toystore 0.5

data/lib/toy/inspect.rb

@@ -0,0 +1,12 @@
+module Toy
+  module Inspect
+    extend ActiveSupport::Concern
+
+    def inspect
+      attributes_as_nice_string = self.class.attributes.keys.map(&:to_s).sort.map do |name|
+        "#{name}: #{read_attribute(name).inspect}"
+      end.join(", ")
+      "#<#{self.class}:#{object_id} #{attributes_as_nice_string}>"
+    end
+  end
+end

data/lib/toy/list.rb

@@ -0,0 +1,46 @@
+require 'toy/proxies/list'
+
+module Toy
+  class List
+    include Toy::Collection
+
+    def after_initialize
+      model.attribute(key, Array)
+      create_accessors
+    end
+
+    def key
+      @key ||= :"#{name.to_s.singularize}_ids"
+    end
+
+    private
+      def proxy_class
+        Toy::Proxies::List
+      end
+
+      def list_method
+        :lists
+      end
+
+      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
+        """
+
+        if options[:dependent]
+          model.class_eval """
+            after_destroy :destroy_#{name}
+            def destroy_#{name}
+              #{name}.each { |o| o.destroy }
+            end
+          """
+        end
+      end
+  end
+end

data/lib/toy/lists.rb

@@ -0,0 +1,37 @@
+module Toy
+  module Lists
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def lists
+        @lists ||= {}
+      end
+
+      def list?(key)
+        lists.keys.include?(key.to_sym)
+      end
+
+      # @examples
+      #   list :games                                   # assumes Game
+      #   list :games, :dependent => true               # assumes Game
+      #   list :active_games, Game                      # uses Game
+      #   list :active_games, Game, :dependent => true  # uses Game
+      #
+      #   list :games do
+      #     def active
+      #       target.select { |t| t.active? }
+      #     end
+      #   end
+      #
+      #   module ActiveExtension
+      #     def active
+      #       target.select { |t| t.active? }
+      #     end
+      #   end
+      #   list :games, :extensions => [ActiveExtension]
+      def list(name, *args, &block)
+        List.new(self, name, *args, &block)
+      end
+    end
+  end
+end

data/lib/toy/logger.rb

@@ -0,0 +1,26 @@
+module Toy
+  module Logger
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def logger
+        Toy.logger
+      end
+
+      def log_operation(operation, adapter, key, value)
+        logger.debug("ToyStore #{operation} :#{adapter.name} #{key.inspect}")
+        logger.debug("  #{value.inspect}")
+      end
+    end
+
+    module InstanceMethods
+      def logger
+        Toy.logger
+      end
+
+      def log_operation(*args)
+        self.class.log_operation(*args)
+      end
+    end
+  end
+end

data/lib/toy/mass_assignment_security.rb

@@ -0,0 +1,16 @@
+module Toy
+  module MassAssignmentSecurity
+    extend ActiveSupport::Concern
+    include ActiveModel::MassAssignmentSecurity
+
+    module InstanceMethods
+      def initialize(attrs={})
+        super(sanitize_for_mass_assignment(attrs || {}))
+      end
+
+      def update_attributes(attrs={})
+        super(sanitize_for_mass_assignment(attrs || {}))
+      end
+    end
+  end
+end

data/lib/toy/persistence.rb

@@ -0,0 +1,138 @@
+module Toy
+  module Persistence
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def store(name=nil, client=nil, options=nil)
+        assert_client(name, client)
+        @store = Adapter[name].new(client, options) if !name.nil? && !client.nil?
+        assert_store(name, client, 'store')
+        @store
+      end
+
+      def has_store?
+        !@store.nil?
+      end
+
+      def cache(name=nil, client=nil)
+        assert_client(name, client)
+        @cache = Adapter[name].new(client) if !name.nil? && !client.nil?
+        assert_store(name, client, 'cache')
+        @cache
+      end
+
+      def has_cache?
+        !@cache.nil?
+      end
+
+      def namespace(new_namespace=nil)
+        if new_namespace.nil?
+          @namespace ||= self.name
+        else
+          @namespace = new_namespace
+        end
+
+        @namespace
+      end
+
+      def store_key(id)
+        [namespace, id].join(':')
+      end
+
+      def create(attrs={})
+        new(attrs).tap { |doc| doc.save }
+      end
+
+      def delete(*ids)
+        ids.each { |id| get(id).try(:delete) }
+      end
+
+      def destroy(*ids)
+        ids.each { |id| get(id).try(:destroy) }
+      end
+
+      private
+        def assert_client(name, client)
+          raise(ArgumentError, 'Client is required') if !name.nil? && client.nil?
+        end
+
+        def assert_store(name, client, which)
+          raise(StandardError, "No #{which} has been set") if name.nil? && client.nil? && !send(:"has_#{which}?")
+        end
+    end
+
+    module InstanceMethods
+      def store
+        self.class.store
+      end
+
+      def cache
+        self.class.cache
+      end
+
+      def store_key
+        self.class.store_key(id)
+      end
+
+      def new_record?
+        @_new_record == true
+      end
+
+      def destroyed?
+        @_destroyed == true
+      end
+
+      def persisted?
+        !new_record? && !destroyed?
+      end
+
+      def save(*)
+        new_record? ? create : update
+      end
+
+      def update_attributes(attrs)
+        self.attributes = attrs
+        save
+      end
+
+      def destroy
+        delete
+      end
+
+      def delete
+        key = store_key
+        @_destroyed = true
+        logger.debug("ToyStore DEL #{key.inspect}")
+        store.delete(key)
+      end
+
+      private
+        def create
+          persist!
+        end
+
+        def update
+          persist!
+        end
+
+        def persist
+          @_new_record = false
+        end
+
+        def persist!
+          key, attrs = store_key, persisted_attributes
+
+          if self.class.has_cache?
+            cache.write(key, attrs)
+            log_operation('WTS', cache, key, attrs)
+          end
+
+          store.write(key, attrs)
+          log_operation('SET', store, key, attrs)
+          persist
+          each_embedded_object(&:persist)
+          true
+        end
+    end
+  end
+end

data/lib/toy/plugins.rb

@@ -0,0 +1,23 @@
+module Toy
+  def models
+    @models ||= Set.new
+  end
+
+  def plugins
+    @plugins ||= Set.new
+  end
+
+  def plugin(mod)
+    Toy.models.each { |model| model.send(:include, mod) }
+    plugins << mod
+  end
+
+  module Plugins
+    extend ActiveSupport::Concern
+
+    included do
+      Toy.models << self
+      Toy.plugins.each { |mod| include mod }
+    end
+  end
+end

data/lib/toy/proxies/embedded_list.rb

@@ -0,0 +1,74 @@
+require 'toy/proxies/proxy'
+
+module Toy
+  module Proxies
+    class EmbeddedList < Toy::Proxies::Proxy
+      def get(id)
+        target.detect { |record| record.id == id }
+      end
+
+      def get!(id)
+        get(id) || raise(Toy::NotFound.new(id))
+      end
+
+      def include?(record)
+        return false if record.nil?
+        target.include?(record)
+      end
+
+      def push(instance)
+        assert_type(instance)
+        assign_reference(instance)
+        self.target.push(instance)
+      end
+      alias :<< :push
+
+      def concat(*instances)
+        instances = instances.flatten
+        instances.each do |instance|
+          assert_type(instance)
+          assign_reference(instance)
+        end
+        self.target.concat instances
+      end
+
+      def replace(instances)
+        @target = instances.map do |instance|
+          instance = instance.is_a?(proxy_class) ? instance : proxy_class.load(instance)
+          assign_reference(instance)
+        end
+      end
+
+      def create(attrs={})
+        proxy_class.new(attrs).tap do |instance|
+          assign_reference(instance)
+          if instance.valid?
+            push(instance)
+            proxy_owner.save
+          end
+        end
+      end
+
+      def destroy(*args, &block)
+        ids = block_given? ? target.select(&block).map(&:id) : args.flatten
+        target.delete_if { |instance| ids.include?(instance.id) }
+        proxy_owner.save
+      end
+
+      def destroy_all
+        target.clear
+        proxy_owner.save
+      end
+
+      private
+        def find_target
+          []
+        end
+
+        def assign_reference(instance)
+          instance.parent_reference = proxy_owner
+          instance
+        end
+    end
+  end
+end

data/lib/toy/proxies/list.rb

@@ -0,0 +1,97 @@
+require 'toy/proxies/proxy'
+
+module Toy
+  module Proxies
+    class List < Toy::Proxies::Proxy
+      def get(id)
+        if target_ids.include?(id)
+          proxy_class.get(id)
+        end
+      end
+
+      def get!(id)
+        get(id) || raise(Toy::NotFound.new(id))
+      end
+
+      def include?(record)
+        return false if record.nil?
+        target_ids.include?(record.id)
+      end
+
+      def push(record)
+        assert_type(record)
+        self.target_ids = target_ids + [record]
+      end
+      alias :<< :push
+
+      def concat(*records)
+        records = records.flatten
+        records.map { |record| assert_type(record) }
+        self.target_ids = target_ids + records
+      end
+
+      def replace(records)
+        reset
+        self.target_ids = records
+      end
+
+      def create(attrs={})
+        if proxy_options[:inverse_of]
+          attrs.update(:"#{proxy_options[:inverse_of]}_id" => proxy_owner.id)
+        end
+        proxy_class.create(attrs).tap do |record|
+          if record.persisted?
+            proxy_owner.reload
+            push(record)
+            proxy_owner.save
+            reset
+          end
+        end
+      end
+
+      def destroy(*args, &block)
+        ids = block_given? ? target.select(&block).map(&:id) : args.flatten
+        proxy_class.destroy(*ids)
+        proxy_owner.reload
+        self.target_ids = target_ids - ids
+        proxy_owner.save
+        reset
+      end
+
+      def destroy_all
+        proxy_class.destroy(*target_ids)
+        self.target_ids = []
+        proxy_owner.save
+        reset
+      end
+
+      def reset
+        @target = nil
+      end
+
+      private
+        def find_target
+          return [] if target_ids.blank?
+          proxy_class.get_multi(target_ids)
+        end
+
+        def target_ids
+          proxy_owner.send(proxy_key)
+        end
+
+        def target_ids=(value)
+          ids = value.map do |item|
+            if item.is_a?(proxy_class)
+              item.id
+            elsif item.is_a?(Hash)
+              item['id']
+            else
+              item
+            end
+          end
+          proxy_owner.send(:"#{proxy_key}=", ids)
+          reset
+        end
+    end
+  end
+end