active-fedora 7.0.0.rc2 → 7.0.0.rc3

data/lib/active_fedora/rdf/indexing.rb

@@ -16,10 +16,14 @@ module ActiveFedora
 
       def to_solr(solr_doc = Hash.new) # :nodoc:
         fields.each do |field_key, field_info|
-          values = get_values(rdf_subject, field_key)
-          Array(values).each do |val|    
-            val = val.to_s if val.kind_of? RDF::URI
-            Solrizer.insert_field(solr_doc, apply_prefix(field_key), val, *field_info[:behaviors])
+          values = resource.get_values(field_key)
+          Array(values).each do |val|
+            if val.kind_of? RDF::URI
+              val = val.to_s 
+            elsif val.kind_of? Rdf::Resource
+              val = val.solrize
+            end
+            self.class.create_and_insert_terms(apply_prefix(field_key), val, field_info[:behaviors], solr_doc)
           end
         end
         solr_doc
@@ -28,12 +32,16 @@ module ActiveFedora
       # 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(field)
         config = self.class.config_for_term_or_uri(field)
+        return nil unless config # punt on index names for deep nodes!
         if behaviors = config.behaviors
-          ActiveFedora::SolrService.solr_name(apply_prefix(field), behaviors.first, type: config.type)
+          behaviors.each do |behavior|
+            result = ActiveFedora::SolrService.solr_name(apply_prefix(field), behavior, type: config.type)
+            return result if Solrizer::DefaultDescriptors.send(behavior).evaluate_suffix(:text).stored?
+          end
+          raise RuntimeError "no stored fields were found"
         end
       end
 
-
       module ClassMethods
         def prefix(dsid, name)
           Deprecation.warn Indexing, "prefix is deprecated and will be removed in active-fedora 8.0.0.", caller
@@ -45,28 +53,21 @@ module ActiveFedora
           config_for_term_or_uri(field).type
         end
       end
-
+      
       private
         # returns a Hash, e.g.: {field => {:values => [], :type => :something, :behaviors => []}, ...}
         def fields
           field_map = {}.with_indifferent_access
 
-          rdf_subject = self.rdf_subject
-          query = RDF::Query.new do
-            pattern [rdf_subject, :predicate, :value]
-          end
-
-          query.execute(graph).each do |solution|
-            predicate = solution.predicate
-            value = solution.value
-            
-            name, config = self.class.config_for_predicate(predicate)
-            next unless config
-            type = config.type
-            behaviors = config.behaviors
-            next unless type and behaviors 
-            field_map[name] ||= {:values => [], :type => type, :behaviors => behaviors}
-            field_map[name][:values] << value.to_s
+          self.class.properties.each do |name, config|
+            type = config[:type]
+            behaviors = config[:behaviors]
+            next unless type and behaviors
+            next if config[:class_name] && config[:class_name] < ActiveFedora::Base
+            resource.query(:subject => rdf_subject, :predicate => config[:predicate]).each_statement do |statement|
+              field_map[name] ||= {:values => [], :type => type, :behaviors => behaviors}
+              field_map[name][:values] << statement.object.to_s
+            end
           end
           field_map
         end

data/lib/active_fedora/rdf/list.rb

@@ -0,0 +1,154 @@
+module ActiveFedora::Rdf
+  ##
+  # An implementation of RDF::List intregrated with ActiveFedora::Rdf.
+  #
+  # A thoughtful reflection period is encouraged before using the
+  # rdf:List concept in your data. The community may pursue other
+  # options for ordered sets.
+  class List < RDF::List
+    include ActiveFedora::Rdf::NestedAttributes
+    extend Configurable
+    extend Properties
+
+    delegate :rdf_subject, :mark_for_destruction, :marked_for_destruction?, :set_value, :get_values, :parent, :dump, :attributes=, to: :resource
+    alias_method :to_ary, :to_a
+
+    class << self
+      def from_uri(uri, vals)
+        list = ListResource.from_uri(uri, vals)
+        self.new(list.rdf_subject, list)
+      end
+    end
+
+    def resource
+      graph
+    end
+
+    def initialize(*args)
+      super
+      parent = graph.parent if graph.respond_to? :parent
+      @graph = ListResource.new(subject) << graph unless graph.kind_of? Resource
+      graph << parent if parent
+      graph.list = self
+      graph.singleton_class.properties = self.class.properties
+      graph.singleton_class.properties.keys.each do |property|
+        graph.singleton_class.send(:register_property, property)
+      end
+      graph.insert RDF::Statement.new(subject, RDF.type, RDF.List)
+      graph.reload
+    end
+
+    def []=(idx, value)
+      raise IndexError "index #{idx} too small for array: minimum 0" if idx < 0
+
+      if idx >= length
+        (idx - length).times do
+          self << RDF::OWL.Nothing
+        end
+        return self << value
+      end
+      each_subject.with_index do |v, i|
+        next unless i == idx
+        resource.set_value(v, RDF.first, value)
+      end
+    end
+
+    ##
+    # Override to return AF::Rdf::Resources as values, where
+    # appropriate.
+    def each(&block)
+      return super unless block_given?
+
+      super do |value|
+        block.call(node_from_value(value))
+      end
+    end
+
+    ##
+    # Do these like #each.
+    def first
+      node_from_value(super)
+    end
+
+    def shift
+      node_from_value(super)
+    end
+
+    ##
+    # Find an AF::Rdf::Resource from the value returned by RDF::List
+    def node_from_value(value)
+      if value.kind_of? RDF::Resource
+        type_uri = resource.query([value, RDF.type, nil]).to_a.first.try(:object)
+        klass = ActiveFedora::Rdf::Resource.type_registry[type_uri]
+        klass ||= Resource
+        return klass.from_uri(value,resource)
+      end
+      value
+    end
+
+    ##
+    # This class is the graph/Resource that backs the List and
+    # supplies integration with the rest of ActiveFedora::Rdf
+    class ListResource < Resource
+      attr_reader :list
+
+      def list=(list)
+        @list ||= list
+      end
+
+      def attributes=(values)
+        raise ArgumentError, "values must be a Hash, you provided #{values.class}" unless values.kind_of? Hash
+        values.with_indifferent_access.each do |key, value|
+          if self.singleton_class.properties.keys.map{ |k| "#{k}_attributes"}.include?(key)
+            klass = properties[key[0..-12]]['class_name']
+            klass = ActiveFedora.class_from_string(klass, final_parent.class) if klass.is_a? String
+            value.is_a?(Hash) ? attributes_hash_to_list(values[key], klass) : attributes_to_list(value, klass)
+          end
+        end
+        persist!
+        super
+      end
+
+      private
+        def attributes_to_list(value, klass)
+          value.each do |entry|
+            item = klass.new()
+            item.attributes = entry
+            list << item
+          end
+        end
+
+        def attributes_hash_to_list(value, klass)
+          value.each do |counter, attr|
+            item = klass.new()
+            item.attributes = attr if attr
+            list[counter.to_i] = item
+          end
+        end
+    end
+
+    ##
+    # Monkey patch to allow lists to have subject URIs.
+    # Overrides RDF::List to prevent URI subjects
+    # from being replaced with nodes.
+    #
+    # @NOTE Lists built this way will return false for #valid?
+    def <<(value)
+      value = case value
+        when nil         then RDF.nil
+        when RDF::Value  then value
+        when Array       then RDF::List.new(nil, graph, value)
+        else value
+      end
+
+      if empty?
+        resource.set_value(RDF.first, value)
+        resource.insert([subject, RDF.rest, RDF.nil])
+        resource << value if value.kind_of? Resource
+        return self
+      end
+      super
+      resource << value if value.kind_of? Resource
+    end
+  end
+end

data/lib/active_fedora/rdf/object_resource.rb

@@ -0,0 +1,20 @@
+module ActiveFedora::Rdf
+  ##
+  # A class of RdfResources to act as the primary/root resource associated
+  # with a Datastream and ActiveFedora::Base object.
+  #
+  # @see ActiveFedora::RDFDatastream
+  class ObjectResource < Resource
+    configure :base_uri => 'info:fedora/'
+    attr_accessor :datastream
+
+    def persist!
+      return false unless datastream and datastream.respond_to? :digital_object
+      @persisted ||= datastream.digital_object.save
+    end
+
+    def persisted?
+      @persisted ||= (not datastream.new?)
+    end
+  end
+end

data/lib/active_fedora/rdf/properties.rb

@@ -0,0 +1,108 @@
+module ActiveFedora::Rdf
+  ##
+  # Implements property configuration common to Rdf::Resource,
+  # RDFDatastream, and others.  It does its work at the class level,
+  # and is meant to be extended.
+  #
+  # Define properties at the class level with:
+  #
+  #    property :title, predicate: RDF::DC.title, class_name: ResourceClass
+  #
+  # or with the 'old' style:
+  #
+  #    map_predicates do |map|
+  #      map.title(in: RDF::DC)
+  #    end
+  #
+  # You can pass a block to either to set index behavior.
+  module Properties
+    extend Deprecation
+    attr_accessor :properties
+
+    ##
+    # Registers properties for Resource-like classes
+    # @param [Symbol]  name of the property (and its accessor methods)
+    # @param [Hash]  opts for this property, must include a :predicate
+    # @yield [index] index sets solr behaviors for the property
+    def property(name, opts={}, &block)
+      config[name] = ActiveFedora::Rdf::NodeConfig.new(name, opts[:predicate], opts.except(:predicate)).tap do |config|
+        config.with_index(&block) if block_given?
+      end
+      behaviors = config[name].behaviors.flatten if config[name].behaviors and not config[name].behaviors.empty?
+
+      self.properties[name] = {
+        behaviors: behaviors,
+        type: config[name].type,
+        class_name: config[name].class_name,
+        predicate: config[name].predicate,
+        term: config[name].term,
+        multivalue: config[name].multivalue
+      }
+      register_property(name)
+    end
+
+    def properties
+      @properties ||= if superclass.respond_to? :properties
+        superclass.properties.dup
+      else
+        {}.with_indifferent_access
+      end
+    end
+
+    def config
+      @config ||= if superclass.respond_to? :config
+        superclass.properties.dup
+      else
+        {}.with_indifferent_access
+      end
+    end
+
+    def config_for_term_or_uri(term)
+      return config[term.to_sym] unless term.kind_of? RDF::Resource
+      config.each { |k, v| return v if v.predicate == term.to_uri }
+    end
+
+    def fields
+      properties.keys.map(&:to_sym)
+    end
+
+    private
+
+    ##
+    # Private method for creating accessors for a given property.
+    # If used on an ActiveFedora::Datastream it will create accessors which use the datastream's resource.
+    # @param [#to_s] name Name of the accessor to be created, get/set_value is called on the resource using this.
+    def register_property(name)
+      parent = Proc.new{self}
+      parent = Proc.new{resource} if self < ActiveFedora::Datastream
+      define_method "#{name}=" do |*args|
+        instance_eval(&parent).set_value(name.to_sym, *args)
+      end
+      define_method name do
+        instance_eval(&parent).get_values(name.to_sym)
+      end
+    end
+
+    public
+    # Mapper is for backwards compatibility with AF::RDFDatastream
+    class Mapper
+      attr_accessor :parent
+      def initialize(parent)
+        @parent = parent
+      end
+      def method_missing(name, *args, &block)
+        properties = args.first || {}
+        vocab = properties.delete(:in)
+        to = properties.delete(:to) || name
+        predicate = vocab.send(to)
+        parent.property(name, properties.merge(predicate: predicate), &block)
+      end
+    end
+    def map_predicates
+      Deprecation.warn Properties, "map_predicates is deprecated and will be removed in active-fedora 8.0.0. Use property :name, predicate: predicate instead.", caller
+      mapper = Mapper.new(self)
+      yield(mapper)
+    end
+
+  end
+end

data/lib/active_fedora/rdf/rdf_datastream.rb

@@ -0,0 +1,113 @@
+module ActiveFedora
+  class RDFDatastream < ActiveFedora::Datastream
+    include Solrizer::Common
+    include ActiveFedora::Rdf::NestedAttributes
+    include Rdf::Indexing
+    extend Rdf::Properties
+
+    delegate :rdf_subject, :set_value, :get_values, :attributes=, :to => :resource
+
+    class << self
+      def rdf_subject &block
+        if block_given?
+          return @subject_block = block
+        end
+
+        @subject_block ||= lambda { |ds| ds.pid }
+      end
+
+      # Utility method which can be overridden to determine the object
+      # resource that is created.
+      def resource_class
+        Rdf::ObjectResource
+      end
+    end
+
+    before_save do
+      if content.blank?
+        logger.warn "Cowardly refusing to save a datastream with empty content: #{self.inspect}"
+        false
+      end
+    end
+
+    def metadata?
+      true
+    end
+    
+    def content
+      serialize
+    end
+
+    def content=(content)
+      resource.clear!
+      resource << RDF::Reader.for(serialization_format).new(content)
+      content
+    end
+
+    def content_changed?
+      return false unless instance_variable_defined? :@resource
+      @content = serialize
+      super
+    end
+
+    def freeze
+      @resource.freeze
+    end
+
+    ##
+    # 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 ||= begin
+                      r = self.class.resource_class.new(digital_object ? self.class.rdf_subject.call(self) : nil)
+                      r.singleton_class.properties = self.class.properties
+                      r.singleton_class.properties.keys.each do |property|
+                        r.singleton_class.send(:register_property, property)
+                      end
+                      r.datastream = self
+                      r.singleton_class.accepts_nested_attributes_for(*nested_attributes_options.keys) unless nested_attributes_options.blank?
+                      r << RDF::Reader.for(serialization_format).new(datastream_content) if datastream_content
+                      r
+                    end
+    end
+
+    alias_method :graph, :resource
+
+    ##
+    # This method allows for delegation.
+    # This patches the fact that there's no consistent API for allowing delegation - we're matching the
+    # OMDatastream implementation as our "consistency" point.
+    # @TODO: We may need to enable deep RDF delegation at one point.
+    def term_values(*values)
+      self.send(values.first)
+    end
+
+    def update_indexed_attributes(hash)
+      hash.each do |fields, value|
+        fields.each do |field|
+          self.send("#{field}=", value)
+        end
+      end
+    end
+
+    def serialize
+      resource.set_subject!(pid) if (digital_object or pid) and rdf_subject.node?
+      resource.dump serialization_format
+    end
+
+    def deserialize(data=nil)
+      return RDF::Graph.new if new? && data.nil?
+      data ||= datastream_content
+      data.force_encoding('utf-8')
+      RDF::Graph.new << RDF::Reader.for(serialization_format).new(data)
+    end
+
+    def serialization_format
+      raise "you must override the `serialization_format' method in a subclass"
+    end
+
+  end
+end