datastax_rails 1.2.3 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a8971782b7516d5060103ef9b6ed6b56b71a5ad4
-  data.tar.gz: 19487f48ae56cdf4ead4176377f5e0bbe3ac6bc3
+  metadata.gz: 6d858bc7834309a95814f407b2c85512b50cfa7a
+  data.tar.gz: c8c2896838848cd1f00a9c8f662958682ec60cff
 SHA512:
-  metadata.gz: 7af9042a6919a4567e66b925934cd17e17fcbecb7dd6edf4ab6de5e66c6af378f942eab851bb962c197f6f46a44bd5a657df747c886f6169c1a9796c0ddc9e46
-  data.tar.gz: 9e0fef7994f2746c934f15b6922e6dfae0b7974b0b4ee88d7594287709f8c3cb7e25cea3dd936a4e16ecaa524eb6fa0ea255bbdc84f460f36040a1f58ca82669
+  metadata.gz: b9cd869dd42101301ad8450e10e45bb983628217a079831fc834e0d65652bd87212ac8ecd90455c7c40fc1632a099f682a30786d42686fd9c4bbd8c64a312580
+  data.tar.gz: 44a0baf08768ac8147fc59555c6cacc3021c95c0da3138aeb0c09790bf28fbcd0ee506faee060a264e4e23be5c5aa97a8ecd1e65a6c20d98ecb9a66b0d9325c6

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011-2012 [Jason M. Kusar]
+Copyright (c) 2011-2014 [Jason M. Kusar]
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -29,12 +29,13 @@ First add it to your Gemfile:
 Configure the config/datastax.yml file:
 
   development:
-    servers: ["localhost:9160"]
+    servers: ["127.0.0.1"]
+    port: 9042
     keyspace: "<my_app>_development"
     strategy_class: "org.apache.cassandra.locator.NetworkTopologyStrategy"
     strategy_options: {"DC1": "1"} 
     connection_options:
-      timeout: 2
+      timeout: 10
     solr:
       port: 8983
       path: /solr
@@ -45,12 +46,13 @@ NetworkTopologySnitch and set up the cassandra-topology.properties file.  See th
 For a more simple, single datacenter setup, something like this should probably work:
 
   development:
-    servers: ["localhost:9160"]
-    keyspace: "<my_app>_development"
+    servers: ["127.0.0.1"]
+    port: 9042
+    keyspace: "datastax_rails_development"
     strategy_class: "org.apache.cassandra.locator.SimpleStrategy"
     strategy_options: {"replication_factor": "1"}
     connection_options:
-      timeout: 2 
+      timeout: 10
     solr:
       port: 8983
       path: /solr
@@ -73,7 +75,7 @@ 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
+    uuid    :id
     string  :first_name
     string  :user_name
     text    :bio
@@ -81,12 +83,22 @@ Create a sample Model.  See Base documentation for more details:
     boolean :active
     timestamps
   end
+  
+=== Different types of models
+
+In addition to the simple model above, there are several special case models that take advantage of special
+features of Cassandra.  For examples of using those, see the following classes:
+
+* {DatastaxRails::WideStorageModel}
+* {DatastaxRails::PayloadModel}
+* {DatastaxRails::DynamicModel}
 
 === Known issues
 
-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.
+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
 
-The documentation for DatastaxRails::Base and DatastaxRails::SearchMethods will give you quite a few examples
+The documentation for {DatastaxRails::Base} and {DatastaxRails::SearchMethods} will give you quite a few examples
 of things you can do.  You can find a copy of the latest documentation on line at http://rdoc.info/github/jasonmk/datastax_rails/master/frames.

data/config/schema.xml.erb

@@ -36,35 +36,38 @@
     	<filter class="solr.LowerCaseFilterFactory"/>
     </analyzer>
   </fieldType>
-  <fieldType name="array" class="solr.TextField" positionIncrementGap="100">
-  	<analyzer>
-  		<tokenizer class="solr.PatternTokenizerFactory" pattern="\$\$\$\$"/>
-  		<filter class="solr.LowerCaseFilterFactory"/>
-  	</analyzer>
-  </fieldType>
   <fieldType name="boolean" class="solr.BoolField" sortMissingLast="true"/>
   <fieldType name="date" class="solr.TrieDateField" precisionStep="0" positionIncrementGap="0"/>
   <fieldType name="int" class="solr.TrieIntField" precisionStep="0" positionIncrementGap="0"/>
   <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"/>
+  <fieldType name="uuid" class="solr.UUIDField" indexed="true" />
+  <fieldType name="binary" class="solr.BinaryField" indexed="false" />
  </types>
  <fields>
-    <field name="id"  type="string" indexed="true"  stored="true"/>
-    <% @fields.each do |field| %>
-    	<field name="<%= field[:name] %>" type="<%= field[:type] %>" indexed="<%= field[:indexed] %>" stored="<%= field[:stored] %>" multiValued="<%= field[:multi_valued] %>"/>
+    <% @columns.each do |field| %>
+      <% if field.type == :map %>
+        <dynamicField name="<%= field.name %>*" type="<%= field.solr_type %>" indexed="<%= field.options[:solr_index] %>" stored="<%= field.options[:solr_store] %>" multiValued="false"/>
+      <% else %>
+    	<field name="<%= field.name %>" type="<%= field.solr_type %>" indexed="<%= field.options[:solr_index] %>" stored="<%= field.options[:solr_store] %>" multiValued="<%= field.options[:multi_valued] %>"/>
+    	<% if field.solr_type == 'text' && field.options[:sortable] %>
+    	    <field name="sort_<%= field.name %>" type="string" indexed="true" stored="fase" multiValued="false"/>
+    	<% end %>
+      <% end %>
     <% end %>
     <field name="text"  type="text" indexed="true"  stored="false" multiValued="true"/>
  </fields>
 
-<defaultSearchField>text</defaultSearchField>
-<solrQueryParser defaultOperator="AND"/>
-<uniqueKey>id</uniqueKey>
-<% @fulltext_fields.each do |field| %>
-  <copyField source="<%= field %>" dest="text"/>
-<% end %>
-<% @copy_fields.each do |field| %>
-  <copyField source="<%= field[:source] %>" dest="<%= field[:dest]%>"/>
-<% end %>
-
+ <defaultSearchField>text</defaultSearchField>
+ <solrQueryParser defaultOperator="AND"/>
+ <uniqueKey><%= @primary_key %></uniqueKey>
+ <% @columns.each do |field| %>
+   <% if field.options[:fulltext] %>
+   <copyField source="<%= field.name %><%= field.type == :map ? "*" : ''%>" dest="text"/>
+   <% end %>
+   <% if field.solr_type == 'text' && field.options[:sortable] %>
+   <copyField source="<%= field.name %>" dest="sort_<%= field.name%>"/>
+   <% end %>
+ <% end %>
 </schema>

data/config/solrconfig.xml.erb

@@ -50,7 +50,7 @@
   <luceneMatchVersion>LUCENE_40</luceneMatchVersion>
   
   <!-- Enable DSE Search new type mappings -->
-  <dseTypeMappingVersion><%= @legacy ? 0 : 1 %></dseTypeMappingVersion>
+  <dseTypeMappingVersion>2</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/cql-rb_extensions.rb

@@ -0,0 +1,27 @@
+require 'cql'
+require 'cql/client/connection_manager'
+
+Cql::Client::ConnectionManager.class_eval do
+  attr_reader :current_connection
+  
+  def random_connection
+    raise NotConnectedError unless connected?
+    @lock.synchronize do
+      @count ||= 0
+      @count += 1
+      if @count > 500
+        @count = 0
+        @current_connection = nil
+      end
+      @current_connection ||= @connections.sample
+    end
+  end
+end
+
+require 'cql/client/synchronous_client'
+
+Cql::Client::SynchronousClient.class_eval do
+  def current_connection
+    async.instance_variable_get(:@connection_manager).current_connection
+  end
+end

data/lib/datastax_rails.rb

@@ -1,5 +1,4 @@
 require 'active_support/all'
-require 'cassandra-cql/1.2'
 require 'blankslate'
 require 'schema_migration'
 
@@ -14,11 +13,12 @@ module DatastaxRails
   autoload :Batches
   autoload :Callbacks
   autoload :CassandraOnlyModel
+  autoload :Column
   autoload :Collection
   autoload :Connection
   autoload :Cql
+  autoload :DynamicModel
   autoload :GroupedCollection
-  autoload :Identity
   autoload :Index
   autoload :Inheritance
   autoload :PayloadModel
@@ -41,7 +41,6 @@ module DatastaxRails
   autoload :Scoping
   autoload :Serialization
   autoload :Timestamps
-  autoload :Type
   autoload_under 'util' do
     autoload :SolrRepair
   end
@@ -53,9 +52,11 @@ module DatastaxRails
     extend ActiveSupport::Autoload
 
     eager_autoload do
-      autoload :Definition
       autoload :Dirty
+      autoload :PrimaryKey
+      autoload :Read
       autoload :Typecasting
+      autoload :Write
     end
   end
   
@@ -73,26 +74,21 @@ module DatastaxRails
     autoload :Keyspace
     autoload :ColumnFamily
   end
-
+  
   module Types
     extend ActiveSupport::Autoload
     
-    autoload :BaseType
-    autoload :BinaryType
-    autoload :ArrayType
-    autoload :BooleanType
-    autoload :DateType
-    autoload :FloatType
-    autoload :IntegerType
-    autoload :JsonType
-    autoload :StringType
-    autoload :TextType
-    autoload :TimeType
-    autoload :TimeWithZoneType
+    eager_autoload do
+      autoload :DirtyCollection
+      autoload :DynamicList
+      autoload :DynamicSet
+      autoload :DynamicMap
+    end
   end
 end
 
 require 'datastax_rails/railtie' if defined?(Rails)
 require 'datastax_rails/errors'
+require 'cql-rb_extensions'
 
 ActiveSupport.run_load_hooks(:datastax_rails, DatastaxRails::Base)

data/lib/datastax_rails/associations/association.rb

@@ -213,10 +213,7 @@ module DatastaxRails
 
         def build_record(attributes, options)
           reflection.build_association(attributes, options) do |r|
-            r.assign_attributes(
-              create_scope.except(*r.changed),
-              :without_protection => true
-            )
+            r.assign_attributes(create_scope.except(*r.changed))
           end
         end
     end

data/lib/datastax_rails/associations/collection_proxy.rb

@@ -61,19 +61,6 @@ module DatastaxRails
       end
       
       def method_missing(method, *args, &block)
-        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
-            proxy_association.send :add_to_target, r
-            yield(r) if block_given?
-          end
-        end
-
         if target.respond_to?(method) || (!proxy_association.klass.respond_to?(method) && Class.respond_to?(method))
           if load_target
             if target.respond_to?(method)

data/lib/datastax_rails/attribute_assignment.rb

@@ -3,112 +3,49 @@ 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
+    include ActiveModel::ForbiddenAttributesProtection
 
-    # 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
+    # Allows you to set all the attributes by passing in a hash of attributes with
+    # keys matching the attribute names (which again matches the column names).
     #
-    #   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 = {})
+    # If the passed hash responds to <tt>permitted?</tt> method and the return value
+    # of this method is +false+ an <tt>ActiveModel::ForbiddenAttributesError</tt>
+    # exception is raised.
+    def assign_attributes(new_attributes)
       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)
+      attributes = sanitize_for_mass_assignment(attributes)
+
+      attributes.each do |k, v|
+        if v.is_a?(Hash)
+          nested_parameter_attributes << [ k, v ]
         else
-          attributes = sanitize_for_mass_assignment(attributes)
+          _assign_attribute(k, v)
         end
       end
 
-      attributes.each do |k, v|
+      assign_nested_parameter_attributes(nested_parameter_attributes) unless nested_parameter_attributes.empty?
+    end
+    alias attributes= assign_attributes
+    
+    private
+    
+      def _assign_attribute(k, v)
+        public_send("#{k}=", v)
+      rescue NoMethodError
         if respond_to?("#{k}=")
-          if v.is_a?(Hash)
-            nested_parameter_attributes << [ k, v ]
-          else
-            send("#{k}=", v)
-          end
+          raise
         else
-          raise(UnknownAttributeError, "unknown attribute: #{k}")
+          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)
+  
+      # Assign any deferred nested attributes after the base attributes have been set.
+      def assign_nested_parameter_attributes(pairs)
+        pairs.each { |k, v| _assign_attribute(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.rb

@@ -1,24 +1,67 @@
+require 'mutex_m'
+
 module DatastaxRails
   module AttributeMethods
     extend ActiveSupport::Concern
     include ActiveModel::AttributeMethods
     
     included do
+      initialize_generated_modules
+
+      include Write
+      include Dirty
+      include Read
+      include PrimaryKey
+      include Typecasting
+      
       alias :[] :read_attribute
       alias :[]= :write_attribute
-
-      attribute_method_suffix("=")
+      alias has_attribute? attribute_exists?
     end
     
     module ClassMethods
+      def inherited(child_class)
+        child_class.initialize_generated_modules
+        super
+      end
+      
+      def initialize_generated_modules
+        @generated_attribute_methods = Module.new {
+          extend Mutex_m
+
+          const_set :AttrNames, Module.new {
+            def self.set_name_cache(name, value)
+              const_name = "ATTR_#{name}"
+              unless const_defined? const_name
+                const_set const_name, value.dup.freeze
+              end
+            end
+          }
+        }
+        @attribute_methods_generated = false
+        include @generated_attribute_methods
+      end
+      
       def define_attribute_methods
-        return if attribute_methods_generated?
-        super(attribute_definitions.keys)
-        # Remove setter methods from readonly attributes
-        readonly_attributes.each do |attr|
-          remove_method("#{attr}=".to_sym) if method_defined?("#{attr}=".to_sym)
+        # Use a mutex; we don't want two thread simultaneously trying to define
+        # attribute methods.
+        generated_attribute_methods.synchronize do
+          return false if attribute_methods_generated?
+          super(attribute_definitions.keys)
+          # Remove setter methods from readonly attributes
+          readonly_attributes.each do |attr|
+            remove_method("#{attr}=".to_sym) if method_defined?("#{attr}=".to_sym)
+          end
+          @attribute_methods_generated = true
+        end
+        true
+      end
+      
+      def undefine_attribute_methods
+        generated_attribute_methods.synchronize do
+          super if attribute_methods_generated?
+          @attribute_methods_generated = false
         end
-        @attribute_methods_generated = true
       end
 
       def attribute_methods_generated?
@@ -32,21 +75,8 @@ 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
+        default = options.delete :default
 
-        if type.is_a?(Symbol)
-          coder = DatastaxRails::Type.get_coder(type) || (raise "Unknown type #{type}")
-        elsif coder.nil?
-          raise "Must supply a :coder for #{name}"
-        end
-        
         if(options[:lazy])
           lazy_attributes << name.to_sym
         end
@@ -54,31 +84,48 @@ module DatastaxRails
         if(options[:readonly])
           readonly_attributes << name.to_sym
         end
-
-        attribute_definitions[name.to_sym] = AttributeMethods::Definition.new(self, name, coder, options)
-      end
-    end
-    
-    # Casts the attribute and stores it in the attribute hash.
-    def write_attribute(name, value)
-      if(attribute_definitions[name.to_sym].coder.is_a?(DatastaxRails::Types::BinaryType))
-        @attributes[name.to_s] = value
-      else
-        @attributes[name.to_s] = self.class.typecast_attribute(self, name, value)
+        
+        column = Column.new(name, default, type, options)
+        column.primary = (name.to_s == primary_key.to_s)
+        if coder
+          coder = coder.constantize rescue nil
+          if coder.class == Class && (coder.instance_methods & [:dump, :load]).size == 2
+            column.coder = coder.new(self)
+          else
+            raise ArgumentError, "Coder must be a class that responds the dump and load instance variables"
+          end
+        end
+        attribute_definitions[name.to_sym] = column
       end
-    end
-
-    # Returns the attribute out of the attribute hash.  If the attribute is lazy loaded and hasn't
-    # been loaded yet it will be done so now.
-    def read_attribute(name)
-      if(!loaded_attributes[name] && persisted? && !key.blank?)
-        @attributes[name.to_s] = self.class.select(name).with_cassandra.find(self.id).read_attribute(name)
-        loaded_attributes[name] = true
+      
+      # Returns the column object for the named attribute. Returns +nil+ if the
+      # named attribute not exists.
+      #
+      #   class Person < DatastaxRails::Base
+      #   end
+      #
+      #   person = Person.new
+      #   person.column_for_attribute(:name)
+      #   # => #<DatastaxRails::Base:0x007ff4ab083980 @name="name", @sql_type="varchar(255)", @null=true, ...>
+      #
+      # person.column_for_attribute(:nothing)
+      # # => nil
+      def column_for_attribute(name)
+        # FIXME: should this return a null object for columns that don't exist?
+        column = self.columns_hash[name.to_s]
+        unless column
+          # Check for a dynamic column
+          columns_hash.values.each do |col|
+            if col.type == :map && name.to_s.starts_with?("#{col.name}")
+              column = col
+              break
+            end
+          end
+        end
+        column
       end
-        
-      @attributes[name.to_s]
     end
-
+    
     def attribute_exists?(name)
       @attributes.key?(name.to_s)
     end
@@ -96,11 +143,29 @@ module DatastaxRails
       self.class.define_attribute_methods unless self.class.attribute_methods_generated?
       super
     end
+    
+    def column_for_attribute(name)
+      self.class.column_for_attribute(name)
+    end
 
     protected
       def attribute_method?(name)
         !!attribute_definitions[name.to_sym]
       end
+      
+      def clone_attributes(reader_method = :read_attribute, attributes = {}) # :nodoc:
+        attribute_names.each do |name|
+          attributes[name] = clone_attribute_value(reader_method, name)
+        end
+        attributes
+      end
+  
+      def clone_attribute_value(reader_method, attribute_name) # :nodoc:
+        value = send(reader_method, attribute_name)
+        value.duplicable? ? value.clone : value
+      rescue TypeError, NoMethodError
+        value
+      end
 
     private
       def attribute(name)