memory_model 0.0.2 → 0.1.0

data/lib/memory_model/base/actionable.rb

@@ -1,95 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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/versionable.rb

@@ -1,17 +0,0 @@
-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/core_ext/object.rb

@@ -1,5 +0,0 @@
-class Object
-  def not_a?(klass)
-    !is_a?(klass)
-  end
-end

data/spec/memory_model/base/versionable_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe MemoryModel::Base::Versionable do
-
-  let(:model) do
-    Class.new(MemoryModel::Base)
-  end
-  let(:instance) do
-    model.new
-  end
-  before(:each) do
-    stub_const('MyModel', model)
-  end
-
-  describe '#versions' do
-    it 'should have a number of versions' do
-      10.times.each do |index|
-        instance.versions.size.should == index
-        instance.commit
-      end
-    end
-  end
-
-  describe '#version' do
-    it 'should be the latest version' do
-      3.times.each { instance.commit }
-      instance.version.should == instance.versions.keys.last
-    end
-  end
-
-end

data/spec/memory_model/core_ext/object_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-describe Object do
-
-  describe '#not_a?' do
-    it 'should be in the inverse of #is_a?' do
-      object = Hash.new
-      object.not_a?(Hash).should_not == object.is_a?(Hash)
-    end
-  end
-
-end