active-fedora 7.0.4 → 7.1.0

data/lib/active_fedora/rdf/configurable.rb

@@ -1,59 +0,0 @@
-module ActiveFedora::Rdf
-  ##
-  # Module to include configurable class-wide properties common to
-  # Resource and RDFDatastream. It does its work at the class level,
-  # and is meant to be extended.
-  #
-  # Define properties at the class level with:
-  #
-  #    configure base_uri: "http://oregondigital.org/resource/", repository: :parent
-  # Available properties are base_uri, rdf_label, type, and repository
-  module Configurable
-    extend Deprecation
-
-    def base_uri
-      nil
-    end
-
-    def rdf_label
-      nil
-    end
-
-    def type
-      nil
-    end
-
-    def rdf_type(value)
-      Deprecation.warn Configurable, "rdf_type is deprecated and will be removed in active-fedora 8.0.0. Use configure type: instead.", caller
-      configure type: value
-    end
-
-    def repository
-      :parent
-    end
-
-    # API method for configuring class properties an RDF Resource may need.
-    # This is an alternative to overriding the methods extended with this module.
-    def configure(options = {})
-      {
-        base_uri: options[:base_uri],
-        rdf_label: options[:rdf_label],
-        type: options[:type],
-        repository: options[:repository]
-      }.each do |name, value|
-        if value
-          value = self.send("transform_#{name}", value) if self.respond_to?("transform_#{name}")
-          define_singleton_method(name) do
-            value
-          end
-        end
-      end
-    end
-
-    def transform_type(value)
-      RDF::URI.new(value).tap do |value|
-        Resource.type_registry[value] = self
-      end
-    end
-  end
-end

data/lib/active_fedora/rdf/list.rb

@@ -1,155 +0,0 @@
-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)
-            values.delete key
-          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/nested_attributes.rb

@@ -1,130 +0,0 @@
-module ActiveFedora
-  module Rdf
-    module NestedAttributes
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :nested_attributes_options, :instance_writer => false
-        self.nested_attributes_options = {}
-      end
-
-      private
-
-      UNASSIGNABLE_KEYS = %w(_destroy )
-
-      # @param [Symbol] association_name
-      # @param [Hash, Array] attributes_collection
-      # @example
-      #
-      #   assign_nested_attributes_for_collection_association(:people, {
-      #     '1' => { id: '1', name: 'Peter' },
-      #     '2' => { name: 'John' },
-      #     '3' => { id: '2', _destroy: true }
-      #   })
-      #
-      # Will update the name of the Person with ID 1, build a new associated
-      # person with the name 'John', and mark the associated Person with ID 2
-      # for destruction.
-      #
-      # Also accepts an Array of attribute hashes:
-      #
-      #   assign_nested_attributes_for_collection_association(:people, [
-      #     { id: '1', name: 'Peter' },
-      #     { name: 'John' },
-      #     { id: '2', _destroy: true }
-      #   ])
-      def assign_nested_attributes_for_collection_association(association_name, attributes_collection)
-        options = self.nested_attributes_options[association_name]
-
-        # TODO
-        #check_record_limit!(options[:limit], attributes_collection)
-
-        if attributes_collection.is_a?(Hash)
-          attributes_collection = attributes_collection.values
-        end
-
-        association = self.send(association_name)
-
-        attributes_collection.each do |attributes|
-          attributes = attributes.with_indifferent_access
-          
-          if attributes['id'] && existing_record = association.detect { |record| record.rdf_subject.to_s == attributes['id'].to_s }
-            if !call_reject_if(association_name, attributes)
-              assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
-            end
-          else
-            attributes = attributes.with_indifferent_access
-            association.build(attributes.except(*UNASSIGNABLE_KEYS))
-          end
-        end
-      end
-
-      # Updates a record with the +attributes+ or marks it for destruction if
-      # +allow_destroy+ is +true+ and has_destroy_flag? returns +true+.
-      def assign_to_or_mark_for_destruction(record, attributes, allow_destroy)
-        record.attributes = attributes.except(*UNASSIGNABLE_KEYS)
-        record.mark_for_destruction if has_destroy_flag?(attributes) && allow_destroy
-      end
-
-      def call_reject_if(association_name, attributes)
-        return false if has_destroy_flag?(attributes)
-        case callback = self.nested_attributes_options[association_name][:reject_if]
-        when Symbol
-          method(callback).arity == 0 ? send(callback) : send(callback, attributes)
-        when Proc
-          callback.call(attributes)
-        end
-      end
-
-      # Determines if a hash contains a truthy _destroy key.
-      def has_destroy_flag?(hash)
-        ["1", "true"].include?(hash['_destroy'].to_s)
-      end
-      
-
-      module ClassMethods
-        def accepts_nested_attributes_for *attr_names
-          options = { :allow_destroy => false, :update_only => false }
-          options.update(attr_names.extract_options!)
-          options.assert_valid_keys(:allow_destroy, :reject_if, :limit, :update_only)
-          options[:reject_if] = REJECT_ALL_BLANK_PROC if options[:reject_if] == :all_blank
-
-          attr_names.each do |association_name|
-            nested_attributes_options = self.nested_attributes_options.dup
-            nested_attributes_options[association_name] = options
-            self.nested_attributes_options = nested_attributes_options
-
-            generate_association_writer(association_name)
-          end
-        end
-
-        private
-
-        # Generates a writer method for this association. Serves as a point for
-        # accessing the objects in the association. For example, this method
-        # could generate the following:
-        #
-        #   def pirate_attributes=(attributes)
-        #     assign_nested_attributes_for_collection_association(:pirate, attributes)
-        #   end
-        #
-        # This redirects the attempts to write objects in an association through
-        # the helper methods defined below. Makes it seem like the nested
-        # associations are just regular associations.
-        def generate_association_writer(association_name)
-          class_eval <<-eoruby, __FILE__, __LINE__ + 1
-            if method_defined?(:#{association_name}_attributes=)
-              remove_method(:#{association_name}_attributes=)
-            end
-            def #{association_name}_attributes=(attributes)
-              assign_nested_attributes_for_collection_association(:#{association_name}, attributes)
-              ## in lieu of autosave_association_callbacks just save all of em.
-              send(:#{association_name}).each {|obj| obj.marked_for_destruction? ? obj.destroy : nil}
-              send(:#{association_name}).reset!
-            end
-          eoruby
-        end
-      end
-    end
-  end
-end

data/lib/active_fedora/rdf/node_config.rb

@@ -1,57 +0,0 @@
-module ActiveFedora
-  module Rdf
-    class NodeConfig
-      attr_accessor :predicate, :term, :class_name, :type, :behaviors, :multivalue
-
-      def initialize(term, predicate, args={})
-        self.term = term
-        self.predicate = predicate
-        self.class_name = args.delete(:class_name)
-        self.multivalue = args.delete(:multivalue) { true } 
-        raise ArgumentError, "Invalid arguments for Rdf Node configuration: #{args} on #{predicate}" unless args.empty?
-      end
-
-      def [](value)
-        value = value.to_sym
-        self.respond_to?(value) ? self.send(value) : nil
-      end
-
-      def class_name
-        if @class_name.kind_of?(String)
-          begin
-            new_class = @class_name.constantize
-            @class_name = new_class
-          rescue NameError
-          end
-        end
-        @class_name
-      end
-
-      def with_index (&block)
-        # needed for solrizer integration
-        iobj = IndexObject.new
-        yield iobj
-        self.type = iobj.data_type
-        self.behaviors = iobj.behaviors
-      end
-
-      # this enables a cleaner API for solr integration
-      class IndexObject
-        attr_accessor :data_type, :behaviors
-        def initialize
-          @behaviors = []
-          @data_type = :string
-        end
-        def as(*args)
-          @behaviors = args
-        end
-        def type(sym)
-          @data_type = sym
-        end
-        def defaults
-          :noop
-        end
-      end
-    end
-  end
-end

data/lib/active_fedora/rdf/properties.rb

@@ -1,94 +0,0 @@
-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 :config
-
-    ##
-    # 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)
-      self.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?
-      register_property(name)
-    end
-
-    def config
-      @config ||= if superclass.respond_to? :config
-        superclass.config.dup
-      else
-        {}.with_indifferent_access
-      end
-    end
-
-    alias_method :properties, :config
-    alias_method :properties=, :config=
-
-    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