believer 0.2.5 → 0.2.6

data/lib/believer/ddl.rb

@@ -6,42 +6,13 @@ module Believer
     module ClassMethods
 
       def drop_table
-        connection_pool.with do |connection|
-          cql = "DROP TABLE #{table_name}"
-          ActiveSupport::Notifications.instrument('ddl.believer', :class => self, :cql => cql, :method => :drop) do
-            connection.execute(cql)
-          end
-        end
+        ::Believer::DropTable.new(:record_class => self).execute
       end
 
       def create_table
-        connection_pool.with do |connection|
-          cql = create_table_cql
-          ActiveSupport::Notifications.instrument('ddl.believer', :class => self, :cql => cql, :method => :create) do
-            connection.execute(cql)
-          end
-        end
+        ::Believer::CreateTable.new(:record_class => self).execute
       end
 
-      def create_table_cql
-
-        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 = "CREATE TABLE #{table_name} (\n"
-        col_statement_parts = columns.keys.map {|col| "#{col} #{columns[col].cql_type}"}
-        s << col_statement_parts.join(",\n")
-        s << ",\n"
-        s << "PRIMARY KEY (#{keys.join(',')})"
-        s << "\n)"
-        s
-      end
     end
 
   end

data/lib/believer/drop_table.rb

@@ -0,0 +1,9 @@
+module Believer
+  class DropTable < Command
+
+    def to_cql
+      "DROP TABLE #{record_class.table_name}"
+    end
+
+  end
+end

data/lib/believer/environment/base_env.rb

@@ -77,6 +77,11 @@ module Believer
         connection
       end
 
+      def drop_keyspace
+        conn = create_connection(:connect_to_keyspace => false)
+        conn.execute("DROP KEYSPACE #{connection_configuration[:keyspace]}")
+      end
+
       def create_keyspace(properties = {}, connection = nil)
         conn = connection || create_connection(:connect_to_keyspace => false)
 

data/lib/believer/insert.rb

@@ -11,7 +11,9 @@ module Believer
 
     def to_cql
       attrs = @values.keys
-      "INSERT INTO #{@record_class.table_name} (#{attrs.join(', ')}) VALUES (#{attrs.map {|a| to_cql_literal(@values[a]) }.join(', ')})"
+      cols_def = "#{attrs.join(', ')}"
+      vals_defs = attrs.map { |a| to_cql_literal(@values[a]) }.join(', ')
+      "INSERT INTO #{@record_class.table_name} (#{cols_def}) VALUES (#{vals_defs})"
     end
   end
 

data/lib/believer/persistence.rb

@@ -24,12 +24,28 @@ module Believer
 
     # Saves the model.
     def save
-      Insert.new(:record_class => self.class, :values => self).execute
+      if persisted? || is_counter_instance?
+        Update.create(self).execute
+      else
+        Insert.new(:record_class => self.class, :values => self).execute
+      end
+      persisted!
+      self
     end
 
     # Destroys the model.
     def destroy
-      Delete.new(:record_class => self.class).where(key_values).execute
+      res = Delete.new(:record_class => self.class).where(key_values).execute
+      @persisted = false
+      res
+    end
+
+    def persisted!
+      @persisted = true
+    end
+
+    def persisted?
+      @persisted == true
     end
 
   end

data/lib/believer/update.rb

@@ -0,0 +1,52 @@
+module Believer
+  class Update < FilterCommand
+    include CqlHelper
+
+    attr_accessor :values
+
+    def self.create(object)
+      pk_cols = object.class.primary_key_columns
+      pk_values = object.attributes.delete_if {|k, v| !pk_cols.include?(k)}
+
+      update = new(:record_class => object.class, :values => object.attributes)
+      update.where(pk_values)
+    end
+
+    def query_attributes
+      attrs = super
+      attrs.merge(:values => (values.dup))
+    end
+
+    def values=(v)
+      pk_cols = record_class.primary_key_columns
+      vals = v.is_a?(Base) ? v.attributes : v.to_hash
+      @values = vals.dup.delete_if {|k, v| pk_cols.include?(k)}
+    end
+
+    def can_execute?
+      if record_class.is_counter_table?
+        mock_instance = record_class.new(values)
+        return mock_instance.has_counter_diffs?
+      end
+      true
+    end
+
+    def to_cql
+      cql = "UPDATE #{record_class.table_name} SET "
+      cql << values.keys.map {|col| assign_statement(col, values[col]) }.flatten.join(', ')
+      cql << " WHERE #{wheres.map { |wc| "#{wc.to_cql}" }.join(' AND ')}" if wheres.any?
+      cql
+    end
+
+    def assign_statement(col_name, val)
+      column = record_class.columns[col_name]
+      if column.ruby_type == :counter
+        return nil if val.nil?
+        operator = val.incremented? ? '+' : '-'
+        return "#{col_name} = #{col_name} #{operator} #{val.diff}"
+      end
+      "#{col_name} = #{to_cql_literal(val)}"
+    end
+
+  end
+end

data/lib/believer/values.rb

@@ -1,7 +1,28 @@
+require 'set'
+
 module Believer
 
   module Values
 
+    # Converts the value to a one that conforms to the type of this column
+    # @param v [Object] the value
+    # @param value_type [Symbol] value type
+    def convert_value_to_type(v, value_type)
+      meth = convert_method(value_type)
+      return send(meth, v) if respond_to?(meth)
+      v
+    end
+
+    def convert_method(value_type)
+      return nil if value_type.nil?
+      "convert_to_#{value_type}".to_sym
+    end
+
+    def convert_to_string(v)
+      return v.to_s unless v.nil?
+      nil
+    end
+
     def convert_to_integer(v)
       return v.to_i unless v.nil?
       nil
@@ -26,6 +47,52 @@ module Believer
       Time.at(v.to_i)
     end
 
+    def convert_to_symbol(v)
+      return nil if v.nil?
+      return v.to_sym
+    end
+
+    def convert_to_counter(v)
+      return nil if v.nil?
+      return v if v.is_a?(Counter)
+      Counter.new(v.to_i)
+    end
+
+    def convert_to_array(v, element_type = nil)
+      return nil if v.nil?
+      arr = v.is_a?(Array) ? v : Array.new(v)
+      convert_collection_elements(arr, element_type)
+    end
+
+    def convert_to_set(v, element_type = nil)
+      return nil if v.nil?
+      s = v.is_a?(Set) ? v : Set.new(v)
+      Set.new(convert_collection_elements(s, element_type))
+    end
+
+    def convert_collection_elements(col, element_type = nil)
+      return col if element_type.nil?
+      meth = convert_method(element_type)
+      col.map {|el| send(meth, el)}
+    end
+
+    def convert_to_hash(v, key_type = nil, value_type = nil)
+      return nil if v.nil?
+      hash = v.is_a?(Hash) ? v : Hash.new(v)
+      unless key_type.nil? && value_type.nil?
+        key_conv_meth = convert_method(key_type)
+        val_conv_meth = convert_method(value_type)
+        hash_conv = {}
+        hash.each do |key, value|
+          key_conv = key_conv_meth.nil? ? key : send(key_conv_meth, key)
+          value_conv = val_conv_meth.nil? ? value : send(val_conv_meth, value)
+          hash_conv[key_conv] = value_conv
+        end
+        return hash_conv
+      end
+      hash
+    end
+
   end
 
 end

data/lib/believer/version.rb

@@ -1,5 +1,5 @@
 module Believer
   module Version
-    VERSION = '0.2.5'
+    VERSION = '0.2.6'
   end
 end

data/spec/believer/base_spec.rb

@@ -2,9 +2,16 @@ require 'spec_helper'
 
 describe Believer::Base do
 
-  it 'equality' do
+  it 'should implement equality' do
     a1 = Test::Artist.new(:name => 'Level 42')
     a2 = Test::Artist.new(:name => 'Level 42', :label => 'Epic')
-    a1.should == a2
+    expect(a1).to eql(a2)
   end
+
+  it 'should be able to reload itself' do
+    artist = Test::Artist.create(:name => 'Level 42', :label => 'Epic')
+    artist.label = 'Apple'
+    expect(artist.reload!.label).to eql('Epic')
+  end
+
 end

data/spec/believer/callback_spec.rb

@@ -17,7 +17,7 @@ describe Believer::Callbacks do
         })
         object.send(method)
 
-        called.should == true
+        expect(called).to eql(true)
       end
     end
   end

data/spec/believer/collection_columns_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe 'Collection columns' do
+
+  before :each do
+    @marbles  = Set.new [:red, :green, :red]
+    @soccer_cards  = ['Messi', 'Ronaldo', 'Pele']
+    @family  = {:father => 'Fred', :mother => 'Tina', :sister => 'Emily'}
+    @children = Test::Child.create(:name => 'Johnny', :marbles => @marbles, :family => @family, :soccer_cards => @soccer_cards)
+  end
+
+  it 'should load a set' do
+    johnny = Test::Child.where(:name => 'Johnny').first
+    expect(johnny.marbles.size).to eql(@marbles.size)
+    @marbles.each do |m|
+      expect(johnny.marbles).to include(m)
+    end
+  end
+
+  it 'should be able to add to a set' do
+    johnny = Test::Child.where(:name => 'Johnny').first
+    johnny.marbles << :yellow
+    johnny.save
+
+    johnny = Test::Child.where(:name => 'Johnny').first
+    expect(johnny.marbles.size).to eql(@marbles.size + 1)
+    expect(johnny.marbles).to include(:yellow)
+  end
+
+  it 'should be able to remove from a set' do
+    johnny = Test::Child.where(:name => 'Johnny').first
+    johnny.marbles.delete(:red)
+    johnny.save
+
+    johnny = Test::Child.where(:name => 'Johnny').first
+    expect(johnny.marbles.size).to eql(@marbles.size - 1)
+    expect(johnny.marbles).not_to include(:red)
+  end
+
+  it 'should load a list' do
+    johnny = Test::Child.where(:name => 'Johnny').first
+    expect(johnny.soccer_cards.size).to eql(@soccer_cards.size)
+    @soccer_cards.each do |m|
+      expect(johnny.soccer_cards).to include(m)
+    end
+  end
+
+  it 'should be able to add to a list' do
+    johnny = Test::Child.where(:name => 'Johnny').first
+    johnny.soccer_cards << 'Neymar'
+    johnny.save
+
+    johnny = Test::Child.where(:name => 'Johnny').first
+    expect(johnny.soccer_cards.size).to eql(@soccer_cards.size + 1)
+    expect(johnny.soccer_cards).to include('Neymar')
+  end
+
+  it 'should be able to remove from a set' do
+    johnny = Test::Child.where(:name => 'Johnny').first
+    johnny.soccer_cards.delete('Messi')
+    johnny.save
+
+    johnny = Test::Child.where(:name => 'Johnny').first
+    expect(johnny.soccer_cards.size).to eql(@soccer_cards.size - 1)
+    expect(johnny.soccer_cards).not_to include('Messi')
+  end
+
+  it 'should load a map' do
+    johnny = Test::Child.where(:name => 'Johnny').first
+    expect(johnny.family.size).to eql(@family.size)
+    @family.each do |k, v|
+      expect(johnny.family.keys).to include(k)
+      expect(johnny.family[k]).to eql(v)
+    end
+  end
+
+  it 'should be able to add to a map' do
+    johnny = Test::Child.where(:name => 'Johnny').first
+    johnny.family[:brother] = 'Brad'
+    johnny.save
+
+    johnny = Test::Child.where(:name => 'Johnny').first
+    expect(johnny.family[:brother]).to eql('Brad')
+  end
+
+  it 'should be able to remove from a map' do
+    johnny = Test::Child.where(:name => 'Johnny').first
+    johnny.family.delete(:sister)
+    johnny.save
+
+    johnny = Test::Child.where(:name => 'Johnny').first
+    expect(johnny.family.has_key?(:sister)).to eql(false)
+  end
+
+end

data/spec/believer/columns_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Believer::Columns do
+
+  it 'should be able to find columns with type' do
+    cols = Test::Song.columns
+    expect(cols.size).to eql 5
+  end
+
+  it 'should be able to find columns with type' do
+    int_cols = Test::Song.columns_with_type(:integer)
+    expect(int_cols).to eql [Test::Song.columns[:track_number]]
+
+    string_cols = Test::Song.columns_with_type(:string)
+    expect(string_cols.size).to eql 4
+
+    counter_cols = Test::AlbumSales.columns_with_type(:counter)
+    expect(counter_cols).to eql [Test::AlbumSales.columns[:sales]]
+  end
+
+end

data/spec/believer/counter_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Believer::Counter do
+
+  it 'should have a default initial value' do
+    c = Believer::Counter.new(3)
+    expect(c.initial_value).to eql 3
+  end
+
+  it 'should increment' do
+    c = Believer::Counter.new(3)
+    c.incr
+    expect(c.initial_value).to eql 3
+    expect(c.to_i).to eql 4
+  end
+
+  it 'should decrement' do
+    c = Believer::Counter.new(3)
+    c.decr
+    expect(c.initial_value).to eql 3
+    expect(c.to_i).to eql 2
+  end
+
+  it 'should adopt a number value' do
+    c = Believer::Counter.new(3)
+    c.adopt_value(4)
+    expect(c.initial_value).to eql 3
+    expect(c.to_i).to eql 4
+  end
+
+  it 'should adopt a counter value' do
+    c = Believer::Counter.new(3)
+    c.adopt_value(Believer::Counter.new(4))
+    expect(c.initial_value).to eql 3
+    expect(c.to_i).to eql 4
+  end
+
+  it 'should adopt a nil value' do
+    c = Believer::Counter.new(3)
+    c.adopt_value(nil)
+    expect(c.initial_value).to eql 3
+    expect(c.to_i).to eql 0
+  end
+
+
+end