datastax_rails 2.0.12 → 2.0.15

data/lib/datastax_rails/cql/create_keyspace.rb

@@ -1,30 +1,30 @@
-module DatastaxRails#:nodoc:
+module DatastaxRails #:nodoc:
   module Cql #:nodoc:
     class CreateKeyspace < Base #:nodoc:
       def initialize(ks_name)
         @ks_name = ks_name
         @strategy_options = {}
       end
-      
+
       def strategy_class(sc)
         @strategy_class = sc
         self
       end
-      
+
       def strategy_options(so)
         @strategy_options.merge!(so)
         self
       end
-      
+
       def to_cql
         stmt = "CREATE KEYSPACE #{@ks_name} WITH REPLICATION = {'class' : '#{@strategy_class}'"
-        
+
         @strategy_options.each do |key, value|
-          stmt << ", '#{key.to_s}' : '#{value.to_s}'"
+          stmt << ", '#{key}' : '#{value}'"
         end
         stmt << '}'
         stmt
       end
     end
   end
-end
+end

data/lib/datastax_rails/cql/delete.rb

@@ -1,53 +1,40 @@
 module DatastaxRails
   module Cql
+    # Generates CQL to delete a record from Cassandra
     class Delete < Base
-      def initialize(klass, keys)
+      def initialize(klass, key)
         @klass = klass
-        @keys = keys
+        @key = key
         @timestamp = nil
         @columns = []
-        @conditions = {}
-        @key_name = @klass.primary_key
         super
       end
-      
+
       def columns(columns)
         @columns = columns
         self
       end
-      
-      def conditions(conditions)
-        @conditions.merge!(conditions)
-        self
-      end
-      
+
       def timestamp(timestamp)
         @timestamp = timestamp
         self
       end
-      
-      def key_name(key_name)
-        @key_name = key_name
-        self
-      end
-      
+
       def to_cql
-        @values = @keys
+        @values = []
         stmt = "DELETE #{@columns.join(',')} FROM #{@klass.column_family} "
-        
-        if(@timestamp)
-          stmt << "AND TIMESTAMP #{@timestamp} "
-        end
-        
-        stmt << "WHERE \"#{@key_name}\" IN (?)"
-        
-        @conditions.each do |col,val|
-          stmt << " AND #{col} = ?"
+        stmt << "AND TIMESTAMP #{@timestamp} " if @timestamp
+        conditions = []
+
+        @key.each do |col, val|
+          conditions << "\"#{col}\" = ?"
           @values << val
         end
-        
+
+        stmt << "WHERE #{conditions.join(' AND ')}"
+
         stmt
       end
     end
   end
-end
+end

data/lib/datastax_rails/cql/drop_column_family.rb

@@ -4,10 +4,10 @@ module DatastaxRails
       def initialize(cf_name)
         @cf_name = cf_name
       end
-      
+
       def to_cql
         "DROP COLUMNFAMILY #{@cf_name}"
       end
     end
   end
-end
+end

data/lib/datastax_rails/cql/drop_index.rb

@@ -4,10 +4,10 @@ module DatastaxRails
       def initialize(index_name)
         @index_name = index_name
       end
-      
+
       def to_cql
         "DROP INDEX #{@index_name}"
       end
     end
   end
-end
+end

data/lib/datastax_rails/cql/drop_keyspace.rb

@@ -4,10 +4,10 @@ module DatastaxRails
       def initialize(ks_name)
         @ks_name = ks_name
       end
-      
+
       def to_cql
         "DROP KEYSPACE #{@ks_name}"
       end
     end
   end
-end
+end

data/lib/datastax_rails/cql/insert.rb

@@ -8,40 +8,34 @@ module DatastaxRails
         @columns = {}
         super
       end
-      
+
       def columns(columns)
         @columns.merge!(columns)
         self
       end
-      
+
       def ttl(ttl)
         @ttl = ttl
         self
       end
-      
+
       def timestamp(timestamp)
         @timestamp = timestamp
         self
       end
-      
+
       def to_cql
         keys = []
-        @columns.each do |k,v|
+        @columns.each do |k, v|
           keys << k.to_s
           @values << v
         end
-        stmt = "INSERT INTO #{@klass.column_family} (#{keys.join(',')}) VALUES (#{('?'*keys.size).split(//).join(',')}) "
-        
-        if(@ttl)
-          stmt << "AND TTL #{@ttl} "
-        end
-        
-        if(@timestamp)
-          stmt << "AND TIMESTAMP #{@timestamp}"
-        end
-        
+        stmt =  "INSERT INTO #{@klass.column_family} (#{keys.join(',')}) "
+        stmt << "VALUES (#{('?' * keys.size).split(//).join(',')}) "
+        stmt << "AND TTL #{@ttl} " if @ttl
+        stmt << "AND TIMESTAMP #{@timestamp}" if @timestamp
         stmt.force_encoding('UTF-8')
       end
     end
   end
-end
+end

data/lib/datastax_rails/cql/select.rb

@@ -1,9 +1,9 @@
-module DatastaxRails#:nodoc:
+module DatastaxRails #:nodoc:
   module Cql #:nodoc:
     class Select < Base #:nodoc:
       def initialize(klass, select)
         @klass = klass
-        @select = select.join(",")
+        @select = select.join(',')
         @limit = nil
         @conditions = {}
         @order = nil
@@ -11,74 +11,62 @@ module DatastaxRails#:nodoc:
         @allow_filtering = nil
         super
       end
-      
+
       def allow_filtering
         @allow_filtering = true
         self
       end
-      
+
       def using(consistency)
         @consistency = consistency
         self
       end
-      
+
       def paginate(start)
         @paginate = start
         self
       end
-      
+
       def conditions(conditions)
         @conditions.merge!(conditions)
         self
       end
-      
+
       def limit(limit)
         @limit = limit
         self
       end
-      
+
       def order(order)
         @order = order
         self
       end
-      
+
       def to_cql
         conditions = []
         stmt = "SELECT #{@select} FROM #{@klass.column_family} "
-        
+
         if @paginate
           conditions << "token(#{@klass.primary_key}) > token(?)"
           @values << @paginate
         end
-        
-        @conditions.each do |k,v|
-          if v.kind_of?(Array)
-            conditions << "\"#{k.to_s}\" IN (#{('?'*v.size).split(//).join(',')})"
+
+        @conditions.each do |k, v|
+          if v.is_a?(Array)
+            conditions << "\"#{k}\" IN (#{('?' * v.size).split(//).join(',')})"
             @values += v
           else
-            conditions << "\"#{k.to_s}\" = ?"
+            conditions << "\"#{k}\" = ?"
             @values << v
           end
         end
-        
-        unless conditions.empty?
-          stmt << "WHERE #{conditions.join(" AND ")} "
-        end
-        
-        if @order
-          stmt << "ORDER BY #{@order} "
-        end
-        
-        if @limit
-          stmt << "LIMIT #{@limit} "
-        end
-        
-        if @allow_filtering
-          stmt << "ALLOW FILTERING "
-        end
-        
+
+        stmt << "WHERE #{conditions.join(' AND ')} " unless conditions.empty?
+        stmt << "ORDER BY #{@order} " if @order
+        stmt << "LIMIT #{@limit} " if @limit
+        stmt << 'ALLOW FILTERING ' if @allow_filtering
         stmt
       end
     end
   end
-end
+end

data/lib/datastax_rails/cql/truncate.rb

@@ -5,10 +5,10 @@ module DatastaxRails
         @klass = klass
         super
       end
-      
+
       def to_cql
         "TRUNCATE #{@klass.column_family}"
       end
     end
   end
-end
+end

data/lib/datastax_rails/cql/update.rb

@@ -7,58 +7,50 @@ module DatastaxRails
         @columns = {}
         super
       end
-      
+
       def columns(columns)
         @columns.merge!(columns)
         self
       end
-      
+
       def limit(limit)
         @limit = limit
         self
       end
-      
+
       def ttl(ttl)
         @ttl = ttl
         self
       end
-      
+
       def timestamp(timestamp)
         @timestamp = timestamp
         self
       end
-      
+
       def to_cql
-        column_names = @columns.keys
-        
         stmt = "update #{@klass.column_family} "
-        
-        if(@ttl)
-          stmt << "AND TTL #{@ttl} "
-        end
-        
-        if(@timestamp)
-          stmt << "AND TIMESTAMP #{@timestamp}"
-        end
-        
+        stmt << "AND TTL #{@ttl} " if @ttl
+        stmt << "AND TIMESTAMP #{@timestamp}" if @timestamp
+
         unless @columns.empty?
-          stmt << "SET "
+          stmt << 'SET '
           updates = []
-          @columns.each do |k,v|
+          @columns.each do |k, v|
             @values << v
             updates << "\"#{k}\" = ?"
           end
-          
-          stmt << updates.join(", ")
+
+          stmt << updates.join(', ')
         end
         conditions = []
-        @key.each do |k,v|
-          conditions << "\"#{k.to_s}\" = ?"
+        @key.each do |k, v|
+          conditions << "\"#{k}\" = ?"
           @values << v
         end
-        stmt << " WHERE #{conditions.join(" AND ")}"
+        stmt << " WHERE #{conditions.join(' AND ')}"
         stmt.force_encoding('UTF-8')
       end
     end
   end
-end
+end

data/lib/datastax_rails/cql/use_keyspace.rb

@@ -4,10 +4,10 @@ module DatastaxRails
       def initialize(ks_name)
         @ks_name = ks_name
       end
-      
+
       def to_cql
         "USE #{@ks_name}"
       end
     end
   end
-end
+end

data/lib/datastax_rails/cql.rb

@@ -7,7 +7,7 @@ module DatastaxRails
         @cql[klass] ||= DatastaxRails::Cql::ColumnFamily.new(klass)
       end
     end
-    
+
     autoload :AlterColumnFamily
     autoload :Base
     autoload :ColumnFamily
@@ -25,4 +25,4 @@ module DatastaxRails
     autoload :Update
     autoload :UseKeyspace
   end
-end
+end

data/lib/datastax_rails/dynamic_model.rb

@@ -31,7 +31,7 @@ module DatastaxRails
   # exception of timestamps, it is simply the first letter of the type
   # followed by an underscore (_). So s_ for strings. Timestamp has a
   # ts_ prefix to differentiate it from texts.
-  #   
+  #
   #   class Item < DatastaxRails::DynamicModel
   #     self.grouping = 'item'
   #     timestamps
@@ -77,75 +77,78 @@ module DatastaxRails
   # assist with search.
   class DynamicModel < WideStorageModel
     self.abstract_class = true
-    
-    PREFIXES = {string: :s_, text: :t_, boolean: :b_, date: :d_,
-                timestamp: :ts_, integer: :i_, float: :f_, uuid: :u_}.with_indifferent_access
-    
+
+    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 :virtual_attributes
-    
+
     class << self
       def grouping=(group)
         self.group_by_attribute = group
-        self.attribute_definitions['group'].default = group
-        default_scope -> {where('group' => group)}
+        attribute_definitions['group'].default = group
+        default_scope -> { where('group' => group) }
       end
-      
+
       alias_method :_attribute, :attribute
-      
+
       def attribute(name, options)
         options.symbolize_keys!
-        unless [:map,:list,:set].include?(options[:type].to_sym)
+        unless [: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.virtual_attributes[name.to_s] = PREFIXES[options[:type]].to_s + name.to_s
+          unless PREFIXES.key?(options[:type])
+            fail(ArgumentError, "Invalid type specified for dynamic attribute: '#{name}: #{options[:type]}'")
+          end
+          virtual_attributes[name.to_s] = PREFIXES[options[:type]].to_s + name.to_s
         end
         super
       end
-      
+
       def inherited(child)
         super
-        child.virtual_attributes = child.virtual_attributes.nil? ? {}.with_indifferent_access : child.virtual_attributes.dup
+        child.virtual_attributes =
+          child.virtual_attributes.nil? ? {}.with_indifferent_access : child.virtual_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 :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}
+          child.instance_eval { alias_attribute k.to_s.pluralize, v }
         end
       end
-      
+
       def solr_field_name(attr, type = nil)
-        type ||= self.attribute_definitions[attr].try(:type)
-        raise(UnknownAttributeError, "Collections cannot be mapped") if [:map,:list,:set].include?(type)
-        raise(UnknownAttributeError, "Unknown attribute: #{attr}. You must specify a type.") unless type
+        type ||= attribute_definitions[attr].try(:type)
+        fail(UnknownAttributeError, 'Collections cannot be mapped') if [:map, :list, :set].include?(type)
+        fail(UnknownAttributeError, "Unknown attribute: #{attr}. You must specify a type.") unless type
         PREFIXES[type].to_s + attr.to_s
       end
     end
-    
+
     def write_attribute(attr_name, val)
       if virtual_attributes.include?(attr_name.to_s)
         type = self.class.attribute_definitions[attr_name].type
-        self.send(PREFIXES[type])[attr_name] = val
+        send(PREFIXES[type])[attr_name] = val
       else
         super
       end
     end
-    
+
     def read_attribute(attr_name)
       if virtual_attributes.include?(attr_name.to_s)
         type = self.class.attribute_definitions[attr_name].type
-        self.send(PREFIXES[type])[attr_name]
+        send(PREFIXES[type])[attr_name]
       else
         super
       end
     end
-    
+
     def solr_field_name(attr, type = nil)
       self.class.solr_field_name(attr, type)
     end
   end
-end
+end