believer 0.1

data/lib/believer/command.rb

@@ -0,0 +1,44 @@
+module Believer
+  class Command
+
+    attr_accessor :record_class
+
+    def initialize(attrs = {})
+      attrs.each do |name, value|
+        send("#{name}=", value)
+      end if attrs.present?
+      #@instrumenter = ActiveSupport::Notifications.instrumenter
+    end
+
+    def clone
+      self.class.new(query_attributes)
+    end
+
+    def query_attributes
+      {:record_class => @record_class}
+    end
+
+    def connection
+      @record_class.connection
+    end
+
+    def execute(name = 'cql.cql_record')
+      cql = to_cql
+      begin
+        start = Time.now
+        puts "Executing #{cql}"
+        res = connection.execute(cql)
+        #Rails.logger.debug "#{name} #{sprintf "%.3f", (Time.now - start)*1000.0} ms: #{cql}"
+        return res
+      rescue Cql::Protocol::DecodingError => e
+        # Decoding errors tend to #$%# up the connection, resulting in no more activity, so a reconnect is performed here.
+        # This is a known issue in cql-rb, and will be fixed in version 1.10
+        @record_class.reset_connection
+        raise e
+      end
+
+    end
+
+  end
+
+end

data/lib/believer/connection.rb

@@ -0,0 +1,22 @@
+module Believer
+  module Connection
+    extend ::ActiveSupport::Concern
+
+    module ClassMethods
+
+      def reset_connection
+        unless connection.nil?
+          connection.close
+          @client_connection = nil
+        end
+      end
+
+      def connection
+        @client_connection ||= environment.create_connection(:connect_to_keyspace => true)
+      end
+
+    end
+
+  end
+
+end

data/lib/believer/ddl.rb

@@ -0,0 +1,36 @@
+module Believer
+
+  module DDL
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def create_table
+        cql = create_table_cql
+        puts "Creating table #{table_name} using CQL:\n#{cql}"
+        connection.execute(cql)
+        puts "Created table #{table_name}"
+      end
+
+      def create_table_cql
+        s = "CREATE TABLE #{table_name} (\n"
+        col_statement_parts = columns.keys.map {|col| "#{col} #{columns[col].cql_column_type}"}
+        s << col_statement_parts.join(",\n")
+
+        keys = []
+        get_primary_key.each do |key_part|
+          if key_part.is_a?(Enumerable)
+            keys << "(#{key_part.join(',')})"
+          else
+            keys << key_part
+          end
+        end
+        s << ",\n"
+        s << "PRIMARY KEY (#{keys.join(',')})"
+        s << "\n)"
+        s
+      end
+    end
+
+  end
+
+end

data/lib/believer/delete.rb

@@ -0,0 +1,11 @@
+module Believer
+  class Delete < ScopedCommand
+
+    def to_cql
+      cql = "DELETE FROM #{@record_class.table_name}"
+      cql << " WHERE #{@wheres.map { |wc| "#{wc.to_cql}" }.join(' AND ')}" if @wheres && @wheres.any?
+      cql
+    end
+
+  end
+end

data/lib/believer/empty_result.rb

@@ -0,0 +1,32 @@
+module Believer
+
+  class EmptyResult
+    DATA_METHODS = {
+        :execute => [],
+        :destroy_all => nil,
+        :delete_all => 0,
+        :to_a => [],
+        :size => 0,
+        :count => 0,
+        :each => nil,
+        :first => nil,
+        :last => nil,
+        :any? => false
+    }
+    QUERY_METHODS = [:select, :where, :order, :limit]
+
+    DATA_METHODS.each do |method_name, return_val|
+      define_method(method_name) do |*|
+        return_val
+      end
+    end
+
+    QUERY_METHODS.each do |method_name|
+      define_method(method_name) do |*|
+        self
+      end
+    end
+
+  end
+
+end

data/lib/believer/environment.rb

@@ -0,0 +1,51 @@
+module Believer
+  module Environment
+    extend ::ActiveSupport::Concern
+
+    module ClassMethods
+
+      def environment
+        if @environment.nil?
+          if defined?(Rails)
+            @environment = RailsEnvironment.new
+          end
+        end
+        @environment
+      end
+
+      def environment=(env)
+        @environment = env
+      end
+
+    end
+
+    class Base
+      def create_connection(options = {})
+        cc = connection_configuration
+
+        if options[:connect_to_keyspace] && cc[:keyspace]
+          connection = Cql::Client.connect(cc)
+          connection.use(cc[:keyspace])
+        else
+          connection = Cql::Client.connect(cc.delete_if {|k,v|k==:keyspace})
+        end
+        connection
+      end
+
+      def create_keyspace(connection = nil)
+        conn = connection || create_connection
+        ks_def = <<-KSDEF
+          CREATE KEYSPACE #{connection_configuration[:keyspace]}
+          WITH replication = {
+            'class': 'SimpleStrategy',
+            'replication_factor': 1
+          }
+        KSDEF
+
+        conn.execute(ks_def)
+      end
+
+    end
+
+  end
+end

data/lib/believer/environment/rails_environment.rb

@@ -0,0 +1,19 @@
+
+module Believer
+  module Environment
+    class RailsEnvironment < Base
+
+      def connection_configuration
+        unless @connection_configuration
+          config_file = Rails.root + "config/cql.yml"
+          #puts "Using CQL connection config file: #{config_file}"
+          config = YAML::load(File.open(config_file.to_s))
+          env_config = config[Rails.env]
+          @connection_configuration = env_config.symbolize_keys
+          @connection_configuration[:logger] = Rails.logger
+        end
+        @connection_configuration
+      end
+    end
+  end
+end

data/lib/believer/insert.rb

@@ -0,0 +1,18 @@
+module Believer
+
+  class Insert < Command
+    include Values
+
+    attr_accessor :values
+
+    def values=(v)
+      @values = v.is_a?(Base) ? v.attributes : v.to_hash
+    end
+
+    def to_cql
+      attrs = @values.keys
+      "INSERT INTO #{@record_class.table_name} (#{attrs.join(', ')}) VALUES (#{attrs.map {|a| to_cql_literal(@values[a]) }.join(', ')})"
+    end
+  end
+
+end

data/lib/believer/limit.rb

@@ -0,0 +1,20 @@
+module Believer
+
+  class Limit
+    attr_reader :size
+
+    def initialize(l)
+      @size = l.to_i
+    end
+
+    def to_cql
+      "LIMIT #{@size}"
+    end
+
+    def to_i
+      @size
+    end
+
+  end
+  
+end

data/lib/believer/model_schema.rb

@@ -0,0 +1,176 @@
+module Believer
+  module ModelSchema
+    extend ActiveSupport::Concern
+
+    included do
+      ##
+      # :singleton-method:
+      # Accessor for the name of the prefix string to prepend to every table name. So if set
+      # to "basecamp_", all table names will be named like "basecamp_projects", "basecamp_people",
+      # etc. This is a convenient way of creating a namespace for tables in a shared database.
+      # By default, the prefix is the empty string.
+      #
+      # If you are organising your models within modules you can add a prefix to the models within
+      # a namespace by defining a singleton method in the parent module called table_name_prefix which
+      # returns your chosen prefix.
+      class_attribute :table_name_prefix, :instance_writer => false
+      self.table_name_prefix = ""
+
+      ##
+      # :singleton-method:
+      # Works like +table_name_prefix+, but appends instead of prepends (set to "_basecamp" gives "projects_basecamp",
+      # "people_basecamp"). By default, the suffix is the empty string.
+      class_attribute :table_name_suffix, :instance_writer => false
+      self.table_name_suffix = ""
+
+      ##
+      # :singleton-method:
+      # Indicates whether table names should be the pluralized versions of the corresponding class names.
+      # If true, the default table name for a Product class will be +products+. If false, it would just be +product+.
+      # See table_name for the full rules on table/class naming. This is true, by default.
+      class_attribute :pluralize_table_names, :instance_writer => false
+      self.pluralize_table_names = true
+    end
+
+    module ClassMethods
+      # Guesses the table name (in forced lower-case) based on the name of the class in the
+      # inheritance hierarchy descending directly from ActiveRecord::Base. So if the hierarchy
+      # looks like: Reply < Message < ActiveRecord::Base, then Message is used
+      # to guess the table name even when called on Reply. The rules used to do the guess
+      # are handled by the Inflector class in Active Support, which knows almost all common
+      # English inflections. You can add new inflections in config/initializers/inflections.rb.
+      #
+      # Nested classes are given table names prefixed by the singular form of
+      # the parent's table name. Enclosing modules are not considered.
+      #
+      # ==== Examples
+      #
+      #   class Invoice < ActiveRecord::Base
+      #   end
+      #
+      #   file                  class               table_name
+      #   invoice.rb            Invoice             invoices
+      #
+      #   class Invoice < ActiveRecord::Base
+      #     class Lineitem < ActiveRecord::Base
+      #     end
+      #   end
+      #
+      #   file                  class               table_name
+      #   invoice.rb            Invoice::Lineitem   invoice_lineitems
+      #
+      #   module Invoice
+      #     class Lineitem < ActiveRecord::Base
+      #     end
+      #   end
+      #
+      #   file                  class               table_name
+      #   invoice/lineitem.rb   Invoice::Lineitem   lineitems
+      #
+      # Additionally, the class-level +table_name_prefix+ is prepended and the
+      # +table_name_suffix+ is appended. So if you have "myapp_" as a prefix,
+      # the table name guess for an Invoice class becomes "myapp_invoices".
+      # Invoice::Lineitem becomes "myapp_invoice_lineitems".
+      #
+      # You can also set your own table name explicitly:
+      #
+      #   class Mouse < ActiveRecord::Base
+      #     self.table_name = "mice"
+      #   end
+      #
+      # Alternatively, you can override the table_name method to define your
+      # own computation. (Possibly using <tt>super</tt> to manipulate the default
+      # table name.) Example:
+      #
+      #   class Post < ActiveRecord::Base
+      #     def self.table_name
+      #       "special_" + super
+      #     end
+      #   end
+      #   Post.table_name # => "special_posts"
+      def table_name
+        reset_table_name unless defined?(@table_name)
+        @table_name
+      end
+
+      def original_table_name #:nodoc:
+        deprecated_original_property_getter :table_name
+      end
+
+      # Sets the table name explicitly. Example:
+      #
+      #   class Project < ActiveRecord::Base
+      #     self.table_name = "project"
+      #   end
+      #
+      # You can also just define your own <tt>self.table_name</tt> method; see
+      # the documentation for ActiveRecord::Base#table_name.
+      def table_name=(value)
+        @original_table_name = @table_name if defined?(@table_name)
+        @table_name          = value && value.to_s
+        @quoted_table_name   = nil
+      end
+
+      def set_table_name(value = nil, &block) #:nodoc:
+        deprecated_property_setter :table_name, value, block
+        @quoted_table_name = nil
+      end
+
+      # Returns a quoted version of the table name, used to construct SQL statements.
+      def quoted_table_name
+        @quoted_table_name ||= "`#{table_name}`"
+      end
+
+      # Computes the table name, (re)sets it internally, and returns it.
+      def reset_table_name #:nodoc:
+        self.table_name = compute_table_name
+      end
+
+      def full_table_name_prefix #:nodoc:
+        (parents.detect{ |p| p.respond_to?(:table_name_prefix) } || self).table_name_prefix
+      end
+
+      private
+
+      # Guesses the table name, but does not decorate it with prefix and suffix information.
+      def undecorated_table_name(class_name = base_class.name)
+        table_name = class_name.to_s.demodulize.underscore
+        table_name = table_name.pluralize if pluralize_table_names
+        table_name
+      end
+
+      # Computes and returns a table name according to default conventions.
+      def compute_table_name
+        "#{full_table_name_prefix}#{undecorated_table_name(name)}#{table_name_suffix}"
+      end
+
+      def deprecated_property_setter(property, value, block)
+        if block
+          ActiveSupport::Deprecation.warn(
+              "Calling set_#{property} is deprecated. If you need to lazily evaluate " \
+            "the #{property}, define your own `self.#{property}` class method. You can use `super` " \
+            "to get the default #{property} where you would have called `original_#{property}`."
+          )
+
+          define_attr_method property, value, false, &block
+        else
+          ActiveSupport::Deprecation.warn(
+              "Calling set_#{property} is deprecated. Please use `self.#{property} = 'the_name'` instead."
+          )
+
+          define_attr_method property, value, false
+        end
+      end
+
+      def deprecated_original_property_getter(property)
+        ActiveSupport::Deprecation.warn("original_#{property} is deprecated. Define self.#{property} and call super instead.")
+
+        if !instance_variable_defined?("@original_#{property}") && respond_to?("reset_#{property}")
+          send("reset_#{property}")
+        else
+          instance_variable_get("@original_#{property}")
+        end
+      end
+    end
+  end
+end

data/lib/believer/observer.rb

@@ -0,0 +1,36 @@
+require 'active_model/observing'
+
+module Believer
+
+  class Observer < ::ActiveModel::Observer
+
+    protected
+
+    def observed_classes
+      klasses = super
+      klasses + klasses.map { |klass| klass.descendants }.flatten
+    end
+
+    def add_observer!(klass)
+      super
+      define_callbacks klass
+    end
+
+    def define_callbacks(klass)
+      observer = self
+      observer_name = observer.class.name.underscore.gsub('/', '__')
+
+      Believer::Callbacks::CALLBACKS.each do |callback|
+        next unless respond_to?(callback)
+        callback_meth = :"_notify_#{observer_name}_for_#{callback}"
+        unless klass.respond_to?(callback_meth)
+          klass.send(:define_method, callback_meth) do |&block|
+            observer.update(callback, self, &block)
+          end
+          klass.send(callback, callback_meth)
+        end
+      end
+    end
+  end
+
+end