json22d 0.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b784be733972cbb47cd4ea2b690c3b934a65afd6
+  data.tar.gz: d8f1a686b5874b77b16400d051fcc547b96a7739
+SHA512:
+  metadata.gz: db66b220c6114cc63609c1c242fb5e3de2a9a83760d6f1fb9a394d03122dd3cd478b6d2ad7994c4e12f55e6c86b1be72114fd4b2b067a68d61ee6f52dacde844
+  data.tar.gz: e6dc4e0286e433bc7511cfffba8b11c8a0a317919ad230bb5c514c5a4cfb23415b776f73e79d0e9d2d691ad1b75f7e94966444e9cc3a7a9623cbe808d143d8e8

data/lib/json22d.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+require "json"
+require "active_support/inflector"
+
+module JSON22d
+  extend self
+
+  VERSION = "0.5"
+
+  def run(arr, config)
+    arr = arr.to_json unless arr.is_a?(String)
+    arr = JSON.parse(arr)
+    fill_blanks(arr, config, &(block_given? ? Proc.new : nil))
+    return Enumerator.new do |y|
+      y << header(config)
+      arr.each do |h|
+        row(block_given? ? yield(h) : h, config).each { |r| y << r }
+      end
+    end
+  end
+
+  private
+
+  def fill_blanks(values, config)
+    values = values.first if values.is_a?(Array) && values.size == 1
+    values = [values] unless values.is_a?(Array)
+    subconfig = config.select { |c| c.is_a?(Hash) }
+    subconfig.each do |name|
+      key, value = name.first
+      comment, key, no_n, shift, unshift = key.to_s.
+        match(/^(#)?([^\[]+?)(\[\])?( SHIFT)?( UNSHIFT)?$/)&.
+        captures
+      if no_n
+        max_n = values.reduce(0) do |acc, v|
+          v = yield(v) if block_given?
+          sub_hash = v&.[](key)
+          if sub_hash.is_a?(Array)
+            acc = sub_hash.count if acc < sub_hash.count
+          elsif !sub_hash.nil?
+            acc = 1 if acc < 1
+          end
+          next acc
+        end
+
+        name.delete(name.keys.first)
+        name["#{key}[#{max_n}]#{shift}#{unshift}"] = value
+      end
+      fill_blanks(values.map do |v|
+        v = yield(v) if block_given?
+        comment ? v : v&.[](key)
+      end, value)
+    end
+  end
+
+  def header(config)
+    return config.reduce([]) do |acc, name|
+      if name.is_a?(Hash)
+        key, value = name.first
+        comment, key, closures, n, n2, shift, unshift = key.to_s.
+          match(/^(#)?([^\[(\s]+)(\[(\d+)\]|\(([^\)]+)\))?( SHIFT)?( UNSHIFT)?$/)&.
+          captures
+        key, op = key.split(".")
+        key = key.singularize
+        if comment
+          acc + header(value).map { |m| "#{key}.#{m}" }
+        elsif n
+          next acc + n.to_i.times.reduce([]) do |a, i|
+            a + header(value).map do |m|
+              if shift
+                "#{key}[#{i}]#{m.match(/^[^(\[\s\.]+(.*)$/)&.captures&.first}"
+              elsif unshift
+                "#{m}[#{i}]"
+              elsif op
+                "#{key}.#{op}_#{m}"
+              else
+                "#{key}[#{i}].#{m}"
+              end
+            end
+          end
+        elsif closures.nil? || n2
+          next acc + header(value).map do |m|
+            if shift
+              "#{key}#{m.match(/^[^(\[\s\.]+(.*)$/)&.captures&.first}"
+            elsif unshift
+              "#{m}"
+            elsif op
+              "#{key}.#{op}_#{m}"
+            else
+              "#{key}.#{m}"
+            end
+          end
+        else
+          # "pos" is the column for determining i.e. offer position in a product
+          next acc + (["pos"] + header(value)).map do |m|
+            if shift
+              "#{key}#{m.match(/^[^(\[\s\.]+(.*)$/)&.captures&.first}"
+            elsif unshift
+              "#{m}"
+            elsif op
+              "#{key}.#{op}_#{m}"
+            else
+              "#{key}.#{m}"
+            end
+          end
+        end
+      elsif name.is_a?(Array)
+        _key, title = name
+        next acc << title.to_s
+      else
+        name, *_ = name.to_s.match(/^([^(]+)(\(([^\)]+)\))?$/)&.captures
+        name = name.match(/^([^+]+)/).captures.first
+        next acc << name.to_s
+      end
+    end
+  end
+
+  def row(hash, config)
+    multiply(slice(hash, config))
+  end
+
+  def multiply(array, result = [[]])
+    array = [array] unless array.is_a?(Array)
+    array.each do |elem|
+      if elem.is_a?(Array)
+        result = elem.reduce([]) { |a, e| a + multiply(e, result.map(&:dup)) }
+      else
+        result = result.map { |r| r << elem }
+      end
+    end
+    return result
+  end
+
+  def slice(hash, config)
+    return config.reduce([]) do |acc, name|
+      if name.is_a?(Hash)
+        key, value = name.first
+        comment, key, closures, n, n2, _shift, _unshift = key.to_s.
+          match(/^(#)?([^\[(\s]+)(\[(\d+)\]|\(([^\)]+)\))?( SHIFT)?( UNSHIFT)?$/)&.
+          captures
+        key, op = key.split(".")
+        sub_hash = hash&.[](key)
+        if comment
+          acc + slice(hash, value)
+        elsif n2 && sub_hash
+          next acc << sub_hash.
+            reduce([]) { |a, h| a + slice(h, value) }.
+            join(n2)
+        elsif n && (sub_hash || n.to_i == 0)
+          next acc + n.to_i.times.map { |i| sub_hash[i] }.
+            reduce([]) { |a, h| a + slice(h, value) }
+        elsif sub_hash.is_a?(Array)
+          # [i] is the "pos" column
+          next acc << [slice({}, value)] if sub_hash.empty?
+          next acc << sub_hash.map.
+            with_index do |h, i|
+              (closures.nil? ? [] : [i]) + slice(h, value)
+            end.reduce(nil, &with_op(op))
+        else
+          next acc + slice(sub_hash, value)
+        end
+      else
+        if hash.nil?
+          next acc << hash
+        else
+          name, _title = name if name.is_a?(Array)
+          name, closures, n = name.to_s.
+            match(/^([^(]+)(\(([^\)]+)\))?$/)&.captures
+          sub_array = hash[name]
+          if sub_array.is_a?(Array)
+            sub_array = sub_array.map(&method(:sprintf))
+          else
+            sub_array = sprintf(sub_array)
+          end
+          if name.include?("+")
+            next acc << name.split("+").map { |k| hash[k] }.compact.join(" ")
+          elsif n && sub_array.is_a?(Array)
+            next acc << sub_array.join(n)
+          else
+            next acc << sub_array
+          end
+        end
+      end
+    end
+  end
+
+  def with_op(op)
+    if op
+      case op
+      when "min"
+        ->(a, e) do
+          e = e.first if e.is_a?(Array)
+          ef = e.to_f
+          af = a&.to_f
+          (af || ef) > ef ? e : (a || e)
+        end
+      when "max"
+        ->(a, e) do
+          e = e.first if e.is_a?(Array)
+          ef = e.to_f
+          af = a&.to_f
+          (af || 0) < ef ? e : a
+        end
+      when "first"
+        ->(a, e) do
+          e = e.first if e.is_a?(Array)
+          a || e
+        end
+      end
+    else
+      return ->(a, e) { (a || []) << e }
+    end
+  end
+
+  def sprintf(value)
+    if !value.respond_to?(:strftime) &&
+       value !~ /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/
+      return value
+    end
+    value = Time.parse(value) if !value.respond_to?(:strftime)
+    return value.strftime("%Y-%m-%d %H:%M:%S %Z")
+  end
+end

data/spec/json22d_spec.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+require "minitest/autorun"
+require "minitest/spec"
+require "json22d"
+
+describe "JSON22d" do
+  after do
+    @arr = @config = nil
+  end
+  describe "fill missing ranges" do
+    before do
+      @arr = [
+        {"a": [{"i": 1}, {"i": 3}, {"i": 6}]},
+        {"a": [{"i": 2}, {"i": 4}]}
+      ]
+      @config = ["a[]": %w(i)]
+    end
+
+    it "inserts the maximum array length into the header as fields" do
+      enum = JSON22d.run(@arr, @config)
+      assert_equal 3, enum.next.size
+    end
+
+    it "uses an iteration index for each generated header" do
+      enum = JSON22d.run(@arr, @config)
+      header = enum.next
+      3.times.each do |i|
+        assert_equal "a[#{i}].i", header[i]
+      end
+    end
+  end
+
+  describe "extract regular fields" do
+    before do
+      @arr = [{"i": 3, "j": 4}, {"i": "foo"}]
+      @config = %w(i j)
+    end
+
+    it "sets the correct header" do
+      header = JSON22d.run(@arr, @config).next
+      assert_equal ["i", "j"], header
+    end
+
+    it "extracts the data in correct order" do
+      enum = JSON22d.run(@arr, @config)
+      enum.next # throw away header
+      assert_equal [3, 4], enum.next
+      assert_equal ["foo", nil], enum.next
+    end
+  end
+
+  describe "extract nested fields" do
+    before do
+      @arr = ["content": {"i": "foo"}]
+      @config = ["content": %w(i)]
+    end
+
+    it "sets the correct header" do
+      header = JSON22d.run(@arr, @config).next
+      assert_equal ["content.i"], header
+    end
+
+    it "extracts the data in correct order" do
+      enum = JSON22d.run(@arr, @config)
+      enum.next # throw away header
+      assert_equal ["foo"], enum.next
+    end
+  end
+
+  describe "simulate nested field in header" do
+    before do
+      @arr = ["content": "foo"]
+      @config = ["#my": %w(content)]
+    end
+
+    it "sets the correct header" do
+      header = JSON22d.run(@arr, @config).next
+      assert_equal ["my.content"], header
+    end
+
+    it "extracts the data while skipping simulated headers" do
+      enum = JSON22d.run(@arr, @config)
+      enum.next # throw away header
+      assert_equal ["foo"], enum.next
+    end
+  end
+
+  describe "multiplies fields within arrays" do
+    before do
+      @arr = ["content": ["bar", "foo"]]
+      @config = ["content"]
+    end
+
+    it "sets the correct header" do
+      header = JSON22d.run(@arr, @config).next
+      assert_equal ["content"], header
+    end
+
+    it "extracts the data in correct order" do
+      enum = JSON22d.run(@arr, @config)
+      enum.next # throw away header
+      assert_equal ["bar"], enum.next
+      assert_equal ["foo"], enum.next
+    end
+  end
+
+  describe "multiplies nested fields within arrays" do
+    before do
+      @arr = ["content": [{"i": "bar"}, {"i": "foo"}]]
+      @config = ["content": %w(i)]
+    end
+
+    it "sets the correct header" do
+      header = JSON22d.run(@arr, @config).next
+      assert_equal ["content.i"], header
+    end
+
+    it "extracts the data in correct order" do
+      enum = JSON22d.run(@arr, @config)
+      enum.next # throw away header
+      assert_equal ["bar"], enum.next
+      assert_equal ["foo"], enum.next
+    end
+  end
+
+  describe "joins two field results with a space" do
+    before do
+      @arr = [{"i": "bar", "j": "foo"}]
+      @config = %w(i+j)
+    end
+
+    it "sets the correct header" do
+      header = JSON22d.run(@arr, @config).next
+      assert_equal ["i"], header
+    end
+
+    it "extracts and joins the two fields" do
+      enum = JSON22d.run(@arr, @config)
+      enum.next # throw away header
+      assert_equal ["bar foo"], enum.next
+    end
+  end
+
+  describe "joins multiple values within subarrays with given delim" do
+    before do
+      @arr = [{"i": ["bar", "blubb"]}, {"i": ["foo"]}]
+      @config = ["i( , )"]
+    end
+
+    it "sets the correct header" do
+      header = JSON22d.run(@arr, @config).next
+      assert_equal ["i"], header
+    end
+
+    it "extracts and joins the arrays" do
+      enum = JSON22d.run(@arr, @config)
+      enum.next # throw away header
+      assert_equal ["bar , blubb"], enum.next
+      assert_equal ["foo"], enum.next
+    end
+  end
+
+  describe "joins multiple values after applying nested fields" do
+    before do
+      @arr = [{"i": [{"j": "bar"}, {"j": "blubb"}]}]
+      @config = ["i( , )": %w(j)]
+    end
+
+    it "sets the correct header" do
+      header = JSON22d.run(@arr, @config).next
+      assert_equal ["i.j"], header
+    end
+
+    it "extracts and joins the arrays" do
+      enum = JSON22d.run(@arr, @config)
+      enum.next # throw away header
+      assert_equal ["bar , blubb"], enum.next
+    end
+  end
+
+  describe "multiplies nested array into header" do
+    before do
+      @arr = ["content": [{"i": "bar"}, {"i": "foo"}]]
+      @config = ["content[]": %w(i)]
+    end
+
+    it "sets the correct header" do
+      header = JSON22d.run(@arr, @config).next
+      assert_equal ["content[0].i", "content[1].i"], header
+    end
+
+    it "extracts the data in correct order" do
+      enum = JSON22d.run(@arr, @config)
+      enum.next # throw away header
+      assert_equal ["bar", "foo"], enum.next
+    end
+  end
+
+  describe "multiplies nested array into header with range" do
+    before do
+      @arr = ["content": [{"i": "bar"}, {"i": "foo"}]]
+      @config = ["content[1]": %w(i)]
+    end
+
+    it "sets the correct header" do
+      header = JSON22d.run(@arr, @config).next
+      assert_equal ["content[0].i"], header
+    end
+
+    it "extracts the data up to range" do
+      enum = JSON22d.run(@arr, @config)
+      enum.next # throw away header
+      assert_equal ["bar"], enum.next
+    end
+  end
+
+  describe "shift nested name down in header" do
+    before do
+      @arr = ["content": [{"i": {"j":"bar"}}, {"i": {"j": "foo"}}]]
+    end
+
+    it "shifts j out for line multiplication" do
+      header = JSON22d.run(@arr, ["content": ["i SHIFT": %w(j)]]).next
+      assert_equal ["content.i"], header
+    end
+
+    it "shifts j out for column multiplication" do
+      header = JSON22d.run(@arr, ["content": ["i[] SHIFT": %w(j)]]).next
+      assert_equal ["content.i[0]"], header
+    end
+
+    it "shifts i out for line multiplication" do
+      header = JSON22d.run(@arr, ["content[] SHIFT": ["i": %w(j)]]).next
+      assert_equal ["content[0].j", "content[1].j"], header
+    end
+
+    it "shifts i out for column multiplication but keeps brackets" do
+      header = JSON22d.run(@arr, ["content[] SHIFT": ["i[]": %w(j)]]).next
+      assert_equal ["content[0][0].j", "content[1][0].j"], header
+    end
+  end
+
+  describe "shift nested name up in header" do
+    before do
+      @arr = ["content": [{"i": {"j":"bar"}}, {"i": {"j": "foo"}}]]
+    end
+
+    it "shifts content out for line multiplication" do
+      header = JSON22d.run(@arr, ["content UNSHIFT": ["i": %w(j)]]).next
+      assert_equal ["i.j"], header
+    end
+
+    it "shifts content out for column multiplication" do
+      header = JSON22d.run(@arr, ["content UNSHIFT": ["i[]": %w(j)]]).next
+      assert_equal ["i[0].j"], header
+    end
+
+    it "shifts j out for line multiplication" do
+      header = JSON22d.run(@arr, ["content[]": ["i UNSHIFT": %w(j)]]).next
+      assert_equal ["content[0].j", "content[1].j"], header
+    end
+
+    it "shifts j out for column multiplication but keeps brackets" do
+      header = JSON22d.run(@arr, ["content[]": ["i[] UNSHIFT": %w(j)]]).next
+      assert_equal ["content[0].j[0]", "content[1].j[0]"], header
+    end
+  end
+
+  {
+    min: 1,
+    max: 3,
+    first: 2
+  }.each do |op, val|
+    describe "extract value by aggregator" do
+      before do
+        @arr = [{"content": [{"i": 2}, {"i": 3}, {"i": 1}]}]
+      end
+
+      it "generates the correct header for #{op}" do
+        header = JSON22d.run(@arr, ["content.#{op}": ["i"]]).next
+        assert_equal ["content.#{op}_i"], header
+      end
+
+      it "extracts the #{op} value from i" do
+        enum = JSON22d.run(@arr, ["content.#{op}": ["i"]])
+        enum.next # throw away header
+        assert_equal [val], enum.next
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: json22d
+version: !ruby/object:Gem::Version
+  version: '0.5'
+platform: ruby
+authors:
+- Matthias Geier
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-01-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5'
+description: Create CSV/XSLX formats and many others with this transpiler
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/json22d.rb
+- spec/json22d_spec.rb
+homepage: https://github.com/metoda/json22d
+licenses:
+- BSD-2-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Transpile JSON into a flat structure
+test_files:
+- spec/json22d_spec.rb