active-fedora 7.0.4 → 7.1.0

data/lib/active_fedora/rdf/repositories.rb

@@ -1,36 +0,0 @@
-module ActiveFedora::Rdf
-  ##
-  # Defines module methods for registering an RDF::Repository for
-  # persistence of Resources.
-  #
-  # This allows any triplestore (or other storage platform) with an
-  # RDF::Repository implementation to be used for persistence of
-  # resources that will be shared between ActiveFedora::Base objects.
-  #
-  #    ActiveFedora::Rdf::Repositories.add_repository :blah, RDF::Repository.new
-  #
-  # Multiple repositories can be registered to keep different kinds of
-  # resources seperate. This is configurable on subclasses of Resource
-  # at the class level.
-  #
-  # @see Configurable
-  module Repositories
-
-    def add_repository(name, repo)
-      raise "Repositories must be an RDF::Repository" unless repo.kind_of? RDF::Repository
-      repositories[name] = repo
-    end
-    module_function :add_repository
-
-    def clear_repositories!
-      @repositories = {}
-    end
-    module_function :clear_repositories!
-
-    def repositories
-      @repositories ||= {}
-    end
-    module_function :repositories
-
-  end
-end

data/lib/active_fedora/rdf/resource.rb

@@ -1,328 +0,0 @@
-module ActiveFedora::Rdf
-  ##
-  # Defines a generic RDF `Resource` as an RDF::Graph with property
-  # configuration, accessors, and some other methods for managing
-  # resources as discrete subgraphs which can be maintained by a Hydra
-  # datastream model.
-  #
-  # Resources can be instances of ActiveFedora::Rdf::Resource
-  # directly, but more often they will be instances of subclasses with
-  # registered properties and configuration. e.g.
-  #
-  #    class License < Resource
-  #      configure repository: :default
-  #      property :title, predicate: RDF::DC.title, class_name: RDF::Literal do |index|
-  #        index.as :displayable, :facetable
-  #      end
-  #    end
-  class Resource < RDF::Graph
-    @@type_registry
-    extend Configurable
-    extend Properties
-    extend Deprecation
-    include ActiveFedora::Rdf::NestedAttributes
-    attr_accessor :parent
-
-    class << self
-      def type_registry
-        @@type_registry ||= {}
-      end
-
-      ##
-      # Adapter for a consistent interface for creating a new node from a URI.
-      # Similar functionality should exist in all objects which can become a node.
-      def from_uri(uri,vals=nil)
-        new(uri, vals)
-      end
-    end
-
-    def writable?
-      !frozen?
-    end
-
-    ##
-    # Initialize an instance of this resource class. Defaults to a
-    # blank node subject. In addition to RDF::Graph parameters, you
-    # can pass in a URI and/or a parent to build a resource from a
-    # existing data.
-    #
-    # You can pass in only a parent with:
-    #    Resource.new(nil, parent)
-    #
-    # @see RDF::Graph
-    def initialize(*args, &block)
-      resource_uri = args.shift unless args.first.is_a?(Hash)
-      self.parent = args.shift unless args.first.is_a?(Hash)
-      set_subject!(resource_uri) if resource_uri
-      super(*args, &block)
-      reload
-      # Append type to graph if necessary.
-      self.get_values(:type) << self.class.type if self.class.type.kind_of?(RDF::URI) && type.empty?
-    end
-
-    def graph
-      Deprecation.warn Resource, "graph is redundant & deprecated. It will be removed in active-fedora 8.0.0.", caller
-      self
-    end
-
-    def final_parent
-      @final_parent ||= begin
-        parent = self.parent
-        while parent && parent.parent && parent.parent != parent
-          parent = parent.parent
-        end
-        parent
-      end
-    end
-
-    def attributes=(values)
-      raise ArgumentError, "values must be a Hash, you provided #{values.class}" unless values.kind_of? Hash
-      values = values.with_indifferent_access
-      set_subject!(values.delete(:id)) if values.has_key?(:id) and node?
-      values.each do |key, value|
-        if properties.keys.include?(key)
-          set_value(rdf_subject, key, value)
-        elsif self.singleton_class.nested_attributes_options.keys.map{ |k| "#{k}_attributes"}.include?(key)
-          send("#{key}=".to_sym, value)
-        else
-          raise ArgumentError, "No association found for name `#{key}'. Has it been defined yet?"
-        end
-      end
-    end
-
-    def rdf_subject
-      @rdf_subject ||= RDF::Node.new
-    end
-
-    def node?
-      return true if rdf_subject.kind_of? RDF::Node
-      false
-    end
-
-    def to_term
-      rdf_subject
-    end
-
-    def base_uri
-      self.class.base_uri
-    end
-
-    def type
-      self.get_values(:type).to_a.map{|x| x.rdf_subject}
-    end
-
-    def type=(type)
-      raise "Type must be an RDF::URI" unless type.kind_of? RDF::URI
-      self.update(RDF::Statement.new(rdf_subject, RDF.type, type))
-    end
-
-    ##
-    # Look for labels in various default fields, prioritizing
-    # configured label fields
-    def rdf_label
-      labels = Array(self.class.rdf_label)
-      labels += default_labels
-      labels.each do |label|
-        values = get_values(label)
-        return values unless values.empty?
-      end
-      node? ? [] : [rdf_subject.to_s]
-    end
-
-    def fields
-      properties.keys.map(&:to_sym).reject{|x| x == :type}
-    end
-
-    ##
-    # Load data from URI
-    def fetch
-      load(rdf_subject)
-      self
-    end
-
-    def persist!
-      raise "failed when trying to persist to non-existant repository or parent resource" unless repository
-      repository.delete [rdf_subject,nil,nil] unless node?
-      if node?
-        repository.statements.each do |statement|
-          repository.send(:delete_statement, statement) if statement.subject == rdf_subject
-        end
-      end
-      repository << self
-      @persisted = true
-    end
-
-    def persisted?
-      @persisted ||= false
-      return (@persisted and parent.persisted?) if parent
-      @persisted
-    end
-
-    ##
-    # Repopulates the graph from the repository or parent resource.
-    def reload
-      @term_cache ||= {}
-      if self.class.repository == :parent
-        return false if final_parent.nil?
-      end
-      self << repository.query(subject: rdf_subject)
-      unless empty?
-        @persisted = true
-      end
-      true
-    end
-
-    ##
-    # Adds or updates a property with supplied values.
-    #
-    # Handles two argument patterns. The recommended pattern is:
-    #    set_value(property, values)
-    #
-    # For backwards compatibility, there is support for explicitly
-    # passing the rdf_subject to be used in the statement:
-    #    set_value(uri, property, values)
-    #
-    # @note This method will delete existing statements with the correct subject and predicate from the graph
-    def set_value(*args)
-      # Add support for legacy 3-parameter syntax
-      if args.length > 3 || args.length < 2
-        raise ArgumentError("wrong number of arguments (#{args.length} for 2-3)")
-      end
-      values = args.pop
-      get_term(args).set(values)
-    end
-
-    ##
-    # Returns an array of values belonging to the property
-    # requested. Elements in the array may RdfResource objects or a
-    # valid datatype.
-    #
-    # Handles two argument patterns. The recommended pattern is:
-    #    get_values(property)
-    #
-    # For backwards compatibility, there is support for explicitly
-    # passing the rdf_subject to be used in th statement:
-    #    get_values(uri, property)
-    def get_values(*args)
-      get_term(args)
-    end
-
-    def get_term(args)
-      @term_cache ||= {}
-      term = ActiveFedora::Rdf::Term.new(self, args)
-      @term_cache["#{term.rdf_subject}/#{term.property}"] ||= term
-      @term_cache["#{term.rdf_subject}/#{term.property}"]
-    end
-
-    ##
-    # Set a new rdf_subject for the resource.
-    #
-    # This raises an error if the current subject is not a blank node,
-    # and returns false if it can't figure out how to make a URI from
-    # the param. Otherwise it creates a URI for the resource and
-    # rebuilds the graph with the updated URI.
-    #
-    # Will try to build a uri as an extension of the class's base_uri
-    # if appropriate.
-    #
-    # @param [#to_uri, #to_s] uri_or_str the uri or string to use
-    def set_subject!(uri_or_str)
-      raise "Refusing update URI when one is already assigned!" unless node?
-      # Refusing set uri to an empty string.
-      return false if uri_or_str.nil? or uri_or_str.to_s.empty?
-      # raise "Refusing update URI! This object is persisted to a datastream." if persisted?
-      old_subject = rdf_subject
-      @rdf_subject = get_uri(uri_or_str)
-
-      each_statement do |statement|
-        if statement.subject == old_subject
-          delete(statement)
-          self << RDF::Statement.new(rdf_subject, statement.predicate, statement.object)
-        elsif statement.object == old_subject
-          delete(statement)
-          self << RDF::Statement.new(statement.subject, statement.predicate, rdf_subject)
-        end
-      end
-    end
-
-    def destroy
-      clear
-      persist!
-      parent.destroy_child(self)
-    end
-
-    def destroy_child(child)
-      statements.each do |statement|
-        delete_statement(statement) if statement.subject == child.rdf_subject || statement.object == child.rdf_subject
-      end
-    end
-
-    def new_record?
-      not persisted?
-    end
-
-    ##
-    # @return [String] the string to index in solr
-    def solrize
-      node? ? rdf_label : rdf_subject.to_s
-    end
-
-    def mark_for_destruction
-      @marked_for_destruction = true
-    end
-
-    def marked_for_destruction?
-      @marked_for_destruction
-    end
-
-    private
-
-    def properties
-      self.singleton_class.properties
-    end
-
-    def property_for_predicate(predicate)
-      properties.each do |property, values|
-        return property if values[:predicate] == predicate
-      end
-      return nil
-    end
-
-    def default_labels
-      [RDF::SKOS.prefLabel,
-       RDF::DC.title,
-       RDF::RDFS.label,
-       RDF::SKOS.altLabel,
-       RDF::SKOS.hiddenLabel]
-    end
-
-    ##
-    # Return the repository (or parent) that this resource should
-    # write to when persisting.
-    def repository
-      @repository ||= 
-        if self.class.repository == :parent
-          final_parent
-        else
-          ActiveFedora::Rdf::Repositories.repositories[self.class.repository]
-        end
-    end
-
-    private
-
-      ##
-      # Takes a URI or String and aggressively tries to create a valid RDF URI.
-      # Combines the input with base_uri if appropriate.
-      #
-      # @TODO: URI.scheme_list is naive and incomplete. Find a better way to check for an existing scheme.
-      def get_uri(uri_or_str)
-        return uri_or_str.to_uri if uri_or_str.respond_to? :to_uri
-        return uri_or_str if uri_or_str.kind_of? RDF::Node
-        uri_or_str = uri_or_str.to_s
-        return RDF::Node(uri_or_str[2..-1]) if uri_or_str.start_with? '_:'
-        return RDF::URI(uri_or_str) if RDF::URI(uri_or_str).valid? and (URI.scheme_list.include?(RDF::URI.new(uri_or_str).scheme.upcase) or RDF::URI.new(uri_or_str).scheme == 'info')
-        return RDF::URI(self.base_uri.to_s + (self.base_uri.to_s[-1,1] =~ /(\/|#)/ ? '' : '/') + uri_or_str) if base_uri && !uri_or_str.start_with?(base_uri.to_s)
-        raise RuntimeError, "could not make a valid RDF::URI from #{uri_or_str}"
-      end
-  end
-end

data/lib/active_fedora/rdf/term.rb

@@ -1,188 +0,0 @@
-module ActiveFedora::Rdf
-  class Term
-    attr_accessor :parent, :value_arguments, :node_cache
-    delegate *(Array.public_instance_methods - [:__send__, :__id__, :class, :object_id] + [:as_json]), :to => :result
-    def initialize(parent, value_arguments)
-      self.parent = parent
-      self.value_arguments = value_arguments
-    end
-
-    def clear
-      set(nil)
-    end
-
-    def result
-      result = parent.query(:subject => rdf_subject, :predicate => predicate)
-      .map{|x| convert_object(x.object)}
-      .reject(&:nil?)
-      return result if !property_config || property_config[:multivalue]
-      result.first
-    end
-
-    def set(values)
-      values = [values].compact unless values.kind_of?(Array)
-      empty_property
-      values.each do |val|
-        set_value(val)
-      end
-      parent.persist! if parent.class.repository == :parent && parent.send(:repository)
-    end
-
-    def empty_property
-      parent.query([rdf_subject, predicate, nil]).each_statement do |statement|
-        if !uri_class(statement.object) || uri_class(statement.object) == class_for_property
-          parent.delete(statement)
-        end
-      end
-    end
-
-    def build(attributes={})
-      new_subject = attributes.key?('id') ? attributes.delete('id') : RDF::Node.new
-      node = make_node(new_subject)
-      node.attributes = attributes
-      if parent.kind_of? List::ListResource
-        parent.list << node
-        return node
-      elsif node.kind_of? RDF::List
-        self.push node.rdf_subject
-        return node
-      end
-      self.push node
-      node
-    end
-
-    def first_or_create(attributes={})
-      result.first || build(attributes)
-    end
-
-    def delete(*values)
-      values.each do |value|
-        parent.delete([rdf_subject, predicate, value])
-      end
-    end
-
-    def << (values)
-      values = Array.wrap(result) | Array.wrap(values)
-      self.set(values)
-    end
-
-    alias_method :push, :<<
-
-    def property_config
-      return type_property if (property == RDF.type || property.to_s == "type") && !parent.send(:properties)[property]
-      parent.send(:properties)[property]
-    end
-
-    def type_property
-      {:multivalue => true, :predicate => RDF.type}
-    end
-
-    def reset!
-    end
-
-    def property
-      value_arguments.last
-    end
-
-    def rdf_subject
-      raise ArgumentError("wrong number of arguments (#{value_arguments.length} for 1-2)") if value_arguments.length < 1 || value_arguments.length > 2
-      if value_arguments.length > 1
-        value_arguments.first
-      else
-        parent.rdf_subject
-      end
-    end
-
-    protected
-
-      def node_cache
-        @node_cache ||= {}
-      end
-
-      def set_value(val)
-        object = val
-        val = val.resource if val.respond_to?(:resource)
-        val = value_to_node(val)
-        if val.kind_of? Resource
-          node_cache[val.rdf_subject] = nil
-          add_child_node(val, object)
-          return
-        end
-        val = val.to_uri if val.respond_to? :to_uri
-        raise 'value must be an RDF URI, Node, Literal, or a valid datatype. See RDF::Literal' unless
-          val.kind_of? RDF::Value or val.kind_of? RDF::Literal
-        parent.insert [rdf_subject, predicate, val]
-      end
-
-      def value_to_node(val)
-        valid_datatype?(val) ? RDF::Literal(val) : val
-      end
-
-      def add_child_node(resource,object=nil)
-        parent.insert [rdf_subject, predicate, resource.rdf_subject]
-        resource.parent = parent unless resource.frozen?
-        self.node_cache[resource.rdf_subject] = (object ? object : resource)
-        resource.persist! if resource.class.repository == :parent
-      end
-
-      def predicate
-        return property_config[:predicate] unless property.kind_of? RDF::URI
-        property
-      end
-
-      def valid_datatype?(val)
-        val.is_a? String or val.is_a? Date or val.is_a? Time or val.is_a? Numeric or val.is_a? Symbol or val == !!val
-      end
-
-      # Converts an object to the appropriate class.
-      def convert_object(value)
-        value = value.object if value.kind_of? RDF::Literal
-        value = make_node(value) if value.kind_of? RDF::Resource
-        value
-      end
-
-      ##
-      # Build a child resource or return it from this object's cache
-      #
-      # Builds the resource from the class_name specified for the
-      # property.
-      def make_node(value)
-        klass = class_for_value(value)
-        value = RDF::Node.new if value.nil?
-        node = node_cache[value] if node_cache[value]
-        node ||= klass.from_uri(value,parent)
-        return nil if property_config[:class_name] && class_for_value(value) != class_for_property
-        self.node_cache[value] ||= node
-        node
-      end
-
-      def final_parent
-        @final_parent ||= begin
-          parent = self.parent
-          while parent != parent.parent && parent.parent
-            parent = parent.parent
-          end
-          return parent.datastream if parent.respond_to?(:datastream) && parent.datastream
-          parent
-        end
-      end
-
-      def class_for_value(v)
-        uri_class(v) || class_for_property
-      end
-
-      def uri_class(v)
-        v = RDF::URI.new(v) if v.kind_of? String
-        type_uri = parent.query([v, RDF.type, nil]).to_a.first.try(:object)
-        ActiveFedora::Rdf::Resource.type_registry[type_uri]
-      end
-
-      def class_for_property
-        klass = property_config[:class_name]
-        klass ||= ActiveFedora::Rdf::Resource
-        klass = ActiveFedora.class_from_string(klass, final_parent.class) if klass.kind_of? String
-        klass
-      end
-
-  end
-end