active_column 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+pkg/*
+*.gem
+.bundle
+.idea

data/.rvmrc

@@ -0,0 +1,7 @@
+
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments" \
+  && -s "${rvm_path:-$HOME/.rvm}/environments/ruby-1.9.2-p0@active_column" ]] ; then
+  \. "${rvm_path:-$HOME/.rvm}/environments/ruby-1.9.2-p0@active_column"
+else
+  rvm --create  "ruby-1.9.2-p0@active_column"
+fi

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in active_column.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,38 @@
+PATH
+  remote: .
+  specs:
+    active_column (0.0.1)
+      simple_uuid
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    cassandra (0.8.2)
+      json
+      rake
+      simple_uuid (>= 0.1.0)
+      thrift_client (>= 0.4.0)
+    diff-lcs (1.1.2)
+    json (1.4.6)
+    rake (0.8.7)
+    rspec (2.2.0)
+      rspec-core (~> 2.2)
+      rspec-expectations (~> 2.2)
+      rspec-mocks (~> 2.2)
+    rspec-core (2.2.1)
+    rspec-expectations (2.2.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.2.0)
+    simple_uuid (0.1.1)
+    thrift (0.2.0.4)
+    thrift_client (0.5.0)
+      thrift (~> 0.2.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  active_column!
+  cassandra
+  rspec
+  simple_uuid

data/README.html

@@ -0,0 +1,156 @@
+<h1>ActiveColumn</h1>
+
+<p>ActiveColumn is a framework for saving and retrieving data from Cassandra in a "time line" model.  It is loosely based
+on concepts in ActiveRecord, but is adapted to saving data in which rows in Cassandra grow indefinitely over time, such
+as in the oft-used Twitter example for Cassandra.</p>
+
+<h2>Installation</h2>
+
+<p>Add ActiveColumn to your Gemfile:</p>
+
+<pre>
+gem 'active_column'
+</pre>
+
+<p>Install with bundler:</p>
+
+<pre>
+bundle install
+</pre>
+
+<h2>Usage</h2>
+
+<h3>Configuration</h3>
+
+<p>ActiveColumn requires the <a href="https://github.com/fauna/cassandra">cassandra gem</a>.  You must provide ActiveColumn with an
+instance of a Cassandra object.  You can do this very simply like this:</p>
+
+<pre>
+ActiveColumn.connection = Cassandra.new('my_keyspace', '127.0.0.1:9160')
+</pre>
+
+<p>However, in a real app this is not flexible enough, so I often create a cassandra.yml file and configure Cassandra in an
+initializer.</p>
+
+<p>config/cassandra.yml</p>
+
+<pre>
+test:
+  home: ":"
+  servers: "127.0.0.1:9160"
+  keyspace: "myapp_test"
+  thrift:
+    timeout: 3
+    retries: 2
+
+development:
+  home: ":"
+  servers: "127.0.0.1:9160"
+  keyspace: "myapp_development"
+  thrift:
+    timeout: 3
+    retries: 2
+</pre>
+
+<p>config/initializers/cassandra.rb</p>
+
+<pre>
+config = YAML.load_file(Rails.root.join("config", "cassandra.yml"))[Rails.env]
+$cassandra = Cassandra.new(config['keyspace'],
+                           config['servers'],
+                           config['thrift'])
+
+ActiveColumn.connection = $cassandra
+</pre>
+
+<p>As you can see, I create a global $cassandra variable, which I use in my tests to validate data directly in Cassandra.</p>
+
+<p>One other thing to note is that you obviously must have Cassandra installed and running!  Please take a look at the
+<a href="https://github.com/carbonfive/mama_cass">mama_cass gem</a> for a quick way to get up and running with Cassandra for
+development and testing.</p>
+
+<h3>Saving data</h3>
+
+<p>To make a model in to an ActiveColumn model, just extend ActiveColumn::Base, and provide two pieces of information:
+* Column Family
+* Function(s) to generate keys for your rows of data</p>
+
+<p>The most basic form of using ActiveColumn looks like this:</p>
+
+<pre>
+class Tweet &lt; ActiveColumn::Base
+  column_family :tweets
+  keys :user_id
+end
+</pre>
+
+<p>Then in your app you can create and save a tweet like this:</p>
+
+<pre>
+tweet = Tweet.new( :user_id => 'mwynholds', :message => "I'm going for a bike ride" )
+tweet.save
+</pre>
+
+<p>When you run #save, ActiveColumn saves a new column in the "tweets" column family in the row with key "mwynholds".  The
+content of the row is the Tweet instance JSON-encoded.</p>
+
+<p><em>Key Generator Functions</em></p>
+
+<p>This is great, but quite often you want to save the content in multiple rows for the sake of speedy lookups.  This is
+basically de-normalizing data, and is extremely common in Cassandra data.  ActiveColumn lets you do this quite easily
+by telling it the name of a function to use to generate the keys during a save.  It works like this:</p>
+
+<pre>
+class Tweet &lt; ActiveColumn::Base
+  column_family :tweets
+  keys :user_id => :generate_user_keys
+
+  def generate_user_keys
+    [ attributes[:user_id], 'all']
+  end
+end
+</pre>
+
+<p>The code to save the tweet is the same as the previous example, but now it saves the tweet in both the "mwynholds" row
+and the "all" row.  This way, you can pull out the last 20 of all tweets quite easily (assuming you needed to do this
+in your app).</p>
+
+<p><em>Compound Keys</em></p>
+
+<p>In some cases you may want to have your rows keyed by multiple values.  ActiveColumn supports compound keys,
+and looks like this:</p>
+
+<pre>
+class TweetDM &lt; ActiveColumn::Base
+  column_family :tweet_dms
+  keys [ { :user_id => :generate_user_keys }, { :recipient_id => :recipient_ids } ]
+
+  def generate_user_keys
+    [ attributes[:user_id], 'all ]
+  end
+end
+</pre>
+
+<p>Now, when you create a new TweetDM, it might look like this:</p>
+
+<pre>
+dm = TweetDM.new( :user_id => 'mwynholds', :recipient_ids => [ 'fsinatra', 'dmartin' ], :message => "Let's go to Vegas" )
+</pre>
+
+<p>This tweet direct message will saved to four different rows in the "tweet_dms" column family, under these keys:
+* mwynholds:fsinatra
+* mwynholds:dmartin
+* all:fsinatra
+* all:dmartin</p>
+
+<p>Now my app can pretty easily figure find all DMs I sent to Old Blue Eyes, or to Dino, and it can also easily find all
+DMs sent from <em>anyone</em> to Frank or Dino.</p>
+
+<p>One thing to note about the TweetDM class above is that the "keys" configuration at the top looks a little uglier than
+before.  If you have a compound key and any of the keys have custom key generators, you need to pass in an array of
+single-element hashes.  This is in place to support Ruby 1.8, which does not have ordered hashes.  Making sure the keys
+are ordered is necessary to keep the compounds keys canonical (ie: deterministic).</p>
+
+<h3>Finding data</h3>
+
+<p>Working on this...</p>

data/README.md

@@ -0,0 +1,150 @@
+# ActiveColumn
+
+ActiveColumn is a framework for saving and retrieving data from Cassandra in a "time line" model.  It is loosely based
+on concepts in ActiveRecord, but is adapted to saving data in which rows in Cassandra grow indefinitely over time, such
+as in the oft-used Twitter example for Cassandra.
+
+## Installation
+
+Add ActiveColumn to your Gemfile:
+<pre>
+gem 'active_column'
+</pre>
+
+Install with bundler:
+<pre>
+bundle install
+</pre>
+
+## Usage
+
+### Configuration
+
+ActiveColumn requires the [cassandra gem](https://github.com/fauna/cassandra).  You must provide ActiveColumn with an
+instance of a Cassandra object.  You can do this very simply like this:
+
+<pre>
+ActiveColumn.connection = Cassandra.new('my_keyspace', '127.0.0.1:9160')
+</pre>
+
+However, in a real app this is not flexible enough, so I often create a cassandra.yml file and configure Cassandra in an
+initializer.
+
+config/cassandra.yml
+<pre>
+test:
+  home: ":"
+  servers: "127.0.0.1:9160"
+  keyspace: "myapp_test"
+  thrift:
+    timeout: 3
+    retries: 2
+
+development:
+  home: ":"
+  servers: "127.0.0.1:9160"
+  keyspace: "myapp_development"
+  thrift:
+    timeout: 3
+    retries: 2
+</pre>
+
+config/initializers/cassandra.rb
+<pre>
+config = YAML.load_file(Rails.root.join("config", "cassandra.yml"))[Rails.env]
+$cassandra = Cassandra.new(config['keyspace'],
+                           config['servers'],
+                           config['thrift'])
+
+ActiveColumn.connection = $cassandra
+</pre>
+
+As you can see, I create a global $cassandra variable, which I use in my tests to validate data directly in Cassandra.
+
+One other thing to note is that you obviously must have Cassandra installed and running!  Please take a look at the
+[mama_cass gem](https://github.com/carbonfive/mama_cass) for a quick way to get up and running with Cassandra for
+development and testing.
+
+### Saving data
+
+To make a model in to an ActiveColumn model, just extend ActiveColumn::Base, and provide two pieces of information:
+* Column Family
+* Function(s) to generate keys for your rows of data
+
+The most basic form of using ActiveColumn looks like this:
+<pre>
+class Tweet &lt; ActiveColumn::Base
+  column_family :tweets
+  keys :user_id
+end
+</pre>
+
+Then in your app you can create and save a tweet like this:
+<pre>
+tweet = Tweet.new( :user_id => 'mwynholds', :message => "I'm going for a bike ride" )
+tweet.save
+</pre>
+
+When you run #save, ActiveColumn saves a new column in the "tweets" column family in the row with key "mwynholds".  The
+content of the row is the Tweet instance JSON-encoded.
+
+*Key Generator Functions*
+
+This is great, but quite often you want to save the content in multiple rows for the sake of speedy lookups.  This is
+basically de-normalizing data, and is extremely common in Cassandra data.  ActiveColumn lets you do this quite easily
+by telling it the name of a function to use to generate the keys during a save.  It works like this:
+
+<pre>
+class Tweet &lt; ActiveColumn::Base
+  column_family :tweets
+  keys :user_id => :generate_user_keys
+
+  def generate_user_keys
+    [ attributes[:user_id], 'all']
+  end
+end
+</pre>
+
+The code to save the tweet is the same as the previous example, but now it saves the tweet in both the "mwynholds" row
+and the "all" row.  This way, you can pull out the last 20 of all tweets quite easily (assuming you needed to do this
+in your app).
+
+*Compound Keys*
+
+In some cases you may want to have your rows keyed by multiple values.  ActiveColumn supports compound keys,
+and looks like this:
+
+<pre>
+class TweetDM &lt; ActiveColumn::Base
+  column_family :tweet_dms
+  keys [ { :user_id => :generate_user_keys }, { :recipient_id => :recipient_ids } ]
+
+  def generate_user_keys
+    [ attributes[:user_id], 'all ]
+  end
+end
+</pre>
+
+Now, when you create a new TweetDM, it might look like this:
+
+<pre>
+dm = TweetDM.new( :user_id => 'mwynholds', :recipient_ids => [ 'fsinatra', 'dmartin' ], :message => "Let's go to Vegas" )
+</pre>
+
+This tweet direct message will saved to four different rows in the "tweet_dms" column family, under these keys:
+* mwynholds:fsinatra
+* mwynholds:dmartin
+* all:fsinatra
+* all:dmartin
+
+Now my app can pretty easily figure find all DMs I sent to Old Blue Eyes, or to Dino, and it can also easily find all
+DMs sent from *anyone* to Frank or Dino.
+
+One thing to note about the TweetDM class above is that the "keys" configuration at the top looks a little uglier than
+before.  If you have a compound key and any of the keys have custom key generators, you need to pass in an array of
+single-element hashes.  This is in place to support Ruby 1.8, which does not have ordered hashes.  Making sure the keys
+are ordered is necessary to keep the compounds keys canonical (ie: deterministic).
+
+### Finding data
+
+Working on this...

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/active_column.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "active_column/version"
+
+Gem::Specification.new do |s|
+  s.name        = "active_column"
+  s.version     = ActiveColumn::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Michael Wynholds"]
+  s.email       = ["mike@wynholds.com"]
+  s.homepage    = "http://rubygems.org/gems/active_column"
+  s.summary     = %q{Provides time line support for Cassandra}
+  s.description = %q{Provides time line support for Cassandra}
+
+  s.rubyforge_project = "active_column"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'simple_uuid'
+
+  s.add_development_dependency 'cassandra'
+  s.add_development_dependency 'rspec'
+end

data/lib/active_column.rb

@@ -0,0 +1,9 @@
+module ActiveColumn
+
+  autoload :Connection, 'active_column/connection'
+  autoload :Base,       'active_column/base'
+  autoload :Version,    'active_column/version'
+
+  extend Connection
+  
+end

data/lib/active_column/base.rb

@@ -0,0 +1,90 @@
+module ActiveColumn
+
+  class Base
+
+    attr_reader :attributes
+
+    def initialize(attrs = {})
+      @attributes = attrs
+    end
+
+    def self.column_family(column_family = nil)
+      return @column_family if column_family.nil?
+      @column_family = column_family
+    end
+
+    def self.keys(*keys)
+      return @keys if keys.nil? || keys.empty?
+      flattened = ( keys.size == 1 && keys[0].is_a?(Array) ? keys[0] : keys )
+      @keys = flattened.collect { |k| KeyConfig.new(k) }
+    end
+
+    def save()
+      value = { SimpleUUID::UUID.new => self.to_json }
+      key_parts = self.class.keys.each_with_object( {} ) do |key_config, key_parts|
+        key_parts[key_config.key] = get_keys(key_config)
+      end
+      keys = self.class.generate_keys(key_parts)
+
+      keys.each do |key|
+        ActiveColumn.connection.insert(self.class.column_family, key, value)
+      end
+
+      self
+    end
+
+    def self.find(key_parts, options = {})
+      keys = generate_keys key_parts
+      ActiveColumn.connection.multi_get(column_family, keys, options).each_with_object( {} ) do |(user, row), results|
+        results[user] = row.to_a.collect { |(_uuid, col)| new(JSON.parse(col)) }
+      end
+    end
+
+    def to_json(*a)
+      @attributes.to_json(*a)
+    end
+
+    private
+
+    def get_keys(key_config)
+      key_config.func.nil? ? attributes[key_config.key] : self.send(key_config.func)
+    end
+
+    def self.generate_keys(key_parts)
+      if keys.size == 1
+        key_config = keys.first
+        value = key_parts.is_a?(Hash) ? key_parts[key_config.key] : key_parts
+        return value if value.is_a? Array
+        return [value]
+      end
+
+      values = keys.collect { |kc| key_parts[kc.key] }
+      product = values.reduce do |memo, key_part|
+        memo     = [memo]     unless memo.is_a? Array
+        key_part = [key_part] unless key_part.is_a? Array
+        memo.product key_part
+      end
+
+      product.collect { |p| p.join(':') }
+    end
+
+  end
+
+  class KeyConfig
+    attr_accessor :key, :func
+
+    def initialize(key_conf)
+      if key_conf.is_a?(Hash)
+        @key = key_conf.keys[0]
+        @func = key_conf[@key]
+      else
+        @key = key_conf
+      end
+    end
+
+    def to_s
+      "KeyConfig[#{key}, #{func or '-'}]"
+    end
+  end
+
+end

data/lib/active_column/connection.rb

@@ -0,0 +1,15 @@
+module ActiveColumn
+
+  module Connection
+
+    def connection
+      @@connection
+    end
+
+    def connection=(connection)
+      @@connection = connection
+    end
+
+  end
+
+end

data/lib/active_column/version.rb

@@ -0,0 +1,3 @@
+module ActiveColumn
+  VERSION = "0.0.1"
+end

data/spec/active_column/base_crud_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe ActiveColumn::Base do
+
+  describe '#save' do
+
+    context 'given a model with a single key' do
+      before do
+        @counter = Counter.new(:tweets, 'user1', 'user2', 'all')
+      end
+
+      context 'and an attribute key function' do
+        before do
+          Tweet.new( user_id: 'user1', message: 'just woke up' ).save
+          Tweet.new( user_id: 'user2', message: 'kinda hungry' ).save
+        end
+
+        it 'saves the model for the key' do
+          @counter.diff.should == [1, 1, 0]
+        end
+      end
+
+      context 'and a custom key function' do
+        before do
+          AggregatingTweet.new( user_id: 'user1', message: 'just woke up' ).save
+          AggregatingTweet.new( user_id: 'user2', message: 'kinda hungry' ).save
+        end
+
+        it 'saves the model for the keys' do
+          @counter.diff.should == [1, 1, 2]
+        end
+      end
+    end
+
+    context 'given a model with a compound key' do
+      before do
+        @counts = Counter.new(:tweet_dms, 'user1:friend1', 'user1:friend2', 'user1:all', 'all:friend1', 'all:friend2')
+        TweetDM.new( user_id: 'user1', recipient_ids: ['friend1', 'friend2'], message: 'feeling blue' ).save
+        TweetDM.new( user_id: 'user1', recipient_ids: ['friend2'], message: 'now im better' ).save
+      end
+
+      it 'saves the model for the combined compounds keys' do
+        @counts.diff.should == [1, 2, 2, 1, 2]
+      end
+    end
+
+  end
+
+  describe '.generate_keys' do
+
+    context 'given a simple key model' do
+      before do
+        @model = SimpleKey.new
+      end
+
+      context 'and a single key' do
+        it 'returns an array with the single key' do
+          keys = @model.class.send :generate_keys, '1'
+          keys.should == ['1']
+        end
+      end
+
+      context 'and an array of keys' do
+        it 'returns an array with the keys' do
+          keys = @model.class.send :generate_keys, ['1', '2', '3']
+          keys.should == ['1', '2', '3']
+        end
+      end
+
+      context 'and a map with a single key' do
+        it 'returns an array with the single key' do
+          keys = @model.class.send :generate_keys, { :one => '1' }
+          keys.should == ['1']
+        end
+      end
+
+      context 'and a map with an array with a single key' do
+        it 'returns an array with the single key' do
+          keys = @model.class.send :generate_keys, { :one => ['1'] }
+          keys.should == ['1']
+        end
+      end
+    end
+
+    context 'given a compound key model' do
+      before do
+        @model = CompoundKey.new
+      end
+
+      context 'and a map of keys' do
+        it 'returns an array of the keys put together' do
+          keys = @model.class.send :generate_keys, { :one => ['1', '2'], :two => ['a', 'b'], :three => 'Z' }
+          keys.should == ['1:a:Z', '1:b:Z', '2:a:Z', '2:b:Z']
+        end
+      end
+
+      context 'and a different map of keys' do
+        it 'returns an array of the keys put together' do
+          keys = @model.class.send :generate_keys, { :one => '1', :two => ['a', 'b'], :three => 'Z' }
+          keys.should == ['1:a:Z', '1:b:Z']
+        end
+      end
+    end
+
+  end
+
+end

data/spec/active_column/base_finders_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe ActiveColumn::Base do
+
+  describe '.find' do
+
+    context 'given a model with a simple key' do
+      before do
+        Tweet.new( :user_id => 'user1', :message => 'Going running' ).save
+        Tweet.new( :user_id => 'user2', :message => 'Watching TV' ).save
+        Tweet.new( :user_id => 'user1', :message => 'Now im hungry' ).save
+        Tweet.new( :user_id => 'user1', :message => 'Now im full' ).save
+      end
+
+      context 'and finding some for a single key' do
+        before do
+          @found = Tweet.find( 'user1', :count => 3, :reversed => true )
+        end
+
+        it 'find all of the models' do
+          @found.size.should == 1
+          @found['user1'].size.should == 3
+          @found['user1'].collect { |t| t.attributes['message'] }.should == [ 'Now im full', 'Now im hungry', 'Going running' ]
+        end
+      end
+
+      context 'and finding some for multiple keys' do
+        before do
+          @found = Tweet.find( ['user1', 'user2'], :count => 1, :reversed => true )
+        end
+
+        it 'finds all of the models' do
+          @found.size.should == 2
+          @found['user1'].collect { |t| t.attributes['message'] }.should == [ 'Now im full' ]
+          @found['user2'].collect { |t| t.attributes['message'] }.should == [ 'Watching TV' ]
+        end
+      end
+    end
+
+    context 'given a model with a compound key' do
+      before do
+        TweetDM.new( :user_id => 'user1', :recipient_ids => [ 'friend1', 'friend2' ], :message => 'Need to do laundry' ).save
+        TweetDM.new( :user_id => 'user1', :recipient_ids => [ 'friend2', 'friend3' ], :message => 'My leg itches' ).save
+      end
+
+      context 'and finding some for both keys' do
+        before do
+          @found = TweetDM.find( { :user_id => ['user1', 'user2'], :recipient_id => ['friend1', 'friend2', 'all'] }, :count => 1, :reversed => true )
+        end
+
+        it 'finds all of the models' do
+          @found.size.should == 6
+          @found['user1:friend1'].collect { |t| t.attributes['message'] }.should == [ 'Need to do laundry' ]
+          @found['user1:friend2'].collect { |t| t.attributes['message'] }.should == [ 'My leg itches' ]
+          @found['user1:all'].collect { |t| t.attributes['message'] }.should == [ 'My leg itches' ]
+          @found['user2:friend1'].should == []
+          @found['user2:friend2'].should == []
+          @found['user2:all'].should == []
+        end
+      end
+    end
+
+  end
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+require 'cassandra'
+require 'active_column'
+
+Dir[ File.expand_path("../support/**/*.rb", __FILE__) ].each {|f| require f}
+
+$cassandra = ActiveColumn.connection = Cassandra.new('active_column', '127.0.0.1:9160')
+$cassandra.clear_keyspace!
+
+RSpec.configure do |config|
+
+end
+
+class Counter
+  def initialize(cf, *keys)
+    @cf = cf
+    @keys = keys
+    @counts = get_counts
+  end
+
+  def diff()
+    new_counts = get_counts
+    @keys.each_with_object( [] ) do |key, counts|
+      counts << new_counts[key] - @counts[key]
+    end
+  end
+
+  private
+
+  def get_counts
+    @keys.each_with_object( {} ) do |key, counts|
+      counts[key] = $cassandra.count_columns(@cf, key)
+    end
+  end
+end

data/spec/support/aggregating_tweet.rb

@@ -0,0 +1,10 @@
+class AggregatingTweet < ActiveColumn::Base
+
+  column_family :tweets
+  keys :user_id => :user_keys
+
+  def user_keys
+    [ attributes[:user_id], 'all' ]
+  end
+
+end

data/spec/support/compound_key.rb

@@ -0,0 +1,4 @@
+class CompoundKey < ActiveColumn::Base
+  column_family :time
+  keys :one, :two, :three
+end

data/spec/support/config/storage-conf.xml

@@ -0,0 +1,54 @@
+<Storage>
+  <ClusterName>ActiveColumn</ClusterName>
+  <AutoBootstrap>false</AutoBootstrap>
+  <HintedHandoffEnabled>true</HintedHandoffEnabled>
+
+  <Keyspaces>
+    <Keyspace Name="active_column">
+      <ColumnFamily Name="time" CompareWith="TimeUUIDType"/>
+      <ColumnFamily Name="tweets" CompareWith="TimeUUIDType"/>
+      <ColumnFamily Name="tweet_dms" CompareWith="TimeUUIDType"/>
+      <ReplicaPlacementStrategy>org.apache.cassandra.locator.RackUnawareStrategy</ReplicaPlacementStrategy>
+      <ReplicationFactor>1</ReplicationFactor>
+      <EndPointSnitch>org.apache.cassandra.locator.EndPointSnitch</EndPointSnitch>
+    </Keyspace>
+  </Keyspaces>
+
+  <Authenticator>org.apache.cassandra.auth.AllowAllAuthenticator</Authenticator>
+  <Partitioner>org.apache.cassandra.dht.RandomPartitioner</Partitioner>
+  <InitialToken></InitialToken>
+
+  <SavedCachesDirectory>/var/lib/cassandra/saved_caches</SavedCachesDirectory>
+  <CommitLogDirectory>/var/lib/cassandra/commitlog</CommitLogDirectory>
+  <DataFileDirectories>
+      <DataFileDirectory>/var/lib/cassandra/data</DataFileDirectory>
+  </DataFileDirectories>
+
+  <Seeds>
+    <Seed>127.0.0.1</Seed>
+  </Seeds>
+
+  <RpcTimeoutInMillis>10000</RpcTimeoutInMillis>
+  <CommitLogRotationThresholdInMB>128</CommitLogRotationThresholdInMB>
+  <ListenAddress>localhost</ListenAddress>
+  <StoragePort>7000</StoragePort>
+  <ThriftAddress>localhost</ThriftAddress>
+  <ThriftPort>9160</ThriftPort>
+  <ThriftFramedTransport>false</ThriftFramedTransport>
+
+  <DiskAccessMode>auto</DiskAccessMode>
+  <RowWarningThresholdInMB>512</RowWarningThresholdInMB>
+  <SlicedBufferSizeInKB>64</SlicedBufferSizeInKB>
+  <FlushDataBufferSizeInMB>32</FlushDataBufferSizeInMB>
+  <FlushIndexBufferSizeInMB>8</FlushIndexBufferSizeInMB>
+  <ColumnIndexSizeInKB>64</ColumnIndexSizeInKB>
+  <MemtableThroughputInMB>64</MemtableThroughputInMB>
+  <BinaryMemtableThroughputInMB>256</BinaryMemtableThroughputInMB>
+  <MemtableOperationsInMillions>0.3</MemtableOperationsInMillions>
+  <MemtableFlushAfterMinutes>60</MemtableFlushAfterMinutes>
+  <ConcurrentReads>8</ConcurrentReads>
+  <ConcurrentWrites>32</ConcurrentWrites>
+  <CommitLogSync>periodic</CommitLogSync>
+  <CommitLogSyncPeriodInMS>10000</CommitLogSyncPeriodInMS>
+  <GCGraceSeconds>864000</GCGraceSeconds>
+</Storage>

data/spec/support/simple_key.rb

@@ -0,0 +1,4 @@
+class SimpleKey < ActiveColumn::Base
+  column_family :time
+  keys :one
+end

data/spec/support/tweet.rb

@@ -0,0 +1,6 @@
+class Tweet < ActiveColumn::Base
+
+  column_family :tweets
+  keys :user_id
+
+end

data/spec/support/tweet_dm.rb

@@ -0,0 +1,14 @@
+class TweetDM < ActiveColumn::Base
+
+  column_family :tweet_dms
+  keys [ { :user_id => :user_keys }, { :recipient_id => :recipient_keys } ]
+
+  def user_keys
+    [ attributes[:user_id], 'all' ]
+  end
+
+  def recipient_keys
+    attributes[:recipient_ids] + ['all']
+  end
+
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification 
+name: active_column
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Michael Wynholds
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-12 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: simple_uuid
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: cassandra
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+description: Provides time line support for Cassandra
+email: 
+- mike@wynholds.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- README.html
+- README.md
+- Rakefile
+- active_column.gemspec
+- lib/active_column.rb
+- lib/active_column/base.rb
+- lib/active_column/connection.rb
+- lib/active_column/version.rb
+- spec/active_column/base_crud_spec.rb
+- spec/active_column/base_finders_spec.rb
+- spec/spec_helper.rb
+- spec/support/aggregating_tweet.rb
+- spec/support/compound_key.rb
+- spec/support/config/storage-conf.xml
+- spec/support/simple_key.rb
+- spec/support/tweet.rb
+- spec/support/tweet_dm.rb
+has_rdoc: true
+homepage: http://rubygems.org/gems/active_column
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: active_column
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Provides time line support for Cassandra
+test_files: 
+- spec/active_column/base_crud_spec.rb
+- spec/active_column/base_finders_spec.rb
+- spec/spec_helper.rb
+- spec/support/aggregating_tweet.rb
+- spec/support/compound_key.rb
+- spec/support/config/storage-conf.xml
+- spec/support/simple_key.rb
+- spec/support/tweet.rb
+- spec/support/tweet_dm.rb