whi-cassie 1.1.0 → 1.3.0

data/lib/cassie/schema.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This class can be used to create, drop, or get information about the cassandra schemas. This class
 # is intended only to provide support for creating schemas in development and test environments. You
 # should not use this class with your production environment since some of the methods can be destructive.
@@ -8,39 +10,42 @@
 # definition files live. The files should be named "#{abstract_keyspace}.cql". The actual keyspace name will
 # be looked from the keyspace mapping in the configuration.
 class Cassie::Schema
-  TABLES_CQL = "SELECT columnfamily_name FROM system.schema_columnfamilies WHERE keyspace_name = ?".freeze
-  
+  TABLES_CQL = "SELECT table_name FROM system_schema.tables WHERE keyspace_name = ?"
+  VERSION_2_TABLES_CQL = "SELECT columnfamily_name FROM system.schema_columnfamilies WHERE keyspace_name = ?"
+
+  # rubocop:disable Lint/MixedRegexpCaptureTypes
   CREATE_MATCHER = /\A(?<create>CREATE (TABLE|((CUSTOM )?INDEX)|TYPE|TRIGGER))(?<exist>( IF NOT EXISTS)?) (?<object>[a-z0-9_.]+)/i.freeze
   DROP_MATCHER = /\A(?<drop>DROP (TABLE|INDEX|TYPE|TRIGGER))(?<exist>( IF EXISTS)?) (?<object>[a-z0-9_.]+)/i.freeze
-  
+  # rubocop:enable Lint/MixedRegexpCaptureTypes
+
   attr_reader :keyspace
-  
+
   class << self
     # Get all the defined schemas.
     def all
       schemas.values
     end
-    
+
     # Find the schema for a keyspace using the abstract name.
     def find(keyspace)
       schemas[keyspace]
     end
-    
+
     # Throw out the cached schemas so they can be reloaded from the configuration.
     def reset!
       @schemas = nil
     end
-    
+
     # Drop a specified keyspace by abstract name. The actual keyspace name will be looked up
     # from the keyspaces in the configuration.
     def drop!(keyspace_name)
       keyspace = Cassie.instance.config.keyspace(keyspace_name)
       raise ArgumentError.new("#{keyspace_name} is not defined as keyspace in the configuration") unless keyspace
-      
+
       drop_keyspace_cql = "DROP KEYSPACE IF EXISTS #{keyspace}"
       Cassie.instance.execute(drop_keyspace_cql)
     end
-    
+
     # Load a specified keyspace by abstract name. The actual keyspace name will be looked up
     # from the keyspaces in the configuration.
     def load!(keyspace_name)
@@ -49,24 +54,24 @@ class Cassie::Schema
 
       schema_file = File.join(Cassie.instance.config.schema_directory, "#{keyspace_name}.cql")
       raise ArgumentError.new("#{keyspace_name} schema file does not exist at #{schema_file}") unless File.exist?(schema_file)
-      schema_statements = File.read(schema_file).split(';').collect{|s| s.strip.chomp(';')}
-      
+      schema_statements = File.read(schema_file).split(";").collect { |s| s.strip.chomp(";") }
+
       create_keyspace_cql = "CREATE KEYSPACE IF NOT EXISTS #{keyspace} WITH replication = {'class': 'SimpleStrategy', 'replication_factor' : 1}"
       Cassie.instance.execute(create_keyspace_cql)
-      
+
       schema_statements.each do |statement|
-        statement = statement.gsub(/#(.*)$/, '').gsub(/\s+/, ' ').strip
+        statement = statement.gsub(/#(.*)$/, "").gsub(/\s+/, " ").strip
         create_match = statement.match(CREATE_MATCHER)
         if create_match
           object = create_match["object"]
-          object = "#{keyspace}.#{object}" unless object.include?('.')
-          statement = statement.sub(create_match.to_s, "#{create_match['create']} IF NOT EXISTS #{object}")
+          object = "#{keyspace}.#{object}" unless object.include?(".")
+          statement = statement.sub(create_match.to_s, "#{create_match["create"]} IF NOT EXISTS #{object}")
         else
           drop_match = statement.match(DROP_MATCHER)
           if drop_match
             object = drop_match["object"]
-            object = "#{keyspace}.#{object}" unless object.include?('.')
-            statement = statement.sub(drop_match.to_s, "#{drop_match['drop']} IF EXISTS #{object}")
+            object = "#{keyspace}.#{object}" unless object.include?(".")
+            statement = statement.sub(drop_match.to_s, "#{drop_match["drop"]} IF EXISTS #{object}")
           end
         end
         unless statement.blank?
@@ -75,23 +80,23 @@ class Cassie::Schema
       end
       nil
     end
-    
+
     # Drop all keyspaces defined in the configuration.
     def drop_all!
       Cassie.instance.config.keyspace_names.each do |keyspace|
         drop!(keyspace)
       end
     end
-    
+
     # Drop all keyspaces defined in the configuration.
     def load_all!
       Cassie.instance.config.keyspace_names.each do |keyspace|
         load!(keyspace)
       end
     end
-    
+
     private
-    
+
     def schemas
       unless defined?(@schemas) && @schemas
         schemas = {}
@@ -103,24 +108,26 @@ class Cassie::Schema
       @schemas
     end
   end
-  
+
   def initialize(keyspace)
     @keyspace = keyspace
   end
-  
+
   # Returns a list of tables defined for the schema.
   def tables
     unless defined?(@tables) && @tables
-      tables = []
-      results = Cassie.instance.execute(TABLES_CQL, keyspace)
-      results.each do |row|
-        tables << row['columnfamily_name']
+      results = nil
+      begin
+        results = Cassie.instance.execute(TABLES_CQL, keyspace)
+      rescue Cassandra::Errors::InvalidError
+        results = Cassie.instance.execute(VERSION_2_TABLES_CQL, keyspace)
       end
+      tables = results.collect { |row| row.values.first }
       @tables = tables
     end
     @tables
   end
-  
+
   # Truncate the data from a table.
   def truncate!(table)
     statement = Cassie.instance.prepare("TRUNCATE #{keyspace}.#{table}")

data/lib/cassie/subscribers.rb

@@ -1,12 +1,13 @@
+# frozen_string_literal: true
+
 # Thread safe list of subscribers. Each subscriber must respond to the :call method.
 class Cassie::Subscribers
-  
   def initialize(parent_subscribers = nil)
     @array = [].freeze
     @lock = Mutex.new
     @parent_subscribers = parent_subscribers
   end
-  
+
   def add(subscriber)
     @lock.synchronize do
       new_array = @array.dup
@@ -15,7 +16,7 @@ class Cassie::Subscribers
     end
   end
   alias_method :<<, :add
-  
+
   def remove(subscriber)
     removed = nil
     @lock.synchronize do
@@ -26,28 +27,25 @@ class Cassie::Subscribers
     removed
   end
   alias_method :delete, :remove
-  
+
   def clear
     @array = []
   end
-  
+
   def size
     @array.size + (@parent_subscribers ? @parent_subscribers.size : 0)
   end
-  
+
   def empty?
     size == 0
   end
-  
+
   def each(&block)
     @array.each(&block)
-    if @parent_subscribers
-      @parent_subscribers.each(&block)
-    end
+    @parent_subscribers&.each(&block)
   end
-  
+
   def include?(subscriber)
     @array.include?(subscriber)
   end
-  
 end

data/lib/cassie/testing.rb

@@ -1,11 +1,13 @@
+# frozen_string_literal: true
+
 # This class provides helper methods for testing.
 module Cassie::Testing
   extend ActiveSupport::Concern
-  
+
   included do
-    alias_method_chain :insert, :testing
+    prepend OverrideMethods
   end
-  
+
   class << self
     # Prepare the test environment. This method must be called before running the test suite.
     def prepare!
@@ -16,31 +18,31 @@ module Cassie::Testing
         end
       end
     end
-    
+
     # Wrap test cases as a block in this method. After the test case finishes, all tables
     # that had data inserted into them will be truncated so that the data state will be clean
     # for the next test case.
     def cleanup!
-      begin
-        yield
-      ensure
-        if Thread.current[:cassie_inserted].present?
-          Cassie.instance.batch do
-            Thread.current[:cassie_inserted].each do |table|
-              keyspace, table = table.split('.', 2)
-              schema = Cassie::Schema.find(keyspace)
-              schema.truncate!(table) if schema
-            end
+      yield
+    ensure
+      if Thread.current[:cassie_inserted].present?
+        Cassie.instance.batch do
+          Thread.current[:cassie_inserted].each do |table|
+            keyspace, table = table.split(".", 2)
+            schema = Cassie::Schema.find(keyspace)
+            schema&.truncate!(table)
           end
-          Thread.current[:cassie_inserted] = nil
         end
+        Thread.current[:cassie_inserted] = nil
       end
     end
   end
-  
-  def insert_with_testing(table, *args)
-    Thread.current[:cassie_inserted] ||= Set.new
-    Thread.current[:cassie_inserted] << table
-    insert_without_testing(table, *args)
+
+  module OverrideMethods
+    def insert(table, *args)
+      Thread.current[:cassie_inserted] ||= Set.new
+      Thread.current[:cassie_inserted] << table
+      super(table, *args)
+    end
   end
 end

data/lib/cassie.rb

@@ -1,4 +1,6 @@
-require 'cassandra'
+# frozen_string_literal: true
+
+require "cassandra"
 
 # This class provides a lightweight wrapper around the Cassandra driver. It provides
 # a foundation for maintaining a connection and constructing CQL statements.
@@ -9,35 +11,35 @@ class Cassie
   require File.expand_path("../cassie/schema.rb", __FILE__)
   require File.expand_path("../cassie/testing.rb", __FILE__)
   require File.expand_path("../cassie/railtie.rb", __FILE__) if defined?(Rails)
-  
+
   class RecordNotFound < StandardError
   end
-  
+
   class RecordInvalid < StandardError
     attr_reader :record
-    
+
     def initialize(record)
       super("Errors on #{record.class.name}: #{record.errors.to_hash.inspect}")
       @record = record
     end
   end
-  
+
   # Message passed to subscribers with the statement, options, and time for each statement
   # to execute. Note that if statements are batched they will be packed into one message
   # with a Cassandra::Statements::Batch statement and empty options.
   class Message
     attr_reader :statement, :options, :elapsed_time
-    
+
     def initialize(statement, options, elapsed_time)
       @statement = statement
       @options = options
       @elapsed_time = elapsed_time
     end
   end
-  
+
   attr_reader :config, :subscribers
   attr_accessor :consistency
-  
+
   class << self
     # A singleton instance that can be shared to communicate with a Cassandra cluster.
     def instance
@@ -47,7 +49,7 @@ class Cassie
       end
       @instance
     end
-    
+
     # Call this method to load the Cassie::Config from the specified file for the
     # specified environment.
     def configure!(options)
@@ -58,7 +60,7 @@ class Cassie
       end
       @config = Cassie::Config.new(options)
     end
-    
+
     # This method can be used to set a consistency level for all Cassandra queries
     # within a block that don't explicitly define them. It can be used where consistency
     # is important (i.e. on validation queries) but where a higher level method
@@ -72,18 +74,16 @@ class Cassie
         Thread.current[:cassie_consistency] = save_val
       end
     end
-    
+
     # Get a Logger compatible object if it has been set.
     def logger
       @logger if defined?(@logger)
     end
-    
+
     # Set a logger with a Logger compatible object.
-    def logger=(value)
-      @logger = value
-    end
+    attr_writer :logger
   end
-  
+
   def initialize(config)
     @config = config
     @monitor = Monitor.new
@@ -93,14 +93,14 @@ class Cassie
     @subscribers = Subscribers.new
     @consistency = ((config.cluster || {})[:consistency] || :local_one)
   end
-  
+
   # Open a connection to the Cassandra cluster.
   def connect
     start_time = Time.now
     cluster_config = config.cluster
-    cluster_config = cluster_config.merge(:logger => logger) if logger
+    cluster_config = cluster_config.merge(logger: logger) if logger
     cluster = Cassandra.cluster(cluster_config)
-    logger.info("Cassie.connect with #{config.sanitized_cluster} in #{((Time.now - start_time) * 1000).round}ms") if logger
+    logger&.info("Cassie.connect with #{config.sanitized_cluster} in #{((Time.now - start_time) * 1000).round}ms")
     @monitor.synchronize do
       @session = cluster.connect(config.default_keyspace)
       @prepared_statements = {}
@@ -109,19 +109,19 @@ class Cassie
 
   # Close the connections to the Cassandra cluster.
   def disconnect
-    logger.info("Cassie.disconnect from #{config.sanitized_cluster}") if logger
+    logger&.info("Cassie.disconnect from #{config.sanitized_cluster}")
     @monitor.synchronize do
-      @session.close if @session
+      @session&.close
       @session = nil
       @prepared_statements = {}
     end
   end
-  
+
   # Return true if the connection to the Cassandra cluster has been established.
   def connected?
     !!@session
   end
-  
+
   # Force reconnection. If you're using this code in conjunction in a forking server environment
   # like passenger or unicorn you should call this method after forking.
   def reconnect
@@ -150,13 +150,13 @@ class Cassie
         end
       end
     end
-    
+
     if cache_filled_up && logger && Time.now > @last_prepare_warning + 10
       # Set a throttle on how often this message is logged so we don't kill performance enven more.
       @last_prepare_warning = Time.now
       logger.warn("Cassie.prepare cache filled up. Consider increasing the size from #{config.max_prepared_statements}.")
     end
-    
+
     statement
   end
 
@@ -210,22 +210,22 @@ class Cassie
     columns = []
     values = []
     values_hash.each do |column, value|
-      if !value.nil?
+      unless value.nil?
         columns << column
         values << value
       end
     end
-    cql = "INSERT INTO #{table} (#{columns.join(', ')}) VALUES (#{question_marks(columns.size)})"
-    
-    if options && options.include?(:ttl)
+    cql = "INSERT INTO #{table} (#{columns.join(", ")}) VALUES (#{question_marks(columns.size)})"
+
+    if options&.include?(:ttl)
       options = options.dup
       ttl = options.delete(:ttl)
       if ttl
-        cql << " USING TTL ?"
+        cql += " USING TTL ?"
         values << Integer(ttl)
       end
     end
-    
+
     batch_or_execute(cql, values, options)
   end
 
@@ -248,20 +248,20 @@ class Cassie
       end
     end
     values = update_values + key_values
-    
+
     cql = "UPDATE #{table}"
-    
-    if options && options.include?(:ttl)
+
+    if options&.include?(:ttl)
       options = options.dup
       ttl = options.delete(:ttl)
       if ttl
-        cql << " USING TTL ?"
+        cql += " USING TTL ?"
         values.unshift(Integer(ttl))
       end
     end
 
-    cql << " SET #{update_cql.join(', ')} WHERE #{key_cql}"
-    
+    cql += " SET #{update_cql.join(", ")} WHERE #{key_cql}"
+
     batch_or_execute(cql, values, options)
   end
 
@@ -281,31 +281,31 @@ class Cassie
     start_time = Time.now
     begin
       statement = nil
-      if cql.is_a?(String)
+      statement = if cql.is_a?(String)
         if values.present?
-          statement = prepare(cql)
+          prepare(cql)
         else
-          statement = Cassandra::Statements::Simple.new(cql)
+          Cassandra::Statements::Simple.new(cql)
         end
       else
-        statement = cql
+        cql
       end
-    
+
       if values.present?
         values = Array(values)
-        options = (options ? options.merge(:arguments => values) : {:arguments => values})
+        options = (options ? options.merge(arguments: values) : {arguments: values})
       end
-    
+
       # Set a default consistency from a block context if it isn't explicitly set.
       statement_consistency = current_consistency
       if statement_consistency
         if options
-          options = options.merge(:consistency => statement_consistency) if options[:consistency].nil?
+          options = options.merge(consistency: statement_consistency) if options[:consistency].nil?
         else
-          options = {:consistency => statement_consistency}
+          options = {consistency: statement_consistency}
         end
       end
-      
+
       session.execute(statement, options || {})
     rescue Cassandra::Errors::IOError => e
       disconnect
@@ -313,18 +313,18 @@ class Cassie
     ensure
       if statement.is_a?(Cassandra::Statement) && !subscribers.empty?
         payload = Message.new(statement, options, Time.now - start_time)
-        subscribers.each{|subscriber| subscriber.call(payload)}
+        subscribers.each { |subscriber| subscriber.call(payload) }
       end
     end
   end
-  
+
   # Return the current consistency level that has been set for statements.
   def current_consistency
     Thread.current[:cassie_consistency] || consistency
   end
 
   private
-  
+
   def logger
     self.class.logger
   end
@@ -333,7 +333,7 @@ class Cassie
     connect unless connected?
     @session
   end
-  
+
   def batch_or_execute(cql, values, options = nil)
     batch = Thread.current[:cassie_batch]
     if batch
@@ -345,9 +345,7 @@ class Cassie
   end
 
   def question_marks(size)
-    q = '?'
-    (size - 1).times{ q << ',?' }
-    q
+    "?#{",?" * (size - 1)}"
   end
 
   def key_clause(key_hash)
@@ -357,9 +355,9 @@ class Cassie
       cql << "#{key} = ?"
       values << value
     end
-    [cql.join(' AND '), values]
+    [cql.join(" AND "), values]
   end
-  
+
   # Extract the CQL from a statement
   def statement_cql(statement, previous = nil)
     cql = nil
@@ -368,7 +366,7 @@ class Cassie
     elsif statement.respond_to?(:statements) && (previous.nil? || !previous.include?(statement))
       previous ||= []
       previous << statement
-      cql = statement.statements.collect{|s| statement_cql(s, previous)}.join('; ')
+      cql = statement.statements.collect { |s| statement_cql(s, previous) }.join("; ")
     end
     cql
   end

data/lib/whi-cassie.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require File.expand_path("../cassie.rb", __FILE__)

data/spec/cassie/config_spec.rb

@@ -1,7 +1,6 @@
 require "spec_helper"
 
 describe Cassie::Config do
-  
   let(:options) do
     {
       "cluster" => {
@@ -14,43 +13,42 @@ describe Cassie::Config do
       "default_keyspace" => "another"
     }
   end
-  
+
   it "should handle empty options" do
     config = Cassie::Config.new({})
-    config.cluster.should == {}
-    config.keyspace_names.should == []
-    config.default_keyspace.should == nil
-    config.schema_directory.should == nil
-    config.max_prepared_statements.should == 1000
+    expect(config.cluster).to eq({})
+    expect(config.keyspace_names).to eq([])
+    expect(config.default_keyspace).to eq(nil)
+    expect(config.schema_directory).to eq(nil)
+    expect(config.max_prepared_statements).to eq(1000)
   end
-  
+
   it "should have cluster options" do
     config = Cassie::Config.new(options)
-    config.cluster.should == {:consistency => :one, :timeout => 15}
+    expect(config.cluster).to eq({consistency: :one, timeout: 15})
   end
-  
+
   it "should have keyspaces" do
     config = Cassie::Config.new(options)
-    config.keyspace(:default).should start_with("test_default")
-    config.keyspace("other").should start_with("test_other")
-    config.keyspace_names.should =~ ["default", "other"]
+    expect(config.keyspace(:default)).to start_with("test_default")
+    expect(config.keyspace("other")).to start_with("test_other")
+    expect(config.keyspace_names).to match_array(["default", "other"])
   end
-  
+
   it "should have a default_keyspace" do
     config = Cassie::Config.new(options)
-    config.default_keyspace.should == "another"
+    expect(config.default_keyspace).to eq("another")
   end
-  
+
   it "should get the schema_directory" do
     config = Cassie::Config.new(options)
-    config.schema_directory.should == "/tmp"
-    Cassie::Config.new({}).schema_directory.should == nil
+    expect(config.schema_directory).to eq("/tmp")
+    expect(Cassie::Config.new({}).schema_directory).to eq(nil)
   end
-  
+
   it "should get the max_prepared_statements" do
     config = Cassie::Config.new(options)
-    config.max_prepared_statements.should == 100
-    Cassie::Config.new({}).max_prepared_statements.should == 1000
+    expect(config.max_prepared_statements).to eq(100)
+    expect(Cassie::Config.new({}).max_prepared_statements).to eq(1000)
   end
-  
 end