ampere 1.1.1 → 1.2.0

data/lib/ampere/model.rb

@@ -1,14 +1,26 @@
 module Ampere
+  # Including the `Ampere::Model` module into one of your classes mixes in all 
+  # the class and instance methods of an Ampere model. See individual methods
+  # for more information.
   module Model
-    
     def self.included(base)
       base.extend(ClassMethods)
       
+      base.extend(Keys)
+      
       base.class_eval do
+        extend(::ActiveModel::Callbacks)
+        define_model_callbacks :create, :update, :save
+        
         include(::ActiveModel::Validations)
+        include(Rails.application.routes.url_helpers) if defined?(Rails)
+        include(ActionController::UrlFor) if defined?(Rails)
+
+        include(Ampere::Keys)
         
         attr_reader :id
-      
+        attr_reader :destroyed
+        
         attr_accessor :fields
         attr_accessor :field_defaults
         attr_accessor :indices
@@ -27,9 +39,9 @@ module Ampere
     # or have been stored and have the same ID, then they are equal.
     def ==(other)
       super or
-        other.instance_of?(self.class) and
+        (other.instance_of?(self.class) and
         not id.nil? and
-        other.id == id
+        other.id == id)
     end
     
     # Returns a Hash with all the fields and their values.
@@ -43,9 +55,15 @@ module Ampere
     
     # Deletes this instance out of the database.
     def destroy
+      @destroyed = true
       self.class.delete(@id)
     end
     
+    # Returns true if this record has been deleted
+    def destroyed?
+      @destroyed
+    end
+    
     # Delegates to ==().
     def eql?(other)
       self == other
@@ -61,18 +79,27 @@ module Ampere
     # 
     #     Post.new :title => "Kitties: Are They Awesome?"
     def initialize(hash = {}, unmarshal = false)
+      @destroyed = false
+      
       hash.each do |k, v|
         if k == 'id' then
           @id = unmarshal ? Marshal.load(v) : v
+        elsif k =~ /_id$/
+          self.send("#{k}=", v.to_i)
         else
-          self.send("#{k}=", (unmarshal and not k =~ /_id$/) ? Marshal.load(v) : v)
+          self.send("#{k}=", unmarshal ? Marshal.load(v) : v)
         end
       end
     end
     
     # Returns true if this record has not yet been saved.
     def new?
-      @id.nil? or not Ampere.connection.exists(@id)
+      @id.nil? or not Ampere.connection.exists(key_for_find(self.class, @id))
+    end
+    alias :new_record? :new?
+    
+    def persisted?
+      not @id.nil?
     end
     
     # Reloads this record from the database.
@@ -82,9 +109,9 @@ module Ampere
       end
       
       self.class.fields.each do |k|
-        v = Ampere.connection.hget(@id, k)
+        v = Ampere.connection.hget(key_for_find(self.class, @id), k)
         if k =~ /_id$/ then
-          self.send("#{k}=", v)
+          self.send("#{k}=", v.to_i)
         else
           self.send("#{k}=", Marshal.load(v))
         end
@@ -94,50 +121,67 @@ module Ampere
     
     # Saves this record to the database.
     def save
-      self.class.unique_indices.each do |idx|
-        # For each uniquely-indexed field, look up the index for that field,
-        # and throw an exception if this record's value for that field is in
-        # the index already.
-        if Ampere.connection.hexists("ampere.index.#{self.class.to_s.downcase}.#{idx}", instance_variable_get("@#{idx}")) then
-          raise "Cannot save non-unique value for #{idx}"
-        end
-      end
-      
-      # Grab a fresh GUID from Redis by incrementing the "__guid" key
-      if @id.nil? then
-        @id = "#{self.class.to_s.downcase}.#{Ampere.connection.incr('__guid')}"
-      end
-      
-      self.attributes.each do |k, v|
-        Ampere.connection.hset(@id, k, k =~ /_id$/ ? v : Marshal.dump(v))
-      end
-      
-      self.class.indices.each do |index|
-        if index.class == String or index.class == Symbol then
-          Ampere.connection.hset(
-            "ampere.index.#{self.class.to_s.downcase}.#{index}", 
-            instance_variable_get("@#{index}"), 
-            ([@id] | (Ampere.connection.hget("ampere.index.#{self.class.to_s.downcase}.#{index}", instance_variable_get("@#{index}")) or "")
-            .split(/:/)).join(":")
-          )
-        elsif index.class == Array then
-          key = index.map{|i| instance_variable_get("@#{i}")}.join(':')
-          val = ([@id] | (Ampere.connection.hget("ampere.index.#{self.class.to_s.downcase}.#{index}", key) or "")
+      run_callbacks :save do
+        run_callbacks :create do
+          self.class.unique_indices.each do |idx|
+            # For each uniquely-indexed field, look up the index for that field,
+            # and throw an exception if this record's value for that field is in
+            # the index already.
+            if Ampere.connection.hexists(key_for_index(idx), instance_variable_get("@#{idx}")) then
+              raise "Cannot save non-unique value for #{idx}"
+            end
+          end
+          
+          # Grab a fresh GUID from Redis by incrementing the "__guid" key
+          if @id.nil? then
+            @id = Ampere.connection.incr('__guid')
+          end
+          
+          self.attributes.each do |k, v|
+            Ampere.connection.hset(key_for_find(self.class, @id), k, k =~ /_id$/ ? v : Marshal.dump(v))
+          end
+          
+          self.class.indices.each do |index|
+            if index.class == String or index.class == Symbol then
+              Ampere.connection.hset(
+                key_for_index(index), 
+                instance_variable_get("@#{index}"), 
+                ([@id] | (Ampere.connection.hget(key_for_index(index), instance_variable_get("@#{index}")) or "")
                 .split(/:/)).join(":")
-          Ampere.connection.hset(
-            "ampere.index.#{self.class.to_s.downcase}.#{index.join(':')}",
-            key,
-            val
-          )
+              )
+            elsif index.class == Array then
+              key = index.map{|i| instance_variable_get("@#{i}")}.join(':')
+              val = ([@id] | (Ampere.connection.hget(key_for_index(index), key) or "")
+                    .split(/:/)).join(":")
+              Ampere.connection.hset(
+                key_for_index(index.join(':')),
+                key,
+                val
+              )
+            end
+          end
+          self
         end
       end
-      self
+    end
+    
+    def to_key #:nodoc:
+      # @id.nil? ? [] : [@id.to_i]
+      if destroyed?
+        [ @id.to_i ]
+      else
+        persisted? ? [ @id.to_i ] : nil
+      end
+    end
+    
+    def to_param #:nodoc:
+      @id.to_s
     end
     
     def update_attribute(key, value)
-      raise "Cannot update a nonexistent field!" unless self.class.fields.include?(key)
+      raise "Cannot update nonexistent field '#{key}'!" unless self.class.fields.include?(key.to_sym)
       self.send("#{key}=", value)
-      Ampere.connection.hset(@id, key, Marshal.dump(value))
+      Ampere.connection.hset(key_for_find(self.class, @id), key, Marshal.dump(value))
     end
     
     def update_attributes(hash = {})
@@ -146,13 +190,14 @@ module Ampere
       
       # The inefficient way I know how to do right now:
       hash.each do |k, v|
-        update_attribute(k, v)
+        self.send("#{k}=", v)
       end
+      self.save
     end
     
     ### Class methods
-    module ClassMethods
-      # Returns an array of all the records that have been stored.
+    module ClassMethods #:nodoc:
+      # Returns a lazy collection of all the records that have been stored.
       def all
         Ampere::Collection.new(self, Ampere.connection.keys("#{to_s.downcase}.*"))
       end
@@ -176,10 +221,13 @@ module Ampere
       def create(hash = {})
         new(hash).save
       end
+      alias :create! :create
     
       # Deletes the record with the given ID.
       def delete(id)
-        Ampere.connection.del(id)
+        record = find(id)
+        Ampere.connection.del(key_for_find(self, id))
+        record
       end
     
       # Declares a field. See the README for more details.
@@ -229,7 +277,9 @@ module Ampere
     
       # Finds the record with the given ID, or the first that matches the given conditions
       def find(options = {})
-        if options.class == String then
+        if options.class == String or options.is_a?(Fixnum) then
+          options = key_for_find(self, options)
+          
           if Ampere.connection.exists(options) then
             new(Ampere.connection.hgetall(options), true)
           else
@@ -240,7 +290,11 @@ module Ampere
           raise "Cannot find by #{options.class} yet"
         end
       end
-    
+
+      def first
+        all.first
+      end
+
       # Defines a has_one relationship with another model. See the README for more details.
       def has_one(field_name, options = {})
         referred_klass_name = (options[:class] or options['class'] or field_name)
@@ -268,16 +322,16 @@ module Ampere
         my_klass_name = to_s.downcase
       
         define_method(:"#{field_name}") do
-          (Ampere.connection.smembers("#{to_s.downcase}.#{self.id}.has_many.#{field_name}")).map do |id|
+          (Ampere.connection.smembers(key_for_has_many(to_s.downcase, self.id, field_name))).map do |id|
             eval(klass_name.to_s.capitalize).find(id)
           end
         end
       
         define_method(:"#{field_name}=") do |val|
           val.each do |v|
-            Ampere.connection.sadd("#{to_s.downcase}.#{self.id}.has_many.#{field_name}", v.id)
+            Ampere.connection.sadd(key_for_has_many(to_s.downcase, self.id, field_name), v.id)
             # Set pointer for belongs_to
-            Ampere.connection.hset(v.id, "#{my_klass_name}_id", self.send("id"))
+            Ampere.connection.hset(key_for_find(v.class, v.id), "#{my_klass_name}_id", self.send("id"))
           end
         end
       end
@@ -309,7 +363,11 @@ module Ampere
       def indices
         @indices
       end
-    
+      
+      def last
+        all.last
+      end
+      
       def unique_indices
         @unique_indices
       end
@@ -328,11 +386,11 @@ module Ampere
           unless indexed_fields.empty?
             indexed_fields.map {|key|
               if key.class == String or key.class == Symbol then
-                Ampere.connection.hget("ampere.index.#{to_s.downcase}.#{key}", options[key]).split(/:/) #.map {|id| find(id)}
+                Ampere.connection.hget(key_for_index(key), options[key]).split(/:/) #.map {|id| find(id)}
               else
                 # Compound index
                 Ampere.connection.hget(
-                  "ampere.index.#{to_s.downcase}.#{key.join(':')}", 
+                  key_for_index(key.join(':')),
                   key.map{|k| options[k]}.join(':')
                 ).split(/:/) #.map {|id| find(id)}
               end
@@ -364,11 +422,12 @@ module Ampere
     
       private
     
-      def compound_indices_for(query)
+      def compound_indices_for(query) #:nodoc:
         compound_indices.select{|ci|
           (query.keys - ci).empty?
         }
       end
+      
     end
     
   end

data/lib/ampere/timestamps.rb

@@ -0,0 +1,23 @@
+module Ampere
+  module Timestamps
+    def self.included(base)
+      base.class_eval do
+        field :created_at
+        field :updated_at
+        
+        define_model_callbacks :create, :update, :save
+        
+        before_create do
+          @updated_at = Time.now
+          if @created_at.nil? then
+            @created_at = Time.now
+          end
+        end
+      
+        before_save do
+          @updated_at = Time.now
+        end
+      end
+    end
+  end
+end

data/lib/ampere.rb

@@ -3,26 +3,42 @@ require "active_record"
 require "redis"
 require "pp"
 
+# The Ampere module contains methods to connect/disconnect and gives access to
+# the Redis connection directly (though you really shouldn't need to use it).
 module Ampere
   @@connection = nil
   
+  # Open a new Redis connection. `options` is passed directly to the Redis.connect
+  # method.
   def self.connect(options = {})
     @@connection = Redis.connect(options)
   end
   
+  # Closes the Redis connection.
   def self.disconnect
     return unless connected?
     @@connection.quit
     @@connection = nil
   end
   
+  # Returns `true` if the Redis connection is active.
   def self.connected?
     !! @@connection
   end
   
+  # Gives access to the Redis connection object.
   def self.connection
     @@connection
   end
+
+  # Alias for Ampere.redis.flushall
+  def self.flush
+    @@connection.flushall if connected?
+  end
+  
 end
 
-Dir[File.join(File.dirname(__FILE__), 'ampere', '**', '*.rb')].each {|f| require f}
+Dir[File.join(File.dirname(__FILE__), 'ampere', '**', '*.rb')].each {|f| require f}
+
+require File.join(File.dirname(__FILE__), "rails", "railtie.rb") if defined?(Rails)
+

data/lib/rails/generators/ampere/config/config_generator.rb

@@ -0,0 +1,15 @@
+module Ampere
+  module Generators
+    class ConfigGenerator < Rails::Generators::Base
+      source_root File.expand_path("../templates", __FILE__)
+    
+      desc "Installs a skeleton Ampere config file for you."
+    
+      argument :prefix, :type => :string, :optional => true
+    
+      def create_config_file
+        template 'ampere.yml', File.join('config', "ampere.yml")
+      end
+    end
+  end
+end

data/lib/rails/generators/ampere/config/templates/ampere.yml

@@ -0,0 +1,11 @@
+development:
+  host: 127.0.0.1
+  port: 6379
+
+test:
+  host: 127.0.0.1
+  port: 6379
+
+production:
+  host: 127.0.0.1
+  port: 6379

data/lib/rails/generators/ampere/model/model_generator.rb

@@ -0,0 +1,27 @@
+module Ampere #:nodoc:
+  module Generators #:nodoc:
+    class ModelGenerator < Rails::Generators::NamedBase #:nodoc:
+      source_root File.expand_path("../templates", __FILE__)
+
+      desc "Creates an Ampere model"
+      argument :attributes, :type => :array, :default => [], :banner => "field field"
+
+      check_class_collision
+
+      def create_model_file
+        template "model.rb.tt", File.join("app/models", class_path, "#{file_name}.rb")
+      end
+
+      hook_for :test_framework
+    
+      unless methods.include?(:module_namespacing)
+
+        # This is only defined on Rails edge at the moment, so include here now
+        # as per: https://github.com/mongoid/mongoid/issues/744
+        def module_namespacing(&block)
+          yield if block
+        end
+      end
+    end
+  end
+end

data/lib/rails/generators/ampere/model/templates/model.rb.tt

@@ -0,0 +1,10 @@
+<% module_namespacing do -%>
+class <%= class_name %>
+  include Ampere::Model
+
+<% attributes.reject{|attr| attr.reference?}.each do |attribute| -%>
+  field :<%= attribute.name %>
+<% end -%>
+
+end
+<% end -%>

data/lib/rails/railtie.rb

@@ -0,0 +1,49 @@
+require 'rails'
+
+module Ampere
+  class Railtie < Rails::Railtie
+    if config.respond_to?(:app_generators) then
+      config.app_generators.orm :ampere, :migration => false
+    else
+      config.generators.orm :ampere, :migration => false
+    end
+    
+    console do
+      Ampere.connect
+      puts "[ampere] Connected."
+    end
+    
+    initializer 'railtie.initialize_redis_connection' do |app|
+      config_file = Rails.root.join("config", "ampere.yml")
+      
+      options = {
+        'development' => {
+          'host' => '127.0.0.1',
+          'port' => 6379
+        },
+        'test' => {
+          'host' => '127.0.0.1',
+          'port' => 6379
+        },
+        'production' => {
+          'host' => '127.0.0.1',
+          'port' => 6379
+        },
+      }
+      
+      if config_file.file?
+        options = YAML.load_file(config_file)
+      end
+      
+      Rails.logger.info "[ampere] Initializing redis connection redis://#{options[Rails.env]['host']}:#{options[Rails.env]['port']}"
+      
+      Ampere.connect options[Rails.env]
+    end
+    
+    rake_tasks do
+      load File.join(File.dirname(__FILE__), '..', 'rails', 'tasks', 'ampere.rake')
+    end
+    
+  end
+  
+end

data/lib/rails/tasks/ampere.rake

@@ -0,0 +1,7 @@
+namespace :ampere do
+  desc "Flush ALL data out of Redis (only call this if you know what you're doing!)"
+  task :flush do
+    Redis.new.flushall
+  end
+  
+end

data/spec/models/model_spec.rb

@@ -177,7 +177,9 @@ describe "Base models", :model => true do
                          :content => "and it doesn't even make sense."
       id = post.id
       post.should_not be_nil
-      Post.delete(id).should == 1
+      deleted_post = Post.delete(id)
+      deleted_post.should eq(post)
+      deleted_post.title.should eq(post.title)
       Post.find(id).should be_nil
     end
     
@@ -186,7 +188,7 @@ describe "Base models", :model => true do
                                  :byline  => "Just seems like one big",
                                  :content => "non sequitor."
       id = another_post.id
-      another_post.destroy.should == 1
+      another_post.destroy.should eq(another_post)
       Post.find(id).should be_nil
     end
     
@@ -207,9 +209,17 @@ describe "Base models", :model => true do
       post = Post.create :title   => "Another title",
                          :byline  => "Max",
                          :content => "Some other content"
+      post.should be_persisted
       Post.find(post.id).should == post
     end
     
+    it "should return an integer for its ID" do
+      post = Post.create :title   => "On Motorcycles and Robots",
+                         :byline  => "Max",
+                         :content => "Motorcycles and robots are awesome"
+      post.id.should be_a(Fixnum)
+    end
+    
     # # #
     
     after :all do

data/spec/models/timestamps_spec.rb

@@ -0,0 +1,45 @@
+describe Ampere::Timestamps do
+  before :all do
+    Ampere.connect
+    
+    Ampere.connection.flushall
+    
+    class Comment
+      include Ampere::Model
+      include Ampere::Timestamps
+      
+      field :body
+    end
+  end
+  
+  context 'when included in models' do
+    it 'sets created_at for newly-created record' do
+      Timecop.freeze(Time.now) do
+        time = Time.now
+        
+        c = Comment.create body: "I am intrigued by your ideas, and would like to subscribe to your newsletter."
+        c.created_at.should eq(time)
+        c.updated_at.should eq(time)
+      end
+    end
+    
+    it 'sets updated_at when changing records' do
+      c = Comment.create body: "I am intrigued by your ideas, and would like to subscribe to your newsletter."
+      created_at = c.created_at
+      
+      time = 0
+      
+      Timecop.freeze(Time.now + 30) do
+        time = Time.now
+        
+        c.body = "Theodore Roosevelt riding a moose, therefore your argument is invalid."
+        c.save
+      end
+      
+      c.updated_at.should eq(time)
+      c.created_at.should eq(created_at)
+    end
+    
+  end
+  
+end

data/spec/module/collections_spec.rb

@@ -72,6 +72,11 @@ describe 'Collections', :collections => true do
     republicans.to_a.map(&:name).should == ["Ulysses S. Grant", "Abraham Lincoln"]
   end
   
+  it 'should give its first and last elements non-lazily' do
+    President.first.name.should eq("Millard Fillmore")
+    President.last.name.should eq("Jimmy Carter")
+  end
+  
   ###
   
   after :all do

data/spec/spec_helper.rb

@@ -7,6 +7,7 @@ end
 require 'rspec'
 require 'rspec/autorun'
 require 'shoulda'
+require 'timecop'
 
 require 'ampere'