ripple 0.7.1 → 0.8.0.beta

data/Rakefile

@@ -11,10 +11,10 @@ gemspec = Gem::Specification.new do |gem|
   gem.email = "seancribbs@gmail.com"
   gem.homepage = "http://seancribbs.github.com/ripple"
   gem.authors = ["Sean Cribbs"]
-  gem.add_development_dependency "rspec", "~>2.0.0.beta.6"
+  gem.add_development_dependency "rspec", "~>2.0.0.beta.18"
   gem.add_dependency "riak-client", version
-  gem.add_dependency "activesupport", "3.0.0.beta3"
-  gem.add_dependency "activemodel", "3.0.0.beta3"
+  gem.add_dependency "activesupport", "3.0.0.rc2"
+  gem.add_dependency "activemodel", "3.0.0.rc2"
 
   files = FileList["**/*"]
   files.exclude /\.DS_Store/
@@ -26,6 +26,7 @@ gemspec = Gem::Specification.new do |gem|
   files.exclude '**/*.rej'
   files.exclude /^pkg/
   files.exclude 'ripple.gemspec'
+  files.exclude 'Gemfile'
 
   gem.files = files.to_a
 
@@ -48,7 +49,7 @@ end
 
 desc %{Release the gem to RubyGems.org}
 task :release => :gem do
-  "gem push pkg/#{gemspec.name}-#{gemspec.version}.gem"
+  system "gem push pkg/#{gemspec.name}-#{gemspec.version}.gem"
 end
 
 require 'rspec/core'

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

@@ -0,0 +1,20 @@
+require 'rails/generators/ripple_generator'
+
+module Ripple
+  module Generators
+    class ModelGenerator < Base
+      desc 'Creates a ripple model'
+      argument :attributes, :type => :array, :default => [], :banner => 'field:type field:type'
+      class_option :parent, :type => :string, :desc => "The parent class for the generated model"
+      class_option :embedded, :type => :boolean, :desc => "Make an embedded document model.", :default => false
+      class_option :embedded_in, :type => :string, :desc => "Specify the enclosing model for the embedded document. Implies --embedded."
+      check_class_collision
+
+      def create_model_file
+        template 'model.rb', "app/models/#{file_path}.rb"
+      end
+
+      hook_for :test_framework
+    end
+  end
+end

data/lib/rails/generators/ripple/model/templates/model.rb

@@ -0,0 +1,10 @@
+class <%= class_name %><%= " < #{options[:parent].classify}" if options[:parent] %>
+<% unless options[:parent] -%>
+  include Ripple::<%= "Embedded" if options[:embedded] || options[:embedded_in] %>Document
+  <% if options[:embedded_in] -%>embedded_in :<%= options[:embedded_in].underscore %><% end -%> 
+<% end -%>
+
+<% attributes.reject{|attr| attr.reference?}.each do |attribute| -%>
+  property :<%= attribute.name %>, <%= attribute.type_class %>
+<% end -%>
+end

data/lib/rails/generators/ripple_generator.rb

@@ -0,0 +1,60 @@
+require "rails/generators/named_base"
+require "rails/generators/active_model"
+
+module Ripple
+  module Generators
+    class Base < ::Rails::Generators::NamedBase
+
+      def self.source_root
+        @_ripple_source_root ||=
+        File.expand_path("../#{base_name}/#{generator_name}/templates", __FILE__)
+      end
+    end
+
+    class ActiveModel < ::Rails::Generators::ActiveModel
+      def self.all(klass)
+        "#{klass}.all"
+      end
+
+      def self.find(klass, params=nil)
+        "#{klass}.find(#{params})"
+      end
+
+      def self.build(klass, params=nil)
+        if params
+          "#{klass}.new(#{params})"
+        else
+          "#{klass}.new"
+        end
+      end
+
+      def save
+        "#{name}.save"
+      end
+
+      def update_attributes(params=nil)
+        "#{name}.update_attributes(#{params})"
+      end
+
+      def errors
+        "#{name}.errors"
+      end
+
+      def destroy
+        "#{name}.destroy"
+      end
+    end
+  end
+end
+
+module Rails
+  module Generators
+    class GeneratedAttribute #:nodoc:
+      def type_class
+        return "Time" if type.to_s == "datetime"
+        return "String" if type.to_s == "text"
+        return type.to_s.camelcase
+      end
+    end
+  end
+end

data/lib/ripple.rb

@@ -16,12 +16,12 @@ require 'riak'
 require 'active_support/all'
 require 'active_model'
 require 'ripple/i18n'
+require 'ripple/core_ext'
 
 # Contains the classes and modules related to the ODM built on top of
 # the basic Riak client.
 module Ripple
   extend ActiveSupport::Autoload
-  include ActiveSupport::Configurable
 
   # Primary models
   autoload :EmbeddedDocument
@@ -42,10 +42,9 @@ module Ripple
   autoload :PropertyTypeMismatch
 
   # Utilities
+  autoload :Inspection
   autoload :Translation
 
-  DEFAULT_CONFIG = {}
-
   class << self
     # @return [Riak::Client] The client for the current thread.
     def client
@@ -60,11 +59,30 @@ module Ripple
 
     def config=(hash)
       self.client = nil
-      super
+      @config = hash.symbolize_keys
+    end
+
+    def config
+      @config ||= {}
     end
 
-    def load_config(config_file)
-      self.config = YAML.load_file(File.expand_path config_file).with_indifferent_access[:ripple]
+    def load_configuration(config_file, config_keys = [:ripple])
+      config_file = File.expand_path(config_file)
+      config_hash = YAML.load(ERB.new(File.read(config_file)).result).with_indifferent_access
+      config_keys.each {|k| config_hash = config_hash[k]}
+      self.config = config_hash || {}
+    rescue Errno::ENOENT
+      raise Ripple::MissingConfiguration.new(config_file)
+    end
+    alias_method :load_config, :load_configuration
+  end
+  
+  class MissingConfiguration < StandardError
+    include Translation
+    def initialize(file_path)
+      super(t("missing_configuration", :file => file_path))
     end
   end
 end
+
+require 'ripple/railtie' if defined? Rails::Railtie

data/lib/ripple/associations.rb

@@ -22,9 +22,12 @@ module Ripple
     autoload :One
     autoload :Many
     autoload :Embedded
+    autoload :Linked
     autoload :Instantiators
     autoload :OneEmbeddedProxy
     autoload :ManyEmbeddedProxy
+    autoload :OneLinkedProxy
+    autoload :ManyLinkedProxy
 
     module ClassMethods
       # @private
@@ -66,7 +69,7 @@ module Ripple
           value
         end
 
-        if association.one?
+        unless association.many?
           define_method("#{name}?") do
             get_proxy(association).present?
           end
@@ -98,6 +101,7 @@ module Ripple
   end
 
   class Association
+    include Ripple::Translation
     attr_reader :type, :name, :options
 
     # association options :using, :class_name, :class, :extend,
@@ -107,6 +111,7 @@ module Ripple
       @type, @name, @options = type, name, options.to_options
     end
 
+    # @return String The class name of the associated object(s)
     def class_name
       @class_name ||= case
                       when @options[:class_name]
@@ -120,38 +125,100 @@ module Ripple
                       end
     end
 
+    # @return [Class] The class of the associated object(s)
     def klass
       @klass ||= options[:class] || class_name.constantize
     end
 
+    # @return [true,false] Is the cardinality of the association > 1
     def many?
       @type == :many
     end
 
+    # @return [true,false] Is the cardinality of the association == 1
     def one?
       @type == :one
     end
 
+    # @return [true,false] Is the associated class an EmbeddedDocument
     def embeddable?
       klass.embeddable?
     end
 
+    # TODO: Polymorphic not supported
+    # @return [true,false] Does the association support more than one associated class
     def polymorphic?
       false
     end
 
+    # @return [true,false] Does the association use links
+    def linked?
+      using == :linked
+    end
+
+    # @return [String] the instance variable in the owner where the association will be stored
     def ivar
       "@_#{name}"
     end
 
+    # @return [Class] the association proxy class
     def proxy_class
       @proxy_class ||= proxy_class_name.constantize
     end
 
+    # @return [String] the class name of the association proxy
     def proxy_class_name
-      @using   ||= options[:using] || (embeddable? ? :embedded : :link)
-      klass_name = (many? ? 'Many' : 'One') + @using.to_s.camelize + ('Polymorphic' if polymorphic?).to_s + 'Proxy'
+      klass_name = (many? ? 'Many' : 'One') + using.to_s.camelize + ('Polymorphic' if polymorphic?).to_s + 'Proxy'
       "Ripple::Associations::#{klass_name}"
     end
+
+    # @return [Proc] a filter proc to be used with Enumerable#select for collecting links that belong to this association (only when #linked? is true)
+    def link_filter
+      linked? ? lambda {|link| link.tag == link_tag } : lambda {|_| false }
+    end
+
+    # @return [String,nil] when #linked? is true, the tag for outgoing links
+    def link_tag
+      linked? ? Array(link_spec).first.tag : nil
+    end
+
+    # @return [Riak::WalkSpec] when #linked? is true, a specification for which links to follow to retrieve the associated documents
+    def link_spec
+      # TODO: support transitive linked associations
+      if linked?
+        tag = name.to_s
+        bucket = polymorphic? ? '_' : klass.bucket_name
+        Riak::WalkSpec.new(:tag => tag, :bucket => bucket)
+      else
+        nil
+      end
+    end
+
+    # @return [Symbol] which method is used for representing the association - currently only supports :embedded and :linked
+    def using
+      @using ||= options[:using] || (embeddable? ? :embedded : :linked)
+    end
+
+    # @raise [ArgumentError] if the value does not match the class of the association
+    def verify_type!(value, owner)
+      unless type_matches?(value)
+        raise ArgumentError.new(t('invalid_association_value',
+                                  :name => name,
+                                  :owner => owner.inspect,
+                                  :klass => polymorphic? ? "<polymorphic>" : klass.name,
+                                  :value => value.inspect))
+      end
+    end
+
+    def type_matches?(value)
+      case
+      when polymorphic?
+        one? || Array === value
+      when many?
+        Array === value && value.all? {|d| (embeddable? && Hash === d) || klass === d }
+      when one?
+        value.nil? || (embeddable? && Hash === value) || klass === value
+      end
+    end
   end
 end

data/lib/ripple/associations/linked.rb

@@ -16,15 +16,27 @@ require 'ripple'
 module Ripple
   module Associations
     module Linked
-
-      def create(attrs={})
-        instantiate_target(:create, attrs)
+      def replace(value)
+        @reflection.verify_type!(value, @owner)
+        @owner.robject.links -= links
+        Array(value).compact.each do |doc|
+          doc.save if doc.new?
+          @owner.robject.links << doc.robject.to_link(@reflection.link_tag)
+        end
+        loaded
+        @target = value
       end
 
-      def create!(attrs={})
-        instantiate_target(:create!, attrs)
+      protected
+      def links
+        @owner.robject.links.select(&@reflection.link_filter)
       end
 
+      def robjects
+        @owner.robject.walk(*Array(@reflection.link_spec)).first || []
+      rescue
+        []
+      end
     end
   end
 end

data/lib/ripple/associations/many.rb

@@ -33,13 +33,14 @@ module Ripple
         @target = []
       end
 
-      def <<
-          raise NotImplementedError
+      def <<(value)
+        raise NotImplementedError
       end
+
       alias_method :push, :<<
-        alias_method :concat, :<<
+      alias_method :concat, :<<
 
-        protected
+      protected
       def instantiate_target(instantiator, attrs={})
         doc = klass.send(instantiator, attrs)
         self << doc

data/lib/ripple/associations/many_embedded_proxy.rb

@@ -21,12 +21,14 @@ module Ripple
 
       def <<(docs)
         load_target
+        @reflection.verify_type!(Array(docs), @owner)
         assign_references(docs)
         @target += Array(docs)
         self
       end
 
       def replace(docs)
+        @reflection.verify_type!(docs, @owner)
         @_docs = docs.map { |doc| attrs = doc.respond_to?(:attributes_for_persistence) ? doc.attributes_for_persistence : doc }
         assign_references(docs)
         reset

data/lib/ripple/associations/many_linked_proxy.rb

@@ -0,0 +1,35 @@
+# 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.
+require 'ripple'
+
+module Ripple
+  module Associations
+    class ManyLinkedProxy < Proxy
+      include Many
+      include Linked
+
+      def <<(value)
+        load_target
+        new_target = @target.concat(Array(value))
+        replace new_target
+        self
+      end
+
+      protected
+      def find_target
+        robjects.map {|robj| klass.send(:instantiate, robj) }
+      end
+    end
+  end
+end

data/lib/ripple/associations/one.rb

@@ -18,6 +18,10 @@ module Ripple
     module One
       include Instantiators
 
+      def to_a
+        [self]
+      end
+      
       protected
       def instantiate_target(instantiator, attrs={})
         @target = klass.send(instantiator, attrs)

data/lib/ripple/associations/one_embedded_proxy.rb

@@ -20,6 +20,7 @@ module Ripple
       include Embedded
 
       def replace(doc)
+        @reflection.verify_type!(doc, @owner)
         @_doc = doc.respond_to?(:attributes_for_persistence) ? doc.attributes_for_persistence : doc
         assign_references(doc)
         reset
@@ -33,7 +34,6 @@ module Ripple
           assign_references(doc)
         end
       end
-
     end
   end
 end