lhs 6.8.0 → 6.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 49f6aad4dc7d9f73ffaabcc3d433b4ea1e22aa9b
-  data.tar.gz: 9b913652093f6587c121d8e8e2da7ddbf8633ae5
+  metadata.gz: a903adf673e0a9c79c2e060986a78bbfd50ff519
+  data.tar.gz: 2be897ab11167c15ab24413e0a3121d3152ddf51
 SHA512:
-  metadata.gz: 6a97f63461df816e36ac3ca2f837db9b330702683a0a320747f39258b3aa6b73ed6c3d37d7f5c2e014a9db9007ce774c58d1f52d0a0bf4d206e3880f41863ae5
-  data.tar.gz: 71c16105809625cd8c2b598f1d8e5934cb7d0152bb067ed904ca41db1604838d5997f36dea4dbbc225d32d578743447067e189f5673e0210ec95254d8328008a
+  metadata.gz: 6155cbf30df50413a5339643d4bfda0126ea7e7c87ae20a21fa7dfc7cd9793448b971c139625d0ec508baa15bee59f318acf8d1c467b64d32479482fa333eddd
+  data.tar.gz: bc9c6bebdab8cbf5c915474e3837b7b6c649b25fc46e5eec1706a515a457e1b4ff28147b814ac1073a59d47f5e475f451d4543588d99f5c0fd87e05dcff683cf

data/lhs.gemspec

@@ -28,6 +28,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency 'rails', '>= 4.0.0'
   s.add_development_dependency 'webmock'
   s.add_development_dependency 'pry'
+  s.add_development_dependency 'pry-byebug'
   s.add_development_dependency 'capybara'
   s.add_development_dependency 'rubocop'
   s.add_development_dependency 'json', '>=  1.8.2'

data/lib/lhs/complex.rb

@@ -3,178 +3,154 @@
 # [{ places: [:customer] }, { places: { customer: :contract }}]
 # and so on
 class LHS::Complex
+  attr_reader :data
 
-  # Merge an array of complex that is created
-  # when chaining includes/references and
-  # reducing values is required for further handling
-  def self.merge(data)
-    result = []
-    data.flatten.uniq.each do |datum|
-      result = merge_first_level!(result, datum)
+  def reduce!(data)
+    if data.is_a?(LHS::Complex)
+      @data = data.data
+    elsif data.is_a?(Array) && !data.empty?
+      @data = data.inject(LHS::Complex.new.reduce!([])) { |acc, datum| acc.merge!(LHS::Complex.new.reduce!(datum)) }.data
+    elsif data.is_a?(Hash) && !data.empty?
+      @data = data.map { |k, v| [k, LHS::Complex.new.reduce!(v)] }.to_h
+    else
+      @data = data
     end
-    reduce!(result)
-  end
 
-  def self.reduce!(array)
-    array.flatten!
-    array.uniq!
-    return array.first if array.length == 1
-    reduce_symbols!(array)
-    return nil if array.blank?
-    array
+    self
   end
-  private_class_method :reduce!
 
-  def self.reduce_symbols!(array)
-    array.each do |element|
-      if element.is_a?(Symbol)
-        array.each do |other_element|
-          array.delete(element) if other_element.is_a?(Hash) && other_element.key?(element)
-          array.delete(element) if other_element.is_a?(Array) && other_element.include?(element)
-        end
-      end
-    end
+  def self.reduce(data)
+    new.reduce!(data).unwrap
   end
-  private_class_method :reduce_symbols!
 
-  # Merging the addition into the base array (first level)
-  def self.merge_first_level!(base, addition)
-    return [addition] if base.empty?
-    base.each do |element|
-      merge_multi_level!(base, element, addition)
-    end
-  end
-  private_class_method :merge_first_level!
-
-  # Merge nested complex (addition) into
-  # an hash or an array (element) of the parent
-  def self.merge_multi_level!(parent, element, addition, key = nil)
-    return if element == addition
-    if addition.is_a?(Symbol) && element.is_a?(Hash)
-      merge_symbol_into_hash!(parent, element, addition, key)
-    elsif addition.is_a?(Symbol) && element.is_a?(Array)
-      merge_symbol_into_array!(parent, element, addition, key)
-    elsif addition.is_a?(Symbol) && element.is_a?(Symbol)
-      add_symbol_to_parent!(parent, element, addition, key)
-    elsif addition.is_a?(Hash) && element.is_a?(Symbol)
-      merge_hash_into_symbol!(parent, element, addition, key)
-    elsif addition.is_a?(Hash) && element.is_a?(Hash)
-      merge_hash_into_hash!(parent, element, addition, key)
-    elsif addition.is_a?(Hash) && element.is_a?(Array)
-      merge_hash_into_array!(element, addition)
-    elsif addition.is_a?(Array) && element.is_a?(Symbol)
-      merge_array_into_symbol!(parent, element, addition, key)
-    elsif addition.is_a?(Array) && element.is_a?(Hash)
-      merge_array_into_hash!(parent, element, addition, key)
-    elsif addition.is_a?(Array) && element.is_a?(Array)
-      merge_array_into_array!(parent, element, addition, key)
+  def merge!(other)
+    if data.is_a?(Symbol)
+      merge_into_symbol!(other)
+    elsif data.is_a?(Array)
+      merge_into_array!(other)
+    elsif data.is_a?(Hash)
+      merge_into_hash!(other)
     else
-      raise "Can't merge that complex: #{addition} -> #{parent} (#{element})#{key ? " for #{key}" : ''}"
+      raise ArgumentError, "Cannot merge #{unwrap} with #{other.unwrap}"
     end
+
+    self
   end
-  private_class_method :merge_multi_level!
 
-  def self.merge_symbol_into_hash!(parent, element, addition, key = nil)
-    return if element.key?(addition)
-    if parent.is_a?(Array)
-      parent.push(addition)
-      reduce!(parent)
-    elsif parent.is_a?(Hash)
-      parent[key] = reduce!([element, addition])
+  def unwrap
+    if data.is_a?(Array)
+      result = data.map(&:unwrap)
+      result.empty? ? nil : result
+    elsif data.is_a?(Hash)
+      result = data.map { |k, v| [k, v.unwrap] }.to_h
+      result.empty? ? nil : result
     else
-      raise "Can't merge that complex: #{addition} -> #{parent} (#{element})#{key ? " for #{key}" : ''}"
+      data
     end
   end
-  private_class_method :merge_symbol_into_hash!
 
-  def self.merge_symbol_into_array!(_parent, element, addition, _key = nil)
-    return if element.include?(addition)
-    element.push(addition)
-    reduce!(element)
+  def ==(other)
+    unwrap == other.unwrap
   end
-  private_class_method :merge_symbol_into_array!
 
-  def self.merge_hash_into_symbol!(parent, element, addition, key = nil)
-    parent.delete(element) if addition.key?(element)
-    if parent.is_a?(Array)
-      merge_hash_into_array!(parent, addition)
-    elsif parent.is_a?(Hash)
-      if addition.key?(element)
-        parent[key] = addition
-      else
-        parent[key] = reduce!([element, addition])
-      end
-    else
-      raise "Can't merge that complex: #{addition} -> #{parent} (#{element})"
+  private
+
+  def merge_into_array!(other)
+    if data.empty?
+      @data = other.data
+    elsif other.data.is_a?(Symbol)
+      merge_symbol_into_array!(other)
+    elsif other.data.is_a?(Array)
+      merge_array_into_array!(other)
+    elsif other.data.is_a?(Hash)
+      merge_hash_into_array!(other)
     end
   end
-  private_class_method :merge_hash_into_symbol!
 
-  def self.merge_array_into_symbol!(parent, element, addition, key = nil)
-    addition.unshift(element)
-    reduce!(addition)
-    parent[key] = addition
+  def merge_symbol_into_array!(other)
+    return if data.include?(other)
+    data.push(other)
   end
-  private_class_method :merge_array_into_symbol!
 
-  def self.merge_hash_into_hash!(parent, element, addition, _key = nil)
-    addition.keys.each do |key|
-      if element[key]
-        parent.delete(addition)
-        merge_multi_level!(element, element[key], addition[key], key)
-      else
-        parent.delete(addition)
-        element[key] = addition[key]
+  def merge_array_into_array!(other)
+    @data = other.data.inject(self) { |acc, datum| acc.merge!(datum) }.data
+  end
+
+  def merge_hash_into_array!(other)
+    @data = [].tap do |new_data|
+      data.each do |element|
+        if element.data.is_a?(Symbol)
+          # remove keys that were in the hash
+          new_data << element if !other.data.key?(element.data)
+        elsif element.data.is_a?(Array)
+          new_data << element
+        elsif element.data.is_a?(Hash)
+          new_data << element.merge!(other)
+        end
       end
     end
+
+    # add it to the array if there was no hash to merge it
+    data.push(other) if !data.any? { |element| element.data.is_a?(Hash) }
   end
-  private_class_method :merge_hash_into_hash!
 
-  def self.merge_array_into_hash!(parent, element, addition, key = nil)
-    addition.each do |element_to_add|
-      merge_multi_level!(parent, element, element_to_add, key)
+  def merge_into_hash!(other)
+    if data.empty?
+      @data = other.data
+    elsif other.data.is_a?(Symbol)
+      merge_symbol_into_hash!(other)
+    elsif other.data.is_a?(Array)
+      merge_array_into_hash!(other)
+    elsif other.data.is_a?(Hash)
+      merge_hash_into_hash!(other)
     end
   end
-  private_class_method :merge_array_into_hash!
 
-  def self.merge_array_into_array!(_parent, element, addition, _key = nil)
-    addition.each do |element_to_add|
-      merge_multi_level!(element, element, element_to_add)
-    end
+  def merge_symbol_into_hash!(other)
+    return if data.key?(other.data)
+
+    @data = [LHS::Complex.new.reduce!(data), other]
+  end
+
+  def merge_array_into_hash!(other)
+    @data = other.data.inject(self) { |acc, datum| acc.merge!(datum) }.data
   end
-  private_class_method :merge_array_into_array!
 
-  def self.merge_hash_into_array!(array, addition)
-    array.each do |element|
-      next unless element.is_a?(Hash)
-      element.keys.each do |key|
-        next unless addition.key?(key)
-        return merge_multi_level!(element, element[key], addition[key], key)
+  def merge_hash_into_hash!(other)
+    other.data.each do |k, v|
+      if data.key?(k)
+        data[k] = data[k].merge!(v)
+      else
+        data[k] = v
       end
     end
-    array.push(addition)
-    reduce!(array)
   end
-  private_class_method :merge_hash_into_array!
 
-  def self.add_symbol_to_parent!(parent, element, addition, key = nil)
-    if parent.is_a?(Array)
-      unless parent.include?(addition)
-        parent.push(addition)
-        reduce!(parent)
-      end
-    elsif parent.is_a?(Hash)
-      add_symbol_to_hash_parent!(parent, element, addition, key)
-    else
-      raise "Can't merge that complex: #{addition} -> #{parent} (#{element})"
+  def merge_into_symbol!(other)
+    if other.data.is_a?(Symbol)
+      merge_symbol_into_symbol!(other)
+    elsif other.data.is_a?(Array)
+      merge_array_into_symbol!(other)
+    elsif other.data.is_a?(Hash)
+      merge_hash_into_symbol!(other)
     end
   end
-  private_class_method :add_symbol_to_parent!
 
-  def self.add_symbol_to_hash_parent!(parent, element, addition, key)
-    return if parent[key] == addition
-    return if parent[key].is_a?(Array) && parent[key].include?(addition)
-    parent[key] = reduce!([element, addition])
+  def merge_symbol_into_symbol!(other)
+    return if other.data == data
+
+    @data = [LHS::Complex.new.reduce!(data), other]
+  end
+
+  def merge_array_into_symbol!(other)
+    @data = other.data.unshift(LHS::Complex.new.reduce!(data)).uniq { |a| a.unwrap }
+  end
+
+  def merge_hash_into_symbol!(other)
+    if other.data.key?(data)
+      @data = other.data
+    else
+      @data = [LHS::Complex.new.reduce!(data), other]
+    end
   end
-  private_class_method :add_symbol_to_hash_parent!
 end

data/lib/lhs/concerns/record/chainable.rb

@@ -288,7 +288,7 @@ class LHS::Record
       end
 
       def chain_includes
-        LHS::Complex.merge(
+        LHS::Complex.reduce(
           _links
             .select { |link| link.is_a?(Include) && link.data.present? }
             .map { |link| link.data }
@@ -296,7 +296,7 @@ class LHS::Record
       end
 
       def chain_references
-        LHS::Complex.merge(
+        LHS::Complex.reduce(
           _links
             .select { |link| link.is_a?(Reference) && link.data.present? }
             .map { |link| link.data }

data/lib/lhs/concerns/record/request.rb

@@ -193,8 +193,8 @@ class LHS::Record
         data = LHC.request(options.compact).map do |response|
           LHS::Data.new(response.body, nil, self, response.request)
         end
-        including = LHS::Complex.merge options.compact.map { |options| options.delete(:including) }.compact
-        referencing = LHS::Complex.merge options.compact.map { |options| options.delete(:referencing) }.compact
+        including = LHS::Complex.reduce options.compact.map { |options| options.delete(:including) }.compact
+        referencing = LHS::Complex.reduce options.compact.map { |options| options.delete(:referencing) }.compact
         data = restore_with_nils(data, locate_nils(options)) # nil objects in data provide location information for mapping
         data = LHS::Data.new(data, nil, self)
         handle_includes(including, data, referencing) if including.present? && !data.empty?

data/lib/lhs/version.rb

@@ -1,3 +1,3 @@
 module LHS
-  VERSION = "6.8.0"
+  VERSION = "6.8.1"
 end

data/spec/complex/{merge_spec.rb → reduce_spec.rb}

@@ -1,125 +1,139 @@
 require 'rails_helper'
 
 describe LHS::Complex do
+  it 'returns nil when result is empty' do
+    expect(LHS::Complex.reduce([])).to be_nil
+  end
+
+  it 'forwards primitive types' do
+    expect(LHS::Complex.reduce(entry_id: 123)).to eq(entry_id: 123)
+  end
+
+  it 'fails when trying to merge primitive types' do
+    expect {
+      LHS::Complex.reduce([{ entry: true }, { entry: :content }])
+    }.to raise_error(ArgumentError)
+  end
+
   context 'first level' do
-    context 'merges symbols into/with X' do
-      it 'merges symbols into hash' do
-        expect(LHS::Complex.merge([
+    context 'reduces symbols into/with X' do
+      it 'reduces symbols into hash' do
+        expect(LHS::Complex.reduce([
           { entries: :contract },
           :entries
         ])).to eq(entries: :contract)
       end
 
-      it 'merges symbols into array' do
-        expect(LHS::Complex.merge([
+      it 'reduces symbols into array' do
+        expect(LHS::Complex.reduce([
           [:contracts],
           :entries
         ])).to eq([:contracts, :entries])
-        expect(LHS::Complex.merge([
+        expect(LHS::Complex.reduce([
           [:entries],
           :entries
         ])).to eq(:entries)
       end
 
-      it 'merges symbols with symbols' do
-        expect(LHS::Complex.merge([
+      it 'reduces symbols with symbols' do
+        expect(LHS::Complex.reduce([
           :contracts,
           :entries
         ])).to eq([:contracts, :entries])
-        expect(LHS::Complex.merge([
+        expect(LHS::Complex.reduce([
           :entries,
           :entries
         ])).to eq(:entries)
       end
     end
 
-    context 'merges arrays into/with X' do
-      it 'merges arrays into an hash' do
-        expect(LHS::Complex.merge([
+    context 'reduces arrays into/with X' do
+      it 'reduces arrays into an hash' do
+        expect(LHS::Complex.reduce([
           { entries: :contract },
           [:entries]
         ])).to eq(entries: :contract)
-        expect(LHS::Complex.merge([
+        expect(LHS::Complex.reduce([
           { entries: :contract },
           [:products]
         ])).to eq([{ entries: :contract }, :products])
       end
 
-      it 'merges arrays into an arrays' do
-        expect(LHS::Complex.merge([
+      it 'reduces arrays into an arrays' do
+        expect(LHS::Complex.reduce([
           [:entries],
           [:entries]
         ])).to eq(:entries)
-        expect(LHS::Complex.merge([
+        expect(LHS::Complex.reduce([
           [:entries],
           [:products]
         ])).to eq([:entries, :products])
       end
 
-      it 'merges arrays into an symbols' do
-        expect(LHS::Complex.merge([
+      it 'reduces arrays into an symbols' do
+        expect(LHS::Complex.reduce([
           :entries,
           [:entries]
         ])).to eq(:entries)
-        expect(LHS::Complex.merge([
+        expect(LHS::Complex.reduce([
           :entries,
           [:products]
         ])).to eq([:entries, :products])
       end
     end
 
-    context 'merges hashes into/with X' do
-      it 'merges hash into an hash' do
-        expect(LHS::Complex.merge([
+    context 'reduces hashes into/with X' do
+      it 'reduces hash into an hash' do
+        expect(LHS::Complex.reduce([
           { entries: :contract },
           { entries: :products }
         ])).to eq(entries: [:contract, :products])
-        expect(LHS::Complex.merge([
+        expect(LHS::Complex.reduce([
           { entries: :contract },
           { entries: :contract }
         ])).to eq(entries: :contract)
       end
 
-      it 'merges hash into an array' do
-        expect(LHS::Complex.merge([
+      it 'reduces hash into an array' do
+        expect(LHS::Complex.reduce([
           [:entries],
           { entries: :products }
         ])).to eq(entries: :products)
-        expect(LHS::Complex.merge([
+        expect(LHS::Complex.reduce([
           [{ entries: :contract }],
           { entries: :contract }
         ])).to eq(entries: :contract)
       end
 
-      it 'merges hash into a symbol' do
-        expect(LHS::Complex.merge([
+      it 'reduces hash into a symbol' do
+        expect(LHS::Complex.reduce([
           :entries,
           { entries: :products }
         ])).to eq(entries: :products)
-        expect(LHS::Complex.merge([
+        expect(LHS::Complex.reduce([
           :products,
           { entries: :contract }
         ])).to eq([:products, { entries: :contract }])
       end
     end
 
-    context 'merges array into/with X' do
-      it 'merges array into hash' do
-        expect(LHS::Complex.merge([
+    context 'reduces array into/with X' do
+      it 'reduces array into hash' do
+        expect(LHS::Complex.reduce([
           { entries: :contract },
           [:entries, :products]
         ])).to eq([{ entries: :contract }, :products])
       end
 
-      it 'merges array into array' do
-        expect(LHS::Complex.merge([
+      it 'reduces array into array' do
+        expect(LHS::Complex.reduce([
           [:contracts],
           [:entries, :products, :contracts]
         ])).to eq([:contracts, :entries, :products])
       end
 
-      it 'merges array with symbols' do
-        expect(LHS::Complex.merge([
+      it 'reduces array with symbols' do
+        expect(LHS::Complex.reduce([
           :contracts,
           [:entries, :products]
         ])).to eq([:contracts, :entries, :products])
@@ -128,8 +142,8 @@ describe LHS::Complex do
   end
 
   context 'multi-level' do
-    it 'merges a complex multi-level example' do
-      expect(LHS::Complex.merge([
+    it 'reduces a complex multi-level example' do
+      expect(LHS::Complex.reduce([
         :contracts,
         [:entries, products: { content_ads: :address }],
         products: { content_ads: { place: :location } }
@@ -140,19 +154,19 @@ describe LHS::Complex do
       ])
     end
 
-    it 'merges another complex multi-level example' do
-      expect(LHS::Complex.merge([
+    it 'reduces another complex multi-level example' do
+      expect(LHS::Complex.reduce([
         [entries: :content_ads, products: :price],
         [:entries, products: { content_ads: :address }],
         [entries: { content_ads: :owner }, products: [{ price: :region }, :image, { content_ads: :owner }]]
       ])).to eq(
         entries: { content_ads: :owner },
-        products: [{ content_ads: [:address, :owner] }, { price: :region }, :image]
+        products: [{ content_ads: [:address, :owner], price: :region }, :image]
       )
     end
 
-    it 'merges another complex multi-level example' do
-      expect(LHS::Complex.merge([
+    it 'reduces another complex multi-level example' do
+      expect(LHS::Complex.reduce([
         { entries: :products },
         { entries: [:customer, :contracts] }
       ])).to eq(
@@ -160,8 +174,8 @@ describe LHS::Complex do
       )
     end
 
-    it 'merges another complex multi-level example' do
-      expect(LHS::Complex.merge([
+    it 'reduces another complex multi-level example' do
+      expect(LHS::Complex.reduce([
         { entries: { customer: :contracts } },
         { entries: [:customer, :content_ads] }
       ])).to eq(
@@ -170,7 +184,7 @@ describe LHS::Complex do
     end
 
     it 'reduces properly' do
-      expect(LHS::Complex.merge([
+      expect(LHS::Complex.reduce([
         [:entries, :place, :content_ads], [{ place: :content_ads }], { content_ads: :place }
       ])).to eq(
         [:entries, { place: :content_ads, content_ads: :place }]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lhs
 version: !ruby/object:Gem::Version
-  version: 6.8.0
+  version: 6.8.1
 platform: ruby
 authors:
 - https://github.com/local-ch/lhs/graphs/contributors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-08 00:00:00.000000000 Z
+date: 2016-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lhc
@@ -108,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: capybara
   requirement: !ruby/object:Gem::Requirement
@@ -221,7 +235,7 @@ files:
 - spec/collection/meta_data_spec.rb
 - spec/collection/respond_to_spec.rb
 - spec/collection/without_object_items_spec.rb
-- spec/complex/merge_spec.rb
+- spec/complex/reduce_spec.rb
 - spec/data/collection_spec.rb
 - spec/data/equality_spec.rb
 - spec/data/inspect_spec.rb
@@ -372,7 +386,7 @@ test_files:
 - spec/collection/meta_data_spec.rb
 - spec/collection/respond_to_spec.rb
 - spec/collection/without_object_items_spec.rb
-- spec/complex/merge_spec.rb
+- spec/complex/reduce_spec.rb
 - spec/data/collection_spec.rb
 - spec/data/equality_spec.rb
 - spec/data/inspect_spec.rb