cassandra-mapper 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f2057b9a950ab60c08bff745c6a8cf5fc2492d98
+  data.tar.gz: 729c987811f2ab5caa1ebff77ea538977ff2a4e0
+SHA512:
+  metadata.gz: 25cc8d2cc84656054045c228ef11e49e93a407acf514ed5bf5ddf8b55a9f970c3d471f2f5f23cf18fc94396ada1b710e2082955122d08bb3e81aaed3d42264c7
+  data.tar.gz: c37205509f6be2ba0cf25faf0573f74fa0fe0810a3680cbe57029a1360750f627db801789b294f293ef71060047cd4556391e8a95387ad15a3dc88d39563073a

data/.gitignore

@@ -0,0 +1,2 @@
+Gemfile.lock
+pkg

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - jruby-19mode
+  - rbx-19mode
+services:
+  - cassandra
+matrix:
+  allow_failures:
+    - rvm: rbx-19mode
+before_install:
+  - sudo sh -c "echo 'JVM_OPTS=\"\${JVM_OPTS} -Djava.net.preferIPv4Stack=false\"' >> /usr/local/cassandra/conf/cassandra-env.sh"
+  - sudo service cassandra start

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 brainopia
+
+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,8 @@
+# Cassandra::Mapper
+
+Abstractions to work with cassandra. Currently under development.
+
+[![Build
+Status](https://secure.travis-ci.org/brainopia/cassandra-mapper.png)](http://travis-ci.org/brainopia/cassandra-mapper)
+[![Code
+Climate](https://codeclimate.com/github/brainopia/cassandra-mapper.png)](https://codeclimate.com/github/brainopia/cassandra-mapper)

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new :default

data/cassandra-mapper.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |gem|
+  gem.name          = 'cassandra-mapper'
+  gem.version       = '0.1'
+  gem.authors       = 'brainopia'
+  gem.email         = 'brainopia@evilmartians.com'
+  gem.homepage      = 'https://github.com/brainopia/cassandra-mapper'
+  gem.summary       = 'Cassandra mapper'
+  gem.description   = <<-DESCRIPTION
+    Work with cassandra in datamapper style.
+  DESCRIPTION
+
+  gem.files         = `git ls-files`.split($/)
+  gem.test_files    = gem.files.grep %r{^spec/}
+  gem.require_paths = %w(lib)
+
+  gem.add_dependency 'cassandra', '~> 0.18.0'
+  gem.add_dependency 'multi_json', '~> 1.0'
+  gem.add_development_dependency 'rspec'
+end

data/lib/cassandra/mapper.rb

@@ -0,0 +1,41 @@
+require 'bigdecimal'
+require 'time'
+require 'cassandra'
+
+Cassandra::THRIFT_DEFAULTS.merge! \
+  connect_timeout: 1, timeout: 1
+
+class Cassandra::Mapper
+  require_relative 'mapper/convert'
+  require_relative 'mapper/data/request'
+  require_relative 'mapper/data/insert'
+  require_relative 'mapper/data/remove'
+  require_relative 'mapper/data/response'
+
+  require_relative 'mapper/extend/schema'
+  require_relative 'mapper/extend/migrate'
+  require_relative 'mapper/extend/queries'
+
+  require_relative 'mapper/utility/hash'
+  require_relative 'mapper/utility/delegate_keys'
+  require_relative 'mapper/utility/config'
+  require_relative 'mapper/utility/store_instances'
+
+  extend Utility::StoreInstances
+
+  attr_reader :table, :config
+
+  def initialize(keyspace, table, &block)
+    @keyspace = keyspace.to_s
+    @table    = table.to_s
+    @config   = Utility::Config.new(&block)
+  end
+
+  def keyspace
+    Thread.current["keyspace_#{keyspace_name}"] ||= Cassandra.new keyspace_name
+  end
+
+  def keyspace_name
+    "#{@keyspace}_#{env}"
+  end
+end

data/lib/cassandra/mapper/convert.rb

@@ -0,0 +1,95 @@
+module Cassandra::Mapper::Convert
+  extend self
+
+  TEXT_TYPE = 'UTF8Type'
+  TYPES     = {
+    uuid:     'TimeUUIDType',
+    integer:  'Int32Type',
+    time:     'DateType'
+  }
+
+  def type(symbol)
+    TYPES.fetch symbol, TEXT_TYPE
+  end
+
+  def to(type, value)
+    send "to_#{type}", value
+  end
+
+  def from(type, value)
+    send "from_#{type}", value
+  end
+
+  def round(type, value)
+    from type, to(type, value)
+  end
+
+  private
+
+  def to_(value)
+    value.to_s
+  end
+
+  def from_(value)
+    value.force_encoding Encoding::UTF_8
+  end
+
+  def to_uuid(value)
+    value = Time.parse value if value.is_a? String
+    SimpleUUID::UUID.new(value).to_s
+  end
+
+  def from_uuid(value)
+    SimpleUUID::UUID.new(value).to_time
+  end
+
+  def to_integer(value)
+    [value.to_i].pack('N')
+  end
+
+  def from_integer(value)
+    value.unpack('N').first
+  end
+
+  def to_boolean(value)
+    value ? 'on' : 'off'
+  end
+
+  def from_boolean(value)
+    value == 'on' ? true : false
+  end
+
+  def to_time(value)
+    value = Time.parse value if value.is_a? String
+    value = value.to_time if value.is_a? Date
+    [(value.to_f * 1000).to_i].pack('Q>')
+  end
+
+  def from_time(value)
+    Time.at(value.unpack('Q>').first.to_f / 1000)
+  end
+
+  def to_decimal(value)
+    value.to_s
+  end
+
+  def from_decimal(value)
+    BigDecimal value
+  end
+
+  def to_json(value)
+    MultiJson.dump value
+  end
+
+  def from_json(value)
+    MultiJson.load value
+  end
+
+  def to_float(value)
+    value.to_s
+  end
+
+  def from_float(value)
+    value.to_f
+  end
+end

data/lib/cassandra/mapper/data/insert.rb

@@ -0,0 +1,28 @@
+class Cassandra::Mapper::Data
+  class Insert < Request
+    def initialize(_config, data)
+      @request = data.dup
+      super
+    end
+
+    def convert!(data)
+      config.before_insert.each {|it| it.call data }
+      super
+    end
+
+    def return!
+      converted.tap do |data|
+        config.after_insert.each {|it| it.call data }
+      end
+    end
+
+    private
+
+    def converted
+      @request.each_with_object({}) do |(field, value), converted|
+        next unless value
+        converted[field] = Cassandra::Mapper::Convert.round config.types[field], value
+      end
+    end
+  end
+end

data/lib/cassandra/mapper/data/remove.rb

@@ -0,0 +1,18 @@
+class Cassandra::Mapper::Data
+  class Remove < Insert
+    def convert!(data)
+      config.before_remove.each {|it| it.call data }
+      super
+    end
+
+    def columns
+      super.keys
+    end
+
+    def return!
+      converted.tap do |data|
+        config.after_remove.each {|it| it.call data }
+      end
+    end
+  end
+end

data/lib/cassandra/mapper/data/request.rb

@@ -0,0 +1,49 @@
+class Cassandra::Mapper::Data
+  class Request
+    KEY_SEPARATOR = '##'
+
+    attr_reader :keys, :subkeys, :data, :config
+
+    def initialize(config, data)
+      @config  = config
+      @data    = convert! data.dup
+      @keys    = extract! :key
+      @subkeys = extract! :subkey
+    end
+
+    def packed_keys
+      keys.join(KEY_SEPARATOR).force_encoding('binary')
+    end
+
+    def columns
+      fields = data.empty? ? { '' => '' } : data
+      fields.each_with_object({}) do |(field, value), columns|
+        columns[composite *subkeys, field.to_s] = value
+      end
+    end
+
+    def query(offset=nil)
+      return { start: offset } if offset
+      return if subkeys.all? &:empty?
+      { start:  composite(*subkeys),
+        finish: composite(*subkeys, slice: :after) }
+    end
+
+    private
+
+    def composite(*args)
+      Cassandra::Composite.new *args
+    end
+
+    def extract!(option)
+      config.send(option).map {|it| data.delete(it).to_s }
+    end
+
+    def convert!(data)
+      data.delete_if {|_, value| value.nil? }
+      data.each do |field, value|
+        data[field] = Cassandra::Mapper::Convert.to config.types[field], value
+      end
+    end
+  end
+end

data/lib/cassandra/mapper/data/response.rb

@@ -0,0 +1,40 @@
+class Cassandra::Mapper::Data
+  class Response
+    attr_reader :config, :key_values, :columns
+
+    def initialize(config, key_values, columns)
+      @config     = config
+      @key_values = key_values
+      @columns    = columns
+    end
+
+    def keys
+      Hash[config.key.zip key_values]
+    end
+
+    def subkeys(values)
+      Hash[config.subkey.zip values]
+    end
+
+    def unpack
+      return [] if columns.empty?
+      records = columns.group_by {|composite, _| composite[0..-2] }
+      records.map do |subkey_values, fields|
+        record = keys.merge subkeys(subkey_values)
+        fields.each do |composite, value|
+          field = composite[-1]
+          record[field.to_sym] = value unless field.empty?
+        end
+        convert! record
+      end
+    end
+
+    private
+
+    def convert!(data)
+      data.each do |field, value|
+        data[field] = Cassandra::Mapper::Convert.from config.types[field], value
+      end
+    end
+  end
+end

data/lib/cassandra/mapper/extend/migrate.rb

@@ -0,0 +1,31 @@
+class Cassandra::Mapper
+  def self.migrate
+    cassandra = Cassandra.new('system')
+    schema[:keyspaces].each do |name|
+      options  = schema.fetch(env, {}).fetch(name, {})
+      options  = Utility::Hash.stringify_keys options
+      strategy = options.delete('strategy') || 'SimpleStrategy'
+      options['replication_factor'] = options.fetch('replication_factor', 1).to_s
+
+      cassandra.add_keyspace Cassandra::Keyspace.new \
+        name:             "#{name}_#{env}",
+        strategy_class:   strategy,
+        strategy_options: options,
+        cf_defs:          []
+    end
+  end
+
+  def migrate
+    subkey_types = config.subkey.map do |it|
+      Convert.type config.types[it]
+    end
+
+    # field subkey
+    subkey_types.push Convert::TEXT_TYPE
+
+    keyspace.add_column_family Cassandra::ColumnFamily.new \
+      keyspace:        keyspace.keyspace,
+      name:            table,
+      comparator_type: "CompositeType(#{subkey_types.join ','})"
+  end
+end

data/lib/cassandra/mapper/extend/queries.rb

@@ -0,0 +1,56 @@
+class Cassandra::Mapper
+  BATCH_SIZE = 500
+
+  def insert(hash)
+    data = Data::Insert.new config, hash
+    keyspace.insert table, data.packed_keys, data.columns
+    data.return!
+  end
+
+  def remove(hash)
+    data = Data::Remove.new config, hash
+    keyspace.remove table, data.packed_keys, data.columns
+    data.return!
+  end
+
+  def get(query)
+    request  = Data::Request.new config, query
+    columns  = columns_for request
+    response = Data::Response.new config, request.keys, columns
+    response.unpack
+  end
+
+  def one(keys)
+    get(keys).first
+  end
+
+  def each(&block)
+    keyspace.each_key table do |packed_keys|
+      keys = unpack_keys packed_keys
+      get(keys).each &block
+    end
+  end
+
+  def all
+    to_enum.to_a
+  end
+
+  private
+
+  def columns_for(request, offset=nil)
+    columns = keyspace.get table, request.packed_keys, request.query(offset)
+    columns ||= {}
+    if columns.size == BATCH_SIZE
+      columns.merge! columns_for(request, columns.keys.last)
+    end
+    columns
+  end
+
+  def unpack_keys(packed_keys)
+    keys = packed_keys.split Data::Request::KEY_SEPARATOR
+    keys = Hash[config.key.zip(keys)]
+    keys.each do |field, value|
+      keys[field] = Convert.from config.types[field], value
+    end
+  end
+end

data/lib/cassandra/mapper/extend/schema.rb

@@ -0,0 +1,21 @@
+class Cassandra::Mapper
+  def self.schema
+    @@schema
+  end
+
+  def self.schema=(schema)
+    @@schema = Utility::Hash.symbolize_keys schema
+  end
+
+  def self.env
+    @@env
+  end
+
+  def self.env=(env)
+    @@env = env.to_sym
+  end
+
+  def env
+    @@env
+  end
+end

data/lib/cassandra/mapper/utility/config.rb

@@ -0,0 +1,56 @@
+module Cassandra::Mapper::Utility
+  class Config
+    extend DelegateKeys
+    delegate_keys 'dsl.options', :key, :subkey, :types, :before_insert,
+                                 :after_insert, :after_remove, :before_remove
+
+    attr_reader :dsl
+
+    def initialize(&block)
+      @dsl = DSL.new &block
+    end
+
+    class DSL
+      attr_reader :options
+
+      def initialize(&block)
+        @options = {
+          types: {},
+          before_insert: [],
+          after_insert: [],
+          after_remove: [],
+          before_remove: []
+        }
+        instance_eval &block
+      end
+
+      def key(*fields)
+        @options[:key] = fields
+      end
+
+      def subkey(*fields)
+        @options[:subkey] = fields
+      end
+
+      def type(field, type)
+        @options[:types][field] = type
+      end
+
+      def before_insert(&block)
+        @options[:before_insert].push block
+      end
+
+      def before_remove(&block)
+        @options[:before_remove].push block
+      end
+
+      def after_insert(&block)
+        @options[:after_insert].push block
+      end
+
+      def after_remove(&block)
+        @options[:after_remove].push block
+      end
+    end
+  end
+end

data/lib/cassandra/mapper/utility/delegate_keys.rb

@@ -0,0 +1,13 @@
+module Cassandra::Mapper::Utility
+  module DelegateKeys
+    def delegate_keys(target, *keys)
+      keys.each do |key|
+        class_eval <<-RUBY
+          def #{key}
+            #{target}[:#{key}]
+          end
+        RUBY
+      end
+    end
+  end
+end

data/lib/cassandra/mapper/utility/hash.rb

@@ -0,0 +1,22 @@
+module Cassandra::Mapper::Utility
+  module Hash
+    extend self
+
+    def symbolize_keys(hash)
+      map_hash_key hash, &:to_sym
+    end
+
+    def stringify_keys(hash)
+      map_hash_key hash, &:to_s
+    end
+
+    private
+
+    def map_hash_key(hash)
+      hash.keys.each do |key|
+        hash[yield key] = hash.delete key
+      end
+      hash
+    end
+  end
+end

data/lib/cassandra/mapper/utility/store_instances.rb

@@ -0,0 +1,13 @@
+module Cassandra::Mapper::Utility
+  module StoreInstances
+    def self.extended(klass)
+      klass.instance_variable_set :@instances, []
+    end
+
+    attr_reader :instances
+
+    def new(*)
+      super.tap {|it| @instances << it }
+    end
+  end
+end

data/spec/cassandra/mapper/convert_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Cassandra::Mapper::Convert do
+  context 'uuid' do
+    let(:time) { Time.now.round }
+
+    it '#to' do
+      subject.to(:uuid, time).should have(16).bytes
+    end
+
+    it '#from' do
+      uuid = subject.to(:uuid, time)
+      subject.from(:uuid, uuid).should == time
+    end
+  end
+
+  context 'integer' do
+    let(:number) { 17 }
+    let(:cassandra_format) { "\x00\x00\x00\x11" }
+
+    it '#to' do
+      subject.to(:integer, number).should == cassandra_format
+    end
+
+    it '#from' do
+      subject.from(:integer, cassandra_format) == number
+    end
+  end
+
+  context 'time' do
+    context 'empty' do
+      it '#to' do
+        expect { subject.to(:time, '') }.to raise_error(ArgumentError)
+      end
+    end
+
+    let(:time) { Time.at((Time.now.to_f * 1000).to_i / 1000) }
+
+    it '#from' do
+      formatted = subject.to(:time, time)
+      subject.from(:time, formatted).should == time
+    end
+  end
+end

data/spec/cassandra/mapper/utility/config_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Cassandra::Mapper::Utility::Config do
+  subject do
+    described_class.new do
+      key :key1, :key2
+      subkey :subkey1, :subkey2
+      type :field, :integer
+    end
+  end
+
+  its(:key)    { should == [:key1, :key2] }
+  its(:subkey) { should == [:subkey1, :subkey2] }
+  its(:types)  { should == { field: :integer }}
+end

data/spec/cassandra/mapper/utility/store_instances_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Cassandra::Mapper::Utility::StoreInstances do
+  let(:subject) { Class.new.tap {|it| it.extend described_class }}
+
+  it 'should initialize instances with array' do
+    subject.instances.should == []
+  end
+
+  it 'should track new instances' do
+    object1 = subject.new
+    object2 = subject.new
+
+    subject.instances.should == [object1, object2]
+  end
+end

data/spec/cassandra/mapper_spec.rb

@@ -0,0 +1,231 @@
+require 'spec_helper'
+
+describe Cassandra::Mapper do
+  subject do
+    described_class.new :mapper, table, &definition
+  end
+
+  before do
+    subject.keyspace.drop_column_family table.to_s rescue nil
+    subject.migrate
+  end
+
+  let(:table) { :common }
+
+  context 'one subkey' do
+    let :definition do
+      proc do
+        key :field1
+        subkey :field2
+        type :field1, :integer
+        type :field2, :integer
+        type :field3, :integer
+      end
+    end
+
+    context '.insert/.get' do
+      let(:field1) { 1 }
+      let(:field2) { 2 }
+      let(:field3) { 3 }
+      let(:keys) {{ field1: field1, field2: field2 }}
+
+      it 'only keys' do
+        subject.insert keys
+        subject.one(keys).should == keys
+      end
+
+      it 'with data' do
+        payload = keys.merge(field3: field3)
+        subject.insert(payload).should == payload
+        subject.one(keys).should == payload
+      end
+
+      it 'nil data field' do
+        payload = keys.merge(field3: nil, field4: nil)
+        converted_payload = subject.insert(payload)
+        converted_payload.should == keys
+        subject.one(keys).should == keys
+      end
+    end
+
+    context 'various commands' do
+      let(:first) {{ field1: 1, field2: 1, data: 'payload1' }}
+      let(:second) {{ field1: 1, field2: 2, data: 'payload2' }}
+      let(:data) {[ first, second ]}
+
+      before { data.each &subject.method(:insert) }
+
+      it '.each' do
+        subject.to_enum.to_a.should == data
+      end
+
+      it '.delete' do
+        subject.get(field1: 1).should have(2).items
+        subject.remove(first)
+        subject.get(field1: 1).should == [second]
+        subject.remove(second)
+        subject.get(field1: 1).should be_empty
+      end
+    end
+  end
+
+  context 'callbacks' do
+    let :definition do
+      proc do
+        key :field1
+        subkey :field2
+        type :field2, :integer
+      end
+    end
+
+    it '.before_insert' do
+      subject.config.dsl.before_insert do |data|
+        data[:field1] = data[:field2]
+      end
+      subject.insert field2: 2
+      subject.one(field1: '2').should == { field1: '2', field2: 2 }
+    end
+
+    it '.after_insert' do
+      subject.config.dsl.after_insert do |data|
+        data.should == { field1: '1', field2: 2 }
+      end
+      subject.insert field1: 1, field2: '2'
+    end
+
+    it '.after_remove' do
+      subject.config.dsl.after_remove do |data|
+        data.should == { field1: '1', field2: 2 }
+      end
+      subject.insert field1: 1, field2: '2'
+      subject.remove field1: 1, field2: '2'
+    end
+  end
+
+  context 'conversions' do
+    let :definition do
+      scope = self
+      proc do
+        key *scope.key
+        subkey *scope.subkey
+        type :field, scope.type
+      end
+    end
+
+    def self.converts(type, original, expected=original, &block)
+      context "converts #{type}" do
+        let(:original) { original }
+        let(:expected) { expected }
+        let(:compare)  { block or -> it { it }}
+        it_behaves_like :type
+      end
+    end
+
+    shared_examples_for :convertable do
+      context 'default text type' do
+        let(:type) { nil }
+        converts 'integer', 2, '2'
+        converts 'string', 'string'
+      end
+
+      context 'integer type' do
+        let(:type) { :integer }
+        converts 'integer', 2
+        converts 'big integer', 1_000_000
+        converts 'string', '32', 32
+      end
+
+      context 'boolean type' do
+        let(:type) { :boolean }
+        converts 'true', true
+        converts 'false', false
+      end
+
+      context 'time' do
+        let(:type) { :time }
+        converts 'time', Time.now.round
+        converts('date', Date.today) {|time| time.to_date }
+      end
+
+      context 'decimal' do
+        let(:type) { :decimal }
+        converts 'integer', 20
+        converts 'float', 30.442
+        converts 'decimal', BigDecimal('42.42')
+      end
+
+      context 'float' do
+        let(:type) { :float }
+        converts 'integer', 20
+        converts 'float', 30.30
+      end
+    end
+
+    shared_examples_for :uuid_convertable do
+      context 'uuid' do
+        let(:type) { :uuid }
+
+        uuid = SimpleUUID::UUID.new
+        converts 'uuid', uuid, uuid.to_time
+        converts 'time', Time.now.round
+      end
+    end
+
+    shared_examples_for :empty_string_convertable do
+      context 'empty string for text type' do
+        let(:type) { nil }
+        converts '', ''
+      end
+    end
+
+    shared_examples_for :type do
+      before { subject.insert data }
+
+      it 'should be correctly restored' do
+        restored = subject.one(query)[:field]
+        compare.(restored).should == expected
+      end
+    end
+
+    context 'key' do
+      let(:key)     { :field }
+      let(:subkey)  {}
+      let(:query)   {{ field: original }}
+      let(:data)    {{ field: original, data: :dummy }}
+
+      it_behaves_like :convertable
+    end
+
+    context 'subkeys' do
+      let(:key)     { :key }
+      let(:subkey)  { :field }
+      let(:query)   {{ key: 42 }}
+      let(:data)    {{ key: 42, field: original }}
+
+      it_behaves_like :convertable
+      it_behaves_like :uuid_convertable
+      it_behaves_like :empty_string_convertable
+    end
+
+    context 'data' do
+      let(:key)     { :key }
+      let(:subkey)  {}
+      let(:query)   {{ key: 42 }}
+      let(:data)    {{ key: 42, field: original }}
+
+      it_behaves_like :convertable
+      it_behaves_like :uuid_convertable
+      it_behaves_like :empty_string_convertable
+    end
+
+    context 'complex key' do
+      let(:key)     {[ :key, :field ]}
+      let(:subkey)  {}
+      let(:query)   {{ key: 42, field: original }}
+      let(:data)    {{ key: 42, field: original, data: :dummy }}
+
+      it_behaves_like :convertable
+      it_behaves_like :empty_string_convertable
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'cassandra/mapper'
+require 'yaml'
+
+Cassandra::Mapper.schema = { keyspaces: [ :mapper ]}
+Cassandra::Mapper.env    = :test
+
+begin
+  Cassandra::Mapper.migrate
+rescue CassandraThrift::InvalidRequestException
+  puts 'Using existing keyspace'
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: cassandra-mapper
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- brainopia
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: cassandra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.18.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.18.0
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+description: |2
+      Work with cassandra in datamapper style.
+email: brainopia@evilmartians.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- cassandra-mapper.gemspec
+- lib/cassandra/mapper.rb
+- lib/cassandra/mapper/convert.rb
+- lib/cassandra/mapper/data/insert.rb
+- lib/cassandra/mapper/data/remove.rb
+- lib/cassandra/mapper/data/request.rb
+- lib/cassandra/mapper/data/response.rb
+- lib/cassandra/mapper/extend/migrate.rb
+- lib/cassandra/mapper/extend/queries.rb
+- lib/cassandra/mapper/extend/schema.rb
+- lib/cassandra/mapper/utility/config.rb
+- lib/cassandra/mapper/utility/delegate_keys.rb
+- lib/cassandra/mapper/utility/hash.rb
+- lib/cassandra/mapper/utility/store_instances.rb
+- spec/cassandra/mapper/convert_spec.rb
+- spec/cassandra/mapper/utility/config_spec.rb
+- spec/cassandra/mapper/utility/store_instances_spec.rb
+- spec/cassandra/mapper_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/brainopia/cassandra-mapper
+licenses: []
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Cassandra mapper
+test_files:
+- spec/cassandra/mapper/convert_spec.rb
+- spec/cassandra/mapper/utility/config_spec.rb
+- spec/cassandra/mapper/utility/store_instances_spec.rb
+- spec/cassandra/mapper_spec.rb
+- spec/spec_helper.rb
+has_rdoc: