friendly_postgres 0.4.3 → 0.4.5

data/lib/friendly/document/storage.rb

@@ -0,0 +1,63 @@
+require 'friendly/document/mixin'
+
+module Friendly
+  module Document
+    module Storage
+      extend Mixin
+
+      module ClassMethods
+        attr_writer :storage_proxy, :query_klass
+        
+        def create_tables!
+          storage_proxy.create_tables!
+        end
+
+        def storage_proxy
+          @storage_proxy ||= StorageProxy.new(self)
+        end
+
+        def indexes(*args)
+          storage_proxy.add(args)
+        end
+
+        def caches_by(*fields)
+          options = fields.last.is_a?(Hash) ? fields.pop : {}
+          storage_proxy.cache(fields, options)
+        end
+
+        def first(query)
+          storage_proxy.first(query(query))
+        end
+
+        def all(query)
+          storage_proxy.all(query(query))
+        end
+
+        def count(conditions)
+          storage_proxy.count(query(conditions))
+        end
+
+        def query_klass
+          @query_klass ||= Query
+        end
+
+        protected
+          def query(conditions)
+            conditions.is_a?(Query) ? conditions : query_klass.new(conditions)
+          end
+      end
+      
+      def save
+        new_record? ? storage_proxy.create(self) : storage_proxy.update(self)
+      end
+
+      def destroy
+        storage_proxy.destroy(self)
+      end
+
+      def storage_proxy
+        self.class.storage_proxy
+      end
+    end
+  end
+end

data/lib/friendly/document.rb

@@ -1,5 +1,9 @@
 require 'active_support/inflector'
-require 'friendly/associations'
+require 'friendly/document/associations'
+require 'friendly/document/attributes'
+require 'friendly/document/convenience'
+require 'friendly/document/scoping'
+require 'friendly/document/storage'
 
 module Friendly
   module Document
@@ -26,198 +30,18 @@ module Friendly
     end
 
     module ClassMethods
-      attr_writer :storage_proxy, :query_klass, 
-                  :table_name,    :collection_klass,
-                  :scope_proxy,   :association_set
-
-      def create_tables!
-        storage_proxy.create_tables!
-      end
-
-      def attribute(name, type = nil, options = {})
-        attributes[name] = Attribute.new(self, name, type, options)
-      end
-
-      def storage_proxy
-        @storage_proxy ||= StorageProxy.new(self)
-      end
-
-      def query_klass
-        @query_klass ||= Query
-      end
-
-      def collection_klass
-        @collection_klass ||= WillPaginate::Collection
-      end
-
-      def indexes(*args)
-        storage_proxy.add(args)
-      end
-
-      def caches_by(*fields)
-        options = fields.last.is_a?(Hash) ? fields.pop : {}
-        storage_proxy.cache(fields, options)
-      end
-
-      def attributes
-        @attributes ||= {}
-      end
-
-      def first(query)
-        storage_proxy.first(query(query))
-      end
-
-      def all(query)
-        storage_proxy.all(query(query))
-      end
-
-      def find(id)
-        doc = first(:id => id)
-        raise RecordNotFound, "Couldn't find #{name}/#{id}" if doc.nil?
-        doc
-      end
-
-      def count(conditions)
-        storage_proxy.count(query(conditions))
-      end
-
-      def paginate(conditions)
-        query      = query(conditions)
-        count      = count(query)
-        collection = collection_klass.new(query.page, query.per_page, count)
-        collection.replace(all(query))
-      end
-
-      def create(attributes = {})
-        doc = new(attributes)
-        doc.save
-        doc
-      end
+      attr_writer :table_name
 
       def table_name
         @table_name ||= name.pluralize.underscore
       end
-
-      def scope_proxy
-        @scope_proxy ||= ScopeProxy.new(self)
-      end
-
-      # Add a named scope to this Document.
-      #
-      # e.g.
-      #     
-      #     class Post
-      #       indexes     :created_at
-      #       named_scope :recent, :order! => :created_at.desc
-      #     end
-      #
-      # Then, you can access the recent posts with:
-      #
-      #     Post.recent.all
-      # ...or...
-      #     Post.recent.first
-      #
-      # Both #all and #first also take additional parameters:
-      #
-      #     Post.recent.all(:author_id => @author.id)
-      #
-      # Scopes are also chainable. See the README or Friendly::Scope docs for details.
-      #
-      # @param [Symbol] name the name of the scope.
-      # @param [Hash] parameters the query that this named scope will perform.
-      #
-      def named_scope(name, parameters)
-        scope_proxy.add_named(name, parameters)
-      end
-
-      # Returns boolean based on whether the Document has a scope by a particular name.
-      #
-      # @param [Symbol] name The name of the scope in question.
-      #
-      def has_named_scope?(name)
-        scope_proxy.has_named_scope?(name)
-      end
-
-      # Create an ad hoc scope on this Document.
-      #
-      # e.g.
-      #     
-      #     scope = Post.scope(:order! => :created_at)
-      #     scope.all # => [#<Post>, #<Post>]
-      #
-      # @param [Hash] parameters the query parameters to create the scope with.
-      #
-      def scope(parameters)
-        scope_proxy.ad_hoc(parameters)
-      end
-
-      def association_set
-        @association_set ||= Associations::Set.new(self)
-      end
-
-      # Add a has_many association.
-      #
-      # e.g.
-      #
-      #     class Post
-      #       attribute :user_id, Friendly::UUID
-      #       indexes   :user_id
-      #     end
-      #      
-      #     class User
-      #       has_many :posts
-      #     end
-      #     
-      #     @user = User.create
-      #     @post = @user.posts.create
-      #     @user.posts.all == [@post] # => true
-      #
-      # _Note: Make sure that the target model is indexed on the foreign key. If it isn't, querying the association will raise Friendly::MissingIndex._
-      #
-      # Friendly defaults the foreign key to class_name_id just like ActiveRecord.
-      # It also converts the name of the association to the name of the target class just like ActiveRecord does.
-      #
-      # The biggest difference in semantics between Friendly's has_many and active_record's is that Friendly's just returns a Friendly::Scope object. If you want all the associated objects, you have to call #all to get them. You can also use any other Friendly::Scope method.
-      #
-      # @param [Symbol] name The name of the association and plural name of the target class.
-      # @option options [String] :class_name The name of the target class of this association if it is different than the name would imply.
-      # @option options [Symbol] :foreign_key Override the foreign key.
-      # 
-      def has_many(name, options = {})
-        association_set.add(name, options)
-      end
-
-      protected
-        def query(conditions)
-          conditions.is_a?(Query) ? conditions : query_klass.new(conditions)
-        end
     end
 
-    def initialize(opts = {})
-      self.attributes = opts
-    end
-
-    def attributes=(attrs)
-      assert_no_duplicate_keys(attrs)
-      attrs.each { |name, value| send("#{name}=", value) }
-    end
-
-    def save
-      new_record? ? storage_proxy.create(self) : storage_proxy.update(self)
-    end
-
-    def update_attributes(attributes)
-      self.attributes = attributes
-      save
-    end
-
-    def destroy
-      storage_proxy.destroy(self)
-    end
-
-    def to_hash
-      Hash[*self.class.attributes.keys.map { |n| [n, send(n)] }.flatten]
-    end
+    include Associations
+    include Convenience
+    include Scoping
+    include Storage
+    include Attributes
 
     def table_name
       self.class.table_name
@@ -236,22 +60,11 @@ module Friendly
       @new_record = value
     end
 
-    def storage_proxy
-      self.class.storage_proxy
-    end
-
     def ==(comparison_object)
       comparison_object.equal?(self) ||
         (comparison_object.is_a?(self.class) &&
           !comparison_object.new_record? && 
             comparison_object.id == id)
     end
-
-    protected
-      def assert_no_duplicate_keys(hash)
-        if hash.keys.map { |k| k.to_s }.uniq.length < hash.keys.length
-          raise ArgumentError, "Duplicate keys: #{hash.inspect}"
-        end
-      end
   end
 end

data/lib/friendly/scope_proxy.rb

@@ -1,5 +1,3 @@
-require 'friendly/named_scope'
-
 module Friendly
   class ScopeProxy
     attr_reader :klass, :scope_klass, :scopes

data/lib/friendly/translator.rb

@@ -12,7 +12,8 @@ module Friendly
     def to_object(klass, record)
       record.delete(:added_id)
       attributes = serializer.parse(record.delete(:attributes))
-      klass.new attributes.merge(record).merge(:new_record => false)
+      attributes.merge!(record).merge!(:new_record => false)
+      klass.new_without_change_tracking attributes
     end
 
     def to_record(document)

data/lib/friendly.rb

@@ -3,13 +3,11 @@ require 'friendly/attribute'
 require 'friendly/boolean'
 require 'friendly/cache'
 require 'friendly/cache/by_id'
-require 'friendly/config'
 require 'friendly/data_store'
 require 'friendly/document'
 require 'friendly/document_table'
 require 'friendly/index'
 require 'friendly/memcached'
-require 'friendly/named_scope'
 require 'friendly/query'
 require 'friendly/sequel_monkey_patches'
 require 'friendly/scope'

data/spec/integration/default_value_spec.rb

@@ -1,15 +1,30 @@
 require File.expand_path("../../spec_helper", __FILE__)
 
 describe "An attribute with a default value" do
-  before do
-    @user = User.new
-  end
+  describe "before saving" do
+    before do
+      @user = User.new
+    end
+
+    it "has the value by default" do
+      @user.happy.should be_true
+    end
 
-  it "has the value by default" do
-    @user.happy.should be_true
+    it "has a default vaue even when it's false" do
+      @user.sad.should be_false
+    end
   end
 
-  it "has a default vaue even when it's false" do
-    @user.sad.should be_false
+  describe "after saving" do
+    before do
+      @user = User.new
+      @user.save
+      @user = User.find(@user.id)
+    end
+
+    it "doesn't set the existing attributes as dirty" do
+      @user.should_not be_changed
+      @user.should_not be_happy_changed
+    end
   end
 end

data/spec/integration/dirty_tracking_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe "Changing an attribute" do
+  describe "before a record is saved" do
+    before do
+      @user      = User.new
+      @user.name = "James"
+    end
+
+    it "responds to the attribute being changed" do
+      @user.should be_name_changed
+    end
+
+    it "returns the original value of the attribute" do
+      @user.name_was.should == ""
+    end
+
+    it "is changed" do
+      @user.should be_changed
+    end
+  end
+
+  describe "after saving a record with changed attributes" do
+    before do
+      @user      = User.create
+      @user.name = "James"
+      @user.save
+    end
+
+    it "is no longer attribute_changed?" do
+      @user.should_not be_name_changed
+    end
+
+    it "returns nil for attribute_was" do
+      @user.name_was.should be_nil
+    end
+
+    it "is no longer changed" do
+      @user.should_not be_changed
+    end
+  end
+end
+

data/spec/integration/finder_spec.rb

@@ -62,3 +62,10 @@ describe "limiting a query with offset" do
              :order!  => :created_at.desc).should == @objects.reverse.slice(2, 2)
   end
 end
+
+describe "all with only order" do
+  it "queries the index" do
+    Address.create
+      Address.all(:order! => :created_at.desc, :limit! => 5)
+  end
+end

data/spec/spec_helper.rb

@@ -64,6 +64,8 @@ class Address
 
   indexes   :user_id
   indexes   :street
+  indexes   :created_at
+
   caches_by :id
 end
 

data/spec/unit/attribute_spec.rb

@@ -2,12 +2,12 @@ require File.expand_path("../../spec_helper", __FILE__)
 
 describe "Friendly::Attribute" do
   before do
-    @klass   = Class.new
+    @klass   = Class.new { def will_change(a); end }
     @name    = Friendly::Attribute.new(@klass, :name, String)
     @id      = Friendly::Attribute.new(@klass, :id, Friendly::UUID)
     @no_type = Friendly::Attribute.new(@klass, :no_type, nil)
     @default = Friendly::Attribute.new(@klass, :default, String, :default => "asdf")
-    @false   = Friendly::Attribute.new(@klass, :default, String, :default => false)
+    @false   = Friendly::Attribute.new(@klass, :false,   String, :default => false)
     @klass.stubs(:attributes).returns({:name    => @name, 
                                        :id      => @id, 
                                        :default => @default,
@@ -15,11 +15,27 @@ describe "Friendly::Attribute" do
     @object = @klass.new
   end
 
-  it "creates a setter and a getter on klass" do
+  it "creates a getting on klass that notifies it of a change" do
+    @object.stubs(:will_change)
+    @object.name = "Something"
+    @object.should have_received(:will_change).with(:name)
+  end
+
+  it "creates a getter on klass" do
     @object.name = "Something"
     @object.name.should == "Something"
   end
 
+  it "creates an 'attr_was' getter" do
+    @object.instance_variable_set(:@name_was, "Joe the Plumber")
+    @object.name_was.should == "Joe the Plumber"
+  end
+
+  it "creates an attr_changed? query method" do
+    @object.stubs(:attribute_changed?).with(:name).returns(true)
+    @object.should be_name_changed
+  end
+
   it "typecasts values using the converter function" do
     uuid = Friendly::UUID.new
     @id.typecast(uuid.to_s).should == uuid
@@ -37,10 +53,6 @@ describe "Friendly::Attribute" do
     }.should raise_error(Friendly::NoConverterExists)
   end
 
-  it "creates a getter with a default value" do
-    @object.id.should be_instance_of(Friendly::UUID)
-  end
-
   it "has a default value of type.new" do
     @id.default.should be_instance_of(Friendly::UUID)
   end
@@ -55,13 +67,21 @@ describe "Friendly::Attribute" do
 
   it "can have a default value" do
     @default.default.should == "asdf"
-    @klass.new.default.should == "asdf"
+    @obj = @klass.new
+    @default.assign_default_value(@obj)
+    @obj.default.should == "asdf"
   end
 
   it "has a default value even if it's false" do
     @false.default.should be_false
   end
 
+  it "knows how to assign its own default" do
+    @object = stub(:false= => nil)
+    @false.assign_default_value(@object)
+    @object.should have_received(:false=).with(false)
+  end
+
   describe "registering a type" do
     before do
       @klass = Class.new

data/spec/unit/data_store_spec.rb

@@ -76,6 +76,19 @@ describe "Friendly::DataStore" do
     end
   end
 
+  describe "all without conditions" do
+    before do
+      @all         = stub(:map => [])
+      @users.stubs(:order).with(:created_at).returns(@all)
+      @query       = query(:order! => :created_at)
+      @return      = @datastore.all(@klass, @query)
+    end
+
+    it "orders the filtered dataset and returns the results" do
+      @return.should == []
+    end
+  end
+
   describe "retrieving first with conditions" do
     before do
       @users.first = {{:id => 1} => {:id => 1}}

data/spec/unit/document/attributes_spec.rb

@@ -0,0 +1,130 @@
+require File.expand_path("../../../spec_helper", __FILE__)
+
+describe "Friendly::Document::Attributes" do
+  before do
+    @klass = Class.new do
+      include Friendly::Document::Attributes
+
+      attribute :name, String
+    end
+  end
+
+  describe "#initialize" do
+    it "sets the attributes using the setters" do
+      @doc = @klass.new :name => "Bond"
+      @doc.name.should == "Bond"
+    end
+
+    it "assigns the default values" do
+      @klass.attribute :id, Friendly::UUID
+      @klass.attributes[:id]   = stub(:assign_default_value => nil)
+      @klass.attributes[:name] = stub(:assign_default_value => nil,
+                                      :typecast             => "Bond")
+      @doc = @klass.new :name => "Bond"
+      @klass.attributes[:id].should have_received(:assign_default_value).with(@doc)
+      @klass.attributes[:name].should have_received(:assign_default_value).with(@doc)
+    end
+  end
+
+  describe "#attributes=" do
+    before do
+      @object = @klass.new
+      @object.attributes = {:name => "Bond"}
+    end
+
+    it "sets the attributes using the setters" do
+      @object.name.should == "Bond"
+    end
+
+    it "raises ArgumentError when there are duplicate keys of differing type" do
+      lambda { 
+        @object.attributes = {:name => "Bond", "name" => "Bond"}
+      }.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "#to_hash" do
+    before do
+      @object = @klass.new(:name => "Stewie")
+    end
+
+    it "creates a hash that contains its attributes" do
+      @object.to_hash.should == {:name => "Stewie"}
+    end
+  end
+
+  describe "#assign" do
+    before do
+      @object = @klass.new
+      @object.assign(:name, "James Bond")
+    end
+
+    it "assigns the value to the attribute" do
+      @object.name.should == "James Bond"
+    end
+  end
+
+  describe "#will_change" do
+    before do
+      @klass.send(:attr_accessor, :some_variable)
+      @object = @klass.new
+      @object.some_variable = "Some value"
+      @object.will_change(:some_variable)
+    end
+
+    it "makes the object #changed?" do
+      @object.should be_changed
+    end
+
+    it "returns the value of the variable for #attribute_was" do
+      @object.attribute_was(:some_variable).should == "Some value"
+    end
+
+    it "returns true for attribute_changed?(:some_variable)" do
+      @object.should be_attribute_changed(:some_variable)
+    end
+  end
+
+  describe "#reset_changes" do
+    before do
+      @klass.send(:attr_accessor, :some_variable)
+      @object = @klass.new
+      @object.some_variable = "Some value"
+      @object.will_change(:some_variable)
+      @object.reset_changes
+    end
+
+    it "resets the changed status of the object" do
+      @object.should_not be_changed
+    end
+
+    it "returns nil for attribute_was(:some_variable)" do
+      @object.attribute_was(:some_variable).should be_nil
+    end
+
+    it "returns false for attribute_changed?(:some_variable)" do
+      @object.should_not be_attribute_changed(:some_variable)
+    end
+  end
+
+  describe "#new_without_change_tracking" do
+    before do
+      @klass = Class.new do
+        attr_reader :name
+
+        def name=(name)
+          will_change(:name)
+          @name = name
+        end
+
+        include Friendly::Document::Attributes
+      end
+      @doc = @klass.new_without_change_tracking(:name => "James")
+    end
+
+    it "initializes and then calls reset_changes" do
+      @doc.name.should == "James"
+      @doc.should_not be_changed
+    end
+  end
+end