lhs 24.0.0

data/lib/lhs/problems/nested/errors.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module LHS::Problems
+  module Nested
+    class Errors < LHS::Problems::Errors
+      include LHS::Problems::Nested::Base
+
+      def initialize(errors, scope)
+        @raw = errors
+        @messages = nest(errors.messages, scope)
+        @message = errors.message
+        @scope = scope
+      end
+    end
+  end
+end

data/lib/lhs/problems/nested/warnings.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module LHS::Problems
+  module Nested
+    class Warnings < LHS::Problems::Warnings
+      include LHS::Problems::Nested::Base
+
+      def initialize(warnings, scope)
+        @raw = warnings.raw
+        @messages = nest(warnings.messages, scope)
+        @scope = scope
+      end
+    end
+  end
+end

data/lib/lhs/problems/warnings.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module LHS::Problems
+  class Warnings < Base
+
+    def initialize(raw, record = nil)
+      @raw = raw
+      @record = record
+      @codes = {}.with_indifferent_access
+      @messages = warnings_from_raw
+    end
+
+    private
+
+    def warnings_from_raw
+      messages = {}
+      return messages if !raw.is_a?(Hash) || raw[:field_warnings].blank?
+      raw[:field_warnings].each do |field_warning|
+        add_error(messages, field_warning[:path].join('.').to_sym, field_warning[:code])
+      end
+      messages.with_indifferent_access
+    end
+  end
+end

data/lib/lhs/proxy.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+# Proxy makes different kind of data accessible
+# If href is present it also alows loading/reloading
+class LHS::Proxy
+  autoload :Accessors,
+    'lhs/concerns/proxy/accessors'
+  autoload :Create,
+    'lhs/concerns/proxy/create'
+  autoload :Problems,
+    'lhs/concerns/proxy/problems'
+  autoload :Link,
+    'lhs/concerns/proxy/link'
+
+  include Accessors
+  include Create
+  include Link
+  include Problems
+
+  # prevent clashing with attributes of underlying data
+  attr_accessor :_data, :_loaded
+  delegate :_record, :becomes, to: :_data, allow_nil: true
+
+  def initialize(data)
+    self._data = data
+    self._loaded = false
+  end
+
+  def record
+    _data.class
+  end
+
+  def load!(options = nil)
+    return self if _loaded
+    reload!(options)
+  end
+
+  def reload!(options = nil)
+    options = {} if options.blank?
+    data = _data.class.request(
+      options.merge(method: :get).merge(reload_options)
+    )
+    _data.merge_raw!(data.unwrap(:item_key))
+    self._loaded = true
+    return becomes(_record) if _record
+    self
+  end
+
+  private
+
+  def as_record
+    @as_record ||= becomes(_record)
+  end
+
+  def reload_options
+    return { url: _data.href } if _data.href
+    return { params: { id: as_record.id } } if as_record.id
+    {}
+  end
+
+  def merge_data_with_options(data, options)
+    if options && options[:params]
+      data.merge(options[:params])
+    else
+      data
+    end
+  end
+end

data/lib/lhs/railtie.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module LHS
+  class Railtie < Rails::Railtie
+    initializer "lhs.hook_into_controller_initialization" do
+      class ActionController::Base
+
+        def initialize
+          prepare_lhs_request_cycle_cache
+          reset_option_blocks
+          reset_extended_rollbar_request_logs
+          super
+        end
+
+        private
+
+        def prepare_lhs_request_cycle_cache
+          return unless LHS.config.request_cycle_cache_enabled
+          LHS::Interceptors::RequestCycleCache::ThreadRegistry.request_id = [Time.now.to_f, request.object_id].join('#')
+        end
+
+        def reset_option_blocks
+          LHS::OptionBlocks::CurrentOptionBlock.options = nil
+        end
+
+        def reset_extended_rollbar_request_logs
+          return unless defined?(::Rollbar)
+          return unless LHC.config.interceptors.include?(LHS::Interceptors::ExtendedRollbar::Interceptor)
+          LHS::Interceptors::ExtendedRollbar::ThreadRegistry.log = []
+        end
+      end
+    end
+  end
+end

data/lib/lhs/record.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+class LHS::Record
+  autoload :AttributeAssignment,
+    'lhs/concerns/record/attribute_assignment'
+  autoload :Batch,
+    'lhs/concerns/record/batch'
+  autoload :Chainable,
+    'lhs/concerns/record/chainable'
+  autoload :Configuration,
+    'lhs/concerns/record/configuration'
+  autoload :Create,
+    'lhs/concerns/record/create'
+  autoload :CustomSetters,
+    'lhs/concerns/record/custom_setters'
+  autoload :Destroy,
+    'lhs/concerns/record/destroy'
+  autoload :Endpoints,
+    'lhs/concerns/record/endpoints'
+  autoload :Equality,
+    'lhs/concerns/record/equality'
+  autoload :Find,
+    'lhs/concerns/record/find'
+  autoload :FindBy,
+    'lhs/concerns/record/find_by'
+  autoload :First,
+    'lhs/concerns/record/first'
+  autoload :HrefFor,
+    'lhs/concerns/record/href_for'
+  autoload :Last,
+    'lhs/concerns/record/last'
+  autoload :Mapping,
+    'lhs/concerns/record/mapping'
+  autoload :Merge,
+    'lhs/concerns/record/merge'
+  autoload :Model,
+    'lhs/concerns/record/model'
+  autoload :Pagination,
+    'lhs/concerns/record/pagination'
+  autoload :Provider,
+    'lhs/concerns/record/provider'
+  autoload :Request,
+    'lhs/concerns/record/request'
+  autoload :Relations,
+    'lhs/concerns/record/relations'
+  autoload :Scope,
+    'lhs/concerns/record/scope'
+  autoload :Tracing,
+    'lhs/concerns/record/tracing'
+  autoload :Update,
+    'lhs/concerns/record/update'
+
+  include AttributeAssignment
+  include Batch
+  include Chainable
+  include Configuration
+  include Create
+  include CustomSetters
+  include Destroy
+  include Endpoints
+  include Equality
+  include Find
+  include FindBy
+  include First
+  include HrefFor
+  include LHS::IsHref
+  include Last
+  include LHS::Inspect
+  include Mapping
+  include Merge
+  include Model
+  include Pagination
+  include Provider
+  include Request
+  include Relations
+  include Scope
+  include Tracing
+  include Update
+
+  delegate :_proxy, :_endpoint, :merge_raw!, :select, :becomes, :respond_to?, to: :_data
+
+  def initialize(data = nil, apply_customer_setters = true)
+    data ||= LHS::Data.new({}, nil, self.class)
+    data = LHS::Data.new(data, nil, self.class) unless data.is_a?(LHS::Data)
+    define_singleton_method(:_data) { data }
+    apply_custom_setters! if apply_customer_setters
+  end
+
+  def as_json(options = nil)
+    _data.as_json(options)
+  end
+
+  def self.build(data = nil)
+    new(data)
+  end
+
+  # Override Object#dup because it doesn't support copying any singleton
+  # methods, which leads to missing `_data` method when you execute `dup`.
+  def dup
+    clone
+  end
+
+  protected
+
+  def method_missing(name, *args, &block)
+    _data.send(name, *args, &block)
+  end
+
+  def respond_to_missing?(name, include_all = false)
+    _data.respond_to_missing?(name, include_all)
+  end
+end

data/lib/lhs/rspec.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'lhs'
+require 'lhs/test/stubbable_records'
+
+RSpec.configure do |config|
+  config.before(:each) do
+    LHS.config.request_cycle_cache.clear
+  end
+end

data/lib/lhs/test/stubbable_records.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'local_uri'
+require 'webmock'
+
+class LHS::Record
+  DEFAULT_LIMIT = LHS::Pagination::Base::DEFAULT_LIMIT
+
+  def self.stub_all(url, items, options = {})
+    extend WebMock::API
+
+    items.each_slice(DEFAULT_LIMIT).with_index do |(*batch), index|
+      uri = LocalUri::URI.new(url)
+      uri.query.merge!(
+        limit_key(:parameter) => DEFAULT_LIMIT
+      )
+      offset = pagination_class.page_to_offset(index + 1, DEFAULT_LIMIT)
+      unless index.zero?
+        uri.query.merge!(
+          pagination_key(:parameter) => offset
+        )
+      end
+      request_stub = stub_request(:get, uri.to_s)
+      request_stub.with(options) if options.present?
+      request_stub.to_return(
+        body: {
+          items: batch,
+          offset: index.zero? ? 0 : offset,
+          total: items.length
+        }.to_json
+      )
+    end
+  end
+end

data/lib/lhs/unprocessable.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module LHS
+  class Unprocessable < StandardError
+  end
+end

data/lib/lhs/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LHS
+  VERSION = '24.0.0'
+end

data/script/ci/build.sh

@@ -0,0 +1,18 @@
+#!/bin/bash -e
+
+# custom vars
+# RUBY = ruby-1.9.3-p125
+# GEMSET = location-app-${GitHub pull request id|branch name}
+# standard vars
+
+if [ -z "$SKIP_RVM" ]; then
+  [[ -s "/usr/local/rvm/scripts/rvm" ]] && . "/usr/local/rvm/scripts/rvm"
+  RUBY=${RUBY:-ruby-2.1.2}
+  GEMSET=${GEMSET:-LHS}
+  rvm use ${RUBY}@${GEMSET} --create
+  gem install bundler --no-rdoc --no-ri
+fi
+
+bundle install --local || bundle install
+RAILS_ENV=test bundle exec rspec
+rvm --force gemset delete ${RUBY}@${GEMSET}

data/spec/auto_oauth_spec.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+describe 'Auto OAuth Authentication', type: :request, dummy_models: true do
+
+  context 'without LHC::Auth interceptor enabled' do
+
+    before do
+      LHS.configure do |config|
+        config.auto_oauth = -> { access_token }
+      end
+    end
+
+    it 'shows a warning that it can not perform auto authentication' do
+      expect(lambda do
+        get '/automatic_authentication/oauth'
+      end).to output(
+        %r{\[WARNING\] Can't enable auto oauth as LHC::Auth interceptor is not enabled\/configured \(see https://github.com/local-ch/lhc/blob/master/README.md#authentication-interceptor\)!}
+      ).to_stderr
+    end
+  end
+
+  context 'with LHC::Auth interceptor enabled' do
+
+    context 'with only one auth provider' do
+
+      let(:token) { ApplicationController::ACCESS_TOKEN }
+
+      let(:record_request) do
+        stub_request(:get, "http://datastore/v2/records_with_oauth/1")
+          .with(
+            headers: { 'Authorization' => "Bearer #{token}" }
+          ).to_return(status: 200, body: { name: 'Record' }.to_json)
+      end
+
+      let(:records_request) do
+        stub_request(:get, "http://datastore/v2/records_with_oauth?color=blue")
+          .with(
+            headers: { 'Authorization' => "Bearer #{token}" }
+          ).to_return(status: 200, body: { items: [{ name: 'Record' }] }.to_json)
+      end
+
+      before do
+        LHS.configure do |config|
+          config.auto_oauth = -> { access_token }
+        end
+        LHC.configure do |config|
+          config.interceptors = [LHC::Auth]
+        end
+        record_request
+        records_request
+      end
+
+      after do
+        LHC.config.reset
+      end
+
+      it 'applies OAuth credentials for the individual request automatically' do
+        get '/automatic_authentication/oauth'
+        expect(record_request).to have_been_requested
+        expect(records_request).to have_been_requested
+      end
+    end
+
+    context 'with multiple auth providers' do
+
+      before do
+        LHS.configure do |config|
+          config.auto_oauth = proc do
+            {
+              provider1: access_token_provider_1,
+              provider2: access_token_provider_2
+            }
+          end
+        end
+        LHC.configure do |config|
+          config.interceptors = [LHC::Auth]
+        end
+        record_request_provider_1
+        records_request_provider_2
+        records_request_per_endpoint_provider_1
+        record_request_per_endpoint_provider_2
+      end
+
+      let(:token) { ApplicationController::ACCESS_TOKEN }
+
+      let(:record_request_provider_1) do
+        stub_request(:get, "http://datastore/v2/records_with_multiple_oauth_providers_1/1")
+          .with(
+            headers: { 'Authorization' => "Bearer #{token}_provider_1" }
+          ).to_return(status: 200, body: { name: 'Record' }.to_json)
+      end
+
+      let(:records_request_provider_2) do
+        stub_request(:get, "http://datastore/v2/records_with_multiple_oauth_providers_2?color=blue")
+          .with(
+            headers: { 'Authorization' => "Bearer #{token}_provider_2" }
+          ).to_return(status: 200, body: { items: [{ name: 'Record' }] }.to_json)
+      end
+
+      let(:records_request_per_endpoint_provider_1) do
+        stub_request(:get, "http://datastore/v2/records_with_multiple_oauth_providers_per_endpoint?color=blue")
+          .with(
+            headers: { 'Authorization' => "Bearer #{token}_provider_1" }
+          ).to_return(status: 200, body: { items: [{ name: 'Record' }] }.to_json)
+      end
+
+      let(:record_request_per_endpoint_provider_2) do
+        stub_request(:get, "http://datastore/v2/records_with_multiple_oauth_providers_per_endpoint/1")
+          .with(
+            headers: { 'Authorization' => "Bearer #{token}_provider_2" }
+          ).to_return(status: 200, body: { name: 'Record' }.to_json)
+      end
+
+      after do
+        LHC.config.reset
+      end
+
+      it 'applies OAuth credentials for the individual request automatically no matter how many auth providers are configured ' do
+        get '/automatic_authentication/oauth_with_multiple_providers'
+        expect(record_request_provider_1).to have_been_requested
+        expect(records_request_provider_2).to have_been_requested
+        expect(records_request_per_endpoint_provider_1).to have_been_requested
+        expect(record_request_per_endpoint_provider_2).to have_been_requested
+      end
+    end
+
+    context 'with provider enabled for auto oauth' do
+
+      let(:token) { ApplicationController::ACCESS_TOKEN }
+
+      let(:record_request) do
+        stub_request(:get, "http://internalservice/v2/records/1")
+          .with(
+            headers: { 'Authorization' => "Bearer #{token}" }
+          ).to_return(status: 200, body: { name: 'Record' }.to_json)
+      end
+
+      let(:records_request) do
+        stub_request(:get, "http://internalservice/v2/records?color=blue")
+          .with(
+            headers: { 'Authorization' => "Bearer #{token}" }
+          ).to_return(status: 200, body: { items: [{ name: 'Record' }] }.to_json)
+      end
+
+      before do
+        LHS.configure do |config|
+          config.auto_oauth = -> { access_token }
+        end
+        LHC.configure do |config|
+          config.interceptors = [LHC::Auth]
+        end
+        record_request
+        records_request
+      end
+
+      after do
+        LHC.config.reset
+      end
+
+      it 'applies OAuth credentials for the individual request automatically' do
+        get '/automatic_authentication/oauth_with_provider'
+        expect(record_request).to have_been_requested
+        expect(records_request).to have_been_requested
+      end
+    end
+  end
+end