lhs 5.0.4 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: fc7129b170c58d2a2ecee0756ca0d33cdd2126fa
-  data.tar.gz: 58922bfe15024065b77b57adc09348cadfd3168c
+  metadata.gz: cb3fe085cc83710039d972594c9f7f8d85adbe23
+  data.tar.gz: dd26184f622e4ac0cf4ed64caf80ba767604cb83
 SHA512:
-  metadata.gz: 84dfc1caa23ff9932ff85bff35fab58bb5bbfdd08539ad9503bfb3926d1a44c0cb8d298ec1af94be0cf7841081a7d859aca989771a40df4c7681304a79364f81
-  data.tar.gz: 11f9058905e009790b21abf82e08f11e3a1b11126a2c356c71a39c437395926f69d6b0dba5d8c0afa8534293a3a16980bf0e755f3a03ad96cb3a76c77d1cac5c
+  metadata.gz: ad8fcbb562a7401d884ebc8104b8b7354466b075245a164623c391ef63a37e8d855dafc30a26b906a9d36820e1edc228d815b1daefb730016f41630bd8c75de4
+  data.tar.gz: b9d6c74ea6abc94fe4dbab55531fc3285a1b76cefc04d6152e29bc3498f93dadffd7e16be4fd921d6073c1918d45c6d7c7b02dc9a45bea4837a67e0aa4cecb2f

data/README.md

@@ -156,6 +156,32 @@ If no record is found, `nil` is returned.
 
 `first!` raises LHC::NotFound if nothing was found.
 
+## Request based options
+
+You can apply options to the request chain. Those options will be forwarded to the request perfomed by the chain/query.
+
+```ruby
+  options = { auth: { bearer: '123456' } }
+  
+  AuthenticatedRecord = Record.options(options)
+  
+  blue_records = AuthenticatedRecord.where(color: 'blue')
+  active_records = AuthenticatedRecord.where(active: true)
+
+  AuthenticatedRecord.create(color: 'red')
+  
+  record = AuthenticatedRecord.find(123)
+  # Find resolves the current query and applies all options from the chain
+  # All further requests are made from scratch and not based on the previous options
+  record.name = 'Walter'
+
+  authenticated_record = record.options(options)
+  authenticated_record.valid?
+  authenticated_record.save
+  authenticated_record.destroy
+  authenticated_record.update(name: 'Steve')
+```
+
 ## Batch processing
 
 **Be careful using methods for batch processing. They could result in a lot of HTTP requests!**

data/lib/lhs/concerns/item/destroy.rb

@@ -6,8 +6,9 @@ class LHS::Item < LHS::Proxy
   module Destroy
     extend ActiveSupport::Concern
 
-    def destroy
-      _data._request = _data.class.request(method: :delete, url: href)._request
+    def destroy(options = {})
+      options ||= {}
+      _data._request = _data.class.request(options.merge(method: :delete, url: href))._request
       _data
     end
   end

data/lib/lhs/concerns/item/save.rb

@@ -6,14 +6,15 @@ class LHS::Item < LHS::Proxy
   module Save
     extend ActiveSupport::Concern
 
-    def save
-      save!
+    def save(options = nil)
+      save!(options)
     rescue LHC::Error => e
       self.errors = LHS::Errors.new(e.response)
       false
     end
 
-    def save!
+    def save!(options = {})
+      options ||= {}
       record = _data.class
       data = _data._raw.dup
       if href.present?
@@ -24,7 +25,7 @@ class LHS::Item < LHS::Proxy
         endpoint.remove_interpolated_params!(data)
       end
 
-      data = record.request(method: :post, url: url, body: data.to_json, headers: { 'Content-Type' => 'application/json' })
+      data = record.request(options.merge(method: :post, url: url, body: data.to_json, headers: { 'Content-Type' => 'application/json' }))
       _data.merge_raw!(data)
       true
     end

data/lib/lhs/concerns/item/update.rb

@@ -6,20 +6,23 @@ class LHS::Item < LHS::Proxy
   module Update
     extend ActiveSupport::Concern
 
-    def update(params)
-      update!(params)
+    def update(params, options = nil)
+      update!(params, options)
     rescue LHC::Error => e
       self.errors = LHS::Errors.new(e.response)
       false
     end
 
-    def update!(params)
+    def update!(params, options = {})
+      options ||= {}
       _data.merge_raw!(LHS::Data.new(params, _data.parent, _data.class))
       response_data = _data.class.request(
-        method: :post,
-        url: href,
-        body: _data.to_json,
-        headers: { 'Content-Type' => 'application/json' }
+        options.merge(
+          method: :post,
+          url: href,
+          body: _data.to_json,
+          headers: { 'Content-Type' => 'application/json' }
+        )
       )
       _data.merge_raw!(response_data)
       true

data/lib/lhs/concerns/item/validation.rb

@@ -5,7 +5,8 @@ class LHS::Item < LHS::Proxy
   module Validation
     extend ActiveSupport::Concern
 
-    def valid?
+    def valid?(options = {})
+      options ||= {}
       self.errors = nil
       fail 'No validation endpoint found!' unless validation_endpoint
       record = LHS::Record.for_url(validation_endpoint.url)
@@ -13,11 +14,13 @@ class LHS::Item < LHS::Proxy
       params = validation_endpoint.options.fetch(:params, {}).merge(validation_params)
       begin
         record.request(
-          url: validation_endpoint.url,
-          method: :post,
-          params: params,
-          body: _data.to_json,
-          headers: { 'Content-Type' => 'application/json' }
+          options.merge(
+            url: validation_endpoint.url,
+            method: :post,
+            params: params,
+            body: _data.to_json,
+            headers: { 'Content-Type' => 'application/json' }
+          )
         )
         true
       rescue LHC::Error => e

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

@@ -0,0 +1,164 @@
+require 'active_support'
+
+class LHS::Record
+
+  module Chainable
+    extend ActiveSupport::Concern
+
+    # You can start new option chains for already fetched records (needed for save, update, valid etc.)
+    def options(hash = nil)
+      Chain.new(self.class, Option.new(hash), self)
+    end
+
+    module ClassMethods
+      def where(hash = nil)
+        Chain.new(self, Parameter.new(hash))
+      end
+
+      def options(hash = nil)
+        Chain.new(self, Option.new(hash))
+      end
+    end
+
+    # Link: A part of a chain
+    class Link
+      def initialize(hash = nil)
+        @hash = hash
+      end
+
+      def to_hash
+        @hash
+      end
+    end
+
+    # Parameter: Part of the chain that will be forwarded to the endpoint as parameter
+    class Parameter < Link
+    end
+
+    # Option: Part of the chain that will be used to configure the communication with the endpoint
+    class Option < Link
+    end
+
+    # A sequence of links
+    class Chain
+
+      # Instance exec is required for scope chains
+      delegated_methods = Object.instance_methods - [:instance_exec]
+      delegate(*delegated_methods, to: :resolve)
+
+      def initialize(record_class, link, record = nil)
+        @record_class = record_class
+        @record = record
+        @chain = [link].compact
+      end
+
+      def create(data = {})
+        @record_class.create(data, chain_options)
+      end
+
+      def create!(data = {})
+        @record_class.create!(data, chain_options)
+      end
+
+      def save!(options = nil)
+        options ||= {}
+        @record.save!(chain_options.merge(options))
+      end
+
+      def save(options = nil)
+        options ||= {}
+        @record.save(chain_options.merge(options))
+      end
+
+      def destroy(options = nil)
+        options ||= {}
+        @record.destroy(chain_options.merge(options))
+      end
+
+      def update(data = {}, options = nil)
+        options ||= {}
+        @record.update(data, chain_options.merge(options))
+      end
+
+      def update!(data = {}, options = nil)
+        options ||= {}
+        @record.update!(data, chain_options.merge(options))
+      end
+
+      def valid?(options = nil)
+        options ||= {}
+        @record.valid?(chain_options.merge(options))
+      end
+      alias validate valid?
+
+      def where(hash = nil)
+        push Parameter.new(hash)
+      end
+
+      def options(hash = nil)
+        push Option.new(hash)
+      end
+
+      def find(args)
+        @record_class.find(args, chain_options)
+      end
+
+      def find_by(params = {})
+        @record_class.find_by(params, chain_options)
+      end
+
+      # Returns a hash of where conditions
+      def where_values_hash
+        chain_parameters
+      end
+
+      # Returns a hash of options
+      def option_values_hash
+        chain_options
+      end
+
+      protected
+
+      def method_missing(name, *args, &block)
+        scope = @record_class.scopes[name]
+        return instance_exec(*args, &scope) if scope
+        resolve.send(name, *args, &block)
+      end
+
+      def respond_to_missing?(name, include_all = false)
+        @record_class.scopes[name] ||
+          resolve.respond_to?(name, include_all)
+      end
+
+      def resolve
+        @resolved ||= @record_class.new(
+          @record_class.request(chain_options.merge(params: chain_parameters))
+        )
+      end
+
+      private
+
+      def push(link)
+        @chain += [link].compact
+        self
+      end
+
+      def chain_parameters
+        merge_links @chain.select { |link| link.is_a? Parameter }
+      end
+
+      def chain_options
+        merge_links @chain.select { |link| link.is_a? Option }
+      end
+
+      def merge_links(links)
+        hash = {}
+        links.each do |link|
+          next if link.to_hash.blank?
+          hash.deep_merge!(link.to_hash)
+        end
+        hash
+      end
+    end
+  end
+end

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

@@ -6,15 +6,15 @@ class LHS::Record
     extend ActiveSupport::Concern
 
     module ClassMethods
-      def create(data = {})
+      def create(data = {}, options = nil)
         record = new(data)
-        record.save
+        record.save(options)
         record
       end
 
-      def create!(data = {})
+      def create!(data = {}, options = nil)
         record = new(data)
-        record.save!
+        record.save!(options)
         record
       end
     end

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

@@ -7,12 +7,12 @@ class LHS::Record
 
     module ClassMethods
       # Find a single uniqe record
-      def find(args)
+      def find(args, options = nil)
         data =
           if args.is_a? Hash
-            find_with_parameters(args)
+            find_with_parameters(args, options)
           else
-            find_by_id(args)
+            find_by_id(args, options)
           end
         return data unless data._record
         data._record.new(data)
@@ -20,8 +20,9 @@ class LHS::Record
 
       private
 
-      def find_with_parameters(params)
-        data = request(params: params)
+      def find_with_parameters(params, options = {})
+        options ||= {}
+        data = request(options.merge(params: params))
         if data._proxy.is_a?(LHS::Collection)
           fail LHC::NotFound.new('Requested unique item. Multiple were found.', data._request.response) if data.length > 1
           data.first || fail(LHC::NotFound.new('No item was found.', data._request.response))
@@ -30,8 +31,9 @@ class LHS::Record
         end
       end
 
-      def find_by_id(id)
-        request(params: { id: id })
+      def find_by_id(id, options = {})
+        options ||= {}
+        request(options.merge(params: { id: id }))
       end
     end
   end

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

@@ -7,22 +7,23 @@ class LHS::Record
 
     module ClassMethods
       # Fetch some record by parameters
-      def find_by(params = {})
-        _find_by(params)
+      def find_by(params = {}, options = nil)
+        _find_by(params, options)
       rescue LHC::NotFound
         nil
       end
 
       # Raise if no record was found
-      def find_by!(params = {})
-        _find_by(params)
+      def find_by!(params = {}, options = nil)
+        _find_by(params, options)
       end
 
       private
 
-      def _find_by(params)
+      def _find_by(params, options = {})
+        options ||= {}
         params = params.dup.merge(limit: 1)
-        data = request(params: params)
+        data = request(options.merge(params: params))
         if data._proxy.is_a?(LHS::Collection)
           data.first || fail(LHC::NotFound.new('No item was found.', data._request.response))
         else

data/lib/lhs/record.rb

@@ -3,19 +3,19 @@ Dir[File.dirname(__FILE__) + '/concerns/record/*.rb'].each { |file| require file
 class LHS::Record
   include All
   include Batch
+  include Chainable
   include Configuration
   include Create
   include Endpoints
   include Find
   include FindBy
   include First
+  include Includes
   include Mapping
   include Model
-  include Includes
-  include Scope
-  include Request
-  include Where
   include Pagination
+  include Request
+  include Scope
 
   delegate :_proxy, to: :_data
   delegate :_endpoint, to: :_data

data/lib/lhs/version.rb

@@ -1,3 +1,3 @@
 module LHS
-  VERSION = "5.0.4"
+  VERSION = "5.1.0"
 end

data/spec/record/options_spec.rb

@@ -0,0 +1,160 @@
+require 'rails_helper'
+
+describe LHS::Record do
+  let(:datastore) do
+    'http://datastore/v2'
+  end
+
+  before(:each) do
+    LHC.config.placeholder('datastore', datastore)
+    class Record < LHS::Record
+      endpoint ':datastore/records', validates: true
+    end
+  end
+
+  let(:options) { { auth: { bearer: '123' }, validates: true } }
+  let(:params) { { name: 'Steve' } }
+
+  context 'options' do
+    it 'is possible to pass options to the chain' do
+      expect(LHC).to receive(:request)
+        .with(options.merge(params: params).merge(url: 'http://datastore/v2/records'))
+        .and_call_original
+      stub_request(:get, "http://datastore/v2/records?name=Steve")
+        .to_return(body: { name: "Steve", is: 'awesome' }.to_json)
+      Record.options(options).where(params).first
+    end
+
+    it 'applies last one wins also to the options' do
+      stub_request(:get, "http://datastore/v2/records")
+        .to_return(body: { name: "Steve", is: 'awesome' }.to_json)
+      expect(LHC).to receive(:request)
+        .with(options.merge(url: 'http://datastore/v2/records'))
+        .and_call_original
+      Record.options(auth: 'basic').options(options).where.first
+    end
+
+    it 'is also applicable to find' do
+      stub_request(:get, 'http://datastore/v2/records?id=123').to_return(body: {}.to_json)
+      expect(LHC).to receive(:request)
+        .with(options.merge(params: { id: "123" }, url: 'http://datastore/v2/records'))
+        .and_call_original
+      Record.options(options).find('123')
+    end
+
+    it 'is also applicable to find_by' do
+      stub_request(:get, 'http://datastore/v2/records?id=123&limit=1').to_return(body: {}.to_json)
+      expect(LHC).to receive(:request)
+        .with(options.merge(params: { id: "123", limit: 1 }, url: 'http://datastore/v2/records'))
+        .and_call_original
+      Record.options(options).find_by(id: '123')
+    end
+
+    it 'is also applicable to first' do
+      stub_request(:get, 'http://datastore/v2/records').to_return(body: {}.to_json)
+      expect(LHC).to receive(:request)
+        .with(options.merge(url: 'http://datastore/v2/records'))
+        .and_call_original
+      Record.options(options).first
+    end
+
+    it 'is also applicable to create' do
+      stub_request(:post, 'http://datastore/v2/records').to_return(body: {}.to_json)
+      expect(LHC).to receive(:request)
+        .with(options.merge(method: :post, url: "http://datastore/v2/records", body: "{\"name\":\"Steve\"}", headers: { 'Content-Type' => 'application/json' }))
+        .and_call_original
+      Record.options(options).create(name: 'Steve')
+    end
+
+    context 'actions on single records' do
+      let!(:record) do
+        stub_request(:get, "http://datastore/v2/records?id=123").to_return(body: { href: 'http://datastore/v2/records/123' }.to_json)
+        Record.find(123)
+      end
+
+      context 'save' do
+        before(:each) do
+          stub_request(:post, 'http://datastore/v2/records/123').to_return(body: {}.to_json)
+          expect(LHC).to receive(:request)
+            .with(options.merge(method: :post, url: "http://datastore/v2/records/123", body: "{\"href\":\"http://datastore/v2/records/123\"}", headers: { "Content-Type" => "application/json" }))
+            .and_call_original
+        end
+
+        it 'applies directly on save' do
+          record.save(options)
+        end
+
+        it 'applies directly on save!' do
+          record.save!(options)
+        end
+
+        it 'applies chaining them with save' do
+          record.options(options).save
+        end
+
+        it 'applies chaining them with save!' do
+          record.options(options).save!
+        end
+      end
+
+      context 'destroy' do
+        before(:each) do
+          stub_request(:delete, 'http://datastore/v2/records/123').to_return(body: {}.to_json)
+          expect(LHC).to receive(:request)
+            .with(options.merge(method: :delete, url: "http://datastore/v2/records/123"))
+            .and_call_original
+        end
+
+        it 'applies directly on destroy' do
+          record.destroy(options)
+        end
+
+        it 'applies chaining them with destroy' do
+          record.options(options).destroy
+        end
+      end
+
+      context 'update' do
+        before(:each) do
+          stub_request(:post, "http://datastore/v2/records/123").to_return(body: {}.to_json)
+          expect(LHC).to receive(:request)
+            .with(options.merge(method: :post, url: "http://datastore/v2/records/123", body: "{\"href\":\"http://datastore/v2/records/123\",\"name\":\"steve\"}", headers: { "Content-Type" => "application/json" }))
+            .and_call_original
+        end
+
+        it 'applies directly on update' do
+          record.update({ name: 'steve' }, options)
+        end
+
+        it 'applies directly on update!' do
+          record.update!({ name: 'steve' }, options)
+        end
+
+        it 'applies chaining them with update' do
+          record.options(options).update(name: 'steve')
+        end
+
+        it 'applies chaining them with update!' do
+          record.options(options).update!(name: 'steve')
+        end
+      end
+
+      context 'valid' do
+        before(:each) do
+          stub_request(:post, 'http://datastore/v2/records?persist=false').to_return(body: {}.to_json)
+          expect(LHC).to receive(:request)
+            .with(options.merge(url: ':datastore/records', method: :post, params: { persist: false }, body: "{\"href\":\"http://datastore/v2/records/123\"}", headers: { "Content-Type" => "application/json" }))
+            .and_call_original
+        end
+
+        it 'applies directly on valid' do
+          record.valid?(options)
+        end
+
+        it 'applies chaining them with valid' do
+          record.options(options).valid?
+        end
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lhs
 version: !ruby/object:Gem::Version
-  version: 5.0.4
+  version: 5.1.0
 platform: ruby
 authors:
 - https://github.com/local-ch/lhs/graphs/contributors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-19 00:00:00.000000000 Z
+date: 2016-05-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lhc
@@ -186,6 +186,7 @@ files:
 - lib/lhs/concerns/item/validation.rb
 - lib/lhs/concerns/record/all.rb
 - lib/lhs/concerns/record/batch.rb
+- lib/lhs/concerns/record/chainable.rb
 - lib/lhs/concerns/record/configuration.rb
 - lib/lhs/concerns/record/create.rb
 - lib/lhs/concerns/record/endpoints.rb
@@ -198,7 +199,6 @@ files:
 - lib/lhs/concerns/record/pagination.rb
 - lib/lhs/concerns/record/request.rb
 - lib/lhs/concerns/record/scope.rb
-- lib/lhs/concerns/record/where.rb
 - lib/lhs/data.rb
 - lib/lhs/endpoint.rb
 - lib/lhs/errors.rb
@@ -296,6 +296,7 @@ files:
 - spec/record/mapping_spec.rb
 - spec/record/model_name_spec.rb
 - spec/record/new_spec.rb
+- spec/record/options_spec.rb
 - spec/record/paginatable_collection_spec.rb
 - spec/record/pagination_spec.rb
 - spec/record/persisted_spec.rb
@@ -428,6 +429,7 @@ test_files:
 - spec/record/mapping_spec.rb
 - spec/record/model_name_spec.rb
 - spec/record/new_spec.rb
+- spec/record/options_spec.rb
 - spec/record/paginatable_collection_spec.rb
 - spec/record/pagination_spec.rb
 - spec/record/persisted_spec.rb

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

@@ -1,65 +0,0 @@
-require 'active_support'
-
-class LHS::Record
-
-  module Where
-    extend ActiveSupport::Concern
-
-    class WhereChain
-
-      # Instance exec is required for scope chains
-      delegated_methods = Object.instance_methods - [:instance_exec]
-      delegate(*delegated_methods, to: :resolve)
-
-      def initialize(record, parameters)
-        @record = record
-        @chain = [parameters].compact
-      end
-
-      def where(parameters)
-        @chain += [parameters].compact
-        self
-      end
-
-      # Returns a hash of where conditions
-      def where_values_hash
-        merged_parameters
-      end
-
-      protected
-
-      def method_missing(name, *args, &block)
-        scope = @record.scopes[name]
-        return instance_exec(*args, &scope) if scope
-        resolve.send(name, *args, &block)
-      end
-
-      def respond_to_missing?(name, include_all = false)
-        @record.scopes[name] ||
-          resolve.respond_to?(name, include_all)
-      end
-
-      def resolve
-        @resolved ||= @record.new(
-          @record.request(params: merged_parameters)
-        )
-      end
-
-      private
-
-      def merged_parameters
-        merged_parameters = {}
-        @chain.each do |parameter|
-          merged_parameters.deep_merge!(parameter)
-        end
-        merged_parameters
-      end
-    end
-
-    module ClassMethods
-      def where(parameters = nil)
-        WhereChain.new(self, parameters)
-      end
-    end
-  end
-end