dhs 1.0.0

data/Rakefile

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'DHS'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new(:spec)
+  task default: :spec
+rescue LoadError
+  # no rspec available
+end
+
+Bundler::GemHelper.install_tasks

data/dhs.gemspec

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.push File.expand_path('lib', __dir__)
+
+# Maintain your gem's version:
+require 'dhs/version'
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name        = 'dhs'
+  s.version     = DHS::VERSION
+  s.authors     = ['https://github.com/DePayFi/dhs/graphs/contributors']
+  s.email       = ['engineering@depay.fi']
+  s.homepage    = 'https://github.com/DePayFi/dhs'
+  s.summary     = 'REST services accelerator: Rails gem providing an easy, active-record-like interface for http (hypermedia) json services'
+  s.description = 'DHS ia a Rails-Gem, providing an ActiveRecord like interface to access HTTP-JSON-Services from Rails Applications. Special features provided by this gem are: Multiple endpoint configuration per resource, active-record-like query-chains, scopes, error handling, relations, request cycle cache, batch processing, including linked resources (hypermedia), data maps (data accessing), nested-resource handling, ActiveModel like backend validation conversion, formbuilder-compatible, three types of pagination support, service configuration per resource, kaminari-support and much more.'
+
+  s.files        = `git ls-files`.split("\n")
+  s.test_files   = `git ls-files -- spec/*`.split("\n")
+  s.require_paths = ['lib']
+
+  s.requirements << 'Ruby >= 3.0.0'
+  s.required_ruby_version = '>= 3.0.0'
+
+  s.add_dependency 'activemodel'
+  s.add_dependency 'activesupport', '>= 6'
+  s.add_dependency 'dhc'
+  s.add_dependency 'local_uri'
+
+  s.add_development_dependency 'capybara'
+  s.add_development_dependency 'json', '>=  1.8.2'
+  s.add_development_dependency 'pry'
+  s.add_development_dependency 'pry-byebug'
+  s.add_development_dependency 'rails', '>= 6'
+  s.add_development_dependency 'rollbar', '<= 2.24.0'
+  s.add_development_dependency 'rspec-rails', '>= 3.7.0'
+  s.add_development_dependency 'rubocop'
+  s.add_development_dependency 'rubocop-rspec'
+  s.add_development_dependency 'sprockets', '< 4'
+  s.add_development_dependency 'webmock'
+  s.add_development_dependency 'webrick'
+
+  s.license = 'GPL-3.0'
+end

data/lib/dhs.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'dhc'
+
+module DHS
+  autoload :Configuration, 'dhs/concerns/configuration'
+  autoload :AutoloadRecords, 'dhs/concerns/autoload_records'
+  autoload :Collection, 'dhs/collection'
+  autoload :Complex, 'dhs/complex'
+  autoload :Config, 'dhs/config'
+  autoload :Data, 'dhs/data'
+  autoload :ExtendedRollbar, 'dhs/interceptors/extended_rollbar/interceptor'
+  autoload :Endpoint, 'dhs/endpoint'
+  autoload :Inspect, 'dhs/concerns/inspect'
+  module Interceptors
+    module AutoOauth
+      autoload :ThreadRegistry, 'dhs/interceptors/auto_oauth/thread_registry'
+      autoload :Interceptor, 'dhs/interceptors/auto_oauth/interceptor'
+    end
+
+    module RequestCycleCache
+      autoload :ThreadRegistry, 'dhs/interceptors/request_cycle_cache/thread_registry'
+      autoload :Interceptor, 'dhs/interceptors/request_cycle_cache/interceptor'
+    end
+
+    module ExtendedRollbar
+      autoload :ThreadRegistry, 'dhs/interceptors/extended_rollbar/thread_registry'
+      autoload :Interceptor, 'dhs/interceptors/extended_rollbar/interceptor'
+      autoload :Handler, 'dhs/interceptors/extended_rollbar/handler'
+    end
+  end
+  autoload :IsHref, 'dhs/concerns/is_href'
+  autoload :Item, 'dhs/item'
+  autoload :OAuth, 'dhs/concerns/o_auth.rb'
+  autoload :OptionBlocks, 'dhs/concerns/option_blocks'
+  autoload :Pagination, 'dhs/pagination/base'
+  module Pagination
+    autoload :Offset, 'dhs/pagination/offset'
+    autoload :Page, 'dhs/pagination/page'
+    autoload :TotalPages, 'dhs/pagination/total_pages'
+    autoload :Start, 'dhs/pagination/start'
+    autoload :Link, 'dhs/pagination/link'
+  end
+  autoload :Problems, 'dhs/problems/base'
+  module Problems
+    autoload :Base, 'dhs/problems/base'
+    autoload :Errors, 'dhs/problems/errors'
+    autoload :Nested, 'dhs/problems/nested/base'
+    module Nested
+      autoload :Base, 'dhs/problems/nested/base'
+      autoload :Errors, 'dhs/problems/nested/errors'
+      autoload :Warnings, 'dhs/problems/nested/warnings'
+    end
+    autoload :Warnings, 'dhs/problems/warnings'
+  end
+  autoload :Proxy, 'dhs/proxy'
+  autoload :Record, 'dhs/record'
+  autoload :Unprocessable, 'dhs/unprocessable'
+
+  include Configuration
+  include AutoloadRecords if defined?(Rails)
+  include OptionBlocks
+
+  require 'dhs/record' # as dhs records in an application are directly inheriting it
+
+  require 'dhs/railtie' if defined?(Rails)
+end

data/lib/dhs/collection.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# A collection is a special type of data
+# that contains multiple items
+class DHS::Collection < DHS::Proxy
+  autoload :HandleNested,
+    'dhs/concerns/collection/handle_nested'
+  autoload :InternalCollection,
+    'dhs/concerns/collection/internal_collection'
+
+  include HandleNested
+  include InternalCollection
+  include Create
+
+  METHOD_NAMES_EXLCUDED_FROM_WRAPPING = %w(to_a to_ary map).freeze
+
+  delegate :select, :length, :size, :insert, to: :_collection
+  delegate :_record, :_raw, to: :_data
+  delegate :limit, :count, :total, :offset, :current_page, :start,
+           :next?, :previous?, to: :_pagination
+
+  def _pagination
+    _record.pagination(_data)
+  end
+
+  def href
+    return _data._raw[:href] if _data._raw.is_a? Hash
+    nil
+  end
+
+  def _collection
+    @_collection ||= begin
+      raw = _data._raw if _data._raw.is_a?(Array)
+      raw ||= _data.access(input: _data._raw, record: _record)
+      Collection.new(raw, _data, _record)
+    end
+  end
+
+  def collection?
+    true
+  end
+
+  def item?
+    false
+  end
+
+  def raw_items
+    if _raw.is_a?(Array)
+      _raw
+    else
+      access(input: _raw, record: _record)
+    end
+  end
+
+  protected
+
+  def method_missing(name, *args, **keyword_args, &block)
+    if _collection.respond_to?(name)
+      value = _collection.send(name, *args, **keyword_args, &block)
+      record = DHS::Record.for_url(value[:href]) if value.is_a?(Hash) && value[:href]
+      record ||= _record
+      value = enclose_item_in_data(value) if value.is_a?(Hash)
+      return value if METHOD_NAMES_EXLCUDED_FROM_WRAPPING.include?(name.to_s)
+      wrap_return(value, record, name, args)
+    elsif _data._raw.is_a?(Hash)
+      get(name, *args, **keyword_args)
+    end
+  end
+
+  def respond_to_missing?(name, _include_all = false)
+    # We accept every message that does not belong to set of keywords and is not a setter
+    !BLACKLISTED_KEYWORDS.include?(name.to_s) && !name.to_s[/=$/]
+  end
+
+  private
+
+  # Encloses accessed collection item
+  # by wrapping it in an DHS::Item
+  def enclose_item_in_data(value)
+    data = DHS::Data.new(value, _data, _record)
+    item = DHS::Item.new(data)
+    DHS::Data.new(item, _data)
+  end
+end

data/lib/dhs/complex.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+# Complex is the main data structure for includes:
+# Can be for example :place, [:place, :customer],
+# [{ places: [:customer] }, { places: { customer: :contract }}]
+# and so on
+class DHS::Complex
+  attr_reader :data
+
+  def reduce!(data)
+    @data = if data.is_a?(DHS::Complex)
+      data.data
+    elsif data.is_a?(Array) && !data.empty?
+      data.inject(DHS::Complex.new.reduce!([])) { |acc, datum| acc.merge!(DHS::Complex.new.reduce!(datum)) }.data
+    elsif data.is_a?(Hash) && !data.empty?
+      data.map { |k, v| [k, DHS::Complex.new.reduce!(v)] }.to_h
+    else
+      data
+    end
+
+    self
+  end
+
+  def self.reduce(data)
+    new.reduce!(data).unwrap
+  end
+
+  def merge!(other)
+    if data.is_a?(Symbol)
+      merge_into_symbol!(other)
+    elsif data.is_a?(Array)
+      merge_into_array!(other)
+    elsif data.is_a?(Hash)
+      merge_into_hash!(other)
+    elsif unwrap != other.unwrap
+      raise ArgumentError, "Cannot merge #{unwrap} with #{other.unwrap}"
+    end
+
+    self
+  end
+
+  def unwrap
+    if data.is_a?(Array)
+      result = data.map(&:unwrap)
+      result.empty? ? nil : result
+    elsif data.is_a?(Hash)
+      result = data.map { |k, v| [k, v.unwrap] }.to_h
+      result.empty? ? nil : result
+    else
+      data
+    end
+  end
+
+  def ==(other)
+    unwrap == other.unwrap
+  end
+
+  private
+
+  def merge_into_array!(other)
+    if data.empty?
+      @data = other.data
+    elsif other.data.is_a?(Symbol)
+      merge_symbol_into_array!(other)
+    elsif other.data.is_a?(Array)
+      merge_array_into_array!(other)
+    elsif other.data.is_a?(Hash)
+      merge_hash_into_array!(other)
+    end
+  end
+
+  def merge_symbol_into_array!(other)
+    return if data.include?(other)
+    data.push(other)
+  end
+
+  def merge_array_into_array!(other)
+    @data = other.data.inject(self) { |acc, datum| acc.merge!(datum) }.data
+  end
+
+  def merge_hash_into_array!(other)
+    @data = [].tap do |new_data|
+      data.each do |element|
+        if element.data.is_a?(Symbol)
+          # remove keys that were in the hash
+          new_data << element unless other.data.key?(element.data)
+        elsif element.data.is_a?(Array)
+          new_data << element
+        elsif element.data.is_a?(Hash)
+          new_data << element.merge!(other)
+        end
+      end
+    end
+
+    # add it to the array if there was no hash to merge it
+    data.push(other) if data.none? { |element| element.data.is_a?(Hash) }
+  end
+
+  def merge_into_hash!(other)
+    if data.empty?
+      @data = other.data
+    elsif other.data.is_a?(Symbol)
+      merge_symbol_into_hash!(other)
+    elsif other.data.is_a?(Array)
+      merge_array_into_hash!(other)
+    elsif other.data.is_a?(Hash)
+      merge_hash_into_hash!(other)
+    end
+  end
+
+  def merge_symbol_into_hash!(other)
+    return if data.key?(other.data)
+
+    @data = [DHS::Complex.new.reduce!(data), other]
+  end
+
+  def merge_array_into_hash!(other)
+    @data = other.data.inject(self) { |acc, datum| acc.merge!(datum) }.data
+  end
+
+  def merge_hash_into_hash!(other)
+    other.data.each do |k, v|
+      data[k] = if data.key?(k)
+        data[k].merge!(v)
+      else
+        v
+      end
+    end
+  end
+
+  def merge_into_symbol!(other)
+    if other.data.is_a?(Symbol)
+      merge_symbol_into_symbol!(other)
+    elsif other.data.is_a?(Array)
+      merge_array_into_symbol!(other)
+    elsif other.data.is_a?(Hash)
+      merge_hash_into_symbol!(other)
+    end
+  end
+
+  def merge_symbol_into_symbol!(other)
+    return if other.data == data
+
+    @data = [DHS::Complex.new.reduce!(data), other]
+  end
+
+  def merge_array_into_symbol!(other)
+    @data = other.data.unshift(DHS::Complex.new.reduce!(data)).uniq { |a| a.unwrap }
+  end
+
+  def merge_hash_into_symbol!(other)
+    @data = if other.data.key?(data)
+      other.data
+    else
+      [DHS::Complex.new.reduce!(data), other]
+    end
+  end
+end

data/lib/dhs/concerns/autoload_records.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+# Preload all the DHS::Records that are defined in app/models/*
+# in order to collect record endpoints and to be able to identify records from hrefs
+# and not only from model constant names (which is different to ActiveRecord)
+module AutoloadRecords
+  extend ActiveSupport::Concern
+
+  included do
+    class Engine < Rails::Engine
+      initializer 'Load all DHS::Records from app/models/**' do |app|
+        Middleware.require_records
+        next if app.config.cache_classes
+
+        app.config.middleware.use Middleware
+      end
+
+      class Middleware
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          self.class.require_records
+          @app.call(env)
+        end
+
+        def self.model_files
+          Dir.glob(Rails.root.join('app', 'models', '**', '*.rb'))
+        end
+
+        def self.require_direct_inheritance
+          model_files.sort.map do |file|
+            next unless File.read(file).match('DHS::Record')
+            require_dependency file
+            file.split('models/').last.gsub('.rb', '').classify
+          end.compact
+        end
+
+        def self.require_inheriting_records(parents)
+          model_files.each do |file|
+            file_content = File.read(file)
+            next if parents.none? { |parent| file_content.match(/\b#{parent}\b/) }
+            next if file_content.match?('extend ActiveSupport::Concern')
+            require_dependency file
+          end
+        end
+
+        def self.require_records
+          require_inheriting_records(require_direct_inheritance)
+        end
+      end
+    end
+  end
+end

data/lib/dhs/concerns/collection/handle_nested.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class DHS::Collection < DHS::Proxy
+
+  # Handles pontentially (deep-)nested collections
+  #   Examples:
+  #     [ { name: 'Steve '} ]
+  #     { items: [ { name: 'Steve' } ] }
+  #     { response: { business: [ { name: 'Steve' } ] } }
+  module HandleNested
+    extend ActiveSupport::Concern
+
+    delegate :access, :nest, :concat, to: :class
+
+    module ClassMethods
+      # Access potentially nested collection of items
+      def access(input:, record: nil)
+        input.dig(*items_key(record))
+      end
+
+      # Initializes nested collection
+      def nest(input:, value: nil, record: nil)
+        input[items_key(record)] = value
+      end
+
+      # Concats existing nested collection of items
+      # with given items
+      def concat(input:, items:, record: nil)
+        input.dig(*items_key(record)).concat(items)
+      end
+
+      private
+
+      # Takes configured items key to access collection of items
+      # of falls back to the default key
+      def items_key(record)
+        record&.items_key || DHS::Record.items_key
+      end
+    end
+  end
+end