cequel 0.5.6 → 1.0.0.pre.1

data/lib/cequel/model/railtie.rb

@@ -4,27 +4,34 @@ module Cequel
 
     class Railtie < Rails::Railtie
 
-      config.cequel = Cequel::Model
+      config.cequel = Cequel::Model::Base
 
       initializer "cequel.configure_rails" do
+        app_name = Rails.application.railtie_name.sub(/_application$/, '')
         config_path = Rails.root.join('config/cequel.yml').to_s
 
         if File.exist?(config_path)
-          yaml = YAML::load(ERB.new(IO.read(config_path)).result)[Rails.env]
-          Cequel::Model.configure(yaml.symbolize_keys) if yaml
+          config = YAML::load(ERB.new(IO.read(config_path)).result)[Rails.env].
+            deep_symbolize_keys
+        else
+          config = {host: '127.0.0.1:9160'}
         end
-
-        Cequel::Model.logger = Rails.logger
-      end
-
-      initializer "cequel.instantiate_observers" do
-        config.after_initialize do
-          ::Cequel::Model.instantiate_observers
-
-          ActionDispatch::Callbacks.to_prepare do
-            ::Cequel::Model.instantiate_observers
-          end
+        config.reverse_merge!(keyspace: "#{app_name}_#{Rails.env}")
+        connection = Cequel.connect(config)
+
+        begin
+          connection = Cequel.connect(config)
+        rescue CassandraCQL::Error::InvalidRequestException
+          connection = Cequel.connect(config.except(:keyspace))
+          #XXX This should be read from the configuration
+          connection.execute(<<-CQL)
+            CREATE KEYSPACE #{keyspace}
+            WITH REPLICATION = {'class': 'SimpleStrategy', 'replication_factor': 1}
+          CQL
+          retry
         end
+        connection.logger = Rails.logger
+        Cequel::Model::Base.connection = connection
       end
     end
 

data/lib/cequel/model/record_set.rb

@@ -0,0 +1,285 @@
+module Cequel
+
+  module Model
+
+    class RecordSet
+
+      extend Forwardable
+      include Enumerable
+
+      Bound = Struct.new(:value, :inclusive)
+
+      def initialize(clazz)
+        @clazz = clazz
+        @select_columns = []
+        @scoped_key_values = []
+      end
+
+      def all
+        self
+      end
+
+      def select(*columns)
+        return super if block_given?
+        scoped { |record_set| record_set.select_columns.concat(columns) }
+      end
+
+      def limit(count)
+        scoped { |record_set| record_set.row_limit = count }
+      end
+
+      def at(*scoped_key_values)
+        record_set_class = next_key_column.partition_key? ?
+          RecordSet : SortableRecordSet
+        scoped(record_set_class) do |record_set|
+          record_set.scoped_key_values.concat(scoped_key_values)
+        end
+      end
+
+      def [](scoped_key_value)
+        if next_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
+      end
+
+      def find(*scoped_key_values)
+        self[*scoped_key_values].load!
+      end
+
+      def /(scoped_key_value)
+        at(scoped_key_value)
+      end
+
+      def after(start_key)
+        scoped do |record_set|
+          record_set.lower_bound = Bound.new(start_key, false)
+        end
+      end
+
+      def before(end_key)
+        scoped do |record_set|
+          record_set.upper_bound = Bound.new(end_key, false)
+        end
+      end
+
+      def in(range)
+        scoped do |record_set|
+          record_set.lower_bound = Bound.new(range.first, true)
+          record_set.upper_bound = Bound.new(range.last, !range.exclude_end?)
+        end
+      end
+
+      def first(count = nil)
+        count ? limit(count).entries : limit(1).each.first
+      end
+
+      def count
+        data_set.count
+      end
+
+      def each(&block)
+        find_each(&block)
+      end
+
+      def find_each(options = {})
+        return enum_for(:find_each, options) unless block_given?
+        find_each_row(options) { |row| yield clazz.hydrate(row) }
+      end
+
+      def find_each_row(options = {}, &block)
+        return enum_for(:find_each_row, options) unless block
+        find_rows_in_batches(options) { |row| row.each(&block) }
+      end
+
+      def find_rows_in_batches(options = {}, &block)
+        return find_rows_in_single_batch(options, &block) if row_limit
+        batch_size = options.fetch(:batch_size, 1000)
+        batch_record_set = base_record_set = limit(batch_size)
+        more_results = true
+
+        while more_results
+          rows = batch_record_set.find_rows_in_single_batch
+          yield rows if rows.any?
+          more_results = rows.length == batch_size
+          last_row = rows.last
+          if more_results
+            find_nested_batches_from(last_row, options, &block)
+            batch_record_set = base_record_set.next_batch_from(last_row)
+          end
+        end
+      end
+
+      protected
+      attr_accessor :row_limit
+      attr_reader :select_columns, :scoped_key_values,
+        :lower_bound, :upper_bound
+
+      def reversed?
+        false
+      end
+
+      def lower_bound=(bound)
+        @lower_bound = bound
+      end
+
+      def upper_bound=(bound)
+        @upper_bound = bound
+      end
+
+      def data_set
+        @data_set ||= construct_data_set
+      end
+
+      def next_batch_from(row)
+        reversed? ? before(row[range_key_name]) : after(row[range_key_name])
+      end
+
+      def find_nested_batches_from(row, options, &block)
+        if next_key_column
+          at(row[range_key_name]).
+            next_batch_from(row).
+            find_rows_in_batches(options, &block)
+        end
+      end
+
+      def find_rows_in_single_batch(options = {})
+        if options.key?(:batch_size)
+          raise ArgumentError,
+            "Can't pass :batch_size argument with a limit in the scope"
+        else
+          data_set.entries.tap do |batch|
+            yield batch if batch.any? && block_given?
+          end
+        end
+      end
+
+      def range_key
+        clazz.key_columns[scoped_key_values.length]
+      end
+
+      def range_key_name
+        range_key.name
+      end
+
+      def scoped_key_columns
+        clazz.key_columns.first(scoped_key_values.length)
+      end
+
+      def scoped_key_names
+        scoped_key_columns.map { |column| column.name }
+      end
+
+      def chain_from(collection)
+        @select_columns = collection.select_columns.dup
+        @scoped_key_values = collection.scoped_key_values.dup
+        @lower_bound = collection.lower_bound
+        @upper_bound = collection.upper_bound
+        @row_limit = collection.row_limit
+        self
+      end
+
+      private
+      attr_reader :clazz
+      def_delegators :clazz, :connection
+
+      def scoped(record_set_class = self.class, &block)
+        record_set_class.new(clazz).chain_from(self).tap(&block)
+      end
+
+      def next_key_column
+        clazz.key_columns[scoped_key_values.length + 1]
+      end
+
+      def next_key_name
+        next_key_column.name if next_key_column
+      end
+
+      def construct_data_set
+        data_set = connection[clazz.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
+          key_conditions = Hash[scoped_key_names.zip(scoped_key_values)]
+          data_set = data_set.where(key_conditions)
+        end
+        if lower_bound
+          fragment = construct_bound_fragment(lower_bound, '>')
+          data_set = data_set.where(fragment, lower_bound.value)
+        end
+        if upper_bound
+          fragment = construct_bound_fragment(upper_bound, '<')
+          data_set = data_set.where(fragment, upper_bound.value)
+        end
+        data_set
+      end
+
+      def construct_bound_fragment(bound, base_operator)
+        operator = bound.inclusive ? "#{base_operator}=" : base_operator
+        "TOKEN(#{range_key_name}) #{operator} TOKEN(?)"
+      end
+
+    end
+
+    class SortableRecordSet < RecordSet
+
+      def initialize(clazz)
+        super
+        @reversed = false
+      end
+
+      def from(start_key)
+        scoped do |record_set|
+          record_set.lower_bound = Bound.new(start_key, true)
+        end
+      end
+
+      def upto(end_key)
+        scoped do |record_set|
+          record_set.upper_bound = Bound.new(end_key, true)
+        end
+      end
+
+      def reverse
+        scoped { |scope| scope.reversed = !reversed? }
+      end
+
+      def last
+        reverse.first
+      end
+
+      def chain_from(collection)
+        super
+        @reversed = collection.reversed?
+        self
+      end
+
+      protected
+      attr_writer :reversed
+
+      def construct_data_set
+        data_set = super
+        data_set = data_set.order(range_key_name => :desc) if reversed?
+        data_set
+      end
+
+      def reversed?
+        @reversed
+      end
+
+      def construct_bound_fragment(bound, base_operator)
+        operator = bound.inclusive ? "#{base_operator}=" : base_operator
+        "#{range_key_name} #{operator} ?"
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/model/schema.rb

@@ -0,0 +1,33 @@
+module Cequel
+
+  module Model
+
+    module Schema
+
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        extend Forwardable
+
+        def_delegators :table_schema, :key_columns, :key_column_names
+
+        def synchronize_schema
+          Cequel::Schema::TableSynchronizer.
+            apply(connection, read_schema, table_schema)
+        end
+
+        def read_schema
+          connection.schema.read_table(table_name)
+        end
+
+        def table_schema
+          @table_schema ||= Cequel::Schema::Table.new(table_name)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/cequel/model/scoped.rb

@@ -4,55 +4,12 @@ module Cequel
 
     module Scoped
 
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-        delegate :consistency, :count, :first, :limit, :select, :where,
-          :find_in_batches, :find_each, :find_rows_in_batches, :find_each_row,
-          :to => :all
-
-        def default_scope(scope)
-          @_cequel.default_scope = scope
-        end
-
-        def all
-          current_scope || @_cequel.default_scope || empty_scope
-        end
-
-        def select(*rows)
-          all.select(*rows)
-        end
-
-        def with_scope(scope)
-          @_cequel.synchronize do
-            old_scope = current_scope
-            begin
-              self.current_scope = scope
-              yield
-            ensure
-              self.current_scope = old_scope
-            end
-          end
-        end
-
-        private
-
-        def empty_scope
-          Scope.new(self, [column_family])
-        end
-
-        def current_scope
-          ::Thread.current[current_scope_key]
-        end
-
-        def current_scope=(scope)
-          ::Thread.current[current_scope_key] = scope
-        end
-
-        def current_scope_key
-          :"cequel-current_scope-#{object_id}"
-        end
+      extend Forwardable
 
+      def_delegators :current_scope, *RecordSet.instance_methods(false)
+
+      def current_scope
+        RecordSet.new(self)
       end
 
     end

data/lib/cequel/model/validations.rb

@@ -1,5 +1,5 @@
 module Cequel
-  
+
   module Model
 
     module Validations
@@ -8,35 +8,35 @@ module Cequel
 
       included do
         include ActiveModel::Validations
-        alias_method_chain :valid?, :callbacks # XXX is there no better way?
+        define_model_callbacks :validation
+        alias_method_chain :valid?, :callbacks
       end
 
       module ClassMethods
 
-        def create!(attributes = {}, &block)
-          instance = new(attributes, &block)
-          instance.save!
+        def create!(attributes, &block)
+          new(attributes, &block).save!
         end
 
       end
 
-      def save(*args)
-        if valid?
-          super
-          true
-        else
-          false
-        end
+      def save(options = {})
+        validate = options.fetch(:validate, true)
+        options.delete(:validate)
+        (!validate || valid?) && super
       end
 
-      def save!(*args)
-        raise RecordInvalid, errors.full_messages.join("; ") unless save
-        self
+      def save!(options = {})
+        tap do
+          unless save(options)
+            raise RecordInvalid, errors.full_messages.join("; ")
+          end
+        end
       end
 
-      def update_attributes!(*args)
-        raise RecordInvalid, errors.full_messages.join("; ") unless update_attributes(*args)
-        self
+      def update_attributes!(attributes)
+        self.attributes = attributes
+        save!
       end
 
       def valid_with_callbacks?