memory_model 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - "1.9.3"
+  - jruby-19mode # JRuby in 1.9 mode
+# uncomment this line if your project needs to run something other than `rake`:
+script: bundle exec rspec

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in memory_model.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,5 @@
+guard 'rspec', after_all_pass: false, all_on_start: false, cli: '--profile' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Jason Waldrip
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+[![Build Status](https://travis-ci.org/jwaldrip/memory_model.png?branch=master)](https://travis-ci.org/jwaldrip/memory_model)
+
+# MemoryModel
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'memory_model'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install memory_model
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/concerned_inheritance/class_methods.rb

@@ -0,0 +1,28 @@
+module ConcernedInheritance::ClassMethods
+
+  def inherited_callbacks
+    (self.singleton_class.ancestors + self.ancestors).select do |ancestor|
+      ancestor.instance_variable_defined? :@inherited_callbacks
+    end.map do |ancestor|
+      ancestor.instance_variable_get :@inherited_callbacks
+    end.flatten
+  end
+
+  private
+
+  def inherited(subclass=nil, &block)
+    if subclass.nil?
+      define_inherited_callback(&block)
+    else
+      run_inherited_callbacks(subclass)
+      super(subclass)
+    end
+  end
+
+  def run_inherited_callbacks(subclass)
+    self.inherited_callbacks.each do |callback|
+      ConcernedInheritance::Delegator.new(self, subclass, callback)
+    end
+  end
+
+end

data/lib/concerned_inheritance/delegator.rb

@@ -0,0 +1,21 @@
+class ConcernedInheritance::Delegator < BasicObject
+
+  attr_reader :baseclass, :subclass
+
+  def initialize(baseclass, subclass, callback)
+    @baseclass = baseclass
+    @subclass  = subclass
+    if callback.not_a?(::Proc)
+      raise ::ArgumentError, "#{callback} must be a proc"
+    elsif (-1..0).cover?(callback.arity)
+      instance_eval(&callback)
+    else
+      raise ::ArgumentError, "#{callback} must have an arity of 0, got #{callback.arity}"
+    end
+  end
+
+  def method_missing(m, *args, &block)
+    subclass.send m, *args, &block
+  end
+
+end

data/lib/concerned_inheritance/module_methods.rb

@@ -0,0 +1,11 @@
+module ConcernedInheritance::ModuleMethods
+
+  def inherited_callbacks
+    @inherited_callbacks
+  end
+
+  def inherited(&block)
+    define_inherited_callback(&block)
+  end
+
+end

data/lib/concerned_inheritance.rb

@@ -0,0 +1,27 @@
+require 'active_support/concern'
+require 'active_support/core_ext/class/attribute'
+require 'active_support/dependencies/autoload'
+
+module ConcernedInheritance
+  extend ActiveSupport::Autoload
+
+  autoload :Delegator
+  autoload :ClassMethods
+  autoload :ModuleMethods
+
+  def self.extended(base)
+    case base
+    when Class
+      base.extend ClassMethods
+    when Module
+      base.extend ModuleMethods
+    end
+    base.instance_variable_set :@inherited_callbacks, [] unless base.instance_variable_defined? :@inherited_callbacks
+  end
+
+  def define_inherited_callback(&block)
+    raise ArgumentError, 'missing required block' unless block_given?
+    @inherited_callbacks += [block]
+  end
+
+end

data/lib/memory_model/base/actionable.rb

@@ -0,0 +1,95 @@
+require 'ice_nine'
+require 'ice_nine/core_ext/object'
+
+module MemoryModel::Base::Actionable
+  extend ActiveSupport::Concern
+
+  included do
+    define_model_callbacks :create, :update, :save, :destroy
+    attr_reader :timestamp
+  end
+
+  VALID_IVARS = [
+    :@deleted,
+    :@attributes,
+    :@timestamp,
+    :@version
+  ]
+
+  def commit
+    @timestamp = Time.now
+    @version   = SecureRandom.hex(6)
+    self.class.insert self
+    self
+  end
+
+  def delete
+    @deleted = true
+    commit
+    freeze
+  end
+
+  def deleted?
+    !!@deleted
+  end
+
+  def deleted_at
+    deleted? ? @timestamp : nil
+  end
+
+  def destroy
+    run_callbacks :destroy do
+      delete
+    end
+  end
+
+  def dup
+    deep_dup
+  end
+
+  def deep_dup
+    Marshal.load Marshal.dump self
+  end
+
+  def freeze
+    instance_variables.reject { |ivar| ivar.in? VALID_IVARS }.each do |ivar|
+      remove_instance_variable ivar if instance_variable_defined?(ivar)
+    end
+    instance_variables.each { |ivar| instance_variable_get(ivar).freeze }
+    deep_freeze
+    super
+  end
+
+  def save
+    callback = persisted? ? :update : :create
+    run_callbacks callback do
+      run_callbacks :save do
+        commit
+      end
+    end
+  end
+
+  def restore
+    instance = frozen? ? self.dup : self
+    instance.instance_variable_set :@deleted, false
+    instance.save
+    instance
+  end
+
+  module ClassMethods
+
+    def create(attributes={})
+      new(attributes).save
+    end
+
+    def delete_all
+      all.map(&:delete).reject(&:deleted?).empty?
+    end
+
+    def destroy_all
+      all.map(&:destroy).reject(&:deleted?).empty?
+    end
+
+  end
+
+end

data/lib/memory_model/base/attributable.rb

@@ -0,0 +1,76 @@
+module MemoryModel::Base::Attributable
+  extend ActiveSupport::Concern
+  include ActiveModel::AttributeMethods
+  include ActiveModel::Dirty
+
+  included do
+    attr_reader :attributes
+    delegate :to_hash, to: :attributes
+    attribute_method_affix :prefix => 'reset_', :suffix => '_to_default!'
+    attribute_method_prefix 'clear_'
+  end
+
+  def has_attribute?(key)
+    case value = @attributes[key]
+    when NilClass, String
+      !value.nil?
+    else
+      value.present?
+    end
+  end
+
+  def inspect
+    inspection = if @attributes
+                   fields.reduce([]) { |array, name|
+                     array << "#{name}: #{attribute_for_inspect(name)}" if has_attribute?(name)
+                     array
+                   }.join(", ")
+                 else
+                   "not initialized"
+                 end
+    "#<#{[self.class, inspection].join(' ')}>"
+  end
+
+  def read_attribute(name)
+    @attributes[name]
+  end
+
+  alias :[] :read_attribute
+
+  def write_attribute(name, value)
+    raise MemoryModel::InvalidFieldError,
+          "#{name} is not a valid field" unless fields.include? name
+    raise MemoryModel::FieldReadOnlyError,
+          "#{name} is read only" if fields[name].options[:readonly]
+
+    send "#{name}_will_change!" unless value == read_attribute(name) || new_record?
+    @attributes[name] = value
+  end
+
+  alias :[]= :write_attribute
+
+  protected
+
+  def attribute_for_inspect(attr_name)
+    value = read_attribute(attr_name)
+
+    if value.is_a?(String) && value.length > 50
+      "#{value[0..50]}...".inspect
+    elsif value.is_a?(Date) || value.is_a?(Time)
+      value.to_s
+    else
+      value.inspect
+    end
+  end
+
+  private
+
+  def reset_attribute_to_default!(attr)
+    write_attribute attr, fields.default_values(self).with_indifferent_access[attr]
+  end
+
+  def clear_attribute(attr)
+    write_attribute attr, nil
+  end
+
+end

data/lib/memory_model/base/collectable.rb

@@ -0,0 +1,22 @@
+require 'active_support/concern'
+
+module MemoryModel::Base::Collectable
+  extend ActiveSupport::Concern
+  extend ConcernedInheritance
+
+  inherited do
+    instance_variable_set :@collection, baseclass.collection
+  end
+
+  module ClassMethods
+    delegate :all, :find, :insert, :<<, :deleted, to: :collection
+    delegate :first, :last, to: :all
+
+    def collection
+      return nil if self == MemoryModel::Base
+      @collection ||= MemoryModel::Collection.new(self)
+    end
+
+  end
+
+end

data/lib/memory_model/base/comparable.rb

@@ -0,0 +1,16 @@
+module MemoryModel::Base::Comparable
+
+  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

data/lib/memory_model/base/fieldable/field.rb

@@ -0,0 +1,35 @@
+class MemoryModel::Base::Fieldable::Field
+
+  attr_reader :name, :options
+  delegate :inspect, to: :to_sym
+
+  def initialize(name, options={ })
+    @name    = name.to_sym
+    @options = options.reverse_merge!({ readonly: false, comparable: true })
+  end
+
+  def ==(other_object)
+    self.to_sym == other_object.to_sym
+  end
+
+  def comparable?
+    !!@options[:comparable]
+  end
+
+  def default
+    @options[:default]
+  end
+
+  def readonly?
+    !!@options[:readonly]
+  end
+
+  def to_sym
+    @name.to_sym
+  end
+
+  def to_s
+    @name.to_s
+  end
+
+end

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

@@ -0,0 +1,74 @@
+require 'active_support/core_ext/hash/keys'
+require 'set'
+
+class MemoryModel::Base::Fieldable::FieldSet
+
+  Field = MemoryModel::Base::Fieldable::Field
+
+  attr_reader :fields
+  delegate :include?, to: :fields
+
+  def initialize
+    @fields = []
+  end
+
+  def [](name)
+    @fields.find { |f| f.name == name.to_sym }
+  end
+
+  def <<(attr)
+    attr = Field.new(attr) unless attr.is_a? Field
+    @fields << attr
+  end
+
+  def add(attr, options={ })
+    @fields.delete_if { |f| f == attr }
+    @fields << Field.new(attr, options)
+  end
+
+  def comparable
+    @fields.select(&:comparable?).map(&:to_sym)
+  end
+
+  def inspect
+    to_a.inspect
+  end
+
+  def default_values(model, attributes={ })
+    @fields.reduce(attributes.symbolize_keys) do |attrs, field|
+      raise MemoryModel::ReadonlyFieldError if attrs[field.name].present? && field.readonly?
+      default           = field.default.is_a?(Symbol) ? field.default.to_proc : field.default
+      attrs[field.name] ||= if default.nil?
+                              nil
+                            elsif default.is_a? String
+                              default
+                            elsif default.not_a?(::Proc)
+                              raise ArgumentError, "#{default} must be a string, symbol, lamba or proc"
+                            elsif default.lambda? && default.arity == 0
+                              default.call
+                            elsif default.arity.in? -1..0
+                              model.instance_eval(&default)
+                            elsif default.arity == 1
+                              default.yield model
+                            else
+                              raise ArgumentError, "#{default} must have an arity of 0..1, got #{default.arity}"
+                            end
+      attrs
+    end
+  end
+
+  def to_a
+    @fields.map(&:to_sym)
+  end
+
+  private
+
+  def method_missing(m, *args, &block)
+    if to_a.respond_to? m
+      to_a.send m, *args, &block
+    else
+      super
+    end
+  end
+
+end

data/lib/memory_model/base/fieldable.rb

@@ -0,0 +1,45 @@
+require 'active_support/concern'
+require 'active_support/dependencies/autoload'
+require 'securerandom'
+
+module MemoryModel::Base::Fieldable
+  extend ConcernedInheritance
+  extend ActiveSupport::Concern
+  extend ActiveSupport::Autoload
+  include ActiveModel::AttributeMethods
+
+  autoload :FieldSet
+  autoload :Field
+
+  inherited do
+    instance_variable_set :@fields, baseclass.fields
+    field :id, readonly: true, default: -> { SecureRandom.uuid }, comparable: false
+  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

data/lib/memory_model/base/persistence.rb

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

data/lib/memory_model/base/versionable.rb

@@ -0,0 +1,17 @@
+module MemoryModel::Base::Versionable
+
+  def versions
+    instances = self.class.collection.records.select { |i| i.id == self.id }
+    instances.reduce({ }) do |hash, instance|
+      hash[instance.version] = instance
+      hash
+    end
+  end
+
+  def version
+    @version
+  end
+
+end
+
+# MemoryModel::Base::Immutable # todo!

data/lib/memory_model/base.rb

@@ -0,0 +1,51 @@
+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"
+    end
+    @attributes = fields.default_values(self, attributes).with_indifferent_access
+    @deleted    = false
+    run_callbacks :initialize
+  end
+
+end