massive_record 0.1.1 → 0.2.0.beta

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

@@ -0,0 +1,174 @@
+module MassiveRecord
+  module ORM
+    module Relations
+      #
+      # Parent class for all proxies sitting between records.
+      # It's responsibility is to transparently load and forward
+      # method calls to it's proxy_target. Iy may also do some small maintenance
+      # work like setting foreign key in proxy_owner object etc. That kind of
+      # functionality is likely to be implemented in one of it's more
+      # specific sub class proxies.
+      #
+      class Proxy
+        instance_methods.each { |m| undef_method m unless m.to_s =~ /^(?:nil\?|send|object_id|to_a|to_s|extend|equal\?)$|^__|^respond_to|^should|^instance_variable_/ }
+
+        attr_reader :proxy_target
+        attr_accessor :proxy_owner, :metadata
+
+        delegate :class_name, :proxy_target_class, :represents_a_collection?, :to => :metadata
+
+        def initialize(options = {})
+          options.to_options!
+          self.metadata = options[:metadata]
+          self.proxy_owner = options[:proxy_owner]
+          self.proxy_target = options[:proxy_target]
+
+          reset if proxy_target.nil?
+        end
+
+
+        #
+        # The proxy_target of a relation is the record
+        # the proxy_owner references. For instance,
+        # 
+        # class Person
+        #   references_one :car
+        # end
+        #
+        # The proxy_owner is a record of class person, the proxy_target will be the car.
+        #
+        def proxy_target=(proxy_target)
+          @proxy_target = proxy_target
+          loaded! unless @proxy_target.nil?
+        end
+        
+        #
+        # Returns the proxy_target. Loads it, if it's not there.
+        # Returns nil if for some reason proxy_target could not be found.
+        #
+        def load_proxy_target
+          self.proxy_target = find_proxy_target_or_find_with_proc if find_proxy_target?
+          proxy_target
+        rescue RecordNotFound
+          reset
+        end
+
+        def reload
+          reset
+          load_proxy_target
+        end
+
+        def reset
+          @loaded = @proxy_target = nil
+        end
+
+        def replace(proxy_target)
+          if proxy_target.nil?
+            reset 
+          else
+            raise_if_type_mismatch(proxy_target)
+            self.proxy_target = proxy_target
+          end
+        end
+
+        def inspect
+          load_proxy_target.inspect
+        end
+
+
+
+        #
+        # If the proxy is loaded it has a proxy_target
+        #
+        def loaded?
+          !!@loaded
+        end
+
+        def loaded!
+          @loaded = true
+        end
+
+
+
+
+        def respond_to?(*args)
+          super || (load_proxy_target && proxy_target.respond_to?(*args))
+        end
+
+        def method_missing(method, *args, &block)
+          return proxy_target.send(method, *args, &block) if load_proxy_target && proxy_target.respond_to?(method)
+          super
+        rescue NoMethodError => e
+          raise e, e.message.sub(/ for #<.*$/, " via proxy for #{proxy_target}")
+        end
+      
+
+        # Strange.. Without Rails, to_param goes through method_missing,
+        #           With Rails it seems like the proxy answered to to_param, which
+        #           kinda was not what I wanted.
+        def to_param # :nodoc:
+          proxy_target.try :to_param
+        end
+        
+
+        protected
+
+        def find_proxy_target_or_find_with_proc
+          find_with_proc? ? find_proxy_target_with_proc : find_proxy_target
+        end
+
+        #
+        # "Abstract" method used to find proxy_target for the proxy.
+        # Implement in subclasses. It is not called when the meta
+        # data contains a find_with proc; in that case find_proxy_target_with_proc
+        # is used instead
+        #
+        def find_proxy_target
+        end
+        
+        #
+        # Gives sub classes a place to hook into when we are
+        # gonna find proxy_target(s) by the proc. For instance, the
+        # references_many proxy ensures that the result of proc
+        # is put inside of an array.
+        #
+        def find_proxy_target_with_proc(options = {})
+          metadata.find_with.call(proxy_owner, options)
+        end
+
+        #
+        # When are we supposed to find a proxy_target? Find a proxy_target is done
+        # through load_proxy_target.
+        #
+        def find_proxy_target?
+          !loaded? && can_find_proxy_target?
+        end
+
+        #
+        # Override this to controll when a proxy_target may be found.
+        #
+        def can_find_proxy_target?
+          find_with_proc?
+        end
+
+        def update_foreign_key_fields_in_proxy_owner?
+          !proxy_owner.destroyed?
+        end
+
+        #
+        # Are we supposed to find proxy_target with a proc?
+        #
+        def find_with_proc?
+          !metadata.find_with.nil? && metadata.find_with.respond_to?(:call)
+        end
+
+        def raise_if_type_mismatch(record)
+          unless record.is_a? proxy_target_class
+            message = "#{class_name}(##{proxy_target_class.object_id}) expected, got #{record.class}(##{record.class.object_id})"
+            raise RelationTypeMismatch.new(message)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/orm/relations.rb

@@ -0,0 +1,6 @@
+require 'massive_record/orm/relations/proxy'
+require 'massive_record/orm/relations/proxy/references_one'
+require 'massive_record/orm/relations/proxy/references_one_polymorphic'
+require 'massive_record/orm/relations/proxy/references_many'
+require 'massive_record/orm/relations/metadata'
+require 'massive_record/orm/relations/interface'

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

@@ -85,7 +85,7 @@ module MassiveRecord
 
           attributes_schema.each do |attr_name, orm_field|
             next unless only_attr_names.empty? || only_attr_names.include?(attr_name)
-            values[orm_field.column] = send(attr_name)
+            values[orm_field.column] = orm_field.encode(send(attr_name))
           end
 
           values

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

@@ -7,7 +7,7 @@ module MassiveRecord
         TYPES = [:string, :integer, :float, :boolean, :array, :hash, :date, :time]
 
         attr_writer :default
-        attr_accessor :name, :column, :type, :fields
+        attr_accessor :name, :column, :type, :fields, :coder
 
 
         validates_presence_of :name
@@ -25,7 +25,7 @@ module MassiveRecord
         def self.new_with_arguments_from_dsl(*args)
           field_options = args.extract_options!
           field_options[:name] = args[0]
-          field_options[:type] = args[1]
+          field_options[:type] ||= args[1]
 
           new(field_options)
         end
@@ -40,6 +40,11 @@ module MassiveRecord
           self.column = options[:column]
           self.type = options[:type] || :string
           self.default = options[:default]
+
+          self.coder = options[:coder] || Base.coder
+
+          @@encoded_nil_value = coder.dump(nil)
+          @@encoded_null_string = coder.dump("null")
         end
 
 
@@ -84,34 +89,36 @@ module MassiveRecord
 
 
         def decode(value)
-          return nil if value.nil?
-
-          if type == :boolean
-            return value if value === TrueClass || value === FalseClass
-          else
-            return value if value.class == type.to_s.classify.constantize
-          end
+          return value if value.nil? || value_is_already_decoded?(value)
           
-          case type
-          when :string
-            value
-          when :boolean
-            value.to_s.empty? ? nil : !value.to_s.match(/^(true|1)$/i).nil?
-          when :integer
-            value.to_s.empty? ? nil : value.to_i
-          when :float
-            value.to_s.empty? ? nil : value.to_f
-          when :date
-            # TODO : find a nicer way to do that
-            value.empty? || value.to_s == "0" ? nil : Date.parse(value)
-          when :time
-            value.empty? ? nil : Time.parse(value)
-          when :array
-            value
-          when :hash
+          value = case type
+                  when :boolean
+                    value.blank? ? nil : !value.to_s.match(/^(true|1)$/i).nil?
+                  when :date
+                    value.blank? || value.to_s == "0" ? nil : (Date.parse(value) rescue nil)
+                  when :time
+                    value.blank? ? nil : (Time.parse(value) rescue nil)
+                  when :string
+                    if value.present?
+                      value = value.to_s if value.is_a? Symbol
+                      coder.load(value)
+                    end
+                  when :integer, :float, :array, :hash
+                    coder.load(value) if value.present?
+                  else
+                    raise "Unable to decode #{value}, class: #{value}"
+                  end
+          ensure
+            unless loaded_value_is_of_valid_class?(value)
+              raise SerializationTypeMismatch.new("Expected #{value} (class: #{value.class}) to be any of: #{classes.join(', ')}.")
+            end
+        end
+
+        def encode(value)
+          if type == :string && !(value.nil? || value == @@encoded_nil_value)
             value
           else
-            value
+            coder.dump(value)
           end
         end
 
@@ -122,6 +129,34 @@ module MassiveRecord
         def name=(name)
           @name = name.to_s
         end
+
+        def classes
+          classes = case type
+                    when :boolean
+                      [TrueClass, FalseClass]
+                    when :integer
+                      [Fixnum]
+                    else
+                      klass = type.to_s.classify
+                      if ::Object.const_defined?(klass)
+                        [klass.constantize]
+                      end
+                    end
+
+          classes || []
+        end
+
+        def value_is_already_decoded?(value)
+          if type == :string
+            value.is_a?(String) && !(value == @@encoded_null_string || value == @@encoded_nil_value)
+          else
+            classes.include?(value.class)
+          end
+        end
+
+        def loaded_value_is_of_valid_class?(value)
+          value.nil? || value.is_a?(String) && value == @@encoded_nil_value || value_is_already_decoded?(value)
+        end
       end
     end
   end

data/lib/massive_record/orm/single_table_inheritance.rb

@@ -0,0 +1,21 @@
+module MassiveRecord
+  module ORM
+    module SingleTableInheritance
+      extend ActiveSupport::Concern
+
+      included do
+        after_initialize :ensure_proper_type
+
+        
+      end
+
+      def ensure_proper_type
+        attr = self.class.inheritance_attribute
+
+        if respond_to?(attr) && self[attr].blank? && self.class.base_class != self.class
+          self[attr] = self.class.to_s
+        end
+      end
+    end
+  end
+end

data/lib/massive_record/version.rb

@@ -1,3 +1,3 @@
 module MassiveRecord
-  VERSION = "0.1.1"
+  VERSION = "0.2.0.beta"
 end

data/lib/massive_record/wrapper/adapter.rb

@@ -0,0 +1,6 @@
+# Include the specific Adapters classes into the Wrapper
+module MassiveRecord
+  module Wrapper
+    include ADAPTER
+  end
+end

data/lib/massive_record/wrapper/base.rb

@@ -1,12 +1,11 @@
 require 'yaml'
-require 'massive_record/wrapper/connection'
+require 'json'
+
+require 'massive_record/wrapper/adapter'
+require 'massive_record/wrapper/errors'
 require 'massive_record/wrapper/tables_collection'
-require 'massive_record/wrapper/table'
-require 'massive_record/wrapper/row'
 require 'massive_record/wrapper/column_families_collection'
-require 'massive_record/wrapper/column_family'
 require 'massive_record/wrapper/cell'
-require 'massive_record/wrapper/scanner'
 
 module MassiveRecord
   module Wrapper
@@ -18,11 +17,11 @@ module MassiveRecord
       end
 
       def self.connection(opts = {})
-        conn = Connection.new(opts.empty? ? config : opts)
+        conn = ADAPTER::Connection.new(opts.empty? ? config : opts)
         conn.open
         conn
       end
       
     end  
   end
-end
+end

data/lib/massive_record/wrapper/cell.rb

@@ -1,44 +1,21 @@
 module MassiveRecord
   module Wrapper
     class Cell
-      attr_writer :value
+      attr_reader :value
       attr_accessor :created_at
 
-      class << self
-        def serialize_value(v)
-          serialize?(v) ? v.to_yaml : v.to_s.force_encoding(Encoding::BINARY)
-        end
-
-        private
-
-        def serialize?(v)
-          [Hash, Array, NilClass].include?(v.class)
-        end
-      end
-
       def initialize(opts = {})
-        @value = opts[:value]
-        @created_at = opts[:created_at]
-      end
-    
-      def value
-        @value.is_a?(String) ? @value.to_s.force_encoding(Encoding::UTF_8) : @value
+        self.value = opts[:value]
+        self.created_at = opts[:created_at]
       end
     
-      def deserialize_value
-        is_yaml? ? YAML.load(@value) : value
+      def value=(v)
+        raise "#{v} was a #{v.class}, but it must be a String!" unless v.is_a? String
+        @value = v.dup.force_encoding(Encoding::UTF_8)
       end
-    
-      def serialize_value(v)
-        @value = self.class.serialize_value(v)
-      end
-    
-      def serialized_value
-        self.class.serialize_value(@value)
-      end
-    
-      def is_yaml?
-        @value =~ /^--- \n/ || @value =~ /^--- {}/ || @value =~ /^--- \[\]/
+
+      def value_to_thrift
+        value.force_encoding(Encoding::BINARY)
       end
     end
   end

data/lib/massive_record/wrapper/column_families_collection.rb

@@ -5,10 +5,10 @@ module MassiveRecord
       attr_accessor :table
   
       def create(column_family, opts = {})
-        if column_family.is_a?(MassiveRecord::Wrapper::ColumnFamily)
+        if column_family.is_a?(ADAPTER::ColumnFamily)
           self.push(column_family)
         else
-          self.push(MassiveRecord::Wrapper::ColumnFamily.new(column_family, opts))
+          self.push(ADAPTER::ColumnFamily.new(column_family, opts))
         end
     
         true