memory_model 0.0.2 → 0.1.0

data/lib/memory_model/collection/loader_delegate.rb

@@ -0,0 +1,63 @@
+require 'active_support/cache'
+require 'active_support/core_ext/module/delegation'
+
+module MemoryModel
+  class Collection
+    class LoaderDelegate < BasicObject
+      include ::Enumerable
+
+      class << self
+        def delegate_and_load(*methods)
+          methods.each do |method|
+            define_method method do |*args, &block|
+              @records.send(method, *args, &block).try(:load)
+            end
+          end
+        end
+
+        def cache
+          @cache ||= ::ActiveSupport::Cache.lookup_store :memory_store
+        end
+      end
+
+      delegate_and_load :first, :last, :sample
+      delegate :count, :size, :length, :present?, :blank?, to: :@records
+      delegate :to_s, :pretty_inspect, :inspect, to: :loaded_records
+
+      def initialize(records)
+        @records = records
+      end
+
+      def each(&block)
+        loaded_records.each(&block)
+      end
+
+      def kind_of?(klass)
+        klass == self.class
+      end
+
+      alias is_a? kind_of?
+
+      def methods
+        LoaderDelegate.ancestors.map(&:instance_methods).flatten.uniq
+      end
+
+      def class
+        LoaderDelegate
+      end
+
+      private
+
+      def loaded_records
+        LoaderDelegate.cache.fetch(records_digest) do
+          @records.map(&:load)
+        end
+      end
+
+      def records_digest
+        ::Digest::MD5.hexdigest @records.map(&:string).join
+      end
+
+    end
+  end
+end

data/lib/memory_model/collection/marshaled_record.rb

@@ -0,0 +1,23 @@
+module MemoryModel
+  class Collection
+    class MarshaledRecord
+
+      attr_reader :uuid, :string
+
+      def initialize(record)
+        @uuid   = record._uuid_
+        @string = Marshal.dump record
+        freeze
+      end
+
+      def load
+        Marshal.load @string
+      end
+
+      def ==(other_object)
+        uuid == other_object.try(:uuid)
+      end
+
+    end
+  end
+end

data/lib/memory_model/collection/operations.rb

@@ -0,0 +1,82 @@
+module MemoryModel
+  class Collection
+    module Operations
+
+      def clear
+        indexes.each { |name, index| index.clear }
+        GC.start
+        all
+      end
+
+      def read_all(*ids)
+        return [] if ids.blank?
+        indexes[primary_key].values_at(*ids).compact
+      end
+
+      def load_all(*uuids)
+        return [] if uuids.blank?
+        indexes[:_uuid_].values_at(*uuids).compact.map(&:load)
+      end
+
+      def create(item)
+        item._uuid_ = SecureRandom.uuid
+        transact item, operation: :create, rollback_with: :delete
+      end
+
+      def read(key)
+        indexes[primary_key].read(key)
+      end
+
+      def update(item)
+        transact item, operation: :update, rollback_with: :rollback
+      end
+
+      def delete(item)
+        transact item, operation: :delete
+      end
+
+      private
+
+      def transact(record, options={})
+        # Set up the index
+        successful_indexes = []
+
+        # Fetch the options
+        operation          = options[:operation] || :undefined
+        indexes            = options[:indexes] || self.indexes.values
+        rollback_operation = options[:rollback_with]
+
+        # Marshal the object
+        marshaled_record   = MarshaledRecord.new(record)
+
+        # Do the transaction
+        indexes.map do |index|
+          send("#{operation}_with_index", index, record, marshaled_record).tap do
+            successful_indexes << index
+          end
+        end
+      rescue Exception => e
+        transact(record, operation: rollback_operation, indexes: successful_indexes) if rollback_operation
+        raise e
+      end
+
+      ## Transactors
+      def create_with_index(index, record, marshaled_record)
+        index.create record.read_attribute(index.name), marshaled_record
+      end
+
+      def update_with_index(index, record, marshaled_record)
+        index.update record.read_attribute(index.name), marshaled_record
+      end
+
+      def rollback_with_index(index, record, marshaled_record)
+        index.update record.changed_attributes[index.name], marshaled_record
+      end
+
+      def delete_with_index(index, record, marshaled_record)
+        index.delete marshaled_record.uuid
+      end
+
+    end
+  end
+end

data/lib/memory_model/collection.rb

@@ -1,80 +1,25 @@
-class MemoryModel::Collection
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/dependencies/autoload'
 
-  class InvalidTypeError < StandardError;
-  end
-
-  class << self
-    attr_accessor :all
-  end
-
-  self.all = []
-
-  def initialize(model=Class.new)
-    @model   = model
-    @records = []
-    self.class.all << self
-  end
+module MemoryModel
+  class Collection
+    extend ActiveSupport::Autoload
 
-  def all
-    unique.reject(&:deleted?)
-  end
-
-  def deleted
-    unique.select(&:deleted?)
-  end
+    autoload :Index
+    autoload :MarshaledRecord
+    autoload :LoaderDelegate
+    autoload :Initializers
+    autoload :Finders
+    autoload :Operations
 
-  def find(id, options={ })
-    version        = options[:version] || 0
-    return_deleted = !!options[:deleted]
-    record         = sorted.select { |r| r.id == id }[version]
-    return nil unless record
-    if !record.deleted? || (return_deleted && record.deleted?)
-      record
-    else
-      raise MemoryModel::RecordNotFoundError
-    end
-  end
+    attr_reader :primary_key
 
-  def insert(record)
-    raise InvalidTypeError unless record.is_a? @model
-    record = record.dup
-    record.freeze unless record.frozen?
-    @records << record
-    self
-  end
+    include Finders
+    include Initializers
+    include Operations
 
-  alias :<< :insert
+    delegate *(LoaderDelegate.public_instance_methods - self.instance_methods), :size, :length, :inspect, to: :all
 
-  def inspect
-    self.all.inspect
   end
-
-  def records(dup = true)
-    if dup
-      @records.map do |record|
-        record.deleted? ? record : record.dup
-      end
-    else
-      @records
-    end
-  end
-
-  private
-
-  def method_missing(m, *args, &block)
-    all.respond_to?(m) ? all.send(m, *args, &block) : super
-  end
-
-  def respond_to_missing?(m, include_private=false)
-    all.respond_to?(m, include_private)
-  end
-
-  def sorted(records=self.records)
-    records.sort { |b, a| a.timestamp <=> b.timestamp }
-  end
-
-  def unique(records=self.records)
-    sorted(records).uniq(&:id)
-  end
-
-end
+end

data/lib/memory_model/version.rb

@@ -1,3 +1,3 @@
 module MemoryModel
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/lib/memory_model.rb

@@ -1,13 +1,13 @@
 require "memory_model/version"
-require "memory_model/core_ext/object"
+require "active_support/dependencies/autoload"
 
 module MemoryModel
-  autoload :Collection, 'memory_model/collection'
-  autoload :Base, 'memory_model/base'
+  extend ActiveSupport::Autoload
 
-  class InvalidCollectionError < StandardError ; end
-  class InvalidFieldError < StandardError ; end
-  class ReadonlyFieldError < StandardError ; end
-  class RecordNotFoundError < StandardError ; end
+  autoload :Collection
+  autoload :Base
+
+  class Error < StandardError ; end
+  class ReadonlyFieldError < Error ; end
 
 end

data/memory_model.gemspec

@@ -17,16 +17,21 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = %w{lib}
 
-  gem.add_dependency 'activemodel'
-  gem.add_dependency 'activesupport'
+  gem.add_dependency 'activemodel', '>= 3.2'
+  gem.add_dependency 'activesupport', '>= 3.2'
   gem.add_dependency 'concerned_inheritance'
-  gem.add_dependency 'ice_nine'
 
+  gem.add_development_dependency 'appraisal'
   gem.add_development_dependency 'guard-rspec'
+  gem.add_development_dependency 'guard-bundler'
   gem.add_development_dependency 'rb-fsevent'
   gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'simplecov'
   gem.add_development_dependency 'terminal-notifier-guard'
   gem.add_development_dependency 'test-unit'
+  gem.add_development_dependency 'coveralls'
+  gem.add_development_dependency 'pry'
+  gem.add_development_dependency 'colorize'
+  gem.add_development_dependency 'faker'
 
 end

data/spec/benchmark/benchmark.rb

@@ -0,0 +1,126 @@
+require 'bundler'
+Bundler.setup(:default)
+require 'memory_model'
+require 'colorize'
+require 'faker'
+
+class Foo < MemoryModel::Base
+
+  set_primary_key :id
+
+  field :first_name
+  field :last_name
+  field :email
+  field :age
+
+  add_index :last_name
+  add_index :first_name
+  add_index :email, unique: true, allow_nil: true
+
+end
+
+def benchmark_average(count, name = nil, options={}, &block)
+
+  nominal_range = options[:range] || (1.5..4)
+
+  puts '',
+       "Starting benchmark of #{name} on #{count} records",
+       '---------',
+       '| '.green + "< #{nominal_range.min}ms",
+       '| '.yellow + "#{nominal_range.to_s}ms",
+       '| '.red + "> #{nominal_range.max}ms",
+       '---------'
+  times = count.times.map do
+    options[:before_each].call if options[:before_each].is_a? Proc
+    st = Time.now
+    block.call
+    (Time.now - st).tap do |seconds|
+      milliseconds = seconds * 1000
+      color        = case milliseconds
+                     when 0..nominal_range.min
+                       :green
+                     when nominal_range
+                       :yellow
+                     else
+                       :red
+                     end
+      print '|'.colorize(color)
+    end
+  end
+  options[:after_all].call if options[:after_all].is_a? Proc
+  print "\n"
+  total                                 = times.reduce(:+)
+  shortest_milliseconds, shortest_index = times.map { |t| t * 1000 }.each_with_index.sort { |(timea, ia), (timeb, ib)| timea <=> timeb }.first
+  longest_milliseconds, longest_index   = times.map { |t| t * 1000 }.each_with_index.sort { |(timea, ia), (timeb, ib)| timea <=> timeb }.reverse.first
+  milliseconds_avg                      = (total / count) * 1000
+
+  color = case milliseconds_avg
+          when 0..nominal_range.min
+            :green
+          when nominal_range
+            :yellow
+          else
+            :red
+          end
+
+  puts '',
+       '------------------------------ BENCHMARK RESULTS ------------------------------',
+       '',
+       "when executing #{name}",
+       "#{count} times",
+       "executions took an average of #{milliseconds_avg} milliseconds".colorize(color),
+       "and a total of #{total.round(2)} seconds",
+       "shortest".green + " was execution ##{shortest_index} lasting #{shortest_milliseconds} milliseconds",
+       "longest".red + " was execution ##{longest_index} lasting #{longest_milliseconds} milliseconds",
+       '',
+       '###############################################################################'
+
+end
+
+def gather_attributes!
+  $attributes = { first_name: Faker::Name.first_name,
+                  last_name:  Faker::Name.last_name,
+                  age:        Random.rand(0..100),
+                  email:      "#{Faker::Lorem.word}_#{SecureRandom.hex(12)}@example.org"
+  }
+end
+
+def create_record!
+  Foo.create gather_attributes!
+end
+
+def clear!
+  Foo.clear
+end
+
+n = 2500
+
+## Creates
+
+# Benchmark Create
+benchmark_average(n, '.create', before_each: -> { gather_attributes! }, after_all: -> { clear! }) { Foo.create $attributes }
+
+## Reads
+
+# Benchmark Find
+require 'pry'
+benchmark_average(n, '.find', before_each: -> { create_record!; $id = Foo.sample.id }, after_all: -> { clear! }) { Foo.find($id) }
+
+# Benchmark Sample
+benchmark_average(n, '.sample', before_each: -> { create_record! }, after_all: -> { clear! }) { Foo.sample }
+
+# Benchmark Where (using index)
+benchmark_average(n, '.where (using index)', before_each: -> { create_record! }, after_all: -> { clear! }) { Foo.where(first_name: Faker::Name.first_name) }
+
+# Benchmark Where (using loading)
+benchmark_average(1000, '.where (using loading)', before_each: -> { create_record! }, after_all: -> { clear! }) { Foo.where(age: Random.rand(0..100)) }
+
+## Updates
+
+# Benchmark Update
+benchmark_average(n, '.update', before_each: -> { $record = create_record! }, after_all: -> { clear! }) { $record.save }
+
+## Deletes
+
+# Benchmark Delete
+benchmark_average(n, '.delete', before_each: -> { 2.times { create_record! } ; $record = Foo.sample }, after_all: -> { clear! }) { $record.delete }