bigrecord 0.0.5

data/lib/big_record/embedded_associations/association_proxy.rb

@@ -0,0 +1,148 @@
+module BigRecord
+  module EmbeddedAssociations
+    class AssociationProxy #:nodoc:
+      instance_methods.each { |m| undef_method m unless m =~ /(^__|^nil\?$|^send$|proxy_)/ }
+
+#      def initialize(owner, reflection)
+#        @owner, @reflection = owner, reflection
+#        Array(reflection.options[:extend]).each { |ext| proxy_extend(ext) }
+#        reset
+#      end
+
+      def find(id)
+        @target.select{|s| s.id == id}.first
+      end
+
+      # Remove +records+ from this association.  Does not destroy +records+.
+      def delete(*records)
+        records = flatten_deeper(records)
+        #records.each { |record| raise_on_type_mismatch(record) }
+        records.reject! { |record| @target.delete(record)}
+      end
+
+      def proxy_owner
+        @owner
+      end
+
+      def proxy_reflection
+        @reflection
+      end
+
+      def proxy_target
+        @target
+      end
+
+      def respond_to?(symbol, include_priv = false)
+        proxy_respond_to?(symbol, include_priv) || (load_target && @target.respond_to?(symbol, include_priv))
+      end
+
+      # Explicitly proxy === because the instance method removal above
+      # doesn't catch it.
+      def ===(other)
+        load_target
+        other === @target
+      end
+
+      def aliased_table_name
+        @reflection.klass.table_name
+      end
+
+      def reset
+        @loaded = false
+        @target = nil
+      end
+
+      def reload
+        reset
+        load_target
+      end
+
+      def loaded?
+        @loaded
+      end
+
+      def loaded
+        @loaded = true
+      end
+
+      def target
+        @target
+      end
+
+      def target=(target)
+        @target = target
+        loaded
+      end
+
+      protected
+        def dependent?
+          @reflection.options[:dependent] || false
+        end
+
+        def quoted_record_ids(records)
+          records.map { |record| record.quoted_id }.join(',')
+        end
+
+        def extract_options_from_args!(args)
+          @owner.send(:extract_options_from_args!, args)
+        end
+
+        def set_belongs_to_association_for(record)
+          if @reflection.options[:as]
+            record["#{@reflection.options[:as]}_id"]   = @owner.id unless @owner.new_record?
+            record["#{@reflection.options[:as]}_type"] = @owner.class.base_class.name.to_s
+          else
+            record[@reflection.primary_key_name] = @owner.id unless @owner.new_record?
+          end
+        end
+
+        def merge_options_from_reflection!(options)
+          options.reverse_merge!(
+            :group   => @reflection.options[:group],
+            :limit   => @reflection.options[:limit],
+            :offset  => @reflection.options[:offset],
+            :joins   => @reflection.options[:joins],
+            :include => @reflection.options[:include],
+            :select  => @reflection.options[:select]
+          )
+        end
+
+      private
+        def method_missing(method, *args, &block)
+          if load_target
+            @target.send(method, *args, &block)
+          end
+        end
+
+        def load_target
+          return nil unless defined?(@loaded)
+
+          if !loaded? and (!@owner.new_record? || foreign_key_present)
+            @target = find_target
+          end
+
+          @loaded = true
+          @target
+        rescue BigRecord::RecordNotFound
+          reset
+        end
+
+        # Can be overwritten by associations that might have the foreign key available for an association without
+        # having the object itself (and still being a new record). Currently, only belongs_to present this scenario.
+        def foreign_key_present
+          false
+        end
+
+        def raise_on_type_mismatch(record)
+          unless record.is_a?(@reflection.klass)
+            raise BigRecord::AssociationTypeMismatch, "#{@reflection.class_name} expected, got #{record.class}"
+          end
+        end
+
+        # Array#flatten has problems with recursive arrays. Going one level deeper solves the majority of the problems.
+        def flatten_deeper(array)
+          array.collect { |element| element.respond_to?(:flatten) ? element.flatten : element }.flatten
+        end
+    end
+  end
+end

data/lib/big_record/family_span_columns.rb

@@ -0,0 +1,89 @@
+# Replace the anonymous classes
+module BigRecord
+  module FamilySpanColumns
+
+    def self.included(base) #:nodoc:
+      super
+      base.alias_method_chain :column_for_attribute, :family_span_columns
+      base.alias_method_chain :attributes_from_column_definition, :family_span_columns
+
+      base.extend(ClassMethods)
+      base.class_eval do
+        class << self
+          alias_method_chain :alias_attribute, :family_span_columns
+        end
+      end
+    end
+
+    module ClassMethods
+
+      # Returns the list of columns that are not spanned on a whole family
+      def simple_columns
+        columns.select{|c|!c.family?}
+      end
+
+      # Returns the list of columns that are spanned on a whole family
+      def family_columns
+        columns.select{|c|c.family?}
+      end
+
+      # Define aliases to the fully qualified attributes
+      def alias_attribute_with_family_span_columns(alias_name, fully_qualified_name)
+        # when it's a single column everything's normal but when it's a
+        # column family then this actually add accessors for the whole family
+        alias_attribute_without_family_span_columns(alias_name, fully_qualified_name)
+
+        # fully_qualified_name ends with ':' => consider it a family span column
+        if fully_qualified_name.ends_with?(":")
+          # add the accessors for the individual columns
+          self.class_eval <<-EOF
+            def #{alias_name}(column_key=nil)
+              if column_key
+                read_attribute("#{fully_qualified_name}\#{column_key}")
+              else
+                read_family_attributes("#{fully_qualified_name}")
+              end
+            end
+            def set_#{alias_name}(column_key, value)
+              write_attribute("#{fully_qualified_name}\#{column_key}", value)
+            end
+          EOF
+        end
+      end
+    end
+
+    # Returns the list of columns that are not spanned on a whole family
+    def simple_columns
+      columns.select{|c|!c.family?}
+    end
+
+    # Returns the column object for the named attribute.
+    def column_for_attribute_with_family_span_columns(name)
+      name = name.to_s
+
+      # ignore methods '=' and '?' (e.g. 'normalized_srf_ief:231=')
+      return if name =~ /=|\?$/
+
+      column = self.columns_hash[name]
+      unless column
+        family = BigRecord::ConnectionAdapters::Column.extract_family(name)
+        column = self.columns_hash[family] if family
+      end
+      column
+    end
+
+    # Initializes the attributes array with keys matching the columns from the linked table and
+    # the values matching the corresponding default value of that column, so
+    # that a new instance, or one populated from a passed-in Hash, still has all the attributes
+    # that instances loaded from the database would.
+    def attributes_from_column_definition_with_family_span_columns
+      self.simple_columns.inject({}) do |attributes, column|
+        unless column.name == self.class.primary_key or column.family?
+          attributes[column.name] = column.default
+        end
+        attributes
+      end
+    end
+
+  end
+end