dhs 1.0.0

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

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class DHS::Record
+
+  # Allows configuring endpoints
+  # like which keys are used for the items, offset, total etc.
+  module Configuration
+    extend ActiveSupport::Concern
+
+    mattr_accessor :configuration
+
+    module ClassMethods
+      def configuration(args = nil)
+        if !args.nil?
+          @configuration = args
+        else
+          @configuration || {}
+        end
+      end
+
+      def auto_oauth?
+        DHS.config.auto_oauth && configuration && auto_oauth
+      end
+
+      def auto_oauth
+        configuration.fetch(:auto_oauth, false)
+      end
+
+      def oauth(provider = nil)
+        value = provider || true
+        configuration.present? ? configuration.merge!(auto_oauth: value) : configuration(auto_oauth: value)
+      end
+
+      def item_key
+        symbolize_unless_complex(
+          configuration.dig(:item_key) || :item
+        )
+      end
+
+      def items_key
+        symbolize_unless_complex(
+          configuration.dig(:items_key) || :items
+        )
+      end
+
+      def item_created_key
+        symbolize_unless_complex(
+          configuration.dig(:item_created_key)
+        )
+      end
+
+      def limit_key(type = nil)
+        symbolize_unless_complex(
+          pagination_parameter(configuration.dig(:limit_key), type) ||
+          :limit
+        )
+      end
+
+      def total_key
+        symbolize_unless_complex(
+          configuration.dig(:total_key) || :total
+        )
+      end
+
+      # Key used for determine current page
+      def pagination_key(type = nil)
+        symbolize_unless_complex(
+          pagination_parameter(configuration.dig(:pagination_key), type) ||
+          :offset
+        )
+      end
+
+      # Strategy used for calculationg next pages and navigate pages
+      def pagination_strategy
+        symbolize_unless_complex(
+          configuration.dig(:pagination_strategy) || :offset
+        )
+      end
+
+      # Allows record to be configured as not paginated,
+      # as by default it's considered paginated
+      def paginated
+        return true if configuration.blank?
+        configuration.fetch(:paginated, true)
+      end
+
+      private
+
+      def symbolize_unless_complex(value)
+        return if value.blank?
+        return value.to_sym unless value.is_a?(Array)
+        value
+      end
+
+      def pagination_parameter(configuration, type)
+        return configuration unless configuration.is_a?(Hash)
+        configuration[type]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class DHS::Record
+
+  module Create
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def create(data = {}, options = nil)
+        record = new(data)
+        record.save(options)
+        record
+      end
+
+      def create!(data = {}, options = nil)
+        record = new(data)
+        record.save!(options)
+        record
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class DHS::Record
+
+  module CustomSetters
+    extend ActiveSupport::Concern
+
+    private
+
+    def apply_custom_setters!
+      return if !_data.item? || !_data._raw.respond_to?(:keys)
+      raw = _data._raw
+      custom_setters = raw.keys.find_all { |key| public_methods.include?("#{key}=".to_sym) }
+      custom_setters.each do |setter|
+        value = raw.delete(setter)
+        send("#{setter}=", value)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class DHS::Record
+
+  module Destroy
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def destroy(args, options = nil)
+        options = {} if options.blank?
+        params = args.respond_to?(:to_h) ? args : { id: args }
+        request(options.merge(params: params, method: :delete))
+      end
+    end
+  end
+end

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

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/core_ext'
+
+class DHS::Record
+
+  # An endpoint is an url that leads to a backend resource.
+  # A record can contain multiple endpoints.
+  # The endpoint that is used to request data is choosen
+  # based on the provided parameters.
+  module Endpoints
+    extend ActiveSupport::Concern
+
+    mattr_accessor :all
+
+    included do
+      class_attribute :endpoints unless defined? endpoints
+      self.endpoints = []
+    end
+
+    module ClassMethods
+      # Adds the endpoint to the list of endpoints.
+      def endpoint(url, options = nil)
+        self.endpoints = endpoints.clone
+        validates_deprecation_check!(options)
+        endpoint = DHC::Endpoint.new(url, options)
+        endpoints.push(endpoint)
+        DHS::Record::Endpoints.all ||= {}
+        DHS::Record::Endpoints.all[url] ||= self
+      end
+
+      def for_url(url)
+        return unless url
+        _template, record = DHS::Record::Endpoints.all.dup.detect do |template, _|
+          DHC::Endpoint.match?(url, template)
+        end
+        record
+      end
+
+      # Find an endpoint based on the provided parameters.
+      # If no parameters are provided it finds the base endpoint
+      # otherwise it finds the endpoint that matches the parameters best.
+      def find_endpoint(params = {}, url = nil)
+        endpoint = find_best_endpoint(params) if params && params.keys.count > 0
+        endpoint ||= find_endpoint_by_url(url) if url.present?
+        endpoint ||= DHC::Endpoint.new(url) if url.present?
+        endpoint ||= find_base_endpoint
+        endpoint
+      end
+
+      # Computes the url from params
+      # by identifiying endpoint and compiles it if necessary.
+      def compute_url!(params)
+        endpoint = find_endpoint(params)
+        url = endpoint.compile(params)
+        endpoint.remove_interpolated_params!(params)
+        url
+      end
+
+      def compute_url(params, url = nil)
+        find_endpoint(params, url)
+          .compile(params)
+      end
+
+      private
+
+      def validates_deprecation_check!(options)
+        return if options.blank?
+        return if options[:validates].blank?
+        return if options[:validates].is_a?(Hash)
+        return if !options[:validates].is_a?(TrueClass) && options[:validates].match(%r{^\/})
+        raise 'Validates with either true or a simple string is deprecated! See here: https://github.com/DePayFi/dhs#validation'
+      end
+
+      # Finds the best endpoint.
+      # The best endpoint is the one where all placeholders are interpolated.
+      def find_best_endpoint(params)
+        sorted_endpoints.find do |endpoint|
+          endpoint.placeholders.all? { |match| endpoint.find_value(match, params).present? }
+        end
+      end
+
+      # Find endpoint by given URL
+      def find_endpoint_by_url(url)
+        sorted_endpoints.find do |endpoint|
+          DHC::Endpoint.match?(url, endpoint.url)
+        end
+      end
+
+      # Sort endpoints by number of placeholders, heighest first
+      def sorted_endpoints
+        endpoints.sort { |a, b| b.placeholders.count <=> a.placeholders.count }
+      end
+
+      # Finds the base endpoint.
+      # A base endpoint is the one thats has the least amont of placeholers.
+      # There cannot be multiple base endpoints.
+      def find_base_endpoint
+        endpoints = self.endpoints.group_by do |endpoint|
+          endpoint.placeholders.length
+        end
+        bases = endpoints[endpoints.keys.min]
+        bases.first
+      end
+    end
+  end
+end

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

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class DHS::Record
+
+  module Equality
+    extend ActiveSupport::Concern
+
+    def ==(other)
+      _raw == other.try(:_raw)
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class DHS::Record
+
+  module Find
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Find a single uniqe record
+      def find(*args)
+        args, options = process_args(args)
+        options = trace!(options)
+        raise(DHS::Unprocessable.new, 'Cannot find Record without an ID') if args.blank? && !args.is_a?(Array)
+        data =
+          if args.present? && args.is_a?(Array)
+            find_in_parallel(args, options)
+          elsif args.is_a? Hash
+            find_with_parameters(args, options)
+          else
+            find_by_id(args, options)
+          end
+        return nil if data.nil?
+        return data unless data._record
+        if data.collection?
+          data.map { |record| data._record.new(record.unwrap_nested_item) }
+        else
+          data._record.new(data.unwrap_nested_item)
+        end
+      end
+
+      private
+
+      def process_args(args)
+        if args.length == 1
+          args = args.first
+        elsif args.length == 2 && args.last.is_a?(Hash)
+          options = args.pop if args.last.is_a?(Hash)
+          args = args.first
+        elsif args.last.is_a?(Hash)
+          options = args.pop
+        end
+        options ||= nil
+        [args, options]
+      end
+
+      def get_unique_item!(data)
+        return if data.nil?
+        if data._proxy.is_a?(DHS::Collection)
+          raise DHC::NotFound.new('Requested unique item. Multiple were found.', data._request.response) if data.length > 1
+          data.first || raise(DHC::NotFound.new('No item was found.', data._request.response))
+        else
+          data
+        end
+      end
+
+      def find_with_parameters(args, options = {})
+        data = request(request_options(args, options))
+        get_unique_item!(data)
+      end
+
+      def find_by_id(args, options = {})
+        request(request_options(args, options))
+      end
+
+      def find_in_parallel(args, options)
+        options = args.map { |argument| request_options(argument, options) }
+        request(options)
+      end
+
+      def request_options(args, options)
+        options ||= {}
+        if args.is_a? Hash
+          options.merge(params: args)
+        elsif href?(args)
+          options.merge(url: args)
+        elsif args.present?
+          options.merge(params: { id: args })
+        else
+          options
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class DHS::Record
+
+  module FindBy
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Fetch some record by parameters
+      def find_by(params = {}, options = nil)
+        _find_by(params, trace!(options))
+      rescue DHC::NotFound
+        nil
+      end
+
+      # Raise if no record was found
+      def find_by!(params = {}, options = nil)
+        _find_by(params, trace!(options))
+      end
+
+      private
+
+      def _find_by(params, options = {})
+        raise(DHS::Unprocessable.new, 'Cannot find Record without an ID') if params.any? && params.all? { |_, value| value.blank? }
+        options ||= {}
+        params = params.dup.merge(limit_key(:parameter) => 1).merge(options.fetch(:params, {}))
+        data = request(options.merge(params: params))
+        if data && data._proxy.is_a?(DHS::Collection)
+          data.first || raise(DHC::NotFound.new('No item was found.', data._request.response))
+        elsif data
+          data._record.new(data.unwrap_nested_item)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class DHS::Record
+
+  module First
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def first(options = nil)
+        find_by({}, trace!(options))
+      end
+
+      def first!(options = nil)
+        find_by!({}, trace!(options))
+      end
+    end
+  end
+end