cassandra_model 0.9.3.2 → 0.9.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 811a3063acc6a1abd58de21ba424e0784606718f
-  data.tar.gz: af46520692a4f205f6cd8f996d928d09d50ef553
+  metadata.gz: be8e45a8dab05f33396f041ca36c48c5e1fe207b
+  data.tar.gz: a3ec0023e367251890116beb12ff834c281e2928
 SHA512:
-  metadata.gz: 3e580bb73ed0999532c19b0a6ec881caa2b265ab0fead7bef262bd772d09eeac53885217777ee3a42245aaea02d6ee2c6f33f917e8cec5d67bb1ad1dd1b832d1
-  data.tar.gz: f309db41c5212ce53996f4d5e3b71e3a1755e628a32ceeed0d3de36f451c984fb46b8406f702c15c1cdd9def00abc09f1a76b2b8e9819a1c26329b08a2b6f04c
+  metadata.gz: 530aee143ab413ec91369652ab008a735eaaeac79b9d562f5b5a137fde28ff8e3bf2b1058fb91b87a09bcab00fccc41ab8fe86139ea591ec15fdb553e72c67eb
+  data.tar.gz: 5b17cd82d99a77133afb742bdef04102b6399374f1c848bbecc29c495de43b85883c0bc12ce9f914d5ce0de86a503e64cd3a05e7698eed004d371d95f1c3a57c

data/lib/cassandra_model/composite_record.rb

@@ -29,7 +29,9 @@ module CassandraModel
 
     def composite_rows
       (self.class.composite_defaults || []).map do |row|
-        merged_attributes = attributes.merge(row)
+        merged_attributes = self.class.deferred_columns.inject(attributes.merge(row)) do |memo, column|
+          memo.merge!(column => public_send(column))
+        end
         self.class.new(merged_attributes, validate: false)
       end
     end
@@ -46,4 +48,4 @@ module CassandraModel
       end
     end
   end
-end
+end

data/lib/cassandra_model/composite_record_static.rb

@@ -1,5 +1,8 @@
 module CassandraModel
   module CompositeRecordStatic
+    PK_MUTEX = Mutex.new
+    CK_MUTEX = Mutex.new
+
     extend Forwardable
 
     def_delegator :table_config, :composite_defaults=
@@ -26,16 +29,24 @@ module CassandraModel
 
     def composite_pk_map
       unless table_data.composite_pk_map
-        table_data.composite_pk_map = {}
-        columns
+        PK_MUTEX.synchronize do
+          return table_data.composite_pk_map if table_data.composite_pk_map
+
+          table_data.composite_pk_map = {}
+          columns
+        end
       end
       table_data.composite_pk_map
     end
 
     def composite_ck_map
       unless table_data.composite_ck_map
-        table_data.composite_ck_map = {}
-        columns
+        CK_MUTEX.synchronize do
+          return table_data.composite_ck_map if table_data.composite_ck_map
+
+          table_data.composite_ck_map = {}
+          columns
+        end
       end
       table_data.composite_ck_map
     end
@@ -63,8 +74,50 @@ module CassandraModel
       end
     end
 
+    def restriction_attributes(restriction)
+      updated_restriction = restriction.inject({}) do |memo, (key, value)|
+        updated_key = key_for_where_params(key)
+        memo.merge!(updated_key => value)
+      end
+
+      missing_keys = Set.new(internal_partition_key - updated_restriction.keys)
+      default_clause = composite_defaults.find { |row| (missing_keys ^ row.keys).empty? }
+      updated_restriction.merge!(default_clause) if default_clause
+      updated_restriction
+    end
+
+    def normalized_column(column)
+      column = super(column)
+
+      if column =~ /^rk_/ || column =~ /^ck_/
+        mapped_column(column)
+      else
+        column
+      end
+    end
+
+    def normalized_attributes(attributes)
+      attributes = super(attributes)
+
+      attributes.inject({}) do |memo, (column, value)|
+        memo.merge!(normalized_column(column) => value)
+      end
+    end
+
+    def select_columns(columns)
+      columns.map { |column| select_column(column) }
+    end
+
+    def select_column(column)
+      has_field?(column) ? column : mapped_column(column)
+    end
+
     private
 
+    def has_field?(column)
+      internal_columns.include?(column)
+    end
+
     def build_composite_map
       if table_config.composite_defaults
         table_config.composite_defaults.map { |row| row_composite_default(row) }
@@ -90,36 +143,27 @@ module CassandraModel
     end
 
     def select_clause(select)
-      select = mapped_select_columns(select) if select
+      select = select_columns(select) if select
       super(select)
     end
 
     def order_by_clause(order_by)
-      order_by = mapped_select_columns(order_by) if order_by
-      super(order_by)
-    end
-
-    def mapped_select_columns(select)
-      select.map do |column|
-        if internal_columns.include?(column)
-          column
-        else
-          mapped_column(column)
+      if order_by
+        order_by = [order_by] unless order_by.is_a?(Array)
+        order_by = order_by.map do |column|
+          if column.is_a?(Hash)
+            column, direction = column.first
+            {select_column(column) => direction}
+          else
+            select_column(column)
+          end
         end
       end
+      super(order_by)
     end
 
     def where_params(clause)
-      updated_clause = clause.inject({}) do |memo, (key, value)|
-        updated_key = key_for_where_params(key)
-        memo.merge!(updated_key => value)
-      end
-
-      missing_keys = Set.new(internal_partition_key - updated_clause.keys)
-      default_clause = composite_defaults.find { |row| (missing_keys ^ row.keys).empty? }
-      updated_clause.merge!(default_clause) if default_clause
-
-      super(updated_clause)
+      super restriction_attributes(clause)
     end
 
     def key_for_where_params(key)
@@ -149,18 +193,6 @@ module CassandraModel
       composite_pk_map[key] || key
     end
 
-    def row_attributes(row)
-      row = super(row)
-
-      row.inject({}) do |memo, (column, value)|
-        if column =~ /^rk_/ || column =~ /^ck_/
-          memo.merge!(mapped_column(column) => value)
-        else
-          memo.merge!(column => value)
-        end
-      end
-    end
-
     def mapped_column(column)
       (composite_ck_map[column] || composite_pk_map[column] || column)
     end

data/lib/cassandra_model/concurrency_helper.rb

@@ -0,0 +1,19 @@
+module CassandraModel
+  module ConcurrencyHelper
+    private
+
+    def safe_getset_variable(mutex, name, &block)
+      result = instance_variable_get(name)
+      return result if result
+
+      mutex.synchronize do
+        raise Cassandra::Errors::InvalidError.new('Connection invalidated!', 'Dummy') if !!@shutdown
+
+        result = instance_variable_get(name)
+        return result if result
+
+        instance_variable_set(name, block.call)
+      end
+    end
+  end
+end

data/lib/cassandra_model/counter_record.rb

@@ -5,16 +5,20 @@ module CassandraModel
       counter_clause = counter_clause(options)
       row_key = internal_primary_key.values
       statement = increment_statement(counter_clause)
+      column_values = options.values + row_key
+
+      validation_error = validate_primary_key!(statement, column_values)
+      return validation_error if validation_error
 
       future = if batch_reactor
-                 execute_async_in_batch(statement, options.values + row_key)
+                 execute_async_in_batch(statement, column_values)
                else
-                 session.execute_async(statement, *options.values, *row_key, write_query_options)
+                 session.execute_async(statement, *column_values, write_query_options)
                end
       future.on_success { execute_callback(:record_saved) }
       future.on_failure do |error|
         Logging.logger.error("Error incrementing #{self.class}: #{error}")
-        execute_callback(:save_record_failed, error)
+        execute_callback(:save_record_failed, error, statement, column_values)
       end.then { self }
     end
 
@@ -29,7 +33,7 @@ module CassandraModel
     private
 
     def internal_primary_key
-      internal_attributes.slice(*self.class.internal_primary_key)
+      self.class.internal_primary_key.inject({}) { |memo, key| memo.merge!(key => internal_attributes[key]) }
     end
 
     def increment_statement(counter_clause)

data/lib/cassandra_model/data_inquirer.rb

@@ -2,7 +2,7 @@ module CassandraModel
   class DataInquirer
     include TypeGuessing
 
-    attr_reader :partition_key, :column_defaults, :is_sharding
+    attr_reader :partition_key, :column_defaults, :shard_column
 
     def initialize
       @partition_key = Hash.new { |hash, key| hash[key] = :text }
@@ -20,8 +20,8 @@ module CassandraModel
       self
     end
 
-    def shards_queries
-      @is_sharding = true
+    def shards_queries(column = :shard)
+      @shard_column = column
     end
 
     def composite_rows

data/lib/cassandra_model/displayable_attributes.rb

@@ -5,6 +5,10 @@ module CassandraModel
       table_config.display_attributes = map ? map : columns
     end
 
+    def filter_display_attributes(*filter_columns)
+      table_config.display_attributes = columns - filter_columns
+    end
+
     def displayable_attributes
       table_config.display_attributes
     end
@@ -19,18 +23,42 @@ module CassandraModel
       if displayable_attributes
         displayable_attributes.is_a?(Hash) ? mapped_as_json : sliced_displayable_attributes
       else
-        attributes
+        json_attributes
       end
     end
 
     private
 
+    def json_attributes
+      json_attributes = attributes.keys.inject({}) do |memo, column|
+        case column_type(column)
+          when :blob
+          when :timestamp
+            memo[column] = attributes[column].to_i
+          when :timeuuid
+            memo[column] = attributes[column].to_s
+          when :uuid
+            memo[column] = attributes[column].to_s
+          else
+            memo[column] = attributes[column]
+        end
+        memo
+      end
+      self.class.deferred_columns.inject(json_attributes) do |memo, column|
+        memo.merge!(column => public_send(column))
+      end
+    end
+
+    def column_type(column)
+      self.class.cassandra_columns[self.class.select_column(column)]
+    end
+
     def mapped_as_json
       sliced_displayable_attributes.inject({}) { |memo, (key, value)| memo.merge!(displayable_attributes[key] => value) }
     end
 
     def sliced_displayable_attributes
-      attributes.slice(*displayable_attributes_slice)
+      json_attributes.slice(*displayable_attributes_slice)
     end
 
     def displayable_attributes_slice

data/lib/cassandra_model/query_builder.rb

@@ -82,15 +82,11 @@ module CassandraModel
     end
 
     def select(*columns)
-      @options[:select] ||= []
-      @options[:select].concat(columns)
-      self
+      append_option(columns, :select)
     end
 
     def order(*columns)
-      @options[:order_by] ||= []
-      @options[:order_by].concat(columns)
-      self
+      append_option(columns, :order_by)
     end
 
     def limit(limit)
@@ -110,6 +106,19 @@ module CassandraModel
 
     private
 
+    def append_option(columns, option)
+      @options[option] ||= []
+      if columns.first.is_a?(Hash)
+        columns = columns.first.map do |column, direction|
+          {column => direction}
+        end
+        @options[option].concat(columns)
+      else
+        @options[option].concat(columns)
+      end
+      self
+    end
+
     def pluck_values(columns, result)
       result.attributes.slice(*columns).values
     end

data/lib/cassandra_model/raw_connection.rb

@@ -19,6 +19,8 @@ module CassandraModel
         timeout: 10
     }.freeze
 
+    include ConcurrencyHelper
+
     def initialize(config_name = nil)
       @config_name = config_name
       @statement_cache = {}
@@ -127,20 +129,6 @@ module CassandraModel
       end
     end
 
-    def safe_getset_variable(mutex, name, &block)
-      result = instance_variable_get(name)
-      return result if result
-
-      mutex.synchronize do
-        raise Cassandra::Errors::InvalidError.new('Connection invalidated!', 'Dummy') if !!@shutdown
-
-        result = instance_variable_get(name)
-        return result if result
-
-        instance_variable_set(name, block.call)
-      end
-    end
-
     def load_config
       if File.exists?(config_path)
         config = yaml_config || {}

data/lib/cassandra_model/record.rb

@@ -3,9 +3,10 @@ require_relative 'meta_columns'
 
 module CassandraModel
   class Record
-    extend CassandraModel::QueryHelper
-    include CassandraModel::MetaColumns
-    include CassandraModel::DisplayableAttributes
+    extend QueryHelper
+    include MetaColumns
+    include DisplayableAttributes
+    include RecordDebug
 
     attr_reader :attributes, :valid, :execution_info
 
@@ -25,6 +26,8 @@ module CassandraModel
         :composite_primary_key,
 
         :composite_shard_key,
+
+        :cassandra_columns,
     ) # Using this instead of OpenStruct, as there seems to be a bug in JRuby that causes this to get mangled over time
     ConfigureableAttributes = Struct.new(
         :table_name,
@@ -116,9 +119,21 @@ module CassandraModel
     end
 
     def inspected_attributes
-      attributes.map do |key, value|
-        %Q{#{key}: "#{value.to_s.truncate(53)}"}
-      end * ', '
+      columns = self.class.cassandra_columns.map do |column, type|
+        self.class.normalized_column(column) unless type == :blob
+      end.compact.uniq
+
+      base_attributes = columns.map do |column|
+        if (value = attributes[column])
+          %Q{#{column}: "#{value.to_s.truncate(53)}"}
+        else
+          "#{column}: (empty)"
+        end
+      end
+      base_attributes += deferred_columns.map do |column|
+        %Q{#{column}: "#{public_send(column)}"}
+      end
+      base_attributes * ', '
     end
 
     protected
@@ -232,17 +247,56 @@ module CassandraModel
 
     def save_row_async(options)
       statement = statement(query_for_save(options))
+      save_column_values = column_values
+
+      validation_error = validate_primary_key!(statement, save_column_values)
+      return validation_error if validation_error
+
       future = if batch_reactor
-                 execute_async_in_batch(statement, column_values)
+                 execute_async_in_batch(statement, save_column_values)
                else
-                 session.execute_async(statement, *column_values, write_query_options(options))
+                 session.execute_async(statement, *save_column_values, write_query_options(options))
                end
       future.on_failure do |error|
-        Logging.logger.error("Error saving #{self.class}: #{error}")
-        execute_callback(:save_record_failed, error)
+        handle_save_error(error, save_column_values, statement)
       end
     end
 
+    def validate_primary_key!(statement, save_column_values)
+      missing_primary_columns = invalid_primary_key_parts
+      if missing_primary_columns.present?
+        error = invalid_key_error(missing_primary_columns, statement)
+        handle_save_error(error, save_column_values, statement)
+        Cassandra::Future.error(error)
+      end
+    end
+
+    def handle_save_error(error, save_column_values, statement)
+      Logging.logger.error("Error saving #{self.class}: #{error}")
+      execute_callback(:save_record_failed, error, statement, save_column_values)
+    end
+
+    def invalid_key_error(missing_primary_columns, statement)
+      Cassandra::Errors::InvalidError.new(missing_key_message(missing_primary_columns), statement)
+    end
+
+    def missing_key_message(missing_primary_columns)
+      "Invalid primary key parts #{missing_primary_columns.map(&:to_s).map(&:inspect) * ', '}"
+    end
+
+    def invalid_primary_key_parts
+      save_attributes = internal_attributes
+      if self.class.internal_partition_key.one? && save_attributes[internal_partition_key_part_one].blank?
+        [internal_partition_key_part_one]
+      else
+        self.class.internal_primary_key.select { |value| save_attributes[value].nil? }
+      end
+    end
+
+    def internal_partition_key_part_one
+      self.class.internal_partition_key.first
+    end
+
     def execute_callback(callback, *extra_params)
       GlobalCallbacks.call(callback, self, *extra_params)
     end
@@ -369,6 +423,32 @@ module CassandraModel
 
       alias :create! :create
 
+      def restriction_attributes(restriction)
+        restriction
+      end
+
+      def normalized_column(column)
+        column.to_sym
+      end
+
+      def normalized_attributes(attributes)
+        attributes.symbolize_keys
+      end
+
+      def select_columns(columns)
+        columns
+      end
+
+      def select_column(column)
+        column
+      end
+
+      def cassandra_columns
+        table_data.cassandra_columns ||= table.connection.keyspace.table(table_name).columns.inject({}) do |memo, column|
+          memo.merge!(column.name.to_sym => column.type)
+        end
+      end
+
       def request_async(clause, options = {})
         page_size = options[:page_size]
         trace = options[:trace]
@@ -398,7 +478,18 @@ module CassandraModel
       end
 
       def order_by_clause(order_by)
-        " ORDER BY #{multi_csv_clause(order_by)}" if order_by
+        if order_by
+          order_by = [order_by] unless order_by.is_a?(Array)
+          ordering_columns = order_by.map do |column|
+            if column.is_a?(Hash)
+              column, direction = column.first
+              "#{column} #{direction.upcase}"
+            else
+              column
+            end
+          end
+          " ORDER BY #{multi_csv_clause(ordering_columns)}"
+        end
       end
 
       def first_async(clause = {}, options = {})
@@ -526,14 +617,10 @@ module CassandraModel
       end
 
       def record_from_result(row, execution_info, invalidate_result)
-        attributes = row_attributes(row)
+        attributes = normalized_attributes(row)
         new(attributes, execution_info: execution_info).tap { |result| result.invalidate! if invalidate_result }
       end
 
-      def row_attributes(row)
-        row.symbolize_keys
-      end
-
       def manual_shard(&block)
         before_save { attributes[shard_key] = instance_eval(&block) }
       end

data/lib/cassandra_model/record_debug.rb

@@ -0,0 +1,25 @@
+module CassandraModel
+  module RecordDebug
+    DebugDump = Struct.new(
+        :record,
+        :klass,
+        :table,
+        :table_config,
+        :table_data,
+        :attributes,
+        :internal_attributes,
+    )
+
+    def debug
+      DebugDump.new(
+          self,
+          self.class,
+          self.class.table,
+          self.class.send(:table_config),
+          self.class.send(:table_data),
+          attributes,
+          internal_attributes,
+      )
+    end
+  end
+end

data/lib/cassandra_model/rotating_table.rb

@@ -1,6 +1,7 @@
 module CassandraModel
   class RotatingTable
     extend Forwardable
+    include TableDebug
 
     def_delegators :first_table, :primary_key, :partition_key, :clustering_columns, :columns
     def_delegators :table, :connection, :name, :truncate!
@@ -14,6 +15,7 @@ module CassandraModel
     end
 
     def allow_truncation!
+      @allow_truncation = true
       tables.each(&:allow_truncation!)
     end
 
@@ -46,4 +48,4 @@ module CassandraModel
     end
 
   end
-end
+end

data/lib/cassandra_model/table_debug.rb

@@ -0,0 +1,36 @@
+module CassandraModel
+  module TableDebug
+    Debug = Struct.new(
+        :name,
+        :table,
+        :rotating_tables,
+        :first_table,
+        :connection_name,
+        :connection,
+        :partition_key,
+        :clustering_columns,
+        :primary_key,
+        :columns,
+        :allows_truncation?,
+        :rotating_schedule,
+    )
+
+    def debug
+      first_table = (@tables.first if @tables)
+      Debug.new(
+          name,
+          table,
+          @tables,
+          first_table,
+          @connection_name,
+          connection,
+          partition_key,
+          clustering_columns,
+          primary_key,
+          columns,
+          !!@allow_truncation,
+          @schedule,
+      )
+    end
+  end
+end

data/lib/cassandra_model/table_definition.rb

@@ -2,12 +2,19 @@ module CassandraModel
   class TableDefinition
     attr_reader :name
 
-    def self.from_data_model(name, inquirer, data_set)
+    def self.from_data_model(table_name, inquirer, data_set)
       partition_key = inquirer_partition_key(inquirer)
-      partition_key.merge!(rk_shard: :int) if inquirer.is_sharding
+      if inquirer.shard_column
+        if inquirer.shard_column.is_a?(Hash)
+          column_name, type = inquirer.shard_column.first
+          partition_key.merge!(:"rk_#{column_name}" => type)
+        else
+          partition_key.merge!(:"rk_#{inquirer.shard_column}" => :int)
+        end
+      end
       clustering_columns = table_set_clustering_columns(data_set)
       remaining_columns = table_set_remaining_columns(data_set)
-      new(name: name, partition_key: partition_key,
+      new(name: table_name, partition_key: partition_key,
           clustering_columns: clustering_columns,
           remaining_columns: remaining_columns)
     end

data/lib/cassandra_model/table_redux.rb

@@ -1,6 +1,7 @@
 module CassandraModel
   class TableRedux
     extend Forwardable
+    include TableDebug
 
     attr_reader :name
 

data/lib/cassandra_model/type_guessing.rb

@@ -13,21 +13,21 @@ module TypeGuessing
     private
 
     def postfix_type
-      if column =~ /_at$/
+      if column =~ /(^|_)at$/
         :timestamp
-      elsif column =~ /_at_id$/
+      elsif column =~ /(^|_)at_id$/
         :timeuuid
-      elsif column =~ /_id$/
+      elsif column =~ /(^|_)id$/
         :uuid
-      elsif column =~ /_(price|average|stddev)$/
+      elsif column =~ /(^|_)(price|average|stddev)$/
         :double
-      elsif column =~ /_(total|count)$/
+      elsif column =~ /(^|_)(total|count)$/
         counter_type
-      elsif column =~ /_(year|day|month|index)$/
+      elsif column =~ /(^|_)(year|day|month|index)$/
         :int
-      elsif column =~ /_data/
+      elsif column =~ /(^|_)data/
         :blob
-      elsif column =~ /_map$/
+      elsif column =~ /(^|_)map$/
         'map<string, string>'
       end
     end

data/lib/cassandra_model.rb

@@ -14,11 +14,16 @@
 # limitations under the License.
 #++
 
+require 'yaml'
+require 'logger'
 require 'concurrent'
 require 'cassandra'
+require 'thomas_utils'
+require 'batch_reactor'
 require 'active_support/all'
 require 'active_support/core_ext/class/attribute_accessors'
 
+require 'cassandra_model/concurrency_helper'
 require 'cassandra_model/logging'
 require 'cassandra_model/global_callbacks'
 require 'cassandra_model/single_token_batch'
@@ -30,11 +35,13 @@ require 'cassandra_model/batch_reactor/future'
 require 'cassandra_model/raw_connection'
 require 'cassandra_model/connection_cache'
 require 'cassandra_model/table_definition'
+require 'cassandra_model/table_debug'
 require 'cassandra_model/table_redux'
 require 'cassandra_model/result_paginator'
 require 'cassandra_model/query_result'
 require 'cassandra_model/query_builder'
 require 'cassandra_model/displayable_attributes'
+require 'cassandra_model/record_debug'
 require 'cassandra_model/record'
 require 'cassandra_model/counter_record'
 require 'cassandra_model/table_descriptor'

metadata

@@ -1,69 +1,69 @@
 --- !ruby/object:Gem::Specification
 name: cassandra_model
 version: !ruby/object:Gem::Version
-  version: 0.9.3.2
+  version: 0.9.18
 platform: ruby
 authors:
 - Thomas RM Rogers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-02 00:00:00.000000000 Z
+date: 2015-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cassandra-driver
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '4.0'
 - !ruby/object:Gem::Dependency
   name: batch_reactor
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.0.1
 - !ruby/object:Gem::Dependency
   name: thomas_utils
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.1.13
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.1.13
 description: |-
@@ -81,6 +81,7 @@ files:
 - lib/cassandra_model/batch_reactor/future.rb
 - lib/cassandra_model/composite_record.rb
 - lib/cassandra_model/composite_record_static.rb
+- lib/cassandra_model/concurrency_helper.rb
 - lib/cassandra_model/connection_cache.rb
 - lib/cassandra_model/counter_record.rb
 - lib/cassandra_model/data_inquirer.rb
@@ -96,12 +97,14 @@ files:
 - lib/cassandra_model/query_result.rb
 - lib/cassandra_model/raw_connection.rb
 - lib/cassandra_model/record.rb
+- lib/cassandra_model/record_debug.rb
 - lib/cassandra_model/result_paginator.rb
 - lib/cassandra_model/rotating_table.rb
 - lib/cassandra_model/single_token_batch.rb
 - lib/cassandra_model/single_token_counter_batch.rb
 - lib/cassandra_model/single_token_logged_batch.rb
 - lib/cassandra_model/single_token_unlogged_batch.rb
+- lib/cassandra_model/table_debug.rb
 - lib/cassandra_model/table_definition.rb
 - lib/cassandra_model/table_descriptor.rb
 - lib/cassandra_model/table_redux.rb
@@ -116,12 +119,12 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []