massive_record 0.2.1 → 0.2.2.rc1

data/lib/massive_record/orm/relations/proxy/references_one.rb

@@ -20,7 +20,7 @@ module MassiveRecord
 
           private
 
-          def find_proxy_target
+          def find_proxy_target(options = {})
             proxy_target_class.find(proxy_owner.send(metadata.foreign_key))
           end
 

data/lib/massive_record/orm/relations/proxy/references_one_polymorphic.rb

@@ -20,7 +20,7 @@ module MassiveRecord
 
           private
 
-          def find_proxy_target
+          def find_proxy_target(options = {})
             proxy_target_class.find(proxy_owner.send(metadata.foreign_key))
           end
 

data/lib/massive_record/orm/relations/proxy_collection.rb

@@ -0,0 +1,84 @@
+module MassiveRecord
+  module ORM
+    module Relations
+
+      #
+      # Proxy class for relations representing a collection
+      #
+      class ProxyCollection < Proxy
+        #
+        # Loading proxy_targets will merge it with records found currently in proxy,
+        # to make sure we don't remove any pushed proxy_targets only cause we load the
+        # proxy_targets.
+        #
+        def load_proxy_target(options = {})
+          proxy_target_before_load = proxy_target
+          proxy_target_after_load = super
+
+          self.proxy_target = (proxy_target_before_load + proxy_target_after_load).uniq
+        end
+
+        def reset(force = false)
+          super
+          @proxy_target = []
+        end
+
+        def replace(*records)
+          records.flatten!
+
+          if records.length == 1 and records.first.nil?
+            reset
+          else
+            delete_all
+            concat(records)
+          end
+        end
+
+        def first
+          limit(1).first
+        end
+
+        def empty?
+          length == 0
+        end
+
+        #
+        # Destroy record(s) from the collection
+        # Each record will be asked to destroy itself as well
+        #
+        def destroy(*records)
+          delete_or_destroy *records, :destroy
+        end
+
+
+        #
+        # Deletes record(s) from the collection
+        #
+        def delete(*records)
+          delete_or_destroy *records, :delete
+        end
+
+        #
+        # Destroys all records
+        #
+        def destroy_all
+          destroy(load_proxy_target).tap do
+            reset
+            loaded!
+          end
+        end
+
+        #
+        # Deletes all records from the relationship.
+        # Does not destroy the records
+        #
+        def delete_all
+          delete(load_proxy_target).tap do
+            reset
+            loaded!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/orm/schema/column_family.rb

@@ -5,7 +5,7 @@ module MassiveRecord
         include ActiveModel::Validations
 
         attr_accessor :column_families, :autoload_fields
-        attr_reader :name, :fields
+        attr_reader :name, :fields, :options_for_autoload_created_fields
 
 
         validates_presence_of :name
@@ -91,8 +91,9 @@ module MassiveRecord
         end
 
         # Internal DSL method
-        def autoload_fields
+        def autoload_fields(field_args = {})
           @autoload_fields = true
+          @options_for_autoload_created_fields = field_args
         end
 
         def autoload

data/lib/massive_record/orm/schema/{column_interface.rb → embedded_interface.rb}

@@ -3,7 +3,7 @@ require 'massive_record/orm/schema/common_interface'
 module MassiveRecord
   module ORM
     module Schema
-      module ColumnInterface
+      module EmbeddedInterface
         extend ActiveSupport::Concern
 
         included do
@@ -17,7 +17,7 @@ module MassiveRecord
           #
           # DSL method exposed into class. Makes it possible to do:
           #
-          # class Person < MassiveRecord::ORM::Column
+          # class Person < MassiveRecord::ORM::Embedded
           #  field :name
           #  field :age, :integer, :default => 0
           #  field :points, :integer, :column => :number_of_points
@@ -52,6 +52,32 @@ module MassiveRecord
           end
 
 
+          #
+          # Returns attributes in embedded object from raw data. Raw
+          # data's keys might different from a field name, if :column
+          # option has been used.
+          #
+          def transpose_raw_data_to_record_attributes_and_raw_data(id, raw_data)
+            attributes = {:id => id}
+            attributes['updated_at'] = raw_data.created_at
+
+            raw_attributes =  if raw_data.value.is_a? String
+                                Base.coder.load(raw_data.value)
+                              else
+                                raw_data.value
+                              end
+
+            raw_data = Hash[raw_attributes.collect do |attr, value|
+              [attr, RawData.new(value: value, created_at: raw_data.created_at)]
+            end]
+
+            attributes_schema.each do |attr_name, orm_field|
+              value = raw_attributes.has_key?(orm_field.column) ? raw_attributes[orm_field.column] : nil
+              attributes[attr_name] = value.nil? ? nil : orm_field.decode(raw_attributes[orm_field.column])
+            end
+
+            [attributes, raw_data]
+          end
 
 
           private
@@ -77,10 +103,13 @@ module MassiveRecord
           send(method, new_field.default) if respond_to? method
         end
         
+
         #
-        # TODO : Need to be cleaned up after we implement the has_many method
+        # Returns attributes as a hash which has correct keys
+        # based on it's field definition. For instance, you can
+        # have a class with a field :attr_name, :column => :stored_as_this
         #
-        def attributes_to_row_values_hash(only_attr_names = [])
+        def attributes_db_raw_data_hash(only_attr_names = [])
           values = Hash.new
 
           attributes_schema.each do |attr_name, orm_field|
@@ -90,6 +119,11 @@ module MassiveRecord
 
           values
         end
+
+        def attributes_to_row_values_hash(only_attr_names = [])
+          ActiveSupport::Deprecation.warn("attributes_to_row_values_hash is deprecated. Please use attributes_db_raw_data_hash")
+          attributes_db_raw_data_hash(only_attr_names)
+        end
       end
     end
   end

data/lib/massive_record/orm/schema/field.rb

@@ -126,6 +126,8 @@ module MassiveRecord
                       coder.load(value)
                     end
                   when :integer
+                    value = value.force_encoding(Encoding::BINARY)
+
                     if value =~ /\A\d*\Z/
                       coder.load(value) if value.present?
                     else

data/lib/massive_record/orm/schema/table_interface.rb

@@ -28,8 +28,15 @@ module MassiveRecord
           #
           #
           def column_family(name, &block)
+            add_column_family(name).instance_eval(&block)
+          end
+
+          #
+          # Adds a column family to your class
+          #
+          def add_column_family(name)
             ensure_column_families_exists
-            column_families.family_by_name_or_new(name).instance_eval(&block)
+            column_families.family_by_name_or_new(name)
           end
 
           #
@@ -54,15 +61,25 @@ module MassiveRecord
           # It should be on a unique and complete form like ["info:name", "info:phone"]
           #
           def autoload_column_families_and_fields_with(column_names)
+            ensure_column_families_exists
+
             column_names.each do |column_family_and_column_name|
               family_name, column_name = column_family_and_column_name.split(":")
               
               if family = column_families.family_by_name(family_name) and family.autoload_fields?
-                family.add? Field.new(:name => column_name)
+                family.add?(Field.new(
+                  family.options_for_autoload_created_fields.merge(:name => column_name)
+                ))
               end
             end
           end
 
+          #
+          # Makes it a bit more convenient to get all the column family names
+          #
+          def known_column_family_names
+            (column_families || []).collect &:name
+          end
 
 
 

data/lib/massive_record/orm/single_table_inheritance.rb

@@ -3,23 +3,54 @@ module MassiveRecord
     module SingleTableInheritance
       extend ActiveSupport::Concern
 
+      # 
+      # Raised if you call first on any sub class of your base class.
+      # Calling first() on a sub class can't be easily done through
+      # thrift as we can't apply any column filter on the STI type column.
+      # 
+      # What you need to do is, the very inefficient, SubClass.all.first
+      # When doing an all, all records will be fetched, but at least the
+      # array or records will be filtered and only correct class will be
+      # returned.
+      #
+      class FirstUnsupported < MassiveRecordError; end
+
+
       included do
         after_initialize :ensure_proper_type
       end
 
 
       module ClassMethods
+        def do_find(*args)
+          result = super
+          single_table_inheritance_enabled? ? ensure_only_class_or_subclass_of_self_are_returned(result) : result
+        end
+
+        def first(*args)
+          if base_class == self
+            super
+          else
+            raise FirstUnsupported.new("Sorry, first() on '#{self}' (sub class of the base class '#{base_class}') is unsupported due to unable to efficiently filter this through Thrift.")
+          end
+        end
 
         private
 
+        def ensure_only_class_or_subclass_of_self_are_returned(result)
+          multiple_result = result.is_a? Array
+          filtered_results = (multiple_result ? result : [result]).select { |result| result.kind_of? self }
+          multiple_result ? filtered_results : filtered_results.first
+        end
+
         #
         # In Rails development environment class files are not required before they are needed.
         #
-        # transpose_hbase_columns_to_record_attributes uses attributes_schema and
+        # transpose_hbase_row_to_record_attributes_and_raw_data uses attributes_schema and
         # for attributes_schema to have loaded all of it's fields correctly we need
         # to make sure Rails loads class file before attributes_schema renders it's schema.
         #
-        def transpose_hbase_columns_to_record_attributes(row) # :nodoc:
+        def transpose_hbase_row_to_record_attributes_and_raw_data(row) # :nodoc:
           if field = attributes_schema[inheritance_attribute]
             if cell_with_record_sti_class = row.columns[field.unique_name] and cell_with_record_sti_class.present?
               if klass = field.decode(cell_with_record_sti_class.value) and klass.present?
@@ -34,6 +65,10 @@ module MassiveRecord
         def ensure_sti_class_is_loaded(klass) # :nodoc:
           klass.constantize
         end
+
+        def single_table_inheritance_enabled?
+          !!attributes_schema[inheritance_attribute]
+        end
       end
 
 

data/lib/massive_record/orm/timestamps.rb

@@ -9,6 +9,10 @@ module MassiveRecord
           raise "created_at must be of type time" if attributes_schema['created_at'].type != :time
           @attributes['created_at'] = Time.now
         end
+
+        before_create do
+          @attributes['updated_at'] = @attributes['created_at'] || Time.now
+        end
       end
 
 
@@ -17,10 +21,11 @@ module MassiveRecord
       module ClassMethods
         private
 
-        def transpose_hbase_columns_to_record_attributes(row)
-          attributes = super
-          attributes['updated_at'] = row.updated_at
-          attributes
+        def transpose_hbase_row_to_record_attributes_and_raw_data(row)
+          super.tap do |attributes, raw_values|
+            attributes['updated_at'] = row.updated_at
+            attributes
+          end
         end
       end
 
@@ -31,6 +36,10 @@ module MassiveRecord
         self.class.time_zone_aware_attributes ? self['updated_at'].try(:in_time_zone) : self['updated_at']
       end
 
+      def updated_at=(time)
+        write_attribute :updated_at, time
+      end
+
       def write_attribute(attr_name, value)
         attr_name = attr_name.to_s
 
@@ -46,9 +55,10 @@ module MassiveRecord
       private
 
       def update(*)
-        # Not 100% accurat, as we might should re-read the saved row from
-        # the database to fetch exactly the correct updated at time, but
-        # it should do for now as it takes an extra query to check the time stamp.
+        # Sets updated at to Time.now, even though the updated at is
+        # read from the cell's time stamp on relad. We do this after
+        # a successfully update to remove the need to do a query to
+        # the db again to get the updated at timestamp.
         @attributes['updated_at'] = Time.now if updated = super 
         updated
       end

data/lib/massive_record/orm/validations.rb

@@ -40,6 +40,10 @@ module MassiveRecord
         perform_validation(options) ? super : raise(RecordInvalid.new(self))
       end
 
+      def valid?(context = nil)
+        context ||= (new_record? ? :create : :update)
+        super
+      end
 
       private
 

data/lib/massive_record/orm/validations/associated.rb

@@ -0,0 +1,50 @@
+module MassiveRecord
+  module ORM
+    module Validations
+      class AssociatedValidator < ActiveModel::EachValidator
+        def validate_each(record, attribute, value)
+          return if (value.is_a?(Array) ? value : [value]).collect{ |r| r.blank? || r.valid? }.all?
+          record.errors.add(attribute, :invalid, options.merge(:value => value))
+        end
+      end
+
+      module ClassMethods
+        # Validates whether the associated object or objects are all valid themselves. Works with any kind of association.
+        #
+        #   class Book < MassiveRecord::ORM::Table
+        #     has_many :pages
+        #     belongs_to :library
+        #
+        #     validates_associated :pages, :library
+        #   end
+        #
+        # Warning: If, after the above definition, you then wrote:
+        #
+        #   class Page < MassiveRecord::ORM::Table
+        #     belongs_to :book
+        #
+        #     validates_associated :book
+        #   end
+        #
+        # this would specify a circular dependency and cause infinite recursion.
+        #
+        # NOTE: This validation will not fail if the association hasn't been assigned. If you want to
+        # ensure that the association is both present and guaranteed to be valid, you also need to
+        # use +validates_presence_of+.
+        #
+        # Configuration options:
+        # * <tt>:message</tt> - A custom error message (default is: "is invalid")
+        # * <tt>:on</tt> - Specifies when this validation is active (default is <tt>:save</tt>, other options <tt>:create</tt>, <tt>:update</tt>).
+        # * <tt>:if</tt> - Specifies a method, proc or string to call to determine if the validation should
+        #   occur (e.g. <tt>:if => :allow_validation</tt>, or <tt>:if => Proc.new { |user| user.signup_step > 2 }</tt>).  The
+        #   method, proc or string should return or evaluate to a true or false value.
+        # * <tt>:unless</tt> - Specifies a method, proc or string to call to determine if the validation should
+        #   not occur (e.g. <tt>:unless => :skip_validation</tt>, or <tt>:unless => Proc.new { |user| user.signup_step <= 2 }</tt>).  The
+        #   method, proc or string should return or evaluate to a true or false value.
+        def validates_associated(*attr_names)
+          validates_with AssociatedValidator, _merge_attributes(attr_names)
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/rails/railtie.rb

@@ -1,6 +1,8 @@
 module MassiveRecord
   module Rails
     class Railtie < ::Rails::Railtie
+      config.massive_record = ActiveSupport::OrderedOptions.new
+
       initializer "massive_record.logger" do
         MassiveRecord::ORM::Base.logger = ::Rails.logger
       end
@@ -20,12 +22,41 @@ module MassiveRecord
         end
       end
 
+      # Insert IdentityMap's middleware if enabled
+      initializer "massive_record.identity_map" do |app|
+        if config.massive_record.delete(:identity_map)
+          config.app_middleware.insert_after "::ActionDispatch::Callbacks", "MassiveRecord::ORM::IdentityMap::Middleware"
+        end
+      end
+
       initializer "massive_record.time_zone_awareness" do
         ActiveSupport.on_load(:massive_record) do
           self.time_zone_aware_attributes = true
           self.default_timezone = :utc
         end
       end
+
+      initializer "massive_record.set_configs" do |app|
+        ActiveSupport.on_load(:massive_record) do
+          app.config.massive_record.each { |k,v| send("#{k}=", v) }
+        end
+      end
+
+      config.after_initialize do
+        ActiveSupport.on_load(:massive_record) do
+          instantiate_observers
+
+          if ::Rails::VERSION::MAJOR >= 3 && ::Rails::VERSION::MINOR >= 1
+            ActionDispatch::Reloader.to_prepare do
+              MassiveRecord::ORM::Base.instantiate_observers
+            end
+          else
+            ActionDispatch::Callbacks.to_prepare(:massive_record_instantiate_observers) do
+              MassiveRecord::ORM::Base.instantiate_observers
+            end
+          end
+        end
+      end
     end
   end
 end