toystore 0.8.3 → 0.9.0

data/LOGGING.rdoc

@@ -1,12 +0,0 @@
-What the 3 letter codes mean when they show up in logging:
-
-  SET: write to store
-  GET: read from store
-  DEL: delete from store
-  KEY: check if key exists in store
-
-  IMG: read from identity map
-  IMS: write to identity map
-  IMD: delete from identity map
-
-  IEM: invalid embedded document

data/README.rdoc

@@ -1,27 +0,0 @@
-= Toystore
-
-An object mapper for anything that can read, write and delete data.
-
-See examples/ for potential direction. The idea is that any key-value store (via adapters) that supports read, write, delete will work (memcache, membase, mongo, redis, couch, toyko. Potentially even RESTFUL services or sqlite with a single key-value table?)
-
-== Mailing List
-
-https://groups.google.com/forum/#!forum/toystoreadapter
-
-== Identity Map
-
-By default, Toystore has identity map turned on. It assumes that any Toystore model has a unique id across all models. This means you either need to use the default uuid id's or create your own key factory that namespaces to model (see examples).
-
-You also need to clear the map before each request. For this, there is a provided piece of middleware that you can use.
-
-    use(Toy::Middleware::IdentityMap)
-
-It is autoloaded, so just add it to your config.ru or sinatra/rails app as you would any other middleware and you are good to go.
-
-== Note on Patches/Pull Requests
-
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so we don't break it in a future version unintentionally.
-* Commit, do not mess with rakefile, version, or history. (if you want to have your own version, that is fine, but bump version in a commit by itself so we can ignore when we pull)
-* Send us a pull request. Bonus points for topic branches.

data/examples/models.rb

@@ -1,51 +0,0 @@
-require 'pathname'
-
-root_path = Pathname(__FILE__).dirname.join('..').expand_path
-lib_path  = root_path.join('lib')
-$:.unshift(lib_path)
-
-require 'toy'
-require 'adapter/memory'
-
-class Address
-  include Toy::Store
-  store :memory, {}
-
-  attribute :city,  String
-  attribute :state, String
-  attribute :zip,   String
-
-  index :zip
-end
-
-class PhoneNumber
-  include Toy::Store
-
-  attribute :area_code, String
-  attribute :number,    String
-end
-
-class Company
-  include Toy::Store
-  store :memory, {}
-
-  attribute :name, String
-end
-
-class User
-  include Toy::Store
-  store :memory, {}
-
-  attribute :name,  String
-  attribute :age,   Integer
-  attribute :admin, Boolean, :default => false
-  attribute :ssn,   String
-  timestamps
-
-  index :ssn
-
-  list :addresses, :dependendent => true
-  reference :employer, Company
-
-  # validations and callbacks are available too
-end

data/lib/toy/dolly.rb

@@ -1,30 +0,0 @@
-module Toy
-  module Dolly
-    extend ActiveSupport::Concern
-
-    def initialize_copy(other)
-      @_new_record = true
-      @_destroyed  = false
-      @attributes = {}
-
-      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

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

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

@@ -1,74 +0,0 @@
-module Toy
-  class Index
-    attr_accessor :model, :name
-
-    def initialize(model, name)
-      @model, @name = model, name.to_sym
-      raise(ArgumentError, "No attribute #{name} for index") unless model.attribute?(name)
-
-      model.indices[name] = self
-      model.send(:include, IndexCallbacks)
-      create_finders
-    end
-
-    def eql?(other)
-      self.class.eql?(other.class) &&
-        model == other.model &&
-        name  == other.name
-    end
-    alias :== :eql?
-
-    def key(value)
-      sha_value = Digest::SHA1.hexdigest(Array.wrap(value).sort.join('')) # sorted for predictability
-      [model.name, name, sha_value].join(':')
-    end
-
-    module IndexCallbacks
-      extend ActiveSupport::Concern
-
-      included do
-        after_create  :index_create
-        after_update  :index_update
-        after_destroy :index_destroy
-      end
-
-      def index_create
-        indices.each_key do |name|
-          create_index(name, send(name), id)
-        end
-      end
-
-      def index_update
-        indices.each_key do |name|
-          if send(:"#{name}_changed?")
-            destroy_index(name, send(:"#{name}_was"), id)
-            create_index(name, send(name), id)
-          end
-        end
-      end
-
-      def index_destroy
-        indices.each_key do |name|
-          destroy_index(name, send(name), id)
-        end
-      end
-    end
-
-    private
-      def create_finders
-        model.class_eval """
-          def self.first_by_#{name}(value)
-            get(get_index(:#{name}, value)[0])
-          end
-
-          def self.first_or_new_by_#{name}(value)
-            first_by_#{name}(value) || new(:#{name} => value)
-          end
-
-          def self.first_or_create_by_#{name}(value)
-            first_by_#{name}(value) || create(:#{name} => value)
-          end
-        """
-      end
-  end
-end

data/lib/toy/indices.rb

@@ -1,56 +0,0 @@
-module Toy
-  module Indices
-    extend ActiveSupport::Concern
-
-    module ClassMethods
-      def indices
-        @indices ||= {}
-      end
-
-      def index(name)
-        Index.new(self, name)
-      end
-
-      def index_key(name, value)
-        if index = indices[name.to_sym]
-          index.key(value)
-        else
-          raise(ArgumentError, "Index for #{name} does not exist")
-        end
-      end
-
-      def get_index(name, value)
-        key = index_key(name, value)
-        store.read(key) || []
-      end
-
-      def create_index(name, value, id)
-        key = index_key(name, value)
-        ids = get_index(name, value)
-        ids.push(id) unless ids.include?(id)
-        store.write(key, ids)
-      end
-
-      def destroy_index(name, value, id)
-        key = index_key(name, value)
-        ids = get_index(name, value)
-        ids.delete(id)
-        store.write(key, ids)
-      end
-    end
-
-    module InstanceMethods
-      def indices
-        self.class.indices
-      end
-
-      def create_index(*args)
-        self.class.create_index(*args)
-      end
-
-      def destroy_index(*args)
-        self.class.destroy_index(*args)
-      end
-    end
-  end
-end

data/lib/toy/proxies/embedded_list.rb

@@ -1,79 +0,0 @@
-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 = if instance.is_a?(proxy_class)
-            instance
-          else
-            key = instance.delete('id')
-            proxy_class.load(key, instance)
-          end
-          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