Implement handling of endless & beginless ranges

This adds an else part for case statement to always be available.
(Because we cannot distinguish between an "else nil end" and a not
existing else clause for a case statement)

Author: paulgoetze

lib/code_breaker/parsable/node.rb

@@ -2,19 +2,21 @@ module CodeBreaker
   module Parsable
     module Node
       def parse(node)
-        return if node.nil?
-
         if node.is_a?(Symbol)
           node
+        elsif node.nil?
+          parse_nil_node(node)
         else
           send("parse_#{node.type}_node", node)
         end
       end
 
-      def parse_children(node)
-        node.children.each_with_object([]) do |child, nodes|
-          nodes << parse(child) unless child.nil?
-          nodes
+      def parse_children(node, compact: true)
+        children = node.children
+        children = children.compact if compact
+
+        children.each_with_object([]) do |child, nodes|
+          nodes << parse(child)
         end
       end
 
@@ -31,7 +33,8 @@ def parse_as_node_type(node)
       end
 
       def method_missing(method, *args, &block)
-        node_type = method.to_s.match(/^parse_(.+)_node$/).captures.first
+        matches = method.to_s.match(/^parse_(.+)_node$/)
+        node_type = matches ? matches.captures.first : []
 
         if node_type.empty?
           super

lib/code_breaker/parsable/ranges.rb

@@ -3,11 +3,15 @@ module Parsable
     module Ranges
       include Parsable::Node
 
-      # inclusive range a..b
-      alias_method :parse_irange_node, :parse_as_hash
+      # inclusive range a..b, a.., ..b
+      def parse_irange_node(node)
+        { node.type => parse_children(node, compact: false) }
+      end
 
-      # exclusive range a...b
-      alias_method :parse_erange_node, :parse_as_hash
+      # exclusive range a...b, a..., ...b
+      def parse_erange_node(node)
+        { node.type => parse_children(node, compact: false) }
+      end
     end
   end
 end

spec/code_breaker/parser/keywords_spec.rb

@@ -267,7 +267,8 @@
               case: [
                 { lvar: :state },
                 { when: Symbol, then: [fixnum_or_integer, :to_s] },
-                { when: Symbol, then: [fixnum_or_integer, :to_s] }
+                { when: Symbol, then: [fixnum_or_integer, :to_s] },
+                { else: NilClass }
               ]
             }
           ]

spec/code_breaker/parser/ranges_spec.rb

@@ -17,5 +17,37 @@
         expect(input).to be_parsed_as output
       end
     end
+
+    context 'for a beginless inclusive range' do
+      it 'returns a Hash with key :irange and the upper bounding type' do
+      input = '..1.2'
+      output = { irange: [NilClass, Float]}
+      expect(input).to be_parsed_as output
+      end
+    end
+
+    context 'for a beginless exclusive range' do
+      it 'returns a Hash with key :erange and the upper bounding type' do
+      input = '...1.2'
+      output = { erange: [NilClass, Float]}
+      expect(input).to be_parsed_as output
+      end
+    end
+
+    context 'for a endless inclusive range' do
+      it 'returns a Hash with key :irange and the lower bounding type' do
+      input = '1.2..'
+      output = { irange: [Float, NilClass]}
+      expect(input).to be_parsed_as output
+      end
+    end
+
+    context 'for a endless exclusive range' do
+      it 'returns a Hash with key :erange and the lower bounding type' do
+      input = '1.2...'
+      output = { erange: [Float, NilClass]}
+      expect(input).to be_parsed_as output
+      end
+    end
   end
 end