lhs 6.7.2 → 6.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 68d9eea1eeef7f8711bc52a5f502889db86060f3
-  data.tar.gz: ace1d44c61822943f8d388abb1ca0729a539bd56
+  metadata.gz: 49f6aad4dc7d9f73ffaabcc3d433b4ea1e22aa9b
+  data.tar.gz: 9b913652093f6587c121d8e8e2da7ddbf8633ae5
 SHA512:
-  metadata.gz: 036a2f4aec3cdba0aab5c5291187725740df70c8613e1651f9b371ef5f17e3908cc57465f461ea3bc1fa4fa873c746c3ec75488571052abb26ba06ea13891ce2
-  data.tar.gz: 0e307ed787e902e0b0b0c37f3665965ef52c8d1909d55cc3f6e95c0a66fe2ba38859b36482ecc275f407bad9f84b00e937b2f4e6f016bd1e33d1fc55eb286e88
+  metadata.gz: 6a97f63461df816e36ac3ca2f837db9b330702683a0a320747f39258b3aa6b73ed6c3d37d7f5c2e014a9db9007ce774c58d1f52d0a0bf4d206e3880f41863ae5
+  data.tar.gz: 71c16105809625cd8c2b598f1d8e5934cb7d0152bb067ed904ca41db1604838d5997f36dea4dbbc225d32d578743447067e189f5673e0210ec95254d8328008a

data/.rubocop.yml

@@ -6,6 +6,9 @@ inherit_from:
 Lint/IneffectiveAccessModifier:
   Enabled: false
 
+Lint/ShadowingOuterLocalVariable:
+  Enabled: false
+
 RSpec/DescribedClass:
   Enabled: false
 

data/lib/lhs/complex.rb

@@ -0,0 +1,180 @@
+# Complex is the main data structure for includes:
+# Can be for example :place, [:place, :customer],
+# [{ places: [:customer] }, { places: { customer: :contract }}]
+# and so on
+class LHS::Complex
+
+  # 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)
+    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
+  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
+  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)
+    else
+      raise "Can't merge that complex: #{addition} -> #{parent} (#{element})#{key ? " for #{key}" : ''}"
+    end
+  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])
+    else
+      raise "Can't merge that complex: #{addition} -> #{parent} (#{element})#{key ? " for #{key}" : ''}"
+    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)
+  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})"
+    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
+  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]
+      end
+    end
+  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)
+    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
+  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)
+      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})"
+    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])
+  end
+  private_class_method :add_symbol_to_hash_parent!
+end

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

@@ -34,20 +34,27 @@ class LHS::Record
       def handle(error_class, handler)
         Chain.new(self, ErrorHandling.new(error_class => handler))
       end
+
+      def includes(*args)
+        Chain.new(self, Include.new(Chain.unfold(args)))
+      end
+
+      def references(*args)
+        Chain.new(self, Reference.new(Chain.unfold(args)))
+      end
     end
 
     # Link: A part of a chain
     class Link
-      def initialize(hash = nil)
-        @hash = hash
-      end
 
-      def [](parameter)
-        @hash[parameter]
+      attr_reader :data
+
+      def initialize(data = nil)
+        @data = data
       end
 
-      def to_hash
-        @hash
+      def [](parameter)
+        @data[parameter]
       end
     end
 
@@ -63,16 +70,25 @@ class LHS::Record
     class Pagination < Link
     end
 
+    # Include: Part of the chain that will be used to include linked resources
+    class Include < Link
+    end
+
+    # Reference: Part of the chain that will be used to pass options to requests
+    # made to include linked resources
+    class Reference < Link
+    end
+
     # ErrorHandling: Catch and resolve errors when resolving the chain
     class ErrorHandling < Link
       delegate :call, to: :handler
 
       def handler
-        @hash.values.first
+        @data.values.first
       end
 
       def class
-        @hash.keys.first
+        @data.keys.first
       end
     end
 
@@ -91,6 +107,10 @@ class LHS::Record
 
       attr_accessor :_links
 
+      def self.unfold(args)
+        args.size == 1 ? args[0] : args
+      end
+
       def initialize(record_class, link, record = nil)
         @record_class = record_class
         @record = record
@@ -98,46 +118,46 @@ class LHS::Record
       end
 
       def create(data = {})
-        @record_class.create(data, chain_options)
+        @record_class.create(data, resolved_options)
       end
 
       def create!(data = {})
-        @record_class.create!(data, chain_options)
+        @record_class.create!(data, resolved_options)
       end
 
       def save!(options = nil)
         options ||= {}
-        @record.save!(chain_options.merge(options))
+        @record.save!(resolved_options.merge(options))
       end
 
       def save(options = nil)
         options ||= {}
-        @record.save(chain_options.merge(options))
+        @record.save(resolved_options.merge(options))
       end
 
       def destroy(options = nil)
         options ||= {}
         options = options.respond_to?(:to_h) ? options : { id: options }
         if @record
-          @record.destroy(chain_options.merge(options))
+          @record.destroy(resolved_options.merge(options))
         else
-          @record_class.destroy(options, chain_options)
+          @record_class.destroy(options, resolved_options)
         end
       end
 
       def update(data = {}, options = nil)
         options ||= {}
-        @record.update(data, chain_options.merge(options))
+        @record.update(data, resolved_options.merge(options))
       end
 
       def update!(data = {}, options = nil)
         options ||= {}
-        @record.update!(data, chain_options.merge(options))
+        @record.update!(data, resolved_options.merge(options))
       end
 
       def valid?(options = nil)
         options ||= {}
-        @record.valid?(chain_options.merge(options))
+        @record.valid?(resolved_options.merge(options))
       end
       alias validate valid?
 
@@ -166,18 +186,28 @@ class LHS::Record
         push ErrorHandling.new(error_class => handler)
       end
 
+      def includes(*args)
+        push Include.new(Chain.unfold(args))
+      end
+
+      def references(*args)
+        push Reference.new(Chain.unfold(args))
+      end
+
       def find(*args)
-        options = chain_options
-        options = options.merge(error_handler: chain_error_handler) if chain_error_handler.any?
-        @record_class.find(*args.push(options))
+        @record_class.find(*args.push(resolved_options))
       end
 
       def find_by(params = {})
-        @record_class.find_by(params, chain_options)
+        @record_class.find_by(params, resolved_options)
       end
 
       def find_by!(params = {})
-        @record_class.find_by!(params, chain_options)
+        @record_class.find_by!(params, resolved_options)
+      end
+
+      def first!
+        @record_class.first!(resolved_options)
       end
 
       # Returns a hash of where conditions
@@ -195,6 +225,16 @@ class LHS::Record
         chain_pagination
       end
 
+      # Returns a hash of include conditions
+      def includes_values
+        chain_includes
+      end
+
+      # Returns a hash of reference options
+      def references_values
+        chain_references
+      end
+
       protected
 
       def method_missing(name, *args, &block)
@@ -209,14 +249,20 @@ class LHS::Record
       end
 
       def resolve
-        options = chain_options
-        options = options.merge(params: chain_parameters.merge(chain_pagination))
-        options = options.merge(error_handler: chain_error_handler) if chain_error_handler.any?
         @resolved ||= @record_class.new(
-          @record_class.request(options)
+          @record_class.request(resolved_options)
         )
       end
 
+      def resolved_options
+        options = chain_options
+        options = options.merge(params: chain_parameters.merge(chain_pagination))
+        options = options.merge(error_handler: chain_error_handler) if chain_error_handler.present?
+        options = options.merge(including: chain_includes) if chain_includes.present?
+        options = options.merge(referencing: chain_references) if chain_references.present?
+        options
+      end
+
       private
 
       def push(link)
@@ -226,11 +272,11 @@ class LHS::Record
       end
 
       def chain_parameters
-        merge_links _links.select { |link| link.is_a? Parameter }
+        merge_links(_links.select { |link| link.is_a? Parameter })
       end
 
       def chain_options
-        merge_links _links.select { |link| link.is_a? Option }
+        merge_links(_links.select { |link| link.is_a? Option })
       end
 
       def chain_error_handler
@@ -241,6 +287,22 @@ class LHS::Record
         resolve_pagination _links.select { |link| link.is_a? Pagination }
       end
 
+      def chain_includes
+        LHS::Complex.merge(
+          _links
+            .select { |link| link.is_a?(Include) && link.data.present? }
+            .map { |link| link.data }
+        )
+      end
+
+      def chain_references
+        LHS::Complex.merge(
+          _links
+            .select { |link| link.is_a?(Reference) && link.data.present? }
+            .map { |link| link.data }
+        )
+      end
+
       def resolve_pagination(links)
         return {} if links.empty?
         page = 1
@@ -259,8 +321,8 @@ class LHS::Record
       def merge_links(links)
         hash = {}
         links.each do |link|
-          next if link.to_hash.blank?
-          hash.deep_merge!(link.to_hash)
+          next if link.data.blank?
+          hash.deep_merge!(link.data)
         end
         hash
       end

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

@@ -6,12 +6,12 @@ class LHS::Record
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def first
-        find_by
+      def first(options = nil)
+        find_by({}, options)
       end
 
-      def first!
-        find_by!
+      def first!(options = nil)
+        find_by!({}, options)
       end
     end
   end

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

@@ -93,10 +93,13 @@ class LHS::Record
 
       def handle_includes(includes, data, references = {})
         references ||= {}
+        references = [references] if includes.is_a?(Array) && !references.is_a?(Array)
         if includes.is_a? Hash
           includes.each { |included, sub_includes| handle_include(included, data, sub_includes, references[included]) }
         elsif includes.is_a? Array
-          includes.each { |included| handle_includes(included, data, references[included]) }
+          includes.each_with_index do |included, index|
+            handle_includes(included, data, references[index])
+          end
         else
           handle_include(includes, data, nil, references[includes])
         end
@@ -123,7 +126,7 @@ class LHS::Record
         record = record_for_options(options) || self
         options = convert_options_to_endpoints(options) if record_for_options(options)
         expanded_data = begin
-          record.without_including.request(options)
+          record.request(options)
         rescue LHC::NotFound
           LHS::Data.new({}, data, record)
         end
@@ -163,7 +166,12 @@ class LHS::Record
         record = record_for_options(options) || self
         options = convert_options_to_endpoints(options) if record_for_options(options)
         begin
-          record.includes(sub_includes).request(options)
+          if options.is_a?(Array)
+            options.each { |options| options.merge!(including: sub_includes) if sub_includes.present? }
+          elsif sub_includes.present?
+            options.merge!(including: sub_includes)
+          end
+          record.request(options)
         rescue LHC::NotFound
           LHS::Data.new({}, data, record)
         end
@@ -185,9 +193,11 @@ 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
         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 && !data.empty?
+        handle_includes(including, data, referencing) if including.present? && !data.empty?
         data
       end
 
@@ -260,6 +270,8 @@ class LHS::Record
 
       def single_request(options)
         options ||= {}
+        including = options.delete(:including)
+        referencing = options.delete(:referencing)
         options = options.dup
         endpoint = find_endpoint(options[:params])
         response = LHC.request(process_options(options, endpoint))

data/lib/lhs/record.rb

@@ -12,7 +12,6 @@ class LHS::Record
   include Find
   include FindBy
   include First
-  include Includes
   include Inspect
   include Mapping
   include Model

data/lib/lhs/version.rb

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

data/spec/complex/merge_spec.rb

@@ -0,0 +1,180 @@
+require 'rails_helper'
+
+describe LHS::Complex do
+  context 'first level' do
+    context 'merges symbols into/with X' do
+      it 'merges symbols into hash' do
+        expect(LHS::Complex.merge([
+          { entries: :contract },
+          :entries
+        ])).to eq(entries: :contract)
+      end
+
+      it 'merges symbols into array' do
+        expect(LHS::Complex.merge([
+          [:contracts],
+          :entries
+        ])).to eq([:contracts, :entries])
+        expect(LHS::Complex.merge([
+          [:entries],
+          :entries
+        ])).to eq(:entries)
+      end
+
+      it 'merges symbols with symbols' do
+        expect(LHS::Complex.merge([
+          :contracts,
+          :entries
+        ])).to eq([:contracts, :entries])
+        expect(LHS::Complex.merge([
+          :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([
+          { entries: :contract },
+          [:entries]
+        ])).to eq(entries: :contract)
+        expect(LHS::Complex.merge([
+          { entries: :contract },
+          [:products]
+        ])).to eq([{ entries: :contract }, :products])
+      end
+
+      it 'merges arrays into an arrays' do
+        expect(LHS::Complex.merge([
+          [:entries],
+          [:entries]
+        ])).to eq(:entries)
+        expect(LHS::Complex.merge([
+          [:entries],
+          [:products]
+        ])).to eq([:entries, :products])
+      end
+
+      it 'merges arrays into an symbols' do
+        expect(LHS::Complex.merge([
+          :entries,
+          [:entries]
+        ])).to eq(:entries)
+        expect(LHS::Complex.merge([
+          :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([
+          { entries: :contract },
+          { entries: :products }
+        ])).to eq(entries: [:contract, :products])
+        expect(LHS::Complex.merge([
+          { entries: :contract },
+          { entries: :contract }
+        ])).to eq(entries: :contract)
+      end
+
+      it 'merges hash into an array' do
+        expect(LHS::Complex.merge([
+          [:entries],
+          { entries: :products }
+        ])).to eq(entries: :products)
+        expect(LHS::Complex.merge([
+          [{ entries: :contract }],
+          { entries: :contract }
+        ])).to eq(entries: :contract)
+      end
+
+      it 'merges hash into a symbol' do
+        expect(LHS::Complex.merge([
+          :entries,
+          { entries: :products }
+        ])).to eq(entries: :products)
+        expect(LHS::Complex.merge([
+          :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([
+          { entries: :contract },
+          [:entries, :products]
+        ])).to eq([{ entries: :contract }, :products])
+      end
+
+      it 'merges array into array' do
+        expect(LHS::Complex.merge([
+          [:contracts],
+          [:entries, :products, :contracts]
+        ])).to eq([:contracts, :entries, :products])
+      end
+
+      it 'merges array with symbols' do
+        expect(LHS::Complex.merge([
+          :contracts,
+          [:entries, :products]
+        ])).to eq([:contracts, :entries, :products])
+      end
+    end
+  end
+
+  context 'multi-level' do
+    it 'merges a complex multi-level example' do
+      expect(LHS::Complex.merge([
+        :contracts,
+        [:entries, products: { content_ads: :address }],
+        products: { content_ads: { place: :location } }
+      ])).to eq([
+        :contracts,
+        :entries,
+        products: { content_ads: [:address, { place: :location }] }
+      ])
+    end
+
+    it 'merges another complex multi-level example' do
+      expect(LHS::Complex.merge([
+        [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]
+      )
+    end
+
+    it 'merges another complex multi-level example' do
+      expect(LHS::Complex.merge([
+        { entries: :products },
+        { entries: [:customer, :contracts] }
+      ])).to eq(
+        entries: [:products, :customer, :contracts]
+      )
+    end
+
+    it 'merges another complex multi-level example' do
+      expect(LHS::Complex.merge([
+        { entries: { customer: :contracts } },
+        { entries: [:customer, :content_ads] }
+      ])).to eq(
+        entries: [{ customer: :contracts }, :content_ads]
+      )
+    end
+
+    it 'reduces properly' do
+      expect(LHS::Complex.merge([
+        [:entries, :place, :content_ads], [{ place: :content_ads }], { content_ads: :place }
+      ])).to eq(
+        [:entries, { place: :content_ads, content_ads: :place }]
+      )
+    end
+  end
+end

data/spec/record/includes_spec.rb

@@ -366,11 +366,17 @@ describe LHS::Record do
     before(:each) do
       class Customer < LHS::Record
         endpoint ':datastore/customers/:id'
+        endpoint ':datastore/customers'
       end
 
       class Place < LHS::Record
         endpoint ':datastore/places'
       end
+
+      stub_request(:get, "#{datastore}/places?forwarded_params=123")
+        .to_return(body: {
+          'items' => [{ id: 1 }]
+        }.to_json)
     end
 
     it 'forwards includes options to requests made for those includes' do
@@ -380,15 +386,25 @@ describe LHS::Record do
             'href' => "#{datastore}/places"
           }
         }.to_json)
-      stub_request(:get, "#{datastore}/places?forwarded_params=123")
-        .to_return(body: {
-          'items' => [{ id: 1 }]
-        }.to_json)
       customer = Customer
         .includes(:places)
         .references(places: { params: { forwarded_params: 123 } })
         .find(1)
       expect(customer.places.first.id).to eq 1
     end
+
+    it 'is chain-able' do
+      stub_request(:get, "#{datastore}/customers?name=Steve")
+        .to_return(body: [
+          'places' => {
+            'href' => "#{datastore}/places"
+          }
+        ].to_json)
+      customers = Customer
+        .where(name: 'Steve')
+        .references(places: { params: { forwarded_params: 123 } })
+        .includes(:places)
+      expect(customers.first.places.first.id).to eq 1
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lhs
 version: !ruby/object:Gem::Version
-  version: 6.7.2
+  version: 6.8.0
 platform: ruby
 authors:
 - https://github.com/local-ch/lhs/graphs/contributors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-10-28 00:00:00.000000000 Z
+date: 2016-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lhc
@@ -178,6 +178,7 @@ files:
 - lhs.gemspec
 - lib/lhs.rb
 - lib/lhs/collection.rb
+- lib/lhs/complex.rb
 - lib/lhs/concerns/collection/internal_collection.rb
 - lib/lhs/concerns/data/equality.rb
 - lib/lhs/concerns/data/json.rb
@@ -198,7 +199,6 @@ files:
 - lib/lhs/concerns/record/find.rb
 - lib/lhs/concerns/record/find_by.rb
 - lib/lhs/concerns/record/first.rb
-- lib/lhs/concerns/record/includes.rb
 - lib/lhs/concerns/record/mapping.rb
 - lib/lhs/concerns/record/model.rb
 - lib/lhs/concerns/record/pagination.rb
@@ -221,6 +221,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/data/collection_spec.rb
 - spec/data/equality_spec.rb
 - spec/data/inspect_spec.rb
@@ -371,6 +372,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/data/collection_spec.rb
 - spec/data/equality_spec.rb
 - spec/data/inspect_spec.rb

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

@@ -1,47 +0,0 @@
-require 'active_support'
-
-class LHS::Record
-
-  module Includes
-    extend ActiveSupport::Concern
-
-    included do
-      cattr_accessor :including, :referencing
-    end
-
-    module ClassMethods
-      def includes(*args)
-        class_clone_factory(args).tap do |class_clone|
-          class_clone.including = unfold_args(args)
-        end
-      end
-
-      def references(*args)
-        class_clone_factory(args).tap do |class_clone|
-          class_clone.referencing = unfold_args(args)
-        end
-      end
-
-      def without_including
-        class_clone_factory(rand.to_s.gsub(/\D/, '')).tap do |class_clone|
-          class_clone.including = nil
-        end
-      end
-
-      private
-
-      def unfold_args(args)
-        args.size == 1 ? args[0] : args
-      end
-
-      def class_clone_factory(args)
-        name = "#{self}#{args.object_id}"
-        constant = Object.const_set(name.demodulize, self.dup) # rubocop:disable Style/RedundantSelf
-        class_clone = constant
-        class_clone.endpoints = endpoints
-        class_clone.mapping = mapping
-        class_clone
-      end
-    end
-  end
-end