lhs 24.0.0

data/lib/lhs/concerns/record/scope.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class LHS::Record
+
+  # Scopes allow you to reuse common where queries
+  module Scope
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def scope(name, block)
+        scopes[name] = block
+        define_singleton_method(name) do |*args|
+          block.call(*args)
+        end
+      end
+
+      def scopes
+        @scopes ||= {}
+        @scopes
+      end
+    end
+  end
+end

data/lib/lhs/concerns/record/tracing.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class LHS::Record
+
+  module Tracing
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Needs to be called directly from the first method (level) within LHS
+      def trace!(options = {})
+        return options unless LHS.config.trace
+
+        (options || {}).tap do |options|
+          source = caller.detect do |source|
+            !source.match?(%r{/lib/lhs})
+          end
+          options[:source] = source
+        end
+      end
+    end
+  end
+end

data/lib/lhs/concerns/record/update.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+class LHS::Record
+
+  module Update
+    extend ActiveSupport::Concern
+
+    included do
+      class <<self
+        alias_method :update, :create
+        alias_method :update!, :create!
+      end
+    end
+  end
+end

data/lib/lhs/config.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'singleton'
+
+class LHS::Config
+  include Singleton
+
+  attr_accessor :request_cycle_cache_enabled, :request_cycle_cache, :trace, :auto_oauth
+
+  def initialize
+    self.request_cycle_cache_enabled ||= true
+    self.trace ||= false
+    if defined?(ActiveSupport::Cache::MemoryStore)
+      self.request_cycle_cache ||= ActiveSupport::Cache::MemoryStore.new
+    end
+  end
+
+  def reset
+    self.request_cycle_cache_enabled = nil
+    self.trace = nil
+    self.request_cycle_cache = nil
+    initialize
+  end
+end

data/lib/lhs/data.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+# Data provides functionalities to accesses information
+class LHS::Data
+  autoload :Becomes,
+    'lhs/concerns/data/becomes'
+  autoload :Equality,
+    'lhs/concerns/data/equality'
+  autoload :Json,
+    'lhs/concerns/data/json'
+  autoload :ToHash,
+    'lhs/concerns/data/to_hash'
+
+  include Becomes
+  include Equality
+  include Json
+  include ToHash
+  include LHS::Inspect
+
+  delegate :instance_methods, :items_key, :limit_key, :total_key, :pagination_key, to: :class
+
+  # prevent clashing with attributes of underlying data
+  attr_accessor :_proxy, :_parent, :_record, :_request, :_endpoint
+  attr_reader :_raw
+
+  def initialize(input, parent = nil, record = nil, request = nil, endpoint = nil)
+    self._raw = raw_from_input(input)
+    self._parent = parent
+    self._record = record
+    self._proxy = proxy_from_input(input)
+    self._request = request
+    self._endpoint = endpoint
+  end
+
+  # merging data
+  # e.g. when loading remote data via link
+  def merge_raw!(data)
+    return false if data.blank? || !data._raw.is_a?(Hash)
+    _raw.merge! data._raw
+  end
+
+  # Unwraps data for certain use cases
+  # like items_created_key for CREATE, UPDATED etc.
+  # like item_key for GET etc.
+  def unwrap(usecase)
+    nested_path = record.send(usecase) if record
+    return LHS::Data.new(dig(*nested_path) || _raw, nil, self.class) if nested_path
+    self
+  end
+
+  def _root
+    root = self
+    root = root._parent while root&._parent
+    root
+  end
+
+  def parent
+    if _parent&._record
+      _parent._record.new(_parent, false)
+    else
+      _parent
+    end
+  end
+
+  def class
+    _record || _root._record
+  end
+
+  # enforce internal data structure to have deep symbolized keys
+  def _raw=(raw)
+    raw.to_hash.deep_symbolize_keys! if raw&.respond_to?(:to_hash)
+    @_raw = raw
+  end
+
+  def root_item?
+    root_item == self
+  end
+
+  def collection?
+    _proxy.is_a? LHS::Collection
+  end
+
+  def item?
+    _proxy.is_a? LHS::Item
+  end
+
+  protected
+
+  def method_missing(name, *args, &block)
+    _proxy.send(name, *args, &block)
+  end
+
+  def respond_to_missing?(name, include_all = false)
+    (root_item? && instance_methods.include?(name)) ||
+      _proxy.respond_to?(name, include_all)
+  end
+
+  private
+
+  def collection_proxy?(input)
+    (input.is_a?(Hash) && LHS::Collection.access(input: input, record: _record)) ||
+      input.is_a?(Array) ||
+      _raw.is_a?(Array)
+  end
+
+  def root_item
+    return if _proxy.class != LHS::Item
+    root = root_item = self
+    loop do
+      root = root._parent
+      root_item = root if root && root._proxy.is_a?(LHS::Item)
+      if !(root && root._parent)
+        break
+      end
+    end
+    root_item
+  end
+
+  def root?
+    _root == self
+  end
+
+  def proxy_from_input(input)
+    if input.is_a? LHS::Proxy
+      input
+    elsif collection_proxy?(raw_from_input(input))
+      LHS::Collection.new(self)
+    else
+      LHS::Item.new(self)
+    end
+  end
+
+  def raw_from_input(input)
+    if json?(input)
+      raw_from_json_string(input)
+    elsif defined?(input._raw)
+      input._raw
+    elsif defined?(input._data)
+      input._data._raw
+    else
+      raw_from_anything_else(input)
+    end
+  end
+
+  def json?(input)
+    input.is_a?(String) && !input.empty? && !!input.match(/^("|\[|'|\{)/)
+  end
+
+  def raw_from_json_string(input)
+    json = JSON.parse(input)
+    if json.is_a?(Hash)
+      json.deep_symbolize_keys
+    elsif json.is_a?(Array)
+      json.map { |item| item.is_a?(Hash) ? item.deep_symbolize_keys : item }
+    else
+      json
+    end
+  end
+
+  def raw_from_anything_else(input)
+    input = input.to_hash if input.class != Hash && input.respond_to?(:to_hash)
+    input.deep_symbolize_keys! if input.is_a?(Hash)
+    input
+  end
+end

data/lib/lhs/endpoint.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# An endpoint is used as source to fetch objects
+class LHS::Endpoint
+
+  def self.for_url(url)
+    template, record = LHS::Record::Endpoints.all.dup.detect do |template, _record|
+      LHC::Endpoint.match?(url, template)
+    end
+    record&.endpoints&.detect { |endpoint| endpoint.url == template }
+  end
+end

data/lib/lhs/interceptors/auto_oauth/interceptor.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+module LHS
+  module Interceptors
+    module AutoOauth
+      extend ActiveSupport::Concern
+
+      class Interceptor < LHC::Interceptor
+
+        def before_request
+          request.options[:auth] = { bearer: token }
+        end
+
+        def tokens
+          @tokens ||= LHS::Interceptors::AutoOauth::ThreadRegistry.access_token
+        end
+
+        def token
+          if tokens.is_a?(Hash)
+            tokens.dig(
+              request.options[:oauth] ||
+              request.options[:record]&.auto_oauth
+            )
+          else
+            tokens
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lhs/interceptors/auto_oauth/thread_registry.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/per_thread_registry'
+
+module LHS
+  module Interceptors
+    module AutoOauth
+      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 :access_token
+      end
+    end
+  end
+end

data/lib/lhs/interceptors/extended_rollbar/handler.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module LHS
+  module Interceptors
+    module ExtendedRollbar
+      class Handler
+
+        def self.init
+          proc do |options|
+            # as handlers cant influence what actually is reported to rollbar
+            # this just makes sure that Rollbar is already loaded when this class is loaded,
+            # so that we can extend rollbar loging
+          end
+        end
+
+        module ExtendedLogging
+          def log(level, *args)
+            args[2] = {} if args[2].nil?
+            args[2][:lhs] = LHS::Interceptors::ExtendedRollbar::ThreadRegistry.log.map do |entry|
+              {
+                request: entry[:request].options,
+                response: {
+                  code: entry[:response].code,
+                  body: entry[:response].body
+                }
+              }
+            end.to_json
+            super
+          end
+        end
+
+        module ::Rollbar
+          class Notifier
+            prepend LHS::Interceptors::ExtendedRollbar::Handler::ExtendedLogging
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lhs/interceptors/extended_rollbar/interceptor.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+module LHS
+  module Interceptors
+    module ExtendedRollbar
+      extend ActiveSupport::Concern
+
+      class Interceptor < LHC::Interceptor
+        def after_response
+          return unless LHS::Interceptors::ExtendedRollbar::ThreadRegistry.log
+          LHS::Interceptors::ExtendedRollbar::ThreadRegistry.log.push(request: request, response: response)
+        end
+      end
+    end
+  end
+
+  const_set('ExtendedRollbar', LHS::Interceptors::ExtendedRollbar::Interceptor)
+end

data/lib/lhs/interceptors/extended_rollbar/thread_registry.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'active_support'
+require 'active_support/per_thread_registry'
+
+module LHS
+  module Interceptors
+    module ExtendedRollbar
+      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 :log
+      end
+    end
+  end
+end

data/lib/lhs/interceptors/request_cycle_cache/interceptor.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'active_support'
+
+module LHS
+  module Interceptors
+    module RequestCycleCache
+      extend ActiveSupport::Concern
+
+      class Interceptor < LHC::Interceptor
+
+        VERSION = 1
+        CACHED_METHODS = [:get].freeze
+
+        def before_request
+          request.options = {
+            cache: {
+              expires_in: 5.minutes,
+              race_condition_ttl: 5.seconds,
+              key: cache_key_for(request),
+              methods: CACHED_METHODS,
+              use: LHS.config.request_cycle_cache
+            }
+          }.merge(request.options)
+        end
+
+        private
+
+        def cache_key_for(request)
+          [
+            "LHS_REQUEST_CYCLE_CACHE(v#{VERSION})",
+            request.method.upcase,
+            [request.url, request.params.presence].compact.join('?'),
+            "REQUEST=#{LHS::Interceptors::RequestCycleCache::ThreadRegistry.request_id}",
+            "HEADERS=#{request.headers.hash}"
+          ].join(' ')
+        end
+      end
+    end
+  end
+end