dhs 1.0.0

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class DHS::Item < DHS::Proxy
+  autoload :EndpointLookup,
+    'dhs/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 DHC::Error => e
+      self.errors = DHS::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(DHS::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/dhs/concerns/item/validation.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class DHS::Item < DHS::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/DePayFi/dhs#validation' unless endpoint
+      record = DHS::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 DHC::Error => e
+      self.errors = DHS::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/dhs/concerns/o_auth.rb

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

data/lib/dhs/concerns/option_blocks.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/per_thread_registry'
+
+module DHS
+  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/dhs/concerns/proxy/accessors.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class DHS::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).freeze
+
+    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 = DHS::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 = DHS::Data.new(value, _data)
+      collection = DHS::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?(DHS::Data) || value.is_a?(DHS::Record)) ? value : DHS::Data.new(value, _data, record, _request)
+      data.errors = DHS::Problems::Nested::Errors.new(errors, name) if errors.any?
+      data.warnings = DHS::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?(DHS::Record)
+        return data.becomes(record, errors: data.errors, warnings: data.warnings)
+      end
+      data
+    end
+
+    def worth_wrapping?(value)
+      value.is_a?(DHS::Proxy)     ||
+        value.is_a?(DHS::Data)    ||
+        value.is_a?(DHS::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

data/lib/dhs/concerns/proxy/create.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class DHS::Proxy
+
+  module Create
+    extend ActiveSupport::Concern
+
+    def create(data = {}, options = nil)
+      record_creation!(options) do
+        record_from_link.create(
+          data,
+          options_for_creation(options)
+        )
+      end
+    end
+
+    def create!(data = {}, options = nil)
+      record_creation!(options) do
+        record_from_link.create!(
+          data,
+          options_for_creation(options)
+        )
+      end
+    end
+
+    private
+
+    def record_creation!(options)
+      raise(ArgumentError, 'Record already exists') if _raw.keys != [:href] && item?
+
+      record = yield
+      # Needed to handle unexpanded collection which looks the same as item
+      reload!(options) if record.errors.empty?
+      record
+    end
+
+    def options_for_creation(options)
+      return options if params_from_link.blank?
+      options = {} if options.blank?
+      options.deep_merge(params: params_from_link)
+    end
+  end
+end

data/lib/dhs/concerns/proxy/link.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class DHS::Proxy
+
+  module Link
+    extend ActiveSupport::Concern
+
+    private
+
+    def record_from_link
+      DHS::Record.for_url(_data.href)
+    end
+
+    def endpoint_from_link
+      DHS::Endpoint.for_url(_data.href)
+    end
+
+    def params_from_link
+      return {} if !_data.href || !endpoint_from_link
+      DHC::Endpoint.values_as_params(endpoint_from_link.url, _data.href)
+    end
+  end
+end

data/lib/dhs/concerns/proxy/problems.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class DHS::Proxy
+
+  module Problems
+    extend ActiveSupport::Concern
+
+    included do
+      attr_writer :errors, :warnings
+    end
+
+    def initialize(data)
+      super(data)
+    end
+
+    def errors
+      response = (_raw.present? && _raw.is_a?(Hash) && _raw[:field_errors]) ? OpenStruct.new(body: _raw.to_json) : nil
+      @errors ||= DHS::Problems::Errors.new(response, record)
+    end
+
+    def warnings
+      @warnings ||= DHS::Problems::Warnings.new(_raw, record)
+    end
+  end
+end

data/lib/dhs/concerns/record/attribute_assignment.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class DHS::Record
+
+  module AttributeAssignment
+    extend ActiveSupport::Concern
+
+    def assign_attributes(new_attributes)
+      unless new_attributes.respond_to?(:stringify_keys)
+        raise ArgumentError, "When assigning attributes, you must pass a hash as an argument, #{new_attributes.class} passed."
+      end
+      return if new_attributes.empty?
+
+      _assign_attributes(new_attributes)
+    end
+
+    private
+
+    def _assign_attributes(attributes)
+      attributes.each do |key, value|
+        public_send(:"#{key}=", value)
+      end
+    end
+  end
+end

data/lib/dhs/concerns/record/batch.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class DHS::Record
+
+  module Batch
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Process single entries fetched in batches
+      def find_each(options = {})
+        find_in_batches(options) do |records|
+          records.each do |record|
+            item = DHS::Item.new(record)
+            yield new(DHS::Data.new(item, records._data, self))
+          end
+        end
+      end
+
+      # Process batches of entries
+      def find_in_batches(options = {})
+        raise 'No block given' unless block_given?
+        options = options.dup
+        start = options.delete(:start) || 1
+        batch_size = options.delete(:batch_size) || DHS::Pagination::Base::DEFAULT_LIMIT
+        loop do # as suggested by Matz
+          options = options.dup
+          options[:params] = (options[:params] || {}).merge(limit_key(:parameter) => batch_size, pagination_key(:parameter) => start)
+          data = request(options)
+          batch_size = data._raw.dig(*limit_key(:body))
+          left = data._raw.dig(*total_key).to_i - data._raw.dig(*pagination_key(:body)).to_i - data._raw.dig(*limit_key(:body)).to_i
+          yield new(data)
+          break if left <= 0
+          start += batch_size
+        end
+      end
+    end
+  end
+end