datastax_rails 2.0.12 → 2.0.15

data/lib/datastax_rails/rsolr_client_wrapper.rb

@@ -3,11 +3,11 @@ module DatastaxRails
   # a new server tried (if one is available)
   class RSolrClientWrapper < BlankSlate
     # @param [RSolr::Client] rsolr the initial RSolr client object to wrap
-    def initialize(rsolr,model)
+    def initialize(rsolr, model)
       @rsolr = rsolr
       @model = model
     end
-    
+
     def method_missing(sym, *args, &block)
       if @rsolr.uri.host != DatastaxRails::Base.current_server
         @rsolr.uri.host = DatastaxRails::Base.current_server
@@ -26,4 +26,4 @@ module DatastaxRails
       end
     end
   end
-end
+end

data/lib/datastax_rails/schema/cassandra.rb

@@ -1,8 +1,9 @@
+# rubocop:disable Style/LineLength
 module DatastaxRails
   module Schema
     module Cassandra
       # Check for missing columns or columns needing cassandra indexes
-      def check_missing_schema(model)
+      def check_missing_schema(model) # rubocop:disable MethodLength
         count = 0
         model.attribute_definitions.each do |attribute, definition|
           unless column_exists?(model.column_family.to_s, attribute.to_s)
@@ -10,26 +11,26 @@ module DatastaxRails
             say "Adding column '#{attribute}'", :subitem
             DatastaxRails::Cql::AlterColumnFamily.new(model.column_family).add(attribute => definition.cql_type).execute
           end
-          if(definition.options[:cql_index] && !definition.options[:solr_index])
+          if definition.options[:cql_index] && !definition.options[:solr_index]
             unless index_exists?(model.column_family.to_s, attribute.to_s)
               if index_exists?(model.column_family.to_s, attribute.to_s)
                 count += 1
-                say "Dropping solr index on #{attribute.to_s}", :subitem
+                say "Dropping solr index on #{attribute}", :subitem
                 DatastaxRails::Cql::DropIndex.new(solr_index_cql_name(model.column_family.to_s, attribute.to_s)).execute
               end
               count += 1
-              say "Creating cassandra index on #{attribute.to_s}", :subitem
+              say "Creating cassandra index on #{attribute}", :subitem
               DatastaxRails::Cql::CreateIndex.new(cassandra_index_cql_name(model.column_family.to_s, attribute.to_s)).on(model.column_family.to_s).column(attribute.to_s).execute
             end
-          elsif(definition.options[:cql_index])
-            unless column_exists?(model.column_family.to_s, "__#{attribute.to_s}")
+          elsif definition.options[:cql_index]
+            unless column_exists?(model.column_family.to_s, "__#{attribute}")
               # Create and populate the new column
               count += 1
               say "Adding column '__#{attribute}'", :subitem
-              DatastaxRails::Cql::AlterColumnFamily.new(model.column_family).add("__#{attribute.to_s}" => definition.cql_type).execute
+              DatastaxRails::Cql::AlterColumnFamily.new(model.column_family).add("__#{attribute}" => definition.cql_type).execute
               say "Populating column '__#{attribute}' (this might take a while)", :subitem
-              export = "echo \"copy #{model.column_family.to_s} (key, #{attribute.to_s}) TO 'dsr_export.csv';\" | cqlsh #{model.current_server}"
-              import = "echo \"copy #{model.column_family.to_s} (key, __#{attribute.to_s}) FROM 'dsr_export.csv';\" | cqlsh #{model.current_server}"
+              export = "echo \"copy #{model.column_family} (key, #{attribute}) TO 'dsr_export.csv';\" | cqlsh #{model.current_server}"
+              import = "echo \"copy #{model.column_family} (key, __#{attribute}) FROM 'dsr_export.csv';\" | cqlsh #{model.current_server}"
               if system(export)
                 system(import)
               else
@@ -37,101 +38,101 @@ module DatastaxRails
               end
             end
             count += 1
-            say "Creating cassandra index on __#{attribute.to_s}", :subitem
-            DatastaxRails::Cql::CreateIndex.new(cassandra_index_cql_name(model.column_family.to_s, "__#{attribute.to_s}")).on(model.column_family.to_s).column("__#{attribute.to_s}").execute
+            say "Creating cassandra index on __#{attribute}", :subitem
+            DatastaxRails::Cql::CreateIndex.new(cassandra_index_cql_name(model.column_family.to_s, "__#{attribute}")).on(model.column_family.to_s).column("__#{attribute}").execute
           end
         end
         count
       end
-      
+
       # Creates a CQL3 backed column family
       def create_cql3_column_family(model)
-        say "Creating Column Family via CQL3", :subitem
+        say 'Creating Column Family via CQL3', :subitem
         columns = {}
-        model.attribute_definitions.each {|k,col| columns[k] = col.cql_type}
+        model.attribute_definitions.each { |k, col| columns[k] = col.cql_type }
         pk = model.primary_key.to_s
-        if(model.respond_to?(:cluster_by) && model.cluster_by.present?)
-          pk += ", #{model.cluster_by.to_s}"
+        if model.respond_to?(:cluster_by) && model.cluster_by.present?
+          pk += ", #{model.cluster_by}"
         end
         cql = DatastaxRails::Cql::CreateColumnFamily.new(model.column_family).primary_key(pk).columns(columns)
         cql.with(model.create_options) if model.create_options
         cql.execute
       end
-      
+
       # Creates the named keyspace
       def create_keyspace(keyspace, options = {})
-        opts = { :name => keyspace.to_s,
-                 :strategy_class => 'org.apache.cassandra.locator.NetworkTopologyStrategy'}.with_indifferent_access.merge(options)
+        opts = { name:           keyspace.to_s,
+                 strategy_class: 'org.apache.cassandra.locator.NetworkTopologyStrategy' }.with_indifferent_access.merge(options)
 
-        if(keyspace_exists?(keyspace.to_s))
-          say "Keyspace #{keyspace.to_s} already exists"
+        if keyspace_exists?(keyspace.to_s)
+          say "Keyspace #{keyspace} already exists"
           return false
         else
           cql = DatastaxRails::Cql::CreateKeyspace.new(opts.delete(:name))
           cql.strategy_class(opts.delete(:strategy_class))
           strategy_options = opts.delete('strategy_options')
           cql.strategy_options(strategy_options.symbolize_keys)
-          say "Creating keyspace #{keyspace.to_s}"
+          say "Creating keyspace #{keyspace}"
           cql.execute
           return true
         end
       end
-      
+
       def drop_keyspace
-        say "Dropping keyspace #{@keyspace.to_s}"
+        say "Dropping keyspace #{@keyspace}"
         DatastaxRails::Cql::DropKeyspace.new(@keyspace.to_s).execute
       end
-      
+
       # Computes the expected solr index name as reported by CQL.
       def solr_index_cql_name(cf, column)
-        "#{@keyspace}_#{cf.to_s}_#{column.to_s}_index"
+        "#{@keyspace}_#{cf}_#{column}_index"
       end
-      
+
       # Computes the expected cassandra index name as reported by CQL.
       def cassandra_index_cql_name(cf, column)
-        "#{cf.to_s}_#{column.to_s}_idx"
+        "#{cf}_#{column}_idx"
       end
-      
+
       # Checks the Cassandra system tables to see if a keyspace exists
       def keyspace_exists?(keyspace)
-        klass = OpenStruct.new(:column_family => 'system.schema_keyspaces', :default_consistency => 'QUORUM')
+        klass = OpenStruct.new(column_family: 'system.schema_keyspaces', default_consistency: 'QUORUM')
         cql = DatastaxRails::Cql::ColumnFamily.new(klass)
-        results = cql.select("count(*)").conditions('keyspace_name' => keyspace).execute
+        results = cql.select('count(*)').conditions('keyspace_name' => keyspace).execute
         results.first['count'].to_i > 0
       end
-      
+
       # Checks the Cassandra system tables to see if a column family exists
       def column_family_exists?(cf)
-        klass = OpenStruct.new(:column_family => 'system.schema_columnfamilies', :default_consistency => 'QUORUM')
+        klass = OpenStruct.new(column_family: 'system.schema_columnfamilies', default_consistency: 'QUORUM')
         cql = DatastaxRails::Cql::ColumnFamily.new(klass)
-        results = cql.select("count(*)").conditions('keyspace_name' => @keyspace, 'columnfamily_name' => cf).execute
+        results = cql.select('count(*)').conditions('keyspace_name' => @keyspace, 'columnfamily_name' => cf).execute
         results.first['count'] > 0
       end
-      
+
       # Checks the Cassandra system tables to see if a column exists on a column family
       def column_exists?(cf, col)
-        klass = OpenStruct.new(:column_family => 'system.schema_columns', :default_consistency => 'QUORUM')
+        klass = OpenStruct.new(column_family: 'system.schema_columns', default_consistency: 'QUORUM')
         cql = DatastaxRails::Cql::ColumnFamily.new(klass)
-        results = cql.select("count(*)").conditions('keyspace_name' => @keyspace, 'columnfamily_name' => cf, 'column_name' => col).execute
+        results = cql.select('count(*)').conditions('keyspace_name' => @keyspace, 'columnfamily_name' => cf, 'column_name' => col).execute
         exists = results.first['count'] > 0
         unless exists
           # We need to check if it's part of an alias (ugh)
-          klass = OpenStruct.new(:column_family => 'system.schema_columnfamilies', :default_consistency => 'QUORUM')
+          klass = OpenStruct.new(column_family: 'system.schema_columnfamilies', default_consistency: 'QUORUM')
           cql = DatastaxRails::Cql::ColumnFamily.new(klass)
-          results = cql.select("column_aliases, key_aliases, value_alias").conditions('keyspace_name' => @keyspace, 'columnfamily_name' => cf).execute
+          results = cql.select('column_aliases, key_aliases, value_alias').conditions('keyspace_name' => @keyspace, 'columnfamily_name' => cf).execute
           row = results.first
           exists = row['key_aliases'].include?(col.to_s) || row['column_aliases'].include?(col.to_s) || (row['value_alias'] && row['value_alias'].include?(col.to_s))
         end
         exists
       end
-      
+
       # Checks the Cassandra system tables to see if an index exists on a column family
       def index_exists?(cf, col)
-        klass = OpenStruct.new(:column_family => 'system.schema_columns', :default_consistency => 'QUORUM')
+        klass = OpenStruct.new(column_family: 'system.schema_columns', default_consistency: 'QUORUM')
         cql = DatastaxRails::Cql::ColumnFamily.new(klass)
-        results = cql.select("index_name").conditions('keyspace_name' => @keyspace, 'columnfamily_name' => cf, 'column_name' => col).execute
+        results = cql.select('index_name').conditions('keyspace_name' => @keyspace, 'columnfamily_name' => cf, 'column_name' => col).execute
         results.first['index_name'] != nil
       end
     end
   end
-end
+end

data/lib/datastax_rails/schema/migrator.rb

@@ -1,13 +1,15 @@
 module DatastaxRails
   module Schema
+    # DatastaxRails reads the attributes from the individual models. This class migrates both Cassandra
+    # and Solr to the point where they reflect what is specified in the models.
     class Migrator
       include DatastaxRails::Schema::Solr
       include DatastaxRails::Schema::Cassandra
-      
+
       cattr_accessor :verbose
       self.verbose = true
       attr_accessor :errors
-      
+
       def initialize(keyspace)
         @keyspace = keyspace
         check_schema_migrations unless keyspace == 'system'
@@ -15,7 +17,7 @@ module DatastaxRails
       end
 
       def migrate_all(force = false)
-        say_with_time("Migrating all models") do
+        say_with_time('Migrating all models') do
 
           FileList[rails_models].each do |model|
             require model
@@ -23,14 +25,12 @@ module DatastaxRails
 
           count = 0
           DatastaxRails::Base.models.each do |m|
-            if !m.abstract_class?
-              count += migrate_one(m, force)
-            end
+            count += migrate_one(m, force) unless m.abstract_class?
           end
           count
         end
       end
-      
+
       def migrate_one(model, force = false)
         count = 0
         say_with_time("Migrating #{model.name} to latest version") do
@@ -38,9 +38,9 @@ module DatastaxRails
             create_cql3_column_family(model)
             count += 1
           end
-          
+
           count += check_missing_schema(model)
-          
+
           unless model <= DatastaxRails::CassandraOnlyModel
             count += upload_solr_configuration(model, force)
           end
@@ -54,49 +54,49 @@ module DatastaxRails
 
       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
-          unless column_family_exists?('schema_migrations')
-            say "Creating schema_migrations column family"
-            DatastaxRails::Cql::CreateColumnFamily.new('schema_migrations').primary_key('cf').columns(:cf => :text, :digest => :text, :solrconfig => :text, :stopwords => :text).execute
-          end
-        end
-        
-        def write(text="")
-          puts(text) if verbose
-        end
-  
-        def say(message, subitem=false)
-          write "#{subitem ? "   ->" : "--"} #{message}"
-        end
-  
-        def say_with_time(message)
-          say(message)
-          result = nil
-          time = Benchmark.measure { result = yield }
-          say "%.4fs" % time.real, :subitem
-          say("#{result} changes", :subitem) if result.is_a?(Integer)
-          result
-        end
-  
-        def suppress_messages
-          save, self.verbose = verbose, false
-          yield
-        ensure
-          self.verbose = save
-        end
+      # 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
+        return if column_family_exists?('schema_migrations')
+        say 'Creating schema_migrations column family'
+        DatastaxRails::Cql::CreateColumnFamily.new('schema_migrations').primary_key('cf')
+          .columns(cf: :text, digest: :text, solrconfig: :text, stopwords: :text).execute
+      end
+
+      def write(text = '')
+        puts(text) if verbose
+      end
+
+      def say(message, subitem = false)
+        write "#{subitem ? '   ->' : '--'} #{message}"
+      end
+
+      def say_with_time(message)
+        say(message)
+        result = nil
+        time = Benchmark.measure { result = yield }
+        say format('%.4fs', time.real), :subitem
+        say("#{result} changes", :subitem) if result.is_a?(Integer)
+        result
+      end
+
+      def suppress_messages
+        save, self.verbose = verbose, false
+        yield
+      ensure
+        self.verbose = save
+      end
     end
   end
 end

data/lib/datastax_rails/schema/solr.rb

@@ -1,3 +1,4 @@
+# rubocop:disable Style/LineLength
 module DatastaxRails
   module Schema
     module Solr
@@ -5,7 +6,7 @@ module DatastaxRails
       # most normal circumstances for indexing.  When a customized template is required, it can
       # be placed in the application's config/solr directory using the naming convention
       # column_family-schema.xml.erb.  It will be processed as a normal ERB file.  See the DSR version
-      # for examples.  
+      # for examples.
       def generate_solr_schema(model)
         @fields = []
         @copy_fields = []
@@ -15,32 +16,34 @@ module DatastaxRails
         else
           @primary_key = model.primary_key
         end
-        @custom_fields = ""
+        @custom_fields = ''
         @columns = model.attribute_definitions.values
-        @fields.sort! {|a,b| a[:name] <=> b[:name]}
-        @copy_fields.sort! {|a,b| a[:source] <=> b[:source]}
+        @fields.sort! { |a, b| a[:name] <=> b[:name] }
+        @copy_fields.sort! { |a, b| a[:source] <=> b[:source] }
         @fulltext_fields.sort!
-        
-        if Rails.root.join('config','solr',"#{model.column_family}-schema.xml.erb").exist?
+
+        if Rails.root.join('config', 'solr', "#{model.column_family}-schema.xml.erb").exist?
           say "Using custom schema for #{model.name}", :subitem
-          ERB.new(Rails.root.join('config','solr',"#{model.column_family}-schema.xml.erb").read, 0, '>').result(binding)
-        elsif Rails.root.join('config','solr','application-schema.xml.erb').exist?
+          ERB.new(Rails.root.join('config', 'solr', "#{model.column_family}-schema.xml.erb").read, 0, '>')
+            .result(binding)
+        elsif Rails.root.join('config', 'solr', 'application-schema.xml.erb').exist?
           say 'Using application default schema', :subitem
-          ERB.new(Rails.root.join('config','solr','application-schema.xml.erb').read, 0, '>').result(binding)
+          ERB.new(Rails.root.join('config', 'solr', 'application-schema.xml.erb').read, 0, '>').result(binding)
         else
-          ERB.new(File.read(File.join(File.dirname(__FILE__),"..","..","..","config","schema.xml.erb")), 0, '>').result(binding)
+          ERB.new(File.read(File.join(File.dirname(__FILE__), '..', '..', '..', 'config', 'schema.xml.erb')), 0, '>')
+            .result(binding)
         end
       end
-      
+
       # Sends a command to Solr instructing it to reindex the data.  The data is reindexed in the background,
       # and the new index is swapped in once it is finished.
-      def reindex_solr(model, destructive=false)
-        url = "#{DatastaxRails::Base.solr_base_url}/admin/cores?action=RELOAD&name=#{DatastaxRails::Base.config[:keyspace]}.#{model.column_family}&reindex=true&deleteAll=#{destructive.to_s}"
+      def reindex_solr(model, destructive = false)
+        url = "#{DatastaxRails::Base.solr_base_url}/admin/cores?action=RELOAD&name=#{DatastaxRails::Base.config[:keyspace]}.#{model.column_family}&reindex=true&deleteAll=#{destructive}"
         say "Posting reindex command to '#{url}'", :subitem
         `curl -s -X POST '#{url}'`
-        say "Reindexing will run in the background", :subitem
+        say 'Reindexing will run in the background', :subitem
       end
-      
+
       # Creates the initial Solr Core.  This is required once the first time a Solr schema is uploaded.
       # It will cause the data to be indexed in the background.
       def create_solr_core(model)
@@ -48,97 +51,102 @@ module DatastaxRails
         say "Posting create command to '#{url}'", :subitem
         `curl -s -X POST '#{url}'`
       end
-      
+
       # Uploads the necessary configuration files for solr to function
       # The solrconfig and stopwords files can be overridden on a per-model basis
       # by creating a file called config/solr/column_family-solrconfig.xml or
       # config/solr/column_family-stopwords.txt
       #
       # TODO: find a way to upload arbitrary files automatically (e.g., additional stopwords lists)
-      def upload_solr_configuration(model, force=false)
+      # TODO: Simplify this method
+      def upload_solr_configuration(model, force = false, reindex = true) # rubocop:disable all
         count = 0
-        if Rails.root.join('config','solr',"#{model.column_family}-solrconfig.xml").exist?
-          say "Using custom solrconfig file", :subitem
-          solrconfig = Rails.root.join('config','solr',"#{model.column_family}-solrconfig.xml").read
+        if Rails.root.join('config', 'solr', "#{model.column_family}-solrconfig.xml").exist?
+          say 'Using custom solrconfig file', :subitem
+          solrconfig = Rails.root.join('config', 'solr', "#{model.column_family}-solrconfig.xml").read
         else
           @legacy = model.legacy_mapping?
-          solrconfig = ERB.new(File.read(File.join(File.dirname(__FILE__),"..","..","..","config","solrconfig.xml.erb"))).result(binding)
+          solrconfig = ERB.new(File.read(File.join(File.dirname(__FILE__), '..', '..', '..', 'config', 'solrconfig.xml.erb'))).result(binding)
         end
-        if Rails.root.join('config','solr',"#{model.column_family}-stopwords.txt").exist?
-          say "Using custom stopwords file", :subitem
-          stopwords = Rails.root.join('config','solr',"#{model.column_family}-stopwords.txt").read
+        if Rails.root.join('config', 'solr', "#{model.column_family}-stopwords.txt").exist?
+          say 'Using custom stopwords file', :subitem
+          stopwords = Rails.root.join('config', 'solr', "#{model.column_family}-stopwords.txt").read
         else
-          stopwords = File.read(File.join(File.dirname(__FILE__),"..","..","..","config","stopwords.txt"))
+          stopwords = File.read(File.join(File.dirname(__FILE__), '..', '..', '..', 'config', 'stopwords.txt'))
         end
         schema = generate_solr_schema(model)
         solrconfig_digest = Digest::SHA1.hexdigest(solrconfig)
         stopwords_digest = Digest::SHA1.hexdigest(stopwords)
         schema_digest = Digest::SHA1.hexdigest(schema)
-        
+
         newcf = !column_exists?(model.column_family, 'solr_query')
         force ||= newcf
-        
-        results = DatastaxRails::Cql::Select.new(SchemaMigration, ['*']).conditions(:cf => model.column_family).execute
+
+        results = DatastaxRails::Cql::Select.new(SchemaMigration, ['*']).conditions(cf: model.column_family).execute
         sm_digests = results.first || {}
-        
+
         solr_url = "#{DatastaxRails::Base.solr_base_url}/resource/#{@keyspace}.#{model.column_family}"
-        
+
         uri = URI.parse(solr_url)
         http = Net::HTTP.new(uri.host, uri.port)
         if uri.scheme == 'https'
           http.use_ssl = true
-          http.cert = OpenSSL::X509::Certificate.new(Rails.root.join("config","datastax_rails.crt").read)
-          http.key = OpenSSL::PKey::RSA.new(Rails.root.join("config","datastax_rails.key").read)
-          http.ca_path = Rails.root.join("config","sade_ca.crt").to_s
+          http.cert = OpenSSL::X509::Certificate.new(Rails.root.join('config', 'datastax_rails.crt').read)
+          http.key = OpenSSL::PKey::RSA.new(Rails.root.join('config', 'datastax_rails.key').read)
+          http.ca_path = Rails.root.join('config', 'sade_ca.crt').to_s
           http.verify_mode = OpenSSL::SSL::VERIFY_NONE
         end
         http.read_timeout = 300
-        
+
         if force || solrconfig_digest != sm_digests['solrconfig']
           count += 1
-          loop do 
+          loop do
             say "Posting Solr Config file to '#{solr_url}/solrconfig.xml'", :subitem
-            http.post(uri.path+"/solrconfig.xml", solrconfig)
+            http.post(uri.path + '/solrconfig.xml', solrconfig)
             if Rails.env.production?
               sleep(5)
-              resp = http.get(uri.path+"/solrconfig.xml")
-              continue unless resp.message == 'OK'                  
+              resp = http.get(uri.path + '/solrconfig.xml')
+              continue unless resp.message == 'OK'
             end
             break
           end
-          DatastaxRails::Cql::Update.new(SchemaMigration, :cf => model.column_family).columns(:solrconfig => solrconfig_digest).execute
+          DatastaxRails::Cql::Update.new(SchemaMigration, cf: model.column_family).columns(solrconfig: solrconfig_digest).execute
         end
         if force || stopwords_digest != sm_digests['stopwords']
           count += 1
           loop do
             say "Posting Solr Stopwords file to '#{solr_url}/stopwords.txt'", :subitem
-            http.post(uri.path+"/stopwords.txt", stopwords)
+            http.post(uri.path + '/stopwords.txt', stopwords)
             if Rails.env.production?
               sleep(5)
-              resp = http.get(uri.path+"/stopwords.txt")
+              resp = http.get(uri.path + '/stopwords.txt')
               continue unless resp.message == 'OK'
             end
             break
           end
-          DatastaxRails::Cql::Update.new(SchemaMigration, :cf => model.column_family).columns(:stopwords => stopwords_digest).execute
+          DatastaxRails::Cql::Update.new(SchemaMigration, cf: model.column_family).columns(stopwords: stopwords_digest).execute
         end
         if force || schema_digest != sm_digests['digest']
           count += 1
           loop do
             say "Posting Solr Schema file to '#{solr_url}/schema.xml'", :subitem
-            http.post(uri.path+"/schema.xml", schema)
+            http.post(uri.path + '/schema.xml', schema)
             if Rails.env.production?
               sleep(5)
-              resp = http.get(uri.path+"/schema.xml")
+              resp = http.get(uri.path + '/schema.xml')
               continue unless resp.message == 'OK'
             end
             break
           end
-          DatastaxRails::Cql::Update.new(SchemaMigration, :cf => model.column_family).columns(:digest => schema_digest).execute
-          newcf ? create_solr_core(model) : reindex_solr(model)
+          DatastaxRails::Cql::Update.new(SchemaMigration, cf: model.column_family).columns(digest: schema_digest).execute
+          if newcf
+            create_solr_core(model)
+          elsif reindex
+            reindex_solr(model)
+          end
         end
         count
       end
     end
   end
-end
+end