lhs 24.0.0

data/lib/lhs/concerns/data/json.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class LHS::Data
+
+  module Json
+    extend ActiveSupport::Concern
+
+    def as_json(options = {})
+      _data._raw.as_json(options)
+    end
+  end
+end

data/lib/lhs/concerns/data/to_hash.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class LHS::Data
+
+  module ToHash
+    extend ActiveSupport::Concern
+
+    included do
+      delegate :to_h, :to_hash, to: :_raw, allow_nil: true
+    end
+  end
+end

data/lib/lhs/concerns/inspect.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+module LHS
+  module Inspect
+    extend ActiveSupport::Concern
+
+    def inspect
+      [
+        [
+          [
+            [
+              to_s.match('LHS::Data') ? 'Data of ' : nil,
+              self.class
+            ].join,
+            _inspect_id
+          ].join(' '),
+          _inspect_path
+        ].compact.join("\n"),
+        pretty_raw
+      ].compact.join("\n")
+    end
+
+    private
+
+    def _inspect_id
+      _root.href || (_root.item? ? _root.id : nil) || object_id
+    end
+
+    def _inspect_path
+      current = self
+      path = []
+      _collect_parents_for_inspect!(path, current)
+      return if path.blank?
+      "> #{path.reverse.join(' > ')}"
+    end
+
+    def _collect_parents_for_inspect!(path, current)
+      return unless current.parent
+      parent_raw = current.parent._raw
+      if parent_raw.is_a?(Array)
+        parent_raw.each_with_index do |element, index|
+          path.push(index) if element == current._raw
+        end
+      elsif parent_raw.is_a?(Hash)
+        parent_raw.each do |key, value|
+          path.push(key) if value == current._raw
+        end
+      end
+      _collect_parents_for_inspect!(path, current.parent)
+    end
+
+    def pretty_raw
+      return if _raw.blank?
+      if _raw.is_a?(Array)
+        _raw
+      else
+        _raw.to_a.map do |key, value|
+          ":#{key} => " +
+            if value.is_a? String
+              "\"#{value}\""
+            else
+              value.to_s
+            end
+        end
+      end.join("\n")
+    end
+  end
+end

data/lib/lhs/concerns/is_href.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+module LHS
+  module IsHref
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def href?(input)
+        input.is_a?(String) && %r{^https?://}.match(input).present?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class LHS::Item < LHS::Proxy
+
+  module Destroy
+    extend ActiveSupport::Concern
+
+    def destroy(options = {})
+      options ||= {}
+      options = options.merge(method: :delete)
+      data = _data._raw.dup
+      url = url_for_deletion!(options, data)
+      options = options.merge(url: url)
+      _data._request = _data.class.request(options)._request
+      _data
+    end
+
+    private
+
+    def url_for_deletion!(options, data)
+      return href if href.present?
+      endpoint = endpoint_for_deletion(data, options)
+      endpoint.compile(
+        merge_data_with_options(data, options)
+      ).tap do
+        endpoint.remove_interpolated_params!(data)
+        endpoint.remove_interpolated_params!(options.fetch(:params, {}))
+        options.merge!(endpoint.options.merge(options)) if endpoint.options
+      end
+    end
+
+    def endpoint_for_deletion(data, options)
+      record.find_endpoint(merge_data_with_options(data, options))
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class LHS::Item < LHS::Proxy
+  module EndpointLookup
+    extend ActiveSupport::Concern
+
+    def url_for_persistance!(data, options)
+      return href if href.present?
+      endpoint = endpoint_for_persistance!(data, options)
+      endpoint.compile(
+        merge_data_with_options(data, options)
+      ).tap do
+        endpoint.remove_interpolated_params!(data)
+        endpoint.remove_interpolated_params!(options.fetch(:params, {}))
+        options.merge!(endpoint.options.merge(options)) if endpoint.options
+      end
+    end
+
+    private
+
+    def endpoint_for_persistance!(data, options)
+      record.find_endpoint(merge_data_with_options(data, options))
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class LHS::Item < LHS::Proxy
+  autoload :EndpointLookup,
+    'lhs/concerns/item/endpoint_lookup'
+
+  module Save
+    extend ActiveSupport::Concern
+
+    included do
+      include EndpointLookup
+    end
+
+    def save(options = nil)
+      save!(options)
+    rescue LHC::Error
+      false
+    end
+
+    def save!(options = {})
+      options = options.present? ? options.dup : {}
+      data = _data._raw.dup
+      url = url_for_persistance!(data, options)
+      create_and_merge_data!(
+        apply_default_creation_options(options, url, data)
+      )
+    rescue LHC::Error => e
+      self.errors = LHS::Problems::Errors.new(e.response, record)
+      raise e
+    end
+
+    private
+
+    def apply_default_creation_options(options, url, data)
+      options = options.merge(method: :post, url: url, body: data)
+      options[:headers] ||= {}
+      options
+    end
+
+    def create_and_merge_data!(options)
+      response_data = record.request(options)
+      if response_data.present?
+        _data.merge_raw!(response_data.unwrap(:item_created_key))
+        response_headers = response_data._request.response.headers
+      end
+      if response_headers && response_headers['Location']
+        location_data = record.request(options.merge(url: response_headers['Location'], method: :get, body: nil))
+        _data.merge_raw!(location_data.unwrap(:item_created_key))
+      end
+      true
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class LHS::Item < LHS::Proxy
+  autoload :EndpointLookup,
+    'lhs/concerns/item/endpoint_lookup'
+
+  module Update
+    extend ActiveSupport::Concern
+
+    included do
+      include EndpointLookup
+    end
+
+    def update(params, options = nil, partial_update = false)
+      update!(params, options, partial_update)
+    rescue LHC::Error => e
+      self.errors = LHS::Problems::Errors.new(e.response, record)
+      false
+    end
+
+    def partial_update(params, options = nil)
+      update(params, options, true)
+    end
+
+    def partial_update!(params, options = nil)
+      update!(params, options, true)
+    end
+
+    def update!(params, options = {}, partial_update = false)
+      options = options.present? ? options.dup : {}
+      partial_record = _record.new(LHS::Data.new(params, _data.parent, _record))
+      _data.merge_raw!(partial_record._data)
+      data = _data._raw.dup
+      partial_data = partial_record._data._raw.dup
+      url = url_for_persistance!(data, options)
+      data_sent = partial_update ? partial_data.extract!(*data.keys) : data
+      response_data = record.request(
+        options.merge(
+          method: options.fetch(:method, :post),
+          url: url,
+          body: data_sent
+        )
+      )
+      _data.merge_raw!(response_data.unwrap(:item_created_key))
+      true
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class LHS::Item < LHS::Proxy
+
+  module Validation
+    extend ActiveSupport::Concern
+
+    def valid?(options = {})
+      options ||= {}
+      errors.clear
+      endpoint = validation_endpoint
+      raise 'No endpoint found to perform validations! See here: https://github.com/local-ch/lhs#validation' unless endpoint
+      record = LHS::Record.for_url(endpoint.url)
+      params = merge_validation_params!(endpoint).merge options.fetch(:params, {})
+      url = validation_url(endpoint)
+      run_validation!(record, options, url, params)
+      true
+    rescue LHC::Error => e
+      self.errors = LHS::Problems::Errors.new(e.response, record)
+      false
+    end
+    alias validate valid?
+
+    private
+
+    def validation_url(endpoint)
+      url = endpoint.url
+      action = endpoint.options[:validates][:path].presence
+      url = "#{url}/#{action}" if action.present?
+      url
+    end
+
+    def merge_validation_params!(endpoint)
+      validates_params = endpoint.options[:validates].reject { |key, _| key.to_sym == :path }
+      params = endpoint.options.fetch(:params, {}).merge(params_from_link)
+      params = params.merge(validates_params) if validates_params.is_a?(Hash)
+      params
+    end
+
+    def run_validation!(record, options, url, params)
+      record.request(
+        options.merge(
+          url: url,
+          method: :post,
+          params: params,
+          body: _data
+        )
+      )
+    end
+
+    def validation_endpoint
+      endpoint = endpoint_from_link if _data.href # take embeded first
+      endpoint ||= record.find_endpoint(_data._raw)
+      validates = endpoint.options&.fetch(:validates, false)
+      raise 'Endpoint does not support validations!' unless validates
+      endpoint
+    end
+  end
+end

data/lib/lhs/concerns/o_auth.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+module LHS
+  module OAuth
+    extend ActiveSupport::Concern
+
+    included do
+      prepend_before_action :lhs_store_oauth_access_token
+    end
+
+    private
+
+    def lhs_store_oauth_access_token
+      lhs_check_auto_oauth_enabled!
+      LHS::Interceptors::AutoOauth::ThreadRegistry.access_token = instance_exec(&LHS.config.auto_oauth)
+    end
+
+    def lhs_check_auto_oauth_enabled!
+      return if LHS.config.auto_oauth.present? && LHS.config.auto_oauth.is_a?(Proc)
+      raise 'You have to enable LHS.config.auto_oauth by passing a proc returning an access token!'
+    end
+  end
+end

data/lib/lhs/concerns/option_blocks.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/per_thread_registry'
+
+module LHS
+  module OptionBlocks
+    extend ActiveSupport::Concern
+
+    class CurrentOptionBlock
+      # Using ActiveSupports PerThreadRegistry to be able to support Active Support v4.
+      # Will switch to thread_mattr_accessor (which comes with Activesupport) when we dropping support for Active Support v4.
+      extend ActiveSupport::PerThreadRegistry
+      attr_accessor :options
+    end
+
+    module ClassMethods
+      def options(options, &block)
+        CurrentOptionBlock.options = options
+        block.call
+      ensure
+        CurrentOptionBlock.options = nil
+      end
+    end
+  end
+end

data/lib/lhs/concerns/proxy/accessors.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class LHS::Proxy
+  module Accessors
+    extend ActiveSupport::Concern
+
+    # Keywords that would not be forwarded via method missing
+    # FIXME: Extend the set of keywords
+    BLACKLISTED_KEYWORDS = %w(new proxy_association)
+
+    delegate :dig, :fetch, to: :_raw, allow_nil: true
+
+    def clear_cache!
+      @cache = nil
+    end
+
+    private
+
+    def set(name, args)
+      clear_cache!
+      return set_attribute_directly(name, args.try(:first)) if name != :[]=
+      key = args[0]
+      value = args[1]
+      _data._raw[key.to_sym] = value
+    end
+
+    def set_attribute_directly(name, value)
+      key = name.to_s.gsub(/=$/, '')
+      _data._raw[key.to_sym] = value
+    end
+
+    def get(name, *args)
+      name = args.first if name == :[]
+      value = _data._raw[name.to_s] if _data._raw
+      if value.nil? && _data._raw.present? && _data._raw.is_a?(Hash)
+        value = _data._raw[name.to_sym]
+        value = _data._raw[name.to_s.classify.to_sym] if value.nil?
+      end
+
+      record = LHS::Record.for_url(value[:href]) if value.is_a?(Hash) && value[:href]
+      access_item(value, record, name) ||
+        access_collection(value, record, name) ||
+        convert(value)
+    end
+
+    def accessing_item?(value, record)
+      return false unless value.is_a?(Hash)
+      return false if record && access(input: value, record: record).present?
+      return false if !record && value[:items].present?
+      true
+    end
+
+    def accessing_collection?(value, record)
+      return true if value.is_a?(Array)
+      return true if value.is_a?(Hash) && record && access(input: value, record: record).present?
+      return true if value.is_a?(Hash) && !record && value[:items].present?
+    end
+
+    def convert(value)
+      return value unless value.is_a?(String)
+      if date_time?(value)
+        Time.zone.parse(value)
+      elsif date?(value)
+        Date.parse(value)
+      else
+        value
+      end
+    end
+
+    def access_item(value, record, name)
+      return unless accessing_item?(value, record)
+      wrap_return(value, record, name)
+    end
+
+    def access_collection(value, record, name)
+      return unless accessing_collection?(value, record)
+      collection_data = LHS::Data.new(value, _data)
+      collection = LHS::Collection.new(collection_data)
+      wrap_return(collection, record, name)
+    end
+
+    # Wraps the return value with a record class.
+    # Adds errors and warnings if existing.
+    # Returns plain data if no record class was found.
+    def wrap_return(value, record, name, args = nil)
+      name = args.first if name == :[]
+      return value unless worth_wrapping?(value)
+      data = (value.is_a?(LHS::Data) || value.is_a?(LHS::Record)) ? value : LHS::Data.new(value, _data, record, _request)
+      data.errors = LHS::Problems::Nested::Errors.new(errors, name) if errors.any?
+      data.warnings = LHS::Problems::Nested::Warnings.new(warnings, name) if warnings.any?
+      if _record && _record._relations[name]
+        klass = _record._relations[name][:record_class_name].constantize
+        return cache.compute_if_absent(klass) do
+          data.becomes(klass, errors: data.errors, warnings: data.warnings)
+        end
+      elsif record && !value.is_a?(LHS::Record)
+        return data.becomes(record, errors: data.errors, warnings: data.warnings)
+      end
+      data
+    end
+
+    def worth_wrapping?(value)
+      value.is_a?(LHS::Proxy)     ||
+        value.is_a?(LHS::Data)    ||
+        value.is_a?(LHS::Record)  ||
+        value.is_a?(Hash)         ||
+        value.is_a?(Array)
+    end
+
+    def date?(value)
+      value[date_time_regex, :date].presence
+    end
+
+    def time?(value)
+      value[date_time_regex, :time].presence
+    end
+
+    def date_time?(value)
+      date?(value) && time?(value)
+    end
+
+    def date_time_regex
+      /(?<date>\d{4}-\d{2}-\d{2})?(?<time>T\d{2}:\d{2}(:\d{2}(\.\d*.\d{2}:\d{2})*)?)?/
+    end
+
+    def cache
+      @cache ||= Concurrent::Map.new
+    end
+  end
+end