datastax_rails 1.0.15 → 1.0.16.3

data/lib/datastax_rails/collection.rb

@@ -1,5 +1,9 @@
 module DatastaxRails
   class Collection < Array
+    # @!attribute [r] total_entries
+    #   @return [Fixnum] the total number of entries that match the search
+    # @!attribute [r] last_column_name
+    #   @return [Fixnum] the last column that was returned in the search in case you limited the number of columns (not supported)
     attr_accessor :last_column_name, :total_entries
     
     def inspect

data/lib/datastax_rails/connection.rb

@@ -1,4 +1,6 @@
 # require 'datastax_rails/rsolr_client_wrapper'
+require 'rsolr/client_cert'
+require 'rest_client'
 module DatastaxRails
   # The connection module holds all the code for establishing and maintaining a connection to
   # Datastax Exterprise.  This includes both the Cassandra and Solr connections.
@@ -13,7 +15,8 @@ module DatastaxRails
     module ClassMethods
       DEFAULT_OPTIONS = {
         :servers => "127.0.0.1:9160",
-        :thrift => {}
+        :thrift => {},
+        :cql_version => '3.0.0'
       }
       
       # Returns the current server that we are talking to.  This is useful when you are talking to a
@@ -48,6 +51,11 @@ module DatastaxRails
       #   solr:
       #     port: 8983
       #     path: /solr
+      #     ssl:
+      #       use_ssl: true
+      #       cert: config/datastax_rails.crt
+      #       key: config/datastax_rails.key
+      #       keypass: changeme
       #
       # The +servers+ entry should be a list of all of the servers in your local datacenter.  These
       # are the servers that DSR will attempt to connect to and will round-robin through.
@@ -85,26 +93,54 @@ module DatastaxRails
         DatastaxRails::Base.config = spec.with_indifferent_access
         spec.reverse_merge!(DEFAULT_OPTIONS)
         connection_options = spec[:connection_options] || {}
-        self.connection = CassandraCQL::Database.new(spec[:servers], {:keyspace => spec[:keyspace]}, connection_options.symbolize_keys)
+        self.connection = CassandraCQL::Database.new(spec[:servers], {:keyspace => spec[:keyspace], :cql_version => spec[:cql_version]}, connection_options.symbolize_keys)
       end
       
       # Returns the base portion of the URL for connecting to SOLR based on the current Cassandra server.
       #
       # @return [String] in the form of 'http://localhost:8983/solr'
       def solr_base_url
-        DatastaxRails::Base.establish_connection unless self.connection 
+        DatastaxRails::Base.establish_connection unless self.connection
         port = DatastaxRails::Base.config[:solr][:port]
         path = DatastaxRails::Base.config[:solr][:path]
-        "http://#{self.current_server}:#{port}#{path}"
+        protocol = DatastaxRails::Base.config[:solr].has_key?(:ssl) && DatastaxRails::Base.config[:solr][:ssl][:use_ssl] ? 'https' : 'http'
+        "#{protocol}://#{self.current_server}:#{port}#{path}"
+      end
+      
+      # Wraps and caches a solr connection object
+      #
+      # @params [Boolean] reconnect force a new connection
+      # @return [DatastaxRails::RSolrClientWrapper] a wrapped RSolr connection      
+      def solr_connection(reconnect = false)
+        if(!@rsolr || reconnect)
+          @rsolr = DatastaxRails::RSolrClientWrapper.new(establish_solr_connection)
+        end
+        @rsolr
       end
       
       # Similar to +establish_connection+, this method creates a connection object for Solr.  Since HTTP is stateless, this doesn't
       # actually launch the connection, but it gets everything set up so that RSolr can do its work.  It's important to note that
       # unlike the cassandra connection which is global to all of DSR, each model will have its own solr_connection.
       #
-      # @return [DatastaxRails::RSolrClientWrapper] a wrapped RSolr connection
-      def solr_connection
-        @rsolr ||= DatastaxRails::RSolrClientWrapper.new(RSolr.connect :url => "#{solr_base_url}/#{DatastaxRails::Base.connection.keyspace}.#{self.column_family}")
+      # @return [RSolr::Client] RSolr client object
+      def establish_solr_connection
+        opts = {:url => "#{solr_base_url}/#{DatastaxRails::Base.connection.keyspace}.#{self.column_family}"}
+        if DatastaxRails::Base.config[:solr].has_key?(:ssl) && 
+            DatastaxRails::Base.config[:solr][:ssl].has_key?(:cert) && 
+            DatastaxRails::Base.config[:solr][:ssl][:use_ssl]
+          cert = Pathname.new(DatastaxRails::Base.config[:solr][:ssl][:cert])
+          key = Pathname.new(DatastaxRails::Base.config[:solr][:ssl][:key])
+          pass = DatastaxRails::Base.config[:solr][:ssl][:keypass]
+          cert = Rails.root.join(cert) unless cert.absolute?
+          key = Rails.root.join(key) unless key.absolute?
+          opts[:ssl_cert_file] = cert.to_s
+          opts[:ssl_key_file] = key.to_s
+          opts[:ssl_key_pass] = pass if pass
+          
+          RSolr::ClientCert.connect opts
+        else
+          RSolr.connect opts
+        end
       end
     end
   end

data/lib/datastax_rails/cql/base.rb

@@ -16,7 +16,6 @@ module DatastaxRails
       # already been set up (Rails does this for you).
       def execute
         cql = self.to_cql
-        Rails.logger.debug(cql)
         DatastaxRails::Base.connection.execute_cql_query(cql)
       end
     end

data/lib/datastax_rails/cql/update.rb

@@ -34,38 +34,40 @@ module DatastaxRails
       end
       
       def to_cql
-        columns = @columns.dup
-        values = []
-        
-        stmt = "update #{@klass.column_family} using consistency #{@consistency} "
-        
-        if(@ttl)
-          stmt << "AND TTL #{@ttl} "
-        end
-        
-        if(@timestamp)
-          stmt << "AND TIMESTAMP #{@timestamp}"
-        end
-        
-        unless columns.empty?
-          stmt << "SET "
+        column_names = @columns.keys
+        cql = ""
+        Tempfile.open('cql', Rails.root.join("tmp")) do |stmt|
+          stmt << "update #{@klass.column_family} using consistency #{@consistency} "
           
-          first_entry = columns.shift
+          if(@ttl)
+            stmt << "AND TTL #{@ttl} "
+          end
           
-          stmt << "#{first_entry.first.to_s} = ?"
-          values << first_entry.last
+          if(@timestamp)
+            stmt << "AND TIMESTAMP #{@timestamp}"
+          end
           
-          columns.each do |k,v|
-            stmt << ", #{k.to_s} = ?"
-            values << v
+          unless @columns.empty?
+            stmt << "SET "
+            
+            first_entry = column_names.first
+            
+            stmt << CassandraCQL::Statement.sanitize("#{first_entry.to_s} = ?", [@columns[first_entry]])
+            column_names[1..-1].each do |col|
+              stmt << CassandraCQL::Statement.sanitize(", #{col.to_s} = ?", [@columns[col]])
+            end
           end
+          
+          stmt << CassandraCQL::Statement.sanitize(" WHERE KEY IN (?)", [@key])
+          stmt.rewind
+          cql = stmt.read
         end
-        
-        stmt << " WHERE KEY IN (?)"
-        values << @key
-        
-        CassandraCQL::Statement.sanitize(stmt, values)
+        cql
       end
+      
+      # def execute
+        # puts to_cql.truncate(50)
+      # end
     end
   end
 end

data/lib/datastax_rails/grouped_collection.rb

@@ -1,5 +1,13 @@
 module DatastaxRails
+  # GroupedCollection extends Hash to add some additional metadata.  The hash keys will be the values
+  # for the thing that was grouped on.  The hash entries point to instances of DatastaxRails::Collection.
   class GroupedCollection < Hash
+    # @!attribute [r] total_entries
+    #   @return [Fixnum] the total number of entries *in the largest group*.  This is to allow will_paginate to work properly.
+    # @!attribute [r] total_groups
+    #   @return [Fixnum] the total number of groups if the groups were paginated (not supported yet)
+    # @!attribute [r] total_for_all
+    #   @return [Fixnum] the total number of entries across all groups that match this search
     attr_accessor :total_entries, :total_groups, :total_for_all
     
     def inspect

data/lib/datastax_rails/persistence.rb

@@ -72,6 +72,10 @@ module DatastaxRails
           end
         end
       end
+      
+      def store_file(key, file, options = {})
+       
+      end
 
       # Instantiates a new object without calling +initialize+.
       #

data/lib/datastax_rails/railtie.rb

@@ -1,3 +1,4 @@
+require 'rubygems'
 require 'datastax_rails'
 require 'rails'
 module DatastaxRails
@@ -17,4 +18,4 @@ module DatastaxRails
       # require 'datastax_rails/generators/migration_generator'
     # end
   end
-end
+end

data/lib/datastax_rails/relation/search_methods.rb

@@ -15,6 +15,9 @@ module DatastaxRails
     # been updated yet with the results.  In practice, this should not happen for
     # records that were created over your connection, but it is possible for other
     # connections to create records that you can't see yet.
+    #
+    # @param level [Symbol, String] the level to set the consistency at
+    # @return [DatastaxRails::Relation] a new Relation object
     def consistency(level)
       level = level.to_s.upcase
       unless self.valid_consistency?(level)
@@ -34,6 +37,8 @@ module DatastaxRails
     #
     # Note that fulltext searches are NEVER escaped.  Use Relation.solr_escape if you
     # want that done.
+    #
+    # @return [DatastaxRails::Relation] a new Relation object
     def dont_escape
       clone.tap do |r|
         r.escape_value = false
@@ -44,6 +49,9 @@ module DatastaxRails
     # a module or a block provided
     #
     # The object returned is a relation which can be further extended
+    #
+    # @param modules [Proc] one or more proc objects
+    # @return [DatastaxRails::Relation] a new Relation object
     def extending(*modules)
       modules << Module.new(&Proc.new) if block_given?
 
@@ -69,6 +77,9 @@ module DatastaxRails
     #       30
     #     end
     #   end
+    #
+    # @param value [String, Fixnum] the number of records to include on a page
+    # @return [DatastaxRails::Relation] a new Relation object
     def limit(value)
       clone.tap do |r|
         r.per_page_value = value.to_i
@@ -79,6 +90,9 @@ module DatastaxRails
     # Sets the page number to retrieve
     #
     #   Model.page(2)
+    #
+    # @param value [String, Fixnum] the page number to retrieve
+    # @return [DatastaxRails::Relation] a new Relation object
     def page(value)
       clone.tap do |r|
         r.page_value = value.to_i
@@ -88,6 +102,10 @@ module DatastaxRails
     # WillPaginate compatible method for paginating
     #
     #   Model.paginate(:page => 2, :per_page => 10)
+    # @param options [Hash] the options to pass to paginate
+    # @option options [String, Fixnum] :page the page number to retrieve
+    # @option options [String, Fixnum] :per_page the number of records to include on a page
+    # @return [DatastaxRails::Relation] a new Relation object
     def paginate(options = {})
       options = options.reverse_merge({:page => 1, :per_page => 30})
       clone.tap do |r|
@@ -102,7 +120,7 @@ module DatastaxRails
     # This modifies the behavior of pagination. When using a group, +per_page+ will
     # specify the number of results returned *for each group*. In addition, +page+
     # will move all groups forward by one page possibly resulting in some groups
-    # getting dropped off if they have fewer matching entires than others.
+    # showing up empty if they have fewer matching entires than others.
     #
     # When grouping is being used, the sort values will be used to sort results within
     # a given group. Any sorting of the groups themselves will need to be handled
@@ -115,6 +133,11 @@ module DatastaxRails
     # NOTE: Group names will be lower-cased
     #
     #   Model.group(:program_id)
+    #
+    # The object the hash entries point to will be a DatastaxRails::Collection
+    #
+    # @param attribute [Symbol, String] the attribute to group by
+    # @return [DatastaxRails::Relation] a new Relation object
     def group(attribute)
       return self if attribute.blank?
       
@@ -133,6 +156,9 @@ module DatastaxRails
     #
     #   Model.order(:name)
     #   Model.order(:name => :desc)
+    #
+    # @param attribute [Symbol, String, Hash] the attribute to sort by and optionally the direction to sort in
+    # @return [DatastaxRails::Relation] a new Relation object
     def order(attribute)
       return self if attribute.blank?
 
@@ -184,15 +210,15 @@ module DatastaxRails
       end
     end
     
-    # Reverses the order of the results
+    # Reverses the order of the results. The following are equivalent:
     # 
     #   Model.order(:name).reverse_order
-    #     is equivalent to
-    #   Model.order(:name => :desc)
+    #   Model.order(:name => :desc) 
     #
     #   Model.order(:name).reverse_order.reverse_order
-    #     is equivalent to
     #   Model.order(:name => :asc)
+    #
+    # @return [DatastaxRails::Relation] a new Relation object
     def reverse_order
       clone.tap do |r|
         r.reverse_order_value == !r.reverse_order_value
@@ -206,11 +232,14 @@ module DatastaxRails
     # *This only applies to fulltext queries*
     #
     #   Model.query_parser('disMax').fulltext("john smith")
-    def query_parser(attribute)
-      return self if attribute.blank?
+    #
+    # @param parser [String] the parser to use for the fulltext query 
+    # @return [DatastaxRails::Relation] a new Relation object
+    def query_parser(parser)
+      return self if parser.blank?
       
       clone.tap do |r|
-        r.query_parser_value = attribute
+        r.query_parser_value = parser
       end
     end
     
@@ -221,6 +250,8 @@ module DatastaxRails
     # it becomes available in SOLR is not guaranteed to be insignificant.  It's
     # very possible to insert a new record and not find it when immediately doing
     # a SOLR search for it.
+    #
+    # @return [DatastaxRails::Relation] a new Relation object
     def with_solr
       clone.tap do |r|
         r.use_solr_value = true
@@ -232,7 +263,9 @@ module DatastaxRails
     # cassandra.
     #
     # NOTE that this method assumes that you have all the proper secondary indexes
-    # in place before you attempt to use it.  If not, you will get an error. 
+    # in place before you attempt to use it.  If not, you will get an error.
+    #
+    # @return [DatastaxRails::Relation] a new Relation object
     def with_cassandra
       clone.tap do |r|
         r.use_solr_value = false
@@ -255,21 +288,43 @@ module DatastaxRails
     #   Model.where(:created_at).greater_than(1.day.ago)
     #   Model.where(:age).less_than(65)
     #
+    # There is an alternate form of specifying greater than/less than queries
+    # that can be done with a single call.  This is useful for remote APIs and
+    # such.
+    #
+    #   Model.where(:created_at => {:greater_than => 1.day.ago})
+    #   Model.where(:age => {:less_than => 65})
+    #
     # NOTE: Due to the way SOLR handles range queries, all greater/less than
-    #       queries are actually greater/less than or equal to queries.
-    #       There is no way to perform a strictly greater/less than query.
+    # queries are actually greater/less than or equal to queries.
+    # There is no way to perform a strictly greater/less than query.
+    #
+    # @param attribute [Symbol, String, Hash] a hash of conditions or a single attribute that will be followed by
+    #   greater_than or less_than
+    # @return [DatastaxRails::Relation] a new Relation object
     def where(attribute)
       return self if attribute.blank?
-      
       if attribute.is_a?(Symbol)
         WhereProxy.new(self, attribute)
       else
-        attributes = attribute.dup
-        attributes.each do |k,v|
-          attributes[k] = solr_format(v)
-        end
         clone.tap do |r|
-          r.where_values << attributes
+          attributes = attribute.dup
+          attributes.each do |k,v|
+            if(v.is_a?(Hash))
+              comp, value = v.first
+              if(comp.to_s == 'greater_than')
+                r.greater_than_values << {k => value}
+              elsif(comp.to_s == 'less_than')
+                r.less_than_values << {k => value}
+              else
+                r.where_values << {k => value}
+              end
+              attributes.delete(k)
+            else
+              attributes[k] = solr_format(v)
+            end
+          end
+          r.where_values << attributes unless attributes.empty?
         end
       end
     end
@@ -285,22 +340,37 @@ module DatastaxRails
     #   Model.where_not(:group_id => ['1234', '5678'])
     #
     # The above would find all models where group id is neither 1234 or 5678.
+    #
+    # @param attribute [Symbol, String, Hash] a hash of conditions or a single attribute that will be followed by
+    #   greater_than or less_than
+    # @return [DatastaxRails::Relation, DatastaxRails::SearchMethods::WhereProxy] a new Relation object
+    #   or a proxy object if just an attribute was passed
     def where_not(attribute)
       return self if attribute.blank?
       
-      attributes = []
-      attribute.each do |k,v|
-        if v.is_a?(Array)
-          v.each do |val|
-            attributes << {k => solr_format(val)}
+      if attribute.is_a?(Symbol)
+        WhereProxy.new(self, attribute, true)
+      else
+        clone.tap do |r|
+          attributes = attribute.dup
+          attributes.each do |k,v|
+            if(v.is_a?(Hash))
+              comp, value = v.first
+              if(comp.to_s == 'greater_than')
+                r.less_than_values << {k => value}
+              elsif(comp.to_s == 'less_than')
+                r.greater_than_values << {k => value}
+              else
+                r.where_not_values << {k => value}
+              end
+              attributes.delete(k)
+            else
+              attributes[k] = solr_format(v)
+            end
           end
-        else
-          attributes << {k => solr_format(v)}
+          r.where_not_values << attributes unless attributes.empty?
         end
       end
-      clone.tap do |r|
-        r.where_not_values += attributes
-      end
     end
     
     # Specifies a full text search string to be processed by SOLR
@@ -314,6 +384,12 @@ module DatastaxRails
     #
     #   Model.fulltext("john smith", :fields => [:title])
     #   Model.fulltext("john smith", :hightlight => [:body])
+    #
+    # @param query [String] a fulltext query to pass to solr
+    # @param opts [Hash] an optional options hash to modify the fulltext query
+    # @option opts [Array] :fields list of fields to search instead of the default of all text fields (not-implemented)
+    # @option opts [Array] :highlight list of fields to retrieve highlights for (not-implemented)
+    # @return [DatastaxRails::Relation] a new Relation object
     def fulltext(query, opts = {})
       return self if query.blank?
       
@@ -367,25 +443,37 @@ module DatastaxRails
       end
     
     class WhereProxy #:nodoc:
-      def initialize(relation, attribute) #:nodoc:
-        @relation, @attribute = relation, attribute
+      def initialize(relation, attribute, invert = false) #:nodoc:
+        @relation, @attribute, @invert = relation, attribute, invert
       end
       
       def equal_to(value) #:nodoc:
         @relation.clone.tap do |r|
-          r.where_values << {@attribute => r.solr_format(value)}
+          if @invert
+            r.where_not_values << {@attribute => r.solr_format(value)}
+          else
+            r.where_values << {@attribute => r.solr_format(value)}
+          end
         end
       end
       
       def greater_than(value) #:nodoc:
         @relation.clone.tap do |r|
-          r.greater_than_values << {@attribute => r.solr_format(value)}
+          if @invert
+            r.less_than_values << {@attribute => r.solr_format(value)}
+          else
+            r.greater_than_values << {@attribute => r.solr_format(value)}
+          end
         end
       end
       
       def less_than(value) #:nodoc:
         @relation.clone.tap do |r|
-          r.less_than_values << {@attribute => r.solr_format(value)}
+          if @invert
+            r.greater_than_values << {@attribute => r.solr_format(value)}
+          else
+            r.less_than_values << {@attribute => r.solr_format(value)}
+          end
         end
       end
     end

data/lib/datastax_rails/relation/spawn_methods.rb

@@ -86,20 +86,45 @@ module DatastaxRails
       result
     end
     
-    VALID_FIND_OPTIONS = [:conditions, :limit, :select, :offset, :order, :group, :page, :per_page]
-    def apply_finder_options(options) #:nodoc:
-      relation = clone
+    VALID_FIND_OPTIONS = [:conditions, :limit, :select, :offset, :order, :group, :page, :per_page, :fulltext, :consistency, :with_solr, :with_cassandra, :where, :where_not]
+    # Applies the passed in finder options and returns a new Relation.
+    # Takes any of the options below and calls them on the relation as if they
+    # were methods (+conditions+ is passed to +where+).
+    #
+    # @param [Hash] options the options hash
+    # @option options [Hash] :conditions
+    # @option options [Symbol, String] :consistency
+    # @option options [String] :fulltext
+    # @option options [Symbol, String] :group
+    # @option options [Integer, String] :limit
+    # @option options [Integer, String] :offset
+    # @option options [String, Hash] :order
+    # @option options [Integer, String] :page
+    # @option options [Integer, String] :per_page
+    # @option options [Array] :select
+    # @option options [Hash] :where
+    # @option options [Hash] :where_not
+    # @option options [Boolean] :with_cassandra
+    # @option options [Boolean] :with_solr
+    # @return [DatastaxRails::Relation] relation with all options applied
+    # @raise [ArgumentError] if an invalid option is passed in
+    def apply_finder_options(options)
+      relation = self
       return relation unless options
       
       options.assert_valid_keys(VALID_FIND_OPTIONS)
       finders = options.dup
       finders.delete_if { |key, value| value.nil? }
       
-      ([:group, :order, :limit, :offset, :page, :per_page, :select] & finders.keys).each do |finder|
-        relation = relation.send(finder, finders[finder])
+      ((VALID_FIND_OPTIONS - [:conditions]) & finders.keys).each do |finder|
+        if(finder.to_s =~ /(with_solr|with_cassandra)/)
+          relation = relation.send(finder)
+        else
+          relation = relation.send(finder, finders[finder])
+        end
       end
       
-      relation = relation.where(finders[:conditions]) if options.has_key?(:conditions)
+      relation = relation.where(finders[:conditions]) if finders.has_key?(:conditions)
       relation
     end
   end

data/lib/datastax_rails/relation.rb

@@ -24,7 +24,13 @@ module DatastaxRails
     alias :loaded? :loaded
     alias :default_scoped? :default_scoped
     
-    def initialize(klass, column_family) #:nodoc:
+    # Initializes the Relation.  Defaults page value to 1, per_page to the class
+    # default, and solr use to true.  Everything else gets defaulted to nil or
+    # empty.
+    #
+    # @param [Class] klass the child of DatastaxRails::Base that this relation searches
+    # @param [String, Symbol] column_family the name of the column family this relation searches
+    def initialize(klass, column_family)
       @klass, @column_family = klass, column_family
       @loaded = false
       @results = []
@@ -146,12 +152,14 @@ module DatastaxRails
       @results = []
     end
     
-    def initialize_copy(other) #:nodoc:
+    # Copies will have changes made to the criteria and so need to be reset.
+    def initialize_copy(other)
       reset
       @search = nil
     end
     
-    def clone #:nodoc:
+    # Performs a deep copy using Marshal when cloning.
+    def clone
       dup.tap do |r|
         MULTI_VALUE_METHODS.each do |m|
           r.send("#{m}_values=", Marshal.load(Marshal.dump(self.send("#{m}_values"))))
@@ -210,7 +218,8 @@ module DatastaxRails
       scoping { @klass.create!(*args, &block) }
     end
     
-    def respond_to?(method, include_private = false) #:nodoc:
+    # Override respond_to? so that it matches method_missing
+    def respond_to?(method, include_private = false)
       Array.method_defined?(method)                       ||
       @klass.respond_to?(method, include_private)         ||
       super
@@ -339,7 +348,7 @@ module DatastaxRails
         params['group.limit'] = @per_page_value
         params['group.offset'] = (@page_value - 1) * @per_page_value
         params['group.ngroups'] = 'true'
-        response = rsolr.post('select', :params => params)["grouped"][@group_value.to_s]
+        response = rsolr.post('select', :data => params)["grouped"][@group_value.to_s]
         results.total_groups = response['ngroups'].to_i
         results.total_for_all = response['matches'].to_i
         results.total_entries = 0
@@ -348,13 +357,18 @@ module DatastaxRails
           results.total_entries = results[group['groupValue']].total_entries if results[group['groupValue']].total_entries > results.total_entries
         end
       else
-        response = rsolr.paginate(@page_value, @per_page_value, 'select', :params => params)["response"]
+        response = rsolr.paginate(@page_value, @per_page_value, 'select', :data => params, :method => :post)["response"]
         results = parse_docs(response, select_columns)
       end
       results
     end
     
-    
+    # Parse out a set of documents and return the results
+    #
+    # @param response [Hash] the response hash from SOLR with a set of documents
+    # @param select_columns [Array] the columns that we actually selected from SOLR
+    #
+    # @return [DatastaxRails::Collection] the resulting collection
     def parse_docs(response, select_columns)
       results = DatastaxRails::Collection.new
       results.total_entries = response['numFound'].to_i
@@ -371,6 +385,10 @@ module DatastaxRails
     end
     protected(:parse_docs)
     
+    # Inspects the results of the search instead of the Relation itself.
+    # Passing true causes the Relation to be inspected.
+    #
+    # @param [Boolean] just_me if true, inspect the Relation, otherwise the results
     def inspect(just_me = false)
       just_me ? super() : to_a.inspect
     end
@@ -389,11 +407,14 @@ module DatastaxRails
       @klass.send(:with_scope, self, :overwrite) { yield }
     end
     
-    def where_values_hash #:nodoc:
+    # Merges all of the where values together into a single hash
+    def where_values_hash
       where_values.inject({}) { |values,v| values.merge(v) }
     end
 
-    def scope_for_create #:nodoc:
+    # Creates a scope that includes all of the where values plus anything
+    # that is in +create_with_value+.
+    def scope_for_create
       @scope_for_create ||= where_values_hash.merge(create_with_value)
     end
     

data/lib/datastax_rails/rsolr_client_wrapper.rb

@@ -10,7 +10,7 @@ module DatastaxRails
     def method_missing(sym, *args, &block)
       if @rsolr.uri.host != DatastaxRails::Base.current_server
         @rsolr.uri.host = DatastaxRails::Base.current_server
-        @rsolr = RSolr.connect(:url => @rsolr.uri.to_s)
+        @rsolr = DatastaxRails::Base.establish_solr_connection
       end
       @rsolr.__send__(sym, *args, &block)
     rescue Errno::ECONNREFUSED