cassanity 0.1.0 → 0.2.0

data/README.md

@@ -2,8 +2,6 @@
 
 Layer of goodness on top of cassandra-cql so you do not have to write CQL strings all over the place.
 
-Current status: Incomplete and changing fast. **Do not use this yet**, but feel free to follow along.
-
 ## Installation
 
 Add this line to your application's Gemfile:

data/cassanity.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |gem|
   gem.email         = ["nunemaker@gmail.com"]
   gem.description   = %q{Layer of goodness on top of cassandra-cql so you do not have to write CQL strings all over the place.}
   gem.summary       = %q{Layer of goodness on top of cassandra-cql so you do not have to write CQL strings all over the place.}
-  gem.homepage      = "https://github.com/jnunemaker/cassanity/"
+  gem.homepage      = "http://johnnunemaker.com/cassanity/"
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }

data/lib/cassanity/argument_generators/column_family_create.rb

@@ -11,11 +11,11 @@ module Cassanity
 
       # Internal
       def call(args = {})
-        name        = args.fetch(:name)
-        schema      = args.fetch(:schema)
-        columns     = schema.columns
-        primary_key = schema.primary_key
-        with        = schema.with
+        name         = args.fetch(:name)
+        schema       = args.fetch(:schema)
+        columns      = schema.columns
+        primary_keys = schema.primary_keys
+        with         = schema.with
 
         definitions, variables = [], []
 
@@ -27,11 +27,11 @@ module Cassanity
           definitions << "#{name} #{type}"
         end
 
-        definitions << "PRIMARY KEY (%s)" % Array(primary_key).join(', ')
+        definitions << "PRIMARY KEY (#{primary_keys.join(', ')})"
 
         cql_definition = definitions.join(', ')
 
-        cql = "CREATE COLUMNFAMILY #{name} (%s)" % cql_definition
+        cql = "CREATE COLUMNFAMILY #{name} (#{cql_definition})"
 
         with_cql, *with_variables = @with_clause.call(with: with)
         cql << with_cql

data/lib/cassanity/argument_generators/column_family_drop.rb

@@ -10,7 +10,7 @@ module Cassanity
           name = "#{keyspace_name}.#{name}"
         end
 
-        cql = "DROP COLUMNFAMILY %s" % name
+        cql = "DROP COLUMNFAMILY #{name}"
         [cql]
       end
     end

data/lib/cassanity/argument_generators/keyspace_create.rb

@@ -1,12 +1,18 @@
+require 'cassanity/argument_generators/with_clause'
+
 module Cassanity
   module ArgumentGenerators
     class KeyspaceCreate
 
+      def initialize(args = {})
+        @with_clause = args.fetch(:with_clause) { WithClause.new }
+      end
+
       # Internal
       def call(args = {})
         options, variables = [], []
         name = args.fetch(:name)
-        cql = "CREATE KEYSPACE %s WITH " % name.to_s
+        cql = "CREATE KEYSPACE #{name}"
 
         with = {
           strategy_class: default_strategy_class,
@@ -17,20 +23,15 @@ module Cassanity
           with[:strategy_class] = args[:strategy_class]
         end
 
-        cql << "strategy_class = ? AND "
-        variables << with[:strategy_class]
-
         if args[:strategy_options]
           args[:strategy_options].each do |key, value|
             with[:strategy_options][key] = value
           end
         end
 
-        with[:strategy_options].each do |key, value|
-          options << "strategy_options:#{key} = ?"
-          variables << value
-        end
-        cql << options.join(' AND ')
+        with_cql, *with_variables = @with_clause.call(with: with)
+        cql << with_cql
+        variables.concat(with_variables)
 
         [cql, *variables]
       end

data/lib/cassanity/argument_generators/keyspace_drop.rb

@@ -5,7 +5,7 @@ module Cassanity
       # Internal
       def call(args = {})
         name = args.fetch(:name)
-        cql = "DROP KEYSPACE %s" % name
+        cql = "DROP KEYSPACE #{name}"
         [cql]
       end
     end

data/lib/cassanity/connection.rb

@@ -42,17 +42,11 @@ module Cassanity
     #
     # Returns Array of Cassanity::Keyspace instances.
     def keyspaces
-      keyspaces = []
-
-      result = @executor.call({
+      rows = @executor.call({
         command: :keyspaces,
       })
 
-      result.fetch_hash do |row|
-        keyspaces << row
-      end
-
-      keyspaces.map { |row|
+      rows.map { |row|
         Keyspace.new({
           name: row['name'],
           executor: @executor,
@@ -60,27 +54,22 @@ module Cassanity
       }
     end
 
-    # Public: Find out if a keyspace exists or not
-    #
-    # name - The String name of the keyspace
-    #
-    # Returns true if keyspace exists else false.
-    def keyspace?(name)
-      keyspaces.map(&:name).include?(name)
-    end
-
     # Public: Get a keyspace instance
     #
-    # name - The String name of the keyspace.
+    # name_or_args - The String name of the keyspace or a Hash which has a name
+    #                key and possibly other arguments.
+    # args - The Hash of arguments to use for Keyspace initialization.
+    #        (optional, default: {}). :executor is always included.
     #
     # Returns a Cassanity::Keyspace instance.
-    def keyspace(name, args = {})
-      keyspace_args = args.merge({
-        name: name,
-        executor: @executor,
-      })
+    def keyspace(name_or_args, args = {})
+      keyspace_args = if name_or_args.is_a?(Hash)
+        name_or_args.merge(args)
+      else
+        args.merge(name: name_or_args)
+      end
 
-      Keyspace.new(keyspace_args)
+      Keyspace.new(keyspace_args.merge(executor: executor))
     end
 
     alias_method :[], :keyspace

data/lib/cassanity/executors/cassandra_cql.rb

@@ -15,7 +15,7 @@ require 'cassanity/argument_generators/column_family_alter'
 require 'cassanity/argument_generators/index_create'
 require 'cassanity/argument_generators/index_drop'
 require 'cassanity/argument_generators/batch'
-require 'cassanity/result_transformers/column_family_select'
+require 'cassanity/result_transformers/result_to_array'
 require 'cassanity/result_transformers/mirror'
 
 module Cassanity
@@ -43,7 +43,8 @@ module Cassanity
 
       # Private: Hash of commands to related result transformers.
       ResultTransformers = {
-        column_family_select: Cassanity::ResultTransformers::ColumnFamilySelect.new,
+        column_family_select: Cassanity::ResultTransformers::ResultToArray.new,
+        keyspaces: Cassanity::ResultTransformers::ResultToArray.new,
       }
 
       # Private: Default result transformer for commands that do not have one.
@@ -62,6 +63,7 @@ module Cassanity
       #
       # args - The Hash of arguments.
       #        :client - The CassandraCQL::Database connection instance.
+      #        :logger - What to use to log the cql and such being executed.
       #        :argument_generators - A Hash where each key is a command name
       #                               and each value is the related argument
       #                               generator that responds to `call`
@@ -78,6 +80,7 @@ module Cassanity
       #
       def initialize(args = {})
         @client = args.fetch(:client)
+        @logger = args[:logger]
         @argument_generators = args.fetch(:argument_generators) { ArgumentGenerators }
         @result_transformers = args.fetch(:result_transformers) { ResultTransformers }
       end
@@ -106,6 +109,10 @@ module Cassanity
         generator = @argument_generators.fetch(command)
         execute_arguments = generator.call(args[:arguments])
 
+        if @logger
+          @logger.debug { "#{self.class} executing #{execute_arguments.inspect}" }
+        end
+
         result = @client.execute(*execute_arguments)
 
         transformer = @result_transformers.fetch(command) { Mirror }

data/lib/cassanity/keyspace.rb

@@ -31,6 +31,15 @@ module Cassanity
       @strategy_options = args[:strategy_options]
     end
 
+    # Public: Returns true or false depending on if keyspace exists in the
+    # current cluster.
+    #
+    # Returns true if keyspace exists, false if it does not.
+    def exists?
+      rows = @executor.call(command: :keyspaces)
+      rows.any? { |row| row['name'].to_s == name.to_s }
+    end
+
     # Public: Creates the keyspace
     #
     # args - The Hash of arguments to pass to the argument generator
@@ -59,6 +68,11 @@ module Cassanity
       })
     end
 
+    def recreate(args = {})
+      drop if exists?
+      create
+    end
+
     # Public: Uses a keyspace
     #
     # args - The Hash of arguments to pass to the argument generator
@@ -99,18 +113,20 @@ module Cassanity
 
     # Public: Get a column family instance
     #
-    # name - The String name of the column family.
+    # name_or_args - The String name of the column family or a Hash which has
+    #                the name key and possibly other arguments.
     # args - The Hash of arguments to use for ColumnFamily initialization
-    #        (optional, default: {}). :name and :keyspace are always included.
+    #        (optional, default: {}). :keyspace is always included.
     #
     # Returns a Cassanity::ColumnFamily instance.
-    def column_family(name, args = {})
-      column_family_args = args.merge({
-        name: name,
-        keyspace: self,
-      })
+    def column_family(name_or_args, args = {})
+      column_family_args = if name_or_args.is_a?(Hash)
+        name_or_args.merge(args)
+      else
+        args.merge(name: name_or_args)
+      end
 
-      ColumnFamily.new(column_family_args)
+      ColumnFamily.new(column_family_args.merge(keyspace: self))
     end
     alias_method :table, :column_family
     alias_method :[], :column_family

data/lib/cassanity/result_transformers/{column_family_select.rb → result_to_array.rb}

@@ -1,6 +1,6 @@
 module Cassanity
   module ResultTransformers
-    class ColumnFamilySelect
+    class ResultToArray
 
       # Internal: Turns result into Array of Hashes.
       def call(result)

data/lib/cassanity/schema.rb

@@ -1,7 +1,10 @@
 module Cassanity
   class Schema
     # Internal
-    attr_reader :primary_key
+    attr_reader :primary_keys
+
+    # Internal
+    alias_method :primary_key, :primary_keys
 
     # Internal
     attr_reader :columns
@@ -17,10 +20,44 @@ module Cassanity
     #        :columns - The Hash of columns where the name is the column name
     #                   and the value is the column type.
     #        :with - The Hash of options for the WITH clause.
+    # Raises KeyError if missing required argument key.
+    # Raises ArgumentError if primary key is not included in the columns.
     def initialize(args = {})
-      @primary_key = args.fetch(:primary_key)
+      @primary_keys = Array(args.fetch(:primary_key))
       @columns = args.fetch(:columns)
+
+      ensure_primary_keys_are_columns
+
       @with = args[:with] || {}
+      @composite_primary_key = @primary_keys.size > 1
+    end
+
+    # Public
+    def composite_primary_key?
+      @composite_primary_key == true
+    end
+
+    # Public: Returns an array of the column names
+    def column_names
+      @column_names ||= @columns.keys
+    end
+
+    # Public: Returns an array of the column types
+    def column_types
+      @column_types ||= @columns.values
+    end
+
+    # Private
+    def ensure_primary_keys_are_columns
+      unless primary_keys_are_defined_as_columns?
+        raise ArgumentError, "Not all primary keys (#{primary_keys.inspect}) were defined as columns (#{column_names.inspect})"
+      end
+    end
+
+    # Private
+    def primary_keys_are_defined_as_columns?
+      shared_columns = column_names & @primary_keys
+      shared_columns == @primary_keys
     end
   end
 end

data/lib/cassanity/version.rb

@@ -1,3 +1,3 @@
 module Cassanity
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/spec/integration/cassanity/connection_spec.rb

@@ -78,10 +78,4 @@ describe Cassanity::Connection do
     client_drop_keyspace(client, 'something1')
     client_drop_keyspace(client, 'something2')
   end
-
-  it "knows if a keyspace exists" do
-    subject.keyspace?(keyspace_name).should be_false
-    client_create_keyspace(client, keyspace_name)
-    subject.keyspace?(keyspace_name).should be_true
-  end
 end

data/spec/integration/cassanity/keyspace_spec.rb

@@ -49,6 +49,25 @@ describe Cassanity::Keyspace do
     client_keyspace?(client, self_created_keyspace_name).should be_true
   end
 
+  it "knows if it exists" do
+    subject.exists?.should be_true
+    client_drop_keyspace(client, keyspace_name)
+    subject.exists?.should be_false
+  end
+
+  it "can recreate when not created" do
+    client_drop_keyspace(client, keyspace_name)
+    client_keyspace?(client, keyspace_name).should be_false
+    subject.recreate
+    client_keyspace?(client, keyspace_name).should be_true
+  end
+
+  it "can recreate when already created" do
+    client_keyspace?(client, keyspace_name).should be_true
+    subject.recreate
+    client_keyspace?(client, keyspace_name).should be_true
+  end
+
   it "can use" do
     client.execute("USE system")
     client.keyspace.should_not eq(keyspace_name)

data/spec/unit/cassanity/connection_spec.rb

@@ -38,21 +38,31 @@ describe Cassanity::Connection do
   end
 
   describe "#keyspace" do
-    before do
-      @return_value = subject.keyspace(keyspace_name)
-    end
+    context "with only name" do
+      before do
+        @return_value = subject.keyspace(keyspace_name)
+      end
 
-    it "returns instance of keyspace" do
-      @return_value.should be_instance_of(Cassanity::Keyspace)
+      it "returns instance of keyspace" do
+        @return_value.should be_instance_of(Cassanity::Keyspace)
+      end
+
+      it "sets name" do
+        @return_value.name.should eq(keyspace_name)
+      end
     end
 
-    context "with args" do
+    context "with name and args" do
       before do
         @return_value = subject.keyspace(keyspace_name, {
           strategy_class: 'NetworkTopologyStrategy',
         })
       end
 
+      it "correctly sets name" do
+        @return_value.name.should eq(keyspace_name)
+      end
+
       it "passes args to initialization" do
         @return_value.strategy_class.should eq('NetworkTopologyStrategy')
       end
@@ -61,6 +71,49 @@ describe Cassanity::Connection do
         @return_value.should be_instance_of(Cassanity::Keyspace)
       end
     end
+
+    context "with single hash" do
+      before do
+        @return_value = subject.keyspace({
+          name: keyspace_name,
+          strategy_class: 'NetworkTopologyStrategy',
+        })
+      end
+
+      it "returns instance of keyspace" do
+        @return_value.should be_instance_of(Cassanity::Keyspace)
+      end
+
+      it "correctly sets name" do
+        @return_value.name.should eq(keyspace_name)
+      end
+
+      it "passes args to initialization" do
+        @return_value.strategy_class.should eq('NetworkTopologyStrategy')
+      end
+    end
+
+    context "with two hashes" do
+      before do
+        @return_value = subject.keyspace({
+          name: keyspace_name,
+        }, {
+          strategy_class: 'NetworkTopologyStrategy',
+        })
+      end
+
+      it "returns instance of keyspace" do
+        @return_value.should be_instance_of(Cassanity::Keyspace)
+      end
+
+      it "correctly sets name" do
+        @return_value.name.should eq(keyspace_name)
+      end
+
+      it "passes args to initialization" do
+        @return_value.strategy_class.should eq('NetworkTopologyStrategy')
+      end
+    end
   end
 
   describe "#[]" do

data/spec/unit/cassanity/executors/cassandra_cql_spec.rb

@@ -105,6 +105,44 @@ describe Cassanity::Executors::CassandraCql do
         subject.call(args)
       end
 
+      context "with logger" do
+        let(:logger) {
+          Class.new do
+            attr_reader :logs
+
+            def initialize
+              @logs = []
+            end
+
+            def debug
+              @logs << {debug: yield}
+            end
+          end.new
+        }
+
+        subject {
+          described_class.new(required_arguments.merge({
+            argument_generators: argument_generators,
+            logger: logger,
+          }))
+        }
+
+        it "logs executed arguments" do
+          args = {
+            command: :foo,
+            arguments: {
+              something: 'else',
+            },
+          }
+
+          subject.call(args)
+
+          logger.logs.should eq([
+            {debug: 'Cassanity::Executors::CassandraCql executing ["mapped", {:something=>"else"}]'},
+          ])
+        end
+      end
+
       context "with result transformer" do
         subject {
           described_class.new(required_arguments.merge({

data/spec/unit/cassanity/keyspace_spec.rb

@@ -62,15 +62,21 @@ describe Cassanity::Keyspace do
   describe "#column_family" do
     let(:column_family_name) { 'apps' }
 
-    before do
-      @return_value = subject.column_family(column_family_name)
-    end
+    context "with only name" do
+      before do
+        @return_value = subject.column_family(column_family_name)
+      end
 
-    it "returns instance of column family" do
-      @return_value.should be_instance_of(Cassanity::ColumnFamily)
+      it "returns instance of column family" do
+        @return_value.should be_instance_of(Cassanity::ColumnFamily)
+      end
+
+      it "sets name" do
+        @return_value.name.should eq(column_family_name)
+      end
     end
 
-    context "with args" do
+    context "with name and hash" do
       let(:schema) { double('Schema') }
 
       before do
@@ -83,6 +89,57 @@ describe Cassanity::Keyspace do
         @return_value.schema.should eq(schema)
       end
 
+      it "sets name" do
+        @return_value.name.should eq(column_family_name)
+      end
+
+      it "returns instance of column family" do
+        @return_value.should be_instance_of(Cassanity::ColumnFamily)
+      end
+    end
+
+    context "with hash" do
+      let(:schema) { double('Schema') }
+
+      before do
+        @return_value = subject.column_family({
+          name: column_family_name,
+          schema: schema,
+        })
+      end
+
+      it "passes args to initialization" do
+        @return_value.schema.should eq(schema)
+      end
+
+      it "sets name" do
+        @return_value.name.should eq(column_family_name)
+      end
+
+      it "returns instance of column family" do
+        @return_value.should be_instance_of(Cassanity::ColumnFamily)
+      end
+    end
+
+    context "with two hashes" do
+      let(:schema) { double('Schema') }
+
+      before do
+        @return_value = subject.column_family({
+          name: column_family_name,
+        }, {
+          schema: schema,
+        })
+      end
+
+      it "passes args to initialization" do
+        @return_value.schema.should eq(schema)
+      end
+
+      it "sets name" do
+        @return_value.name.should eq(column_family_name)
+      end
+
       it "returns instance of column family" do
         @return_value.should be_instance_of(Cassanity::ColumnFamily)
       end
@@ -96,6 +153,10 @@ describe Cassanity::Keyspace do
       @return_value = subject.table(column_family_name)
     end
 
+    it "sets name" do
+      @return_value.name.should eq(column_family_name)
+    end
+
     it "returns instance of column family" do
       @return_value.should be_instance_of(Cassanity::ColumnFamily)
     end
@@ -108,11 +169,80 @@ describe Cassanity::Keyspace do
       @return_value = subject[column_family_name]
     end
 
+    it "sets name" do
+      @return_value.name.should eq(column_family_name)
+    end
+
     it "returns instance of column family" do
       @return_value.should be_instance_of(Cassanity::ColumnFamily)
     end
   end
 
+  describe "#exists?" do
+    it "returns true if name in existing keyspace names" do
+      executor.should_receive(:call).with(command: :keyspaces).and_return([
+        {'name' => keyspace_name.to_s},
+      ])
+      subject.exists?.should be_true
+    end
+
+    it "returns false if name not in existing keyspace names" do
+      executor.should_receive(:call).with(command: :keyspaces).and_return([
+        {'name' => 'batman'},
+      ])
+      subject.exists?.should be_false
+    end
+
+    it "returns false if no keyspaces" do
+      executor.should_receive(:call).with(command: :keyspaces).and_return([])
+      subject.exists?.should be_false
+    end
+  end
+
+  describe "#create" do
+    it "sends command and arguments, including :name, to executor" do
+      args = {something: 'else'}
+      executor.should_receive(:call).with({
+        command: :keyspace_create,
+        arguments: args.merge(name: keyspace_name),
+      })
+      subject.create(args)
+    end
+  end
+
+  describe "#recreate" do
+    context "for existing keyspace" do
+      before do
+        subject.stub(:exist? => true)
+      end
+      it "performs drop" do
+        subject.should_not_receive(:drop)
+        subject.recreate
+      end
+
+      it "performs create" do
+        subject.should_receive(:create)
+        subject.recreate
+      end
+    end
+
+    context "for non-existing keyspace" do
+      before do
+        subject.stub(:exist? => false)
+      end
+
+      it "does not perform drop" do
+        subject.should_not_receive(:drop)
+        subject.recreate
+      end
+
+      it "performs create" do
+        subject.should_receive(:create)
+        subject.recreate
+      end
+    end
+  end
+
   describe "#use" do
     it "sends command and arguments, including :name, to executor" do
       args = {something: 'else'}

data/spec/unit/cassanity/result_transformers/result_to_array_spec.rb

@@ -0,0 +1,28 @@
+require 'helper'
+require 'cassanity/result_transformers/result_to_array'
+
+describe Cassanity::ResultTransformers::ResultToArray do
+  let(:result_array) {
+    [{one: 1}, {two: 2}, {three: 3}]
+  }
+
+  let(:result) {
+    Class.new do
+      def initialize(array)
+        @array = array
+      end
+
+      def fetch_hash
+        @array.each do |row|
+          yield row
+        end
+      end
+    end.new(result_array)
+  }
+
+  describe "#call" do
+    it "it iterates fetch_hash and returns array" do
+      subject.call(result).should eq(result_array)
+    end
+  end
+end

data/spec/unit/cassanity/schema_spec.rb

@@ -12,6 +12,22 @@ describe Cassanity::Schema do
     }
   }
 
+  let(:composite_required_arguments) {
+    {
+      primary_key: [:bucket, :id],
+      columns: {
+        bucket: :text,
+        id: :text,
+        name: :text,
+      }
+    }
+  }
+
+  let(:schema) { described_class.new(required_arguments) }
+  let(:composite_schema) { described_class.new(composite_required_arguments) }
+
+  subject { schema }
+
   describe "#initialize" do
     [:primary_key, :columns].each do |key|
       it "raises error without :#{key} key" do
@@ -19,5 +35,84 @@ describe Cassanity::Schema do
         expect { described_class.new(args) }.to raise_error(KeyError)
       end
     end
+
+    it "raises error if primary_keys are not all included in columns" do
+      args = required_arguments.merge({
+        primary_key: [:foo, :bar],
+        columns: {
+          id: :text,
+        }
+      })
+
+      expect {
+        described_class.new(args)
+      }.to raise_error(ArgumentError, "Not all primary keys ([:foo, :bar]) were defined as columns ([:id])")
+    end
+  end
+
+  describe "#column_names" do
+    it "returns array of column names" do
+      subject.column_names.should eq([:id, :name])
+    end
+  end
+
+  describe "#column_types" do
+    it "returns array of column types" do
+      subject.column_types.should eq([:text, :text])
+    end
+  end
+
+  describe "#primary_keys" do
+    context "with single primary key" do
+      subject { schema }
+
+      it "returns array of primary keys" do
+        subject.primary_keys.should eq([:id])
+      end
+    end
+
+    context "with composite primary key" do
+      subject { composite_schema }
+
+      it "returns array of primary keys" do
+        subject.primary_keys.should eq([:bucket, :id])
+      end
+    end
+  end
+
+  describe "#primary_key" do
+    context "with single primary key" do
+      subject { schema }
+
+      it "returns array of primary keys" do
+        subject.primary_key.should eq([:id])
+      end
+    end
+
+    context "with composite primary key" do
+      subject { composite_schema }
+
+      it "returns array of primary keys" do
+        subject.primary_key.should eq([:bucket, :id])
+      end
+    end
+  end
+
+  describe "#composite_primary_key?" do
+    context "with single primary key" do
+      subject { schema }
+
+      it "returns returns false" do
+        subject.composite_primary_key?.should be_false
+      end
+    end
+
+    context "with composite primary key" do
+      subject { composite_schema }
+
+      it "returns true" do
+        subject.composite_primary_key?.should be_true
+      end
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cassanity
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-06 00:00:00.000000000 Z
+date: 2012-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cassandra-cql
@@ -73,8 +73,8 @@ files:
 - lib/cassanity/error.rb
 - lib/cassanity/executors/cassandra_cql.rb
 - lib/cassanity/keyspace.rb
-- lib/cassanity/result_transformers/column_family_select.rb
 - lib/cassanity/result_transformers/mirror.rb
+- lib/cassanity/result_transformers/result_to_array.rb
 - lib/cassanity/schema.rb
 - lib/cassanity/version.rb
 - spec/helper.rb
@@ -106,11 +106,11 @@ files:
 - spec/unit/cassanity/error_spec.rb
 - spec/unit/cassanity/executors/cassandra_cql_spec.rb
 - spec/unit/cassanity/keyspace_spec.rb
-- spec/unit/cassanity/result_transformers/column_family_select_spec.rb
 - spec/unit/cassanity/result_transformers/mirror_spec.rb
+- spec/unit/cassanity/result_transformers/result_to_array_spec.rb
 - spec/unit/cassanity/schema_spec.rb
 - spec/unit/cassanity_spec.rb
-homepage: https://github.com/jnunemaker/cassanity/
+homepage: http://johnnunemaker.com/cassanity/
 licenses: []
 post_install_message: 
 rdoc_options: []
@@ -122,12 +122,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -3410109094406772154
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -3410109094406772154
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
@@ -165,8 +171,7 @@ test_files:
 - spec/unit/cassanity/error_spec.rb
 - spec/unit/cassanity/executors/cassandra_cql_spec.rb
 - spec/unit/cassanity/keyspace_spec.rb
-- spec/unit/cassanity/result_transformers/column_family_select_spec.rb
 - spec/unit/cassanity/result_transformers/mirror_spec.rb
+- spec/unit/cassanity/result_transformers/result_to_array_spec.rb
 - spec/unit/cassanity/schema_spec.rb
 - spec/unit/cassanity_spec.rb
-has_rdoc: