toystore 0.5

data/lib/toy/caching.rb

@@ -0,0 +1,20 @@
+module Toy
+  module Caching
+    extend ActiveSupport::Concern
+
+    module InstanceMethods
+      def cache_key(*suffixes)
+        cache_key = case
+                      when new_record?
+                        "#{self.class.name}:new"
+                      when timestamp = self[:updated_at]
+                        "#{self.class.name}:#{id}-#{timestamp.utc.to_s(:number)}"
+                      else
+                        "#{self.class.name}:#{id}"
+                    end
+        cache_key += ":#{suffixes.join(':')}" unless suffixes.empty?
+        cache_key
+      end
+    end
+  end
+end

data/lib/toy/callbacks.rb

@@ -0,0 +1,48 @@
+module Toy
+  module Callbacks
+    extend ActiveSupport::Concern
+    include ActiveSupport::Callbacks
+
+    included do
+      extend ActiveModel::Callbacks
+      define_model_callbacks :save, :create, :update, :destroy
+    end
+
+    module InstanceMethods
+      def save(*)
+        run_callbacks(:save) { super }
+      end
+
+      def destroy
+        run_callbacks(:destroy) { super }
+      end
+
+      def run_callbacks(callback, &block)
+        callback = :create if callback == :update && !persisted?
+
+        embedded_records = self.class.embedded_lists.keys.inject([]) do |records, key|
+          records += send(key).target
+        end
+
+        block = embedded_records.inject(block) do |chain, record|
+          if record.class.respond_to?("_#{callback}_callbacks")
+            lambda { record.run_callbacks(callback, &chain) }
+          else
+            chain
+          end
+        end
+        super callback, &block
+      end
+
+      private
+
+        def create
+          run_callbacks(:create) { super }
+        end
+
+        def update
+          run_callbacks(:update) { super }
+        end
+    end
+  end
+end

data/lib/toy/collection.rb

@@ -0,0 +1,55 @@
+module Toy
+  module Collection
+    extend ActiveSupport::Concern
+
+    included do
+      attr_accessor :model, :name, :options
+    end
+
+    def initialize(model, name, *args, &block)
+      @model   = model
+      @name    = name.to_sym
+      @options = args.extract_options!
+      @type    = args.shift
+
+      model.send(list_method)[name] = self
+
+      options[:extensions] = modularized_extensions(block, options[:extensions])
+      after_initialize
+    end
+
+    def type
+      @type ||= name.to_s.classify.constantize
+    end
+
+    def instance_variable
+      @instance_variable ||= :"@_#{name}"
+    end
+
+    def new_proxy(owner)
+      proxy_class.new(self, owner)
+    end
+
+    def extensions
+      options[:extensions]
+    end
+
+    def eql?(other)
+      self.class.eql?(other.class) &&
+        model == other.model &&
+        name  == other.name
+    end
+    alias :== :eql?
+
+    private
+      def proxy_class
+        raise('Not Implemented')
+      end
+
+      def modularized_extensions(*extensions)
+        extensions.flatten.compact.map do |extension|
+          Proc === extension ? Module.new(&extension) : extension
+        end
+      end
+  end
+end

data/lib/toy/connection.rb

@@ -0,0 +1,28 @@
+module Toy
+  module Connection
+    def logger
+      @@logger ||= init_default_logger
+    end
+
+    def logger=(logger)
+      @@logger = logger
+    end
+
+    def key_factory=(key_factory)
+      @@key_factory = key_factory
+    end
+
+    def key_factory
+      @@key_factory ||= Toy::Identity::UUIDKeyFactory.new
+    end
+
+    def init_default_logger
+      if Object.const_defined?("RAILS_DEFAULT_LOGGER")
+        @@logger = Object.const_get("RAILS_DEFAULT_LOGGER")
+      else
+        require 'logger'
+        @@logger = ::Logger.new(STDOUT)
+      end
+    end
+  end
+end

data/lib/toy/dirty.rb

@@ -0,0 +1,47 @@
+module Toy
+  module Dirty
+    extend ActiveSupport::Concern
+    include ActiveModel::Dirty
+
+    module InstanceMethods
+      def initialize(*)
+        super
+        if new_record?
+          # never register initial id assignment as a change
+          @changed_attributes.delete('id')
+        else
+          @previously_changed = {}
+          @changed_attributes.clear if @changed_attributes
+        end
+      end
+
+      def initialize_copy(*)
+        super.tap do
+          @previously_changed = {}
+          @changed_attributes = {}
+        end
+      end
+
+      def reload
+        super.tap do
+          @previously_changed = {}
+          @changed_attributes = {}
+        end
+      end
+
+      def save(*)
+        super.tap do
+          @previously_changed = changes
+          @changed_attributes.clear if @changed_attributes
+        end
+      end
+
+      def write_attribute(name, value)
+        name    = name.to_s
+        current = read_attribute(name)
+        attribute_will_change!(name) if current != value
+        super
+      end
+    end
+  end
+end

data/lib/toy/dolly.rb

@@ -0,0 +1,30 @@
+module Toy
+  module Dolly
+    extend ActiveSupport::Concern
+
+    def initialize_copy(other)
+      @_new_record = true
+      @_destroyed  = false
+      @attributes = {}.with_indifferent_access
+
+      self.class.embedded_lists.each do |name, list|
+        instance_variable_set(list.instance_variable, nil)
+      end
+
+      self.class.lists.each do |name, list|
+        instance_variable_set(list.instance_variable, nil)
+      end
+
+      other.attributes.except('id').each do |key, value|
+        value = value.duplicable? ? value.clone : value
+        send("#{key}=", value)
+      end
+
+      other.class.embedded_lists.keys.each do |name|
+        send("#{name}=", other.send(name).map(&:clone))
+      end
+
+      write_attribute(:id, self.class.next_key(self))
+    end
+  end
+end

data/lib/toy/embedded_list.rb

@@ -0,0 +1,45 @@
+require 'toy/proxies/embedded_list'
+
+module Toy
+  class EmbeddedList
+    include Toy::Collection
+
+    def after_initialize
+      create_accessors
+    end
+
+    private
+      def create_accessors
+        model.class_eval """
+          def #{name}
+            #{instance_variable} ||= self.class.#{list_method}[:#{name}].new_proxy(self)
+          end
+
+          def #{name}=(records)
+            #{name}.replace(records)
+          end
+
+          def #{name.to_s.singularize}_attributes=(attrs)
+            self.#{name} = attrs.map do |value|
+              value = value.is_a?(Hash) ? value : value[1]
+              #{type}.new(value)
+            end
+          end
+
+          def #{name.to_s.singularize}_attributes
+            #{name}.map(&:attributes)
+          end
+        """
+
+        type.class_eval { attr_accessor :parent_reference }
+      end
+
+      def proxy_class
+        Toy::Proxies::EmbeddedList
+      end
+
+      def list_method
+        :embedded_lists
+      end
+  end
+end

data/lib/toy/embedded_lists.rb

@@ -0,0 +1,68 @@
+module Toy
+  module EmbeddedLists
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def embedded_lists
+        @embedded_lists ||= {}
+      end
+
+      def embedded_list?(key)
+        embedded_lists.keys.include?(key.to_sym)
+      end
+
+      def parent_reference_module
+        @parent_reference_module ||= begin
+          mod = Module.new
+          include mod
+          mod
+        end
+      end
+
+      def parent_references
+        @parent_references ||= []
+      end
+
+      def parent_reference?(key)
+        parent_references.include?(key.to_sym)
+      end
+
+      def parent_reference(*names)
+        names.flatten.each do |name|
+          parent_references << name
+          parent_reference_module.module_eval <<-CODE
+            def #{name}
+              parent_reference
+            end
+
+            def #{name}?
+              parent_reference.present?
+            end
+          CODE
+        end
+      end
+
+      # @examples
+      #   list :moves                                   # assumes Move
+      #   list :moves, :dependent => true               # assumes Move
+      #   list :recent_moves, Move                      # uses Move
+      #   list :recent_moves, Move, :dependent => true  # uses Move
+      #
+      #   embedded_list :moves do
+      #     def recent
+      #       target.select { |t| t.recent? }
+      #     end
+      #   end
+      #
+      #   module RecentExtension
+      #     def recent
+      #       target.select { |t| t.recent? }
+      #     end
+      #   end
+      #   embedded_list :moves, :extensions => [RecentExtension]
+      def embedded_list(name, *args, &block)
+        EmbeddedList.new(self, name, *args, &block)
+      end
+    end
+  end
+end

data/lib/toy/equality.rb

@@ -0,0 +1,19 @@
+module Toy
+  module Equality
+    def eql?(other)
+      return true if self.class.eql?(other.class) && id == other.id
+      return true if other.respond_to?(:target) &&
+                     self.class.eql?(other.target.class) &&
+                     id == other.target.id
+      false
+    end
+    alias :== :eql?
+
+    def equal?(other)
+      if other.respond_to?(:proxy_respond_to?) && other.respond_to?(:target)
+        other = other.target
+      end
+      super other
+    end
+  end
+end

data/lib/toy/exceptions.rb

@@ -0,0 +1,29 @@
+module Toy
+  class Error < StandardError; end
+
+  class RecordInvalidError < Error
+    attr_reader :record
+    def initialize(record)
+      @record = record
+      super("Invalid record: #{@record.errors.full_messages.to_sentence}")
+    end
+  end
+
+  class NotFound < Error
+    def initialize(id)
+      super("Could not find document with id: #{id.inspect}")
+    end
+  end
+
+  class UndefinedLock < Error
+    def initialize(klass, name)
+      super("Undefined lock :#{name} for class #{klass.name}")
+    end
+  end
+
+  class AdapterNoLocky < Error
+    def initialize(adapter)
+      super("#{adapter.name.to_s.capitalize} adapter does not support locking")
+    end
+  end
+end

data/lib/toy/extensions/array.rb

@@ -0,0 +1,22 @@
+module Toy
+  module Extensions
+    module Array
+      def store_default
+        []
+      end
+
+      def to_store(value, *)
+        value = value.respond_to?(:lines) ? value.lines : value
+        value.to_a
+      end
+
+      def from_store(value, *)
+        value || store_default
+      end
+    end
+  end
+end
+
+class Array
+  extend Toy::Extensions::Array
+end

data/lib/toy/extensions/boolean.rb

@@ -0,0 +1,43 @@
+module Toy
+  module Extensions
+    module Boolean
+      Mapping = {
+        true    => true, 
+        'true'  => true, 
+        'TRUE'  => true, 
+        'True'  => true, 
+        't'     => true, 
+        'T'     => true, 
+        '1'     => true, 
+        1       => true, 
+        1.0     => true,
+        false   => false, 
+        'false' => false, 
+        'FALSE' => false, 
+        'False' => false, 
+        'f'     => false, 
+        'F'     => false, 
+        '0'     => false, 
+        0       => false, 
+        0.0     => false, 
+        nil     => nil
+      }
+
+      def to_store(value, *)
+        if value.is_a?(Boolean)
+          value
+        else
+          Mapping[value]
+        end
+      end
+
+      def from_store(value, *)
+        value.nil? ? nil : !!value
+      end
+    end
+  end
+end
+
+class Boolean
+  extend Toy::Extensions::Boolean
+end