cassava_rb 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 608975429084fed43ea970713fc2ba91497d061b
+  data.tar.gz: 8c782e434e9172dd8d9a23ac286186de9ba155b4
+SHA512:
+  metadata.gz: 2116e9edaff4ac4ef6d91f105a41028b1d217b57f689f26ee96594792dff87c68ec201f28f4fe062d2819fa719d60726a19011c0e1a3de2b06e2a761ae18c8ba
+  data.tar.gz: b027b99912c044a853d0d47bc76308df2714dfba43da863ff866f63d7d603f47c16b14a6251993da834c41e8cb49d8142166e0e359bde53eac84fd4d4924b85c

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cassava.gemspec
+gemspec
+
+group :development, :test do
+  gem "pry"
+  gem "awesome_print"
+  gem 'm', :git => 'git@github.com:ANorwell/m.git', :branch => 'minitest_5'
+end
+
+group :test do
+  gem 'minitest_should', :git => 'git@github.com:citrus/minitest_should.git'
+  gem "mocha"
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Datto
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,112 @@
+# Cassava
+
+[![Code Climate](https://codeclimate.com/github/backupify/cassava/badges/gpa.svg)](https://codeclimate.com/github/backupify/cassava)
+
+An unopinionated Cassandra client built on top of the Datastax Cassandra Driver. Cassava provides a higher-level statement execution interface while still supporting asynchronous queries and the ability to connect to multiple clusters.
+
+ _If prepared incorrectly, the cassava plant can produce cyanide, a deadly compound when consumed._
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'cassava_rb', github: 'backupify/cassava'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cassava_rb
+
+## Usage
+
+Creating a client requires a `Cassandra::Session` object:
+
+```ruby
+require 'cassava'
+cluster = Cassandra.cluster
+session = cluster.connect('a_keyspace')
+client = Cassava::Client.new(session)
+```
+
+### Insert
+
+```ruby
+client.insert(:table, :id => 'id', :a => 1, :b => 'b')
+
+```
+
+### Select
+
+A select statement is built and then executed. To create a statement that will
+select all columns:
+
+```ruby
+statement = client.select(:table)
+```
+
+This statement can then be further refined:
+
+```ruby
+new_statement = statement.where(:id => 'id').limit(2)
+```
+
+and then executed:
+
+```ruby
+result = new_statement.execute
+```
+
+or executed asynchronously:
+
+```ruby
+promise = new_statement.execute_async
+```
+
+To select only certain rows, provide those rows to the select method:
+
+```ruby
+client.select(:table, [:id, :a, :b]).execute
+```
+
+Ordering can be specified using the order method:
+
+```ruby
+client.select(:table).where('id = ? AND a > ?', 1, 'b').order(:a, :desc).execute
+```
+
+Filtering is permitting with the `allow_filtering` method.
+
+Multiple records can be specified by passing an array of values, but this will generate an CQL IN query and should be used with caution:
+
+```ruby
+client.select(:table).where(:id => 1, :a => [1, 2])
+```
+
+### Delete
+
+To delete an entire record:
+
+```ruby
+client.delete(table).where(:id => 1, :a => 1).execute
+```
+
+To delete only certain columns:
+
+```ruby
+client.delete(table, [:c, :d]).where(:id => 1, :a => 1).execute
+```
+
+Note here that :c and :d must not be part of the primary key.
+
+## Contributing
+
+1. Fork it ( https://github.com/backupify/cassava/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/gem_tasks"
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.pattern = 'test/**/*_test.rb'
+  t.libs.push 'test'
+end
+
+task :setup do
+  require 'bundler/setup'
+  Bundler.require(:default, :development)
+end
+
+
+task :console => [:setup] do
+  Pry.start
+end

data/cassava_rb.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cassava/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cassava_rb"
+  spec.version       = Cassava::VERSION
+  spec.authors       = ["Arron Norwell"]
+  spec.email         = ["anorwell@datto.com"]
+  spec.summary       = %q{An unopinionated wrapper for the datastax cassandra gem.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "minitest-reporters"
+
+  spec.add_dependency 'cassandra-driver'
+end

data/lib/cassava.rb

@@ -0,0 +1,5 @@
+require 'cassandra'
+require "cassava/version"
+require 'cassava/client'
+
+module Cassava; end

data/lib/cassava/client.rb

@@ -0,0 +1,264 @@
+module Cassava
+  class Client
+    attr_reader :session, :executor
+
+    # @param session [Cassandra::Session] The session object
+    # @option opts [Object] :logger responding to :debug, :info, :warn, :error, :fatal
+    def initialize(session, opts = {})
+      @session = session
+      logger = opts[:logger] || NullLogger.new
+      @executor = Executor.new(session, logger)
+    end
+
+    # @see #insert
+    def insert_async(table, data)
+      executor.execute_async(insert_statement(table, data), :arguments => data.values)
+    end
+
+    # @param table [Symbol] the table name
+    # @param data [Hash] A hash of column names to data, which will be inserted into the table
+    def insert(table, data)
+      statement = insert_statement(table, data)
+      executor.execute(statement, :arguments => data.values)
+    end
+
+    # @param table [Symbol] the table name
+    # @param columns [Array<Symbol>] An optional list of column names (as symbols), to only select those columns
+    # @return [StatementBuilder] A statement builder representing the partially completed statement.
+    def select(table, columns = nil)
+      StatementBuilder.new(executor).select(table, columns)
+    end
+
+    # @param table [Symbol] the table name
+    # @param columns [Array<String] A list of columns that will be deleted. If nil, all columns will be deleted.
+    # @return [StatementBuilder] A statement builder representing the partially completed statement.
+    def delete(table, columns = nil)
+      StatementBuilder.new(executor).delete(table, columns)
+    end
+
+    # Pass a raw query to execute synchronously to the underlying session object.
+    # @param statement[String] The statment to execute
+    # @param opts [Hash] options accepted by Cassandra::Session
+    def execute_async(statement, opts = {})
+      executor.execute_async(statement, opts)
+    end
+
+    # Pass a raw query to execute asynchronously to the underlying session object.
+    # @param statement [String] The statment to execute
+    # @param opts [Hash] options accepted by Cassandra::Session
+    def execute(statement, opts = {})
+      executor.execute(statement, opts)
+    end
+
+    private
+
+    def insert_statement(table, data)
+      column_names = data.keys
+      statement_cql = "INSERT INTO #{table} (#{column_names.join(', ')}) VALUES (#{column_names.map { |x| '?' }.join(',')})"
+      executor.prepare(statement_cql)
+    end
+  end
+
+  class StatementBuilder
+    attr_reader :executor, :table, :clauses
+
+    CLAUSE_ORDERING = {
+                       :main => 0,
+                       :from => 1,
+                       :where => 2,
+                       :order => 3,
+                       :limit => 4,
+                       :allow_filtering => 5
+                      }
+
+    def initialize(executor, clauses = {})
+      @executor = executor
+      @table = table
+      @clauses = clauses
+    end
+
+    # Execute the statement synchronously
+    # @param opts [Hash] options accepted by Cassandra::Session
+    def execute(opts = {})
+      options = opts.dup.merge(:arguments => prepared_arguments)
+      executor.execute(prepared_statement, options)
+    end
+
+    # Execute the statement asynchronously
+    # @param opts [Hash] options accepted by Cassandra::Session
+    def execute_async(opts = {})
+      options = opts.dup.merge(:arguments => prepared_arguments)
+      executor.execute_async(prepared_statement, options)
+    end
+
+    # @param table [Symbol] table to select data from
+    # @param columns [Array<Symbol>] Columns to select -- defaults to all.
+    # @return [StatementBuilder]
+    def select(table, columns = nil)
+      add_clause(SelectClause.new(table, columns), :main)
+    end
+
+    # @param table [Symbol] table to delete data from
+    # @param columns [Array<Symbol>] Columns to delete -- defaults to all.
+    # @return [StatementBuilder]
+    def delete(table, columns = nil)
+      add_clause(DeleteClause.new(table, columns), :main)
+    end
+
+    # Condition the query based on a condition
+    # Provide either a String and a list of arguments, or a hash.
+    # @example
+    #      statement.where('id = ? and field > ?', 1, 'a')
+    # @example
+    #      statement.where(:id => 1, :field => 'x')
+    # @param args [Array] arguments representing the where condition
+    # @return [StatementBuilder]
+    def where(*args)
+      clause = clauses[:where] || WhereClause.new([], [])
+      add_clause(clause.where(*args), :where)
+    end
+
+    # Allow filtering for this query
+    # @return [StatementBuilder]
+    def allow_filtering
+      add_clause('ALLOW FILTERING', :allow_filtering)
+    end
+
+    # @param clustering_column [Symbol] clustering_column to order by
+    # @param direction [:asc|:desc] the direction to order by, defaults to :asc
+    # @return [StatementBuilder]
+    def order(clustering_column, direction = :asc)
+      add_clause("ORDER BY #{clustering_column.to_s} #{direction.to_s}", :order)
+    end
+
+    # @param n [Integer] maximum number of results to return
+    # @return [StatementBuilder]
+    def limit(n)
+      add_clause("LIMIT #{n.to_i}", :limit)
+    end
+
+    # Return the count of objects rather than the objects themselves
+    # @return [StatementBuilder]
+    def count
+      add_clause(clauses[:main].count, :main)
+    end
+
+    # @return [String] the CQL statement that this StatementBuilder represents
+    def statement
+      clauses.sort_by { |s| CLAUSE_ORDERING[s[0]] }.map { |s| s[1] }.join(' ')
+    end
+
+    private
+
+    def prepared_statement
+      executor.prepare(statement)
+    end
+
+    def prepared_arguments
+      clauses[:where] ? clauses[:where].arguments : []
+    end
+
+    # Adds a clause of a given type.
+    # @return [StatementBuilder] A new StatementBuilder with the added clause
+    def add_clause(clause, type)
+      clauses_copy = clauses.dup
+      clauses_copy[type] = clause
+      self.class.new(executor, clauses_copy)
+    end
+  end
+
+  SelectClause = Struct.new(:table, :columns, :count_boolean) do
+    def count
+      self.class.new(table, _columns = nil, _count_boolean = true)
+    end
+
+    def to_s
+      if count_boolean
+        "SELECT COUNT(*) FROM #{table}"
+      else
+        self.columns ||= ['*']
+        "SELECT #{columns.join(', ')} from #{table}"
+      end
+    end
+  end
+
+  DeleteClause = Struct.new(:table, :columns) do
+    def to_s
+      if columns
+        "DELETE #{columns.join(', ')} from #{table}"
+      else
+        "DELETE from #{table}"
+      end
+    end
+  end
+
+  WhereClause = Struct.new(:parts, :arguments) do
+    def where(*args)
+      new_parts = self.parts.dup || []
+      new_arguments = self.arguments.dup || []
+
+      case args[0]
+      when String
+        new_parts << args[0]
+        new_arguments += args[1..-1]
+      when Hash
+        new_parts += args[0].map { |key, value| "#{key} #{where_string(value)}" }
+        new_arguments += args[0].values.flatten
+      end
+      self.class.new(new_parts, new_arguments)
+    end
+
+    def to_s
+      "WHERE #{parts.join(' AND ')}"
+    end
+
+    private
+
+    def where_string(value)
+      case value
+      when Array
+        quoted_values = value.map { |v| type_quote(v) }
+        "IN(#{quoted_values.map { |_| '?' }.join(', ')})"
+      else "= ?"
+      end
+    end
+
+    def type_quote(value)
+      case value
+      when Numeric then value.to_s
+      when String then "'#{value}'"
+      end
+    end
+  end
+
+  Executor = Struct.new(:session, :logger) do
+    def execute(statement, opts = {})
+      log_statement(statement, opts)
+      session.execute(statement, opts)
+    rescue => e
+      log_error(e, statement, opts)
+      raise e
+    end
+
+    def execute_async(statement, opts = {})
+      log_statement(statement, opts)
+      session.execute_async(statement, opts)
+    end
+
+    def prepare(*args)
+      session.prepare(*args)
+    end
+
+    def log_statement(statement, opts)
+      logger.debug("Executing Cassandra request #{statement.to_s} with options #{opts}")
+    end
+
+    def log_error(e, statement, opts)
+      logger.debug("Error #{e} executing Cassandra request #{statement.to_s} with options #{opts}")
+    end
+  end
+
+  class NullLogger
+    def method_missing(*); end
+  end
+end

data/lib/cassava/version.rb

@@ -0,0 +1,3 @@
+module Cassava
+  VERSION = "0.1.0"
+end

data/test/cassava/client_test.rb

@@ -0,0 +1,195 @@
+require_relative '../test_helper'
+
+module Cassava
+  class ClientTest < Minitest::Should::TestCase
+    setup do
+      initialize_test_table
+      @session = session_for_keyspace
+      @client = Cassava::Client.new(@session)
+    end
+
+    def string_keys(hash)
+      Hash[hash.map { |k, v| [k.to_s, v] }]
+    end
+
+    context 'insert' do
+      should 'be able to insert an item' do
+        item = { :id => 'i', :a => 1, :b => 'b', :c => 'c', :d => 1}
+        @client.insert(:test, item)
+        assert_equal string_keys(item), @client.select(:test).execute.first
+      end
+
+      should 'insert an item with some fields missing' do
+        item = { :id => 'i', :a => 1, :b => 'b', :c => 'c'}
+        expected = item.merge(:d => nil)
+        @client.insert(:test, item)
+        assert_equal string_keys(expected), @client.select(:test).execute.first
+      end
+
+      should 'raise an error if the row key is missing' do
+        item = { :a => 1, :b => 'b', :c => 'c'}
+        assert_raises(Cassandra::Errors::InvalidError) { @client.insert(:test, item) }
+      end
+
+      should 'raise an error if a primary key part is missing' do
+        item = { :id => 'i', :a => 1, :c => 'c'}
+        assert_raises(Cassandra::Errors::InvalidError) { @client.insert(:test, item) }
+      end
+
+      should 'allow the insertion of columns with mismatched quotes' do
+        item = { :id => 'i', :a => 1, :b => 'b', :c => "'\"item(", :d => 1}
+        @client.insert(:test, item)
+        assert_equal string_keys(item), @client.select(:test).execute.first
+      end
+    end
+
+    context 'select' do
+
+      setup do
+        @client.insert(:test, :id => 'i', :a => 1, :b => 'b', :c => '1')
+        @client.insert(:test, :id => 'i', :a => 2, :b => 'a', :c => '1')
+        @client.insert(:test, :id => 'i', :a => 3, :b => 'c', :c => '1')
+        @client.insert(:test, :id => 'i2', :a => 4, :b => 'b', :c => '1')
+      end
+
+      should 'select all columns for all items' do
+        items = @client.select(:test).execute
+        assert_equal 4, items.count
+        assert_equal [1,2,3,4].to_set, items.map { |x| x['a'] }.to_set
+        assert_equal %w(id a b c d).to_set, items.first.keys.to_set
+      end
+
+      should 'select certain columns for all items' do
+        items = @client.select(:test, %w(id a c)).execute
+        assert_equal 4, items.count
+        assert_equal [1,2,3,4].to_set, items.map { |x| x['a'] }.to_set
+        assert_equal %w(id a c).to_set, items.first.keys.to_set
+      end
+
+      context 'where' do
+        should 'allow where clause' do
+          items = @client.select(:test).where(:id => 'i').execute
+          assert_equal [1,2,3].to_set, items.map { |x| x['a'] }.to_set
+        end
+
+        should 'allow string-based where clauses' do
+          items = @client.select(:test).where("id = 'i' and a > 1").execute
+          assert_equal [2,3].to_set, items.map { |x| x['a'] }.to_set
+        end
+
+        should 'allow string-based where clauses with arguments' do
+          items = @client.select(:test).where("id = ? and a > ?", 'i', 1).execute
+          assert_equal [2,3].to_set, items.map { |x| x['a'] }.to_set
+        end
+
+        should 'allow multiple where clauses to be chained' do
+          items = @client.select(:test).where(:id => 'i').where('a > 1').execute
+          assert_equal [2,3].to_set, items.map { |x| x['a'] }.to_set
+        end
+
+        should 'create an IN clause when a list of values is passed' do
+          items = @client.select(:test).where(:id => 'i', :a => 1, :b => %w(a b)).execute
+          assert_equal [1], items.map { |x| x['a'] }
+        end
+
+        context 'hash arguments' do
+          should 'allow single and double quotes in the value' do
+            items = @client.select(:test).where(:id => "'\"abc").execute
+            assert_equal [], items.to_a
+          end
+        end
+
+        context 'string arguments' do
+          should 'allow single and double quotes in the value' do
+            items = @client.select(:test).where('id = ?', "'\"abc").execute
+            assert_equal [], items.to_a
+          end
+        end
+      end
+
+      should 'order by ascending primary key by default' do
+        items = @client.select(:test).where(:id => 'i').execute
+        assert_equal [1,2,3], items.map { |x| x['a'] }
+      end
+
+      should 'allow order to specify ordering' do
+        items = @client.select(:test).where(:id => 'i').order(:a, :desc).execute
+        assert_equal [3, 2, 1], items.map { |x| x['a'] }
+      end
+
+      should 'allow limiting the result count' do
+        items = @client.select(:test).where(:id => 'i').limit(2).execute
+        assert_equal [1, 2], items.map { |x| x['a'] }
+      end
+
+      should 'not allow queries across multiple rows if allow_filtering is not set' do
+        assert_raises(Cassandra::Errors::InvalidError) { @client.select(:test).where(:a => 1).execute }
+      end
+
+      should 'allow queries across multiple rows if allow_filtering is set' do
+        items = @client.select(:test).where('a >= 3').allow_filtering.execute
+        assert_equal [3, 4].to_set, items.map { |x| x['a'] }.to_set
+      end
+
+      should 'allow clauses to be chained in any order' do
+        items = @client.select(:test).limit(2).allow_filtering.where('a >= 2').execute
+        assert_equal [2, 4].to_set, items.map { |x| x['a'] }.to_set
+      end
+
+      should 'allow select statements to be modified without affecting the original statement' do
+        partial_query = @client.select(:test).allow_filtering.where(:a => 1)
+
+        items = partial_query.where(:b => 'missing').execute
+        assert_equal 0, items.count
+
+        original_items = partial_query.execute
+        assert_equal 1, original_items.count
+      end
+
+      should 'support count queries' do
+        count = @client.select(:test).where("id = ? and a > ?", 'i', 1).count.execute
+        assert_equal 2, count.first["count"]
+      end
+    end
+
+    context 'delete' do
+      setup do
+        @client.insert(:test, :id => 'i', :a => 2, :b => 'a', :c => '1', :d => 1)
+        @client.insert(:test, :id => 'i', :a => 3, :b => 'c', :c => '1', :d => 1)
+      end
+
+      should 'delete entire rows' do
+        @client.delete(:test).where(:id => 'i', :a => 2).execute
+        items = @client.select(:test).where(:id => 'i', :a => 2).execute
+        assert_equal 0, items.count
+      end
+
+      should 'delete multiple elements in a partition' do
+        @client.delete(:test).where(:id => 'i').execute
+        items = @client.select(:test).where(:id => 'i').execute
+        assert_equal 0, items.count
+      end
+
+      should 'delete individual columns' do
+        @client.delete(:test, [:c, :d]).where(:id => 'i', :a => 2, :b => 'a').execute
+        items = @client.select(:test).where(:id => 'i', :a => 2).execute
+        assert_equal nil, items.first['c']
+        assert_equal nil, items.first['d']
+      end
+
+      context 'hash arguments' do
+        should 'allow single and double quotes in the value' do
+          # no error raised
+          @client.delete(:test).where(:id => "'\"abc").execute
+        end
+      end
+
+      context 'string arguments' do
+        should 'allow single and double quotes in the value' do
+          # no error raised
+          @client.delete(:test).where('id = ?', "'\"abc").execute
+        end
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,25 @@
+require 'rubygems'
+require 'pry'
+require 'minitest/autorun'
+require 'minitest/should'
+
+
+require 'cassava'
+
+class Minitest::Should::TestCase
+  def self.xshould(*args)
+    puts "Disabled test: #{args}"
+  end
+end
+
+def session_for_keyspace(keyspace = 'test_cassava')
+  c = Cassandra.cluster(port: 9242)
+  c.connect(keyspace)
+end
+
+def initialize_test_table
+  sess = session_for_keyspace(nil)
+  sess.execute('DROP KEYSPACE test_cassava') rescue nil
+  sess.execute("CREATE KEYSPACE test_cassava with replication = { 'class' : 'SimpleStrategy', 'replication_factor' : 1 }")
+  session_for_keyspace.execute('CREATE TABLE test(id text, a int, b text, c text, d int, primary key ((id), a, b))')
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: cassava_rb
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Arron Norwell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: cassandra-driver
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- anorwell@datto.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- cassava_rb.gemspec
+- lib/cassava.rb
+- lib/cassava/client.rb
+- lib/cassava/version.rb
+- test/cassava/client_test.rb
+- test/test_helper.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: An unopinionated wrapper for the datastax cassandra gem.
+test_files:
+- test/cassava/client_test.rb
+- test/test_helper.rb
+has_rdoc: