lhs 24.0.0

data/lib/lhs/collection.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+# A collection is a special type of data
+# that contains multiple items
+class LHS::Collection < LHS::Proxy
+  autoload :HandleNested,
+    'lhs/concerns/collection/handle_nested'
+  autoload :InternalCollection,
+    'lhs/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, 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, &block)
+    if _collection.respond_to?(name)
+      value = _collection.send(name, *args, &block)
+      record = LHS::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)
+    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 LHS::Item
+  def enclose_item_in_data(value)
+    data = LHS::Data.new(value, _data, _record)
+    item = LHS::Item.new(data)
+    LHS::Data.new(item, _data)
+  end
+end

data/lib/lhs/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 LHS::Complex
+  attr_reader :data
+
+  def reduce!(data)
+    if data.is_a?(LHS::Complex)
+      @data = data.data
+    elsif data.is_a?(Array) && !data.empty?
+      @data = data.inject(LHS::Complex.new.reduce!([])) { |acc, datum| acc.merge!(LHS::Complex.new.reduce!(datum)) }.data
+    elsif data.is_a?(Hash) && !data.empty?
+      @data = data.map { |k, v| [k, LHS::Complex.new.reduce!(v)] }.to_h
+    else
+      @data = 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 if !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 = [LHS::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|
+      if data.key?(k)
+        data[k] = data[k].merge!(v)
+      else
+        data[k] = 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 = [LHS::Complex.new.reduce!(data), other]
+  end
+
+  def merge_array_into_symbol!(other)
+    @data = other.data.unshift(LHS::Complex.new.reduce!(data)).uniq { |a| a.unwrap }
+  end
+
+  def merge_hash_into_symbol!(other)
+    if other.data.key?(data)
+      @data = other.data
+    else
+      @data = [LHS::Complex.new.reduce!(data), other]
+    end
+  end
+end

data/lib/lhs/concerns/autoload_records.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+# Preload all the LHS::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 LHS::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.map do |file|
+            next unless File.read(file).match('LHS::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|
+            next if parents.none? { |parent| File.read(file).match(parent) }
+            require_dependency file
+          end
+        end
+
+        def self.require_records
+          require_inheriting_records(require_direct_inheritance)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class LHS::Collection < LHS::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 || LHS::Record.items_key
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class LHS::Collection < LHS::Proxy
+
+  module InternalCollection
+    extend ActiveSupport::Concern
+
+    # The internal collection class that includes enumerable
+    # and insures to return LHS::Items in case of iterating items
+    class Collection
+      include Enumerable
+
+      attr_accessor :raw
+      delegate :length, :size, :first, :last, :sample, :[], :present?, :blank?, :empty?,
+               :<<, :push, :compact, 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
+
+      private
+
+      def cast_item(item)
+        record_by_href = LHS::Record.for_url(item[:href]) if item[:href]
+        data = LHS::Data.new(item, @parent, @record)
+        return (record_by_href || @record).new(data) if record_by_href || @record
+        data
+      end
+    end
+  end
+end

data/lib/lhs/concerns/configuration.rb

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

data/lib/lhs/concerns/data/becomes.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class LHS::Data
+
+  module Becomes
+    extend ActiveSupport::Concern
+
+    def becomes(klass, options = {})
+      return self if self.class == klass && !is_a?(LHS::Data)
+      data = LHS::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/lhs/concerns/data/equality.rb

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