whi-cassie 1.1.0 → 1.3.0

data/lib/cassie/model.rb

@@ -1,5 +1,7 @@
-require 'active_model'
-require 'active_support/hash_with_indifferent_access'
+# frozen_string_literal: true
+
+require "active_model"
+require "active_support/hash_with_indifferent_access"
 
 # This module provides a simple interface for models backed by Cassandra tables.
 #
@@ -15,19 +17,19 @@ require 'active_support/hash_with_indifferent_access'
 #
 #   class Thing
 #     include Cassie::Model
-#   
+#
 #     self.table_name = "things"
 #     self.keyspace = "test"
 #     self.primary_key = [:owner, :id]
-#   
+#
 #     column :owner, :int
 #     column :id, :int, :as => :identifier
 #     column :val, :varchar, :as => :value
-#   
+#
 #     ordering_key :id, :desc
-#   
+#
 #     validates_presence_of :id, :value
-#   
+#
 #     before_save do
 #       ...
 #     end
@@ -38,17 +40,17 @@ module Cassie::Model
   include ActiveModel::Validations
   include ActiveModel::Validations::Callbacks
   extend ActiveModel::Callbacks
-    
+
   included do |base|
-    class_attribute :table_name, :instance_reader => false, :instance_writer => false
-    class_attribute :_keyspace, :instance_reader => false, :instance_writer => false
-    class_attribute :_primary_key, :instance_reader => false, :instance_writer => false
-    class_attribute :_columns, :instance_reader => false, :instance_writer => false
-    class_attribute :_column_aliases, :instance_reader => false, :instance_writer => false
-    class_attribute :_ordering_keys, :instance_reader => false, :instance_writer => false
-    class_attribute :_counter_table, :instance_reader => false, :instance_writer => false
-    class_attribute :find_subscribers, :instance_reader => false, :instance_writer => false
-    class_attribute :read_consistency, :instance_reader => false, :instance_writer => false
+    class_attribute :table_name, instance_reader: false, instance_writer: false
+    class_attribute :_keyspace, instance_reader: false, instance_writer: false
+    class_attribute :_primary_key, instance_reader: false, instance_writer: false
+    class_attribute :_columns, instance_reader: false, instance_writer: false
+    class_attribute :_column_aliases, instance_reader: false, instance_writer: false
+    class_attribute :_ordering_keys, instance_reader: false, instance_writer: false
+    class_attribute :_counter_table, instance_reader: false, instance_writer: false
+    class_attribute :find_subscribers, instance_reader: false, instance_writer: false
+    class_attribute :read_consistency, instance_reader: false, instance_writer: false
     class_attribute :write_consistency
     define_model_callbacks :create, :update, :save, :destroy
     self._columns = {}
@@ -56,19 +58,19 @@ module Cassie::Model
     self._ordering_keys = {}
     self.find_subscribers = Cassie::Subscribers.new(Cassie::Model.find_subscribers)
   end
-  
+
   class << self
     @@find_subscribers = Cassie::Subscribers.new
-    
+
     def find_subscribers
       @@find_subscribers
     end
   end
-  
+
   # Message sent to find subscribers for instrumenting find operations.
   class FindMessage
     attr_reader :cql, :args, :options, :elapsed_time, :rows
-    
+
     def initialize(cql, args, options, elapsed_time, rows)
       @cql = cql
       @args = args
@@ -77,8 +79,8 @@ module Cassie::Model
       @rows = rows
     end
   end
-  
-  module ClassMethods    
+
+  module ClassMethods
     # Define a column name and type from the table. Columns must be defined in order
     # to be used. This method will handle defining the getter and setter methods as well.
     #
@@ -108,49 +110,49 @@ module Cassie::Model
       rescue NameError
         raise ArgumentError.new("#{type.inspect} is not an allowed Cassandra type")
       end
-      
+
       self._columns = _columns.merge(name => type_class)
-      self._column_aliases = self._column_aliases.merge(name => name)
+      self._column_aliases = _column_aliases.merge(name => name)
 
       aliased = (as && as.to_s != name.to_s)
       if aliased
-        self._column_aliases = self._column_aliases.merge(as => name)
+        self._column_aliases = _column_aliases.merge(as => name)
       end
 
-      if type.to_s == "counter".freeze
+      if type.to_s == "counter"
         self._counter_table = true
-        
-        define_method(name){ instance_variable_get(:"@#{name}") || 0 }
-        define_method("#{name}="){ |value| instance_variable_set(:"@#{name}", value.to_i) }
-        
-        define_method("increment_#{name}!"){ |amount=1, ttl: nil| send(:adjust_counter!, name, amount, ttl: ttl) }
-        define_method("decrement_#{name}!"){ |amount=1, ttl: nil| send(:adjust_counter!, name, -amount, ttl: ttl) }
+
+        define_method(name) { instance_variable_get(:"@#{name}") || 0 }
+        define_method("#{name}=") { |value| instance_variable_set(:"@#{name}", value.to_i) }
+
+        define_method("increment_#{name}!") { |amount = 1, ttl: nil| send(:adjust_counter!, name, amount, ttl: ttl) }
+        define_method("decrement_#{name}!") { |amount = 1, ttl: nil| send(:adjust_counter!, name, -amount, ttl: ttl) }
         if aliased
-          define_method(as){ send(name) }
-          define_method("increment_#{as}!"){ |amount=1, ttl: nil| send("increment_#{name}!", amount, ttl: ttl) }
-          define_method("decrement_#{as}!"){ |amount=1, ttl: nil| send("increment_#{name}!", amount, ttl: ttl) }
+          define_method(as) { send(name) }
+          define_method("increment_#{as}!") { |amount = 1, ttl: nil| send("increment_#{name}!", amount, ttl: ttl) }
+          define_method("decrement_#{as}!") { |amount = 1, ttl: nil| send("increment_#{name}!", amount, ttl: ttl) }
         end
       else
         attr_reader name
-        define_method("#{name}="){ |value| instance_variable_set(:"@#{name}", self.class.send(:coerce, value, type_class)) }
+        define_method("#{name}=") { |value| instance_variable_set(:"@#{name}", self.class.send(:coerce, value, type_class)) }
         attr_reader name
         if aliased
-          define_method(as){ send(name) }
-          define_method("#{as}="){|value| send("#{name}=", value) }
+          define_method(as) { send(name) }
+          define_method("#{as}=") { |value| send("#{name}=", value) }
         end
       end
     end
-    
+
     # Returns an array of the defined column names as symbols.
     def column_names
       _columns.keys
     end
-    
+
     # Returns the internal column name after resolving any aliases.
     def column_name(name_or_alias)
-      name = _column_aliases[name_or_alias] || name_or_alias
+      _column_aliases[name_or_alias] || name_or_alias
     end
-    
+
     # Set the primary key for the table. The value should be set as an array with the
     # clustering key first.
     def primary_key=(value)
@@ -162,31 +164,31 @@ module Cassie::Model
         end
       }.flatten
     end
-    
+
     # Return an array of column names for the table primary key.
     def primary_key
       _primary_key
     end
-    
+
     # Define and ordering key for the table. The order attribute should be either :asc or :desc
     def ordering_key(name, order)
       order = order.to_sym
       raise ArgumentError.new("order must be either :asc or :desc") unless order == :asc || order == :desc
       _ordering_keys[name.to_sym] = order
     end
-  
+
     # Set the keyspace for the table. The name should be an abstract keyspace name
     # that is mapped to an actual keyspace name in the configuration. If the name
     # provided is not mapped in the configuration, then the raw value will be used.
     def keyspace=(name)
       self._keyspace = name.to_s
     end
-    
+
     # Return the keyspace name where the table is located.
     def keyspace
       connection.config.keyspace(_keyspace)
     end
-    
+
     # Return the full table name including the keyspace.
     def full_table_name
       if _keyspace
@@ -195,7 +197,7 @@ module Cassie::Model
         table_name
       end
     end
-  
+
     # Find all records.
     #
     # The +where+ argument can be a Hash, Array, or String WHERE clause to
@@ -215,27 +217,27 @@ module Cassie::Model
     # record as it is foundto the block instead of returning them.
     def find_all(where:, select: nil, order: nil, limit: nil, options: nil)
       start_time = Time.now
-      columns = (select ? Array(select).collect{|c| column_name(c)} : column_names)
-      cql = "SELECT #{columns.join(', ')} FROM #{full_table_name}"
+      columns = (select ? Array(select).collect { |c| column_name(c) } : column_names)
+      cql = "SELECT #{columns.join(", ")} FROM #{full_table_name}"
       values = nil
-    
+
       raise ArgumentError.new("Where clause cannot be blank. Pass :all to find all records.") if where.blank?
       if where && where != :all
         where_clause, values = cql_where_clause(where)
       else
         values = []
       end
-      cql << " WHERE #{where_clause}" if where_clause
-    
+      cql += " WHERE #{where_clause}" if where_clause
+
       if order
-        cql << " ORDER BY #{order}"
+        cql += " ORDER BY #{order}"
       end
-    
+
       if limit
-        cql << " LIMIT ?"
+        cql += " LIMIT ?"
         values << Integer(limit)
       end
-    
+
       results = connection.find(cql, values, consistency_options(read_consistency, options))
       records = [] unless block_given?
       row_count = 0
@@ -253,15 +255,15 @@ module Cassie::Model
         break if results.last_page?
         results = results.next_page
       end
-      
+
       if find_subscribers && !find_subscribers.empty?
         payload = FindMessage.new(cql, values, options, Time.now - start_time, row_count)
-        find_subscribers.each{|subscriber| subscriber.call(payload)}
+        find_subscribers.each { |subscriber| subscriber.call(payload) }
       end
-      
+
       records
     end
-    
+
     # Find a single record that matches the +where+ argument.
     def find(where)
       options = nil
@@ -271,7 +273,7 @@ module Cassie::Model
       end
       find_all(where: where, limit: 1, options: options).first
     end
-    
+
     # Find a single record that matches the +where+ argument or raise an
     # ActiveRecord::RecordNotFound error if none is found.
     def find!(where)
@@ -279,7 +281,7 @@ module Cassie::Model
       raise Cassie::RecordNotFound unless record
       record
     end
-  
+
     # Return the count of rows in the table. If the +where+ argument is specified
     # then it will be added as the WHERE clause.
     def count(where = nil)
@@ -288,21 +290,21 @@ module Cassie::Model
         where = where.dup
         options = where.delete(:options)
       end
-      
-      cql = "SELECT COUNT(*) FROM #{self.full_table_name}"
+
+      cql = "SELECT COUNT(*) FROM #{full_table_name}"
       values = nil
-    
+
       if where
         where_clause, values = cql_where_clause(where)
-        cql << " WHERE #{where_clause}"
+        cql += " WHERE #{where_clause}"
       else
-        where = connection.prepare(cql)
+        connection.prepare(cql)
       end
-      
+
       results = connection.find(cql, values, consistency_options(read_consistency, options))
       results.rows.first["count"]
     end
-    
+
     # Returns a newly created record. If the record is not valid then it won't be
     # persisted.
     def create(attributes)
@@ -310,7 +312,7 @@ module Cassie::Model
       record.save
       record
     end
-    
+
     # Returns a newly created record or raises an ActiveRecord::RecordInvalid error
     # if the record is not valid.
     def create!(attributes)
@@ -318,7 +320,7 @@ module Cassie::Model
       record.save!
       record
     end
-    
+
     # Delete all rows from the table that match the key hash. This method bypasses
     # any destroy callbacks defined on the model.
     def delete_all(key_hash)
@@ -326,9 +328,9 @@ module Cassie::Model
       key_hash.each do |name, value|
         cleanup_up_hash[column_name(name)] = value
       end
-      connection.delete(full_table_name, cleanup_up_hash, :consistency => write_consistency)
+      connection.delete(full_table_name, cleanup_up_hash, consistency: write_consistency)
     end
-    
+
     # All insert, update, and delete calls within the block will be sent as a single
     # batch to Cassandra. The consistency level will default to the write consistency
     # level if it's been set.
@@ -338,12 +340,12 @@ module Cassie::Model
         yield
       end
     end
-    
+
     # Returns the Cassie instance used to communicate with Cassandra.
     def connection
       Cassie.instance
     end
-  
+
     # Since Cassandra doesn't support offset we need to find the order key of record
     # at the specified the offset.
     #
@@ -360,7 +362,7 @@ module Cassie::Model
       cluster_order = _ordering_keys[ordering_key] || :asc
       order ||= cluster_order
       order_cql = "#{ordering_key} #{order}" unless order == cluster_order
-      
+
       from = (order == :desc ? max : min)
       to = (order == :desc ? min : max)
       loop do
@@ -368,11 +370,11 @@ module Cassie::Model
         conditions_cql = []
         conditions = []
         if from
-          conditions_cql << "#{ordering_key} #{order == :desc ? '<' : '>'} ?"
+          conditions_cql << "#{ordering_key} #{order == :desc ? "<" : ">"} ?"
           conditions << from
         end
         if to
-          conditions_cql << "#{ordering_key} #{order == :desc ? '>' : '<'} ?"
+          conditions_cql << "#{ordering_key} #{order == :desc ? ">" : "<"} ?"
           conditions << to
         end
         key.each do |name, value|
@@ -381,10 +383,10 @@ module Cassie::Model
         end
         conditions.unshift(conditions_cql.join(" AND "))
 
-        results = find_all(:select => [ordering_key], :where => conditions, :limit => limit, :order => order_cql)
+        results = find_all(select: [ordering_key], where: conditions, limit: limit, order: order_cql)
         last_row = results.last if results.size == limit
         last_id = last_row.send(ordering_key) if last_row
-      
+
         if last_id.nil?
           return nil
         elsif limit >= offset
@@ -395,9 +397,9 @@ module Cassie::Model
         end
       end
     end
-  
+
     private
-  
+
     # Turn a hash of column value, array of [cql, value] or a CQL string into
     # a CQL where clause. Returns the values pulled out in an array for making
     # a prepared statement.
@@ -409,8 +411,7 @@ module Cassie::Model
         where.each do |column, value|
           col_name = column_name(column)
           if value.is_a?(Array)
-            q = '?'
-            (value.size - 1).times{ q << ',?' }
+            q = "?#{",?" * (value.size - 1)}"
             cql << "#{col_name} IN (#{q})"
             values.concat(value)
           else
@@ -418,7 +419,7 @@ module Cassie::Model
             values << coerce(value, _columns[col_name])
           end
         end
-        [cql.join(' AND '), values]
+        [cql.join(" AND "), values]
       when Array
         [where.first, where[1, where.size]]
       when String
@@ -427,7 +428,7 @@ module Cassie::Model
         raise ArgumentError.new("invalid CQL where clause #{where}")
       end
     end
-    
+
     # Force a value to be the correct Cassandra data type.
     def coerce(value, type_class)
       if value.nil?
@@ -450,41 +451,41 @@ module Cassie::Model
       elsif type_class == Cassandra::Types::Set
         Set.new(value)
       elsif type_class == Cassandra::Types::Map
-        Hash[value]
+        value.to_h
       else
         type_class.new(value)
       end
     end
-    
+
     def consistency_options(consistency, options)
       if consistency
         if options
-          options = options.merge(:consistency => consistency) if options[:consistency].nil?
+          options = options.merge(consistency: consistency) if options[:consistency].nil?
           options
         else
-          {:consistency => consistency}
+          {consistency: consistency}
         end
       else
         options
       end
     end
   end
-  
+
   def initialize(attributes = {})
     super
     @persisted = false
   end
-  
+
   # Return true if the record has been persisted to Cassandra.
   def persisted?
     @persisted
   end
-  
+
   # Return true if the table is used for a counter.
   def counter_table?
     !!self.class._counter_table
   end
-  
+
   # Save a record. Returns true if the record was persisted and false if it was invalid.
   # This method will run the save callbacks as well as either the update or create
   # callbacks as necessary.
@@ -493,7 +494,7 @@ module Cassie::Model
     valid_record = (validate ? valid? : true)
     if valid_record
       run_callbacks(:save) do
-        options = {:consistency => write_consistency, :ttl => (ttl || persistence_ttl)}
+        options = {consistency: write_consistency, ttl: (ttl || persistence_ttl)}
         if persisted?
           run_callbacks(:update) do
             self.class.connection.update(self.class.full_table_name, values_hash, key_hash, options)
@@ -510,7 +511,7 @@ module Cassie::Model
       false
     end
   end
-  
+
   # Save a record. Returns true if the record was saved and raises an ActiveRecord::RecordInvalid
   # error if the record is invalid.
   def save!(ttl: nil)
@@ -520,16 +521,28 @@ module Cassie::Model
       raise Cassie::RecordInvalid.new(self)
     end
   end
-  
+
   # Delete a record and call the destroy callbacks.
   def destroy
     run_callbacks(:destroy) do
-      self.class.connection.delete(self.class.full_table_name, key_hash, :consistency => write_consistency)
+      self.class.connection.delete(self.class.full_table_name, key_hash, consistency: write_consistency)
       @persisted = false
       true
     end
   end
-  
+
+  # Update a record with the specified attributes. Returns false the record is invalid.
+  def update(values)
+    self.attributes = values
+    save
+  end
+
+  # Update a record with the specified attributes and raise an error if it is invalid.
+  def update!(values)
+    self.attributes = values
+    save!
+  end
+
   # Returns a hash of column to values. Column names will be symbols.
   def attributes
     hash = {}
@@ -538,38 +551,57 @@ module Cassie::Model
     end
     hash
   end
-  
+
+  # Mass set attributes from a hash.
+  def attributes=(values)
+    values.each do |name, value|
+      send("#{name}=", value)
+    end
+  end
+
+  # Returns a hash representing the primary key value.
+  def primary_key
+    self.class.primary_key.each_with_object({}) { |name, hash|
+      hash[name] = send(name)
+    }
+  end
+
+  # Reloads the record in memory.
+  def reload
+    self.class.find(primary_key)
+  end
+
   # Subclasses can override this method to provide a TTL on the persisted record.
   def persistence_ttl
     nil
   end
-  
+
   def eql?(other)
     other.is_a?(self.class) && other.key_hash == key_hash
   end
-  
+
   def ==(other)
     eql?(other)
   end
-  
+
   # Returns the primary key as a hash
   def key_hash
     hash = {}
     self.class.primary_key.each do |key|
-      hash[key] = self.send(key)
+      hash[key] = send(key)
     end
     hash
   end
-  
+
   private
-  
+
   # Used for updating counter columns.
   def adjust_counter!(name, amount, ttl: nil)
     amount = amount.to_i
     if amount != 0
       run_callbacks(:update) do
         adjustment = (amount < 0 ? "#{name} = #{name} - #{amount.abs}" : "#{name} = #{name} + #{amount}")
-        options = {:consistency => write_consistency, :ttl => (ttl || persistence_ttl)}
+        options = {consistency: write_consistency, ttl: (ttl || persistence_ttl)}
         self.class.connection.update(self.class.full_table_name, adjustment, key_hash, options)
       end
     end
@@ -577,13 +609,13 @@ module Cassie::Model
     value = (record ? record.send(name) : send(name) + amount)
     send("#{name}=", value)
   end
-  
+
   # Returns a hash of value except for the ones that constitute the primary key
   def values_hash
     pk = self.class.primary_key
     hash = {}
     self.class.column_names.each do |name|
-      hash[name] = send(name) unless pk.include?(name) 
+      hash[name] = send(name) unless pk.include?(name)
     end
     hash
   end

data/lib/cassie/railtie.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Initialize Cassie instance with default behaviors for a Rails environment.
 #
 # Configuration will be gotten from config/cassie.yml.
@@ -6,13 +8,13 @@
 class Cassie::Railtie < Rails::Railtie
   initializer "cassie.initialization" do
     Cassie.logger = Rails.logger
-    
-    config_file = Rails.root + 'config' + 'cassie.yml'
+
+    config_file = Rails.root + "config" + "cassie.yml"
     if config_file.exist?
-      options = YAML::load(ERB.new(config_file.read).result)[Rails.env]
+      options = YAML.load(ERB.new(config_file.read).result)[Rails.env] # rubocop:disable Security/YAMLLoad
       if Rails.env.development? || Rails.env.test?
-        schema_dir = Rails.root + 'db' + 'cassandra'
-        options['schema_directory'] = schema_dir.to_s if schema_dir.exist?
+        schema_dir = Rails.root + "db" + "cassandra"
+        options["schema_directory"] = schema_dir.to_s if schema_dir.exist?
       end
       Cassie.configure!(options)
     end