fixably 0.1.0

data/lib/fixably/active_resource/base.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module ActiveResource
+  class Base
+    class << self
+      private
+
+      alias original_instantiate_record instantiate_record
+
+      # Fixably uses camel case keys but it's more Ruby-like to use underscores
+      def instantiate_record(record, prefix_options = {})
+        underscored_record = record.deep_transform_keys(&:underscore)
+        original_instantiate_record(underscored_record, prefix_options)
+      end
+
+      alias original_query_string query_string
+
+      # Fixably expects all searches to be sent under a singular query parameter
+      # q=search1,search2,attribute:search3
+      def query_string(options)
+        opts = {}
+
+        non_query_parameters.each do
+          opts[_1] = options.fetch(_1) if options[_1]
+        end
+
+        f = filters(options)
+        opts[:q] = f.join(",") unless f.count.zero?
+
+        original_query_string(opts)
+      end
+
+      def filters(options)
+        options.each_with_object([]) do |(key, value), array|
+          next if non_query_parameters.include?(key)
+
+          array <<
+            if key.equal?(:filter)
+              value
+            else
+              camel_key = key.to_s.camelize(:lower)
+              "#{camel_key}:#{value}"
+            end
+        end
+      end
+
+      def non_query_parameters = %i[expand limit offset page]
+    end
+  end
+end
+
+ActiveResource::Base.collection_parser =
+  Fixably::ActiveResource::PaginatedCollection

data/lib/fixably/active_resource/paginated_collection.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require_relative "../create_has_many_record"
+
+module Fixably
+  module ActiveResource
+    class PaginatedCollection < ::ActiveResource::Collection
+      class << self
+        def paginatable?(value)
+          collection = attributes(value)
+          return false unless collection.is_a?(Hash)
+
+          interface = %w[limit offset total_items items]
+          (interface - collection.keys).empty?
+        end
+
+        def attributes(collection_wrapper)
+          if collection_wrapper.respond_to?(:attributes)
+            collection_wrapper.attributes
+          else
+            collection_wrapper
+          end
+        end
+      end
+
+      attr_reader :limit
+      attr_reader :offset
+      attr_reader :total_items
+
+      attr_accessor :parent_resource
+      attr_accessor :parent_association
+
+      def initialize(collection_wrapper = nil)
+        @limit = collection_wrapper&.fetch("limit") || 0
+        @offset = collection_wrapper&.fetch("offset") || 0
+        @total_items = collection_wrapper&.fetch("totalItems") do
+          collection_wrapper.fetch("total_items")
+        end || 0
+
+        collection = collection_wrapper&.fetch("items") || []
+        super(collection)
+      end
+
+      def <<(record)
+        CreateHasManyRecord.(record: record, collection: self)
+      end
+
+      def paginated_each
+        page = self
+
+        loop do
+          page.each { yield(_1) }
+          break unless page.next_page?
+
+          page = page.next_page
+        end
+      end
+
+      def paginated_map
+        [].tap do |records|
+          paginated_each { records << _1 }
+        end
+      end
+
+      def next_page
+        raise StopIteration, "There are no more pages" unless next_page?
+
+        where(limit: limit, offset: offset + limit)
+      end
+
+      def next_page?
+        (limit + offset) < total_items
+      end
+
+      def previous_page
+        raise StopIteration, "There are no more pages" unless previous_page?
+
+        new_offset = offset - limit
+        new_limit = limit
+        new_limit += new_offset if new_offset.negative?
+        new_offset = 0 if new_offset.negative?
+
+        where(limit: new_limit, offset: new_offset)
+      end
+
+      def previous_page?
+        offset.positive?
+      end
+    end
+  end
+end

data/lib/fixably/application_resource.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative "actions"
+require_relative "authorization"
+require_relative "encoding"
+require_relative "load_from_response"
+
+module Fixably
+  class ApplicationResource < ::ActiveResource::Base
+    self.include_format_in_path = false
+
+    include Actions
+    include Encoding
+    include LoadFromResponse
+    extend Authorization
+
+    attr_accessor :parent_association
+
+    class << self
+      def site
+        self.site = site_url unless _site_defined?
+        super()
+      end
+
+      protected
+
+      def site_url
+        subdomain = Fixably.config.require(:subdomain)
+        base_url = "https://#{subdomain}.fixably.com/api/#{api_version}"
+
+        name_parts = name.split("::")
+        return base_url if name_parts.length.equal?(2)
+
+        parent_resource = name_parts.fetch(1).underscore
+        "#{base_url}/#{parent_resource.pluralize}/:#{parent_resource}_id"
+      end
+
+      private
+
+      def api_version = "v3"
+    end
+
+    def initialize(attributes = {}, persisted = false) # rubocop:disable Style/OptionalBooleanParameter
+      super(attributes, persisted)
+
+      self.class.site
+    end
+  end
+end

data/lib/fixably/argument_parameterisation.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Fixably
+  module ArgumentParameterisation
+    private
+
+    def parametize_arguments(scope, arguments)
+      arguments ||= {}
+      arguments.merge!(arguments.delete(:params)) if arguments.key?(:params)
+
+      associations = expand_associations(scope, arguments)
+      arguments[:expand] = associations if associations
+
+      { params: arguments }
+    end
+
+    def expand_associations(scope, arguments)
+      return if arguments[:expand].instance_of?(String)
+
+      case scope
+      when :all, :first, :last
+        assoc = associations(arguments)&.join(",")
+        assoc ? "items(#{assoc})" : "items"
+      when :one, nil, Integer, String
+        associations(arguments)&.join(",")
+      else
+        raise ArgumentError, "Unknown scope: #{scope.inspect}"
+      end
+    end
+
+    def associations(arguments)
+      arguments[:expand]&.to_set { expand_association(_1) }
+    end
+
+    def expand_association(association)
+      relationship = reflections.fetch(association).macro
+      case relationship
+      when :has_one
+        association
+      when :has_many
+        "#{association}(items)"
+      else
+        raise ArgumentError, "Unknown relationship, #{relationship}"
+      end
+    end
+
+    def stringify_array_values(arguments)
+      arguments.tap do |args|
+        args.each do |attribute, value|
+          next unless value.is_a?(Array)
+
+          validate_array_value!(attribute, value)
+          value << nil if value.length.equal?(1)
+          args[attribute] = "[#{value.map { stringify(_1) }.join(",")}]"
+        end
+      end
+    end
+
+    def validate_array_value!(attribute, value)
+      return if value.length.positive? && value.length <= 2
+
+      raise(
+        ArgumentError,
+        "Ranged searches should have either 1 or 2 values but " \
+        "#{attribute} has #{value.length}"
+      )
+    end
+
+    def stringify(value)
+      if value.respond_to?(:strftime)
+        value.strftime("%F")
+      else
+        value
+      end
+    end
+  end
+end

data/lib/fixably/authorization.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Fixably
+  module Authorization
+    def headers
+      result = super()
+      result["Authorization"] = api_key
+      result
+    end
+
+    private
+
+    def api_key
+      Fixably.config.require(:api_key)
+    end
+  end
+end

data/lib/fixably/config.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative "logger"
+
+module Fixably
+  class Config
+    attr_accessor :api_key
+    attr_accessor :subdomain
+
+    def logger
+      Logger.logger
+    end
+
+    def logger=(log)
+      Logger.logger = log
+    end
+
+    def require(param)
+      value = public_send(param)
+      return value unless value.nil? || value.empty?
+
+      require_error(param)
+    end
+
+    private
+
+    def require_error(param)
+      raise(
+        ArgumentError,
+        <<~MESSAGE
+          #{param} is required but hasn't been set.
+          Fixably.configure do |config|
+            config.#{param} = "value"
+          end
+        MESSAGE
+      )
+    end
+  end
+end

data/lib/fixably/create_has_many_record.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module Fixably
+  class CreateHasManyRecord
+    def self.call(record:, collection:)
+      new(record: record, collection: collection).call
+    end
+
+    attr_reader :record
+    attr_reader :collection
+
+    def initialize(record:, collection:)
+      @record = record
+      @collection = collection
+    end
+
+    def call
+      can_append!
+      save_record
+      collection.elements << record
+    end
+
+    private
+
+    def can_append!
+      instance_of_resource_class!
+      nested_resource!
+      parent_recource_known!
+      parent_association_known!
+      parent_is_persisted!
+    end
+
+    def instance_of_resource_class!
+      return if record.instance_of?(collection.resource_class)
+
+      raise(
+        TypeError,
+        "Appended record must be an instance of " \
+        "#{collection.resource_class.name}"
+      )
+    end
+
+    def nested_resource!
+      return if nested_resource?
+
+      raise(
+        ArgumentError,
+        "Can only appended resources nested one level deep"
+      )
+    end
+
+    def nested_resource?
+      name_parts = record.class.name.split("::")
+      name_parts.length.equal?(3)
+    end
+
+    def parent_recource_known!
+      return if collection.parent_resource
+
+      raise "A parent resource has not been set"
+    end
+
+    def parent_association_known!
+      return if collection.parent_association
+
+      raise "The association to the parent resource has not been set"
+    end
+
+    def parent_is_persisted!
+      if !collection.parent_resource.persisted?
+        raise "The parent resource has not been been persisted"
+      end
+
+      if !collection.parent_resource.id?
+        raise "Cannot find an ID for the parent resource"
+      end
+    end
+
+    def save_record
+      record.parent_association = collection.parent_association
+      record.prefix_options[parent_id_key] = collection.parent_resource.id
+      record.save!
+    end
+
+    def parent_id_key
+      "#{collection.parent_resource.class.name.split("::").last.underscore}_id".
+        to_sym
+    end
+  end
+end

data/lib/fixably/encoding.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Fixably
+  module Encoding
+    # Since our monkey patch converts the keys to underscore, it is necessary to
+    # convert them back to camelcase when performing a create or update
+    def encode(_options = nil, attrs: nil)
+      attrs ||= attributes
+      remove_has_many_associations(attrs)
+      remove_unallowed_parameters(attrs)
+      nest_for_association(attrs).
+        deep_transform_keys { _1.camelize(:lower) }.
+        public_send("to_#{self.class.format.extension}")
+    end
+
+    protected
+
+    def remove_on_encode = %w[created_at href id]
+
+    private
+
+    def remove_has_many_associations(attrs)
+      reflections.select { _2.macro.equal?(:has_many) }.keys.each do
+        attrs.delete(_1)
+      end
+    end
+
+    def remove_unallowed_parameters(attrs)
+      remove_on_encode.each { attrs.delete(_1) }
+    end
+
+    def nest_for_association(attrs)
+      return attrs unless parent_association
+
+      { parent_association.to_s => [attrs] }
+    end
+  end
+end