djc 0.4.0 → 1.1.0

data/README.md

@@ -1,12 +1,16 @@
-djconvolvs
-==========
+djc
+===
 
-JSON to CSV mapping DSL
+Finally, a *D*SL that converts *J*SON into *C*SV
 
-DJ
-CSV
- OL
- N
+---
+
+    DJC.build(objects/files) do
+        dsl(headers) do
+          field do
+            +captured_field
+          end
+        end
+    end
 
-==========
 

data/lib/djc.rb

@@ -1,312 +1,383 @@
 require 'json'
 require 'csv'
+require 'ctx'
 
 module DJC
 
-  class ::String
-    def ~@
-      "##{self}"
+  class Mapper
+
+    class << self
+      def map(objects, &block)
+        self.new(&block).map(objects)
+      end
     end
 
-  end
+    class Mapping
+      attr_accessor :left, :right, :matchers, :field
+      def initialize(left, right, field = nil) @left, @right, @field, @matchers = left, right, field, {} end
+      def to_s() "MERGE #@right INTO #@left #{ "%(#{field}) " if field }WHERE #{@matchers.map { |k, v| "#{k} = #{v}" }.join(" AND ")}" end
+    end
 
-  class ::Array
+    class ::String
+      ctx :mapping do
+        def ~@() "~#{self}" end
+        def -@() "^.#{self}" end
 
-    def select_first(&block)
-      selected = nil
-      each do |item|
-        selected = block.call(item)
-        break if selected
+        def &(other)
+          ctx[:mappings] ||= []
+          if other.is_a?(Mapping)
+            other.left = self
+            ctx[:mappings] << other
+          else
+            ctx[:mappings] << Mapping.new(self, other)
+          end
+#          p ctx[:mappings]
+          self
+        end
+        def +(other) self & other end
+        def <=(other) self & other end
+        def <<(other) self & other end
+        def <(other) self & other end
+
+        def %(other) Mapping.new(nil, self, other) end
+        def <=>(other) ctx[:mappings].last.matchers[self] = other end
+        def method_missing(other) "#{self}.#{other}" end
       end
-      selected
     end
+    def method_missing(name) name.to_s end
 
-    def walk(obj)
-      path = self.dup
-      keys = path.shift.to_s.split('|')
+    class ::Class
+      ctx :mapping do
+        def const_missing(name)
+          name
+        end
+      end
+    end
 
-      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)
+    attr_accessor :mappings
+    def initialize(&block)
+      ctx :mapping do
+        self.instance_eval(&block)
+        self.mappings = ctx[:mappings]
+      end
+    end
+
+    def map(objects)
+      objects = Mobj::Circle.wrap(objects)
+      mappings.each do |mapping|
+        matched = {}
+        mapping.matchers.each_pair do |left, right|
+          mapping.left.tokenize.walk(objects).each do |lobj|
+            lval = left.tokenize.walk(lobj)
+            mapping.right.tokenize.walk(objects).each do |robj|
+              rval = right.tokenize.walk(robj)
+              if lval == rval
+                matched[left] ||= []
+                matched[left] << [lobj, robj]
+                matched[left].uniq!
               end
-              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]
+        end
+
+        matching = matched.values.inject(matched.values.first) { |memo, val| memo & val }
+        matching.each do |val|
+          if mapping.field
+            val.first[mapping.field] = val.last
           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
+            val.first.merge!(val.last)
           end
-        elsif obj.respond_to? key
-          obj.send(key)
         end
       end
 
-      path.empty? ? val : path.walk(val)
+      objects
     end
+  end
 
-    def collate
-      collated = [[]]
-      fill = {}
-      each_with_index do |obj, index|
-        if obj.is_a?(Array)
-          obj.each_with_index do |item, row|
-            collated[row] ||= []
-            collated[row][index] = item
-          end
-        end
-      end
-      collated.each do |row|
-        each_with_index do |obj, index|
-          unless obj.is_a?(Array)
-            row[index] = obj
-          end
-        end
+  class Builder
+    class Rule
+      attr_accessor :type, :args, :block, :chain
+      def initialize(type, *args, &block) @type, @args, @block, @chain = type.sym, args, block, [] end
+      def to_s() "RULE:#{type.upcase}(#{args.join(', ')})#{ " +" + chain.map(&:to_s).join(" +") unless chain.empty?}" end
+      def method_missing(type, *args, &block)
+        chain << Rule.new(type, args, &block)
+        self
       end
-      collated.size == 1 ? collated.first : collated
     end
 
+    def initialize(&block)
+      ctx :compile do
+        self.instance_eval(&block)
+      end
+    end
 
-    def cross
-      crossed = [[]]
+    def map(&block) @mappings = block end
+    alias :mappings :map
 
-      each do |obj|
-        if obj.is_a?(Array)
-          adding = []
-          obj.each_with_index do |item, index|
-            crossed.each do |cross|
-              row = cross.dup
-              row << item
-              adding << row
-            end
-          end
-          crossed = adding
-        else
-          crossed.each { |cross| cross << obj }
+    def rules(*headers, &block)
+      @headers = headers
+      @dsl = DSL.new(&block)
+    end
+    alias :dsl :rules
+
+    def build(objects)
+      mapped = Mapper.map(objects, &@mappings)
+      rows = @dsl.parse(mapped)
+      keys = @headers || rows.flat_map(&:keys).uniq.sort
+      CSV.generate do |csv|
+        csv << keys
+        rows.each do |row|
+          csv << keys.map { |key| row[key] }
         end
       end
-      crossed.size == 1 ? crossed.first : crossed
     end
   end
 
-  class Rule
-    def parse(paths)
-      regex = /\/[^\/]+\//
-      lookup = /\<[^\<]\>/
-      indexes = /(?:-?\d+(?:(?:\.\.\.?|-|\+)(?:-?\d+)?)?,?)+/
-      node = /[^\[\]\{\}\.]+/
-      paths.split('||').map do |path|
-        path.scan(/#{regex}|#{lookup}|#{indexes}|#{node}/)
-      end
-
+  def self.build(objects, &block)
+    parsed = [*objects].inject({}) do |memo, (key, val)|
+      memo[key.sym] = if val.is_a?(String)
+                        val = File.read(val) if File.exists?(val)
+                        JSON.parse(val, max_nesting: false,
+                                        symbolize_names: true,
+                                        create_additions: false,
+                                        object_class: Mobj::CircleHash,
+                                        array_class: Mobj::CircleRay)
+                      else
+                        val
+                      end
+      memo
     end
 
-    attr_reader :type, :paths, :blocks
-    def initialize(type, rules, &block)
-      if rules.is_a?(String) && rules[0] == '#'
-        @type, @blocks, @paths = 'LITERAL', [proc { rules[1..-1] }], nil
-      else
-        @type, @blocks, @paths = type, [block].compact, (rules.is_a?(String) ? parse(rules) : rules)
+    Builder.new(&block).build(parsed)
+  end
+
+  class DSL < ::Object
+    class ::String
+      ctx(:djc_dsl_def) do
+        def +@()
+          +ctx[:dsl].__djc_dsl(self.to_sym)
+        end
+        def ~@()
+          ctx[:dsl].find(self)
+        end
       end
     end
 
-    def to_s
-      rules = if type == 'LITERAL'
-                @blocks.first.call
-              elsif paths
-                paths.join(paths.first.is_a?(Rule) ? ' + ' : '.')
-              end
-
-      "#{type}(#{rules})"
+    def emit_name(name = nil)
+      if @name.is_a?(Proc)
+        @name.call(name)
+      elsif @finder && name
+        name
+      else
+        "#@name#{ "_#{name}" if name }"
+      end
     end
-
-    def sum
-      @type = 'SUM'
-      @blocks << proc { |array| array.map(&:to_i).inject(0, :+) if array }
+    def __djc_build_name(rule = nil) @name ? "#{@name}_#{rule}" : rule end
+    def __djc_reparent(parent) @parent = parent end
+
+    def initialize(rule = nil, parent = nil, name = parent.attempt(rule).__djc_build_name(rule), &block)
+      @rule, @parent, @name, @capture, @finder, @nodes, @composer, @splatter, @partials = rule, parent, name, false, false, [], [], false, {}
+      ctx(:djc_dsl_def) do
+        ctx[:dsl] = self
+        instance_eval(&block)
+      end if block
       self
     end
-
-    def avg
-      @type = 'AVG'
-      @blocks << proc { |array| ( array.map(&:to_i).inject(0.0, :+) / array.size) if array }
+    def ~@()
+      @finder = true
       self
     end
-
-    def each(&each_block)
-      @type = 'EACH'
-      @blocks <<  proc { |array| array.map { |val| each_block.call(val) } if array }
+    def +@()
+      @capture = true
+      @rule = @rule.gsub(/^\/([^()]*)\/$/, '/(\1)/') if @finder
       self
     end
-
-    def join(sep = '')
-      @type = 'JOIN'
-      @blocks << proc { |vals| vals.is_a?(Array) ? vals.compact.join(sep) : vals }
+    def >(other)
+      @name = other
       self
     end
+    alias_method :%, :>
+
+    def to_str() to_s end
+    def to_s(depth = 0)
+      str = "DJC:"
+      str += @capture ? "+" : ""
+      str += (@rule || "ROOT").to_s
+      str += "(#@name)" if @name
+      str += " [#{@partials.keys.join(",")}]" unless @partials.empty?
+      str += " {\n#{@nodes.map {|n| ("  " * (depth + 1)) + n.to_s(depth + 1)}.join("\n") }\n#{"  " * depth}}" unless @nodes.empty?
+      str
+    end
 
-    def 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
+    def find(rule, &block)
+      rule = rule.inspect if rule.is_a?(Regexp)
+      ~__djc_dsl(rule, &block)
     end
+    alias_method :match, :find
+    alias_method :with, :find
+    alias_method :field, :find
 
-    def match(matcher)
-      @type = 'MATCH'
-      @blocks << proc do |val|
-        if val
-          if val.is_a?(Array)
-            val.compact.map do |v|
-              match = v.scan(matcher).flatten
-              match.size == 1 ? match.first : match
-            end
-          else
-            match = val.scan(matcher).flatten
-            match.size == 1 ? match.first : match
-          end
-        end
+    def compose(*args, &block)
+      if ctx[:dsl] == self
+        __djc_dsl(:compose, *args, &block)
+      else
+        @composer << block
+        self
       end
-      self
     end
 
-    def apply(obj)
-      if @blocks.empty?
-        walker = paths.dup
-        value = nil
-        while value.nil? && (path = walker.shift)
-          value = path.is_a?(Rule) ? path.apply(obj) : path.walk(obj)
-        end
-        value
+    def join(delimiter=$,, &block)
+      if ctx[:dsl] == self
+        args = delimiter != $, ? [delimiter] : []
+        __djc_dsl(:join, *args, &block)
       else
-        if paths.nil? || paths.empty?
-          value = blocks.inject(obj) { |val, block| block.call(val) }
-        elsif paths.length > 1
-          value = [[]]
-          paths.each_with_index do |rule, index|
-            val = rule.apply(obj)
-            if val.is_a?(Array)
-              val.each_with_index do |v, row|
-                value[row] ||= []
-                value[row][index] ||= []
-                value[row][index] = v
-              end
-            else
-              value.first << val
-            end
-          end
-          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 = blocks.inject(value) { |val, block| block.call(val) } unless blocks.empty?
-        end
+        compose { |*values| [*values].join(delimiter) }
+        self
       end
-      value
     end
-  end
 
-  class Column
-    attr_reader :name, :rule
-    def initialize(name, rule)
-      @name, @rule = name, rule.is_a?(Rule) ? rule : Rule.new('LOOKUP', rule)
+    def sum(initial = 0.0, op = :+, &block)
+      if ctx[:dsl] == self
+        args = initial != 0.0 ? [initial] : []
+        __djc_dsl(:sum, *args, &block)
+      else
+        compose { |*values| values.map(&:to_f).inject(initial, block ? block : op) if values }
+        self
+      end
     end
-  end
 
-  class Builder
-    def self.compile(path=nil, &block)
-      builder = Builder.new(path)
-      builder.instance_eval &block
-      builder
+    def avg(*args, &block)
+      if ctx[:dsl] == self
+        __djc_dsl(:avg, *args, &block)
+      else
+        compose { |*values| (values.map(&:to_f).inject(0.0, :+) / values.size) if values }
+        self
+      end
     end
 
-    def initialize(path = nil)
-      @path = Rule.new('USING', path) if path
+    def sort(*args, &block)
+      if ctx[:dsl] == self
+        __djc_dsl(:sort, *args, &block)
+      else
+        compose { |*sort| sort.compact.sort(&block) }
+        self
+      end
     end
 
-    attr_reader :columns
-    def []=(column, rule)
-      @columns ||= []
-      @columns << Column.new(column, rule)
+    def uniq(*args, &block)
+      if ctx[:dsl] == self
+        __djc_dsl(:uniq, *args, &block)
+      else
+        compose { |*values| values.uniq }
+        self
+      end
     end
 
-    def header
-      columns.map { |column| column.name }
+    def count(compact = false, &block)
+      if ctx[:dsl] == self
+        args = compact ? [compact] : []
+        __djc_dsl(:count, *args, &block)
+      else
+        compose { |*values| compact ? values.compact.size : values.size }
+        self
+      end
     end
 
-    def sum(*paths)
-      with(*paths).sum
+    def *(*)
+      @splatter = true
+      self
     end
 
-    def avg(*paths)
-      with(*paths).avg
+    def capture(regex = nil, *captures, &block)
+      if ctx[:dsl] == self
+        args = [regex, *captures].compact
+        __djc_dsl(:capture, *args, &block)
+      else
+        compose do |value|
+          if (match = regex.match(value.to_s))
+            if captures.empty?
+              block ? block.call(match) : match.captures
+            else
+              symbols = captures.any? { |i| i.is_a?(String) || i.is_a?(Symbol) }
+              captured = symbols ? captures.map { |name| match[name] } : match.to_a.values_at(*captures)
+              block ? block.call(*captured) : captured
+            end.sequester
+          end
+        end
+        self
+      end
     end
 
-    def each(*paths, &block)
-      with(*paths).each(&block)
+    def __djc_partial(name)
+      @partials[name] || @parent.__djc_partial(name)
     end
 
-    def with(*paths, &block)
-      Rule.new('WITH', paths.map { |path| Rule.new('LOOKUP', path) }, &block)
+    def __djc_dsl(name, *args, &block)
+      if name.to_s[0] == '_'
+        if block
+          @partials[name] = block
+          self
+        else
+          dsl = __djc_partial(name).call(*args)
+          dsl.__djc_reparent(self)
+          @nodes << dsl
+          dsl
+        end
+      else
+        dsl = DSL.new(name, self, *args, &block)
+        @nodes << dsl
+        dsl
+      end
     end
 
-    def rule(&block)
-      Rule.new('RULE', nil, &block)
+    def method_missing(name, *args, &block)
+      __djc_dsl(name, *args, &block)
     end
 
-    def build(json)
-      json = @path.apply(json) if @path
-      rows = []
-      if json.is_a? Array
-        json.each do |row|
-          row = @columns.map do |column|
-            column.rule.apply(row)
-          end
-          rows << row
+    def rule_parse(data)
+      if data.is_a?(Array)
+        data.flat_map do |element|
+          rule_parse(element)
         end
       else
-        rows << @columns.map do |column|
-          column.rule.apply(json)
+        values = @rule.to_s.walk(data)
+
+        row = if (@splatter || @finder) && values.is_a?(Hash)
+          values.each.with_object({}) { |(k, v), r| r[emit_name(k)] = v }
+        elsif @splatter && values.is_a?(Array)
+          values.each.with_index.with_object({}) { |(v, i), r| r[emit_name(i)] = v }
+        else
+          { emit_name => values }
         end
+
+        [ @composer.empty? ? row : row.each.with_object({}) { |(k,v), r| r[k] = @composer.inject(v) { |m,c| c.call(*m) } } ]
       end
-      rows
     end
 
-  end
-
-  class << self
-
-    def build(json = nil, &block)
-      json = JSON.parse(json) if json.is_a?(String)
-
-      builder = Builder.compile(&block)
-
-      out = CSV.generate do |csv|
-        csv << builder.header
-        builder.build(json).each do |row|
-          csv << row
+    def parse(data, extract = true)
+      if @capture
+        rule_parse(data)
+      else
+        data = if @finder && extract
+          @rule.to_s.walk(data)
+        elsif data && @rule && extract && data.is_a?(Hash)
+          data[@rule]
+        else
+          data
+        end
+        if data.is_a?(Array)
+          data.flat_map do |element|
+            parse(element, false)
+          end
+        else
+          @nodes.inject([]) do |rows, node|
+            result = node.parse(data)
+            result.flat_map do |res|
+              rows.empty? ? res : rows.map { |row| row.merge(res) }
+            end
+          end
         end
       end
-      out
     end
   end
-
 end

metadata

@@ -1,15 +1,16 @@
 --- !ruby/object:Gem::Specification
 name: djc
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
 - Mason
+- Glenna
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-22 00:00:00.000000000 Z
+date: 2012-12-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -35,7 +36,7 @@ extra_rdoc_files: []
 files:
 - lib/djc.rb
 - README.md
-homepage: http://rubygems.org/gems/djc
+homepage: https://github.com/gnovos/djc
 licenses: []
 post_install_message: 
 rdoc_options: []