ripple 1.0.0.beta → 1.0.0.beta2

data/lib/ripple/properties.rb

@@ -37,7 +37,8 @@ module Ripple
     # @param [String, Symbol] key the key of the property
     # @param [Class] type the Ruby type of the property. Use {Boolean} for true or false types.
     # @param [Hash] options configuration options
-    # @option options [Object, Proc] :default (nil) a default value for the property, or a lambda to evaluate when providing the default.
+    # @option options [Object, Proc] :default (nil) a default value
+    #   for the property, or a lambda to evaluate when providing the default.
     def initialize(key, type, options={})
       @options = options.to_options
       @key = key.to_sym

data/lib/ripple/railtie.rb

@@ -13,5 +13,14 @@ module Ripple
         Ripple.load_configuration Rails.root.join('config', 'ripple.yml'), [Rails.env]
       end
     end
+
+    initializer "ripple.configure_test_server_root", :after => "ripple.configure_rails_initialization" do
+      unless Rails.env.development? || Rails.env.production?
+        # Make sure the TestServer lives in the default location, if
+        # not set in the config file.
+        Ripple.config[:root] ||= (Rails.root + 'tmp/riak_test_server').to_s
+        Ripple.config[:js_source_dir] ||= (Rails.root + "app/mapreduce").to_s
+      end
+    end
   end
 end

data/lib/ripple/railties/ripple.rake

@@ -22,14 +22,8 @@ namespace :riak do
     cluster.create
   end
 
-  desc "Destroys and recreates the cluster for the current environment."
-  task :reset => ['riak:destroy', 'riak:setup']
-
-  desc "Creates the Riak cluster and loads the seed data."
-  task :setup => ["riak:create", "db:seed"]
-
   desc "Destroys the generated Riak cluster for the current environment."
-  task :destroy => :rails_env do
+  task :destroy => ['rails_env', 'riak:stop'] do
     cluster.destroy
   end
 
@@ -60,13 +54,36 @@ namespace :riak do
 end
 
 namespace :db do
+  desc "Creates the database(s) for the current environment"
   task :create => "riak:create"
-  namespace(:create){ task :all => "riak:create:all" }
-  task :drop => "riak:drop"
-  namespace(:drop) { task :all => "riak:drop:all" }
-  task :setup => "riak:setup"
-  task :reset => "riak:reset"
-  task seed: ['riak:start', 'environment'] do
+
+  namespace(:create) do
+    desc "Creates the database(s) for all environments"
+    task :all => "riak:create:all"
+  end
+
+  desc "Drops the database(s) for the current environment"
+  task :drop => ['db:stop', 'riak:drop']
+
+  namespace(:drop) do
+    desc "Drops the database(s) for all environments"
+    task :all => "riak:drop:all"
+  end
+
+  desc "Starts the database(s) for the current environment"
+  task :start => 'riak:start'
+
+  desc "Stops the database(s) for the current environment"
+  task :stop => 'riak:stop'
+
+  desc "Creates the database(s) and loads the seed data."
+  task :setup => ['db:create', 'db:start', 'db:seed']
+
+  desc "Drops and recreates the database(s) for the current environment."
+  task :reset => ['db:drop', 'db:setup']
+
+  desc "Loads the seed data in to the current environment"
+  task :seed => :environment do
     Rails.application.load_seed
   end
 end
@@ -79,8 +96,8 @@ end
 
 def cluster(environment=nil, config=nil)
   environment ||= Rails.env
-  config ||= load_config[environment]
+  config ||= load_config[environment].with_indifferent_access
   root = Rails.root + "db" + environment.to_s
   # TODO: We need to deal with multiple hosts and client ports
-  Riak::Cluster.new(config.merge(:root => root.to_s).with_indifferent_access)
+  Riak::Cluster.new({ :root => root.to_s }.merge(config).with_indifferent_access)
 end

data/lib/ripple/serialization.rb

@@ -24,61 +24,59 @@ module Ripple
     extend ActiveSupport::Concern
     include ::ActiveModel::Serializers::JSON
 
-    module InstanceMethods
-      # Creates a Hash suitable for conversion to an external format.
-      # @param [Hash] options (nil) serialization options
-      # @option options [Array<Symbol>] :only emit only the specified attributes
-      # @option options [Array<Symbol>] :except omit the specified attributes
-      # @option options [Array<Symbol>, Hash] :include include the
-      #      specified associations (with or without extra
-      #      options). This defaults to all embedded associations.
-      # @return [Hash] a hash of attributes and embedded documents
-      def serializable_hash(options=nil)
-        options = options.try(:clone) || {}
-
-        unless options.has_key?(:include)
-          options[:include] = self.class.embedded_associations.map(&:name)
-        end
-
-        hash = super(options)
-
-        hash['key'] = key if respond_to?(:key) && key.present? && (!options[:except] || !options[:except].map(&:to_s).include?("key"))
-
-        serializable_add_includes(options) do |association, records, opts|
-          hash[association.to_s] = records.is_a?(Enumerable) ? records.map {|r| r.serializable_hash(opts) } : records.serializable_hash(opts)
-        end
-        hash
+    # Creates a Hash suitable for conversion to an external format.
+    # @param [Hash] options (nil) serialization options
+    # @option options [Array<Symbol>] :only emit only the specified attributes
+    # @option options [Array<Symbol>] :except omit the specified attributes
+    # @option options [Array<Symbol>, Hash] :include include the
+    #      specified associations (with or without extra
+    #      options). This defaults to all embedded associations.
+    # @return [Hash] a hash of attributes and embedded documents
+    def serializable_hash(options=nil)
+      options = options.try(:clone) || {}
+    
+      unless options.has_key?(:include)
+        options[:include] = self.class.embedded_associations.map(&:name)
       end
-
-      private
-      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 = case self.class.associations[association.to_sym].type
-                    when :many
-                      send(association).to_a
-                    when :one
-                      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
+    
+      hash = super(options)
+    
+      hash['key'] = key if respond_to?(:key) && key.present? && (!options[:except] || !options[:except].map(&:to_s).include?("key"))
+    
+      serializable_add_includes(options) do |association, records, opts|
+        hash[association.to_s] = records.is_a?(Enumerable) ? records.map {|r| r.serializable_hash(opts) } : records.serializable_hash(opts)
+      end
+      hash
+    end
+    
+    private
+    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 = case self.class.associations[association.to_sym].type
+                  when :many
+                    send(association).to_a
+                  when :one
+                    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
-
-        options[:include] = include_associations
       end
+    
+      options[:include] = include_associations
     end
   end
 end

data/lib/ripple/test_server.rb

@@ -23,13 +23,12 @@ module Ripple
     def initialize(options=Ripple.config.dup)
       options[:env] ||= {}
       options[:env][:riak_kv] ||= {}
-      options[:env][:riak_kv][:js_source_dir] ||= Ripple.config.delete(:js_source_dir) || (Rails.root + "app/mapreduce").to_s
+      options[:env][:riak_kv][:js_source_dir] ||= Ripple.config.delete(:js_source_dir)
       options[:env][:riak_kv][:map_cache_size] ||= 0
       options[:env][:riak_core] ||= {}
       options[:env][:riak_core][:http] ||= [ Tuple[Ripple.config[:host], Ripple.config[:http_port]] ]
       options[:env][:riak_kv][:pb_port] ||= Ripple.config[:pb_port]
       options[:env][:riak_kv][:pb_ip] ||= Ripple.config[:host]
-      options[:root] ||= (Rails.root + 'tmp/riak_test_server').to_s
       super(options)
     end
   end

data/lib/ripple/timestamps.rb

@@ -10,18 +10,16 @@ module Ripple
     module ClassMethods
       # Adds the :created_at and :updated_at timestamp properties to
       # the document.
-      def timestamps!
-        property :created_at, Time, :default => proc { Time.now }
-        property :updated_at, Time
+      def timestamps!(options={})
+        property :created_at, Time, options.merge(:default => proc { Time.now })
+        property :updated_at, Time, options.dup
         before_save :touch
       end
     end
 
-    module InstanceMethods
-      # Sets the :updated_at attribute before saving the document.
-      def touch
-        self.updated_at = Time.now
-      end
+    # Sets the :updated_at attribute before saving the document.
+    def touch
+      self.updated_at = Time.now
     end
   end
 end

data/lib/ripple/validations.rb

@@ -36,31 +36,29 @@ module Ripple
 
       # Instantiates a new document, applies attributes from a block, and saves it
       # Raises Ripple::DocumentInvalid if the record did not save
-      def create!(attrs={}, &block)
-        obj = create(attrs, &block)
+      def create!(*args, &block)
+        obj = create(*args, &block)
         (raise Ripple::DocumentInvalid.new(obj) if obj.new?) || obj
       end
     end
 
-    module InstanceMethods
-      # @private
-      def save(options={:validate => true})
-        return false if options[:validate] && !valid?
-        super()
-      end
-
-      # Saves the document and raises {DocumentInvalid} exception if
-      # validations fail.
-      def save!
-        (raise Ripple::DocumentInvalid.new(self) unless save) || true
-      end
-
-      # Sets the passed attributes and saves the document, raising a
-      # {DocumentInvalid} exception if the validations fail.
-      def update_attributes!(attrs)
-        self.attributes = attrs
-        save!
-      end
+    # @private
+    def save(options={:validate => true})
+      return false if options[:validate] && !valid?
+      super()
+    end
+    
+    # Saves the document and raises {DocumentInvalid} exception if
+    # validations fail.
+    def save!
+      (raise Ripple::DocumentInvalid.new(self) unless save) || true
+    end
+    
+    # Sets the passed attributes and saves the document, raising a
+    # {DocumentInvalid} exception if the validations fail.
+    def update_attributes!(attrs)
+      self.attributes = attrs
+      save!
     end
   end
 end

data/lib/ripple/version.rb

@@ -1,3 +1,3 @@
 module Ripple
-  VERSION = "1.0.0.beta"
+  VERSION = "1.0.0.beta2"
 end

data/ripple.gemspec

@@ -12,11 +12,12 @@ Gem::Specification.new do |gem|
   gem.authors = ["Sean Cribbs"]
 
   # Deps
-  gem.add_development_dependency "rspec", "~>2.6.0"
-  gem.add_development_dependency 'rake', '~> 0.8.7'
-  gem.add_dependency "riak-client", "~>#{Ripple::VERSION}"
-  gem.add_dependency "activesupport", [">= 3.0.0", "< 3.2.0"]
-  gem.add_dependency "activemodel", [">= 3.0.0", "< 3.2.0"]
+  gem.add_development_dependency "rspec", "~>2.8.0"
+  gem.add_development_dependency 'rake'
+  gem.add_development_dependency 'ammeter', '~>0.2.2'
+  gem.add_dependency "riak-client", "~> 1.0.0"
+  gem.add_dependency "activesupport", [">= 3.0.0", "< 3.3.0"]
+  gem.add_dependency "activemodel", [">= 3.0.0", "< 3.3.0"]
   gem.add_dependency "tzinfo"
 
   # Files

data/spec/generators/ripple/configuration_generator_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+require 'rails/generators/ripple/configuration/configuration_generator'
+
+describe Ripple::Generators::ConfigurationGenerator do
+  before { run_generator }
+  it "should generate the ripple.yml file" do
+    file('config/ripple.yml').should exist
+  end
+end

data/spec/generators/ripple/js_generator_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+require 'rails/generators/ripple/js/js_generator'
+
+describe Ripple::Generators::JsGenerator do
+  before { run_generator }
+
+  it "should create an app/mapreduce directory" do
+    file('app/mapreduce').should exist
+  end
+
+  it "should copy all standard JS files into the mapreduce directory" do
+    Dir[file('app/mapreduce/*')].sort.map{|f| File.basename(f) }.should == %w{contrib.js iso8601.js ripple.js}
+  end
+end

data/spec/generators/ripple/model_generator_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'rails/generators/ripple/model/model_generator'
+
+shared_examples_for :model_generator do
+  it("should create the model file"){ model_file.should exist }
+  it { should contain(class_decl) }
+  it("should create the attribute declarations") do
+    attributes.each do |name, type|
+      should contain("property :#{name}, #{type}")
+    end
+  end
+end
+
+shared_examples_for :subclass_model_generator do
+  it_behaves_like :model_generator
+  it { should_not contain("include Ripple::Document") }
+  it { should_not contain("include Ripple::EmbeddedDocument") }
+end
+
+shared_examples_for :embedded_document_generator do
+  it_behaves_like :model_generator
+  it { should contain("include Ripple::EmbeddedDocument") }
+end
+
+shared_examples_for :document_generator do
+  it_behaves_like :model_generator
+  it { should contain("include Ripple::Document") }
+end
+
+describe Ripple::Generators::ModelGenerator do
+  let(:cli){ %w{general_model} }
+  let(:model_file){ file('app/models/general_model.rb') }
+  let(:class_decl){ "class GeneralModel" }
+  let(:attributes){ {} }
+  subject { model_file }
+  before { run_generator cli }
+
+  describe "generating a bare model" do
+    it_behaves_like :document_generator
+  end
+
+  describe "generating with attributes" do
+    let(:cli){ %w{general_model name:string shipped:datetime size:integer} }
+    let(:attributes) { {:name => String, :shipped => Time, :size => Integer } }
+    it_behaves_like :document_generator
+  end
+
+  describe "generating a model with a parent class" do
+    let(:cli){ %w{general_model --parent=widget} }
+    let(:class_decl){ "class GeneralModel < Widget" }
+    it_behaves_like :subclass_model_generator
+  end
+
+  describe "generating an embedded model" do
+    let(:cli){ %w{general_model --embedded} }
+    it_behaves_like :embedded_document_generator
+  end
+
+  describe "generating a model embedded in a parent document" do
+    let(:cli){ %w{general_model --embedded-in=widget} }
+    it_behaves_like :embedded_document_generator
+    it { should contain("embedded_in :widget") }
+  end
+end

data/spec/generators/ripple/observer_generator_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+require 'rails/generators/ripple/observer/observer_generator'
+
+describe Ripple::Generators::ObserverGenerator do
+  context "in the top-level scope" do
+    before { run_generator %w{person} }
+    subject{ file('app/models/person_observer.rb') }
+
+    it { should exist }
+    it { should contain("class PersonObserver < ActiveModel::Observer") }
+  end
+
+  context "in a nested scope" do
+    before { run_generator %w{profiles/social} }
+    subject { file('app/models/profiles/social_observer.rb') }
+
+    it { should exist }
+    it { should contain("class Profiles::SocialObserver < ActiveModel::Observer") }
+  end
+end

data/spec/generators/ripple/test_generator_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+require 'rails/generators/ripple/test/test_generator'
+
+describe Ripple::Generators::TestGenerator do
+  context "when Cucumber is present" do
+    before { mkdir_p file('features/support') }
+    before { run_generator }
+
+    it "should create a support file for the test server" do
+      file('features/support/ripple.rb').should exist
+    end
+  end
+
+  context "when RSpec is present" do
+    let(:original_contents) do
+      [
+       "require 'rspec'",
+       "RSpec.configure do |config|",
+       "  config.mock_with :rspec",
+       "end"
+      ]
+    end
+    let(:helper) { file('spec/spec_helper.rb') }
+    let(:contents) { File.read(helper) }
+    before do
+      mkdir_p file('spec')
+      File.open(helper,'w') do |f|
+        f.write original_contents.join("\n")
+      end
+      run_generator
+    end
+
+    it "should insert the test server require" do
+      contents.should include("require 'ripple/test_server'")
+    end
+
+    it "should insert the test server setup" do
+      contents.should include("  config.before(:suite) { Ripple::TestServer.setup }")
+      contents.should include("  config.after(:each) { Ripple::TestServer.clear }")
+    end
+
+    context "when the configuration block is indented" do
+      let(:original_contents) do
+        [
+         "require 'rspec'",
+         "require 'spork'",
+         "Spork.prefork do",
+         "  RSpec.configure do |config|",
+         "    config.mock_with :rspec",
+         "  end",
+         "end"
+        ]
+      end
+
+      it "should insert the test server require with additional indentation" do
+        contents.should include("  require 'ripple/test_server'")
+      end
+
+      it "should insert the test server setup with additional indentation" do
+        contents.should include("    config.before(:suite) { Ripple::TestServer.setup }")
+        contents.should include("    config.after(:each) { Ripple::TestServer.clear }")
+      end
+    end
+  end
+
+  context "when Test::Unit is present" do
+    let(:original_contents) do
+      [
+       "require 'active_support/test_case'",
+       "class ActiveSupport::TestCase",
+       "  setup :load_fixtures",
+       "end"
+      ]
+    end
+    let(:helper) { file('test/test_helper.rb') }
+    let(:contents) { File.read(helper) }
+    before do
+      mkdir_p file('test')
+      File.open(helper,'w') do |f|
+        f.write original_contents.join("\n")
+      end
+      run_generator
+    end
+
+    it "should insert the test server require" do
+      contents.should include("require 'ripple/test_server'")
+    end
+
+    it "should insert the test server setup and teardown" do
+      contents.should include("  setup { Ripple::TestServer.setup }")
+      contents.should include("  teardown { Ripple::TestServer.clear }")
+    end
+
+    context "when the test case class is indented" do
+      let(:original_contents) do
+        [
+         "require 'active_support/test_case'",
+         "module MyApp",
+         "  class ActiveSupport::TestCase",
+         "    setup :load_fixtures",
+         "  end",
+         "end"
+        ]
+      end
+
+      it "should insert the test server require with additional indentation" do
+        contents.should include("  require 'ripple/test_server'")
+      end
+
+      it "should insert the test server setup and teardown with additional indentation" do
+        contents.should include("    setup { Ripple::TestServer.setup }")
+        contents.should include("    teardown { Ripple::TestServer.clear }")
+      end
+    end
+  end
+end