Rewrite method using case in Ruby

Question

So I have defined this class File inside a module and what I want to do is rewrite the self.parse method so that it uses case. I'm new to Ruby so this is not straightforward for me. Also the method must contain in it's body no more than 8 lines of code. Any ideas how to do it? Also I asked it on Code Review and they said it was off topic for them.

---

module RBFS
    class File
        attr_accessor :content
        def initialize (data = nil)
            @content = data
        end

        def data_type
            case @content
                when NilClass then :nil
                when String then :string
                when TrueClass , FalseClass then :boolean
                when Float , Integer then :number 
                when Symbol then :symbol                                                              
            end
        end

       def serialize
           case @content
               when NilClass then "nil:"
               when String then "string:#{@content}"
               when TrueClass , FalseClass then "boolean:#{@content}"
               when Symbol then "symbol:#{@content}"
               when Integer , Float then "number:#{@content}"        
           end
       end

       def self.parse (str)
           arr = str.partition(':')
           if arr[0] == "nil" then return File.new(nil) end
           if arr[0] == "string" then return File.new(arr[2].to_s) end
           if (arr[0] == "boolean" && arr[2].to_s == 'true') then return File.new(true) end
           if (arr[0] == "boolean" && arr[2].to_s == 'false') then return File.new(false) end
           if arr[0] == "symbol" then return File.new(arr[2].to_sym) end
           return File.new(arr[2].to_i) if (arr[0] == "number" && arr[2].to_s.include?('.') == false)
           return File.new(arr[2].to_f) if (arr[0] == "number" && arr[2].to_s.include?('.') == true)
       end
   end
end

---

Example how 'RBFS::File.parse' works:

RBFS::File.parse("string:"Hello world") => #<RBFS::File:0x1c45098 @content="Hello world"> #Tested in irb

Answer 1

I would personally prefer this:

def self.parse(arg)
  key, value = arg.to_s.split(':')
  {
    'nil'     => new(nil), 
    'string'  => new(value),
    'boolean' => new(value == 'true'),
    'symbol'  => new(value.to_sym),
    'number'  => new(value.include?('.') ? BigDecimal(value) : Integer(value))
  }[key]
end

Code above is actually of 2 lines, broken into multiple lines for readability sake. However, if using case is a must then you can change your code to this:

def self.parse(arg)
  key, value = arg.to_s.split(':')
  case key
  when 'nil' then new(nil)
  when 'string' then new(value)
  when 'boolean' then new(value == 'true')
  when 'symbol' then new(value.to_sym)
  when 'number' then new(value.include?('.') ? BigDecimal(value) : Integer(value))
  end
end

Answer 2

In Ruby, case statements test using the case equality method #===. #=== returns true for several different of comparisons beyond the type checking you've already implemented in #serialize and #data_type. For example:

Integer === 1    //=> true
Numeric === 1    //=> true
(1..10) === 1    //=> true
1 === 1          //=> true

With that knowledge, we can construct a #parse method as follows:

def parse(serialized)
  type, content = serialized.split(':') # A neat trick that'll make things more readable.
  case type
  when 'nil'
     # ...
  when 'string'
     # ...
  when 'boolean'
     # ...
  when 'symbol'
     # ...
  when 'number'
     # ...
  else
    raise "Invalid RBFS file."
  end
end

I'm not sure that you'll be able to do this in 8 lines without compromising the file's readability or dropping the error handling step I added at the end (which I highly recommend), but to get close, you can use the when ... then ... syntax.

Answer 3

Below is a suggestion for one way you might write this. It is untested, of course. I made two assumptions:

• what you refer to as a[2] is a string, so a[2].to_s is unnecessary.
• if a[0] => "boolean", a[2] is 'true' or 'false'.

module RBFS
  class File
    attr_accessor :content
    def initialize (data = nil)
      @content = data
    end

    def data_type
      class_to_sym[@content.class]
    end

    def serialize
      return nil if @content.class == NilClass
      "#{class_to_sym[@content.class].to_s}:#{@content}"
    end

    def self.parse (str)
      type,_,val = str.partition(':')
      File.new(type_to_arg(type, val))
    end

    private

    def class_to_sym
       { NilClass=>:nil, String=>:string, TrueClass=>:boolean,
         FalseClass=>:boolean, Numeric=>:number, Symbol=>:symbol }
    end

    def type_to_arg(type, val)
      case type
        when "nil"     then nil
        when "string"  then val
        when "boolean" then val == 'true' 
        when "symbol"  then val.to_sym 
        when "numeric" then val[/\./] ? val.to_f : val.to_i 
        end
      end
    end

  end
end

If you prefer, you could replace val[/\./] with val.include?('.').

You could alternatively use a hash to simulate a case statement in type_to_arg:

def type_to_arg(type, val)
  { "nil"    =>nil,
    "string" =>val,
    "boolean"=>(val=='true'),
    "symbol" =>val.to_sym,
    "number" =>val[/\./] ? val.to_f : val.to_i
  }[type]
end