active-fedora 8.7.0 → 9.0.0.beta1

data/lib/active_fedora/{datastream_attribute.rb → delegated_attribute.rb}

@@ -1,7 +1,7 @@
 module ActiveFedora
   # Represents the mapping between a model attribute and a field in a datastream
-  class DatastreamAttribute
-    
+  class DelegatedAttribute
+
     attr_accessor :dsid, :field, :datastream_class, :at, :multiple
 
     def initialize(field, dsid, datastream_class, args={})
@@ -12,11 +12,11 @@ module ActiveFedora
       self.at = args[:at]
     end
 
-    # Gives the primary solr name for a column. If there is more than one indexer on the field definition, it gives the first 
+    # Gives the primary solr name for a column. If there is more than one indexer on the field definition, it gives the first
     def primary_solr_name
-      @datastream ||= datastream_class.new(nil, dsid)
+      @datastream ||= datastream_class.new
       if @datastream.respond_to?(:primary_solr_name)
-        @datastream.primary_solr_name(field)
+        @datastream.primary_solr_name(field, dsid)
       else
         raise NoMethodError, "the datastream '#{datastream_class}' doesn't respond to 'primary_solr_name'"
       end
@@ -34,41 +34,72 @@ module ActiveFedora
       ds = datastream_for_attribute(obj, dsid)
       obj.mark_as_changed(field) if obj.value_has_changed?(field, v)
       if ds.kind_of?(ActiveFedora::RDFDatastream)
-        ds.send("#{field}=", v)
+        write_rdf(ds, v)
       else
-        terminology = at || [field]
-        ds.send(:update_indexed_attributes, {terminology => v})
+        write_om(ds, v)
       end
     end
 
     def reader(obj, *opts)
-      if obj.inner_object.is_a? SolrDigitalObject
-        begin
-          # Look in the cache
-          return obj.inner_object.fetch(field)
-        rescue NoMethodError => e
-          # couldn't get it from solr, so try from fedora.
-          ActiveFedora::Base.logger.info "Couldn't get #{field} out of solr, because #{e.message}. Trying another way." if ActiveFedora::Base.logger
-        end
-      end
-      # Load from fedora
       ds = datastream_for_attribute(obj, dsid)
       if ds.kind_of?(ActiveFedora::RDFDatastream)
-        ds.send(field)
+        read_rdf(ds)
       else
-        terminology = at || [field]
-        if terminology.length == 1 && opts.present?
-          ds.send(terminology.first, *opts)
-        else
-          ds.send(:term_values, *terminology)
-        end
+        read_om(ds, *opts)
       end
     end
 
     private
 
+    def write_om(ds, v)
+      terminology = at || [field]
+      ds.send(:update_indexed_attributes, {terminology => v})
+    end
+
+    def read_om(ds, *opts)
+      terminology = at || [field]
+      if terminology.length == 1 && opts.present?
+        ds.send(terminology.first, *opts)
+      else
+        ds.send(:term_values, *terminology)
+      end
+    end
+
+    def write_rdf(node, v)
+      term = if at
+        vals = at.dup
+        while vals.length > 1
+          node = node.send(vals.shift)
+          node = node.build if node.empty?
+          node = node.first
+        end
+        vals.first
+      else
+        field
+      end
+      node.send("#{term}=", v)
+    end
+
+    def read_rdf(node)
+      term = if at
+        vals = at.dup
+        while vals.length > 1
+          node = node.send(vals.shift)
+          node = if node.empty?
+            node.build
+          else
+            node.first
+          end
+        end
+        vals.first
+      else
+        field
+      end
+      node.send(term)
+    end
+
     def datastream_for_attribute(obj, dsid)
-      obj.datastreams[dsid] || raise(ArgumentError, "Undefined datastream id: `#{dsid}' in has_attributes")
+      obj.attached_files[dsid] || raise(ArgumentError, "Undefined datastream id: `#{dsid}' in has_attributes")
     end
 
   end

data/lib/active_fedora/errors.rb

@@ -0,0 +1,61 @@
+module ActiveFedora #:nodoc:
+
+  # Generic ActiveFedora exception class
+  class ActiveFedoraError < StandardError
+  end
+
+  # Raised when ActiveFedora cannot find the record by given id or set of ids
+  class ObjectNotFoundError < ActiveFedoraError
+  end
+
+  # Raised when attempting to access an attribute that has not been defined
+  class UnknownAttributeError < NoMethodError
+  end
+
+  # Raised when there is an error with the configuration files.
+  class ConfigurationError < ActiveFedoraError
+  end
+
+  # Raised when ActiveFedora cannot find the predicate mapping configuration file
+  class PredicateMappingsNotFoundError < ConfigurationError
+  end
+
+  # Raised when an object assigned to an association has an incorrect type.
+  #
+  #   class Ticket < ActiveFedora::Base
+  #     has_many :patches
+  #   end
+  #
+  #   class Patch < ActiveFedora::Base
+  #     belongs_to :ticket, predicate: ActiveFedora::RDF::RelsExt.isComponentOf
+  #   end
+  #
+  #   # Comments are not patches, this assignment raises AssociationTypeMismatch.
+  #   @ticket.patches << Comment.new(content: "Please attach tests to your patch.")
+  class AssociationTypeMismatch < ActiveFedoraError
+  end
+
+  # Raised when ActiveFedora cannot find the predicate corresponding to the given property
+  # in the predicate registy
+  class UnregisteredPredicateError < ActiveFedoraError
+  end
+
+  # Raised by ActiveFedora::Base.save! and ActiveFedora::Base.create! methods when record cannot be
+  # saved because record is invalid.
+  class RecordNotSaved < ActiveFedoraError
+  end
+
+  # Raised on attempt to update record that is instantiated as read only.
+  class ReadOnlyRecord < ActiveFedoraError
+  end
+
+  # Raised when trying to initialize a record that already exists. ActiveFedora::Base.find should
+  # be used instead
+  class IllegalOperation < ActiveFedoraError
+  end
+
+  # Used to rollback a transaction in a deliberate way without raising an exception.
+  # Transactions are currently incomplete
+  class Rollback < ActiveFedoraError
+  end
+end

data/lib/active_fedora/fedora.rb

@@ -0,0 +1,19 @@
+module ActiveFedora
+  class Fedora
+    def initialize(config)
+      @config = config
+    end
+
+    def host
+      @config[:url]
+    end
+
+    def base_path
+      @config[:base_path] || '/'
+    end
+
+    def connection
+      @connection ||= Ldp::Client.new(host)
+    end
+  end
+end

data/lib/active_fedora/fedora_attributes.rb

@@ -1,45 +1,77 @@
 module ActiveFedora
   module FedoraAttributes
+    extend ActiveSupport::Concern
 
-    delegate :state=, :label=, to: :inner_object
+    included do
+      include RDF::Indexing
+      include ActiveTriples::Properties
+      include ActiveTriples::Reflection
+      delegate :rdf_subject,  :get_values, to: :resource
 
-    #return the pid of the Fedora Object
-    # if there is no fedora object (loaded from solr) get the instance var
-    # TODO make inner_object a proxy that can hold the pid
-    def pid
-       @pid ||= @inner_object.pid
-    end
+      property :has_model, predicate: ::RDF::URI.new("http://fedora.info/definitions/v4/rels-ext#hasModel")
+      property :create_date, predicate: ActiveFedora::RDF::Fcrepo.created
+      property :modified_date, predicate: ActiveFedora::RDF::Fcrepo.lastModified
 
-    def id   ### Needed for the nested form helper
-      self.pid
-    end
+      def create_date
+        super.first
+      end
 
-    #return the owner id
-    def owner_id
-      Array(@inner_object.ownerId).first
+      def modified_date
+        super.first
+      end
     end
-    
-    def owner_id=(owner_id)
-      @inner_object.ownerId=(owner_id)
+
+    # Override ActiveTriples method for setting properties
+    def set_value(*args)
+      raise ReadOnlyRecord if readonly?
+      resource.set_value(*args)
     end
 
-    def label
-      Array(@inner_object.label).first
+    def id
+      if uri.kind_of?(::RDF::URI) && uri.value.blank?
+        nil
+      elsif uri.present?
+        self.class.uri_to_id(URI.parse(uri))
+      end
     end
 
-    def state
-      Array(@inner_object.state).first
+    # TODO: Remove after we no longer support #pid.
+    def pid
+      Deprecation.warn FedoraAttributes, "#{self.class}#pid is deprecated and will be removed in active-fedora 10.0. Use #{self.class}#id instead."
+      id
     end
 
-    #return the create_date of the inner object (unless it's a new object)
-    def create_date
-      @inner_object.new_record? ?  Time.now : Array(@inner_object.createdDate).first
+    def uri
+      # TODO could we return a RDF::URI instead?
+      uri = @ldp_source.try(:subject_uri)
+      uri.value == '' ? uri : uri.to_s
     end
 
-    #return the modification date of the inner object (unless it's a new object)
-    def modified_date
-      @inner_object.new_record? ? Time.now : Array(@inner_object.lastModifiedDate).first
+    ##
+    # The resource is the RdfResource object that stores the graph for
+    # the datastream and is the central point for its relationship to
+    # other nodes.
+    #
+    # set_value, get_value, and property accessors are delegated to this object.
+    def resource
+      @resource ||= self.class.resource_class.new(@ldp_source.graph.rdf_subject, @ldp_source.graph)
     end
 
+    module ClassMethods
+      # We make a unique class, because properties belong to a class.
+      # This keeps properties from different objects separate.
+      def resource_class
+        @generated_resource_class ||= begin
+            klass = self.const_set(:GeneratedResourceSchema, Class.new(ActiveTriples::Resource))
+            klass.properties.merge(self.properties).each do |property, config|
+              klass.property(config.term,
+                             predicate: config.predicate,
+                             class_name: config.class_name,
+                             multivalue: config.multivalue)
+            end
+            klass
+        end
+      end
+    end
   end
 end

data/lib/active_fedora/file.rb

@@ -0,0 +1,318 @@
+module ActiveFedora
+
+  #This class represents a Fedora datastream
+  class File
+    include AttributeMethods # allows 'content' to be tracked
+    include ActiveModel::Dirty
+    extend Deprecation
+    extend ActiveTriples::Properties
+    generate_method 'content'
+
+    extend ActiveModel::Callbacks
+    define_model_callbacks :save, :create, :destroy
+    define_model_callbacks :initialize, only: :after
+
+    attr_accessor :last_modified
+
+    # @param parent_or_url [ActiveFedora::Base, String, Hash, NilClass] the parent resource or the URI of this resource
+    # @param path_name [String] the path partial relative to the resource
+    # @param options [Hash]
+    def initialize(parent_or_url_or_hash = nil, dsid=nil, options={})
+      case parent_or_url_or_hash
+      when Hash
+        content = ''
+        @ldp_source = Ldp::Resource::BinarySource.new(ldp_connection, nil, content, ActiveFedora.fedora.host + ActiveFedora.fedora.base_path)
+      when nil, String
+      #TODO this is similar to Core#build_ldp_resource
+        content = ''
+        @ldp_source = Ldp::Resource::BinarySource.new(ldp_connection, parent_or_url_or_hash, content, ActiveFedora.fedora.host + ActiveFedora.fedora.base_path)
+      when ActiveFedora::Base
+        Deprecation.warn File, "Initializing a file by passing a container is deprecated. Initialize with a uri instead. This capability will be removed in active-fedora 10.0"
+        uri = if parent_or_url_or_hash.uri.kind_of?(::RDF::URI) && parent_or_url_or_hash.uri.value.empty?
+          nil
+        else
+          "#{parent_or_url_or_hash.uri}/#{dsid}"
+        end
+        @ldp_source = Ldp::Resource::BinarySource.new(ldp_connection, uri, nil, ActiveFedora.fedora.host + ActiveFedora.fedora.base_path)
+
+      else
+        raise "The first argument to #{self} must be a String or an ActiveFedora::Base. You provided a #{parent_or_url.class}"
+      end
+
+      @attributes = {}.with_indifferent_access
+    end
+
+    def ldp_source
+      @ldp_source || raise("NO source")
+    end
+
+    def described_by
+      raise "#{self} isn't persisted yet" if new_record?
+      links['describedby'].first
+    end
+
+    def ldp_connection
+      ActiveFedora.fedora.connection
+    end
+
+    # TODO this is like FedoraAttributes#uri
+    def uri
+      ldp_source.subject
+    end
+
+    def new_record?
+      ldp_source.new?
+    end
+
+    def uri= uri
+      @ldp_source = Ldp::Resource::BinarySource.new(ldp_connection, uri, '', ActiveFedora.fedora.host + ActiveFedora.fedora.base_path)
+    end
+
+    # When restoring from previous versions, we need to reload certain attributes from Fedora
+    def reload
+      return if new_record?
+      reset
+    end
+
+    def reset
+      @ldp_source = Ldp::Resource::BinarySource.new(ldp_connection, uri)
+      @original_name = nil
+      @mime_type = nil
+      @content = nil
+      @metadata = nil
+    end
+
+    def check_fixity
+      FixityService.new(@ldp_source.subject).check
+    end
+
+    def datastream_will_change!
+      attribute_will_change! :profile
+    end
+
+    def attribute_will_change!(attr)
+      if attr == 'content'
+        changed_attributes['content'] = true
+      else
+        super
+      end
+    end
+
+    def remote_content
+      return if new_record?
+      @ds_content ||= retrieve_content
+    end
+
+    attr_writer :mime_type
+    def mime_type
+      @mime_type ||= fetch_mime_type unless new_record?
+      @mime_type || default_mime_type
+    end
+
+    def metadata
+      @metadata ||= ActiveFedora::WithMetadata::MetadataNode.new(self)
+    end
+
+    def original_name
+      @original_name ||= fetch_original_name_from_headers
+    end
+
+    def digest
+      response = metadata.ldp_source.graph.query(:predicate => ::RDF::URI.new("http://fedora.info/definitions/v4/repository#digest"))
+      response.map(&:object)
+    end
+
+    def persisted_size
+      ldp_source.head.headers['Content-Length'].to_i unless new_record?
+    end
+
+    def dirty_size
+      content.size if changed? && content.respond_to?(:size)
+    end
+
+    def size
+      dirty_size || persisted_size
+    end
+
+    def has_content?
+      size && size > 0
+    end
+
+    def empty?
+      !has_content?
+    end
+
+    def content_changed?
+      return true if new_record? and !local_or_remote_content(false).blank?
+      local_or_remote_content(false) != @ds_content
+    end
+
+    def changed?
+      super || content_changed?
+    end
+
+
+    class << self
+      def default_attributes
+        {}
+      end
+    end
+
+    def default_attributes
+      @default_attributes ||= self.class.default_attributes
+    end
+
+    def default_attributes= attributes
+      @default_attributes = default_attributes.merge attributes
+    end
+
+    def original_name= name
+      @original_name = name
+    end
+
+    def inspect
+      "#<#{self.class} uri=\"#{uri}\" >"
+    end
+
+    #compatibility method for rails' url generators. This method will
+    #urlescape escape dots, which are apparently
+    #invalid characters in a dsid.
+    def to_param
+      dsid.gsub(/\./, '%2e')
+    end
+
+    # @abstract Override this in your concrete datastream class.
+    # @return [boolean] does this datastream contain metadata (not file data)
+    def metadata?
+      false
+    end
+
+    # Freeze datastreams such that they can be loaded from Fedora, but can't be changed
+    def freeze
+      @frozen = true
+    end
+
+    def frozen?
+      !!@frozen
+    end
+
+    # serializes any changed data into the content field
+    def serialize!
+    end
+
+    def to_solr(solr_doc={}, opts={})
+      solr_doc
+    end
+
+    protected
+
+    def default_mime_type
+      'text/plain'
+    end
+
+    # The string to prefix all solr fields with. Override this method if you want
+    # a prefix other than the default
+    def prefix(dsid)
+      dsid ? "#{dsid.underscore}__" : ''
+    end
+
+    def fetch_original_name_from_headers
+      return if new_record?
+      m = ldp_source.head.headers['Content-Disposition'].match(/filename="(?<filename>[^"]*)";/)
+      m[:filename]
+    end
+
+    def fetch_mime_type
+      ldp_source.head.headers['Content-Type']
+    end
+
+    private
+
+    def links
+      @links ||= Ldp::Response.links(ldp_source.head)
+    end
+
+
+    # Rack::Test::UploadedFile is often set via content=, however it's not an IO, though it wraps an io object.
+    def behaves_like_io?(obj)
+      [IO, Tempfile, StringIO].any? { |klass| obj.kind_of? klass } || (defined?(Rack) && obj.is_a?(Rack::Test::UploadedFile))
+    end
+
+    # Persistence is an included module, so that we can include other modules which override these methods
+    module Persistence
+      def content= string_or_io
+        content_will_change! unless @content == string_or_io
+        @content = string_or_io
+      end
+
+      def content
+        local_or_remote_content(true)
+      end
+
+      def save(*)
+        return unless content_changed?
+        payload = behaves_like_io?(content) ? content.read : content
+        headers = { 'Content-Type' => mime_type }
+        headers['Content-Disposition'] = "attachment; filename=\"#{@original_name}\"" if @original_name
+        ldp_source.content = payload
+        if new_record?
+          ldp_source.create do |req|
+            req.headers = headers
+          end
+        else
+          ldp_source.update do |req|
+            req.headers = headers
+          end
+        end
+        reset
+        changed_attributes.clear
+      end
+
+      def retrieve_content
+        ldp_source.get.body
+      end
+
+      # @param range [String] the Range HTTP header
+      # @yield [chunk] a block that receives chunked content
+      def stream(range = nil, &block)
+        uri = URI.parse(self.uri)
+
+        headers = {}
+        headers['Range'] = range if range
+        Net::HTTP.start(uri.host, uri.port) do |http|
+          request = Net::HTTP::Get.new uri, headers
+          http.request request do |response|
+            raise "Couldn't get data from Fedora (#{uri}). Response: #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+            response.read_body do |chunk|
+              block.call(chunk)
+            end
+          end
+        end
+      end
+
+      private
+
+      def local_or_remote_content(ensure_fetch = true)
+        return @content if new_record?
+
+        @content ||= ensure_fetch ? remote_content : @ds_content
+
+        if behaves_like_io?(@content)
+          begin
+            @content.rewind
+            @content.read
+          ensure
+            @content.rewind
+          end
+        else
+          @content
+        end
+        @content
+      end
+    end
+
+    include ActiveFedora::File::Persistence
+    include ActiveFedora::Versionable
+  end
+
+end