active-fedora 8.7.0 → 9.0.0.beta1

data/lib/active_fedora/attribute_methods.rb

@@ -0,0 +1,122 @@
+require 'active_support/core_ext/object'
+require 'active_support/core_ext/class/attribute'
+
+module ActiveFedora
+  module AttributeMethods
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeMethods
+
+    AttrNames = Module.new {
+      def self.set_name_cache(name, value)
+        const_name = "ATTR_#{name}"
+        unless const_defined? const_name
+          const_set const_name, value.dup.freeze
+        end
+      end
+    }
+
+    class AttributeMethodCache
+      def initialize
+        @module = Module.new
+        @method_cache = ThreadSafe::Cache.new
+      end
+
+      def [](name)
+        @method_cache.compute_if_absent(name) do
+          safe_name = name.unpack('h*').first
+          temp_method = "__temp__#{safe_name}"
+          ActiveFedora::AttributeMethods::AttrNames.set_name_cache safe_name, name
+          @module.module_eval method_body(temp_method, safe_name), __FILE__, __LINE__
+          @module.instance_method temp_method
+        end
+      end
+
+      private
+      def method_body; raise NotImplementedError; end
+    end
+
+
+    included do
+      initialize_generated_modules
+      include Read
+      include Write
+      include Dirty
+    end
+
+    # Returns an array of names for the attributes available on this object.
+    #
+    #   class Person < ActiveFedora::Base
+    #   end
+    #
+    #   person = Person.new
+    #   person.attribute_names
+    #   # => ["id", "created_at", "updated_at", "name", "age"]
+    def attribute_names
+      @attributes.keys
+    end
+
+    # Returns a hash of all the attributes with their names as keys and the values of the attributes as values.
+    #
+    #   class Person < ActiveFedora::Base
+    #   end
+    #
+    #   person = Person.create(name: 'Francesco', age: 22)
+    #   person.attributes
+    #   # => {"id"=>3, "created_at"=>Sun, 21 Oct 2012 04:53:04, "updated_at"=>Sun, 21 Oct 2012 04:53:04, "name"=>"Francesco", "age"=>22}
+    def attributes
+      attribute_names.each_with_object({}) { |name, attrs|
+        attrs[name] = read_attribute(name)
+      }
+    end
+
+
+    # Returns the value of the attribute identified by <tt>attr_name</tt> after it has been typecast (for example,
+    # "2004-12-12" in a date column is cast to a date object, like Date.new(2004, 12, 12)). It raises
+    # <tt>ActiveModel::MissingAttributeError</tt> if the identified attribute is missing.
+    #
+    # Alias for the <tt>read_attribute</tt> method.
+    #
+    #   class Person < ActiveRecord::Base
+    #     belongs_to :organization
+    #   end
+    #
+    #   person = Person.new(name: 'Francesco', age: '22')
+    #   person[:name] # => "Francesco"
+    #   person[:age]  # => 22
+    #
+    #   person = Person.select('id').first
+    #   person[:name]            # => ActiveModel::MissingAttributeError: missing attribute: name
+    #   person[:organization_id] # => ActiveModel::MissingAttributeError: missing attribute: organization_id
+    def [](attr_name)
+      read_attribute(attr_name) { |n| missing_attribute(n, caller) }
+    end
+
+    # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+.
+    # (Alias for the protected <tt>write_attribute</tt> method).
+    #
+    #   class Person < ActiveFedora::Base
+    #   end
+    #
+    #   person = Person.new
+    #   person[:age] = '22'
+    #   person[:age] # => 22
+    #   person[:age] # => Fixnum
+    def []=(attr_name, value)
+      write_attribute(attr_name, value)
+    end
+
+    module ClassMethods
+      def initialize_generated_modules # :nodoc:
+        @generated_attribute_methods = Module.new { extend Mutex_m }
+        include @generated_attribute_methods
+      end
+      private
+        # @param name [Symbol] name of the attribute to generate
+        def generate_method(name)
+          generated_attribute_methods.synchronize do
+            define_attribute_methods name
+          end
+        end
+    end
+  end
+end

data/lib/active_fedora/attribute_methods/dirty.rb

@@ -0,0 +1,16 @@
+module ActiveFedora
+  module AttributeMethods
+    module Dirty
+      extend ActiveSupport::Concern
+
+      def set_value(*val)
+        attribute = val.first
+        unless [:has_model, :modified_date].include? attribute
+          attribute_will_change!(attribute)
+        end
+        super
+      end
+    end
+  end
+end
+

data/lib/active_fedora/attribute_methods/read.rb

@@ -0,0 +1,61 @@
+module ActiveFedora
+  module AttributeMethods
+    module Read
+      ReaderMethodCache = Class.new(AttributeMethodCache) {
+        private
+        # We want to generate the methods via module_eval rather than
+        # define_method, because define_method is slower on dispatch.
+        # Evaluating many similar methods may use more memory as the instruction
+        # sequences are duplicated and cached (in MRI).  define_method may
+        # be slower on dispatch, but if you're careful about the closure
+        # created, then define_method will consume much less memory.
+        #
+        # But sometimes the database might return columns with
+        # characters that are not allowed in normal method names (like
+        # 'my_column(omg)'. So to work around this we first define with
+        # the __temp__ identifier, and then use alias method to rename
+        # it to what we want.
+        #
+        # We are also defining a constant to hold the frozen string of
+        # the attribute name. Using a constant means that we do not have
+        # to allocate an object on each call to the attribute method.
+        # Making it frozen means that it doesn't get duped when used to
+        # key the @attributes_cache in read_attribute.
+        def method_body(method_name, const_name)
+          <<-EOMETHOD
+          def #{method_name}
+            name = ::ActiveFedora::AttributeMethods::AttrNames::ATTR_#{const_name}
+            read_attribute(name) { |n| missing_attribute(n, caller) }
+          end
+          EOMETHOD
+        end
+      }.new
+
+      extend ActiveSupport::Concern
+
+      # Returns the value of the attribute identified by <tt>attr_name</tt> after
+      # it has been typecast (for example, "2004-12-12" in a date column is cast
+      # to a date object, like Date.new(2004, 12, 12)).
+      def read_attribute(attr_name)
+        name = attr_name.to_s
+        @attributes.fetch(name, nil)
+      end
+
+      private
+        def attribute(attribute_name)
+          read_attribute(attribute_name)
+        end
+
+
+      module ClassMethods
+        def define_method_attribute(name)
+          method = ReaderMethodCache[name.to_s]
+          generated_attribute_methods.module_eval {
+            define_method name, method
+          }
+        end
+
+      end
+    end
+  end
+end

data/lib/active_fedora/attribute_methods/write.rb

@@ -0,0 +1,47 @@
+module ActiveFedora
+  module AttributeMethods
+    module Write
+      WriterMethodCache = Class.new(AttributeMethodCache) {
+        private
+
+        def method_body(method_name, const_name)
+          <<-EOMETHOD
+          def #{method_name}(value)
+            name = ::ActiveFedora::AttributeMethods::AttrNames::ATTR_#{const_name}
+            write_attribute(name, value)
+          end
+          EOMETHOD
+        end
+      }.new
+
+      extend ActiveSupport::Concern
+
+      included do
+        attribute_method_suffix "="
+      end
+
+      def write_attribute(attribute_name, value)
+        if self.class.properties.key?(attribute_name)
+          @attributes[attribute_name] = value
+        else
+          raise ActiveModel::MissingAttributeError, "can't write unknown attribute `#{attribute_name}'"
+        end
+      end
+
+      private
+        def attribute=(attribute_name, value)
+          write_attribute(attribute_name, value)
+        end
+
+      module ClassMethods
+        def define_method_attribute=(name)
+          method = WriterMethodCache[name.to_s]
+          generated_attribute_methods.module_eval {
+            define_method "#{name}=", method
+          }
+        end
+      end
+
+    end
+  end
+end

data/lib/active_fedora/attributes.rb

@@ -1,17 +1,16 @@
 module ActiveFedora
   module Attributes
     extend ActiveSupport::Concern
-    extend ActiveSupport::Autoload
     include ActiveModel::Dirty
-    
-    autoload :Serializers
 
     included do
       include Serializers
+      include PrimaryKey
+
       after_save :clear_changed_attributes
       def clear_changed_attributes
         @previously_changed = changes
-        clear_attribute_changes(changes.keys)
+        @changed_attributes.clear
       end
     end
 
@@ -21,23 +20,46 @@ module ActiveFedora
       end
     end
 
+    def attribute_names
+      self.class.attribute_names
+    end
+
     def attributes
-      self.class.defined_attributes.keys.each_with_object({"id" => id}) {|key, hash| hash[key] = self[key]}
+      attribute_names.each_with_object({"id" => id}) {|key, hash| hash[key] = self[key] }
     end
 
-    # Calling inspect may trigger a bunch of loads, but it's mainly for debugging, so no worries.
+    # Calling inspect may trigger a bunch of datastream loads, but it's mainly for debugging, so no worries.
     def inspect
-      values = ["pid: #{pretty_pid.inspect}"]
-      values << self.class.defined_attributes.keys.map {|r| "#{r}: #{send(r).inspect}"}
+      values = ["id: #{id.inspect}"]
+      values << self.class.attribute_names.map { |attr| "#{attr}: #{self[attr].inspect}" }
       "#<#{self.class} #{values.flatten.join(', ')}>"
     end
 
     def [](key)
-      array_reader(key)
+      if assoc = self.association(key.to_sym)
+        # This is for id attributes stored in the rdf graph.
+        assoc.reader
+      elsif self.class.properties.key?(key.to_s)
+        # The attribute is stored in the RDF graph for this object
+        resource[key]
+      else
+        # The attribute is a delegate to a datastream
+        array_reader(key)
+      end
     end
 
     def []=(key, value)
-      array_setter(key, value)
+      raise ReadOnlyRecord if readonly?
+      if assoc = self.association(key.to_sym)
+        # This is for id attributes stored in the rdf graph.
+        assoc.replace(value)
+      elsif self.class.properties.key?(key.to_s)
+        # The attribute is stored in the RDF graph for this object
+        self.send(key.to_s+"=", value)
+      else
+        # The attribute is a delegate to a datastream
+        array_setter(key, value)
+      end
     end
 
     # @return [Boolean] true if there is an reader method and it returns a
@@ -50,6 +72,9 @@ module ActiveFedora
       self.send("#{field}_will_change!")
     end
 
+    def local_attributes
+      self.class.local_attributes
+    end
 
 
     protected
@@ -58,52 +83,63 @@ module ActiveFedora
     # the callback methods seem to trigger this, which means just initing an object (after_init)
     # causes a load of all the datastreams.
     def attribute_method?(attr_name) #:nodoc:
-      respond_to_without_attributes?(:attributes) && self.class.defined_attributes.include?(attr_name)
+      respond_to_without_attributes?(:attributes) && self.class.delegated_attributes.include?(attr_name)
     end
 
     private
-
     def array_reader(field, *args)
-      if md = /^(.+)_id$/.match(field)
-        # a belongs_to association reader
-        association = association(md[1].to_sym)
-        return association.id_reader if association
-      end
-      raise UnknownAttributeError, "#{self.class} does not have an attribute `#{field}'" unless self.class.defined_attributes.key?(field)
+      raise UnknownAttributeError, "#{self.class} does not have an attribute `#{field}'" unless self.class.delegated_attributes.key?(field)
 
-      value = self.class.defined_attributes[field].reader(self, *args)
-      self.class.multiple?(field) ? value : value.first      
+      val = self.class.delegated_attributes[field].reader(self, *args)
+      self.class.multiple?(field) ? val : val.first
     end
 
     def array_setter(field, args)
-      if md = /^(.+)_id$/.match(field)
-        # a belongs_to association writer
-        association = association(md[1].to_sym)
-        return association.id_writer(args) if association
-      end
-      raise UnknownAttributeError, "#{self.class} does not have an attribute `#{field}'" unless self.class.defined_attributes.key?(field)
+      raise UnknownAttributeError, "#{self.class} does not have an attribute `#{field}'" unless self.class.delegated_attributes.key?(field)
       if self.class.multiple?(field)
-        unless args.nil? || ( args.respond_to?(:each) && !args.kind_of?(ActiveTriples::Resource) )
-          raise ArgumentError, "Cannot set the multi-valued attribute `#{field}' to a single value."
-        end
-      elsif args.respond_to?(:each) # unique
-        unless args.kind_of?(ActiveTriples::Resource)
-          raise ArgumentError, "Cannot set the single-valued attribute `#{field}' to multiple values."
+        if args.present? && !args.respond_to?(:each)
+          raise ArgumentError, "You attempted to set the attribute `#{field}' on `#{self.class}' to a scalar value. However, this attribute is declared as being multivalued."
         end
+      elsif args.respond_to?(:each) # singular
+        raise ArgumentError, "You attempted to set the attribute `#{field}' on `#{self.class}' to an enumerable value. However, this attribute is declared as being singular."
       end
-      self.class.defined_attributes[field].writer(self, args)
+      self.class.delegated_attributes[field].writer(self, args)
     end
 
     module ClassMethods
+      def attribute_names
+        @attribute_names ||= delegated_attributes.keys + association_attributes - system_attributes
+      end
+
+      # Attributes that are asserted about this RdfSource (not on a datastream)
+      def local_attributes
+        association_attributes + properties.keys - system_attributes
+      end
+
+      # Attributes that are required by ActiveFedora and Fedora
+      def system_attributes
+        ['has_model', 'create_date', 'modified_date']
+      end
+
+      # Attributes that represent associations to other repository objects
+      def association_attributes
+        outgoing_reflections.values.map { |reflection| reflection.foreign_key.to_s }
+      end
+
       def defined_attributes
-        @defined_attributes ||= {}.with_indifferent_access
-        return @defined_attributes unless superclass.respond_to?(:defined_attributes) and value = superclass.defined_attributes
-        @defined_attributes = value.dup if @defined_attributes.empty?
-        @defined_attributes
+        Deprecation.warn Attributes, "defined_attributes has been renamed to delegated_attributes. defined_attributes will be removed in ActiveFedora 9"
+        delegated_attributes
+      end
+
+      def delegated_attributes
+        @delegated_attributes ||= {}.with_indifferent_access
+        return @delegated_attributes unless superclass.respond_to?(:delegated_attributes) and value = superclass.delegated_attributes
+        @delegated_attributes = value.dup if @delegated_attributes.empty?
+        @delegated_attributes
       end
 
-      def defined_attributes= val
-        @defined_attributes = val
+      def delegated_attributes= val
+        @delegated_attributes = val
       end
 
       def has_attributes(*fields)
@@ -128,15 +164,29 @@ module ActiveFedora
       # @param [Symbol] field the field to query
       # @return [Boolean]
       def multiple?(field)
-        defined_attributes[field].multiple
+        raise UnknownAttributeError, "#{self} does not have an attribute `#{field}'" unless delegated_attributes.key?(field)
+        delegated_attributes[field].multiple
       end
 
-      def find_or_create_defined_attribute(field, dsid, args)  
-        self.defined_attributes[field] ||= DatastreamAttribute.new(field, dsid, datastream_class_for_name(dsid), args)
+
+      def property name, properties
+        find_or_create_defined_attribute(name, nil, {multiple: true}.merge(properties))
+        super
       end
 
       private
 
+      def find_or_create_defined_attribute(field, dsid, args)
+        delegated_attributes[field] ||= DelegatedAttribute.new(field, dsid, datastream_class_for_name(dsid), args)
+      end
+
+      # @param [String] dsid the datastream id
+      # @return [Class] the class of the datastream
+      def datastream_class_for_name(dsid)
+        reflection = reflect_on_association(dsid)
+        reflection ? reflection.klass : ActiveFedora::File
+      end
+
       def create_attribute_reader(field, dsid, args)
         find_or_create_defined_attribute(field, dsid, args)
 
@@ -147,9 +197,8 @@ module ActiveFedora
 
       def create_attribute_setter(field, dsid, args)
         find_or_create_defined_attribute(field, dsid, args)
-
         define_method "#{field}=".to_sym do |v|
-          self[field] = v
+          self[field]=v
         end
       end
     end