dhs 1.0.0

data/lib/dhs/interceptors/request_cycle_cache/thread_registry.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/per_thread_registry'
+
+module DHS
+  module Interceptors
+    module RequestCycleCache
+      extend ActiveSupport::Concern
+      class ThreadRegistry
+        # 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 :request_id
+      end
+    end
+  end
+end

data/lib/dhs/item.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+# An item is a concrete record.
+# It can be part of another proxy like collection.
+class DHS::Item < DHS::Proxy
+
+  autoload :Destroy,
+    'dhs/concerns/item/destroy'
+  autoload :Save,
+    'dhs/concerns/item/save'
+  autoload :Update,
+    'dhs/concerns/item/update'
+  autoload :Validation,
+    'dhs/concerns/item/validation'
+
+  include Create
+  include Destroy
+  include Save
+  include Update
+  include Validation
+
+  delegate :map, :present?, :blank?, :empty?, to: :_raw, allow_nil: true
+  delegate :_raw, to: :_data
+
+  def collection?
+    false
+  end
+
+  def item?
+    true
+  end
+
+  def respond_to?(sym, include_all = false)
+    if sym == :to_ary
+      false
+    else
+      super(sym, include_all)
+    end
+  end
+
+  protected
+
+  def method_missing(name, *args, **_keyword_args, &_block)
+    return set(name, args) if name.to_s[/=$/]
+    get(name, *args)
+  end
+
+  def respond_to_missing?(name, _include_all = false)
+    # We accept every message that does not belong to set of keywords
+    !BLACKLISTED_KEYWORDS.include?(name.to_s)
+  end
+
+  def unwrap_nested_item
+    return _data unless _record.item_key
+    nested_data = _data.dig(*_record.item_key)
+    return _data unless nested_data
+    DHS::Data.new(nested_data, _data._parent, _record, _data._request, _data._endpoint)
+  end
+end

data/lib/dhs/pagination/base.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module/delegation'
+
+# Pagination is used to navigate paginateable collections
+module DHS::Pagination
+  class Base
+
+    DEFAULT_LIMIT = 100
+
+    delegate :_record, to: :data
+    attr_accessor :data
+
+    def initialize(data)
+      self.data = data
+    end
+
+    def total
+      data._raw.dig(*_record.total_key) || 0
+    end
+
+    # as standard in Rails' ActiveRecord count is not summing up, but using the number provided from data source
+    alias count total
+
+    def limit
+      data._raw.dig(*_record.limit_key(:body)) || DEFAULT_LIMIT
+    end
+
+    def offset
+      data._raw.dig(*_record.pagination_key(:body)) || self.class::DEFAULT_OFFSET
+    end
+    alias start offset
+
+    def pages_left
+      total_pages - current_page
+    end
+
+    def pages_left?
+      pages_left > 0
+    end
+
+    def next_offset(_step = 1)
+      raise 'to be implemented in subclass'
+    end
+
+    def current_page
+      # should be implemented in subclass (optional)
+    end
+
+    def first_page
+      1
+    end
+
+    def last_page
+      total_pages
+    end
+
+    def parallel?
+      true
+    end
+
+    def next?
+      data._raw[:next].present?
+    end
+
+    def previous?
+      data._raw[:previous].present?
+    end
+
+    def prev_page
+      current_page - 1
+    end
+
+    def next_page
+      current_page + 1
+    end
+
+    def limit_value
+      limit
+    end
+
+    def total_pages
+      (total.to_f / limit).ceil
+    end
+
+    def self.page_to_offset(page, _limit)
+      page.to_i
+    end
+  end
+end

data/lib/dhs/pagination/link.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class DHS::Pagination::Link < DHS::Pagination::Base
+  def total
+    data._raw.dig(*_record.items_key).count || 0
+  end
+
+  alias count total
+
+  def pages_left
+    pages_left? ? 1 : 0
+  end
+
+  def pages_left?
+    data._raw[:next].present?
+  end
+
+  def parallel?
+    false
+  end
+end

data/lib/dhs/pagination/offset.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class DHS::Pagination::Offset < DHS::Pagination::Base
+
+  DEFAULT_OFFSET = 0
+
+  def current_page
+    (offset + limit) / limit
+  end
+
+  def next_offset(step = 1)
+    self.class.next_offset(offset, limit, step)
+  end
+
+  def self.page_to_offset(page, limit = DEFAULT_LIMIT)
+    (page.to_i - 1) * limit.to_i
+  end
+
+  def self.next_offset(offset, limit, step = 1)
+    offset.to_i + limit.to_i * step.to_i
+  end
+end

data/lib/dhs/pagination/page.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class DHS::Pagination::Page < DHS::Pagination::Base
+
+  DEFAULT_OFFSET = 1
+
+  def current_page
+    offset
+  end
+
+  def next_offset(step = 1)
+    self.class.next_offset(current_page, limit, step)
+  end
+
+  def self.next_offset(current_page, _limit, step = 1)
+    current_page.to_i + step.to_i
+  end
+end

data/lib/dhs/pagination/start.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class DHS::Pagination::Start < DHS::Pagination::Base
+
+  DEFAULT_OFFSET = 1
+
+  def current_page
+    (offset + limit - 1) / limit
+  end
+
+  def next_offset(step = 1)
+    self.class.next_offset(offset, limit, step)
+  end
+
+  def self.page_to_offset(page, limit = DEFAULT_LIMIT)
+    (page.to_i - 1) * limit.to_i + 1
+  end
+
+  def self.next_offset(offset, limit, step = 1)
+    offset.to_i + limit.to_i * step.to_i
+  end
+end

data/lib/dhs/pagination/total_pages.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+class DHS::Pagination::TotalPages < DHS::Pagination::Page
+
+  def total
+    (data._raw.dig(*_record.total_key) || 0) * limit
+  end
+  alias count total
+end

data/lib/dhs/problems/base.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module'
+require 'active_support/core_ext/hash'
+
+# Like ActiveModel::Errors
+module DHS::Problems
+  class Base
+    include Enumerable
+
+    attr_reader :raw, :messages, :codes, :record
+
+    def include?(attribute)
+      messages[attribute].present?
+    end
+    alias has_key? include?
+    alias key? include?
+
+    def add(attribute, message = :invalid, options = {})
+      self[attribute]
+      messages[attribute] << generate_message(attribute, message, options)
+    end
+
+    def get(key)
+      messages[key]
+    end
+
+    def set(key, message)
+      return if message.blank?
+      messages[key] = [generate_message(key, message)]
+    end
+
+    delegate :delete, to: :messages
+
+    def [](attribute)
+      get(attribute.to_sym) || messages[attribute] = []
+    end
+
+    def []=(attribute, message)
+      self[attribute] << generate_message(attribute, message)
+    end
+
+    def each
+      if messages.is_a?(Hash)
+        messages.each_key do |attribute|
+          self[attribute].each { |message| yield attribute, message }
+        end
+      elsif messages.is_a?(Array)
+        messages.each { |message| yield message }
+      end
+    end
+
+    def size
+      values.flatten.size
+    end
+
+    def clear
+      @raw = nil
+      @messages.clear
+      @codes.clear
+    end
+
+    delegate :values, to: :messages
+
+    delegate :keys, to: :messages
+
+    def count
+      to_a.size
+    end
+
+    def empty?
+      all? { |_k, v| v&.empty? && !v.is_a?(String) }
+    end
+
+    private
+
+    def add_error(messages, key, value)
+      key = key.to_sym
+      codes[key] ||= []
+      codes[key].push(value)
+      messages[key] ||= []
+      messages[key].push(generate_message(key, value))
+    end
+
+    def generate_message(attribute, message, _options = {})
+      problem_type = self.class.name.demodulize.downcase
+      find_translated_message(attribute, message, problem_type) || message
+    end
+
+    def find_translated_message(attribute, message, problem_type)
+      normalized_attribute = attribute.to_s.underscore.gsub(/\.[\d+\.]/, '')
+      normalized_message = message.to_s.underscore
+      messages = []
+      messages = messages_for_record(normalized_attribute, normalized_message, problem_type) if record
+      messages.concat([
+        ['dhs', problem_type, 'messages', normalized_message],
+        ['dhs', problem_type, 'attributes', normalized_attribute, normalized_message],
+        ['dhs', problem_type, 'fallback_message']
+      ]).detect do |path|
+        key = path.join('.')
+        return I18n.translate(key) if I18n.exists?(key)
+      end
+    end
+
+    def messages_for_record(normalized_attribute, normalized_message, problem_type)
+      record_name = record.model_name.name.underscore
+      [
+        ['dhs', problem_type, 'records', record_name, 'attributes', normalized_attribute, normalized_message],
+        ['dhs', problem_type, 'records', record_name, normalized_message]
+      ]
+    end
+  end
+end

data/lib/dhs/problems/errors.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module DHS::Problems
+  class Errors < Base
+
+    attr_reader :status_code, :message
+
+    def initialize(response = nil, record = nil)
+      @raw = response.body if response
+      @record = record
+      @codes = {}.with_indifferent_access
+      @messages = messages_from_response(response).with_indifferent_access
+      @message = message_from_response(response)
+      @status_code = response.code if response
+    rescue JSON::ParserError
+      @messages = (messages || {}).with_indifferent_access
+      @codes = (codes || {}).with_indifferent_access
+      @message = 'parse error'
+      add_error(@messages, 'body', 'parse error')
+    end
+
+    private
+
+    def parse_messages(json)
+      messages = {}
+      fields_to_errors(json, messages) if json['fields']
+      field_errors_to_errors(json, messages) if json['field_errors']
+      fallback_errors(json, messages) if messages.empty? && !json['fields'] && !json['field_errors']
+      messages
+    end
+
+    def fallback_errors(json, messages)
+      if json.present?
+        json.each do |key, value|
+          add_error(messages, key, value)
+        end
+      else
+        add_error(messages, 'unknown', 'error')
+      end
+    end
+
+    def field_errors_to_errors(json, messages)
+      json['field_errors'].each do |field_error|
+        add_error(messages, field_error['path'].join('.').to_sym, field_error['code'])
+      end
+    end
+
+    def fields_to_errors(json, messages)
+      json['fields'].each do |field|
+        field['details'].each do |detail|
+          add_error(messages, field['name'].to_sym, detail['code'])
+        end
+      end
+    end
+
+    def messages_from_response(response = nil)
+      return {} if !response || !response.body.is_a?(String) || response.body.length.zero?
+      json = JSON.parse(response.body)
+      parse_messages(json)
+    end
+
+    def message_from_response(response = nil)
+      return if response.blank?
+      raise JSON::ParserError if response.body.blank?
+      json = JSON.parse(response.body)
+      json['message']
+    end
+  end
+end