spira 0.0.5 → 0.0.6

data/CHANGES.md

@@ -1,5 +1,30 @@
 # Changelog for Spira <http://github.com/datagraph/spira>
 
+## 0.0.6
+ * Added #exists?, which returns a boolean if an instance exists in
+   the backing store.
+ * Added #data, which returns an enumerator of all RDF data for a subject, not
+   just model data.
+ * #save! and #update! now return self for chaining
+ * Implemented #update and #update!, which allow setting multiple properties 
+   at once
+ * Existing values not matching a model's defined type will now be deleted on 
+   #save!
+ * Saving resources will now only update dirty fields
+ * Saving resources now removes all existing triples for a given predicate 
+   if the field was updated instead of only removing one.
+ * Implemented and documented #destroy!, #destroy!(:subject), 
+   #destroy!(:object), and #destroy!(:completely).  Removed #destroy_resource!
+ * has_many collections are now Sets and not Arrays, more accurately reflecting
+   RDF semantics.
+ * The Any (default) property type will now work fine with URIs
+ * Added ResourceDeclarationError to replace various errors that occur during
+   invalid class declarations via the DSL.
+ * Raise an error if a non-URI predicate is given in the DSL
+ * Small updates for RDF.rb 0.2.0
+ * Implemented dirty field tracking.  Resource#dirty?(:name) will now report if
+   a field has not been saved.
+
 ## 0.0.5
  * Relations can now find related classes in modules, either by absolute
    reference, or by class name if they are in the same namespace.  

data/VERSION

@@ -1 +1 @@
-0.0.5
+0.0.6

data/lib/spira/exceptions.rb

@@ -12,4 +12,8 @@ module Spira
   ##
   # For cases in which a repository is required but none has been given
   class NoRepositoryError < StandardError ; end
+
+  ##
+  # For errors in the DSL, such as invalid predicates
+  class ResourceDeclarationError < StandardError ; end
 end

data/lib/spira/resource/dsl.rb

@@ -221,11 +221,14 @@ module Spira
           when opts[:predicate]
             opts[:predicate]
           when @default_vocabulary.nil?
-            raise TypeError, "A :predicate option is required for types without a default vocabulary"
+            raise ResourceDeclarationError, "A :predicate option is required for types without a default vocabulary"
           else @default_vocabulary
             separator = @default_vocabulary.to_s[-1,1] =~ /(\/|#)/ ? '' : '/'
             RDF::URI.new(@default_vocabulary.to_s + separator + name.to_s)
         end
+        if !(predicate.respond_to?(:to_uri))
+         raise ResourceDeclarationError, ":predicate options must be RDF::URIs or strings with a default vocabulary declared"
+        end
         type = case
             when opts[:type].nil?
               Spira::Types::Any
@@ -241,27 +244,13 @@ module Spira
         @properties[name][:type] = type
         name_equals = (name.to_s + "=").to_sym
 
-        (getter,setter) = self.send(accessors_method, name, predicate, type)
-        self.send(:define_method,name_equals, &setter) 
-        self.send(:define_method,name, &getter) 
-
-      end
-
-      ##
-      # Getter and Setter methods for predicates.
-      # FIXME: this and add_accessors are from an older version in which
-      # multiple versions of accessors existed, and can be refactored.
-      # @private
-      def hash_accessors(name, predicate, type)
-        setter = lambda do |arg|
-          attribute_set(name,arg)
+        self.send(:define_method,name_equals) do |arg|
+          attribute_set(name, arg)
         end
-
-        getter = lambda do
+        self.send(:define_method,name) do 
           attribute_get(name)
         end
 
-        [getter, setter]
       end
 
     end

data/lib/spira/resource/instance_methods.rb

@@ -1,4 +1,5 @@
 require 'rdf/isomorphic'
+require 'set'
 
 module Spira
   module Resource
@@ -25,7 +26,7 @@ module Spira
       # attributes.  To use a URI or existing blank node as a subject, use
       # {Spira::Resource::ClassMethods#for} instead.
       #
-      # @param [Hash] opts Default attributes for this instance
+      # @param [Hash{Symbol => Any}] opts Default attributes for this instance
       # @see Spira::Resource::ClassMethods#for
       # @see RDF::URI#as
       # @see RDF::Node#as
@@ -42,8 +43,10 @@ module Spira
       # @param   [Hash{Symbol => Any}] opts
       # @option opts [Symbol] :any A property name.  Sets the given property to the given value.
       def reload(opts = {})
+        @dirty = {}
+        # We need to save all attributes twice to track state changes in
+        # mutable objects, like lists
         @attributes = promise { reload_attributes }
-        @original_attributes = promise { @attributes.force ; @original_attributes }
         self.class.properties.each do |name, predicate|
           attribute_set(name, opts[name]) unless opts[name].nil?
         end
@@ -52,47 +55,53 @@ module Spira
       ##
       # Load this instance's attributes.  Overwrite loaded values with attributes in the given options.
       #
-      # @param [Hash] opts
-      # @return [Hash] @attributes
+      # @return [Hash{Symbol => Any}] attributes
       # @private
       def reload_attributes()
         statements = self.class.repository_or_fail.query(:subject => @subject)
-        @attributes = {}
+        attributes = {}
+        attributes[:original] = {}
+        attributes[:current] = {}
 
-        unless statements.empty?
-          # Set attributes for each statement corresponding to a predicate
-          self.class.properties.each do |name, property|
-            if self.class.is_list?(name)
-              # FIXME: This should not be an Array, but a Set.  However, a set
-              # must compare its values to see if they already exist.  This
-              # means any referenced relations will check their attributes and
-              # execute the promises to load those classes.  Need an identity
-              # map of some sort to fix that.
-              values = []
-              collection = statements.query(:subject => @subject, :predicate => property[:predicate])
-              unless collection.nil?
-                collection.each do |statement|
-                  values << self.class.build_value(statement,property[:type])
-                end
+        # Set attributes for each statement corresponding to a predicate
+        self.class.properties.each do |name, property|
+          if self.class.is_list?(name)
+            values = Set.new
+            collection = statements.query(:subject => @subject, :predicate => property[:predicate]) unless statements.empty?
+            unless collection.nil?
+              collection.each do |statement|
+                values << self.class.build_value(statement,property[:type])
               end
-              attribute_set(name, values)
-            else
-              statement = statements.query(:subject => @subject, :predicate => property[:predicate]).first
-              attribute_set(name, self.class.build_value(statement, property[:type]))
+            end
+            attributes[:current][name] = values
+            attributes[:original][name] = values.dup
+          else
+            statement = statements.query(:subject => @subject, :predicate => property[:predicate]).first unless statements.empty?
+            attributes[:current][name] = self.class.build_value(statement, property[:type])
+
+            # Lots of things like Fixnums and Nil can't be dup'd, but they are
+            # all immutable, so if we can't dup, it's no problem for dirty tracking.
+            begin
+              attributes[:original][name] = attributes[:current][name].dup
+            rescue TypeError
+              attributes[:original][name] = attributes[:current][name]
             end
           end
         end
 
-        # We need to load and save the original attributes so we can remove
-        # them from the repository on save, since RDF will happily let us add
-        # as many triples for a subject and predicate as we want.
-        @original_attributes = {}
-        @original_attributes = @attributes.dup
-        @original_attributes.each do | name, value |
-          @original_attributes[name] = value.dup if value.is_a?(Array)
-        end
+        attributes
+      end
 
-        @attributes
+      ##
+      # Returns a hash of name => value for this instance's attributes
+      #
+      # @return [Hash{Symbol => Any}] attributes
+      def attributes
+        attributes = {}
+        self.class.properties.keys.each do |property|
+          attributes[property] = attribute_get(property)
+        end
+        attributes
       end
 
       ##
@@ -109,29 +118,35 @@ module Spira
       end
  
       ##
-      # Remove this instance from the repository.  Will not delete statements
-      # not associated with this model.
+      # Delete this instance from the repository.
       #
+      # @param [Symbol] what
+      # @example Delete all fields defined in the model
+      #     @object.destroy!
+      # @example Delete all instances of this object as the subject of a triple, including non-model data @object.destroy!
+      #     @object.destroy!(:subject)
+      # @example Delete all instances of this object as the object of a triple
+      #     @object.destroy!(:object)
+      # @example Delete all triples with this object as the subject or object
+      #     @object.destroy!(:completely)
       # @return [true, false] Whether or not the destroy was successful
-      def destroy!
-        _destroy_attributes(@attributes, :destroy_type => true)
-        reload
-      end
-
-      ##
-      # Remove all statements associated with this instance from the
-      # repository. This will delete statements unassociated with the current
-      # projection.
-      #
-      # @return [true, false] Whether or not the destroy was successful
-      def destroy_resource!
-        self.class.repository_or_fail.delete([@subject,nil,nil])
+      def destroy!(what = nil)
+        case what
+          when nil
+            _destroy_attributes(attributes, :destroy_type => true) != nil
+          when :subject
+            self.class.repository_or_fail.delete([subject, nil, nil]) != nil
+          when :object
+            self.class.repository_or_fail.delete([nil, nil, subject]) != nil
+          when :completely
+            destroy!(:subject) && destroy!(:object)
+        end
       end
 
       ##
       # Save changes in this instance to the repository.
       #
-      # @return [true, false] Whether or not the save was successful
+      # @return [self] self
       def save!
         unless self.class.validators.empty?
           errors.clear
@@ -144,6 +159,47 @@ module Spira
         else
           _update!
         end
+        self
+      end
+
+      ##
+      # Update multiple attributes of this repository.
+      #
+      # @example Update multiple attributes
+      #     person.update(:name => 'test', :age => 10)
+      #     #=> person
+      #     person.name
+      #     #=> 'test'
+      #     person.age
+      #     #=> 10
+      #     person.dirty?
+      #     #=> true
+      # @param  [Hash{Symbol => Any}] properties
+      # @return [self]
+      def update(properties)
+        properties.each do |property, value|
+          attribute_set(property, value)
+        end
+        self
+      end
+
+      ##
+      # Equivalent to #update followed by #save!
+      #
+      # @example Update multiple attributes and save the changes
+      #     person.update!(:name => 'test', :age => 10)
+      #     #=> person
+      #     person.name
+      #     #=> 'test'
+      #     person.age
+      #     #=> 10
+      #     person.dirty?
+      #     #=> false
+      # @param  [Hash{Symbol => Any}] properties
+      # @return [self]
+      def update!(properties)
+        update(properties)
+        save!
       end
 
       ##
@@ -151,9 +207,23 @@ module Spira
       #
       # @private
       def _update!
-        _destroy_attributes(@original_attributes)
-        self.class.repository_or_fail.insert(*self)
-        @original_attributes = @attributes.dup
+        self.class.properties.each do |property, predicate|
+          if dirty?(property)
+            self.class.repository_or_fail.delete([subject, predicate[:predicate], nil])
+            if self.class.is_list?(property)
+              repo = RDF::Repository.new
+              attribute_get(property).each do |value|
+                repo << RDF::Statement.new(subject, predicate[:predicate], self.class.build_rdf_value(value, self.class.properties[property][:type]))
+              end
+              self.class.repository_or_fail.insert(*repo)
+            else
+              self.class.repository_or_fail.insert(RDF::Statement.new(subject, predicate[:predicate], self.class.build_rdf_value(attribute_get(property), self.class.properties[property][:type])))
+            end
+          end
+          @dirty[property] = nil
+          @attributes[:original][property] = attribute_get(property)
+        end
+        self.class.repository_or_fail.insert(RDF::Statement.new(@subject, RDF.type, type)) unless type.nil?
       end
  
       ## 
@@ -197,18 +267,44 @@ module Spira
       #
       # @see http://rdf.rubyforge.org/RDF/Enumerable.html
       def each(*args, &block)
-        return RDF::Enumerator.new(self, :each) unless block_given?
-        repository = repository_for_attributes(@attributes)
+        return enum_for(:each) unless block_given?
+        repository = repository_for_attributes(attributes)
         repository.insert(RDF::Statement.new(@subject, RDF.type, type)) unless type.nil?
         repository.each(*args, &block)
       end
 
+      ##
+      # The number of RDF::Statements this projection has.
+      #
+      # @see http://rdf.rubyforge.org/RDF/Enumerable.html#count
+      def count
+        each.size
+      end
+
       ##
       # Sets the given attribute to the given value.
       #
       # @private
       def attribute_set(name, value)
-        @attributes[name] = value
+        @dirty[name] = true
+        @attributes[:current][name] = value
+      end
+
+      ##
+      # Returns true if the given attribute has been changed from the backing store
+      #
+      def dirty?(name = nil)
+        case name
+          when nil
+            self.class.properties.keys.any? { |key| dirty?(key) }
+          else
+            case
+              when @dirty[name] == true
+                true
+              else 
+                @attributes[:current][name] != @attributes[:original][name]
+            end
+          end
       end
 
       ##
@@ -216,12 +312,7 @@ module Spira
       #
       # @private
       def attribute_get(name)
-        case self.class.is_list?(name)
-          when true
-            @attributes[name] ||= []
-          when false   
-            @attributes[name]
-        end
+        @attributes[:current][name]
       end
 
       ##
@@ -331,6 +422,25 @@ module Spira
         @errors ||= Spira::Errors.new
       end
 
+      ##
+      # Returns true if any data exists for this subject in the backing RDF store
+      #
+      # @return [Boolean]
+      def exists?
+        !data.empty?
+      end
+      alias_method :exist?, :exists?
+    
+      ##
+      # Returns an Enumerator of all RDF data for this subject, not just model data.
+      #
+      # @see #each
+      # @see http://rdf.rubyforge.org/RDF/Enumerable.html
+      # @return [Enumerator]
+      def data
+        self.class.repository.query(:subject => subject)
+      end
+
       ## We have defined #each and can do this fun RDF stuff by default
       include ::RDF::Enumerable, ::RDF::Queryable
 

data/lib/spira/types/any.rb

@@ -12,11 +12,12 @@ module Spira::Types
     include Spira::Type
 
     def self.unserialize(value)
-      value.object
+      value.respond_to?(:to_uri) ? value.to_uri : value.object
     end
 
     def self.serialize(value)
-      RDF::Literal.new(value)
+      raise TypeError, "Spira::Types::Any cannot serialize collections" if value.is_a?(Array)
+      value.respond_to?(:to_uri) ? value.to_uri : RDF::Literal.new(value)
     end
 
   end

data/lib/spira/version.rb

@@ -2,7 +2,7 @@ module Spira
   module VERSION
     MAJOR = 0
     MINOR = 0
-    TINY  = 5
+    TINY  = 6
     EXTRA = nil
 
     STRING = [MAJOR, MINOR, TINY].join('.')

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 5
-  version: 0.0.5
+  - 6
+  version: 0.0.6
 platform: ruby
 authors: 
 - Ben Lavender
@@ -15,7 +15,7 @@ bindir:
 - bin
 cert_chain: []
 
-date: 2010-06-28 00:00:00 -05:00
+date: 2010-08-23 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -28,8 +28,8 @@ dependencies:
         segments: 
         - 0
         - 2
-        - 0
-        version: 0.2.0
+        - 2
+        version: 0.2.2
   type: :development
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -70,8 +70,8 @@ dependencies:
         segments: 
         - 0
         - 2
-        - 0
-        version: 0.2.0
+        - 2
+        version: 0.2.2
   type: :runtime
   version_requirements: *id004
 - !ruby/object:Gem::Dependency 
@@ -97,9 +97,9 @@ dependencies:
       - !ruby/object:Gem::Version 
         segments: 
         - 0
-        - 2
+        - 3
         - 0
-        version: 0.2.0
+        version: 0.3.0
   type: :runtime
   version_requirements: *id006
 description: Spira is a framework for using the information in RDF.rb repositories as model objects.