dhs 1.0.0

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

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class DHS::Collection < DHS::Proxy
+
+  module InternalCollection
+    extend ActiveSupport::Concern
+
+    # The internal collection class that includes enumerable
+    # and insures to return DHS::Items in case of iterating items
+    class Collection
+      include Enumerable
+
+      attr_accessor :raw
+
+      delegate :length, :size, :first, :last, :sample, :[], :present?, :blank?, :empty?,
+               :<<, :push, :insert, to: :raw
+
+      def initialize(raw, parent, record)
+        self.raw = raw
+        @parent = parent
+        @record = record
+      end
+
+      def to_ary
+        map { |item| item }
+      end
+
+      def each(&_block)
+        raw.each do |item|
+          if item.is_a? Hash
+            yield cast_item(item)
+          else
+            yield item
+          end
+        end
+      end
+
+      def compact
+        dup.tap do |collection|
+          collection.compact! if collection.raw.present?
+        end.as_json # do not return an internal collection!
+      end
+
+      def compact!
+        self.raw = raw.map do |item|
+          if item.is_a?(DHS::Data) && item._request && !item._request.response.success?
+            nil
+          else
+            cast_item(item)
+          end
+        end.compact
+      end
+
+      private
+
+      def cast_item(item)
+        data = DHS::Data.new(item, @parent, @record)
+        (record_by_href(item) || @record)&.new(data) || data
+      end
+
+      def record_by_href(item)
+        return if plain_value?(item) || item[:href].blank?
+
+        DHS::Record.for_url(item[:href])
+      end
+
+      def plain_value?(item)
+        item.is_a?(String) || item.is_a?(Numeric) || item.is_a?(TrueClass) || item.is_a?(FalseClass)
+      end
+    end
+  end
+end

data/lib/dhs/concerns/configuration.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+module DHS
+  module Configuration
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def config
+        DHS::Config.instance
+      end
+
+      def configure
+        DHS::Config.instance.reset
+        yield config
+      end
+    end
+  end
+end

data/lib/dhs/concerns/data/becomes.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class DHS::Data
+
+  module Becomes
+    extend ActiveSupport::Concern
+
+    def becomes(klass, options = {})
+      return self if self.instance_of?(klass) && !is_a?(DHS::Data)
+      data = DHS::Data.new(_raw, _parent, klass)
+      data.errors = options[:errors] if options[:errors]
+      data.warnings = options[:warnings] if options[:warnings]
+      klass.new(data)
+    end
+  end
+end

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

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

data/lib/dhs/concerns/data/extend.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class DHS::Data
+
+  module Extend
+    extend ActiveSupport::Concern
+
+    # Extends already fetched data (self) with additionally
+    # fetched data (addition) using the given key
+    def extend!(addition, key = nil)
+      addition = cast_relation_class_for_extension(addition, key)
+      if collection?
+        extend_collection!(addition, key)
+      elsif _raw.is_a?(Array) || self[key]._raw.is_a?(Array)
+        extend_array!(addition, key)
+      elsif item?
+        extend_item!(addition, key)
+      end
+    end
+
+    private
+
+    def cast_relation_class_for_extension(addition, key = nil)
+      return addition if _record.nil? || key.nil? || _record._relations.nil? || _record._relations[key].nil?
+      addition.becomes(_record._relations[key][:record_class_name].constantize, errors: addition.errors, warnings: addition.warnings)
+    end
+
+    def extend_collection!(addition, key = nil)
+      map do |item|
+        item_raw = key ? item._raw[key] : item._raw
+        item_raw.blank? ? [nil] : item_raw
+      end
+        .flatten
+        .each_with_index do |item, index|
+          item_addition = addition[index]
+          next if item_addition.nil? || item.nil?
+          if item_addition._raw.is_a?(Array)
+            item[items_key] ||= []
+            item[items_key].concat(item_addition._raw)
+          else
+            item.merge! item_addition._raw
+          end
+        end
+    end
+
+    def extend_array!(addition, key = nil)
+      (key ? self[key] : self).zip(addition) do |item, additional_item|
+        item._raw.merge!(additional_item._raw) if additional_item.present?
+      end
+    end
+
+    def extend_item!(addition, key = nil)
+      return if addition.nil?
+      if addition.collection?
+        extend_item_with_collection!(addition, key)
+      else # simple case merges hash into hash
+        (key ? _raw[key.to_sym] : _raw).merge!(addition._raw)
+      end
+    end
+
+    def extend_item_with_collection!(addition, key = nil)
+      target = (key ? self[key] : self)
+      if target._raw.is_a? Array
+        self[key] = addition.map(&:_raw) if key
+      else # hash with items
+        extend_item_with_hash_containing_items!(target, addition)
+      end
+    end
+
+    def extend_item_with_hash_containing_items!(target, addition)
+      DHS::Collection.nest(input: target._raw, value: [], record: self) # inits the nested collection
+      if DHS::Collection.access(input: target._raw, record: self).empty?
+        DHS::Collection.nest(
+          input: target._raw,
+          value: addition.reject { |item| item.nil? },
+          record: self
+        )
+      else
+        DHS::Collection.access(input: target._raw, record: self).each_with_index do |item, index|
+          item.merge!(addition[index])
+        end
+      end
+    end
+  end
+end

data/lib/dhs/concerns/data/json.rb

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

data/lib/dhs/concerns/data/to_hash.rb

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

data/lib/dhs/concerns/inspect.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+module DHS
+  module Inspect
+    extend ActiveSupport::Concern
+
+    def inspect
+      [
+        [
+          [
+            [
+              to_s.match('DHS::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/dhs/concerns/is_href.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+module DHS
+  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/dhs/concerns/item/destroy.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class DHS::Item < DHS::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/dhs/concerns/item/endpoint_lookup.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class DHS::Item < DHS::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/dhs/concerns/item/save.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class DHS::Item < DHS::Proxy
+  autoload :EndpointLookup,
+    'dhs/concerns/item/endpoint_lookup'
+
+  module Save
+    extend ActiveSupport::Concern
+
+    included do
+      include EndpointLookup
+    end
+
+    def save(options = nil)
+      save!(options)
+    rescue DHC::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 DHC::Error => e
+      self.errors = DHS::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