toystore 0.5

data/lib/toy/proxies/proxy.rb

@@ -0,0 +1,59 @@
+module Toy
+  module Proxies
+    class Proxy
+      include Enumerable
+      extend  Forwardable
+
+      def_delegator :@list, :type,    :proxy_class
+      def_delegator :@list, :key,     :proxy_key
+      def_delegator :@list, :options, :proxy_options
+
+      alias :proxy_respond_to? :respond_to?
+      alias :proxy_extend :extend
+
+      instance_methods.each { |m| undef_method m unless m.to_s =~ /^(?:nil\?|send|object_id|to_a)$|^__|proxy_/ }
+
+      def initialize(list, owner)
+        @list, @owner = list, owner
+        list.extensions.each { |extension| proxy_extend(extension) }
+      end
+
+      def proxy_owner
+        @owner
+      end
+
+      def each
+        target.each { |i| yield(i) }
+      end
+
+      def eql?(other)
+        target == other
+      end
+      alias :== :eql?
+
+      def target
+        @target ||= find_target
+      end
+      alias :to_a :target
+
+      def assert_type(record)
+        unless record.is_a?(proxy_class)
+          raise(ArgumentError, "#{proxy_class} expected, but was #{record.class}")
+        end
+      end
+
+      def respond_to?(*args)
+        proxy_respond_to?(*args) || target.respond_to?(*args)
+      end
+
+      private
+        def find_target
+          raise('Not Implemented')
+        end
+
+        def method_missing(method, *args, &block)
+          target.send(method, *args, &block)
+        end
+    end
+  end
+end

data/lib/toy/querying.rb

@@ -0,0 +1,57 @@
+module Toy
+  module Querying
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def get(id)
+        key = store_key(id)
+
+        if has_cache?
+          value = cache.read(key)
+          log_operation('RTG', cache, key, value)
+        end
+
+        if value.nil?
+          value = store.read(key)
+          log_operation('GET', store, key, value)
+
+          if has_cache?
+            cache.write(key, value)
+            log_operation('RTS', cache, key, value)
+          end
+        end
+
+        load(value)
+      end
+
+      def get!(id)
+        get(id) || raise(Toy::NotFound.new(id))
+      end
+
+      def get_multi(*ids)
+        ids.flatten.map { |id| get(id) }
+      end
+
+      def get_or_new(id)
+        get(id) || new(:id => id)
+      end
+
+      def get_or_create(id)
+        get(id) || create(:id => id)
+      end
+
+      def key?(id)
+        key = store_key(id)
+        value = store.key?(key)
+        log_operation('KEY', store, key, value)
+        value
+      end
+      alias :has_key? :key?
+
+      def load(attrs)
+        return nil if attrs.nil?
+        allocate.initialize_from_database(attrs)
+      end
+    end
+  end
+end

data/lib/toy/reference.rb

@@ -0,0 +1,134 @@
+module Toy
+  class Reference
+    attr_accessor :model, :name, :options
+
+    def initialize(model, name, *args)
+      @model   = model
+      @name    = name.to_sym
+      @options = args.extract_options!
+      @type    = args.shift
+
+      model.references[name] = self
+      model.attribute(key, String)
+      create_accessors
+    end
+
+    def type
+      @type ||= name.to_s.classify.constantize
+    end
+
+    def key
+      @key ||= :"#{name.to_s.singularize}_id"
+    end
+
+    def instance_variable
+      @instance_variable ||= :"@_#{name}"
+    end
+
+    def new_proxy(owner)
+      ReferenceProxy.new(self, owner)
+    end
+
+    def eql?(other)
+      self.class.eql?(other.class) &&
+        model == other.model &&
+        name  == other.name
+    end
+    alias :== :eql?
+
+    class ReferenceProxy
+      extend Forwardable
+
+      def_delegator :@reference, :type, :proxy_class
+      def_delegator :@reference, :key, :proxy_key
+      alias_method :proxy_respond_to?, :respond_to?
+      instance_methods.each { |m| undef_method m unless m.to_s =~ /^(?:nil\?|send|object_id|to_a)$|^__|proxy_/ }
+
+      def initialize(reference, owner)
+        @reference, @owner = reference, owner
+      end
+
+      def proxy_owner
+        @owner
+      end
+
+      def target
+        return nil if target_id.blank?
+        @target ||= proxy_class.get(target_id)
+      end
+
+      def reset
+        @target = nil
+      end
+
+      def replace(record)
+        if record.nil?
+          reset
+          self.target_id = nil
+        else
+          assert_type(record)
+          @target = record
+          self.target_id = record.id
+        end
+      end
+
+      def create(attrs={})
+        proxy_class.create(attrs).tap do |record|
+          if record.persisted?
+            self.target_id = record.id
+            proxy_owner.save
+            reset
+          end
+        end
+      end
+
+      def build(attrs={})
+        proxy_class.new(attrs).tap do |record|
+          self.target_id = record.id
+          reset
+        end
+      end
+
+      # Does the proxy or its \target respond to +symbol+?
+      def respond_to?(*args)
+        proxy_respond_to?(*args) || target.respond_to?(*args)
+      end
+
+      private
+        def assert_type(record)
+          unless record.instance_of?(proxy_class)
+            raise(ArgumentError, "#{proxy_class} expected, but was #{record.class}")
+          end
+        end
+
+        def target_id
+          proxy_owner.send(proxy_key)
+        end
+
+        def target_id=(value)
+          proxy_owner.send("#{proxy_key}=", value)
+        end
+
+        def method_missing(method, *args, &block)
+          target.send(method, *args, &block)
+        end
+    end
+
+    private
+      def create_accessors
+        model.class_eval """
+          def #{name}
+            #{instance_variable} ||= self.class.references[:#{name}].new_proxy(self)
+          end
+
+          def #{name}=(record)
+            #{name}.replace(record)
+          end
+
+          def #{name}?
+            #{name}.present?
+          end
+        """
+      end
+  end
+end

data/lib/toy/references.rb

@@ -0,0 +1,19 @@
+module Toy
+  module References
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def references
+        @references ||= {}
+      end
+
+      def reference?(key)
+        references.keys.include?(key.to_sym)
+      end
+
+      def reference(name, *args)
+        Reference.new(self, name, *args)
+      end
+    end
+  end
+end

data/lib/toy/serialization.rb

@@ -0,0 +1,81 @@
+module Toy
+  module Serialization
+    extend ActiveSupport::Concern
+    include ActiveModel::Serializers::JSON
+    include ActiveModel::Serializers::Xml
+
+    def serializable_attributes
+      attributes.keys.sort.map(&:to_sym)
+    end
+
+    def serializable_hash(options = nil)
+      hash = {}
+      options ||= {}
+      options[:only]   = Array.wrap(options[:only]).map(&:to_sym)
+      options[:except] = Array.wrap(options[:except]).map(&:to_sym)
+
+      serializable_stuff = serializable_attributes.map(&:to_sym) + self.class.embedded_lists.keys.map(&:to_sym)
+
+      if options[:only].any?
+        serializable_stuff &= options[:only]
+      elsif options[:except].any?
+        serializable_stuff -= options[:except]
+      end
+
+      serializable_stuff += Array.wrap(options[:methods]).map(&:to_sym).select do |method|
+        respond_to?(method)
+      end
+
+      serializable_stuff.each do |name|
+        value = send(name)
+        hash[name.to_s] = if value.is_a?(Array)
+                            value.map { |v| v.respond_to?(:serializable_hash) ? v.serializable_hash : v }
+                          elsif value.respond_to?(:serializable_hash)
+                            value.serializable_hash
+                          else
+                            value
+                          end
+      end
+
+      serializable_add_includes(options) do |association, records, opts|
+        hash[association] = records.is_a?(Enumerable) ?
+          records.map { |r| r.serializable_hash(opts) } :
+          records.serializable_hash(opts)
+      end
+
+      hash
+    end
+
+    private
+      # Add associations specified via the <tt>:includes</tt> option.
+      # Expects a block that takes as arguments:
+      #   +association+ - name of the association
+      #   +records+     - the association record(s) to be serialized
+      #   +opts+        - options for the association records
+      def serializable_add_includes(options = {})
+        return unless include_associations = options.delete(:include)
+
+        base_only_or_except = { :except => options[:except],
+                                :only => options[:only] }
+
+        include_has_options = include_associations.is_a?(Hash)
+        associations = include_has_options ? include_associations.keys : Array.wrap(include_associations)
+
+        for association in associations
+          records = if self.class.list?(association)
+            send(association).to_a
+          elsif self.class.reference?(association) || self.class.parent_reference?(association)
+            send(association)
+          end
+
+          unless records.nil?
+            association_options = include_has_options ? include_associations[association] : base_only_or_except
+            opts = options.merge(association_options)
+            yield(association, records, opts)
+          end
+        end
+
+        options[:include] = include_associations
+      end
+  end
+end

data/lib/toy/store.rb

@@ -0,0 +1,36 @@
+module Toy
+  module Store
+    extend ActiveSupport::Concern
+
+    included do
+      extend  ActiveModel::Naming
+      include ActiveModel::Conversion
+      include Attributes
+      include Identity
+      include Persistence
+      include MassAssignmentSecurity
+      include Plugins
+      include Dolly
+      include Dirty
+      include Equality
+      include Inspect
+      include Querying
+
+      include Callbacks
+      include Validations
+      include Serialization
+      include Timestamps
+
+      include Lists
+      include EmbeddedLists
+      include References
+      include Indices
+      include Logger
+
+      include IdentityMap
+      include Caching
+    end
+  end
+
+  extend Connection
+end

data/lib/toy/timestamps.rb

@@ -0,0 +1,22 @@
+module Toy
+  module Timestamps
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def timestamps
+        attribute(:created_at, Time)
+        attribute(:updated_at, Time)
+
+        before_create do |record|
+          now = Time.now
+          record.created_at = now unless created_at?
+          record.updated_at = now
+        end
+
+        before_update do |record|
+          record.updated_at = Time.now
+        end
+      end
+    end
+  end
+end

data/lib/toy/validations.rb

@@ -0,0 +1,45 @@
+module Toy
+  module Validations
+    extend ActiveSupport::Concern
+    include ActiveModel::Validations
+
+    included do
+      extend ActiveModel::Callbacks
+      define_model_callbacks :validation
+    end
+
+    module ClassMethods
+      def validates_embedded(*names)
+        validates_each(*names) do |record, name, value|
+          invalid = value.compact.select { |o| !o.valid? }
+          if invalid.any?
+            record.errors.add(name, 'is invalid')
+            logger.debug("ToyStore IEM")
+            invalid.each do |o|
+              logger.debug("  #{o.attributes.inspect} - #{o.errors.full_messages.inspect}")
+            end
+          end
+        end
+      end
+
+      def create!(attrs={})
+        new(attrs).tap { |doc| doc.save! }
+      end
+    end
+
+    module InstanceMethods
+      def valid?
+        run_callbacks(:validation) { super }
+      end
+
+      def save(options={})
+        options.assert_valid_keys(:validate)
+        !options.fetch(:validate, true) || valid? ? super : false
+      end
+
+      def save!
+        save || raise(RecordInvalidError.new(self))
+      end
+    end
+  end
+end