datastax_rails 2.0.3 → 2.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d858bc7834309a95814f407b2c85512b50cfa7a
-  data.tar.gz: c8c2896838848cd1f00a9c8f662958682ec60cff
+  metadata.gz: 06972ed110ef94f1e39ad303f9d83b3c012f2840
+  data.tar.gz: 633ea7c7ff603672a07bc70ecb5b62059d12d18d
 SHA512:
-  metadata.gz: b9cd869dd42101301ad8450e10e45bb983628217a079831fc834e0d65652bd87212ac8ecd90455c7c40fc1632a099f682a30786d42686fd9c4bbd8c64a312580
-  data.tar.gz: 44a0baf08768ac8147fc59555c6cacc3021c95c0da3138aeb0c09790bf28fbcd0ee506faee060a264e4e23be5c5aa97a8ecd1e65a6c20d98ecb9a66b0d9325c6
+  metadata.gz: b826619dcf22f443352173c26accb3f994a8b229739aa6ab71e64013a05fed9df1d59af3478f05bbcb21dc19637699ad009dc5c577abf1c87fe2984d29ee05db
+  data.tar.gz: f86a2dec43ce66e55c270b494554b15d4a33ace9e84481d459e5200f32a71c5045575befe6549a4147f04288ac6a28ff8c36ccf4fc256e4046a5bd70997ff180

data/lib/datastax_rails/callbacks.rb

@@ -1,4 +1,256 @@
 module DatastaxRails
+  # = Datastax Rails Callbacks
+  #
+  # Callbacks are hooks into the life cycle of an Datastax Rails object that allow you to trigger logic
+  # before or after an alteration of the object state. This can be used to make sure that associated and
+  # dependent objects are deleted when +destroy+ is called (by overwriting +before_destroy+) or to massage attributes
+  # before they're validated (by overwriting +before_validation+). As an example of the callbacks initiated, consider
+  # the <tt>Base#save</tt> call for a new record:
+  #
+  # * (-) <tt>save</tt>
+  # * (-) <tt>valid</tt>
+  # * (1) <tt>before_validation</tt>
+  # * (-) <tt>validate</tt>
+  # * (2) <tt>after_validation</tt>
+  # * (3) <tt>before_save</tt>
+  # * (4) <tt>before_create</tt>
+  # * (-) <tt>create</tt>
+  # * (5) <tt>after_create</tt>
+  # * (6) <tt>after_save</tt>
+  # * (7) <tt>after_commit</tt>
+  #
+  # Additionally, an <tt>after_touch</tt> callback is triggered whenever an
+  # object is touched.
+  #
+  # Lastly an <tt>after_find</tt> and <tt>after_initialize</tt> callback is triggered for each object that
+  # is found and instantiated by a finder, with <tt>after_initialize</tt> being triggered after new objects
+  # are instantiated as well.
+  #
+  # There are eighteen callbacks in total, which give you immense power to react and prepare for each state in the
+  # Datastax Rails life cycle. The sequence for calling <tt>Base#save</tt> for an existing record is similar,
+  # except that each <tt>_create</tt> callback is replaced by the corresponding <tt>_update</tt> callback.
+  #
+  # Examples:
+  #   class CreditCard < DatastaxRails::Base
+  #     # Strip everything but digits, so the user can specify "555 234 34" or
+  #     # "5552-3434" and both will mean "55523434"
+  #     before_validation(on: :create) do
+  #       self.number = number.gsub(/[^0-9]/, "") if attribute_present?("number")
+  #     end
+  #   end
+  #
+  #   class Subscription < DatastaxRails::Base
+  #     before_create :record_signup
+  #
+  #     private
+  #       def record_signup
+  #         self.signed_up_on = Date.today
+  #       end
+  #   end
+  #
+  #   class Firm < DatastaxRails::Base
+  #     # Destroys the associated clients and people when the firm is destroyed
+  #     before_destroy { |record| Person.destroy_all "firm_id = #{record.id}"   }
+  #     before_destroy { |record| Client.destroy_all "client_of = #{record.id}" }
+  #   end
+  #
+  # == Inheritable callback queues
+  #
+  # Besides the overwritable callback methods, it's also possible to register callbacks through the
+  # use of the callback macros. Their main advantage is that the macros add behavior into a callback
+  # queue that is kept intact down through an inheritance hierarchy.
+  #
+  #   class Topic < DatastaxRails::Base
+  #     before_destroy :destroy_author
+  #   end
+  #
+  #   class Reply < Topic
+  #     before_destroy :destroy_readers
+  #   end
+  #
+  # Now, when <tt>Topic#destroy</tt> is run only +destroy_author+ is called. When <tt>Reply#destroy</tt> is
+  # run, both +destroy_author+ and +destroy_readers+ are called. Contrast this to the following situation
+  # where the +before_destroy+ method is overridden:
+  #
+  #   class Topic < DatastaxRails::Base
+  #     def before_destroy() destroy_author end
+  #   end
+  #
+  #   class Reply < Topic
+  #     def before_destroy() destroy_readers end
+  #   end
+  #
+  # In that case, <tt>Reply#destroy</tt> would only run +destroy_readers+ and _not_ +destroy_author+.
+  # So, use the callback macros when you want to ensure that a certain callback is called for the entire
+  # hierarchy, and use the regular overwritable methods when you want to leave it up to each descendant
+  # to decide whether they want to call +super+ and trigger the inherited callbacks.
+  #
+  # *IMPORTANT:* In order for inheritance to work for the callback queues, you must specify the
+  # callbacks before specifying the associations. Otherwise, you might trigger the loading of a
+  # child before the parent has registered the callbacks and they won't be inherited.
+  #
+  # == Types of callbacks
+  #
+  # There are four types of callbacks accepted by the callback macros: Method references (symbol), callback objects,
+  # inline methods (using a proc), and inline eval methods (using a string). Method references and callback objects
+  # are the recommended approaches, inline methods using a proc are sometimes appropriate (such as for
+  # creating mix-ins), and inline eval methods are deprecated.
+  #
+  # The method reference callbacks work by specifying a protected or private method available in the object, like this:
+  #
+  #   class Topic < DatastaxRails::Base
+  #     before_destroy :delete_parents
+  #
+  #     private
+  #       def delete_parents
+  #         self.class.delete_all "parent_id = #{id}"
+  #       end
+  #   end
+  #
+  # The callback objects have methods named after the callback called with the record as the only parameter, such as:
+  #
+  #   class BankAccount < DatastaxRails::Base
+  #     before_save      EncryptionWrapper.new
+  #     after_save       EncryptionWrapper.new
+  #     after_initialize EncryptionWrapper.new
+  #   end
+  #
+  #   class EncryptionWrapper
+  #     def before_save(record)
+  #       record.credit_card_number = encrypt(record.credit_card_number)
+  #     end
+  #
+  #     def after_save(record)
+  #       record.credit_card_number = decrypt(record.credit_card_number)
+  #     end
+  #
+  #     alias_method :after_initialize, :after_save
+  #
+  #     private
+  #       def encrypt(value)
+  #         # Secrecy is committed
+  #       end
+  #
+  #       def decrypt(value)
+  #         # Secrecy is unveiled
+  #       end
+  #   end
+  #
+  # So you specify the object you want messaged on a given callback. When that callback is triggered, the object has
+  # a method by the name of the callback messaged. You can make these callbacks more flexible by passing in other
+  # initialization data such as the name of the attribute to work with:
+  #
+  #   class BankAccount < DatastaxRails::Base
+  #     before_save      EncryptionWrapper.new("credit_card_number")
+  #     after_save       EncryptionWrapper.new("credit_card_number")
+  #     after_initialize EncryptionWrapper.new("credit_card_number")
+  #   end
+  #
+  #   class EncryptionWrapper
+  #     def initialize(attribute)
+  #       @attribute = attribute
+  #     end
+  #
+  #     def before_save(record)
+  #       record.send("#{@attribute}=", encrypt(record.send("#{@attribute}")))
+  #     end
+  #
+  #     def after_save(record)
+  #       record.send("#{@attribute}=", decrypt(record.send("#{@attribute}")))
+  #     end
+  #
+  #     alias_method :after_initialize, :after_save
+  #
+  #     private
+  #       def encrypt(value)
+  #         # Secrecy is committed
+  #       end
+  #
+  #       def decrypt(value)
+  #         # Secrecy is unveiled
+  #       end
+  #   end
+  #
+  # The callback macros usually accept a symbol for the method they're supposed to run, but you can also
+  # pass a "method string", which will then be evaluated within the binding of the callback. Example:
+  #
+  #   class Topic < DatastaxRails::Base
+  #     before_destroy 'self.class.delete_all "parent_id = #{id}"'
+  #   end
+  #
+  # Notice that single quotes (') are used so the <tt>#{id}</tt> part isn't evaluated until the callback
+  # is triggered. Also note that these inline callbacks can be stacked just like the regular ones:
+  #
+  #   class Topic < DatastaxRails::Base
+  #     before_destroy 'self.class.delete_all "parent_id = #{id}"',
+  #                    'puts "Evaluated after parents are destroyed"'
+  #   end
+  #
+  # == <tt>before_validation*</tt> returning statements
+  #
+  # If the returning value of a +before_validation+ callback can be evaluated to +false+, the process will be
+  # aborted and <tt>Base#save</tt> will return +false+. If Base#save! is called it will raise a
+  # DatastaxRails::RecordInvalid exception. Nothing will be appended to the errors object.
+  #
+  # == Canceling callbacks
+  #
+  # If a <tt>before_*</tt> callback returns +false+, all the later callbacks and the associated action are
+  # cancelled. If an <tt>after_*</tt> callback returns +false+, all the later callbacks are cancelled.
+  # Callbacks are generally run in the order they are defined, with the exception of callbacks defined as
+  # methods on the model, which are called last.
+  #
+  # == Ordering callbacks
+  #
+  # Sometimes the code needs that the callbacks execute in a specific order. For example, a +before_destroy+
+  # callback (+log_children+ in this case) should be executed before the children get destroyed by the +dependent: destroy+ option.
+  #
+  # Let's look at the code below:
+  #
+  #   class Topic < DatastaxRails::Base
+  #     has_many :children, dependent: destroy
+  #
+  #     before_destroy :log_children
+  #
+  #     private
+  #       def log_children
+  #         # Child processing
+  #       end
+  #   end
+  #
+  # In this case, the problem is that when the +before_destroy+ callback is executed, the children are not available
+  # because the +destroy+ callback gets executed first. You can use the +prepend+ option on the +before_destroy+ callback to avoid this.
+  #
+  #   class Topic < DatastaxRails::Base
+  #     has_many :children, dependent: destroy
+  #
+  #     before_destroy :log_children, prepend: true
+  #
+  #     private
+  #       def log_children
+  #         # Child processing
+  #       end
+  #   end
+  #
+  # This way, the +before_destroy+ gets executed before the <tt>dependent: destroy</tt> is called, and the data is still available.
+  #
+  # == Debugging callbacks
+  #
+  # The callback chain is accessible via the <tt>_*_callbacks</tt> method on an object. ActiveModel Callbacks support
+  # <tt>:before</tt>, <tt>:after</tt> and <tt>:around</tt> as values for the <tt>kind</tt> property. The <tt>kind</tt> property
+  # defines what part of the chain the callback runs in.
+  #
+  # To find all callbacks in the before_save callback chain:
+  #
+  #   Topic._save_callbacks.select { |cb| cb.kind.eql?(:before) }
+  #
+  # Returns an array of callback objects that form the before_save chain.
+  #
+  # To further check if the before_save chain contains a proc defined as <tt>rest_when_dead</tt> use the <tt>filter</tt> property of the callback object:
+  #
+  #   Topic._save_callbacks.select { |cb| cb.kind.eql?(:before) }.collect(&:filter).include?(:rest_when_dead)
+  #
+  # Returns true or false depending on whether the proc is contained in the before_save callback chain on a Topic model.
+  #
   module Callbacks
     extend ActiveSupport::Concern
 
@@ -9,33 +261,37 @@ module DatastaxRails
       :before_destroy, :around_destroy, :after_destroy, :after_commit, :after_rollback
     ]
 
+    module ClassMethods
+      include ActiveModel::Callbacks
+    end
 
     included do
-      extend ActiveModel::Callbacks
       include ActiveModel::Validations::Callbacks
+
       define_model_callbacks :initialize, :find, :touch, :only => :after
       define_model_callbacks :save, :create, :update, :destroy
     end
 
     def destroy(*) #:nodoc:
-      #_run_destroy_callbacks { super }
       run_callbacks(:destroy) { super }
     end
 
-    private
-      def _create_or_update(*) #:nodoc:
-        #_run_save_callbacks { super }
-        run_callbacks(:save) { super }
-      end
-
-      def _create(*) #:nodoc:
-        #_run_create_callbacks { super }
-        run_callbacks(:create) { super }
-      end
-
-      def _update(*) #:nodoc:
-        #_run_update_callbacks { super }
-        run_callbacks(:update) { super }
-      end
+    def touch(*) #:nodoc:
+      run_callbacks(:touch) { super }
+    end
+
+  private
+
+    def _create_or_update(*) #:nodoc:
+      run_callbacks(:save) { super }
+    end
+
+    def _create_record(*) #:nodoc:
+      run_callbacks(:create) { super }
+    end
+
+    def _update_record(*) #:nodoc:
+      run_callbacks(:update) { super }
+    end
   end
-end
+end

data/lib/datastax_rails/column.rb

@@ -146,10 +146,11 @@ module DatastaxRails
       return coder.dump(value) if encoded?
       
       case (dest_type || type)
-      when :uuid             then value.is_a?(::Cql::Uuid) ? value : self.class.value_to_uuid(value)
-      when :date             then value.to_time
-      when :list, :set       then list_to_cql3_value(value)
-      when :map              then map_to_cql3_value(value)
+      when :uuid                        then value.is_a?(::Cql::Uuid) ? value : self.class.value_to_uuid(value)
+      when :time, :datetime, :timestamp then value.to_time.utc
+      when :date                        then value.to_time.utc
+      when :list, :set                  then list_to_cql3_value(value)
+      when :map                         then map_to_cql3_value(value)
       else value
       end
     end
@@ -163,7 +164,7 @@ module DatastaxRails
       
       case (dest_type || type)
       when :boolean                            then value ? 'true' : 'false'
-      when :date, :time, :datetime, :timestamp then value.strftime(Format::SOLR_TIME_FORMAT)
+      when :date, :time, :datetime, :timestamp then value.to_time.utc.strftime(Format::SOLR_TIME_FORMAT)
       when :list, :set                         then self.list_to_solr_value(value)
       when :map                                then self.map_to_solr_value(value)
       else value
@@ -171,19 +172,19 @@ module DatastaxRails
     end
     
     def list_to_solr_value(value)
-      value.map {|v| type_cast_for_solr(v, @options[:holds])}
+      value.map {|v| type_cast_for_solr(v, @options[:holds].to_sym)}
     end
     
     def map_to_solr_value(value)
-      value.each {|k,v| value[k] = type_cast_for_solr(v, @options[:holds])}
+      value.each {|k,v| value[k] = type_cast_for_solr(v, @options[:holds].to_sym)}
     end
     
     def list_to_cql3_value(value)
-      value.map {|v| type_cast_for_cql3(v, @options[:holds])}
+      value.map {|v| type_cast_for_cql3(v, @options[:holds].to_sym)}
     end
     
     def map_to_cql3_value(value)
-      value.dup.each {|k,v| value[k] = type_cast_for_cql3(v, @options[:holds])}
+      value.dup.each {|k,v| value[k] = type_cast_for_cql3(v, @options[:holds].to_sym)}
       value
     end
 
@@ -210,7 +211,7 @@ module DatastaxRails
     end
     
     def full_solr_range
-      if solr_type == 'date'
+      if %w[date uuid].include? solr_type
         '[* TO *]'
       else
         '[\"\" TO *]'

data/lib/datastax_rails/dynamic_model.rb

@@ -33,17 +33,17 @@ module DatastaxRails
   # ts_ prefix to differentiate it from texts.
   #   
   #   class Item < DatastaxRails::DynamicModel
-  #     self.group_by = 'item'
+  #     self.grouping = 'item'
   #     timestamps
   #   end
   #
   #   class CoreMetadata < DatastaxRails::DynamicModel
-  #     self.group_by = 'core'
+  #     self.grouping = 'core'
   #     timestamps
   #   end
   #
   #   class TeamMetadata < DatastaxRails::DynamicModel
-  #     self.group_by = 'team'
+  #     self.grouping = 'team'
   #     timestamps
   #   end
   #
@@ -60,39 +60,79 @@ module DatastaxRails
   # the collection so:
   #
   #   Item.first.strings #=> {s_title: "Title"}
+  #
+  # If you would like to still define known attributes ahead of time, you can still do so:
+  #
+  #   class TeamMetadata < DatastaxRails::DynamicModel
+  #     self.grouping = 'team'
+  #     string :name
+  #     timestamps
+  #   end
+  #
+  #   TeamMetadata.new(name: 'John').name #=> 'John'
+  #   TeamMetadata.new(name: 'John').strings #=> {'s_name' => 'John'}
+  #
+  # Getters and setters are automatically created to map to the attribute stored in the hash.
+  # In addition, there is a helper method to map column names to the field name in solr to
+  # assist with search.
   class DynamicModel < WideStorageModel
     self.abstract_class = true
     
-    class_attribute :group_by_attribute
-    
-    def self.group_by=(group)
-      self.group_by_attribute = group
-      self.attribute_definitions['group'].default = group
-      default_scope -> {where('group' => group)}
-    end
+    PREFIXES = {string: :s_, text: :t_, boolean: :b_, date: :d_,
+                timestamp: :ts_, integer: :i_, float: :f_, uuid: :u_}.with_indifferent_access
     
+    class_attribute :group_by_attribute
+    class_attribute :declared_attributes
     
-    def self.inherited(child)
-      super
-      child.column_family = 'dynamic_model'
-      child.primary_key = 'id'
-      child.cluster_by = 'group'
-      child.uuid :id
-      child.string :group
-      child.map :s_,  :holds => :string
-      child.map :t_,  :holds => :text
-      child.map :b_,  :holds => :boolean
-      child.map :d_,  :holds => :date
-      child.map :ts_, :holds => :timestamp
-      child.map :i_,  :holds => :integer
-      child.map :f_,  :holds => :float
-      child.map :u_,  :holds => :uuid
+    class << self
+      def grouping=(group)
+        self.group_by_attribute = group
+        self.attribute_definitions['group'].default = group
+        default_scope -> {where('group' => group)}
+      end
+      
+      alias_method :_attribute, :attribute
+      
+      def attribute(name, options)
+        options.symbolize_keys!
+        return super if [:map,:list,:set].include?(options[:type].to_sym)
+        # Only type supported for now
+        options.assert_valid_keys(:type)
+        raise ArgumentError, "Invalid type specified for dynamic attribute: '#{name}: #{options[:type]}'" unless PREFIXES.has_key?(options[:type])
+        self.declared_attributes[name] = PREFIXES[options[:type]].to_s + name.to_s
+        define_method(name) do
+          self.send(PREFIXES[options[:type]])[name]
+        end
+        define_method("#{name.to_s}=") do |val|
+          self.send(PREFIXES[options[:type]])[name] = val
+        end
+      end
       
-      child.map_columns.each do |col|
-        child.instance_eval do
-          alias_attribute col.options[:holds].to_s.pluralize, col.name
+      def inherited(child)
+        super
+        child.declared_attributes = child.declared_attributes.nil? ? {}.with_indifferent_access : child.declared_attributes.dup
+        child.column_family = 'dynamic_model'
+        child.primary_key = 'id'
+        child.cluster_by = 'group'
+        child._attribute :id, :type => :uuid
+        child._attribute :group, :type => :string
+        PREFIXES.each do |k,v| 
+          child._attribute v, holds: k.to_sym, type: :map
+          child.instance_eval { alias_attribute k.to_s.pluralize, v}
         end
       end
+      
+      def solr_field_name(attr, type = nil)
+        if type
+          PREFIXES[type].to_s + attr.to_s
+        else
+          declared_attributes[attr] || raise(UnknownAttributeError, "Unknown attribute: #{attr}. You must specify a type.")
+        end
+      end
+    end
+    
+    def solr_field_name(attr, type = nil)
+      self.class.solr_field_name(attr, type)
     end
   end
 end

data/lib/datastax_rails/relation/search_methods.rb

@@ -399,7 +399,7 @@ module DatastaxRails
               end
               attributes.delete(k)
             else
-              attributes[k] = solr_format(v)
+              attributes[k] = solr_format(k,v)
             end
           end
           r.where_values << attributes unless attributes.empty?
@@ -443,7 +443,7 @@ module DatastaxRails
               end
               attributes.delete(k)
             else
-              attributes[k] = solr_format(v)
+              attributes[k] = solr_format(k,v)
             end
           end
           r.where_not_values << attributes unless attributes.empty?
@@ -536,27 +536,26 @@ module DatastaxRails
     end
     
     # Formats a value for solr (assuming this is a solr query).
-    def solr_format(value)
+    def solr_format(attribute, value)
       return value unless use_solr_value
+      column = attribute.is_a?(DatastaxRails::Column) ? attribute : klass.column_for_attribute(attribute)
+      # value = column.type_cast_for_solr(value)
       case
-        when value.is_a?(Time)
-          value.utc.strftime(DatastaxRails::Column::Format::SOLR_TIME_FORMAT)
-        when value.is_a?(DateTime)
-          value.to_time.utc.strftime(DatastaxRails::Column::Format::SOLR_TIME_FORMAT)
-        when value.is_a?(Date)
-          value.strftime(DatastaxRails::Column::Format::SOLR_TIME_FORMAT)
-        when value.is_a?(Array)
-          value.collect {|v| v.to_s.gsub(/ /,"\\ ") }.join(" OR ")
+        when value.is_a?(Time) || value.is_a?(DateTime) || value.is_a?(Date) 
+          column.type_cast_for_solr(value)
+        when value.is_a?(Array) || value.is_a?(Set)
+          column.type_cast_for_solr(value).collect {|v| v.to_s.gsub(/ /,"\\ ") }.join(" OR ")
         when value.is_a?(Fixnum)
           value < 0 ? "\\#{value}" : value
         when value.is_a?(Range)
-          "[#{solr_format(value.first)} TO #{solr_format(value.last)}]"
+          "[#{solr_format(attribute, value.first)} TO #{solr_format(attribute, value.last)}]"
         when value.is_a?(String)
           solr_escape(downcase_query(value.gsub(/ /,"\\ ")))
         when value.is_a?(FalseClass), value.is_a?(TrueClass)
           value.to_s
         else
           value
+          
       end
     end
     
@@ -571,9 +570,9 @@ module DatastaxRails
       def equal_to(value) #:nodoc:
         @relation.clone.tap do |r|
           if @invert
-            r.where_not_values << {@attribute => r.solr_format(value)}
+            r.where_not_values << {@attribute => r.solr_format(@attribute, value)}
           else
-            r.where_values << {@attribute => r.solr_format(value)}
+            r.where_values << {@attribute => r.solr_format(@attribute, value)}
           end
         end
       end
@@ -581,9 +580,9 @@ module DatastaxRails
       def greater_than(value) #:nodoc:
         @relation.clone.tap do |r|
           if @invert
-            r.less_than_values << {@attribute => r.solr_format(value)}
+            r.less_than_values << {@attribute => r.solr_format(@attribute, value)}
           else
-            r.greater_than_values << {@attribute => r.solr_format(value)}
+            r.greater_than_values << {@attribute => r.solr_format(@attribute, value)}
           end
         end
       end
@@ -591,9 +590,9 @@ module DatastaxRails
       def less_than(value) #:nodoc:
         @relation.clone.tap do |r|
           if @invert
-            r.greater_than_values << {@attribute => r.solr_format(value)}
+            r.greater_than_values << {@attribute => r.solr_format(@attribute, value)}
           else
-            r.less_than_values << {@attribute => r.solr_format(value)}
+            r.less_than_values << {@attribute => r.solr_format(@attribute, value)}
           end
         end
       end

data/lib/datastax_rails/schema/migrator.rb

@@ -16,10 +16,11 @@ module DatastaxRails
 
       def migrate_all(force = false)
         say_with_time("Migrating all models") do
-          # Ensure all models are loaded (necessary for non-production mode)
-          Dir[Rails.root.join("app","models",'*.rb').to_s].each do |file|
-            require File.basename(file, File.extname(file))
+
+          FileList[rails_models].each do |model|
+            require model
           end
+
           count = 0
           DatastaxRails::Base.models.each do |m|
             if !m.abstract_class?
@@ -52,6 +53,18 @@ module DatastaxRails
       end
 
       private
+
+        # Determine all models to be included within the migration
+        # using Rails config paths instead of absolute paths.
+        # This enables Rails Engines to monkey patch their own
+        # models in, to be automatically included within migrations.
+        #
+        # @see http://pivotallabs.com/leave-your-migrations-in-your-rails-engines/
+        #
+        # @return [Array] list of configured application models
+        def rails_models
+          Rails.configuration.paths['app/models'].expanded.map { |p| p + '/*.rb' }
+        end
       
         # Checks to ensure that the schema_migrations column family exists and creates it if not
         def check_schema_migrations

data/lib/datastax_rails/serialization.rb

@@ -19,6 +19,11 @@ module DatastaxRails
 
       hash
     end
+    
+    def as_json(options = {})
+      json = super(options)
+      json.each {|k,v| json[k] = v.to_s if v.is_a?(::Cql::Uuid)}
+    end
 
     private
       # Add associations specified via the <tt>:include</tt> option.

data/lib/datastax_rails/types/dynamic_map.rb

@@ -20,13 +20,12 @@ module DatastaxRails
         super(convert_key(key))
       end
       
-      protected
-        def convert_key(key)
-          unless key.to_s.starts_with?(name)
-            key = name + key.to_s
-          end
-          super(key)
+      def convert_key(key)
+        unless key.to_s.starts_with?(name)
+          key = name + key.to_s
         end
+        super(key)
+      end
     end
   end
 end

data/lib/datastax_rails/version.rb

@@ -1,4 +1,3 @@
 module DatastaxRails
-  # The current version of the gem
-  VERSION = "2.0.3"
+  VERSION = "2.0.4"
 end

data/spec/datastax_rails/base_spec.rb

@@ -8,12 +8,18 @@ describe DatastaxRails::Base do
   end
   
   it "should run after_save" do
-    Person.commit_solr
-    p = Person.new(:name => "Jason")
-    p.save!
+    p = Person.new(:name => "Steve")
+    p.save
     p.instance_variable_get(:@after_save_ran).should == "yup"
   end
   
+  it "should run after_create" do
+    p = Person.new(:name => "Tommy")
+    p.save
+    p.instance_variable_get(:@after_create_ran).should == "yup"
+  end
+  
+  
   it "should raise RecordNotFound when finding a bogus ID" do
     lambda { Person.find("xyzzy") }.should raise_exception(DatastaxRails::RecordNotFound)
   end
@@ -26,20 +32,22 @@ describe DatastaxRails::Base do
     end
     
     it "considers a new object to be unequal to a saved object" do
-      p1=Person.create!(:name => 'John')
-      p2=Person.new(:name => 'John')
+      p1=Person.create!(:name => 'Mike')
+      p2=Person.new(:name => 'Mike')
       expect(p1).not_to eq(p2)
     end
     
     it "considers two persisted objects to be equal if their primary keys are equal" do
-      p1=Person.create!(:name => 'John')
+      Person.commit_solr
+      p1=Person.create!(:name => 'Jim')
       p2=Person.find(p1.id)
       expect(p1).to eq(p2)
     end
     
     it "considers two persisted objects to be unequal if they have different primary keys" do
-      p1=Person.create!(:name => 'John')
-      p2=Person.create!(:name => 'James')
+      Person.commit_solr
+      p1=Person.create!(:name => 'Kirk')
+      p2=Person.create!(:name => 'Tiberious')
       expect(p1).not_to eq(p2)
     end
   end

data/spec/datastax_rails/column_spec.rb

@@ -197,6 +197,7 @@ describe DatastaxRails::Column do
     
     describe "map" do
       let(:c) {DatastaxRails::Column.new("field_", nil, "map", :holds => :integer)}
+      let(:dc) {DatastaxRails::Column.new("field_", nil, "map", :holds => :date)}
       
       it "casts map keys to strings" do
         expect(c.type_cast({:field_key => 7}, record)).to eq({"field_key" => 7})
@@ -209,6 +210,14 @@ describe DatastaxRails::Column do
       it "wraps map values in a DynamicMap" do
         expect(c.type_cast({'field_key' => '7'}, record)).to be_a(DatastaxRails::Types::DynamicMap)
       end
+      
+      describe "to cql" do
+        it "casts map values to the appropriate type" do
+          date = Date.parse("1980-10-19")
+          time = Time.parse("1980-10-19 00:00:00 +0000")
+          expect(dc.type_cast_for_cql3({:field_key => date})).to eq(:field_key => time)
+        end
+      end
     end
     
     describe "list" do

data/spec/datastax_rails/dynamic_model_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+class DynamicTestModel1 < DatastaxRails::DynamicModel
+  self.grouping = 'test1'
+  string :name
+  timestamps
+end
+
+class DynamicTestModel2 < DatastaxRails::DynamicModel
+  self.grouping = 'test2'
+end
+
+describe DatastaxRails::DynamicModel do
+  let(:one) {DynamicTestModel1.new}
+  let(:two) {DynamicTestModel2.new}
+  
+  it {expect(one).to respond_to(:created_at)}
+  it {expect(one).to respond_to(:created_at=)}
+  it {expect(two).not_to respond_to(:created_at)}
+  it {expect(two).not_to respond_to(:created_at=)}
+  
+  it "sets the attribute in the dynamic collection" do
+    one.name = 'John'
+    expect(one.s_).to eq('s_name' => 'John')
+  end
+  
+  it "retrieves the attribute from the dynamic collection" do
+    one.strings[:name] = 'John'
+    expect(one.name).to eq('John')
+  end
+  
+  describe "#solr_field_name" do
+    it "maps a attribute name to the underlying storage key" do
+      expect(one.solr_field_name(:name)).to eq('s_name')
+    end
+    
+    it "raises DatastaxRails::UnknownAttributeError if an unknown attribute is mapped without a type" do
+      expect{two.solr_field_name(:name)}.to raise_exception(DatastaxRails::UnknownAttributeError)
+    end
+    
+    it "maps an undeclared attribute if a type is given" do
+      expect(one.solr_field_name(:birthdate, :date)).to eq('d_birthdate')
+    end
+  end
+end

data/spec/datastax_rails/relation/search_methods_spec.rb

@@ -228,20 +228,23 @@ describe DatastaxRails::Relation do
   describe '#solr_format' do
     context 'when formatting Time' do
       let(:time) { Time.new 2011, 10, 9, 8, 7, 6, "-05:00" }
+      let(:c) {DatastaxRails::Column.new("field", nil, "time")}
       
-      it { expect(@relation.solr_format(time)).to eq '2011-10-09T13:07:06Z' }
+      it { expect(@relation.solr_format(c,time)).to eq '2011-10-09T13:07:06Z' }
     end
     
     context 'when formatting Date' do
       let(:date) { Date.new 2001, 2, 3 }
+      let(:c) {DatastaxRails::Column.new("field", nil, "date")}
       
-      it { expect(@relation.solr_format(date)).to eq '2001-02-03T00:00:00Z' }
+      it { expect(@relation.solr_format(c,date)).to eq '2001-02-03T00:00:00Z' }
     end
     
     context 'when formatting DateTime' do
       let(:datetime) { DateTime.new 2001, 2, 3, 4, 5, 6, "-07:00" }
+      let(:c) {DatastaxRails::Column.new("field", nil, "timestamp")}
       
-      it { expect(@relation.solr_format(datetime)).to eq '2001-02-03T11:05:06Z' }
+      it { expect(@relation.solr_format(c,datetime)).to eq '2001-02-03T11:05:06Z' }
     end
   end
 end

data/spec/spec_helper.rb

@@ -21,7 +21,7 @@ RSpec.configure do |config|
   # Filter slow specs. Add a :slow tag to the spec to keep it from
   # running unless the SLOW_SPECS environment variable is set.
   config.treat_symbols_as_metadata_keys_with_true_values = true
-  config.filter_run_excluding :slow unless ENV['SLOW_SPECS']
+  # config.filter_run_excluding :slow unless ENV['SLOW_SPECS']
   
   config.before(:each) do
     DatastaxRails::Base.recorded_classes = {}

data/spec/support/models.rb

@@ -16,6 +16,7 @@ class Person < DatastaxRails::Base
   before_create :set_variable2
   before_save :set_nickname
   after_save :set_variable
+  after_create :set_variable3
   
   validates :name, :presence => true, :uniqueness => :true
   
@@ -30,6 +31,10 @@ class Person < DatastaxRails::Base
   def set_variable2
     @before_create_ran = "yup"
   end
+  
+  def set_variable3
+    @after_create_ran = 'yup'
+  end
 end
 
 class Car < DatastaxRails::Base
@@ -103,9 +108,9 @@ class Hobby < DatastaxRails::Base
 end
 
 class CoreMetadata < DatastaxRails::DynamicModel
-  self.group_by = 'core'
+  self.grouping = 'core'
 end
 
 class TeamMetadata < DatastaxRails::DynamicModel
-  self.group_by = 'team'
+  self.grouping = 'team'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: datastax_rails
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.0.4
 platform: ruby
 authors:
 - Jason M. Kusar
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-22 00:00:00.000000000 Z
+date: 2014-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -246,6 +246,7 @@ files:
 - spec/datastax_rails/column_spec.rb
 - spec/datastax_rails/cql/select_spec.rb
 - spec/datastax_rails/cql/update_spec.rb
+- spec/datastax_rails/dynamic_model_spec.rb
 - spec/datastax_rails/inheritance_spec.rb
 - spec/datastax_rails/persistence_spec.rb
 - spec/datastax_rails/relation/batches_spec.rb
@@ -336,6 +337,7 @@ test_files:
 - spec/support/models.rb
 - spec/support/default_consistency_shared_examples.rb
 - spec/support/datastax_test_hook.rb
+- spec/datastax_rails/dynamic_model_spec.rb
 - spec/datastax_rails/attribute_methods_spec.rb
 - spec/datastax_rails/scoping/default_spec.rb
 - spec/datastax_rails/associations_spec.rb