cequel 1.0.0.pre.5 → 1.0.0.pre.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f830646acc29101f50ff14afb06933e15fa88e35
-  data.tar.gz: c3d9d72fbf56847758e5de1191e7f48200b03423
+  metadata.gz: 720dcb8eb0924dd3f972efba9e93c2d96ae046ab
+  data.tar.gz: 36b08070aa03e28e6f0748e1c6a375e2ca57822f
 SHA512:
-  metadata.gz: 981a73d5f5f4a6b5a07374df3f96ccdd599642927ea29aa652a13249234ffd18a40921aaa675345355de052072b94ecd8e8f2b63d47e16c2b1bdabbb7c7150e1
-  data.tar.gz: dc9035f9e642cdffac8f3b83ab9ec2abacb3498580cdfe4e3b6e5b370ec8a70fe22ab4e5f20a9f702fc5d8eacda436098a73fb04592d7858a73f64bd1720e1c6
+  metadata.gz: c51e2ab0b17869ca3f6720e1c74b78c6f116ac705cce8aac49925750e4204012a7701ea1ed6ce4b51702a9f0a88ed2aad3d39609e5b57080ca9d2be1b0913fa6
+  data.tar.gz: 1dae89c0e31809ee91f54a137ca22396d8c591b5ebdf85efe9091ef53143674a71d9873b3b84b562c2deeb5eacad8ffd8dfe25d4fcb4706489656c5307e7ec81

data/lib/cequel/metal/batch.rb

@@ -43,7 +43,10 @@ module Cequel
       #
       def apply
         return if @statement_count.zero?
-        @statement.append("APPLY BATCH\n")
+        if @statement_count > 1
+          @statement.prepend("BEGIN BATCH\n")
+          @statement.append("APPLY BATCH\n")
+        end
         @keyspace.execute(*@statement.args)
       end
 
@@ -51,7 +54,6 @@ module Cequel
 
       def reset
         @statement = Statement.new
-        @statement.append("BEGIN BATCH\n")
         @statement_count = 0
       end
 

data/lib/cequel/metal/keyspace.rb

@@ -144,13 +144,14 @@ module Cequel
       #   end
       #
       def batch(options = {})
-        old_batch = get_batch
-        new_batch = Batch.new(self, options)
-        set_batch(new_batch)
-        yield
-        new_batch.apply
-      ensure
-        set_batch(old_batch)
+        return yield if get_batch
+        begin
+          new_batch = Batch.new(self, options)
+          set_batch(new_batch)
+          yield.tap { new_batch.apply }
+        ensure
+          set_batch(nil)
+        end
       end
 
       private

data/lib/cequel/metal/statement.rb

@@ -3,14 +3,19 @@ module Cequel
   module Metal
 
     class Statement
-      attr_reader :bind_vars
+      attr_reader :bind_vars, :length
 
       def initialize
-        @cql, @bind_vars = StringIO.new, []
+        @cql, @bind_vars = [], []
       end
 
       def cql
-        @cql.string
+        @cql.join
+      end
+
+      def prepend(cql, *bind_vars)
+        @cql.unshift(cql)
+        @bind_vars.unshift(*bind_vars)
       end
 
       def append(cql, *bind_vars)

data/lib/cequel/record.rb

@@ -8,6 +8,7 @@ require 'cequel/record/collection'
 require 'cequel/record/persistence'
 require 'cequel/record/record_set'
 require 'cequel/record/bound'
+require 'cequel/record/lazy_record_collection'
 require 'cequel/record/scoped'
 require 'cequel/record/secondary_indexes'
 require 'cequel/record/associations'

data/lib/cequel/record/callbacks.rb

@@ -12,11 +12,11 @@ module Cequel
       end
 
       def save(options = {})
-        run_callbacks(:save) { super }
+        connection.batch { run_callbacks(:save) { super }}
       end
 
       def destroy
-        run_callbacks(:destroy) { super }
+        connection.batch { run_callbacks(:destroy) { super }}
       end
 
       protected

data/lib/cequel/record/lazy_record_collection.rb

@@ -0,0 +1,44 @@
+module Cequel
+
+  module Record
+
+    class LazyRecordCollection < DelegateClass(Array)
+
+      def initialize(record_set)
+        raise ArgumentError if record_set.nil?
+
+        exploded_key_attributes = [{}].tap do |all_key_attributes|
+          record_set.key_columns.zip(record_set.scoped_key_attributes.values) do |column, values|
+            all_key_attributes.replace(Array(values).flat_map do |value|
+              all_key_attributes.map do |key_attributes|
+                key_attributes.merge(column.name => value)
+              end
+            end)
+          end
+        end
+
+        unloaded_records = exploded_key_attributes.map do |key_attributes|
+          record_set.target_class.new_empty(key_attributes, self)
+        end
+
+        super(unloaded_records)
+        @record_set = record_set
+      end
+
+      def load!
+        records_by_identity = index_by { |record| record.key_values }
+
+        record_set.find_each_row do |row|
+          identity = row.values_at(*record_set.key_column_names)
+          records_by_identity[identity].hydrate(row)
+        end
+      end
+
+      private
+      attr_reader :record_set
+
+    end
+
+  end
+
+end

data/lib/cequel/record/persistence.rb

@@ -17,7 +17,7 @@ module Cequel
         end
 
         def hydrate(row)
-          new_empty { hydrate(row) }
+          new_empty(row).__send__(:hydrated!)
         end
 
       end
@@ -42,11 +42,7 @@ module Cequel
 
       def load
         assert_keys_present!
-        unless loaded?
-          row = metal_scope.first
-          hydrate(row) unless row.nil?
-          collection_proxies.each_value { |collection| collection.loaded! }
-        end
+        record_collection.load! unless loaded?
         self
       end
 
@@ -96,14 +92,22 @@ module Cequel
         !persisted?
       end
 
+      def hydrate(row)
+        @attributes = row
+        hydrated!
+        self
+      end
+
       protected
 
       def persisted!
         @persisted = true
+        self
       end
 
       def transient!
         @persisted = false
+        self
       end
 
       def create
@@ -159,8 +163,13 @@ module Cequel
         end
       end
 
-      def hydrate(row)
-        @attributes = row
+      def record_collection
+        @record_collection ||=
+          LazyRecordCollection.new(self.class.at(*key_values)).
+          tap { |set| set.__setobj__([self]) }
+      end
+
+      def hydrated!
         loaded!
         persisted!
         self
@@ -169,11 +178,11 @@ module Cequel
       def loaded!
         @loaded = true
         collection_proxies.each_value { |collection| collection.loaded! }
+        self
       end
 
       def metal_scope
-        connection[table_name].
-          where(key_attributes)
+        connection[table_name].where(key_attributes)
       end
 
       def attributes_for_create

data/lib/cequel/record/properties.rb

@@ -111,9 +111,10 @@ module Cequel
 
       end
 
-      def initialize(&block)
-        @attributes, @collection_proxies = {}, {}
-        instance_eval(&block) if block
+      # FIXME this isn't empty anymore! Rethink.
+      def initialize(attributes = {}, record_collection = nil)
+        @attributes, @record_collection = attributes, record_collection
+        @collection_proxies = {}
       end
 
       def attribute_names

data/lib/cequel/record/record_set.rb

@@ -12,10 +12,13 @@ module Cequel
         {:scoped_key_values => [], :select_columns => []}
       end
 
-      def initialize(clazz, attributes = {})
+      attr_reader :target_class
+      attr_writer :unloaded_records
+
+      def initialize(target_class, attributes = {})
         attributes = self.class.default_attributes.merge!(attributes)
-        @clazz, @attributes = clazz, attributes
-        super(clazz)
+        @target_class, @attributes = target_class, attributes
+        super(target_class)
       end
 
       def all
@@ -32,11 +35,11 @@ module Cequel
       end
 
       def where(column_name, value)
-        column = clazz.reflect_on_column(column_name)
+        column = target_class.reflect_on_column(column_name)
         raise IllegalQuery,
           "Can't scope by more than one indexed column in the same query" if scoped_indexed_column
         raise ArgumentError,
-          "No column #{column_name} configured for #{clazz.name}" unless column
+          "No column #{column_name} configured for #{target_class.name}" unless column
         raise ArgumentError,
           "Use the `at` method to restrict scope by primary key" unless column.data_column?
         raise ArgumentError,
@@ -45,26 +48,20 @@ module Cequel
       end
 
       def at(*scoped_key_values)
-        scoped do |attributes|
-          type_cast_key_values = scoped_key_values.zip(unscoped_key_columns).
-            map { |value, column| column.cast(value) }
-          attributes[:scoped_key_values].concat(type_cast_key_values)
-        end
+        warn "`at` is deprecated. Use `[]` instead"
+        scoped_key_values.
+          inject(self) { |record_set, key_value| record_set[key_value] }
       end
 
-      def [](scoped_key_value)
-        scoped_key_value = cast_range_key(scoped_key_value)
+      def [](*new_scoped_key_values)
+        new_scoped_key_values =
+          new_scoped_key_values.map(&method(:cast_range_key))
 
-        if next_range_key_column
-          at(scoped_key_value)
-        else
-          attributes = {}
-          key_values = [*scoped_key_values, scoped_key_value]
-          clazz.key_column_names.zip(key_values) do |key_name, key_value|
-            attributes[key_name] = key_value
-          end
-          clazz.new_empty { @attributes = attributes }
-        end
+        new_scoped_key_values =
+          new_scoped_key_values.first if new_scoped_key_values.one?
+
+        scoped { |attributes| attributes[:scoped_key_values] <<
+          new_scoped_key_values }.resolve_if_fully_specified
       end
 
       def find(*scoped_key_values)
@@ -72,7 +69,7 @@ module Cequel
       end
 
       def /(scoped_key_value)
-        at(scoped_key_value)
+        self[scoped_key_value]
       end
 
       def after(start_key)
@@ -91,7 +88,7 @@ module Cequel
       end
 
       def from(start_key)
-        unless single_partition?
+        unless partition_specified?
           raise IllegalQuery,
             "Can't construct exclusive range on partition key #{range_key_name}"
         end
@@ -99,7 +96,7 @@ module Cequel
       end
 
       def upto(end_key)
-        unless single_partition?
+        unless partition_specified?
           raise IllegalQuery,
             "Can't construct exclusive range on partition key #{range_key_name}"
         end
@@ -107,7 +104,7 @@ module Cequel
       end
 
       def reverse
-        unless single_partition?
+        unless partition_specified?
           raise IllegalQuery,
             "Can't reverse without scoping to partition key #{range_key_name}"
         end
@@ -134,7 +131,7 @@ module Cequel
 
       def find_each(options = {})
         return enum_for(:find_each, options) unless block_given?
-        find_each_row(options) { |row| yield clazz.hydrate(row) }
+        find_each_row(options) { |row| yield target_class.hydrate(row) }
       end
 
       def find_each_row(options = {}, &block)
@@ -211,11 +208,11 @@ module Cequel
       end
 
       def scoped_key_columns
-        clazz.key_columns.first(scoped_key_values.length)
+        target_class.key_columns.first(scoped_key_values.length)
       end
 
       def unscoped_key_columns
-        clazz.key_columns.drop(scoped_key_values.length)
+        target_class.key_columns.drop(scoped_key_values.length)
       end
 
       def unscoped_key_names
@@ -238,27 +235,68 @@ module Cequel
         next_range_key_column.try(:name)
       end
 
-      def single_partition?
-        scoped_key_values.length >= clazz.partition_key_columns.length
+      def fully_specified?
+        scoped_key_values.length == target_class.key_columns.length
+      end
+
+      def partition_specified?
+        scoped_key_values.length >= target_class.partition_key_columns.length
+      end
+
+      def multiple_records_specified?
+        scoped_key_values.any? { |values| values.is_a?(Array) }
+      end
+
+      def resolve_if_fully_specified
+        if fully_specified?
+          if multiple_records_specified?
+            LazyRecordCollection.new(select_non_collection_columns!)
+          else
+            LazyRecordCollection.new(self).first
+          end
+        else
+          self
+        end
       end
 
       # Try to order results by the first clustering column. Fall back to partition key if none exist.
       def order_by_column
-        clazz.clustering_columns.first.name if clazz.clustering_columns.any?
+        target_class.clustering_columns.first.name if target_class.clustering_columns.any?
+      end
+
+      def selects_collection_columns?
+        select_columns.any? do |column_name|
+          target_class.reflect_on_column(column_name).
+            is_a?(Cequel::Schema::CollectionColumn)
+        end
+      end
+
+      def select_non_collection_columns!
+        if selects_collection_columns?
+          raise ArgumentError,
+            "Can't scope by multiple keys when selecting a collection column."
+        end
+        if select_columns.empty?
+          non_collection_columns = target_class.columns.
+            reject { |column| column.is_a?(Cequel::Schema::CollectionColumn) }.
+            map { |column| column.name }
+          select(*non_collection_columns)
+        else
+          self
+        end
       end
 
       private
-      attr_reader :clazz
-      def_delegators :clazz, :connection
+      def_delegators :target_class, :connection
       def_delegator :range_key_column, :cast, :cast_range_key
       private :connection, :cast_range_key
 
       def method_missing(method, *args, &block)
-        clazz.with_scope(self) { super }
+        target_class.with_scope(self) { super }
       end
 
       def construct_data_set
-        data_set = connection[clazz.table_name]
+        data_set = connection[target_class.table_name]
         data_set = data_set.limit(row_limit) if row_limit
         data_set = data_set.select(*select_columns) if select_columns
         if scoped_key_values
@@ -292,7 +330,7 @@ module Cequel
         attributes_copy = Marshal.load(Marshal.dump(attributes))
         attributes_copy.merge!(new_attributes)
         attributes_copy.tap(&block) if block
-        RecordSet.new(clazz, attributes_copy)
+        RecordSet.new(target_class, attributes_copy)
       end
 
     end

data/lib/cequel/record/schema.rb

@@ -15,7 +15,7 @@ module Cequel
       module ClassMethods
         extend Forwardable
 
-        def_delegators :table_schema, :key_columns, :key_column_names,
+        def_delegators :table_schema, :columns, :key_columns, :key_column_names,
           :partition_key_columns, :clustering_columns, :compact_storage?
         def_delegator :table_schema, :column, :reflect_on_column
 

data/lib/cequel/version.rb

@@ -1,3 +1,3 @@
 module Cequel
-  VERSION = '1.0.0.pre.5'
+  VERSION = '1.0.0.pre.6'
 end

data/spec/examples/record/callbacks_spec.rb

@@ -24,6 +24,28 @@ describe Cequel::Record::Callbacks do
 
   end
 
+  model :Comment do
+    belongs_to :post
+    key :id, :timeuuid, :auto => true
+    column :body, :text
+
+    before_save :create_post
+    after_save :run_instance_after_save
+
+    attr_writer :instance_after_save
+
+    private
+
+    def create_post
+      post = Post.create!(permalink: 'autopost', title: 'Auto Post')
+      self.post = post
+    end
+
+    def run_instance_after_save
+      @instance_after_save.call
+    end
+  end
+
   let(:new_post) do
     Post.new do |post|
       post.permalink = 'new-post'
@@ -83,4 +105,15 @@ describe Cequel::Record::Callbacks do
     it { should include(:before_destroy) }
     it { should include(:after_destroy) }
   end
+
+  describe 'atomic writes' do
+    it 'should run callbacks in a logged batch' do
+      comment = Comment.new(:body => 'Great web site!')
+      comment.instance_after_save =
+        -> { expect { Post.find('autopost') }.
+          to raise_error(Cequel::Record::RecordNotFound) }
+      comment.save!
+      Post.find('autopost').title.should == 'Auto Post'
+    end
+  end
 end

data/spec/examples/record/record_set_spec.rb

@@ -36,53 +36,92 @@ describe Cequel::Record::RecordSet do
     column :permalink, :ascii, index: true
   end
 
-  let(:subdomains) { [] }
+  let(:subdomains) { blogs.map(&:subdomain) }
   let(:uuids) { Array.new(2) { CassandraCQL::UUID.new }}
   let(:now) { Time.at(Time.now.to_i) }
 
-  before do
-    cequel.batch do
-      3.times do |i|
-        Blog.new do |blog|
-          subdomains << blog.subdomain = "blog-#{i}"
-          blog.name = "Blog #{i}"
-          blog.description = "This is Blog number #{i}"
-        end.save
+  let(:blogs) do
+    3.times.map do |i|
+      Blog.new do |blog|
+        blog.subdomain = "blog-#{i}"
+        blog.name = "Blog #{i}"
+        blog.description = "This is Blog number #{i}"
       end
+    end
+  end
 
-      5.times do |i|
-        cequel[:posts].insert(
-          :blog_subdomain => 'cassandra',
-          :permalink => "cequel#{i}",
-          :title => "Cequel #{i}",
-          :body => "Post number #{i}",
-          :author_id => uuids[i%2]
-        )
-        cequel[:published_posts].insert(
-          :blog_subdomain => 'cassandra',
-          :published_at => max_uuid(now + (i - 4).minutes),
-          :permalink => "cequel#{i}"
-        )
-        cequel[:posts].insert(
-          :blog_subdomain => 'postgres',
-          :permalink => "sequel#{i}",
-          :title => "Sequel #{i}"
-        )
-      end
+  let(:cassandra_posts) do
+    5.times.map do |i|
+      Post.new(
+        :blog_subdomain => 'cassandra',
+        :permalink => "cequel#{i}",
+        :title => "Cequel #{i}",
+        :body => "Post number #{i}",
+        :author_id => uuids[i%2]
+      )
+    end
+  end
 
-      5.times do |i|
-        cequel[:comments].insert(
-          :blog_subdomain => 'cassandra',
-          :permalink => 'cequel0',
-          :id => CassandraCQL::UUID.new(Time.now - 5 + i),
-          :body => "Comment #{i}"
-        )
-      end
+  let(:published_posts) do
+    5.times.map do |i|
+      PublishedPost.new(
+        :blog_subdomain => 'cassandra',
+        :published_at => max_uuid(now + (i - 4).minutes),
+        :permalink => "cequel#{i}"
+      )
+    end
+  end
+
+  let(:postgres_posts) do
+    5.times.map do |i|
+      Post.new(
+        :blog_subdomain => 'postgres',
+        :permalink => "sequel#{i}",
+        :title => "Sequel #{i}"
+      )
+    end
+  end
+
+  let(:mongo_posts) do
+    5.times.map do |i|
+      Post.new(
+        :blog_subdomain => 'mongo',
+        :permalink => "mongoid#{i}",
+        :title => "Mongoid #{i}"
+      )
+    end
+  end
+
+  let(:orm_posts) do
+    5.times.map do |i|
+      Post.new(
+        :blog_subdomain => 'orms',
+        :permalink => "cequel#{i}",
+        :title => "Cequel ORM #{i}"
+      )
     end
   end
 
+  let(:posts) { [cassandra_posts, postgres_posts] }
+
+  let(:comments) do
+    5.times.map do |i|
+      Comment.new(
+        :blog_subdomain => 'cassandra',
+        :permalink => 'cequel0',
+        :id => CassandraCQL::UUID.new(Time.now - 5 + i),
+        :body => "Comment #{i}"
+      )
+    end
+  end
+
+  let(:records) { posts }
+
+  before { cequel.batch { records.flatten.each { |record| record.save! }}}
+
   describe '::find' do
     context 'simple primary key' do
+      let(:records) { blogs }
       subject { Blog.find('blog-0') }
 
       its(:subdomain) { should == 'blog-0' }
@@ -104,6 +143,7 @@ describe Cequel::Record::RecordSet do
     end
 
     context 'compound primary key' do
+      let(:records) { cassandra_posts }
       subject { Post['cassandra'].find('cequel0') }
 
       its(:blog_subdomain) { should == 'cassandra' }
@@ -128,7 +168,8 @@ describe Cequel::Record::RecordSet do
   end
 
   describe '::[]' do
-    context 'simple primary key' do
+    context 'fully specified simple primary key' do
+      let(:records) { blogs }
       subject { Blog['blog-0'] }
 
       it 'should not query the database' do
@@ -151,7 +192,32 @@ describe Cequel::Record::RecordSet do
       end
     end
 
-    context 'compound primary key' do
+    context 'multiple simple primary keys' do
+      let(:records) { blogs }
+      subject { Blog['blog-0', 'blog-1'] }
+
+      it 'should return both specified records' do
+        subject.map(&:subdomain).should =~ %w(blog-0 blog-1)
+      end
+
+      it 'should not query the database' do
+        disallow_queries!
+        subject.map(&:subdomain)
+      end
+
+      it 'should load value lazily' do
+        subject.first.name.should == 'Blog 0'
+      end
+
+      it 'should load values for all referenced records on first access' do
+        max_statements! 1
+        subject.first.name.should == 'Blog 0'
+        subject.last.name.should == 'Blog 1'
+      end
+    end
+
+    context 'fully specified compound primary key' do
+      let(:records) { posts }
       subject { Post['cassandra']['cequel0'] }
 
       it 'should not query the database' do
@@ -175,61 +241,118 @@ describe Cequel::Record::RecordSet do
         subject.body.should == 'Post number 0'
       end
     end
+
+    context 'fully specified compound primary key with multiple clustering columns' do
+      let(:records) { posts }
+      subject { Post['cassandra']['cequel0', 'cequel1'] }
+
+      it 'should combine partition key with each clustering column' do
+        disallow_queries!
+        subject.map(&:key_values).
+          should == [['cassandra', 'cequel0'], ['cassandra', 'cequel1']]
+      end
+
+      it 'should lazily load all records when one record accessed' do
+        max_statements! 1
+        subject.first.title.should == 'Cequel 0'
+        subject.second.title.should == 'Cequel 1'
+      end
+
+      it 'should not allow collection columns to be selected' do
+        expect { Post.select(:tags)['cassandra']['cequel0', 'cequel1'] }.
+          to raise_error(ArgumentError)
+      end
+    end
+
+    context 'partially specified compound primary key' do
+      let(:records) { posts }
+      it 'should create partial collection if not all keys specified' do
+        Post['cassandra'].find_each(:batch_size => 2).map(&:title).
+          should == (0...5).map { |i| "Cequel #{i}" }
+      end
+    end
+
+    context 'partially specified compound primary key with multiple partition keys' do
+      let(:records) { posts }
+      subject { Post['cassandra', 'postgres'] }
+
+      it 'should return scope to keys' do
+        subject.map { |post| post.title }.should =~ (0...5).
+          map { |i| ["Cequel #{i}", "Sequel #{i}"] }.flatten
+      end
+    end
+
+    context 'fully specified compound primary key with multiple partition keys' do
+      let(:records) { [posts, orm_posts] }
+
+      subject { Post['cassandra', 'orms']['cequel0'] }
+
+      it 'should return collection of unloaded models' do
+        disallow_queries!
+        subject.map(&:key_values).
+          should == [['cassandra', 'cequel0'], ['orms', 'cequel0']]
+      end
+
+      it 'should lazy-load all records when properties of one accessed' do
+        max_statements! 1
+        subject.first.title.should == 'Cequel 0'
+        subject.second.title.should == 'Cequel ORM 0'
+      end
+    end
   end
 
   describe '#all' do
+    let(:records) { blogs }
+
     it 'should return all the records' do
       Blog.all.map(&:subdomain).should =~ subdomains
     end
   end
 
   describe '#find_each' do
+    let(:records) { [posts, blogs, mongo_posts] }
+
     it 'should respect :batch_size argument' do
       cequel.should_receive(:execute).twice.and_call_original
       Blog.find_each(:batch_size => 2).map(&:subdomain).
         should =~ subdomains
     end
     it 'should iterate over all keys' do
-      Post.find_each(:batch_size => 2).map(&:title).
-        should =~ (0...5).flat_map { |i| ["Cequel #{i}", "Sequel #{i}"] }
+      Post.find_each(:batch_size => 2).map(&:title).should =~
+        (0...5).flat_map { |i| ["Cequel #{i}", "Sequel #{i}", "Mongoid #{i}"] }
     end
   end
 
-  describe '#at' do
+  describe '#[]' do
     it 'should return partial collection' do
-      Post.at('cassandra').find_each(:batch_size => 2).map(&:title).
+      Post['cassandra'].find_each(:batch_size => 2).map(&:title).
         should == (0...5).map { |i| "Cequel #{i}" }
     end
 
     it 'should cast arguments correctly' do
-      Post.at('cassandra'.force_encoding('ASCII-8BIT')).
+      Post['cassandra'.force_encoding('ASCII-8BIT')].
         find_each(:batch_size => 2).map(&:title).
         should == (0...5).map { |i| "Cequel #{i}" }
     end
   end
 
-  describe '#[]' do
-    it 'should create partial collection if not all keys specified' do
-      Post['cassandra'].find_each(:batch_size => 2).map(&:title).
-        should == (0...5).map { |i| "Cequel #{i}" }
-    end
-  end
-
   describe '#/' do
-    it 'should behave like #at' do
+    it 'should behave like #[]' do
       (Post / 'cassandra').find_each(:batch_size => 2).map(&:title).
         should == (0...5).map { |i| "Cequel #{i}" }
     end
   end
 
   describe '#after' do
+    let(:records) { [posts, published_posts] }
+
     it 'should return collection after given key' do
-      Post.at('cassandra').after('cequel1').map(&:title).
+      Post['cassandra'].after('cequel1').map(&:title).
         should == (2...5).map { |i| "Cequel #{i}" }
     end
 
     it 'should cast argument' do
-      Post.at('cassandra').after('cequel1'.force_encoding('ASCII-8BIT')).
+      Post['cassandra'].after('cequel1'.force_encoding('ASCII-8BIT')).
         map(&:title).should == (2...5).map { |i| "Cequel #{i}" }
     end
 
@@ -240,13 +363,15 @@ describe Cequel::Record::RecordSet do
   end
 
   describe '#from' do
+    let(:records) { [posts, published_posts] }
+
     it 'should return collection starting with given key' do
-      Post.at('cassandra').from('cequel1').map(&:title).
+      Post['cassandra'].from('cequel1').map(&:title).
         should == (1...5).map { |i| "Cequel #{i}" }
     end
 
     it 'should cast argument' do
-      Post.at('cassandra').from('cequel1'.force_encoding('ASCII-8BIT')).
+      Post['cassandra'].from('cequel1'.force_encoding('ASCII-8BIT')).
         map(&:title).should == (1...5).map { |i| "Cequel #{i}" }
     end
 
@@ -262,8 +387,10 @@ describe Cequel::Record::RecordSet do
   end
 
   describe '#before' do
+    let(:records) { [posts, published_posts] }
+
     it 'should return collection before given key' do
-      Post.at('cassandra').before('cequel3').map(&:title).
+      Post['cassandra'].before('cequel3').map(&:title).
         should == (0...3).map { |i| "Cequel #{i}" }
     end
 
@@ -273,19 +400,21 @@ describe Cequel::Record::RecordSet do
     end
 
     it 'should cast argument' do
-      Post.at('cassandra').before('cequel3'.force_encoding('ASCII-8BIT')).
+      Post['cassandra'].before('cequel3'.force_encoding('ASCII-8BIT')).
         map(&:title).should == (0...3).map { |i| "Cequel #{i}" }
     end
   end
 
   describe '#upto' do
+    let(:records) { [posts, published_posts] }
+
     it 'should return collection up to given key' do
-      Post.at('cassandra').upto('cequel3').map(&:title).
+      Post['cassandra'].upto('cequel3').map(&:title).
         should == (0..3).map { |i| "Cequel #{i}" }
     end
 
     it 'should cast argument' do
-      Post.at('cassandra').upto('cequel3'.force_encoding('ASCII-8BIT')).
+      Post['cassandra'].upto('cequel3'.force_encoding('ASCII-8BIT')).
         map(&:title).should == (0..3).map { |i| "Cequel #{i}" }
     end
 
@@ -296,19 +425,21 @@ describe Cequel::Record::RecordSet do
   end
 
   describe '#in' do
+    let(:records) { [posts, published_posts] }
+
     it 'should return collection with inclusive upper bound' do
-      Post.at('cassandra').in('cequel1'..'cequel3').map(&:title).
+      Post['cassandra'].in('cequel1'..'cequel3').map(&:title).
         should == (1..3).map { |i| "Cequel #{i}" }
     end
 
     it 'should cast arguments' do
-      Post.at('cassandra').in('cequel1'.force_encoding('ASCII-8BIT')..
+      Post['cassandra'].in('cequel1'.force_encoding('ASCII-8BIT')..
                               'cequel3'.force_encoding('ASCII-8BIT')).
         map(&:title).should == (1..3).map { |i| "Cequel #{i}" }
     end
 
     it 'should return collection with exclusive upper bound' do
-      Post.at('cassandra').in('cequel1'...'cequel3').map(&:title).
+      Post['cassandra'].in('cequel1'...'cequel3').map(&:title).
         should == (1...3).map { |i| "Cequel #{i}" }
     end
 
@@ -324,18 +455,20 @@ describe Cequel::Record::RecordSet do
   end
 
   describe '#reverse' do
+    let(:records) { [posts, comments] }
+
     it 'should not call the database' do
       disallow_queries!
-      Post.at('cassandra').reverse
+      Post['cassandra'].reverse
     end
 
     it 'should return collection in reverse' do
-      Post.at('cassandra').reverse.map(&:title).
+      Post['cassandra'].reverse.map(&:title).
         should == (0...5).map { |i| "Cequel #{i}" }.reverse
     end
 
     it 'should batch iterate over collection in reverse' do
-      Post.at('cassandra').reverse.find_each(:batch_size => 2).map(&:title).
+      Post['cassandra'].reverse.find_each(:batch_size => 2).map(&:title).
         should == (0...5).map { |i| "Cequel #{i}" }.reverse
     end
 
@@ -351,16 +484,18 @@ describe Cequel::Record::RecordSet do
 
   describe 'last' do
     it 'should return the last instance' do
-      Post.at('cassandra').last.title.should == "Cequel 4"
+      Post['cassandra'].last.title.should == "Cequel 4"
     end
 
     it 'should return the last N instances if specified' do
-      Post.at('cassandra').last(3).map(&:title).
+      Post['cassandra'].last(3).map(&:title).
         should == ["Cequel 2", "Cequel 3", "Cequel 4"]
     end
   end
 
   describe '#first' do
+    let(:records) { blogs }
+
     context 'with no arguments' do
       it 'should return an arbitrary record' do
         subdomains.should include(Blog.first.subdomain)
@@ -377,12 +512,16 @@ describe Cequel::Record::RecordSet do
   end
 
   describe '#limit' do
-    it 'should return the number of blogs requested' do
+    let(:records) { blogs }
+
+    it 'should return the number of records requested' do
       Blog.limit(2).should have(2).entries
     end
   end
 
   describe '#select' do
+    let(:records) { blogs }
+
     context 'with no block' do
       subject { Blog.select(:subdomain, :name).first }
 
@@ -435,6 +574,8 @@ describe Cequel::Record::RecordSet do
   end
 
   describe '#count' do
+    let(:records) { blogs }
+
     it 'should count records' do
       Blog.count.should == 3
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cequel
 version: !ruby/object:Gem::Version
-  version: 1.0.0.pre.5
+  version: 1.0.0.pre.6
 platform: ruby
 authors:
 - Mat Brown
@@ -12,7 +12,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-08 00:00:00.000000000 Z
+date: 2013-11-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -62,14 +62,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.9.2
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: i18n
   requirement: !ruby/object:Gem::Requirement
@@ -160,6 +160,7 @@ files:
 - lib/cequel/record/dirty.rb
 - lib/cequel/record/errors.rb
 - lib/cequel/record/has_many_association.rb
+- lib/cequel/record/lazy_record_collection.rb
 - lib/cequel/record/mass_assignment.rb
 - lib/cequel/record/persistence.rb
 - lib/cequel/record/properties.rb