massive_record 0.2.1 → 0.2.2.rc1

data/lib/massive_record/adapters/thrift/table.rb

@@ -5,6 +5,27 @@ module MassiveRecord
         
         attr_accessor :connection, :name, :column_families
     
+        #
+        # TODO
+        # Helper method to inform about changed options. Remove this in next version..
+        # Also note that this method is used other places to wrap same functionality.
+        #
+        def self.warn_and_change_deprecated_finder_options(options)
+          deprecations = {
+            :start => :starts_with
+          }
+
+          deprecations.each do |deprecated, current|
+            if options.has_key? deprecated
+              # TODO remove this for next version
+              ActiveSupport::Deprecation.warn("finder option '#{deprecated}' is deprecated. Please use: '#{current}'")
+              options[current] = options.delete deprecated
+            end
+          end
+          
+          options
+        end
+
         def initialize(connection, table_name)
           @connection = connection
           @name = table_name.to_s
@@ -87,9 +108,14 @@ module MassiveRecord
         end
       
         def format_options_for_scanner(opts = {})
+          opts = self.class.warn_and_change_deprecated_finder_options(opts)
+
+          start = opts[:starts_with] && opts[:starts_with].dup.force_encoding(Encoding::BINARY)
+          offset = opts[:offset] && opts[:offset].dup.force_encoding(Encoding::BINARY)
+
           {
-            :start_key  => opts[:start],
-            :offset_key => opts[:offset],
+            :start_key  => start,
+            :offset_key => offset,
             :created_at => opts[:created_at],
             :columns    => opts[:select], # list of column families to fetch from hbase
             :limit      => opts[:limit] || opts[:batch_size]
@@ -115,8 +141,16 @@ module MassiveRecord
         # table.get("my_id", :info, :name) # => "Bob"
         #
         def get(id, column_family_name, column_name)
-          if value = connection.get(name, id, "#{column_family_name.to_s}:#{column_name.to_s}").first.try(:value)
-            MassiveRecord::Wrapper::Cell.new(:value => value).value # might seems a bit strange.. Just to "enforice" that the value is a supported type
+          get_cell(id, column_family_name, column_name).try :value
+        end
+
+
+        #
+        # Fast way of fetching one cell
+        #
+        def get_cell(id, column_family_name, column_name)
+          if cell = connection.get(name, id.dup.force_encoding(Encoding::BINARY), "#{column_family_name.to_s}:#{column_name.to_s}").first
+            MassiveRecord::Wrapper::Cell.populate_from_tcell(cell)
           end
         end
         
@@ -126,17 +160,20 @@ module MassiveRecord
         # Returns nil if id is not found
         #
         def find(*args)
-          what_to_find = args.first
           options = args.extract_options!.symbolize_keys
+          what_to_find = args.first
 
-          if what_to_find.is_a?(Array)
-            what_to_find.collect { |id| find(id, options) }
-          else
-            if column_families_to_find = options[:select]
-              column_families_to_find = column_families_to_find.collect { |c| c.to_s }
-            end
+          if column_families_to_find = options[:select]
+            column_families_to_find = column_families_to_find.collect { |c| c.to_s }
+          end
 
-            if t_row_result = connection.getRowWithColumns(name, what_to_find, column_families_to_find).first
+          if what_to_find.is_a? Array
+            what_to_find.collect! { |id| id.dup.force_encoding(Encoding::BINARY) }
+            connection.getRowsWithColumns(name, what_to_find, column_families_to_find).collect do |t_row_result|
+              Row.populate_from_trow_result(t_row_result, connection, name, column_families_to_find)
+            end
+          else
+            if t_row_result = connection.getRowWithColumns(name, what_to_find.dup.force_encoding(Encoding::BINARY), column_families_to_find).first
               Row.populate_from_trow_result(t_row_result, connection, name, column_families_to_find)
             end
           end

data/lib/massive_record/orm/attribute_methods.rb

@@ -37,14 +37,22 @@ module MassiveRecord
       def attributes=(new_attributes)
         return unless new_attributes.is_a?(Hash)
 
+        multiparameter_attributes = []
+
         sanitize_for_mass_assignment(new_attributes).each do |attr, value|
-          writer_method = "#{attr}="
-          if respond_to? writer_method
-            send(writer_method, value)
+          if multiparameter? attr
+            multiparameter_attributes << [attr, value]
           else
-            raise UnknownAttributeError.new("Unkown attribute: #{attr}")
+            writer_method = "#{attr}="
+            if respond_to? writer_method
+              send(writer_method, value)
+            else
+              raise UnknownAttributeError.new("Unkown attribute: #{attr}")
+            end
           end
         end
+
+        assign_multiparameter_attributes(multiparameter_attributes)
       end
 
       
@@ -84,10 +92,74 @@ module MassiveRecord
       end
 
       def fill_attributes_with_default_values_where_nil_is_not_allowed
-        attributes_schema.reject { |attr_name, field| field.allow_nil? || self[attr_name].present? }.each do |attr_name, field|
+        attributes_to_fill = attributes_schema.reject do |attr_name, field|
+          field.allow_nil? || self[attr_name].present? || (field.type == :boolean && self[attr_name] == false)
+        end
+
+        attributes_to_fill.each do |attr_name, field|
           self[attr_name] = field.default
         end
       end
+
+
+
+
+
+
+      def multiparameter?(attr)
+        attr.to_s.include?('(')
+      end
+
+      def assign_multiparameter_attributes(attribute_pairs)
+        convert_multiparameter_pairs_to_hash_with_initializer_arguments(attribute_pairs).each do |attr_name, initialize_values|
+          if field = attributes_schema[attr_name]
+            value = begin
+                      if initialize_values.any?
+                        case field.type
+                        when :date
+                          initialize_values = initialize_values[0, 3]
+                          initialize_values.collect! { |v| v.nil? ? 1 : v }
+                          Date.new(*initialize_values)
+                        when :time
+                          initialize_values = initialize_values[0, 6]
+                          initialize_values.collect! { |v| v.nil? ? 0 : v }
+                          Time.new(*initialize_values)
+                        end
+                      end
+                    rescue ArgumentError
+                      nil
+                    end
+
+            self[attr_name] = value
+          end
+        end
+      end
+
+      def convert_multiparameter_pairs_to_hash_with_initializer_arguments(attribute_pairs)
+        out = Hash.new { |h, k| h[k] = [] }.tap do |hash|
+          attribute_pairs.each do |pair|
+            name, value = pair
+            attr_name = name.split('(').first
+            hash[attr_name] << [multiparameter_position(name), type_cast_multiparameter_value(name, value)]
+          end
+        end
+
+        out.each do |attr_name, positions_and_values|
+          out[attr_name] = positions_and_values.sort_by(&:first).collect(&:last)
+        end
+
+        out
+      end
+
+      def type_cast_multiparameter_value(name, value)
+        unless value.empty?
+          name =~ /\([0-9]*([if])\)/ ? value.send("to_" + $1) : value
+        end
+      end
+
+      def multiparameter_position(name)
+        name.scan(/\(([0-9]*).*\)/).first.first
+      end
     end
   end
 end

data/lib/massive_record/orm/attribute_methods/cast_numbers_on_write.rb

@@ -0,0 +1,24 @@
+module MassiveRecord
+  module ORM
+    module AttributeMethods
+      module CastNumbersOnWrite
+        extend ActiveSupport::Concern
+
+        def write_attribute(attr_name, value)
+          if value.present?
+            if field = attributes_schema[attr_name]
+              case field.type
+              when :integer
+                value = value.to_i
+              when :float
+                value = value.to_f
+              end
+            end
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/orm/attribute_methods/dirty.rb

@@ -45,6 +45,24 @@ module MassiveRecord
         end
 
 
+        def changed?
+          super || relation_proxies_for_embedded.any?(&:changed?)
+        end
+
+        def changed
+          super + relation_proxies_for_embedded.select(&:changed?).collect { |proxy| proxy.metadata.name }
+        end
+
+        def changes
+          changes_in_embedded_proxies = {}
+
+          relation_proxies_for_embedded.select(&:changed?).each do |proxy|
+            changes_in_embedded_proxies[proxy.metadata.name] = proxy.changes 
+          end
+
+          super.update(changes_in_embedded_proxies)
+        end
+
         private
 
         def update(*)

data/lib/massive_record/orm/attribute_methods/time_zone_conversion.rb

@@ -56,16 +56,37 @@ module MassiveRecord
                     time.in_time_zone
                   end
                 end
+                alias_method attr_name, internal_read_method
               end
             else
               super
             end
           end
 
-          # Redefine writer method if we are to do time zone configuration on field
           def define_method_attribute=(attr_name)
-            # Nothing special goes on here, at the moment
-            super
+            if time_zone_conversion_on_field?(attributes_schema[attr_name])
+              internal_write_method = "_#{attr_name}="
+
+              if attr_name =~ ActiveModel::AttributeMethods::COMPILABLE_REGEXP
+                generated_attribute_methods.module_eval <<-RUBY, __FILE__, __LINE__
+                  def #{internal_write_method}(time)
+                    time = Time.zone.parse(time) if time.is_a? String
+                    #{attr_name}_will_change! if will_change_attribute? #{attr_name}, time
+                    @attributes['#{attr_name}'] = time
+                  end
+                  alias #{attr_name}= #{internal_write_method}
+                RUBY
+              else
+                generated_attribute_methods.send(:define_method, internal_write_method) do |time|
+                  time = Time.zone.parse(time) if time.is_a? String
+                  send("#{attr_name}_will_change!") if will_change_attribute? attr_name, time
+                  @attributes[attr_name] = time
+                end
+                alias_method "#{attr_name}=", internal_write_method
+              end
+            else
+              super
+            end
           end
 
 

data/lib/massive_record/orm/attribute_methods/write.rb

@@ -28,7 +28,14 @@ module MassiveRecord
         end
 
         def write_attribute(attr_name, value)
-          @attributes[attr_name.to_s] = value
+          attr_name = attr_name.to_s
+          internal_write_method = "_#{attr_name}="
+
+          if respond_to? internal_write_method
+            send(internal_write_method, value)
+          else
+            @attributes[attr_name.to_s] = value
+          end
         end
 
         private

data/lib/massive_record/orm/base.rb

@@ -18,15 +18,19 @@ require 'massive_record/orm/finders/rescue_missing_table_on_find'
 require 'massive_record/orm/attribute_methods'
 require 'massive_record/orm/attribute_methods/time_zone_conversion'
 require 'massive_record/orm/attribute_methods/write'
+require 'massive_record/orm/attribute_methods/cast_numbers_on_write'
 require 'massive_record/orm/attribute_methods/read'
 require 'massive_record/orm/attribute_methods/dirty'
 require 'massive_record/orm/single_table_inheritance'
 require 'massive_record/orm/validations'
+require 'massive_record/orm/validations/associated'
 require 'massive_record/orm/callbacks'
 require 'massive_record/orm/timestamps'
 require 'massive_record/orm/persistence'
 require 'massive_record/orm/default_id'
 require 'massive_record/orm/query_instrumentation'
+require 'massive_record/orm/observer'
+require 'massive_record/orm/identity_map'
 
 
 module MassiveRecord
@@ -75,8 +79,21 @@ module MassiveRecord
       class_attribute :check_record_uniqueness_on_create, :instance_writer => false
       self.check_record_uniqueness_on_create = false
 
-      class_attribute :auto_increment_id, :instance_writer => false
-      self.auto_increment_id = true
+
+      #
+      # Default id and id facyory settings
+      # Should we set automatically the id, and which factory should we ask?
+      #
+      # The default id factory is set when massive record is fully loaded, as
+      # it uses MassiveRecord itself to communicate with the database.
+      # Take a look inside of orm/id_factory.rb; we are utilizing the on_load hook.
+      #
+      class_attribute :id_factory, :instance_writer => false
+      class_attribute :set_id_from_factory_before_create, :instance_writer => false
+      self.set_id_from_factory_before_create = true
+
+
+
      
       class << self
         def table_name
@@ -146,11 +163,13 @@ module MassiveRecord
         @new_record = true
         @destroyed = @readonly = false
         @relation_proxy_cache = {}
+        @raw_data = Hash.new { |h,k| h[k] = {} }
+
+        clear_dirty_states!
 
         self.attributes_raw = attributes_from_field_definition.merge('id' => id)
         self.attributes = attributes
 
-        clear_dirty_states!
 
         _run_initialize_callbacks
       end
@@ -176,7 +195,7 @@ module MassiveRecord
         @destroyed = @readonly = false
         @relation_proxy_cache = {}
 
-        self.attributes_raw = coder['attributes']
+        reinit_with(coder)
         fill_attributes_with_default_values_where_nil_is_not_allowed
 
         _run_find_callbacks
@@ -185,6 +204,12 @@ module MassiveRecord
         self
       end
 
+      def reinit_with(coder) # :nodoc:
+        @raw_data = Hash.new { |h,k| h[k] = {} }
+        @raw_data.update(coder['raw_data']) if coder.has_key? 'raw_data'
+        self.attributes_raw = coder['attributes']
+      end
+
 
       def ==(other)
         other.equal?(self) || other.instance_of?(self.class) && id == other.id
@@ -197,6 +222,7 @@ module MassiveRecord
 
       def freeze
         @attributes.freeze
+        self
       end
 
       def frozen?
@@ -242,6 +268,31 @@ module MassiveRecord
         object.init_with('attributes' => attributes.select{|k| !['id', 'created_at', 'updated_at'].include?(k)})
         object
       end
+
+
+      #
+      # The raw data is raw values returned by the adapter.
+      # It is a nested hash like:
+      #
+      # {
+      #   'family' => {
+      #     'attr1' => 'value'
+      #     'attr2' => 'value'
+      #   },
+      #
+      #   'addresses' => {
+      #     'address-1' => {'serialized' => 'attributes', 'for' => 'address-2'}
+      #   }
+      #   ...
+      # }
+      #
+      def raw_data
+        @raw_data.dup
+      end
+
+      def update_raw_data_for_column_family(column_family, new_values) # :nodoc:
+        @raw_data[column_family] = new_values
+      end
       
 
       private
@@ -271,7 +322,7 @@ module MassiveRecord
 
 
       def next_id
-        IdFactory.next_for(self.class).to_s
+        id_factory.next_for(self.class).to_s
       end
     end
 
@@ -279,19 +330,21 @@ module MassiveRecord
     Base.class_eval do
       include Config
       include Persistence
-      include Relations::Interface
       include Finders
+      include IdentityMap
       extend  RescueMissingTableOnFind
       include AttributeMethods
+      include Relations::Interface
       include AttributeMethods::Write, AttributeMethods::Read
       include AttributeMethods::TimeZoneConversion
       include AttributeMethods::Dirty
+      include AttributeMethods::CastNumbersOnWrite
       include Validations
-      include Callbacks
+      include Callbacks, ActiveModel::Observing
       include Timestamps
       include SingleTableInheritance
       include DefaultId
-      include QueryInstrumentation
+      include QueryInstrumentation::Table
 
 
       alias [] read_attribute
@@ -302,6 +355,7 @@ end
 
 require 'massive_record/orm/table'
 require 'massive_record/orm/column'
+require 'massive_record/orm/embedded'
 require 'massive_record/orm/id_factory'
 require 'massive_record/orm/log_subscriber'