datastax_rails 1.1.0.3 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 315f2c0bed2d3ebd73b696212d09be65be6071f1
-  data.tar.gz: 3c7f2f05d532f73ec40128bf748f032cb7825ec4
+  metadata.gz: a8971782b7516d5060103ef9b6ed6b56b71a5ad4
+  data.tar.gz: 19487f48ae56cdf4ead4176377f5e0bbe3ac6bc3
 SHA512:
-  metadata.gz: 956823938bdc95ac435bd57a7ec19cd6d1f565790847d10117fb86f30a2db78cbbe3ca0466db66632c9cd6a826bc1564146b687ac15027e15e8de54639698754
-  data.tar.gz: 0c082e39d39012a3c79dbed78180433dee4cd9bd0138aa3c9116aa03a267a5dff3f009973a9f86fb323e3a9a40254efd4d1afa8762f39ec72e56ca3909aed5aa
+  metadata.gz: 7af9042a6919a4567e66b925934cd17e17fcbecb7dd6edf4ab6de5e66c6af378f942eab851bb962c197f6f46a44bd5a657df747c886f6169c1a9796c0ddc9e46
+  data.tar.gz: 9e0fef7994f2746c934f15b6922e6dfae0b7974b0b4ee88d7594287709f8c3cb7e25cea3dd936a4e16ecaa524eb6fa0ea255bbdc84f460f36040a1f58ca82669

data/README.rdoc

@@ -64,27 +64,27 @@ Create your keyspace:
 
 Once you've created some models, the following will upload the solr schemas and create the column families:
 
-  rake ds:schema
-  rake ds:schema RAILS_ENV=test
+  rake ds:migrate
+  rake ds:migrate RAILS_ENV=test
 
-It is safe to run ds:schema over and over.  In fact, it is necessary to re-run it any time you change the
+It is safe to run ds:migrate over and over.  In fact, it is necessary to re-run it any time you change the
 attributes on any model.  DSR will only upload schema files if they have changed.
 
 Create a sample Model.  See Base documentation for more details:
 
-class Person < DatastaxRails::Base
-  key     :uuid
-  string  :first_name
-  string  :user_name
-  text    :bio
-  date    :birthdate
-  boolean :active
-  timestamps
-end
+  class Person < DatastaxRails::Base
+    key     :uuid
+    string  :first_name
+    string  :user_name
+    text    :bio
+    date    :birthdate
+    boolean :active
+    timestamps
+  end
 
 === Known issues
 
-Trying to set a value to nil via the solr API results in the field value not changing at all.  Updating it via CQL doesn't have this issue.
+When doing a grouped query, the total groups reported is only the total groups included in your query, not the total matching groups (if you're paginating).  This is due to the way solr sharding works with grouped queries.
 
 === More information
 

data/Rakefile

@@ -1,4 +1,5 @@
 #!/usr/bin/env rake
+require 'rubygems'
 begin
   require 'bundler/setup'
 rescue LoadError

data/config/schema.xml.erb

@@ -48,7 +48,6 @@
   <fieldType name="float" class="solr.TrieFloatField" precisionStep="0" positionIncrementGap="0"/>
   <fieldType name="long" class="solr.TrieLongField" precisionStep="0" positionIncrementGap="0"/>
   <fieldType name="double" class="solr.TrieDoubleField" precisionStep="0" positionIncrementGap="0"/>
-   
  </types>
  <fields>
     <field name="id"  type="string" indexed="true"  stored="true"/>

data/config/{solrconfig.xml → solrconfig.xml.erb}

@@ -50,7 +50,7 @@
   <luceneMatchVersion>LUCENE_40</luceneMatchVersion>
   
   <!-- Enable DSE Search new type mappings -->
-  <dseTypeMappingVersion>0</dseTypeMappingVersion>
+  <dseTypeMappingVersion><%= @legacy ? 0 : 1 %></dseTypeMappingVersion>
 
   <!-- lib directives can be used to instruct Solr to load an Jars
        identified and use them to resolve any "plugins" specified in

data/lib/blankslate.rb

@@ -21,7 +21,7 @@ class BlankSlate
     def hide(name)
       methods = instance_methods.map(&:to_sym)
       if methods.include?(name.to_sym) and
-        name !~ /^(__|instance_eval)/
+        name !~ /^(__|instance_eval|object_id)/
         @hidden_methods ||= {}
         @hidden_methods[name.to_sym] = instance_method(name)
         undef_method name

data/lib/datastax_rails/associations/collection_proxy.rb

@@ -61,7 +61,11 @@ module DatastaxRails
       end
       
       def method_missing(method, *args, &block)
-        match = ActiveRecord::DynamicFinderMatch.match(method)
+        if Rails.version =~ /^3.*/
+          match = ActiveRecord::DynamicFinderMatch.match(method)
+        elsif Rails.version =~ /^4.*/
+          match = ActiveRecord::DynamicMatchers::Method.match(self, method)
+        end
         if match && match.instantiator?
           send(:find_or_instantiator_by_attributes, match, match.attribute_names, *args) do |r|
             proxy_association.send :set_owner_attributes, r
@@ -115,4 +119,4 @@ module DatastaxRails
       end
     end
   end
-end
+end

data/lib/datastax_rails/attribute_assignment.rb

@@ -0,0 +1,114 @@
+require 'active_support/concern'
+
+module DatastaxRails
+  module AttributeAssignment
+    extend ActiveSupport::Concern
+    if Rails.version =~ /^3.*/
+      include ActiveModel::MassAssignmentSecurity
+    elsif Rails.version =~ /^4.*/
+      include ActiveModel::DeprecatedMassAssignmentSecurity
+      include ActiveModel::ForbiddenAttributesProtection
+    end
+
+    module ClassMethods
+      private
+
+      # The primary key can never be set by mass-assignment for security reasons.
+      def attributes_protected_by_default
+        ["key"]
+      end
+    end
+
+    # Allows you to set all the attributes at once by passing in a hash with keys
+    # matching the attribute names (which again matches the column names).
+    #
+    # If any attributes are protected by either +attr_protected+ or
+    # +attr_accessible+ then only settable attributes will be assigned.
+    #
+    #   class User < ActiveRecord::Base
+    #     attr_protected :is_admin
+    #   end
+    #
+    #   user = User.new
+    #   user.attributes = { :username => 'Phusion', :is_admin => true }
+    #   user.username   # => "Phusion"
+    #   user.is_admin?  # => false
+    def attributes=(new_attributes)
+      return unless new_attributes.is_a?(Hash)
+
+      assign_attributes(new_attributes)
+    end
+
+    # Allows you to set all the attributes for a particular mass-assignment
+    # security role by passing in a hash of attributes with keys matching
+    # the attribute names (which again matches the column names) and the role
+    # name using the :as option.
+    #
+    # To bypass mass-assignment security you can use the :without_protection => true
+    # option.
+    #
+    #   class User < ActiveRecord::Base
+    #     attr_accessible :name
+    #     attr_accessible :name, :is_admin, :as => :admin
+    #   end
+    #
+    #   user = User.new
+    #   user.assign_attributes({ :name => 'Josh', :is_admin => true })
+    #   user.name       # => "Josh"
+    #   user.is_admin?  # => false
+    #
+    #   user = User.new
+    #   user.assign_attributes({ :name => 'Josh', :is_admin => true }, :as => :admin)
+    #   user.name       # => "Josh"
+    #   user.is_admin?  # => true
+    #
+    #   user = User.new
+    #   user.assign_attributes({ :name => 'Josh', :is_admin => true }, :without_protection => true)
+    #   user.name       # => "Josh"
+    #   user.is_admin?  # => true
+    def assign_attributes(new_attributes, options = {})
+      return if new_attributes.blank?
+
+      attributes = new_attributes.stringify_keys
+      nested_parameter_attributes = []
+      @mass_assignment_options = options
+
+      unless options[:without_protection]
+        if Rails.version =~ /3.*/
+          attributes = sanitize_for_mass_assignment(attributes, mass_assignment_role)
+        else
+          attributes = sanitize_for_mass_assignment(attributes)
+        end
+      end
+
+      attributes.each do |k, v|
+        if respond_to?("#{k}=")
+          if v.is_a?(Hash)
+            nested_parameter_attributes << [ k, v ]
+          else
+            send("#{k}=", v)
+          end
+        else
+          raise(UnknownAttributeError, "unknown attribute: #{k}")
+        end
+      end
+
+      # assign any deferred nested attributes after the base attributes have been set
+      nested_parameter_attributes.each do |k,v|
+        send("#{k}=", v)
+      end
+
+      @mass_assignment_options = nil
+    end
+
+    protected
+
+    def mass_assignment_options
+      @mass_assignment_options ||= {}
+    end
+
+    def mass_assignment_role
+      mass_assignment_options[:as] || :default
+    end
+  end
+end

data/lib/datastax_rails/attribute_methods/definition.rb

@@ -1,8 +1,9 @@
 module DatastaxRails
   module AttributeMethods
     class Definition
-      attr_reader :name, :coder, :lazy
-      def initialize(name, coder, options)
+      attr_reader :klass, :name, :coder, :lazy
+      def initialize(klass, name, coder, options)
+        @klass  = klass
         @name   = name.to_s
         @lazy   = options.delete(:lazy)
         @coder  = coder.new(options)
@@ -16,6 +17,11 @@ module DatastaxRails
         coder.wrap(record, name, value)
       end
       
+      # Returns :solr, :cassandra, :both, or +false+
+      def indexed
+        coder.options[:indexed]
+      end
+      
       def type
         coder.type
       end

data/lib/datastax_rails/attribute_methods/typecasting.rb

@@ -7,7 +7,7 @@ module DatastaxRails
         class_attribute :attribute_definitions
         class_attribute :lazy_attributes
         class_attribute :readonly_attributes
-        self.attribute_definitions = {}
+        self.attribute_definitions = ActiveSupport::HashWithIndifferentAccess.new
         self.lazy_attributes = []
         self.readonly_attributes = []
 
@@ -20,12 +20,9 @@ module DatastaxRails
         end 
         
         # We need to ensure that inherited classes get their own attribute definitions.
-        # In addition, we take the opportunity to track all the DatastaxRails::Base decendents.
-        # This will be useful when it comes to things like schema generation.
         def inherited(child)
           super
           child.attribute_definitions = attribute_definitions.dup
-          self.models << child
         end
         
         # @!group Attribute Types
@@ -99,4 +96,4 @@ module DatastaxRails
       end
     end
   end
-end
+end

data/lib/datastax_rails/attribute_methods.rb

@@ -32,6 +32,14 @@ module DatastaxRails
       def attribute(name, options)
         type  = options.delete :type
         coder = options.delete :coder
+        
+        if self <= CassandraOnlyModel
+          if options[:indexed] == :both || options[:indexed] == :cassandra
+            options[:indexed] = :cassandra
+          else
+            options[:indexed] = false
+          end
+        end
 
         if type.is_a?(Symbol)
           coder = DatastaxRails::Type.get_coder(type) || (raise "Unknown type #{type}")
@@ -47,7 +55,7 @@ module DatastaxRails
           readonly_attributes << name.to_sym
         end
 
-        attribute_definitions[name.to_sym] = AttributeMethods::Definition.new(name, coder, options)
+        attribute_definitions[name.to_sym] = AttributeMethods::Definition.new(self, name, coder, options)
       end
     end
     
@@ -75,12 +83,6 @@ module DatastaxRails
       @attributes.key?(name.to_s)
     end
 
-    def attributes=(attributes)
-      attributes.each do |(name, value)|
-        send("#{name}=", value)
-      end
-    end
-
     def method_missing(method_id, *args, &block)
       if !self.class.attribute_methods_generated?
         self.class.define_attribute_methods

data/lib/datastax_rails/base.rb

@@ -1,6 +1,10 @@
-require 'active_record/dynamic_finder_match'
-require 'active_record/dynamic_scope_match'
-require 'datastax_rails/log_subscriber'
+if Rails.version =~ /^3.*/
+  # Dynamic finders are only supported in Rails 3.x applications (depricated in 4.x)
+  require 'active_record/dynamic_finder_match'
+  require 'active_record/dynamic_scope_match'
+elsif Rails.version =~ /^4.*./
+  require 'active_record/deprecated_finders/dynamic_matchers'
+end
 require 'datastax_rails/types'
 require 'datastax_rails/errors'
 module DatastaxRails #:nodoc:
@@ -222,6 +226,8 @@ module DatastaxRails #:nodoc:
   #
   # == Dynamic attribute-based finders
   #
+  # Note: These are only available in Rails 3.x applications, and are not supported in Rails 4.x
+  #
   # Dynamic attribute-based finders are a cleaner way of getting (and/or creating) objects
   # by simple queries without using where chains. They work by appending the name of an attribute
   # to <tt>find_by_</tt> or <tt>find_all_by_</tt> and thus produces finders
@@ -270,6 +276,32 @@ module DatastaxRails #:nodoc:
   #
   #   User.scoped_by_user_name('David')
   #
+  # == Facets
+  #
+  # DSR support both field and range facets.  For additional detail on facets, see the documentation
+  # available under the FacetMethods module.  The result is available through the facets accessor
+  #
+  # Facet examples:
+  #
+  # results = Article.field_facet(:author)
+  # results.facets => {"author"=>["vonnegut", 2. "asimov", 3]} 
+  #
+  # Model.field_facet(:author)
+  # Model.field_facet(:author, :sort => 'count', :limit => 10, :mincount => 1)
+  # Model.range_facet(:price, 500, 1000, 10)
+  # Model.range_facet(:price, 500, 1000, 10, :include => 'all')
+  # Model.range_facet(:publication_date, "1968-01-01T00:00:00Z", "2000-01-01T00:00:00Z", "+1YEAR")
+  #
+  # Range Gap syntax for dates: +1YEAR, +5YEAR, +5YEARS, +1MONTH, +1DAY
+  #
+  # Useful constants:
+  #
+  # DatastaxRails::FacetMethods::BY_YEAR  (+1YEAR)
+  # DatastaxRails::FacetMethods::BY_MONTH (+1MONTH)
+  # DatastaxRails::FacetMethods::BY_DAY   (+1DAY)
+  #
+  # Model.range_facet(:publication_date, "1968-01-01T00:00:00Z", "2000-01-01T00:00:00Z", DatastaxRails::FacetMethods::BY_YEAR)
+  #
   # == Exceptions
   #
   # * DatastaxRailsError - Generic error class and superclass of all other errors raised by DatastaxRails.
@@ -293,12 +325,13 @@ module DatastaxRails #:nodoc:
     extend ActiveModel::Naming
     include ActiveModel::Conversion
     extend ActiveSupport::DescendantsTracker
-    include ActiveModel::MassAssignmentSecurity
     
     include Connection
+    include Inheritance
     include Identity
     include FinderMethods
     include Batches
+    include AttributeAssignment
     include AttributeMethods
     include AttributeMethods::Dirty
     include AttributeMethods::Typecasting
@@ -310,7 +343,6 @@ module DatastaxRails #:nodoc:
     include Scoping
     include Timestamps
     include Serialization
-    include Migrations
     include SolrRepair
     
     # Stores the default scope for the class
@@ -326,9 +358,6 @@ module DatastaxRails #:nodoc:
     class_attribute :storage_method
     self.storage_method = :cql
     
-    class_attribute :models
-    self.models = []
-    
     attr_reader :attributes
     attr_reader :loaded_attributes
     attr_accessor :key
@@ -338,29 +367,24 @@ module DatastaxRails #:nodoc:
     class_attribute :serialized_attributes
     self.serialized_attributes = {}
     
+    # Whether or not we are using solr legacy mappings
+    class_attribute :legacy_mapping
+    
     def initialize(attributes = {}, options = {})
       @key = attributes.delete(:key)
       @attributes = {}.with_indifferent_access
       @loaded_attributes = {}.with_indifferent_access
       
-      @relation = nil
       @new_record = true
       @destroyed = false
       @previously_changed = {}
       @changed_attributes = {}
-      @schema_version = self.class.current_schema_version
       
       __set_defaults
       
       populate_with_current_scope_attributes
       
-      sanitize_for_mass_assignment(attributes).each do |k,v|
-        if respond_to?("#{k.to_s.downcase}=")
-          send("#{k.to_s.downcase}=",v)
-        else
-          raise(DatastaxRails::UnknownAttributeError, "unknown attribute: #{k}")
-        end
-      end
+      assign_attributes(attributes, options) if attributes
       
       yield self if block_given?
       run_callbacks :initialize
@@ -405,55 +429,6 @@ module DatastaxRails #:nodoc:
       self == (comparison_object)
     end
     
-    # Allows you to set all the attributes for a particular mass-assignment
-    # security role by passing in a hash of attributes with keys matching
-    # the attribute names (which again matches the column names) and the role
-    # name using the :as option.
-    #
-    # To bypass mass-assignment security you can use the :without_protection => true
-    # option.
-    #
-    #   class User < ActiveRecord::Base
-    #     attr_accessible :name
-    #     attr_accessible :name, :is_admin, :as => :admin
-    #   end
-    #
-    #   user = User.new
-    #   user.assign_attributes({ :name => 'Josh', :is_admin => true })
-    #   user.name # => "Josh"
-    #   user.is_admin? # => false
-    #
-    #   user = User.new
-    #   user.assign_attributes({ :name => 'Josh', :is_admin => true }, :as => :admin)
-    #   user.name # => "Josh"
-    #   user.is_admin? # => true
-    #
-    #   user = User.new
-    #   user.assign_attributes({ :name => 'Josh', :is_admin => true }, :without_protection => true)
-    #   user.name # => "Josh"
-    #   user.is_admin? # => true
-    def assign_attributes(new_attributes, options = {})
-      return unless new_attributes
-
-      attributes = new_attributes.stringify_keys
-      multi_parameter_attributes = []
-      @mass_assignment_options = options
-
-      unless options[:without_protection]
-        attributes = sanitize_for_mass_assignment(attributes, mass_assignment_role)
-      end
-
-      attributes.each do |k, v|
-        if respond_to?("#{k.to_s.downcase}=")
-          send("#{k.to_s.downcase}=",v)
-        else
-          raise(UnknownAttributeError, "unknown attribute: #{k}")
-        end
-      end
-
-      @mass_assignment_options = nil
-    end
-    
     def attribute_names
       self.class.attribute_names
     end
@@ -472,14 +447,15 @@ module DatastaxRails #:nodoc:
       end
       
     class << self
-      delegate :find, :first, :all, :exists?, :any?, :many?, :to => :scoped
+      delegate :find, :find_by, :find_by!, :first, :all, :exists?, :any?, :many?, :to => :scoped
       delegate :destroy, :destroy_all, :delete, :update, :update_all, :to => :scoped
-      delegate :order, :limit, :where, :where_not, :page, :paginate, :select, :to => :scoped
+      delegate :order, :limit, :where, :where_not, :page, :paginate, :select, :slow_order, :to => :scoped
       delegate :per_page, :each, :group, :total_pages, :search, :fulltext, :to => :scoped
       delegate :count, :first, :first!, :last, :last!, :compute_stats, :to => :scoped
       delegate :sum, :average, :minimum, :maximum, :stddev, :to => :scoped
-      delegate :cql, :with_cassandra, :with_solr, :commit_solr, :to => :scoped
+      delegate :cql, :with_cassandra, :with_solr, :commit_solr, :allow_filtering, :to => :scoped
       delegate :find_each, :find_in_batches, :consistency, :to => :scoped
+      delegate :field_facet, :range_facet, :to => :scoped
 
       # Sets the column family name
       #
@@ -496,10 +472,22 @@ module DatastaxRails #:nodoc:
         @column_family || name.underscore.pluralize
       end
       
+      def models
+        self.descendants.reject {|m|m.abstract_class?}
+      end
+      
       def payload_model?
         self.ancestors.include?(DatastaxRails::PayloadModel)
       end
       
+      def wide_storage_model?
+        self.ancestors.include?(DatastaxRails::WideStorageModel)
+      end
+      
+      def legacy_mapping?
+        @legacy_mapping
+      end
+      
       def base_class
         klass = self
         while klass.superclass != Base
@@ -519,12 +507,19 @@ module DatastaxRails #:nodoc:
       end
       
       def respond_to?(method_id, include_private = false)
-        if match = ActiveRecord::DynamicFinderMatch.match(method_id)
-          return true if all_attributes_exists?(match.attribute_names)
-        elsif match = ActiveRecord::DynamicScopeMatch.match(method_id)
-          return true if all_attributes_exists?(match.attribute_names)
+       
+        if Rails.version =~ /^3.*/
+          if match = ActiveRecord::DynamicFinderMatch.match(method_id)
+            return true if all_attributes_exists?(match.attribute_names)
+          elsif match = ActiveRecord::DynamicScopeMatch.match(method_id)
+            return true if all_attributes_exists?(match.attribute_names)
+          end
+        elsif Rails.version =~ /^4.*/
+          if match = ActiveRecord::DynamicMatchers::Method.match(self, method_id)
+            return true if all_attributes_exists?(match.attribute_names)
+          end
         end
-
+        
         super
       end
       
@@ -578,41 +573,64 @@ module DatastaxRails #:nodoc:
         # Each dynamic finder using <tt>scoped_by_*</tt> is also defined in the class after it
         # is first invoked, so that future attempts to use it do not run through method_missing.
         def method_missing(method_id, *arguments, &block)
-          if match = ActiveRecord::DynamicFinderMatch.match(method_id)
-            attribute_names = match.attribute_names
-            super unless all_attributes_exists?(attribute_names)
-            if !arguments.first.is_a?(Hash) && arguments.size < attribute_names.size
-              ActiveSupport::Deprecation.warn(
-                "Calling dynamic finder with less number of arguments than the number of attributes in " \
-                "method name is deprecated and will raise an ArguementError in the next version of Rails. " \
-                "Please passing `nil' to the argument you want it to be nil."
-              )
-            end
-            if match.finder?
-              options = arguments.extract_options!
-              relation = options.any? ? scoped(options) : scoped
-              relation.send :find_by_attributes, match, attribute_names, *arguments
-            elsif match.instantiator?
-              scoped.send :find_or_instantiator_by_attributes, match, attribute_names, *arguments, &block
-            end
-          elsif match = ActiveRecord::DynamicScopeMatch.match(method_id)
-            attribute_names = match.attribute_names
-            super unless all_attributes_exists?(attribute_names)
-            if arguments.size < attribute_names.size
-              ActiveSupport::Deprecation.warn(
-                "Calling dynamic scope with less number of arguments than the number of attributes in " \
-                "method name is deprecated and will raise an ArguementError in the next version of Rails. " \
-                "Please passing `nil' to the argument you want it to be nil."
-              )
+          if Rails.version =~ /^3.*/
+            if match = ActiveRecord::DynamicFinderMatch.match(method_id)
+              attribute_names = match.attribute_names
+              super unless all_attributes_exists?(attribute_names)
+              if !arguments.first.is_a?(Hash) && arguments.size < attribute_names.size
+                ActiveSupport::Deprecation.warn(
+                  "Calling dynamic finder with less number of arguments than the number of attributes in " \
+                  "method name is deprecated and will raise an ArguementError in the next version of Rails. " \
+                  "Please passing `nil' to the argument you want it to be nil."
+                )
+              end
+              if match.finder?
+                options = arguments.extract_options!
+                relation = options.any? ? scoped(options) : scoped
+                relation.send :find_by_attributes, match, attribute_names, *arguments
+              elsif match.instantiator?
+                scoped.send :find_or_instantiator_by_attributes, match, attribute_names, *arguments, &block
+              end
+            elsif match = ActiveRecord::DynamicScopeMatch.match(method_id)
+              attribute_names = match.attribute_names
+              super unless all_attributes_exists?(attribute_names)
+              if arguments.size < attribute_names.size
+                ActiveSupport::Deprecation.warn(
+                  "Calling dynamic scope with less number of arguments than the number of attributes in " \
+                  "method name is deprecated and will raise an ArguementError in the next version of Rails. " \
+                  "Please passing `nil' to the argument you want it to be nil."
+                )
+              end
+              if match.scope?
+                self.class_eval <<-METHOD, __FILE__, __LINE__ + 1
+                  def self.#{method_id}(*args)                                    # def self.scoped_by_user_name_and_password(*args)
+                    attributes = Hash[[:#{attribute_names.join(',:')}].zip(args)] #   attributes = Hash[[:user_name, :password].zip(args)]
+                    scoped(:conditions => attributes)                             #   scoped(:conditions => attributes)
+                  end                                                             # end
+                  METHOD
+                send(method_id, *arguments)
+              end
+            else
+              super
             end
-            if match.scope?
-              self.class_eval <<-METHOD, __FILE__, __LINE__ + 1
-                def self.#{method_id}(*args)                                    # def self.scoped_by_user_name_and_password(*args)
-                  attributes = Hash[[:#{attribute_names.join(',:')}].zip(args)] #   attributes = Hash[[:user_name, :password].zip(args)]
-                  scoped(:conditions => attributes)                             #   scoped(:conditions => attributes)
-                end                                                             # end
-                METHOD
-              send(method_id, *arguments)
+          elsif Rails.version =~ /^4.*/
+            if match = ActiveRecord::DynamicMatchers::Method.match(self, method_id)
+              attribute_names = match.attribute_names
+              super unless all_attributes_exists?(attribute_names)
+              if !arguments.first.is_a?(Hash) && arguments.size < attribute_names.size
+                ActiveSupport::Deprecation.warn(
+                  "Calling dynamic scope with less number of arguments than the number of attributes in " \
+                  "method name is deprecated and will raise an ArguementError in the next version of Rails. " \
+                  "Please passing `nil' to the argument you want it to be nil."
+                )
+              end
+              if match.finder.present?
+                options = arguments.extract_options!
+                relation = options.any? ? scoped(options) : scoped
+                relation.send :find_by_attributes, match, attribute_names, *arguments
+              elsif match.instantiator?
+                scoped.send :find_or_instantiator_by_attributes, match, attribute_names, *arguments, &block
+              end
             end
           else
             super
@@ -624,7 +642,7 @@ module DatastaxRails #:nodoc:
         end
         
         def relation #:nodoc:
-          @relation ||= Relation.new(self, column_family)
+          Relation.new(self, column_family)
         end
         
         # Returns the class type of the record using the current module as a prefix. So descendants of