believer 0.1

data/lib/believer/order_by.rb

@@ -0,0 +1,22 @@
+module Believer
+  class OrderBy
+    attr_reader :field, :dir
+
+    def initialize(field, dir = :asc)
+      raise "Invalid field: #{field}" unless field.is_a?(Symbol) || field.is_a?(String)
+      raise "Direction must be one of (:asc|:desc): #{dir}" unless dir == :asc || dir == :desc
+      @field = field
+      @dir = dir
+    end
+
+    def to_cql
+      "ORDER BY #{@field} #{@dir.present? ? @dir.to_s.upcase : 'ASC'}"
+    end
+
+    def inverse
+      OrderBy.new(@field, @dir == :asc ? :desc : :asc)
+    end
+
+  end
+
+end

data/lib/believer/owner.rb

@@ -0,0 +1,48 @@
+module Believer
+  module Owner
+    extend ::ActiveSupport::Concern
+
+    module ClassMethods
+      def cql_record_relations
+        @cql_record_relations ||= {}
+      end
+
+      def has_some(name, opts = {})
+        defaults = {
+        }
+        options = opts.merge(defaults)
+
+        relation_class = options[:class]
+        if relation_class.nil?
+          relation_class = Kernel.const_get(name.to_s.camelize[0, (name.to_s.size - 1)])
+        elsif relation_class.is_a?(String)
+          relation_class = Kernel.const_get(relation_type)
+        end
+
+        foreign_key = options[:foreign_key]
+        foreign_key = "#{self.name.underscore}_id" if foreign_key.nil?
+        foreign_key = foreign_key.to_sym
+
+        key_attribute = options[:key_attribute]
+        if key_attribute.nil?
+          key_attribute = foreign_key
+        end
+
+        cql_record_relations[name] = options
+
+        self.redefine_method(name) do
+          q = relation_class.where(foreign_key => self.send(key_attribute))
+          if options[:filter]
+            q = options[:filter].call(self, q)
+            return EmptyResult.new unless q
+          end
+          q
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/believer/persistence.rb

@@ -0,0 +1,31 @@
+module Believer
+
+  module Persistence
+
+    extend ::ActiveSupport::Concern
+
+    module ClassMethods
+
+      def create(attributes = nil, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create(attr, &block) }
+        else
+          object = new(attributes, &block)
+          object.save
+          object
+        end
+      end
+
+    end
+
+    # Saves the model.
+    def save
+      Insert.new(:record_class => self.class, :values => self).execute
+    end
+
+    def destroy
+      Delete.new(:record_class => self.class).where(key_values).execute
+    end
+
+  end
+end

data/lib/believer/primary_key.rb

@@ -0,0 +1,5 @@
+module Believer
+  class PrimaryKey
+
+  end
+end

data/lib/believer/query.rb

@@ -0,0 +1,140 @@
+module Believer
+  class Query < ScopedCommand
+
+    attr_accessor :record_class, :selects, :order_by, :limit_to
+
+    delegate *(Enumerable.instance_methods(false).map {|enum_method| enum_method.to_sym}), :to => :to_a
+
+    def initialize(attrs)
+      super
+    end
+
+    def query_attributes
+      attrs = super
+      attrs.merge(:order_by => @order_by, :selects => @selects, :limit_to => @limit_to)
+    end
+
+    def select(*fields)
+      q = clone
+      q.selects ||= []
+      q.selects += fields
+      q.selects.flatten!
+      #puts "New selects: #{q.selects}, added: #{fields}"
+      q
+    end
+
+    def order(field, order = :asc)
+      q = clone
+      q.order_by = OrderBy.new(field, order)
+      q
+    end
+
+    def limit(l)
+      q = clone
+      q.limit_to = Limit.new(l)
+      q
+    end
+
+    def limit_to=(l)
+      if l.nil?
+        @limit_to = nil
+      else
+        @limit_to = Limit.new(l.to_i)
+      end
+    end
+
+    def to_cql
+      cql = "SELECT "
+      if @selects && @selects.any?
+        cql << "#{@selects.join(', ')}"
+      else
+        cql << @record_class.columns.keys.join(',')
+        #cql << "*"
+      end
+
+      cql << " FROM #{@record_class.table_name}"
+      cql << " WHERE #{@wheres.map { |wc| "#{wc.to_cql}" }.join(' AND ')}" if @wheres && @wheres.any?
+      cql << " #{@order_by.to_cql}" unless @order_by.nil?
+      cql << " #{@limit_to.to_cql}" unless @limit_to.nil?
+      cql
+    end
+
+    def destroy_all
+      objects = to_a
+      objects.each do |obj|
+        obj.destroy
+      end
+      objects.size
+    end
+
+    def delete_all(options = {})
+      cnt = count
+      chunk_size = options[:delete_batch_chunk_size] || (self.limit_to.nil? ? nil : self.limit_to.size) || cnt
+      key_cols = self.record_class.primary_key_columns
+      deleted_count = 0
+      while deleted_count < cnt
+        batch = Batch.new(:record_class => @record_class)
+        rows_to_delete = clone.select(key_cols).limit(chunk_size).execute
+        rows_to_delete.each do |row_to_delete|
+          batch << Delete.new(:record_class => self.record_class).where(row_to_delete)
+        end
+        batch.execute
+        deleted_count += batch.commands.size
+      end
+      deleted_count
+    end
+
+    def to_a
+      unless @result_rows
+        result = execute
+        @result_rows = []
+        start = Time.now
+        result.each do |row|
+          @result_rows << @record_class.instantiate_from_result_rows(row)
+        end
+        puts "Took #{sprintf "%.3f", (Time.now - start)*1000.0} ms to deserialize #{@result_rows.size} object(s)"
+      end
+      @result_rows
+    end
+
+    def size
+      to_a.size
+    end
+
+    def count
+      count_q = clone
+      count_q.selects = ['COUNT(*)']
+      result = count_q.execute
+
+      cnt = -1
+      result.each do |row|
+        cnt = row['count']
+      end
+      cnt
+    end
+
+    def each
+      to_a.each do |r|
+        yield r
+      end
+    end
+
+    def [](index)
+      to_a[index]
+    end
+
+    def first
+      return @result_rows.first unless @result_rows.nil?
+      clone.limit(1)[0]
+    end
+
+    def last
+      return @result_rows.last unless @result_rows.nil?
+      raise "Cannot retrieve last of no order column is set" if @order_by.nil?
+      lq = clone.limit(1)
+      lq.order_by = @order_by.inverse
+      lq[0]
+    end
+  end
+
+end

data/lib/believer/querying.rb

@@ -0,0 +1,6 @@
+module Believer
+  module Querying
+    delegate :select, :where, :order, :limit, :to => :scoped
+
+  end
+end

data/lib/believer/scoped_command.rb

@@ -0,0 +1,19 @@
+module Believer
+  class ScopedCommand < Command
+
+    attr_accessor :wheres
+
+    def query_attributes
+      attrs = super
+      attrs.merge(:wheres => @wheres)
+    end
+
+    def where(*args)
+      q = clone
+      q.wheres ||= []
+      q.wheres << WhereClause.new(*args)
+      q
+    end
+
+  end
+end

data/lib/believer/scoping.rb

@@ -0,0 +1,16 @@
+module Believer
+
+  module Scoping
+    extend ::ActiveSupport::Concern
+
+    module ClassMethods
+
+      def scoped
+        Query.new(:record_class => self)
+      end
+
+    end
+
+  end
+
+end

data/lib/believer/test/rspec/test_run_life_cycle.rb

@@ -0,0 +1,51 @@
+module Believer
+  module Test
+    module RSpec
+      # Controls the life cycle for all objects created in a test
+      module TestRunLifeCycle
+        extend ActiveSupport::Concern
+
+        included do
+          Believer::Base.observers = Destructor
+
+          after(:each) do
+            Destructor.instance.cleanup
+          end
+        end
+
+        def saved_models
+          @saved_models ||= []
+        end
+
+        def after_save(model)
+          saved_models << model
+        end
+
+        # Detroys all CqlRecord::Base instances created
+        class Destructor < Believer::Observer
+          observe Believer::Base
+
+          def cleanup
+            saved_models.each do |model|
+              begin
+                model.destroy
+              rescue Exception => e
+                puts "Could not destroy model #{model}: #{e}\n#{e.backtrace.join("\n")}"
+              end
+            end
+          end
+
+          def saved_models
+            @saved_models ||= []
+          end
+
+          def after_save(model)
+            saved_models << model
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/believer/values.rb

@@ -0,0 +1,40 @@
+module Believer
+
+  module Values
+
+    TIMESTAMP_FORMAT = '%Y-%m-%d %H:%M:%S%z'
+
+    def to_cql_literal(value)
+      return 'NULL' if value.nil?
+      return "'#{value}'" if value.is_a?(String)
+      return "#{value}" if value.is_a?(Numeric)
+      return "'#{value.strftime(TIMESTAMP_FORMAT)}'" if value.is_a?(Time) || value.is_a?(DateTime)
+      #return "#{value.to_i * 1000}" if value.is_a?(Time) || value.is_a?(DateTime)
+      return nil
+    end
+
+    def convert_to_integer(v)
+      return v.to_i unless v.nil?
+      nil
+    end
+
+    def convert_to_float(v)
+      return v.to_f unless v.nil?
+      nil
+    end
+
+    def convert_to_boolean(v)
+      return v.to_bool if v.respond_to?(:to_bool)
+      nil
+    end
+
+    def convert_to_time(v)
+      return nil if v.nil?
+      return v if v.is_a?(Time)
+      return Time.parse(v) if v.is_a?(String)
+      Time.at(v.to_i)
+    end
+
+  end
+
+end

data/lib/believer/version.rb

@@ -0,0 +1,5 @@
+module Believer
+  module Version
+    VERSION = '0.1'
+  end
+end

data/lib/believer/where_clause.rb

@@ -0,0 +1,40 @@
+module Believer
+
+  class WhereClause
+    include Values
+
+    def initialize(*args)
+      if args.any?
+        if args[0].is_a?(Hash)
+          @value_map = args[0]
+        else
+          @where_string = args[0]
+          @bindings = args.slice(1, args.length - 1)
+        end
+      end
+    end
+
+    def to_cql
+      if @value_map && @value_map.any?
+        return @value_map.keys.map {|k| create_expression(k, @value_map[k])}.join(' AND ')
+      end
+      binding_index = 0
+      ws = @where_string.gsub(/\?/) { |match|
+        rep_val = to_cql_literal(@bindings[binding_index])
+        binding_index += 1
+        rep_val
+      }
+      ws
+    end
+
+    private
+    def create_expression(key, value)
+      if value.is_a?(Enumerable)
+        values = value.map {|v| to_cql_literal(v)}.join(',')
+        return "#{key} IN (#{values})"
+      end
+      "#{key} = #{to_cql_literal(value)}"
+    end
+  end
+
+end

data/spec/believer/base_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe Believer::Base do
+
+
+end