ripple 0.6.1 → 0.7.0

data/lib/ripple/document/finders.rb

@@ -14,6 +14,27 @@
 require 'ripple'
 
 module Ripple
+  
+  # Raised by <tt>find!</tt> when a document cannot be found with the given key.
+  #   begin
+  #     Example.find!('badkey')
+  #   rescue Ripple::DocumentNotFound
+  #     puts 'No Document here!'
+  #   end
+  class DocumentNotFound < StandardError
+    include Translation
+    def initialize(keys, found)
+      if keys.empty?
+        super(t("document_not_found.no_key"))
+      elsif keys.one?
+        super(t("document_not_found.one_key", :key => keys.first))
+      else
+        missing = keys - found.compact.map(&:key)
+        super(t("document_not_found.many_keys", :keys => missing.join(', ')))
+      end
+    end
+  end
+  
   module Document
     module Finders
       extend ActiveSupport::Concern
@@ -35,10 +56,33 @@ module Ripple
         #   @return [Array<Document>] a list of found documents, including nil for missing documents
         def find(*args)
           args.flatten!
-          return [] if args.length == 0
-          return find_one(args.first) if args.length == 1
+          return nil if args.empty?
+          return find_one(args.first) if args.one?
           args.map {|key| find_one(key) }
         end
+        
+        # Retrieve single or multiple documents from Riak
+        # but raise Ripple::DocumentNotFound if a key can
+        # not be found in the bucket.
+        def find!(*args)
+          found = find(*args)
+          raise DocumentNotFound.new(args, found) if !found || Array(found).include?(nil)
+          found
+        end
+        
+        # Find the first object using the first key in the
+        # bucket's keys using find. You should not expect to 
+        # actually get the first object you added to the bucket.
+        # This is just a convenience method.
+        def first
+          find(bucket.keys.first)
+        end
+        
+        # Find the first object using the first key in the
+        # bucket's keys using find!
+        def first!
+          find!(bucket.keys.first)
+        end
 
         # Find all documents in the Document's bucket and return them.
         # @overload all()
@@ -74,7 +118,10 @@ module Ripple
 
         def instantiate(robject)
           klass = robject.data['_type'].constantize rescue self
-          klass.new(robject.data.merge('key' => robject.key)).tap do |doc|
+          data = {'key' => robject.key}
+          data.reverse_merge!(robject.data) rescue data
+          klass.new(data).tap do |doc|
+            doc.key = data['key']
             doc.instance_variable_set(:@new, false)
             doc.instance_variable_set(:@robject, robject)
           end

data/lib/ripple/document/persistence.rb

@@ -18,11 +18,20 @@ module Ripple
     module Persistence
       extend ActiveSupport::Concern
       extend ActiveSupport::Autoload
+      
+      module ClassMethods
+        
+        # Instantiates a new record, applies attributes from a block, and saves it
+        def create(attrs={}, &block)
+          new(attrs, &block).tap {|s| s.save}
+        end
 
-      autoload :Callbacks
-
-      included do
-        include Ripple::Document::Persistence::Callbacks
+        # Destroys all records one at a time.
+        # Place holder while :delete to bucket is being developed.
+        def destroy_all
+          all(&:destroy)
+        end
+        
       end
 
       module InstanceMethods
@@ -36,7 +45,6 @@ module Ripple
         def new?
           @new || false
         end
-        alias :new_record? :new?
 
         # Saves the document in Riak.
         # @return [true,false] whether the document succeeded in saving
@@ -73,7 +81,7 @@ module Ripple
         def freeze
           @attributes.freeze; super
         end
-
+        
         protected
         attr_writer :robject
 

data/lib/ripple/document/validations.rb

@@ -14,10 +14,31 @@
 require 'ripple'
 
 module Ripple
+  
+  # Raised by <tt>save!</tt> when the document is invalid.  Use the
+  # +document+ method to retrieve the document which did not validate.
+  #   begin
+  #     invalid_document.save!
+  #   rescue Ripple::DocumentInvalid => invalid
+  #     puts invalid.document.errors
+  #   end
+  class DocumentInvalid < StandardError
+    include Translation
+    attr_reader :document
+    def initialize(document)
+      @document = document
+      errors = @document.errors.full_messages.join(", ")
+      super(t("document_invalid", :errors => errors))
+    end
+  end
+  
   module Document
     module Validations
       extend ActiveSupport::Concern
+      extend ActiveSupport::Autoload
       include ActiveModel::Validations
+      
+      autoload :AssociatedValidator
 
       module ClassMethods
         # @private
@@ -25,19 +46,26 @@ module Ripple
           prop = super
           validates key, prop.validation_options unless prop.validation_options.blank?
         end
+        
+        # Instantiates a new record, 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)
+          (raise Ripple::DocumentInvalid.new(obj) if obj.new?) || obj
+        end
       end
 
       module InstanceMethods
         # @private
-        def save
-          valid? && super
+        def save(options={:validate => true})
+          return false if options[:validate] && !valid?
+          super()
         end
-
-        # @private
-        def valid?
-          @_on_validate = new? ? :create : :update
-          super
+        
+        def save!
+          (raise Ripple::DocumentInvalid.new(self) unless save) || true
         end
+        
       end
     end
   end

data/lib/ripple/document/validations/associated_validator.rb

@@ -0,0 +1,37 @@
+# Copyright 2010 Sean Cribbs, Sonian Inc., and Basho Technologies, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+#
+# Taken from ActiveRecord::Validations::AssociatedValidators
+#
+
+require 'ripple'
+
+module Ripple
+  module Document
+    module Validations
+      class AssociatedValidator < ActiveModel::EachValidator
+        def validate_each(record, attribute, value)
+          return if (value.is_a?(Array) ? value : [value]).collect{ |r| r.nil? || r.valid? }.all?
+          record.errors.add(attribute, :invalid, :default => options[:message], :value => value)
+        end
+      end
+
+      module ClassMethods
+        def validates_associated(*attr_names)
+          validates_with AssociatedValidator, _merge_attributes(attr_names)
+        end
+      end
+    end
+  end
+end

data/lib/ripple/embedded_document.rb

@@ -18,16 +18,22 @@ module Ripple
     extend ActiveSupport::Concern
     extend ActiveSupport::Autoload
 
+    autoload :Conversion
+    autoload :Finders
     autoload :Persistence
     include Translation
 
     included do
       extend ActiveModel::Naming
       extend Ripple::Document::Properties
-      include Persistence
       include Ripple::Document::AttributeMethods
       include Ripple::Document::Timestamps
       include Ripple::Document::Validations
+      include Ripple::Document::Associations
+      include Ripple::Document::Callbacks
+      include Conversion
+      include Finders
+      include Persistence
     end
 
     module ClassMethods
@@ -36,4 +42,4 @@ module Ripple
       end
     end
   end
-end
+end

data/lib/{riak/map_reduce_error.rb → ripple/embedded_document/conversion.rb}

@@ -11,10 +11,24 @@
 #    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
-require 'riak'
+require 'ripple'
 
-module Riak
-  # Raised when an error occurred in the Javascript map-reduce chain.
-  # The message will be the body of the JSON error response.
-  class MapReduceError < StandardError; end
+module Ripple
+  module EmbeddedDocument
+    module Conversion
+      extend ActiveSupport::Concern
+
+      module InstanceMethods
+        include ActiveModel::Conversion
+        
+        def to_key
+          new? ? nil : [key]
+        end
+
+        def to_param
+          key
+        end
+      end
+    end
+  end
 end

data/lib/{riak/invalid_response.rb → ripple/embedded_document/finders.rb}

@@ -11,15 +11,24 @@
 #    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
-require 'riak'
+require 'ripple'
 
-module Riak
-  # Raised when Riak returns a response that is in an unexpected format
-  class InvalidResponse < StandardError
-    def initialize(expected, received, extra="")
-      expected = expected.inspect if Hash === expected
-      received = received.inspect if Hash === received
-      super "Expected #{expected} but received #{received} from Riak #{extra}"
+module Ripple
+  module EmbeddedDocument
+    module Finders
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def instantiate(attrs)
+          begin
+            klass = attrs['_type'].present? ? attrs['_type'].constantize : self
+            klass.new(attrs)
+          rescue NameError
+            new(attrs)
+          end
+        end
+      end
+      
     end
   end
 end

data/lib/ripple/embedded_document/persistence.rb

@@ -14,32 +14,94 @@
 require 'ripple'
 
 module Ripple
+  class NoRootDocument < StandardError
+    include Translation
+    def initialize(doc, method)
+      super(t("no_root_document", :doc => doc.inspect, :method => method))
+    end
+  end
+  
   module EmbeddedDocument
     module Persistence
       extend ActiveSupport::Concern
-
-      included do
-        attr_accessor :_root_document
+      
+      module ClassMethods
+        def embedded_in(parent)
+          define_method(parent) { @_parent_document }
+        end
       end
-
+      
       module InstanceMethods
-        # Delegates to the root document
+        
+        attr_reader :_parent_document
+        
+        def embeddable?
+          self.class.embeddable?
+        end
+        
         def new?
-          if @_root_document
-            @_root_document.new?
-          else
+          if _root_document?
             super
+          elsif @_root_document
+            _root_document.new?
+          else
+            true
           end
         end
-
-        # Delegates to the root document
-        def save
-          if @_root_document
-            @_root_document.save
+        
+        # because alias_method doesn't like super
+        def new_record?; new?; end
+        
+        # for ActiveModel::Conversion
+        def persisted?; !new?; end
+        
+        def save(*args)
+          if _root_document?
+            super
+          elsif @_root_document
+            _root_document.save(*args)
           else
+            raise NoRootDocument.new(self, :save)
+          end
+        end
+        
+        def save!(*args)
+          if _root_document?
             super
+          elsif @_root_document
+            _root_document.save!(*args)
+          else
+            raise NoRootDocument.new(self, :save!)
           end
         end
+        
+        def _root_document
+          embeddable? ? @_root_document : self
+        end
+        
+        def _root_document?
+          _root_document === self
+        end
+
+        def attributes_for_persistence
+          attributes.merge("_type" => self.class.name).merge(embedded_attributes_for_persistence)
+        end
+        
+        def _parent_document=(value)
+          @_root_document   = value._root_document
+          @_parent_document = value
+        end
+        
+        protected
+        
+          def embedded_attributes_for_persistence
+            embedded_associations.inject({}) do |attrs, association|
+              if documents = instance_variable_get(association.ivar)
+                attrs[association.name] = documents.is_a?(Array) ? documents.map(&:attributes_for_persistence) : documents.attributes_for_persistence
+              end
+              attrs
+            end
+          end
       end
     end
   end

data/lib/ripple/locale/en.yml

@@ -14,4 +14,10 @@
 en:
   ripple:
     property_type_mismatch: "Cannot cast {{value}} into a {{class}}"
-    attribute_hash: "value of attributes must be a Hash"
+    attribute_hash: "value of attributes must be a Hash"
+    document_invalid: "Validation failed: {{errors}}"
+    document_not_found: 
+      no_key: "Couldn't find document without a key"
+      one_key: "Couldn't find document with key: {{key}}"
+      many_keys: "Couldn't find documents with keys: {{keys}}"
+    no_root_document: "You cannot call {{method}} on {{doc}} without a root document"

data/{spec/riak/net_http_backend_spec.rb → lib/ripple/railtie.rb}

@@ -11,18 +11,22 @@
 #    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 #    See the License for the specific language governing permissions and
 #    limitations under the License.
-require File.expand_path("../spec_helper", File.dirname(__FILE__))
-                  
-describe Riak::Client::NetHTTPBackend do
-  before :each do
-    @client = Riak::Client.new
-    @backend = Riak::Client::NetHTTPBackend.new(@client)
-    FakeWeb.allow_net_connect = false
-  end
+require 'ripple'
+require 'rails'
 
-  def setup_http_mock(method, uri, options={})
-    FakeWeb.register_uri(method, uri, options)
+# require in gemfile using
+# <tt>gem "ripple", :require_as => ["ripple", "ripple/railtie"]</tt>
+module Ripple
+  class Railtie < Rails::Railtie
+    railtie_name :ripple
+    
+    initializer "ripple.configure_rails_initialization" do
+      Ripple.load_configuration
+    end
   end
-
-  it_should_behave_like "HTTP backend"
-end
+  
+  def self.load_configuration
+    config_file = Rails.root.join('config', 'database.yml')
+    self.config = YAML.load_file(File.expand_path config_file).with_indifferent_access[:ripple][Rails.env]
+  end
+end