active-triples 0.0.1

data/lib/active_triples/nested_attributes.rb

@@ -0,0 +1,132 @@
+require 'active_support'
+require 'active_support/concern'
+require 'active_support/core_ext/class'
+
+module ActiveTriples
+  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
+

data/lib/active_triples/node_config.rb

@@ -0,0 +1,56 @@
+module ActiveTriples
+  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
+

data/lib/active_triples/properties.rb

@@ -0,0 +1,96 @@
+require 'deprecation'
+require 'active_support/core_ext/hash'
+
+module ActiveTriples
+  ##
+  # 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] = 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.
+    # @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 ActiveFedora::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_triples/repositories.rb

@@ -0,0 +1,36 @@
+module ActiveTriples
+  ##
+  # 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_triples/resource.rb

@@ -0,0 +1,369 @@
+require 'deprecation'
+require 'active_model'
+require 'active_support/core_ext/hash'
+
+module ActiveTriples
+  ##
+  # 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 ActiveTriples::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
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+    include ActiveModel::Serialization
+    include ActiveModel::Serializers::JSON
+    include 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
+      attrs = {}
+      attrs['id'] = id if id
+      fields.map { |f| attrs[f.to_s] = get_values(f) }
+      unregistered_predicates.map { |uri| attrs[uri.to_s] = get_values(uri) }
+      attrs
+    end
+
+    def serializable_hash(options = nil)
+      attrs = (fields.map { |f| f.to_s }) << 'id'
+      hash = super(:only => attrs)
+      unregistered_predicates.map { |uri| hash[uri.to_s] = get_values(uri) }
+      hash
+    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 id
+      node? ? nil : rdf_subject.to_s
+    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 = 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! if repository
+      parent.destroy_child(self) if parent
+      @destroyed = true
+    end
+    alias_method :destroy!, :destroy
+    
+    def destroyed?
+      @destroyed ||= false
+    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 registered_predicates 
+        properties.values.map { |config| config.predicate }
+      end
+      
+      def unregistered_predicates
+        preds = registered_predicates
+        preds << RDF.type
+        predicates.select { |p| !preds.include? p }
+      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
+            Repositories.repositories[self.class.repository]
+          end
+      end
+
+      ##
+      # 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