cuprum-collections 0.1.0

data/lib/cuprum/collections/basic/commands/insert_one.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'stannum/constraints/types/hash_with_string_keys'
+
+require 'cuprum/collections/basic/command'
+require 'cuprum/collections/basic/commands'
+require 'cuprum/collections/errors/already_exists'
+
+module Cuprum::Collections::Basic::Commands
+  # Command for inserting an entity into the collection.
+  class InsertOne < Cuprum::Collections::Basic::Command
+    # @!method call(entity:)
+    #   Inserts the entity into the collection.
+    #
+    #   If the collection already includes an entity with the same primary key,
+    #   #call will fail and the collection will not be updated.
+    #
+    #   @param entity [Hash] The collection entity to persist.
+    #
+    #   @return [Cuprum::Result<Hash>] the persisted entity.
+    validate_parameters :call do
+      keyword :entity,
+        Stannum::Constraints::Types::HashWithStringKeys.new
+    end
+
+    private
+
+    def find_existing(entity:)
+      value = entity[primary_key_name.to_s]
+      index = data.index { |item| item[primary_key_name.to_s] == value }
+
+      return if index.nil?
+
+      error = Cuprum::Collections::Errors::AlreadyExists.new(
+        collection_name:    collection_name,
+        primary_key_name:   primary_key_name,
+        primary_key_values: value
+      )
+      failure(error)
+    end
+
+    def process(entity:)
+      step { find_existing(entity: entity) }
+
+      data << tools.hash_tools.deep_dup(entity)
+
+      entity
+    end
+  end
+end

data/lib/cuprum/collections/basic/commands/update_one.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'stannum/constraints/types/hash_with_string_keys'
+
+require 'cuprum/collections/basic/command'
+require 'cuprum/collections/basic/commands'
+require 'cuprum/collections/errors/not_found'
+
+module Cuprum::Collections::Basic::Commands
+  # Command for updating an entity in the collection.
+  class UpdateOne < Cuprum::Collections::Basic::Command
+    # @!method call(entity:)
+    #   Updates the entity in the collection.
+    #
+    #   If the collection does not already have an entity with the same primary
+    #   key, #call will fail and the collection will not be updated.
+    #
+    #   @param entity [Hash] The collection entity to persist.
+    #
+    #   @return [Cuprum::Result<Hash>] the persisted entity.
+    validate_parameters :call do
+      keyword :entity,
+        Stannum::Constraints::Types::HashWithStringKeys.new
+    end
+
+    private
+
+    def find_existing(entity:)
+      value = entity[primary_key_name.to_s]
+      index = data.index { |item| item[primary_key_name.to_s] == value }
+
+      return index unless index.nil?
+
+      error = Cuprum::Collections::Errors::NotFound.new(
+        collection_name:    collection_name,
+        primary_key_name:   primary_key_name,
+        primary_key_values: entity[primary_key_name.to_s]
+      )
+      failure(error)
+    end
+
+    def process(entity:)
+      index = step { find_existing(entity: entity) }
+
+      entity = data[index].merge(entity)
+
+      data[index] = entity.dup
+
+      entity
+    end
+  end
+end

data/lib/cuprum/collections/basic/commands/validate_one.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'stannum/constraints/types/hash_with_string_keys'
+
+require 'cuprum/collections/basic/command'
+require 'cuprum/collections/basic/commands'
+require 'cuprum/collections/errors/failed_validation'
+require 'cuprum/collections/errors/missing_default_contract'
+
+module Cuprum::Collections::Basic::Commands
+  # Command for validating a collection entity.
+  class ValidateOne < Cuprum::Collections::Basic::Command
+    # @!method call(entity:, contract: nil)
+    #   Validates the entity against the given or default contract.
+    #
+    #   If the entity matches the contract, #call will return a passing result
+    #   with the entity as the result value. If the entity does not match the
+    #   contract, #call will return a failing result with a FailedValidation
+    #   error and the validation errors.
+    #
+    #   @param contract [Stannum::Constraints:Base] The contract with which to
+    #     validate the entity. If not given, the entity will be validated using
+    #     the collection's default contract.
+    #   @param entity [Hash] The collection entity to validate.
+    #
+    #   @return [Cuprum::Result<Hash>] the validated entity.
+    validate_parameters :call do
+      keyword :contract,
+        Stannum::Constraints::Base,
+        optional: true
+      keyword :entity,
+        Stannum::Constraints::Types::HashWithStringKeys.new
+    end
+
+    private
+
+    def contract_or_default(contract:, entity:)
+      return contract if contract
+
+      return default_contract if default_contract
+
+      error = Cuprum::Collections::Errors::MissingDefaultContract.new(
+        entity_class: entity.class
+      )
+      failure(error)
+    end
+
+    def process(entity:, contract: nil)
+      contract =
+        step { contract_or_default(contract: contract, entity: entity) }
+
+      step { validate_entity(contract: contract, entity: entity) }
+
+      entity
+    end
+
+    def validate_entity(contract:, entity:)
+      valid, errors = contract.match(entity)
+
+      return if valid
+
+      error = Cuprum::Collections::Errors::FailedValidation.new(
+        entity_class: entity.class,
+        errors:       errors
+      )
+      failure(error)
+    end
+  end
+end

data/lib/cuprum/collections/basic/commands.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'cuprum/collections/basic'
+
+module Cuprum::Collections::Basic
+  # Namespace for commands implementing basic collection functionality.
+  module Commands
+    autoload :AssignOne,    'cuprum/collections/basic/commands/assign_one'
+    autoload :BuildOne,     'cuprum/collections/basic/commands/build_one'
+    autoload :DestroyOne,   'cuprum/collections/basic/commands/destroy_one'
+    autoload :FindMany,     'cuprum/collections/basic/commands/find_many'
+    autoload :FindMatching, 'cuprum/collections/basic/commands/find_matching'
+    autoload :FindOne,      'cuprum/collections/basic/commands/find_one'
+    autoload :InsertOne,    'cuprum/collections/basic/commands/insert_one'
+    autoload :UpdateOne,    'cuprum/collections/basic/commands/update_one'
+    autoload :ValidateOne,  'cuprum/collections/basic/commands/validate_one'
+  end
+end

data/lib/cuprum/collections/basic/query.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require 'cuprum/collections/basic'
+require 'cuprum/collections/basic/query_builder'
+require 'cuprum/collections/query'
+
+module Cuprum::Collections::Basic
+  # Concrete implementation of a Query for an in-memory collection.
+  class Query < Cuprum::Collections::Query
+    include Enumerable
+
+    # @param data [Array<Hash>] The current data in the collection. Should be an
+    #   Array of Hashes, each of which represents one item in the collection.
+    def initialize(data)
+      super()
+
+      @data    = data
+      @filters = []
+      @limit   = nil
+      @offset  = nil
+      @order   = {}
+    end
+
+    # Iterates through the collection, yielding each item matching the query.
+    #
+    # If the query has criteria, only items matching each criterion will be
+    # processed; these are the matching items. If the query does not have any
+    # criteria, all items in the collection will be processed.
+    #
+    # If the query has an ordering, the matching items are then sorted in the
+    # specified order. If the query does not have an order, the matching items
+    # will be processed in the order they appear in the collection.
+    #
+    # Finally, the limit and/or offset will be applied to the sorted matching
+    # items. Each sorted, matching item starting at the offset and up to the
+    # given limit of items will be yielded to the block.
+    #
+    # @overload each
+    #   @return [Enumerator] an enumerator that iterates over the sorted,
+    #     matching items within the given offset and limit.
+    #
+    # @overload each(&block)
+    #   @yield [Object] Each sorted, matching item within the given offset and
+    #     limit is yielded to the block.
+    #
+    # @see #limit
+    # @see #offset
+    # @see #order
+    # @see #to_a
+    # @see #where
+    def each(&block)
+      return enum_for(:each) unless block_given?
+
+      filtered_data.each(&block)
+    end
+
+    # Checks for the presence of collection items matching the query.
+    #
+    # If the query has criteria, then only items matching each criterion will be
+    # processed; these are the matching items. If there is at least one matching
+    # item, #exists will return true; otherwise, it will return false.
+    #
+    # @return [Boolean] true if any items match the query; otherwise false.
+    def exists?
+      data.any? do |item|
+        @filters.all? { |filter| filter.call(item) }
+      end
+    end
+
+    # Returns an array containing each collection item matching the query.
+    #
+    # If the query has criteria, only items matching each criterion will be
+    # processed; these are the matching items. If the query does not have any
+    # criteria, all items in the collection will be processed.
+    #
+    # If the query has an ordering, the matching items are then sorted in the
+    # specified order. If the query does not have an order, the matching items
+    # will be processed in the order they appear in the collection.
+    #
+    # Finally, the limit and/or offset will be applied to the sorted matching
+    # items. Each sorted, matching item starting at the offset and up to the
+    # given limit of items will be returned in the array.
+    #
+    # @return [Array] The sorted, matching items within the given offset and
+    #   limit.
+    #
+    # @see #each
+    # @see #limit
+    # @see #offset
+    # @see #order
+    # @see #where
+    def to_a
+      filtered_data
+    end
+
+    protected
+
+    def query_builder
+      Cuprum::Collections::Basic::QueryBuilder.new(self)
+    end
+
+    def reset!
+      @filtered_data = nil
+
+      self
+    end
+
+    def with_filters(filters)
+      @filters += filters
+
+      self
+    end
+
+    private
+
+    attr_reader :data
+
+    attr_reader :filters
+
+    def apply_filters(data)
+      data.select do |item|
+        @filters.all? { |filter| filter.call(item) }
+      end
+    end
+
+    def apply_limit_offset(data)
+      return data[@offset...(@offset + @limit)] || [] if @limit && @offset
+      return data[0...@limit] if @limit
+
+      return data[@offset..] || [] if @offset
+
+      data
+    end
+
+    def apply_order(data)
+      return data if @order.empty?
+
+      data.sort do |u, v|
+        @order.reduce(0) do |memo, (attribute, direction)|
+          next memo unless memo.zero?
+
+          attr_name = attribute.to_s
+
+          cmp = u[attr_name] <=> v[attr_name]
+
+          direction == :asc ? cmp : -cmp
+        end
+      end
+    end
+
+    def filtered_data
+      @filtered_data ||=
+        data
+          .yield_self { |ary| apply_filters(ary) }
+          .yield_self { |ary| apply_order(ary) }
+          .yield_self { |ary| apply_limit_offset(ary) }
+          .map(&:dup)
+    end
+  end
+end

data/lib/cuprum/collections/basic/query_builder.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'cuprum/collections/basic'
+require 'cuprum/collections/query_builder'
+
+module Cuprum::Collections::Basic
+  # Concrete implementation of QueryBuilder for a basic query.
+  class QueryBuilder < Cuprum::Collections::QueryBuilder
+    # @param base_query [Cuprum::Collections::Basic::Query] The original
+    #   query.
+    def initialize(base_query)
+      super
+
+      @filters = base_query.send(:filters)
+    end
+
+    private
+
+    attr_reader :filters
+
+    def build_filters(criteria)
+      criteria.map do |(attribute, operator, value)|
+        send(operator, attribute, value)
+      end
+    end
+
+    def build_query(criteria)
+      super.send(:with_filters, build_filters(criteria))
+    end
+
+    def equal(attribute, value)
+      ->(actual) { actual[attribute.to_s] == value }
+    end
+    alias eq equal
+
+    def greater_than(attribute, value)
+      ->(actual) { actual[attribute.to_s] > value }
+    end
+    alias gt greater_than
+
+    def greater_than_or_equal_to(attribute, value)
+      ->(actual) { actual[attribute.to_s] >= value }
+    end
+    alias gte greater_than_or_equal_to
+
+    def less_than(attribute, value)
+      ->(actual) { actual[attribute.to_s] < value }
+    end
+    alias lt less_than
+
+    def less_than_or_equal_to(attribute, value)
+      ->(actual) { actual[attribute.to_s] <= value }
+    end
+    alias lte less_than_or_equal_to
+
+    def not_equal(attribute, value)
+      ->(actual) { actual[attribute.to_s] != value }
+    end
+    alias ne not_equal
+
+    def not_one_of(attribute, value)
+      ->(actual) { !value.include?(actual[attribute.to_s]) }
+    end
+
+    def one_of(attribute, value)
+      ->(actual) { value.include?(actual[attribute.to_s]) }
+    end
+  end
+end