believer 0.1.4 → 0.2

data/lib/believer/query.rb

@@ -53,9 +53,9 @@ module Believer
       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 << " WHERE #{wheres.map { |wc| "#{wc.to_cql}" }.join(' AND ')}" if wheres.any?
+      cql << " #{order_by.to_cql}" unless order_by.nil?
+      cql << " #{limit_to.to_cql}" unless limit_to.nil?
       cql
     end
 

data/lib/believer/relation.rb

@@ -0,0 +1,90 @@
+module Believer
+  module Relation
+    extend ::ActiveSupport::Concern
+
+    module ClassMethods
+      def cql_record_relations
+        @cql_record_relations ||= {}
+      end
+
+      def has_single(name, opts = {})
+        if opts[:foreign_key].nil?
+          opts[:foreign_key] = opts[:key].nil? ? :id : opts[:key]
+        end
+        if opts[:key].nil?
+          opts[:key] = opts[:foreign_key].nil? ? "#{self.name.underscore}_id".to_sym : opts[:foreign_key]
+        end
+        has_a_relation(name, opts.merge(:type => :one_2_one))
+      end
+
+      def has_some(name, opts = {})
+        if opts[:foreign_key].nil?
+          opts[:foreign_key] = opts[:key].nil? ? "#{self.name.underscore}_id".to_sym : opts[:key]
+        end
+        if opts[:key].nil?
+          opts[:key] = opts[:foreign_key].nil? ? :id : opts[:foreign_key]
+        end
+
+        has_a_relation(name, opts.merge(:type => :one_2_many))
+      end
+
+      # Defines a (one to many) relation.
+      # @param name [Symbol] the name of the relation, which will also be used as an accessor method
+      # @param opts [Hash] the options
+      # @option opts :class the name of the referenced class. If nil, it will be created from the relation name. Can be a constant or a String
+      # @option opts :foreign_key the name of the attribute of the referenced class which acts as the key to this object
+      # @option opts :key the name of the attribute of the referencing class which acts as the key the referenced records
+      # @option opts :filter a Proc or lambda which is called with a Believer::Query instance as a parameter to tweak the relation query
+      def has_a_relation(name, opts = {})
+        defaults = {
+        }
+        options = defaults.merge(opts)
+
+        # Use a proc to avoid classes not yet loaded being referenced
+        get_relation_class = lambda do
+          if options[:relation_class].nil?
+            relation_class = options[:class]
+            if relation_class.nil?
+              cn = name.to_s.camelize
+              if options[:type] == :one_2_many
+                cn = cn[0, (name.to_s.size - 1)]
+              end
+              relation_class = Kernel.const_get(cn)
+            elsif relation_class.is_a?(String)
+              relation_class = relation_class.split('::').inject(Kernel) { |scope, const_name| scope.const_get(const_name) }
+            end
+            options[:relation_class] = relation_class
+          end
+          options[:relation_class]
+        end
+
+        cql_record_relations[name] = options
+
+        opts[:foreign_key] = opts[:foreign_key].is_a?(Array) ? opts[:foreign_key] : [opts[:foreign_key]]
+        opts[:key] = opts[:key].is_a?(Array) ? opts[:key] : [opts[:key]]
+
+        raise "key and foreign_key must have same number of items" if opts[:key].size != opts[:foreign_key].size
+
+        self.redefine_method(name) do
+          relation_class = get_relation_class.call
+
+          q = relation_class.scoped
+          opts[:foreign_key].each_with_index do |fk, index|
+            key = opts[:key][index]
+            q = q.where(fk => self.send(key))
+          end
+          if options[:filter]
+            q = self.instance_exec(q, &(options[:filter]))
+            return EmptyResult.new unless q
+          end
+          return q.first if options[:type] == :one_2_one
+          q
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/believer/scoped_command.rb

@@ -1,16 +1,23 @@
 module Believer
+  # A command implementation which includes a CQL WHERE clause
   class ScopedCommand < Command
 
-    attr_accessor :wheres
-
     def query_attributes
       attrs = super
-      attrs.merge(:wheres => @wheres)
+      attrs.merge(:wheres => (wheres.dup))
+    end
+
+    def wheres
+      #puts "Wheres: #{@wheres}"
+      @wheres ||= []
+    end
+
+    def wheres=(w)
+      @wheres = w.is_a?(Array) ? w : [w]
     end
 
     def where(*args)
       q = clone
-      q.wheres ||= []
       q.wheres << WhereClause.new(*args)
       q
     end

data/lib/believer/test/test_run_life_cycle.rb

@@ -0,0 +1,49 @@
+module Believer
+  module Test
+    # 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

data/lib/believer/values.rb

@@ -2,17 +2,6 @@ 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
@@ -24,6 +13,8 @@ module Believer
     end
 
     def convert_to_boolean(v)
+      return true if v.is_a?(TrueClass)
+      return false if v.is_a?(FalseClass)
       return v.to_bool if v.respond_to?(:to_bool)
       nil
     end

data/lib/believer/version.rb

@@ -1,5 +1,5 @@
 module Believer
   module Version
-    VERSION = '0.1.4'
+    VERSION = '0.2'
   end
 end

data/lib/believer/where_clause.rb

@@ -1,7 +1,7 @@
 module Believer
 
   class WhereClause
-    include Values
+    include CqlHelper
 
     def initialize(*args)
       if args.any?

data/spec/believer/delete_spec.rb

@@ -3,9 +3,9 @@ require 'spec_helper'
 describe Believer::Delete do
 
   it "create a valid delete statement" do
-    del = Believer::Delete.new(:record_class => Test::Computer)
+    del = Believer::Delete.new(:record_class => Test::Artist)
     del = del.where(:id => 1)
-    del.to_cql.should == 'DELETE FROM computers WHERE id = 1'
+    del.to_cql.should == 'DELETE FROM artists WHERE id = 1'
   end
 
 

data/spec/believer/environment_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Believer::Environment do
+
+  before :each do
+    @original_env = Believer::Base.environment
+    Believer::Base.environment = nil
+  end
+
+  after :each do
+    Believer::Base.environment = @original_env
+  end
+
+  it 'load the Merb configuration' do
+    Env = Struct.new(:root, :environment, :logger)
+
+    Merb = Env.new(File.join(RSpec.configuration.test_files_dir, 'merb'), :development, nil)
+    env = Believer::Base.environment
+    env.class.should == Believer::Environment::MerbEnv
+    env.configuration[:host].should == 'merb.local'
+  end
+
+  it 'load the rails configuration' do
+    Env = Struct.new(:root, :env, :logger)
+
+    Rails = Env.new(File.join(RSpec.configuration.test_files_dir, 'rails'), :development, nil)
+    env = Believer::Base.environment
+    env.class.should == Believer::Environment::RailsEnv
+    env.configuration[:host].should == '123.456.789.0'
+  end
+
+end

data/spec/believer/insert_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Believer::Insert do
 
   it "create statement based on hash" do
-    insert = Believer::Insert.new(:record_class => Test::Computer, :values => {:id => 1, :brand => 'Apple'})
-    insert.to_cql.should == "INSERT INTO computers (id, brand) VALUES (1, 'Apple')"
+    insert = Believer::Insert.new(:record_class => Test::Artist, :values => {:id => 1, :name => 'Beatles'})
+    insert.to_cql.should == "INSERT INTO artists (id, name) VALUES (1, 'Beatles')"
   end
 end

data/spec/believer/query_spec.rb

@@ -1,27 +1,27 @@
 require 'spec_helper'
 
 describe Believer::Query do
- include Believer::Test::RSpec::TestRunLifeCycle
+ include Believer::Test::TestRunLifeCycle
 
   it 'create simple statement' do
-    q = Believer::Query.new(:record_class => Test::Computer)
-    q = q.select(:id).
-        select(:brand).
-        where(:brand => 'Atari').
-        where(:production_date => Time.utc(2013)).
-        order(:id, :desc).
+    q = Believer::Query.new(:record_class => Test::Album)
+    q = q.select(:name).
+        select(:artist).
+        where(:name => 'Revolver').
+        where(:release_date => Time.utc(2013)).
+        order(:name, :desc).
         limit(10)
-    q.to_cql.should == "SELECT id, brand FROM computers WHERE brand = 'Atari' AND production_date = '2013-01-01 00:00:00+0000' ORDER BY id DESC LIMIT 10"
+    q.to_cql.should == "SELECT name, artist FROM albums WHERE name = 'Revolver' AND release_date = '2013-01-01 00:00:00+0000' ORDER BY name DESC LIMIT 10"
   end
 
   it 'should behave like an Enumerable' do
-    puts Test::Computer.environment
-    @objects = Test::Computer.create([
-        {:id => 1, :brand => 'Dell'},
-        {:id => 2, :brand => 'Apple'},
-        {:id => 3, :brand => 'HP'}
+
+    @objects = Test::Artist.create([
+        {:name => 'Beatles', :label => 'Apple'},
+        {:name => 'Jethro Tull', :label => 'Crysalis'},
+        {:name => 'Pink Floyd', :label => 'Epic'}
     ])
-    q = Believer::Query.new(:record_class => Test::Computer).where(:id => @objects.map {|o|o.id})
+    q = Believer::Query.new(:record_class => Test::Artist).where(:name => @objects.map {|o|o.name})
     Enumerable.instance_methods(false).each do |enum_method|
       q.respond_to?(enum_method.to_sym).should == true
     end

data/spec/believer/relation_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Believer::Relation do
+
+  before :each do
+    @artists = []
+    @artists << Test::Artist.create(:name => 'Beatles', :label => 'Apple')
+    @artists << Test::Artist.create(:name => 'Jethro Tull', :label => 'Crysalis')
+    @artists << Test::Artist.create(:name => 'Pink Floyd', :label => 'Epic')
+
+    @albums = []
+    @albums << Test::Album.create(:artist_name => 'Beatles', :name => 'Help', :release_date => Time.utc(1965))
+    @albums << Test::Album.create(:artist_name => 'Beatles', :name => 'Revolver', :release_date => Time.utc(1966))
+    @albums << Test::Album.create(:artist_name => 'Beatles', :name => 'Abbey Road', :release_date => Time.utc(1969))
+
+    @albums << Test::Album.create(:artist_name => 'Pink Floyd', :name => 'Dark side of the moon', :release_date => Time.utc(1973))
+    @albums << Test::Album.create(:artist_name => 'Pink Floyd', :name => 'Wish you were here', :release_date => Time.utc(1975))
+
+    @songs = []
+    @songs << Test::Song.create(:artist_name => 'Pink Floyd', :album_name => 'Wish you were here', :name => 'Have a cigar')
+
+  end
+
+  it "report correct size of one to many relation" do
+    a = Test::Artist.where(:name => 'Beatles').first
+    a.albums.size.should == 3
+  end
+
+  it "one to one relation" do
+    @songs[0].album.should == Test::Album.where(:artist_name => 'Pink Floyd', :name => 'Wish you were here').first
+  end
+
+end

data/spec/spec_helper.rb

@@ -10,28 +10,14 @@ unless ENV['COVERAGE'] == 'no'
 end
 
 require 'believer'
-
-require 'believer/test/rspec/test_run_life_cycle'
-
-
-
+require 'believer/test/test_run_life_cycle'
 
 Dir[File.expand_path('../support/*.rb', __FILE__)].each {|f| require f}
 
-
 setup_database
 
-#class Event < Cql::Model
-#  primary_key :id
-#
-#  column :location
-#  column :date
-#end
-#
-#class Person < Cql::Model
-#  primary_key :id
-#
-#  column :first_name
-#  column :last_name
-#  column :birth_date, column_name: :dob
-#end
+RSpec.configure do |c|
+  c.add_setting :test_files_dir, :default => File.expand_path('../test_files/', __FILE__)
+end
+
+File.expand_path('../test_files/', __FILE__)

data/spec/support/setup_database.rb

@@ -8,7 +8,7 @@ def setup_database
     connection.use(env.connection_configuration[:keyspace])
   rescue Cql::QueryError
 
-    env.create_keyspace(connection)
+    env.create_keyspace({}, connection)
     connection.use(env.connection_configuration[:keyspace])
 
     Test.classes.each do |cl|

data/spec/support/test_classes.rb

@@ -1,34 +1,37 @@
 
 module Test
 
-  class Processor < Believer::Base
-    column :computer_id, :type => :integer
-    column :speed, :type => :integer
-    primary_key :computer_id
-  end
-
-  class Computer < Believer::Base
-    include Believer::Owner
+  class Artist < Believer::Base
+    include Believer::Relation
 
+    column :name
+    column :label
 
-    column :id, :type => :integer
-    column :brand, :type => :string
-    column :production_date, :type => :timestamp
+    primary_key :name
 
-    primary_key :id
+    has_some :albums, :class => 'Test::Album', :key => :name, :foreign_key => :artist_name
+  end
 
-    has_some :processors, :class => Processor
+  class Album < Believer::Base
+    column :artist_name
+    column :name
+    column :release_date, :type => :timestamp
 
+    primary_key :artist_name, :name
   end
 
-  class Event < Believer::Base
-    column :computer_id, :type => :integer
-    column :event_type, :type => :integer
-    column :time, :type => :integer, :key => true
-    column :description, :type => :string
+  class Song < Believer::Base
+    include Believer::Relation
 
-    primary_key [:computer_id, :event_type], :time
+    column :artist_name
+    column :album_name
+    column :name
+    column :track_number, :type => :integer
+    column :data, :cql_type => :blob
 
+    primary_key :artist_name, :album_name, :name
+
+    has_single :album, :class => 'Test::Album', :key => [:artist_name, :album_name], :foreign_key => [:artist_name, :name]
   end
 
   class Person < Believer::Base
@@ -41,8 +44,18 @@ module Test
 
   end
 
+  class Event < Believer::Base
+    column :computer_id, :type => :integer
+    column :event_type, :type => :integer
+    column :time, :type => :integer, :key => true
+    column :description, :type => :string
+
+    primary_key [:computer_id, :event_type], :time
+
+  end
+
   class Environment < Believer::Environment::BaseEnv
-    def connection_configuration
+    def configuration
       {:host => '127.0.0.1', :keyspace => 'believer_test_space'}
     end
   end
@@ -52,7 +65,7 @@ module Test
   end
 
   Believer::Base.environment = test_environment
-  CLASSES = [Processor, Computer, Event, Person]
+  CLASSES = [Artist, Album, Song, Event, Person]
   #CLASSES.each {|cl| cl.environment = test_environment}
 
   def self.classes