djc 0.3.0 → 0.4.0

data/lib/djc.rb

@@ -12,47 +12,54 @@ module DJC
 
   class ::Array
 
+    def select_first(&block)
+      selected = nil
+      each do |item|
+        selected = block.call(item)
+        break if selected
+      end
+      selected
+    end
+
     def walk(obj)
       path = self.dup
-      key = path.shift.to_s
-
-      val = if obj.is_a? Array
-              if key == '*'
-                if path.empty?
-                  obj
-                else
-                  sub = obj.map do |inner|
-                    path.dup.walk(inner)
-                  end
-                  path.clear
-                  sub
-                end
-              elsif /^[\d,\+-\.]+$/.match(key)
-                selected = nil
-                key.split('|').each do |option|
-                  locators = option.split(',').map do |dex|
-                    range = /(?<start>\d+)(?:-|\+|\.\.(?<exclusive>\.)?)?(?<end>-?\d+)/.match(dex)
-                    range ? Range.new(range['start'].to_i, (range['end'] || -1).to_i, range['exclusive']) : dex.to_i
-                  end
-                  selected = obj.values_at(*locators)
-                  break if selected
-                end
-                selected.size == 1 ? selected.first : selected
-              end
-            elsif obj.is_a? Hash
-              match = key[/\/(.*)\//, 1]
-              if match.nil?
-                obj[key]
-              else
-                found = obj.keys.select { |k| Regexp.new(match).match(k) }
-                found = found.map { |k| path.empty? ? obj[k] : path.walk(obj[k]) }
-                path.clear
-                found = found.first if found.size < 2
-                found
+      keys = path.shift.to_s.split('|')
+
+      val = keys.select_first do |key|
+        if obj.is_a? Array
+          if key == '*'
+            if path.empty?
+              obj
+            else
+              sub = obj.map do |inner|
+                path.dup.walk(inner)
               end
-            elsif obj.respond_to? key
-              obj.send(key)
+              path.clear
+              sub
+            end
+          elsif /^[\d,\+-\.]+$/.match(key)
+            locators = key.split(',').map do |dex|
+              range = /(?<start>\d+)(?:-|\+|\.\.(?<exclusive>\.)?)?(?<end>-?\d+)/.match(dex)
+              range ? Range.new(range['start'].to_i, (range['end'] || -1).to_i, range['exclusive']) : dex.to_i
             end
+            selected = obj.values_at(*locators)
+            selected.size == 1 ? selected.first : selected
+          end
+        elsif obj.is_a? Hash
+          match = key[/\/(.*)\//, 1]
+          if match.nil?
+            obj[key]
+          else
+            found = obj.keys.select { |k| Regexp.new(match).match(k) }
+            found = found.map { |k| path.empty? ? obj[k] : path.walk(obj[k]) }
+            path.clear
+            found = found.first if found.size < 2
+            found
+          end
+        elsif obj.respond_to? key
+          obj.send(key)
+        end
+      end
 
       path.empty? ? val : path.walk(val)
     end
@@ -103,65 +110,73 @@ module DJC
 
   class Rule
     def parse(paths)
-
       regex = /\/[^\/]+\//
       lookup = /\<[^\<]\>/
       indexes = /(?:-?\d+(?:(?:\.\.\.?|-|\+)(?:-?\d+)?)?,?)+/
-      node = /[^\[\]\{\}\|\.]+/
-      rules = paths.split('||').map do |path|
+      node = /[^\[\]\{\}\.]+/
+      paths.split('||').map do |path|
         path.scan(/#{regex}|#{lookup}|#{indexes}|#{node}/)
       end
 
-      rules
     end
 
-    attr_reader :paths, :type, :block
-    def initialize(type='lookup', rules, &block)
+    attr_reader :type, :paths, :blocks
+    def initialize(type, rules, &block)
       if rules.is_a?(String) && rules[0] == '#'
-        @type, @block, @paths = 'literal', proc { rules[1..-1] }, nil
+        @type, @blocks, @paths = 'LITERAL', [proc { rules[1..-1] }], nil
       else
-        @type, @block, @paths = type, block, rules.is_a?(String) ? parse(rules) : rules
+        @type, @blocks, @paths = type, [block].compact, (rules.is_a?(String) ? parse(rules) : rules)
       end
     end
 
     def to_s
-      "#{paths}:#{type}:#{block}"
+      rules = if type == 'LITERAL'
+                @blocks.first.call
+              elsif paths
+                paths.join(paths.first.is_a?(Rule) ? ' + ' : '.')
+              end
+
+      "#{type}(#{rules})"
     end
 
     def sum
-      @type, @block = 'sum', proc { |array| array.map(&:to_i).inject(0, :+) if array }
+      @type = 'SUM'
+      @blocks << proc { |array| array.map(&:to_i).inject(0, :+) if array }
       self
     end
 
     def avg
-      @type, @block = 'avg', proc { |array| ( array.map(&:to_i).inject(0.0, :+) / array.size) if array }
+      @type = 'AVG'
+      @blocks << proc { |array| ( array.map(&:to_i).inject(0.0, :+) / array.size) if array }
       self
     end
 
     def each(&each_block)
-      @type, @block = 'each', proc { |array| array.map { |val| each_block.call(val) } if array }
+      @type = 'EACH'
+      @blocks <<  proc { |array| array.map { |val| each_block.call(val) } if array }
       self
     end
 
     def join(sep = '')
-      @type, @block = 'join', proc { |vals| vals.is_a?(Array) ? vals.compact.join(sep) : vals }
+      @type = 'JOIN'
+      @blocks << proc { |vals| vals.is_a?(Array) ? vals.compact.join(sep) : vals }
       self
     end
 
     def sort(&sort_block)
-      @type, @block = 'sort', proc { |sort| sort.is_a?(Array) ? sort.compact.sort(&sort_block) : sort.sort(&sort_block) }
+      @type = 'SORT'
+      @blocks << proc { |sort| sort.is_a?(Array) ? sort.compact.sort(&sort_block) : (sort.nil? ? nil : sort.sort(&sort_block)) }
       self
     end
 
     def match(matcher)
-      @type, @block = 'match', proc do |val|
+      @type = 'MATCH'
+      @blocks << proc do |val|
         if val
           if val.is_a?(Array)
-            val.map do |v|
-              if v
-                match = v.scan(matcher).flatten
-                match.size == 1 ? match.first : match
-              end
+            val.compact.map do |v|
+              match = v.scan(matcher).flatten
+              match.size == 1 ? match.first : match
             end
           else
             match = val.scan(matcher).flatten
@@ -173,17 +188,16 @@ module DJC
     end
 
     def apply(obj)
-      value = nil
-      if type == 'lookup'
+      if @blocks.empty?
         walker = paths.dup
         value = nil
-        while value.nil? && path = walker.shift
-          value = path.walk(obj)
+        while value.nil? && (path = walker.shift)
+          value = path.is_a?(Rule) ? path.apply(obj) : path.walk(obj)
         end
         value
       else
         if paths.nil? || paths.empty?
-          value = block.call(obj)
+          value = blocks.inject(obj) { |val, block| block.call(val) }
         elsif paths.length > 1
           value = [[]]
           paths.each_with_index do |rule, index|
@@ -198,23 +212,22 @@ module DJC
               value.first << val
             end
           end
-          value = value.map { |val| block.call(val) } unless block.nil?
+          value = value.map { |val| blocks.inject(val) { |v, block| block.call(v) }} unless blocks.empty?
           value = value.first if value.length == 1
           value
         else
           value = paths.first.apply(obj)
-          value = block.call(value) unless block.nil?
+          value = blocks.inject(value) { |val, block| block.call(val) } unless blocks.empty?
         end
       end
       value
     end
-
   end
 
   class Column
     attr_reader :name, :rule
     def initialize(name, rule)
-      @name, @rule = name, rule.is_a?(Rule) ? rule : Rule.new(rule)
+      @name, @rule = name, rule.is_a?(Rule) ? rule : Rule.new('LOOKUP', rule)
     end
   end
 
@@ -226,7 +239,7 @@ module DJC
     end
 
     def initialize(path = nil)
-      @path = Rule.new(path) if path
+      @path = Rule.new('USING', path) if path
     end
 
     attr_reader :columns
@@ -252,11 +265,11 @@ module DJC
     end
 
     def with(*paths, &block)
-      Rule.new('with', paths.map { |path| Rule.new(path) }, &block)
+      Rule.new('WITH', paths.map { |path| Rule.new('LOOKUP', path) }, &block)
     end
 
     def rule(&block)
-      Rule.new('rule', nil, &block)
+      Rule.new('RULE', nil, &block)
     end
 
     def build(json)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: djc
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-20 00:00:00.000000000 Z
+date: 2012-10-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec