memory_model 0.0.2 → 0.1.0

data/lib/memory_model/base/fields/field_set.rb

@@ -0,0 +1,87 @@
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/core_ext/string'
+require 'set'
+
+module MemoryModel
+  class Base
+    module Fields
+      class FieldSet < Set
+
+        def [](name)
+          find { |f| f.name == name.to_sym }
+        end
+
+        def add(name, options={})
+          delete_if { |f| f == name }
+          self << Field.new(name, options)
+        end
+
+        def include?(name)
+          self[name].present?
+        end
+
+        def comparable
+          select(&:comparable?).map(&:to_sym)
+        end
+
+        def set_default_values(model, attributes={})
+          model.attributes = self.map(&:name).reduce(attributes.with_indifferent_access) do |hash, field|
+            hash[field] ||= fetch_default_value(model, field)
+            hash
+          end
+        end
+
+        def set_default_value(model, field)
+          model.write_attribute field, fetch_default_value(model, field)
+        end
+
+        def fetch_default_value(model, field)
+          default = self[field].default
+          send("fetch_value_using_#{default.class.name.underscore}", model, default)
+        rescue NoMethodError => e
+          raise ArgumentError, "#{default} must be a string, symbol, lambda or proc"
+        end
+
+        private
+
+        def fetch_value_using_proc(model, proc)
+          raise TypeError, 'value must be a Proc' unless proc.is_a? Proc
+          if proc.lambda? && proc.arity == 0
+            proc.call
+          elsif proc.arity < 1
+            model.instance_eval(&proc)
+          elsif proc.arity == 1
+            proc.yield model
+          else
+            raise ArgumentError, "#{proc} must have an arity of 0..1, got #{proc.arity}"
+          end
+        end
+
+        def fetch_value_using_string(model, string)
+          raise TypeError, 'value must be a String' unless string.is_a? String
+          string
+        end
+
+        def fetch_value_using_symbol(model, symbol)
+          raise TypeError, 'value must be a Symbol' unless symbol.is_a? Symbol
+          model.instance_eval(&symbol)
+        end
+
+        def fetch_value_using_nil_class(model, nil_object)
+          raise TypeError, 'value must be a NilClass' unless nil_object.is_a? NilClass
+          nil
+        end
+
+        def method_missing(m, *args, &block)
+          if to_a.respond_to? m
+            to_a.send m, *args, &block
+          else
+            super
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/memory_model/base/fields.rb

@@ -0,0 +1,49 @@
+require 'active_support/concern'
+require 'active_support/dependencies/autoload'
+require 'securerandom'
+
+module MemoryModel
+  class Base
+    module Fields
+
+      extend ConcernedInheritance
+      extend ActiveSupport::Concern
+      extend ActiveSupport::Autoload
+      include ActiveModel::AttributeMethods
+
+      autoload :FieldSet
+      autoload :Field
+
+      inherited do
+        instance_variable_set :@fields, baseclass.fields
+      end
+
+      module ClassMethods
+        def field(attr, options={})
+          define_attribute_method attr unless instance_method_already_implemented? attr
+          fields.add(attr.to_sym, options)
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{attr}
+              read_attribute :#{attr}
+            end
+
+            def #{attr}=(value)
+              write_attribute :#{attr}, value
+            end
+          RUBY
+        end
+
+        def fields
+          return nil if self == MemoryModel::Base
+          @fields ||= FieldSet.new
+        end
+
+      end
+
+      def fields
+        self.class.fields
+      end
+
+    end
+  end
+end

data/lib/memory_model/base/operations/comparisons.rb

@@ -0,0 +1,25 @@
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/hash_with_indifferent_access'
+
+module MemoryModel
+  class Base
+    module Operations
+      module Comparisons
+
+        def ==(other_object)
+          attributes.slice(*fields.comparable) ==
+            other_object.to_hash.with_indifferent_access.slice(*fields.comparable)
+        end
+
+        def !=(other_object)
+          !(self == other_object)
+        end
+
+        def ===(other_object)
+          other_object.kind_of?(self.class) && self == other_object
+        end
+
+      end
+    end
+  end
+end

data/lib/memory_model/base/operations.rb

@@ -0,0 +1,10 @@
+module MemoryModel
+  class Base
+    module Operations
+      extend ActiveSupport::Autoload
+
+      autoload :Comparisons
+
+    end
+  end
+end

data/lib/memory_model/base/persistence.rb

@@ -1,15 +1,17 @@
-module MemoryModel::Base::Persistence
+module MemoryModel
+  class Base
+    module Persistence
 
-  def persisted?
-    !!self.class.find(self.id)
-  rescue MemoryModel::RecordNotFoundError
-    false
-  end
+      def persisted?
+        !!self.class.find_by(_uuid_: self._uuid_)
+      end
 
-  alias :exists? :persisted?
+      alias :exists? :persisted?
 
-  def new_record?
-    !persisted?
-  end
+      def new_record?
+        !persisted?
+      end
 
-end
+    end
+  end
+end

data/lib/memory_model/base.rb

@@ -1,51 +1,66 @@
-require "concerned_inheritance"
+require 'concerned_inheritance'
 require 'active_support/core_ext/object'
 require 'active_support/core_ext/hash'
 require 'active_support/dependencies/autoload'
-require 'active_support/core_ext/hash/indifferent_access'
 require 'active_model'
 
-class MemoryModel::Base
-  extend ActiveSupport::Autoload
-  extend ConcernedInheritance
-
-  autoload :Fieldable
-  autoload :Collectable
-  autoload :Comparable
-  autoload :Actionable
-  autoload :Attributable
-  autoload :Versionable
-  autoload :Persistence
-
-  # Active Model Additions
-  extend ActiveModel::Callbacks
-  extend ActiveModel::Naming
-  extend ActiveModel::Translation
-  include ActiveModel::Conversion
-  include ActiveModel::MassAssignmentSecurity
-  include ActiveModel::Observing
-  include ActiveModel::Serialization
-  include ActiveModel::Validations
-
-  # Memory Model Additions
-  include Fieldable
-  include Collectable
-  include Comparable
-  include Actionable
-  include Attributable
-  include Versionable
-  include Persistence
-
-  # Active Model Callbacks
-  define_model_callbacks :initialize, only: [:after]
-
-  def initialize(attributes={ })
-    unless self.class.collection.is_a? MemoryModel::Collection
-      raise MemoryModel::InvalidCollectionError, "#{self.class} does not have an assigned collection"
+module MemoryModel
+
+  class InvalidCollectionError < Error ; end
+
+  class Base
+    extend ActiveSupport::Autoload
+    extend ConcernedInheritance
+
+    autoload :Fields
+    autoload :Collectible
+    autoload :Comparison
+    autoload :Actions
+    autoload :Attributes
+    autoload :Persistence
+    autoload :Operations
+    autoload :Conversion
+    autoload :AutoIncrement
+
+    # Active Model Additions
+    extend ActiveModel::Callbacks
+    extend ActiveModel::Naming
+    extend ActiveModel::Translation
+    include ActiveModel::Conversion
+    include ActiveModel::Serialization
+    include ActiveModel::Validations
+
+    # 3.2 Only Active Model Additions
+    if ActiveModel::VERSION::MAJOR < 4 || (ActiveModel::VERSION::MAJOR == 3 && ActiveModel::VERSION::MINOR > 2)
+      include ActiveModel::MassAssignmentSecurity
+      include ActiveModel::Observing
     end
-    @attributes = fields.default_values(self, attributes).with_indifferent_access
-    @deleted    = false
-    run_callbacks :initialize
-  end
 
+    # Memory Model Additions
+    include Fields
+    include Collectible
+    include Operations::Comparisons
+    include Actions
+    include Attributes
+    include Persistence
+    include Conversion
+    include AutoIncrement
+
+    # Active Model Callbacks
+    define_model_callbacks :initialize, only: [:after]
+
+    def initialize(attributes={})
+      unless self.class.collection.is_a? MemoryModel::Collection
+        raise MemoryModel::InvalidCollectionError, "#{self.class} does not have an assigned collection"
+      end
+      fields.set_default_values(self, attributes)
+      run_callbacks :initialize
+    end
+
+    def initialize_dup(other)
+      @attributes = other.attributes.dup
+      reset_incremented_fields!
+    end
+
+  end
 end

data/lib/memory_model/collection/finders.rb

@@ -0,0 +1,75 @@
+module MemoryModel
+
+  class RecordNotFoundError < Error;
+  end
+
+  class Collection
+    module Finders
+
+      def all
+        LoaderDelegate.new records
+      end
+
+      def count
+        _uuids_.count
+      end
+
+      def find(key)
+        read(key).load
+      rescue NoMethodError
+        raise RecordNotFoundError
+      end
+
+      def find_all(*ids)
+        read_all(*ids).map(&:load)
+      end
+
+      def find_by(hash)
+        where(hash).first
+      end
+
+      def find_or_initialize_by(hash)
+        find_by(hash) || model.new(hash)
+      end
+
+      def find_or_create_by(hash)
+        find_by(hash) || model.create(hash)
+      end
+
+      def find_or_create_by!(hash)
+        find_by(hash) || model.create!(hash)
+      end
+
+      def where(hash)
+        matched_ids = hash.symbolize_keys.reduce(_uuids_) do |array, (attr, value)|
+          records = if indexes.has_key?(attr)
+                      where_in_index(attr, value).compact.map(&:uuid)
+                    else
+                      where_in_all(attr, value).map(&:_uuid_)
+                    end
+          array & records
+        end
+        load_all(*matched_ids)
+      end
+
+      private
+
+      def _uuids_
+        indexes[:_uuid_].keys
+      end
+
+      def records
+        indexes[:_uuid_].values
+      end
+
+      def where_in_all(attr, value)
+        all.select { |record| record.read_attribute(attr) == value }
+      end
+
+      def where_in_index(attr, value)
+        indexes[attr].where value
+      end
+
+    end
+  end
+end

data/lib/memory_model/collection/index/multi.rb

@@ -0,0 +1,61 @@
+module MemoryModel
+  class Collection
+    class Index
+      class Multi < MemoryModel::Collection::Index
+
+        # `create` should implement creating a new record, raising an error if an item with the matching storage id already
+        # exists in the index.
+        def create(key, item)
+          insert_into_key(key, item)
+        end
+
+        # `update` should find a record in the collection by its storage_id, remove it, and add with the new value.
+        def update(key, item)
+          raise(RecordNotInIndexError, [self, item]) unless exists? item
+          delete(item)
+          create(key, item)
+        end
+
+        # `read` should find a record in the collection by its indexed_value, remove it, and add with the new value.
+        def read(key)
+          index[key].first
+        end
+
+        # `delete` should find a record in the collection by its indexed_value, and remove it.
+        def delete(key)
+          index.values.map { |refs| refs.delete key }
+        end
+
+        # `exists?` return whether or not an item with the given storage id exists.
+        def exists?(item)
+          index.values.any? { |refs| refs.has_key? item.uuid }
+        end
+
+        # `values` should return the values of the index
+        def values
+          index.values.map(&:values)
+        end
+
+        private
+
+        def where_using_default(matcher)
+          Array.wrap index[matcher].try(:values)
+        end
+
+        def where_using_proc(matcher)
+          index.slice(*index.keys.select(&matcher)).values.map(&:values).flatten
+        end
+
+        def where_using_regexp(matcher)
+          where_using_proc ->(key) { key =~ matcher }
+        end
+
+        def insert_into_key(key, item)
+          index[key]            ||= {}
+          index[key][item.uuid] = item
+        end
+
+      end
+    end
+  end
+end

data/lib/memory_model/collection/index/unique.rb

@@ -0,0 +1,79 @@
+module MemoryModel
+
+  class NilValueError < IndexError
+
+    def initialize(index)
+      super "`#{index.name}` cannot be nil"
+    end
+
+  end
+
+  class RecordNotUniqueError < IndexError
+
+    def initialize(args)
+      index, key = args
+      super "`#{index.name}` with `#{key}` already exists"
+    end
+
+  end
+
+  class Collection
+    class Index
+      class MemoryModel::Collection::Index::Unique < MemoryModel::Collection::Index
+
+        delegate :values_at, to: :index
+
+        # `create` should implement creating a new record, raising an error if an item with the matching storage id already
+        # exists in the index.
+        def create(key, item)
+          raise(NilValueError, self) if key.nil? && !options[:allow_nil]
+          raise(RecordNotUniqueError, [self, key]) if index.has_key?(key)
+          return if key.nil?
+          index[key] = item
+        end
+
+        # `update` should find a record in the collection by its storage_id, remove it, and add with the new value.
+        def update(key, item)
+          raise(RecordNotInIndexError, [self, item]) unless exists? item
+          delete(item.uuid)
+          create(key, item)
+        end
+
+        # `read` should find a record in the collection by its indexed_value, remove it, and add with the new value.
+        def read(key)
+          index[key]
+        end
+
+        # `delete` should find a record in the collection by its indexed_value, and remove it.
+        def delete(key)
+          index.delete_if { |k, value| key == value.uuid }
+        end
+
+        # `exists?` return whether or not an item with the given storage id exists.
+        def exists?(item)
+          index.any? { |key, value| item.uuid == value.uuid }
+        end
+
+        # `values` should return the values of the index
+        def values
+          index.values
+        end
+
+        private
+
+        def where_using_default(matcher)
+          [read(matcher)]
+        end
+
+        def where_using_proc(matcher)
+          index.values_at *index.keys.select(&matcher)
+        end
+
+        def where_using_regexp(matcher)
+          where_using_proc ->(key) { key =~ matcher }
+        end
+
+      end
+    end
+  end
+end

data/lib/memory_model/collection/index.rb

@@ -0,0 +1,86 @@
+module MemoryModel
+
+  class IndexError < Error
+  end
+
+  class InvalidWhereQuery < IndexError
+
+    def initialize(matcher_class)
+      super "Unable to perform a where with #{matcher_class}"
+    end
+
+  end
+
+  class RecordNotInIndexError < IndexError
+
+    def initialize(args)
+      item, index = args
+      super "record `#{item.uuid}` is missing from index `#{index.name}`"
+    end
+
+  end
+
+  class Collection
+    class Index
+      extend ActiveSupport::Autoload
+
+      autoload :Unique
+      autoload :Multi
+
+      attr_reader :name, :options, :index
+
+      delegate :clear, :keys, to: :index
+      delegate :count, to: :values
+
+      def initialize(name, options)
+        @name    = name
+        @options = options
+        @index   = {}
+      end
+
+      # This is the base index, each method below must be implemented on each subclass
+
+      # `create` should implement creating a new record, raising an error if an item with the matching storage id already
+      # exists in the index.
+      def create(key, item)
+        raise NotImplementedError, "#{__method__} has not been implemented for this #{name} index"
+      end
+
+      # `update` should find a record in the collection by its storage_id, remove it, and add with the new value.
+      def update(key, item)
+        raise NotImplementedError, "#{__method__} has not been implemented for this #{name} index"
+      end
+
+      # `read` should find a record in the collection by its indexed_value, remove it, and add with the new value.
+      def read(key)
+        raise NotImplementedError, "#{__method__} has not been implemented for this #{name} index"
+      end
+
+      # `delete` should find a record in the collection by its indexed_value, and remove it.
+      def delete(key)
+        raise NotImplementedError, "#{__method__} has not been implemented for this #{name} index"
+      end
+
+      # `exists?` return whether or not an item with the given storage id exists.
+      def exists?(item)
+        raise NotImplementedError, "#{__method__} has not been implemented for this #{name} index"
+      end
+
+      # `where` should allow me to specify complex arguments and return an array
+      def where(matcher)
+        matcher_class = matcher.class.name.underscore
+        send("where_using_#{matcher_class}", matcher)
+      rescue NoMethodError
+        respond_to?(:where_using_default, true) ? where_using_default(matcher) :
+          raise(InvalidWhereQuery, matcher_class)
+      end
+
+      # `values` should return the values of the index
+      def values
+        raise NotImplementedError, "#{__method__} has not been implemented for this #{name} index"
+      end
+
+    end
+  end
+end
+

data/lib/memory_model/collection/initializers.rb

@@ -0,0 +1,48 @@
+module MemoryModel
+  class Collection
+    module Initializers
+      extend ActiveSupport::Concern
+
+      def initialize(model)
+        @model = model
+        set_primary_key :_uuid_, default: nil
+      end
+
+      def add_index(name, options={})
+        type          = :unique if options.delete(:unique)
+        type          ||= options.delete(:type) || :multi
+        indexes[name] = Index.const_get(type.to_s.camelize).new(name, options)
+      rescue NameError => e
+        raise TypeError, "#{type.inspect} is not a valid index"
+      end
+
+      def indexes
+        @indexes ||= {}
+      end
+
+      def index_names
+        indexes.keys
+      end
+
+      def set_primary_key(key, options={})
+        if options[:auto_increment] != false && !options.has_key?(:default)
+          options[:auto_increment] = true
+        end
+        options[:comparable] ||= false
+        @model.field key, options
+        add_index key, type: :unique
+        @primary_key = key
+      end
+
+      module ClassMethods
+
+        def all
+          MemoryModel::Collection.instance_variable_get(:@all) ||
+            MemoryModel::Collection.instance_variable_set(:@all, [])
+        end
+
+      end
+
+    end
+  end
+end