datastax_rails 2.0.12 → 2.0.15

data/lib/datastax_rails/schema_cache.rb

@@ -12,9 +12,7 @@ module DatastaxRails
       end
 
       @columns_hash = Hash.new do |h, table_name|
-        h[table_name] = Hash[columns[table_name].map { |col|
-          [col.name, col]
-        }]
+        h[table_name] = Hash[columns[table_name].map { |col| [col.name, col] }]
       end
 
       @primary_keys = Hash.new do |h, table_name|

data/lib/datastax_rails/scoping/default.rb

@@ -7,7 +7,7 @@ module DatastaxRails
 
       included do
         # Stores the default scope for the class
-        class_attribute :default_scopes, :instance_writer => false
+        class_attribute :default_scopes, instance_writer: false
         self.default_scopes = []
       end
 
@@ -102,7 +102,7 @@ module DatastaxRails
             evaluate_default_scope { default_scope }
           elsif default_scopes.any?
             evaluate_default_scope do
-              default_scopes.inject(relation) do |default_scope, scope|
+              default_scopes.reduce(relation) do |default_scope, scope|
                 if scope.is_a?(Hash)
                   default_scope.apply_finder_options(scope)
                 elsif !scope.is_a?(Relation) && scope.respond_to?(:call)
@@ -135,7 +135,6 @@ module DatastaxRails
             self.ignore_default_scope = false
           end
         end
-
       end
     end
   end

data/lib/datastax_rails/scoping/named.rb

@@ -186,13 +186,11 @@ module DatastaxRails
           singleton_class.send(:redefine_method, name, &scope_proc)
         end
 
-      protected
+        protected
 
         def valid_scope_name?(name)
-          if logger && respond_to?(name, true)
-            logger.warn "Creating scope :#{name}. " \
-                        "Overwriting existing method #{self.name}.#{name}."
-          end
+          logger && respond_to?(name, true) &&
+            logger.warn("Creating scope :#{name}. Overwriting existing method #{self.name}.#{name}.")
         end
       end
     end

data/lib/datastax_rails/scoping.rb

@@ -57,11 +57,10 @@ module DatastaxRails
       #   end
       #
       # *Note*: the +:find+ scope also has effect on update and deletion methods, like +update_all+ and +delete_all+.
-      def with_scope(scope = {}, action = :merge, &block)
+      def with_scope(scope = {}, action = :merge, &_block) # rubocop:disable Style/CyclomaticComplexity
         # If another DatastaxRails class has been passed in, get its current scope
         scope = scope.current_scope if !scope.is_a?(Relation) && scope.respond_to?(:current_scope)
-
-        previous_scope = self.current_scope
+        previous_scope = current_scope
 
         if scope.is_a?(Hash)
           # Dup first and second level of hash (method and params).
@@ -70,16 +69,16 @@ module DatastaxRails
             scope[method] = params.dup unless params == true
           end
 
-          scope.assert_valid_keys([ :find, :create ])
+          scope.assert_valid_keys([:find, :create])
           relation = construct_finder_arel(scope[:find] || {})
           relation.default_scoped = true unless action == :overwrite
 
           if previous_scope && previous_scope.create_with_value && scope[:create]
             scope_for_create = if action == :merge
-              previous_scope.create_with_value.merge(scope[:create])
-            else
-              scope[:create]
-            end
+                                 previous_scope.create_with_value.merge(scope[:create])
+                               else
+                                 scope[:create]
+                               end
 
             relation = relation.create_with(scope_for_create)
           else
@@ -106,8 +105,9 @@ module DatastaxRails
       # Works like with_scope, but discards any nested properties.
       def with_exclusive_scope(method_scoping = {}, &block)
         if method_scoping.values.any? { |e| e.is_a?(DatastaxRails::Relation) }
-          raise ArgumentError, <<-MSG
-  New finder API can not be used with_exclusive_scope. You can either call unscoped to get an anonymous scope not bound to the default_scope:
+          fail ArgumentError, <<-MSG
+  New finder API can not be used with_exclusive_scope. You can either call unscoped to get
+  an anonymous scope not bound to the default_scope:
 
   User.unscoped.where(:active => true)
 
@@ -137,13 +137,12 @@ module DatastaxRails
         relation = scope.merge(relation) if scope
         relation
       end
-
     end
 
     def populate_with_current_scope_attributes
       return unless self.class.scope_attributes?
 
-      self.class.scope_attributes.each do |att,value|
+      self.class.scope_attributes.each do |att, value|
         send("#{att}=", value) if respond_to?("#{att}=")
       end
     end

data/lib/datastax_rails/serialization.rb

@@ -12,52 +12,55 @@ module DatastaxRails
       hash = super(options)
 
       serializable_add_includes(options) do |association, records, opts|
-        hash[association] = records.is_a?(Enumerable) ?
-          records.map { |r| r.serializable_hash(opts) } :
-          records.serializable_hash(opts)
+        hash[association] = if records.is_a?(Enumerable)
+                              records.map { |r| r.serializable_hash(opts) }
+                            else
+                              records.serializable_hash(opts)
+                            end
       end
 
       hash
     end
-    
+
     def as_json(options = {})
       json = super(options)
-      json.each {|k,v| json[k] = v.to_s if v.is_a?(::Cql::Uuid)}
+      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.
-      #
-      # Expects a block that takes as arguments:
-      #   +association+ - name of the association
-      #   +records+     - the association record(s) to be serialized
-      #   +opts+        - options for the association records
-      def serializable_add_includes(options = {})
-        return unless include_associations = options.delete(:include)
 
-        base_only_or_except = { :except => options[:except],
-                                :only => options[:only] }
+    # Add associations specified via the <tt>:include</tt> option.
+    #
+    # Expects a block that takes as arguments:
+    #   +association+ - name of the association
+    #   +records+     - the association record(s) to be serialized
+    #   +opts+        - options for the association records
+    def serializable_add_includes(options = {})
+      include_associations = options.delete(:include)
+      return unless include_associations
 
-        include_has_options = include_associations.is_a?(Hash)
-        associations = include_has_options ? include_associations.keys : Array.wrap(include_associations)
+      base_only_or_except = { except: options[:except],
+                              only:   options[:only] }
 
-        associations.each do |association|
-          records = case self.class.reflect_on_association(association).macro
-          when :has_many, :has_and_belongs_to_many
-            send(association).to_a
-          when :has_one, :belongs_to
-            send(association)
-          end
+      include_has_options = include_associations.is_a?(Hash)
+      associations = include_has_options ? include_associations.keys : Array.wrap(include_associations)
 
-          if records
-            association_options = include_has_options ? include_associations[association] : base_only_or_except
-            opts = options.merge(association_options)
-            yield(association, records, opts)
-          end
-        end
+      associations.each do |association|
+        records = case self.class.reflect_on_association(association).macro
+                  when :has_many, :has_and_belongs_to_many
+                    send(association).to_a
+                  when :has_one, :belongs_to
+                    send(association)
+                  end
 
-        options[:include] = include_associations
+        next unless records
+        association_options = include_has_options ? include_associations[association] : base_only_or_except
+        opts = options.merge(association_options)
+        yield(association, records, opts)
       end
+
+      options[:include] = include_associations
+    end
   end
 end
 

data/lib/datastax_rails/serializers/xml_serializer.rb

@@ -2,175 +2,176 @@ require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/hash/conversions'
 
 module DatastaxRails
+  # Builds an XML document to represent the model. Some configuration is
+  # available through +options+. However more complicated cases should
+  # override DatastaxRails::Base#to_xml.
+  #
+  # By default the generated XML document will include the processing
+  # instruction and all the object's attributes. For example:
+  #
+  #   <?xml version="1.0" encoding="UTF-8"?>
+  #   <topic>
+  #     <title>The First Topic</title>
+  #     <author-name>David</author-name>
+  #     <id type="integer">1</id>
+  #     <approved type="boolean">false</approved>
+  #     <replies-count type="integer">0</replies-count>
+  #     <bonus-time type="datetime">2000-01-01T08:28:00+12:00</bonus-time>
+  #     <written-on type="datetime">2003-07-16T09:28:00+1200</written-on>
+  #     <content>Have a nice day</content>
+  #     <author-email-address>david@loudthinking.com</author-email-address>
+  #     <parent-id></parent-id>
+  #     <last-read type="date">2004-04-15</last-read>
+  #   </topic>
+  #
+  # This behavior can be controlled with <tt>:only</tt>, <tt>:except</tt>,
+  # <tt>:skip_instruct</tt>, <tt>:skip_types</tt>, <tt>:dasherize</tt> and <tt>:camelize</tt> .
+  # The <tt>:only</tt> and <tt>:except</tt> options are the same as for the
+  # +attributes+ method. The default is to dasherize all column names, but you
+  # can disable this setting <tt>:dasherize</tt> to +false+. Setting <tt>:camelize</tt>
+  # to +true+ will camelize all column names - this also overrides <tt>:dasherize</tt>.
+  # To not have the column type included in the XML output set <tt>:skip_types</tt> to +true+.
+  #
+  # For instance:
+  #
+  #   topic.to_xml(:skip_instruct => true, :except => [ :id, :bonus_time, :written_on, :replies_count ])
+  #
+  #   <topic>
+  #     <title>The First Topic</title>
+  #     <author-name>David</author-name>
+  #     <approved type="boolean">false</approved>
+  #     <content>Have a nice day</content>
+  #     <author-email-address>david@loudthinking.com</author-email-address>
+  #     <parent-id></parent-id>
+  #     <last-read type="date">2004-04-15</last-read>
+  #   </topic>
+  #
+  # To include first level associations use <tt>:include</tt>:
+  #
+  #   firm.to_xml :include => [ :account, :clients ]
+  #
+  #   <?xml version="1.0" encoding="UTF-8"?>
+  #   <firm>
+  #     <id type="integer">1</id>
+  #     <rating type="integer">1</rating>
+  #     <name>37signals</name>
+  #     <clients type="array">
+  #       <client>
+  #         <rating type="integer">1</rating>
+  #         <name>Summit</name>
+  #       </client>
+  #       <client>
+  #         <rating type="integer">1</rating>
+  #         <name>Microsoft</name>
+  #       </client>
+  #     </clients>
+  #     <account>
+  #       <id type="integer">1</id>
+  #       <credit-limit type="integer">50</credit-limit>
+  #     </account>
+  #   </firm>
+  #
+  # Additionally, the record being serialized will be passed to a Proc's second
+  # parameter.  This allows for ad hoc additions to the resultant document that
+  # incorporate the context of the record being serialized. And by leveraging the
+  # closure created by a Proc, to_xml can be used to add elements that normally fall
+  # outside of the scope of the model -- for example, generating and appending URLs
+  # associated with models.
+  #
+  #   proc = Proc.new { |options, record| options[:builder].tag!('name-reverse', record.name.reverse) }
+  #   firm.to_xml :procs => [ proc ]
+  #
+  #   <firm>
+  #     # ... normal attributes as shown above ...
+  #     <name-reverse>slangis73</name-reverse>
+  #   </firm>
+  #
+  # To include deeper levels of associations pass a hash like this:
+  #
+  #   firm.to_xml :include => {:account => {}, :clients => {:include => :address}}
+  #   <?xml version="1.0" encoding="UTF-8"?>
+  #   <firm>
+  #     <id type="integer">1</id>
+  #     <rating type="integer">1</rating>
+  #     <name>37signals</name>
+  #     <clients type="array">
+  #       <client>
+  #         <rating type="integer">1</rating>
+  #         <name>Summit</name>
+  #         <address>
+  #           ...
+  #         </address>
+  #       </client>
+  #       <client>
+  #         <rating type="integer">1</rating>
+  #         <name>Microsoft</name>
+  #         <address>
+  #           ...
+  #         </address>
+  #       </client>
+  #     </clients>
+  #     <account>
+  #       <id type="integer">1</id>
+  #       <credit-limit type="integer">50</credit-limit>
+  #     </account>
+  #   </firm>
+  #
+  # To include any methods on the model being called use <tt>:methods</tt>:
+  #
+  #   firm.to_xml :methods => [ :calculated_earnings, :real_earnings ]
+  #
+  #   <firm>
+  #     # ... normal attributes as shown above ...
+  #     <calculated-earnings>100000000000000000</calculated-earnings>
+  #     <real-earnings>5</real-earnings>
+  #   </firm>
+  #
+  # To call any additional Procs use <tt>:procs</tt>. The Procs are passed a
+  # modified version of the options hash that was given to +to_xml+:
+  #
+  #   proc = Proc.new { |options| options[:builder].tag!('abc', 'def') }
+  #   firm.to_xml :procs => [ proc ]
+  #
+  #   <firm>
+  #     # ... normal attributes as shown above ...
+  #     <abc>def</abc>
+  #   </firm>
+  #
+  # Alternatively, you can yield the builder object as part of the +to_xml+ call:
+  #
+  #   firm.to_xml do |xml|
+  #     xml.creator do
+  #       xml.first_name "David"
+  #       xml.last_name "Heinemeier Hansson"
+  #     end
+  #   end
+  #
+  #   <firm>
+  #     # ... normal attributes as shown above ...
+  #     <creator>
+  #       <first_name>David</first_name>
+  #       <last_name>Heinemeier Hansson</last_name>
+  #     </creator>
+  #   </firm>
+  #
+  # As noted above, you may override +to_xml+ in your DatastaxRails::Base
+  # subclasses to have complete control about what's generated. The general
+  # form of doing this is:
+  #
+  #   class IHaveMyOwnXML < DatastaxRails::Base
+  #     def to_xml(options = {})
+  #       options[:indent] ||= 2
+  #       xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+  #       xml.instruct! unless options[:skip_instruct]
+  #       xml.level_one do
+  #         xml.tag!(:second_level, 'content')
+  #       end
+  #     end
+  #   end
   module Serialization
     include ActiveModel::Serializers::Xml
 
-    # Builds an XML document to represent the model. Some configuration is
-    # available through +options+. However more complicated cases should
-    # override DatastaxRails::Base#to_xml.
-    #
-    # By default the generated XML document will include the processing
-    # instruction and all the object's attributes. For example:
-    #
-    #   <?xml version="1.0" encoding="UTF-8"?>
-    #   <topic>
-    #     <title>The First Topic</title>
-    #     <author-name>David</author-name>
-    #     <id type="integer">1</id>
-    #     <approved type="boolean">false</approved>
-    #     <replies-count type="integer">0</replies-count>
-    #     <bonus-time type="datetime">2000-01-01T08:28:00+12:00</bonus-time>
-    #     <written-on type="datetime">2003-07-16T09:28:00+1200</written-on>
-    #     <content>Have a nice day</content>
-    #     <author-email-address>david@loudthinking.com</author-email-address>
-    #     <parent-id></parent-id>
-    #     <last-read type="date">2004-04-15</last-read>
-    #   </topic>
-    #
-    # This behavior can be controlled with <tt>:only</tt>, <tt>:except</tt>,
-    # <tt>:skip_instruct</tt>, <tt>:skip_types</tt>, <tt>:dasherize</tt> and <tt>:camelize</tt> .
-    # The <tt>:only</tt> and <tt>:except</tt> options are the same as for the
-    # +attributes+ method. The default is to dasherize all column names, but you
-    # can disable this setting <tt>:dasherize</tt> to +false+. Setting <tt>:camelize</tt>
-    # to +true+ will camelize all column names - this also overrides <tt>:dasherize</tt>.
-    # To not have the column type included in the XML output set <tt>:skip_types</tt> to +true+.
-    #
-    # For instance:
-    #
-    #   topic.to_xml(:skip_instruct => true, :except => [ :id, :bonus_time, :written_on, :replies_count ])
-    #
-    #   <topic>
-    #     <title>The First Topic</title>
-    #     <author-name>David</author-name>
-    #     <approved type="boolean">false</approved>
-    #     <content>Have a nice day</content>
-    #     <author-email-address>david@loudthinking.com</author-email-address>
-    #     <parent-id></parent-id>
-    #     <last-read type="date">2004-04-15</last-read>
-    #   </topic>
-    #
-    # To include first level associations use <tt>:include</tt>:
-    #
-    #   firm.to_xml :include => [ :account, :clients ]
-    #
-    #   <?xml version="1.0" encoding="UTF-8"?>
-    #   <firm>
-    #     <id type="integer">1</id>
-    #     <rating type="integer">1</rating>
-    #     <name>37signals</name>
-    #     <clients type="array">
-    #       <client>
-    #         <rating type="integer">1</rating>
-    #         <name>Summit</name>
-    #       </client>
-    #       <client>
-    #         <rating type="integer">1</rating>
-    #         <name>Microsoft</name>
-    #       </client>
-    #     </clients>
-    #     <account>
-    #       <id type="integer">1</id>
-    #       <credit-limit type="integer">50</credit-limit>
-    #     </account>
-    #   </firm>
-    #
-    # Additionally, the record being serialized will be passed to a Proc's second
-    # parameter.  This allows for ad hoc additions to the resultant document that
-    # incorporate the context of the record being serialized. And by leveraging the
-    # closure created by a Proc, to_xml can be used to add elements that normally fall
-    # outside of the scope of the model -- for example, generating and appending URLs
-    # associated with models.
-    #
-    #   proc = Proc.new { |options, record| options[:builder].tag!('name-reverse', record.name.reverse) }
-    #   firm.to_xml :procs => [ proc ]
-    #
-    #   <firm>
-    #     # ... normal attributes as shown above ...
-    #     <name-reverse>slangis73</name-reverse>
-    #   </firm>
-    #
-    # To include deeper levels of associations pass a hash like this:
-    #
-    #   firm.to_xml :include => {:account => {}, :clients => {:include => :address}}
-    #   <?xml version="1.0" encoding="UTF-8"?>
-    #   <firm>
-    #     <id type="integer">1</id>
-    #     <rating type="integer">1</rating>
-    #     <name>37signals</name>
-    #     <clients type="array">
-    #       <client>
-    #         <rating type="integer">1</rating>
-    #         <name>Summit</name>
-    #         <address>
-    #           ...
-    #         </address>
-    #       </client>
-    #       <client>
-    #         <rating type="integer">1</rating>
-    #         <name>Microsoft</name>
-    #         <address>
-    #           ...
-    #         </address>
-    #       </client>
-    #     </clients>
-    #     <account>
-    #       <id type="integer">1</id>
-    #       <credit-limit type="integer">50</credit-limit>
-    #     </account>
-    #   </firm>
-    #
-    # To include any methods on the model being called use <tt>:methods</tt>:
-    #
-    #   firm.to_xml :methods => [ :calculated_earnings, :real_earnings ]
-    #
-    #   <firm>
-    #     # ... normal attributes as shown above ...
-    #     <calculated-earnings>100000000000000000</calculated-earnings>
-    #     <real-earnings>5</real-earnings>
-    #   </firm>
-    #
-    # To call any additional Procs use <tt>:procs</tt>. The Procs are passed a
-    # modified version of the options hash that was given to +to_xml+:
-    #
-    #   proc = Proc.new { |options| options[:builder].tag!('abc', 'def') }
-    #   firm.to_xml :procs => [ proc ]
-    #
-    #   <firm>
-    #     # ... normal attributes as shown above ...
-    #     <abc>def</abc>
-    #   </firm>
-    #
-    # Alternatively, you can yield the builder object as part of the +to_xml+ call:
-    #
-    #   firm.to_xml do |xml|
-    #     xml.creator do
-    #       xml.first_name "David"
-    #       xml.last_name "Heinemeier Hansson"
-    #     end
-    #   end
-    #
-    #   <firm>
-    #     # ... normal attributes as shown above ...
-    #     <creator>
-    #       <first_name>David</first_name>
-    #       <last_name>Heinemeier Hansson</last_name>
-    #     </creator>
-    #   </firm>
-    #
-    # As noted above, you may override +to_xml+ in your DatastaxRails::Base
-    # subclasses to have complete control about what's generated. The general
-    # form of doing this is:
-    #
-    #   class IHaveMyOwnXML < DatastaxRails::Base
-    #     def to_xml(options = {})
-    #       options[:indent] ||= 2
-    #       xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
-    #       xml.instruct! unless options[:skip_instruct]
-    #       xml.level_one do
-    #         xml.tag!(:second_level, 'content')
-    #       end
-    #     end
-    #   end
+    # See the module level documentation for an example of +to_xml+.
     def to_xml(options = {}, &block)
       options[:methods] ||= []
       options[:methods] << :id
@@ -179,7 +180,8 @@ module DatastaxRails
     end
   end
 
-  class XmlSerializer < ActiveModel::Serializers::Xml::Serializer #:nodoc:
+  # Implementation of ActiveModel's XML Serializer
+  class XmlSerializer < ActiveModel::Serializers::Xml::Serializer
     def initialize(*args)
       super
     end
@@ -196,14 +198,14 @@ module DatastaxRails
       options[:procs] = procs
     end
 
-    # TODO This can likely be cleaned up to simple use ActiveSupport::XmlMini.to_tag as well.
+    # TODO: This can likely be cleaned up to simple use ActiveSupport::XmlMini.to_tag as well.
     def add_associations(association, records, opts)
       association_name = association.to_s.singularize
-      merged_options   = options.merge(opts).merge!(:root => association_name, :skip_instruct => true)
+      merged_options   = options.merge(opts).merge!(root: association_name, skip_instruct: true)
 
       if records.is_a?(Enumerable)
         tag  = ActiveSupport::XmlMini.rename_key(association.to_s, options)
-        type = options[:skip_types] ? { } : {:type => "array"}
+        type = options[:skip_types] ? {} : { type: 'array' }
 
         if records.empty?
           @builder.tag!(tag, type)
@@ -214,19 +216,20 @@ module DatastaxRails
                 record_type = {}
               else
                 record_class = (record.class.to_s.underscore == association_name) ? nil : record.class.name
-                record_type = {:type => record_class}
+                record_type = { type: record_class }
               end
 
               record.to_xml merged_options.merge(record_type)
             end
           end
         end
-      elsif record = @serializable.send(association)
+      elsif (record = @serializable.send(association))
         record.to_xml(merged_options)
       end
     end
 
-    class Attribute < ActiveModel::Serializers::Xml::Serializer::Attribute #:nodoc:
+    # Implementation of ActiveModel's XML Serializer Attribute
+    class Attribute < ActiveModel::Serializers::Xml::Serializer::Attribute
       def compute_type
         klass = @serializable.class
         type = if klass.serialized_attributes.key?(name.to_sym)
@@ -237,8 +240,8 @@ module DatastaxRails
                  NilClass
                end
 
-        { :text => :string,
-          :time => :datetime }[type] || type
+        { text: :string,
+          time: :datetime }[type] || type
       end
       protected :compute_type
     end