spira 0.0.12 → 0.5.0

data/lib/spira/association_reflection.rb

@@ -0,0 +1,25 @@
+class AssociationReflection
+  attr_reader :macro
+  attr_reader :name
+  attr_reader :options
+
+  def initialize(macro, name, options = {})
+    @macro = macro
+    @name = name
+    @options = options
+  end
+
+  def class_name
+    @class_name ||= (options[:type] || derive_class_name).to_s
+  end
+
+  def klass
+    @klass ||= class_name.constantize
+  end
+
+  private
+
+  def derive_class_name
+    name.to_s.camelize
+  end
+end

data/lib/spira/base.rb

@@ -1,11 +1,360 @@
+require "set"
+require "active_model"
+require "rdf/isomorphic"
+require "active_support/core_ext/hash/indifferent_access"
+
+require "spira/resource"
+require "spira/persistence"
+require "spira/validations"
+require "spira/reflections"
+require "spira/serialization"
+
 module Spira
 
   ##
-  # Spira::Base does nothing but include Spira::Resource, if it's more your
-  # style to do inheritance than module inclusion.
+  # Spira::Base aims to perform similar to ActiveRecord::Base
+  # You should inherit your models from it.
   #
-  # @see Spira::Resource
   class Base
-    include Spira::Resource
+    extend ActiveModel::Callbacks
+    extend ActiveModel::Naming
+    include ActiveModel::Conversion
+    include ActiveModel::Dirty
+
+    include ::RDF, ::RDF::Enumerable, ::RDF::Queryable
+
+    define_model_callbacks :save, :destroy, :create, :update
+
+    ##
+    # This instance's URI.
+    #
+    # @return [RDF::URI]
+    attr_reader :subject
+
+    attr_accessor :attributes
+
+    class << self
+      attr_reader :reflections, :properties
+
+      def types
+        Set.new
+      end
+
+      ##
+      # The base URI for this class.  Attempts to create instances for non-URI
+      # objects will be appended to this base URI.
+      #
+      # @return [Void]
+      def base_uri
+        # should be redefined in children, if required
+        # see also Spira::Resource.configure :base_uri option
+        nil
+      end
+
+      ##
+      # The default vocabulary for this class.  Setting a default vocabulary
+      # will allow properties to be defined without a `:predicate` option.
+      # Predicates will instead be created by appending the property name to
+      # the given string.
+      #
+      # @return [Void]
+      def default_vocabulary
+        # should be redefined in children, if required
+        # see also Spira::Resource.configure :default_vocabulary option
+        nil
+      end
+
+      def serialize(node, options = {})
+        if node.respond_to?(:subject)
+          node.subject
+        elsif node.respond_to?(:blank?) && node.blank?
+          nil
+        else
+          raise TypeError, "cannot serialize #{node.inspect} as a Spira resource"
+        end
+      end
+
+      def unserialize(value, options = {})
+        if value.respond_to?(:blank?) && value.blank?
+          nil
+        else
+          # Spira resources are instantiated as "promised"
+          # to avoid instantiation loops in case of resource-to-resource relations.
+          promise { instantiate_record(value) }
+        end
+      end
+
+
+      private
+
+      def inherited(child)
+        child.instance_variable_set :@properties, @properties.dup
+        child.instance_variable_set :@reflections, @reflections.dup
+        super
+      end
+
+      def instantiate_record(subj)
+        new(:_subject => id_for(subj))
+      end
+
+    end # class methods
+
+
+    def id
+      new_record? ? nil : subject.path.split(/\//).last
+    end
+
+    ##
+    # Initialize a new Spira::Base instance of this resource class using
+    # a new blank node subject.  Accepts a hash of arguments for initial
+    # attributes.  To use a URI or existing blank node as a subject, use
+    # {Spira.for} instead.
+    #
+    # @param [Hash{Symbol => Any}] props Default attributes for this instance
+    # @yield [self] Executes a given block
+    # @yieldparam [self] self The newly created instance
+    # @see Spira.for
+    # @see RDF::URI#as
+    # @see RDF::Node#as
+    def initialize(props = {}, options = {})
+      @subject = props.delete(:_subject) || RDF::Node.new
+
+      @attributes = {}
+      reload props
+
+      yield self if block_given?
+    end
+
+    # Freeze the attributes hash such that associations are still accessible, even on destroyed records.
+    def freeze
+      @attributes.freeze; self
+    end
+
+    # Returns +true+ if the attributes hash has been frozen.
+    def frozen?
+      @attributes.frozen?
+    end
+
+    ##
+    # The `RDF.type` associated with this class.
+    #
+    # This just takes a first type from "types" list,
+    # so make sure you know what you're doing if you use it.
+    #
+    # @return [nil,RDF::URI] The RDF type associated with this instance's class.
+    def type
+      self.class.type
+    end
+
+    ##
+    # All `RDF.type` nodes associated with this class.
+    #
+    # @return [nil,RDF::URI] The RDF type associated with this instance's class.
+    def types
+      self.class.types
+    end
+
+    ##
+    # Assign all attributes from the given hash.
+    #
+    def reload(props = {})
+      reset_changes
+      super
+      assign_attributes(props)
+      self
+    end
+
+    ##
+    # Returns the RDF representation of this resource.
+    #
+    # @return [RDF::Enumerable]
+    def to_rdf
+      self
+    end
+
+    ##
+    # A developer-friendly view of this projection
+    #
+    def inspect
+      "<#{self.class}:#{self.object_id} @subject: #{@subject}>"
+    end
+
+    ##
+    # Compare this instance with another instance.  The comparison is done on
+    # an RDF level, and will work across subclasses as long as the attributes
+    # are the same.
+    #
+    # @see http://rdf.rubyforge.org/isomorphic/
+    def ==(other)
+      # TODO: define behavior for equality on subclasses.
+      # TODO: should we compare attributes here?
+      if self.class == other.class
+        subject == other.uri
+      elsif other.is_a?(RDF::Enumerable)
+        self.isomorphic_with?(other)
+      else
+        false
+      end
+    end
+
+    ##
+    # Returns true for :to_uri if this instance's subject is a URI, and false if it is not.
+    # Returns true for :to_node if this instance's subject is a Node, and false if it is not.
+    # Calls super otherwise.
+    #
+    def respond_to?(*args)
+      case args[0]
+      when :to_uri
+        subject.respond_to?(:to_uri)
+      when :to_node
+        subject.node?
+      else
+        super(*args)
+      end
+    end
+
+    ##
+    # Returns the RDF::URI associated with this instance if this instance's
+    # subject is an RDF::URI, and nil otherwise.
+    #
+    # @return [RDF::URI,nil]
+    def uri
+      subject.respond_to?(:to_uri) ? subject : nil
+    end
+
+    ##
+    # Returns the URI representation of this resource, if available.  If this
+    # resource's subject is a BNode, raises a NoMethodError.
+    #
+    # @return [RDF::URI]
+    # @raise [NoMethodError]
+    def to_uri
+      uri || (raise NoMethodError, "No such method: :to_uri (this instance's subject is not a URI)")
+    end
+
+    ##
+    # Returns true if the subject associated with this instance is a blank node.
+    #
+    # @return [true, false]
+    def node?
+      subject.node?
+    end
+
+    ##
+    # Returns the Node subject of this resource, if available.  If this
+    # resource's subject is a URI, raises a NoMethodError.
+    #
+    # @return [RDF::Node]
+    # @raise [NoMethodError]
+    def to_node
+      subject.node? ? subject : (raise NoMethodError, "No such method: :to_uri (this instance's subject is not a URI)")
+    end
+
+    ##
+    # Returns a new instance of this class with the new subject instead of self.subject
+    #
+    # @param [RDF::Resource] new_subject
+    # @return [Spira::Base] copy
+    def copy(new_subject)
+      self.class.new(attributes.merge(:_subject => new_subject))
+    end
+
+    ##
+    # Returns a new instance of this class with the new subject instead of
+    # self.subject after saving the new copy to the repository.
+    #
+    # @param [RDF::Resource] new_subject
+    # @return [Spira::Base, String] copy
+    def copy!(new_subject)
+      copy(new_subject).save!
+    end
+
+    ##
+    # Assign attributes to the resource
+    # without persisting it.
+    def assign_attributes(attrs)
+      attrs.each do |name, value|
+        attribute_will_change!(name.to_s)
+        send "#{name}=", value
+      end
+    end
+
+
+    private
+
+    def reset_changes
+      @previously_changed = changes
+      @changed_attributes.clear
+    end
+
+    def write_attribute(name, value)
+      name = name.to_s
+      if self.class.properties[name]
+        if attributes[name].is_a?(Promise)
+          changed_attributes[name] = attributes[name] unless changed_attributes.include?(name)
+          attributes[name] = value
+        else
+          if value != read_attribute(name)
+            attribute_will_change!(name)
+            attributes[name] = value
+          end
+        end
+      else
+        raise Spira::PropertyMissingError, "attempt to assign a value to a non-existing property '#{name}'"
+      end
+    end
+
+    ##
+    # Get the current value for the given attribute
+    #
+    def read_attribute(name)
+      value = attributes[name.to_s]
+
+      refl = self.class.reflections[name]
+      if refl && !value
+        # yield default values for empty reflections
+        case refl.macro
+        when :has_many
+          # TODO: this should be actually handled by the reflection class
+          []
+        end
+      else
+        value
+      end
+    end
+
+    # Build a Ruby value from an RDF value.
+    def build_value(node, type)
+      klass = classize_resource(type)
+      if klass.respond_to?(:unserialize)
+        klass.unserialize(node)
+      else
+        raise TypeError, "Unable to unserialize #{node} as #{type}"
+      end
+    end
+
+    # Build an RDF value from a Ruby value for a property
+    def build_rdf_value(value, type)
+      klass = classize_resource(type)
+      if klass.respond_to?(:serialize)
+        klass.serialize(value)
+      else
+        raise TypeError, "Unable to serialize #{value} as #{type}"
+      end
+    end
+
+    def valid_object?(node)
+      node && (!node.literal? || node.valid?)
+    end
+
+    extend Resource
+    extend Reflections
+    include Types
+    include Persistence
+    include Validations
+    include Serialization
+
+    @reflections = HashWithIndifferentAccess.new
+    @properties = HashWithIndifferentAccess.new
   end
 end

data/lib/spira/exceptions.rb

@@ -1,19 +1,25 @@
 module Spira
 
+  class SpiraError < StandardError ; end
+
   ##
   # For cases when a method is called which requires a `type` method be
   # declared on a Spira class.
-  class NoTypeError < StandardError ; end
-
-  ##
-  # For cases when a projection fails a validation check
-  class ValidationError < StandardError ; end
+  class NoTypeError < SpiraError ; end
 
   ##
   # For cases in which a repository is required but none has been given
-  class NoRepositoryError < StandardError ; end
+  class NoRepositoryError < SpiraError ; end
 
   ##
   # For errors in the DSL, such as invalid predicates
-  class ResourceDeclarationError < StandardError ; end
+  class ResourceDeclarationError < SpiraError ; end
+
+  ##
+  # Raised when user tries to assign a non-existing property
+  class PropertyMissingError < SpiraError ; end
+
+  ##
+  # Raised when record cannot be persisted
+  class RecordNotSaved < SpiraError ; end
 end

data/lib/spira/persistence.rb

@@ -0,0 +1,531 @@
+module Spira
+  module Persistence
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      ##
+      # Repository name for this class
+      #
+      # @return [Symbol]
+      def repository_name
+        # should be redefined in children, if required
+        # see also Spira::Resource.configure :repository option
+        :default
+      end
+
+      ##
+      # The current repository for this class
+      #
+      # @return [RDF::Repository, nil]
+      def repository
+        Spira.repository(repository_name)
+      end
+
+      ##
+      # Simple finder method.
+      #
+      # @param [Symbol, ID] scope
+      #   scope can be :all, :first or an ID
+      # @param [Hash] args
+      #   args can contain:
+      #     :conditions - Hash of properties and values
+      #     :limit      - Fixnum, limiting the amount of returned records
+      # @return [Spira::Base, Array]
+      def find(scope, *args)
+        case scope
+        when :first
+          find_each(*args).first
+        when :all
+          find_all(*args)
+        else
+          instantiate_record(scope)
+        end
+      end
+
+      def all(*args)
+        find(:all, *args)
+      end
+
+      def first(*args)
+        find(:first, *args)
+      end
+
+      ##
+      # Enumerate over all resources projectable as this class.  This method is
+      # only valid for classes which declare a `type` with the `type` method in
+      # the Resource.
+      #
+      # Note that the instantiated records are "promises" not real instances.
+      #
+      # @raise  [Spira::NoTypeError] if the resource class does not have an RDF type declared
+      # @overload each
+      #   @yield [instance] A block to perform for each available projection of this class
+      #   @yieldparam [self] instance
+      #   @yieldreturn [Void]
+      #   @return [Void]
+      #
+      # @overload each
+      #   @return [Enumerator]
+      def each(*args)
+        raise Spira::NoTypeError, "Cannot count a #{self} without a reference type URI" unless type
+
+        options = args.extract_options!
+        conditions = options.delete(:conditions) || {}
+
+        raise Spira::SpiraError, "Cannot accept :type in query conditions" if conditions.delete(:type) || conditions.delete("type")
+
+        if block_given?
+          limit = options[:limit] || -1
+          offset = options[:offset] || 0
+          # TODO: ideally, all types should be joined in a conjunction
+          #       within "conditions_to_query", but since RDF::Query
+          #       cannot handle such patterns, we iterate across types "manually"
+          types.each do |tp|
+            break if limit.zero?
+            q = conditions_to_query(conditions.merge(:type => tp))
+            repository.query(q) do |solution|
+              break if limit.zero?
+              if offset.zero?
+                yield unserialize(solution[:subject])
+                limit -= 1
+              else
+                offset -= 1
+              end
+            end
+          end
+        else
+          enum_for(:each, *args)
+        end
+      end
+      alias_method :find_each, :each
+
+      ##
+      # The number of URIs projectable as a given class in the repository.
+      # This method is only valid for classes which declare a `type` with the
+      # `type` method in the Resource.
+      #
+      # @raise  [Spira::NoTypeError] if the resource class does not have an RDF type declared
+      # @return [Integer] the count
+      def count
+        each.count
+      end
+
+      # Creates an object (or multiple objects) and saves it to the database, if validations pass.
+      # The resulting object is returned whether the object was saved successfully to the database or not.
+      #
+      # The +attributes+ parameter can be either be a Hash or an Array of Hashes. These Hashes describe the
+      # attributes on the objects that are to be created.
+      #
+      # +create+ respects mass-assignment security and accepts either +:as+ or +:without_protection+ options
+      # in the +options+ parameter.
+      #
+      # ==== Examples
+      #   # Create a single new object
+      #   User.create(:first_name => 'Jamie')
+      #
+      #   # Create a single new object using the :admin mass-assignment security role
+      #   User.create({ :first_name => 'Jamie', :is_admin => true }, :as => :admin)
+      #
+      #   # Create a single new object bypassing mass-assignment security
+      #   User.create({ :first_name => 'Jamie', :is_admin => true }, :without_protection => true)
+      #
+      #   # Create an Array of new objects
+      #   User.create([{ :first_name => 'Jamie' }, { :first_name => 'Jeremy' }])
+      #
+      #   # Create a single object and pass it into a block to set other attributes.
+      #   User.create(:first_name => 'Jamie') do |u|
+      #     u.is_admin = false
+      #   end
+      #
+      #   # Creating an Array of new objects using a block, where the block is executed for each object:
+      #   User.create([{ :first_name => 'Jamie' }, { :first_name => 'Jeremy' }]) do |u|
+      #     u.is_admin = false
+      #   end
+      def create(attributes = nil, options = {}, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| create(attr, options, &block) }
+        else
+          object = new(attributes, options, &block)
+          object.save
+          object
+        end
+      end
+
+      ##
+      # Create a new projection instance of this class for the given URI.  If a
+      # class has a base_uri given, and the argument is not an `RDF::URI`, the
+      # given identifier will be appended to the base URI.
+      #
+      # Spira does not have 'find' or 'create' functions.  As RDF identifiers
+      # are globally unique, they all simply 'are'.
+      #
+      # On calling `for`, a new projection is created for the given URI.  The
+      # first time access is attempted on a field, the repository will be
+      # queried for existing attributes, which will be used for the given URI.
+      # Underlying repositories are not accessed at the time of calling `for`.
+      #
+      # A class with a base URI may still be projected for any URI, whether or
+      # not it uses the given resource class' base URI.
+      #
+      # @raise [TypeError] if an RDF type is given in the attributes and one is
+      # given in the attributes.
+      # @raise [ArgumentError] if a non-URI is given and the class does not
+      # have a base URI.
+      # @overload for(uri, attributes = {})
+      #   @param [RDF::URI] uri The URI to create an instance for
+      #   @param [Hash{Symbol => Any}] attributes Initial attributes
+      # @overload for(identifier, attributes = {})
+      #   @param [Any] uri The identifier to append to the base URI for this class
+      #   @param [Hash{Symbol => Any}] attributes Initial attributes
+      # @yield [self] Executes a given block and calls `#save!`
+      # @yieldparam [self] self The newly created instance
+      # @return  [Spira::Base] The newly created instance
+      # @see http://rdf.rubyforge.org/RDF/URI.html
+      def for(identifier, attributes = {}, &block)
+        self.project(id_for(identifier), attributes, &block)
+      end
+      alias_method :[], :for
+
+      ##
+      # Create a new instance with the given subject without any modification to
+      # the given subject at all.  This method exists to provide an entry point
+      # for implementing classes that want to create a more intelligent .for
+      # and/or .id_for for their given use cases, such as simple string
+      # appending to base URIs or calculated URIs from other representations.
+      #
+      # @example Using simple string concatentation with base_uri in .for instead of joining delimiters
+      #     def for(identifier, attributes = {}, &block)
+      #       self.project(RDF::URI(self.base_uri.to_s + identifier.to_s), attributes, &block)
+      #     end
+      # @param [RDF::URI, RDF::Node] subject
+      # @param [Hash{Symbol => Any}] attributes Initial attributes
+      # @return [Spira::Base] the newly created instance
+      def project(subject, attributes = {}, &block)
+        new(attributes.merge(:_subject => subject), &block)
+      end
+
+      ##
+      # Creates a URI or RDF::Node based on a potential base_uri and string,
+      # URI, or Node, or Addressable::URI.  If not a URI or Node, the given
+      # identifier should be a string representing an absolute URI, or
+      # something responding to to_s which can be appended to a base URI, which
+      # this class must have.
+      #
+      # @param  [Any] identifier
+      # @return [RDF::URI, RDF::Node]
+      # @raise  [ArgumentError] If this class cannot create an identifier from the given argument
+      # @see http://rdf.rubyforge.org/RDF/URI.html
+      # @see Spira.base_uri
+      # @see Spira.for
+      def id_for(identifier)
+        case
+          # Absolute URI's go through unchanged
+        when identifier.is_a?(RDF::URI) && identifier.absolute?
+          identifier
+          # We don't have a base URI to join this fragment with, so go ahead and instantiate it as-is.
+        when identifier.is_a?(RDF::URI) && self.base_uri.nil?
+          identifier
+          # Blank nodes go through unchanged
+        when identifier.respond_to?(:node?) && identifier.node?
+          identifier
+          # Anything that can be an RDF::URI, we re-run this case statement
+          # on it for the fragment logic above.
+        when identifier.respond_to?(:to_uri) && !identifier.is_a?(RDF::URI)
+          id_for(identifier.to_uri)
+          # see comment with #to_uri above, this might be a fragment
+        when identifier.is_a?(Addressable::URI)
+          id_for(RDF::URI.intern(identifier))
+          # This is a #to_s or a URI fragment with a base uri.  We'll treat them the same.
+          # FIXME: when #/ makes it into RDF.rb proper, this can all be wrapped
+          # into the one case statement above.
+        else
+          uri = identifier.is_a?(RDF::URI) ? identifier : RDF::URI.intern(identifier.to_s)
+          case
+          when uri.absolute?
+            uri
+          when self.base_uri.nil?
+            raise ArgumentError, "Cannot create identifier for #{self} by String without base_uri; an RDF::URI is required"
+          else
+            separator = self.base_uri.to_s[-1,1] =~ /(\/|#)/ ? '' : '/'
+            RDF::URI.intern(self.base_uri.to_s + separator + identifier.to_s)
+          end
+        end
+      end
+
+
+      private
+
+      def find_all(*args)
+        [].tap do |records|
+          find_each(*args) do |record|
+            records << record
+          end
+        end
+      end
+
+      def conditions_to_query(conditions)
+        patterns = []
+        conditions.each do |name, value|
+          if name.to_s == "type"
+            patterns << [:subject, RDF.type, value]
+          else
+            patterns << [:subject, properties[name][:predicate], value]
+          end
+        end
+
+        RDF::Query.new do
+          patterns.each { |pat| pattern(pat) }
+        end
+      end
+    end
+
+    # A resource is considered to be new if the repository
+    # does not have statements where subject == resource type
+    def new_record?
+      !self.class.repository.has_subject?(subject)
+    end
+
+    def destroyed?
+      @destroyed
+    end
+
+    def persisted?
+      # FIXME: an object should be considered persisted
+      # when its attributes (and their exact values) are all available in the storage.
+      # This should check for !(changed? || new_record? || destroyed?) actually.
+      !(new_record? || destroyed?)
+    end
+
+    def save(*)
+      create_or_update
+    end
+
+    def save!(*)
+      create_or_update || raise(RecordNotSaved)
+    end
+
+    def destroy(*args)
+      run_callbacks :destroy do
+        destroy_model_data(*args)
+      end
+    end
+
+    def destroy!(*args)
+      destroy(*args) || raise(RecordNotSaved)
+    end
+
+    ##
+    # Enumerate each RDF statement that makes up this projection.  This makes
+    # each instance an `RDF::Enumerable`, with all of the nifty benefits
+    # thereof.  See <http://rdf.rubyforge.org/RDF/Enumerable.html> for
+    # information on arguments.
+    #
+    # @see http://rdf.rubyforge.org/RDF/Enumerable.html
+    def each
+      if block_given?
+        self.class.properties.each do |name, property|
+          if value = read_attribute(name)
+            if self.class.reflect_on_association(name)
+              value.each do |val|
+                node = build_rdf_value(val, property[:type])
+                yield RDF::Statement.new(subject, property[:predicate], node) if valid_object?(node)
+              end
+            else
+              node = build_rdf_value(value, property[:type])
+              yield RDF::Statement.new(subject, property[:predicate], node) if valid_object?(node)
+            end
+          end
+        end
+        self.class.types.each do |t|
+          yield RDF::Statement.new(subject, RDF.type, t)
+        end
+      else
+        enum_for(:each)
+      end
+    end
+
+    ##
+    # The number of RDF::Statements this projection has.
+    #
+    # @see http://rdf.rubyforge.org/RDF/Enumerable.html#count
+    def count
+      each.count
+    end
+
+    ##
+    # Update multiple attributes of this repository.
+    #
+    # @example Update multiple attributes
+    #     person.update_attributes(:name => 'test', :age => 10)
+    #     #=> person
+    #     person.name
+    #     #=> 'test'
+    #     person.age
+    #     #=> 10
+    #     person.dirty?
+    #     #=> true
+    # @param  [Hash{Symbol => Any}] properties
+    # @param  [Hash{Symbol => Any}] options
+    # @return [self]
+    def update_attributes(properties, options = {})
+      assign_attributes properties
+      save options
+    end
+
+    ##
+    # Reload all attributes for this instance.
+    # This resource will block if the underlying repository
+    # blocks the next time it accesses attributes.
+    #
+    # If repository is not defined, the attributes are just not set,
+    # instead of raising a Spira::NoRepositoryError.
+    #
+    # NB: "props" argument is ignored, it is handled in Base
+    #
+    def reload(props = {})
+      sts = self.class.repository && self.class.repository.query(:subject => subject)
+      self.class.properties.each do |name, options|
+        name = name.to_s
+        if sts
+          objects = sts.select { |s| s.predicate == options[:predicate] }
+          attributes[name] = retrieve_attribute(name, options, objects)
+        end
+      end
+    end
+
+
+    private
+
+    def create_or_update
+      run_callbacks :save do
+        # "create" callback is triggered only when persisting a resource definition
+        persistance_callback = new_record? && type ? :create : :update
+        run_callbacks persistance_callback do
+          materizalize
+          persist!
+          reset_changes
+        end
+      end
+      self
+    end
+
+    ##
+    # Save changes to the repository
+    #
+    def persist!
+      repo = self.class.repository
+      self.class.properties.each do |name, property|
+        value = read_attribute name
+        if self.class.reflect_on_association(name)
+          # TODO: for now, always persist associations,
+          #       as it's impossible to reliably determine
+          #       whether the "association property" was changed
+          #       (e.g. for "in-place" changes like "association << 1")
+          #       This should be solved by splitting properties
+          #       into "true attributes" and associations
+          #       and not mixing the both in @properties.
+          repo.delete [subject, property[:predicate], nil]
+          value.each do |val|
+            store_attribute(name, val, property[:predicate], repo)
+          end
+        else
+          if attribute_changed?(name.to_s)
+            repo.delete [subject, property[:predicate], nil]
+            store_attribute(name, value, property[:predicate], repo)
+          end
+        end
+      end
+      types.each do |type|
+        # NB: repository won't accept duplicates,
+        #     but this should be avoided anyway, for performance
+        repo.insert RDF::Statement.new(subject, RDF.type, type)
+      end
+    end
+
+    # "Materialize" the resource:
+    # assign a persistable subject to a non-persisted resource,
+    # so that it can be properly stored.
+    def materizalize
+      if new_record? && subject.anonymous? && type
+        # TODO: doesn't subject.anonymous? imply subject.id == nil ???
+        @subject = self.class.id_for(subject.id)
+      end
+    end
+
+    def store_attribute(property, value, predicate, repository)
+      unless value.nil?
+        val = build_rdf_value(value, self.class.properties[property][:type])
+        repository.insert RDF::Statement.new(subject, predicate, val) if valid_object?(val)
+      end
+    end
+
+    # Directly retrieve an attribute value from the storage
+    def retrieve_attribute(name, options, sts)
+      if self.class.reflections[name]
+        sts.inject([]) do |values, statement|
+          if statement.predicate == options[:predicate]
+            values << build_value(statement.object, options[:type])
+          else
+            values
+          end
+        end
+      else
+        sts.first ? build_value(sts.first.object, options[:type]) : nil
+      end
+    end
+
+    # Destroy all model data
+    # AND non-model data, where this resource is referred to as object.
+    def destroy_model_data(*args)
+      if self.class.repository.delete(*statements) && self.class.repository.delete([nil, nil, subject])
+        @destroyed = true
+        freeze
+      end
+    end
+
+    # Return the appropriate class object for a string or symbol
+    # representation.  Throws errors correctly if the given class cannot be
+    # located, or if it is not a Spira::Base
+    #
+    def classize_resource(type)
+      return type unless type.is_a?(Symbol) || type.is_a?(String)
+
+      klass = nil
+      begin
+        klass = qualified_const_get(type.to_s)
+      rescue NameError
+        raise NameError, "Could not find relation class #{type} (referenced as #{type} by #{self})"
+      end
+      klass
+    end
+
+    # Resolve a constant from a string, relative to this class' namespace, if
+    # available, and from root, otherwise.
+    #
+    # FIXME: this is not really 'qualified', but it's one of those
+    # impossible-to-name functions.  Open to suggestions.
+    #
+    # @author njh
+    # @private
+    def qualified_const_get(str)
+      path = str.to_s.split('::')
+      from_root = path[0].empty?
+      if from_root
+        from_root = []
+        path = path[1..-1]
+      else
+        start_ns = ((Class === self)||(Module === self)) ? self : self.class
+        from_root = start_ns.to_s.split('::')
+      end
+      until from_root.empty?
+        begin
+          return (from_root+path).inject(Object) { |ns,name| ns.const_get(name) }
+        rescue NameError
+          from_root.delete_at(-1)
+        end
+      end
+      path.inject(Object) { |ns,name| ns.const_get(name) }
+    end
+
+  end
+end