spira 0.0.1.pre

data/AUTHORS

@@ -0,0 +1 @@
+* Ben Lavender <blavender@gmail.com>

data/README

@@ -0,0 +1,271 @@
+# Spira
+
+It's time to breathe life into your linked data.
+
+---
+
+## Synopsis
+Spira is a framework for using the information in RDF.rb repositories as model
+objects.  It gives you the ability to work in a resource-oriented way without
+losing access to statement-oriented nature of linked data, if you so choose.
+It can be used either to access existing RDF data in a resource-oriented way,
+or to create a new store of RDF data based on simple defaults.
+
+### Example
+
+    class Person
+    
+      include Spira::Resource
+
+      base_uri "http://example.org/example/people"
+    
+      property :name, :predicate => RDF::FOAF.name, :type => String
+      property :age,  :predicate => RDF::FOAF.age,  :type => Integer
+
+    end
+
+    bob = Person.create 'bob'
+    bob.age  = 15
+    bob.name = "Bob Smith"
+    bob.save!
+
+    bob.each_statement {|s| puts s}
+    #=> RDF::Statement:0x80abb80c(<http://example.org/example/people/bob> <http://xmlns.com/foaf/0.1/name> "Bob Smith" .)
+    #=> RDF::Statement:0x80abb8fc(<http://example.org/example/people/bob> <http://xmlns.com/foaf/0.1/age> "15"^^<http://www.w3.org/2001/XMLSchema#integer> .)
+   
+### Features
+
+ * Extensible validations system
+ * Easy to use multiple data sources
+ * Easy to adapt models to existing data
+ * Objects are still RDF.rb-compatible enumerable objects
+ * No need to put everything about an object into Spira
+ * Easy to use a resource as multiple models
+
+## Getting Started
+
+By far the easiest way to work with Spira is to install it via Rubygems:
+
+    $ sudo gem install spira
+
+Nonetheless, downloads are available at the Github project page.
+
+## Defining Model Classes
+
+To use Spira, define model classes for your RDF data.  Spira classes include
+RDF, and thus have access to all `RDF::Vocabulary` classes and `RDF::URI`
+without the `RDF::` prefix.  For example:
+
+    require 'spira'
+    
+    class CD
+      include Spira::Resource
+      base_uri 'http://example.org/cds'
+      property :name,   :predicate => DC.title,   :type => XSD.string
+      property :artist, :predicate => URI.new('http://example.org/vocab/artist'), :type => :artist
+    end
+    
+    class Artist
+      include Spira::Resource
+      base_uri 'http://example.org/artists'
+      property :name, :predicate => DC.title, :type => XSD.string
+      has_many :cds,  :predicate => URI.new('http://example.org/vocab/published_cd'), :type => XSD.string
+    end
+
+Then use your model classes, in a way more or less similar to any number of ORMs:
+
+    cd = CD.create "queens-greatest-hits"
+    cd.name = "Queen's greatest hits"
+    artist = Artist.create "queen"
+    artist.name = "Queen"
+    
+    cd.artist = artist
+    cd.save!
+    artist.cds = [cd]
+    artist.save!
+
+    queen = Arist.find 'queen'
+    hits = CD.find 'queens-greatest-hits'
+    hits.artist == artist == queen
+
+### Absolute and Relative URIs
+
+A class with a base URI can reference objects by a short name:
+
+    Artist.find 'queen'
+
+However, a class is not required to have a base URI, and even if it does, it
+can always access classes with a full URI:
+
+    nk = Artist.find RDF::URI.new('http://example.org/my-hidden-cds/new-kids')
+    
+### Class Options
+
+A number of options are available for Spira classes.
+
+#### base_uri
+
+A class with a `base_uri` set (either an `RDF::URI` or a `String`) will
+use that URI as a base URI for non-absolute `create` and `find` calls.
+
+Example
+    CD.find 'queens-greatest-hits' # is the same as...
+    CD.find RDF::URI.new('http://example.org/cds/queens-greatest-hits')
+
+#### type
+
+A class with a `type` set is assigned an `RDF.type` on creation and saving.
+
+    class Album
+      include Spira::Resource
+      type RDF::URI.new('http://example.org/types/album')
+      property :name,   :predicate => DC.title
+    end
+
+    rolling_stones = Album.create RDF::URI.new('http://example.org/cds/rolling-stones-hits')
+    # See RDF.rb for more information about #has_predicate?
+    rolling_stones.has_predicate?(RDF.type) #=> true
+    Album.type #=> RDF::URI('http://example.org/types/album')
+
+In addition, one can count the members of a class with a `type` defined:
+
+    Album.count  #=> 1 
+
+#### property
+
+A class declares property members with the `property` function.  See `Property Options` for more information.
+
+#### has_many
+
+A class declares list members with the `has_many` function.  See `Property Options` for more information.
+
+#### default_vocabulary
+
+A class with a `default_vocabulary` set will transparently create predicates for defined properties:
+
+    class Song
+      include Spira::Resource
+      default_vocabulary RDF::URI.new('http://example.org/vocab')
+      base_uri 'http://example.org/songs'
+      property :title
+      property :author, :type => :artist
+    end
+
+    dancing_queen = Song.create 'dancing-queen'
+    dancing_queen.title = "Dancing Queen"
+    dancing_queen.artist = abba
+    dancing_queen.has_predicate?(RDF::URI.new('http://example.org/vocab/title'))  #=> true
+    dancing_queen.has_predicate?(RDF::URI.new('http://example.org/vocab/artist')) #=> true
+
+#### default_source
+
+Provides this class with a default repository to use instead of the `:default`
+repository if one is not set.
+
+    class Song
+      default_source :songs
+    end
+
+See 'Defining Repositories' for more information.
+
+### Property Options
+
+Spira classes can have properties that are either singular or a list.  For a
+list, define the property with `has_many`, for a property with a single item,
+use `property`.  The semantics are otherwise the same.  A `has_many` property
+will always return a list, including an empty list for no value.  All options
+for `property` work for `has_many`.
+
+    property :artist, :type => :artist    #=> cd.artist returns a single value
+    has_many :cds,    :type => :cd        #=> artist.cds returns an array
+
+Property always takes a symbol name as a name, and a variable list of options.  The supported options are:
+
+ * `:type`: The type for this property.  This can be a Ruby base class, an 
+   RDF::XSD entry, or another Spira model class, referenced as a symbol. Default: `String`
+ * `:predicate`: The predicate to use for this type.  This can be any RDF URI.
+   This option is required unless the `default_vocabulary` has been used.
+
+### Relations
+
+If the `:type` of a spira class is the name of another Spira class as a symbol,
+such as `:artist` for `Artist`, Spira will attempt to load the referenced
+object when the appropriate property is accessed.
+
+In the RDF store, this will be represented by the URI of the referenced object.
+
+## Defining Repositories
+
+You can define multiple repositories with Spira, and use more than one at a time:
+
+    require 'rdf/ntriples'
+    require 'rdf/sesame'
+    Spira.add_repository! :cds,    RDF::Sesame::Repository.new 'some_server'
+    Spira.add_repository! :albums, RDF::Repository.load('some_file.nt')
+
+    CD.repository = :cds
+    Album.repository = :albums
+
+Objects can reference each other cross-repository.
+
+If no repository has been specified, the `:default` repository will be used.
+
+    repo = RDF::Repository.new
+    Spira.add_repository! :default, repo
+    Artist.repository == repo #=> true
+
+Classes can specify a default repository to use other than `:default` with the
+`default_source` function:
+
+    class Song
+      default_source :songs
+    end
+
+    Song.repository #=> nil, won't use :default
+
+## Validations
+
+Before saving, each object will run a `validate` function, if one exists.  You
+can use the built in `assert` and assert helpers such as `assert_set` and
+`asssert_numeric`.
+
+
+    class CD
+      def validate
+        # the only valid CDs are ABBA CD's!
+        assert(artist.name == "Abba","Could not save a CD made by #{artist.name}")
+      end
+    end
+
+    dancing-queen.artist = nil
+    dancing-queen.save!  #=> ValidationError
+
+    dancing-queen.artist = abba
+    dancing-queen.save!  #=> true
+
+## Using Model Objects as RDF.rb Objects
+
+All model objects are fully-functional as `RDF::Enumerable`, `RDF::Queryable`,
+and `RDF::Mutable`.  This lets you manipulate objects on the RDF statement
+level.  You can also access attributes that are not defined as properties.
+
+## Support
+
+There are a number of ways to ask for help.  In declining order of likelihood of response:
+
+ * Fork the project and write a failing test, or a pending test for a feature request
+ * You can post issues to the Github issue queue
+ * (there might one day be a google group or other such support channel, but not yet)
+
+## Authors, Development, and License
+
+#### Authors
+ * Ben Lavender <blavender@gmail.com>
+
+#### 'License'
+Spira is free and unemcumbered software released into the public
+domain.  For more information, see the included UNLICENSE file.
+
+#### Contributing
+Fork it on Github and go.  Please make sure you're kosher with the UNLICENSE
+file before contributing.

data/UNLICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org/>

data/VERSION

@@ -0,0 +1 @@
+0.0.1.pre

data/lib/spira.rb

@@ -0,0 +1,40 @@
+require 'rdf'
+
+module Spira
+
+
+  def repositories
+    settings[:repositories] ||= {}
+  end
+  module_function :repositories
+
+  def settings
+    Thread.current[:spira] ||= {}
+  end
+  module_function :settings
+
+  def add_repository(name, klass, *args)
+    repositories[name] = case klass
+      when RDF::Repository
+        klass
+      when Class
+        klass.new(*args)
+      else
+        raise ArgumentError, "Could not add repository #{klass} as #{name}; expected an RDF::Repository or class name"
+     end
+     if (name == :default) && settings[:repositories][name].nil?
+        warn "WARNING: Adding nil default repository"
+     end
+  end
+  alias_method :add_repository!, :add_repository
+  module_function :add_repository, :add_repository!
+
+  def repository(name)
+    repositories[name]
+  end
+  module_function :repository
+
+  autoload :Resource,         'spira/resource'
+
+  class ValidationError < StandardError; end
+end

data/lib/spira/resource.rb

@@ -0,0 +1,26 @@
+module Spira
+  module Resource
+ 
+    autoload :DSL,              'spira/resource/dsl'
+    autoload :ClassMethods,     'spira/resource/class_methods'
+    autoload :InstanceMethods,  'spira/resource/instance_methods'
+    autoload :Validations,      'spira/resource/validations'
+
+    def self.included(child)
+      child.extend DSL
+      child.extend ClassMethods
+      child.instance_eval do
+        class << self
+          attr_accessor :properties, :lists
+        end
+        @properties = {}
+        @lists      = {}
+      end
+    end
+    
+    # This lets including classes reference vocabularies without the RDF:: prefix
+    include RDF
+    include InstanceMethods
+
+  end
+end

data/lib/spira/resource/class_methods.rb

@@ -0,0 +1,87 @@
+module Spira
+ module Resource
+
+   # This module contains all class methods available to a Spira::Resource class
+   #
+   #
+    module ClassMethods
+      def repository=(repo)
+        @repository = repo
+      end
+
+      def repository
+        case @repository_name
+          when nil
+            Spira.repository(:default)
+          else
+            Spira.repository(@repository_name)
+        end
+      end
+
+      def oldrepo
+        case
+          #when !@repository.nil?
+          #  @repository
+          when !@repository_name.nil?
+            Spira.repository(@repository_name) || raise(RuntimeError, "#{self} is configured to use #{@repository_name} as a repository, but was unable to find it.")
+            #@repository = Spira.repository(@repository_name)
+            #if @repository.nil?
+            #  raise RuntimeError, "#{self} is configured to use #{@repository_name} as a repository, but was unable to find it."
+            #end
+            #@repository
+          else
+            @repository = Spira.repository(:default)
+            if @repository.nil? 
+              raise RuntimeError, "#{self} has no configured repository and was unable to find a default repository."
+            end
+            @repository
+        end
+        #@repository
+      end
+
+      def find(identifier)
+        if repository.nil?
+          raise RuntimeError, "#{self} is configured to use #{@repository_name} as a repository, but was unable to find it." 
+        end
+        uri = case identifier
+          when RDF::URI
+            identifier
+          when String
+            raise ArgumentError, "Cannot find #{self} by String without base_uri; RDF::URI required" if self.base_uri.nil?
+            separator = self.base_uri.to_s[-1,1] == "/" ? '' : '/'
+            RDF::URI.parse(self.base_uri.to_s + separator + identifier)
+          else
+            raise ArgumentError, "Cannot instantiate #{self} from #{identifier}, expected RDF::URI or String"
+        end
+        statements = self.repository.query(:subject => uri)
+        if statements.empty?
+          nil
+        else
+          self.new(identifier, :statements => statements) 
+        end
+      end
+ 
+      def count
+        raise TypeError, "Cannot count a #{self} without a reference type URI." if @type.nil?
+        result = repository.query(:predicate => RDF.type, :object => @type)
+        result.count
+      end
+
+      def create(name, attributes = {})
+        # TODO: validate attributes
+        unless @type.nil?
+          if attributes[:type]
+            raise TypeError, "Cannot assign type to new instance of #{self}; this class is associated with #{@type}"
+          end
+          attributes[:type] = @type
+        end
+        resource = self.new(name, attributes)
+      end
+
+      def is_list?(property)
+        @lists.has_key?(property)
+      end
+
+    end
+  end
+end

data/lib/spira/resource/dsl.rb

@@ -0,0 +1,164 @@
+require 'promise'
+
+module Spira
+ module Resource
+
+   # This module contains all user-exposed methods for use in building a model class.
+   # It is used to extend classes that include Spira::Resource.
+   # @see a little bit of magic in Spira::Resource#included as well--some
+   # tricks need class_eval before this module is included.
+   # @see Spira::Resource::ClassMethods for class methods available after class
+   # definition 
+   # @see Spira::Resource::InstanceMethods for instance methods available after
+   # class definition
+    module DSL  
+
+      def default_source(name)
+        @repository_name = name
+        @repository = Spira.repository(name)
+      end
+  
+      def base_uri(uri = nil)
+        @base_uri = uri unless uri.nil?
+        @base_uri
+      end
+      
+      def default_vocabulary(uri)
+        @default_vocabulary = uri
+      end
+
+      def property(name, opts = {} )
+        add_accessors(name,opts,:hash_accessors)
+      end
+
+      def has_many(name, opts = {})
+        add_accessors(name,opts,:hash_accessors)
+        @lists[name] = true
+      end
+
+      def type(uri = nil)
+        unless uri.nil?
+          @type = case uri
+            when RDF::URI
+              uri
+            else
+              raise TypeError, "Cannot assign type #{uri} (of type #{uri.class}) to #{self}, expected RDF::URI"
+          end
+        end
+        @type
+      end
+
+      #
+      # @private
+      def build_value(statement, type)
+        case
+          when statement == nil
+            nil
+          when type == String
+            statement.object.object.to_s
+          when type == Integer
+            statement.object.object
+          when type.is_a?(Symbol)
+            klass = Kernel.const_get(type.to_s.capitalize)
+            raise TypeError, "#{klass} is not a Spira Resource (referenced as #{type} by #{self}" unless klass.ancestors.include? Spira::Resource
+            promise { klass.find(statement.object) || klass.create(statement.object) }
+        end
+      end
+
+      # @private
+      def build_rdf_value(value, type)
+        case
+          when value.class.ancestors.include?(Spira::Resource)
+            value.uri
+          when type == nil
+            value
+          when type == RDF::URI && value.is_a?(RDF::URI)
+            value
+          when type.is_a?(RDF::URI)
+            RDF::Literal.new(value, :datatype => type)
+          else
+            RDF::Literal.new(value)
+        end
+      end
+
+      private
+
+      def add_accessors(name, opts, accessors_method)
+        predicate = case
+          when opts[:predicate]
+            opts[:predicate]
+          when @default_vocabulary.nil?
+            raise TypeError, "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
+
+        type = opts[:type] || String
+        @properties[name] = {}
+        @properties[name][:predicate] = predicate
+        @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
+
+      def hash_accessors(name, predicate, type)
+        setter = lambda do |arg|
+          attribute_set(name,arg)
+        end
+
+        getter = lambda do
+          attribute_get(name)
+        end
+
+        [getter, setter]
+      end
+
+      def list_accessors(name, predicate, type)
+
+        setter = lambda do |arg|
+          old = @repo.query(:subject => @uri, :predicate => predicate)
+          @repo.delete(*old.to_a) unless old.empty?
+          new = []
+          arg.each do |value|
+            value = self.class.build_rdf_value(value, type)
+            new << RDF::Statement.new(@uri, predicate, value)
+          end
+          @repo.insert(*new)
+        end
+
+        getter = lambda do
+          values = []
+          statements = @repo.query(:subject => @uri, :predicate => predicate)
+          statements.each do |statement|
+            values << self.class.build_value(statement, type)
+          end
+          values
+        end
+
+        [getter, setter]
+      end
+
+      def single_accessors(name, predicate, type)
+        setter = lambda do |arg|
+          old = @repo.query(:subject => @uri, :predicate => predicate)
+          @repo.delete(*old.to_a) unless old.empty?
+          arg = self.class.build_rdf_value(arg, type)
+          @repo.insert(RDF::Statement.new(@uri, predicate, arg))
+        end
+
+        getter = lambda do
+          statement = @repo.query(:subject => @uri, :predicate => predicate).first
+          self.class.build_value(statement, type)
+        end
+
+        [getter, setter]
+      end
+
+    end
+  end
+end

data/lib/spira/resource/instance_methods.rb

@@ -0,0 +1,175 @@
+require 'rdf/isomorphic'
+
+module Spira
+  module Resource
+    module InstanceMethods 
+  
+      attr_reader :uri
+
+      # Initialize a new instance of a spira resource.
+      # The new instance can be instantiated with an opts[:statements] or opts[:attributes], but not both.
+      def initialize(identifier, opts = {})
+       
+        @attributes = {}
+
+        if identifier.is_a? RDF::URI
+          @uri = identifier
+        else
+          if (self.class.base_uri)
+            separator = self.class.base_uri.to_s[-1,1] == "/" ? '' : '/'
+            @uri = RDF::URI.parse(self.class.base_uri.to_s + separator + identifier)
+          else
+            raise ArgumentError, "#{self.class} has no base URI configured, and can thus only be created using RDF::URIs (got #{identifier.inspect})"
+          end
+        end
+
+        #@repo = RDF::Repository.new
+        #@repo.insert(*(opts[:statements])) unless opts[:statements].nil?
+        #@repo.insert(*[RDF::Statement.new(@uri, RDF.type, opts[:type])]) if opts[:type]
+
+        #  If we got statements, we are being loaded, not created
+        if opts[:statements]
+          # Set attributes for each statement corresponding to a predicate
+          self.class.properties.each do |name, property|
+            if self.class.is_list?(name)
+              values = []
+              statements = opts[:statements].query(:subject => @uri, :predicate => property[:predicate])
+              unless statements.nil?
+                statements.each do |statement|
+                  values << self.class.build_value(statement,property[:type])
+                end
+              end
+              attribute_set(name, values)
+            else
+              statement = opts[:statements].query(:subject => @uri, :predicate => property[:predicate]).first
+              attribute_set(name, self.class.build_value(statement, property[:type]))
+            end
+          end
+        else
+          self.class.properties.each do |name, predicate|
+            attribute_set(name, opts[name]) unless opts[name].nil?
+          end
+
+        end
+
+
+        #@repo = RDF::Repository.new
+        #@repo.insert(*(opts[:statements])) unless opts[:statements].nil?
+        #@repo.insert(*[RDF::Statement.new(@uri, RDF.type, opts[:type])]) if opts[:type]
+  
+        #self.class.properties.each do |name, predicate|
+        #  send(((name.to_s)+"=").to_sym, opts[name]) unless opts[name].nil?
+        #end
+        @original_attributes = @attributes.dup
+        @original_attributes.each do | name, value |
+          @original_attributes[name] = value.dup if value.is_a?(Array)
+        end
+      end
+    
+      def _destroy_attributes(attributes)
+        repository = repository_for_attributes(attributes)
+        self.class.repository.delete(*repository)
+      end
+  
+      def destroy!
+        _destroy_attributes(@attributes)
+      end
+
+      def save!
+        if self.class.repository.nil?
+          raise RuntimeError, "#{self} is configured to use #{@repository_name} as a repository, but was unable to find it." 
+        end
+        if respond_to?(:validate)
+          errors.clear
+          validate
+          if errors.empty?
+            _update!
+          else
+            raise(ValidationError, "Could not save #{self.inspect} due to validation errors: " + errors.join(';'))
+          end
+        else
+          _update!
+        end
+      end
+
+      def _update!
+        _destroy_attributes(@original_attributes)
+        self.class.repository.insert(*self)
+        @original_attributes = @attributes.dup
+      end
+  
+      def type
+        self.class.type
+      end
+  
+      def type=(type)
+        raise TypeError, "Cannot reassign RDF.type for #{self}; consider appending to a has_many :types"
+      end
+  
+      def inspect
+        "<#{self.class}:#{self.object_id} uri: #{@uri}>"
+      end
+  
+      def each(*args, &block)
+        repository = repository_for_attributes(@attributes)
+        repository.insert(RDF::Statement.new(@uri, RDF.type, type)) unless type.nil?
+        if block_given?
+          repository.each(*args, &block)
+        else
+          ::Enumerable::Enumerator.new(self, :each)
+        end
+      end
+
+      def attribute_set(name, value)
+        @attributes[name] = value
+      end
+
+      def attribute_get(name)
+        case self.class.is_list?(name)
+          when true
+            @attributes[name] ||= []
+          when false   
+            @attributes[name]
+        end
+      end
+
+      def repository_for_attributes(attributes)
+        repo = RDF::Repository.new
+        attributes.each do | name, attribute |
+          if self.class.is_list?(name)
+            #old = @repo.query(:subject => @uri, :predicate => predicate)
+            #@repo.delete(*old.to_a) unless old.empty?
+            new = []
+            attribute.each do |value|
+              value = self.class.build_rdf_value(value, self.class.properties[name][:type])
+              new << RDF::Statement.new(@uri, self.class.properties[name][:predicate], value)
+            end
+            repo.insert(*new)
+          else
+            value = self.class.build_rdf_value(attribute, self.class.properties[name][:type])
+            repo.insert(RDF::Statement.new(@uri, self.class.properties[name][:predicate], value))
+          end
+        end
+        repo
+      end
+
+      def ==(other)
+        case other
+          # TODO: define behavior for equality on subclasses.  also subclasses.
+          when self.class
+            @uri == other.uri 
+          when RDF::Enumerable
+            self.isomorphic_with?(other)
+          else
+            false
+        end
+      end
+
+
+      include ::RDF::Enumerable, ::RDF::Queryable
+
+      include Spira::Resource::Validations
+
+    end  
+  end
+end

data/lib/spira/resource/validations.rb

@@ -0,0 +1,23 @@
+module Spira
+  module Resource
+    module Validations
+
+      def errors
+        @errors ||= []
+      end
+
+      def assert(boolean, message)
+        errors.push(message) unless boolean
+      end
+
+      def assert_set(name)
+        assert(!(self.send(name).nil?), "#{name.to_s} cannot be nil")
+      end
+
+      def assert_numeric(name)
+        assert(self.send(name).is_a?(Numeric), "#{name.to_s} must be numeric (was #{self.send(name)})")
+      end
+
+    end
+  end
+end

metadata

@@ -0,0 +1,162 @@
+--- !ruby/object:Gem::Specification 
+name: spira
+version: !ruby/object:Gem::Version 
+  prerelease: true
+  segments: 
+  - 0
+  - 0
+  - 1
+  - pre
+  version: 0.0.1.pre
+platform: ruby
+authors: 
+- Ben Lavender
+autorequire: 
+bindir: 
+- bin
+cert_chain: []
+
+date: 2010-04-17 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rdf-spec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 0
+        version: 0.1.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 3
+        - 0
+        version: 1.3.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 5
+        - 3
+        version: 0.5.3
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rdf
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 0
+        version: 0.1.0
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rdf-isomorphic
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 2
+        version: 0.1.2
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: promise
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        - 0
+        version: 0.1.0
+  type: :runtime
+  version_requirements: *id006
+description: Spira is a framework for using the information in RDF.rb repositories as model objects.
+email: blavender@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- AUTHORS
+- README
+- UNLICENSE
+- VERSION
+- lib/spira/resource/class_methods.rb
+- lib/spira/resource/dsl.rb
+- lib/spira/resource/instance_methods.rb
+- lib/spira/resource/validations.rb
+- lib/spira/resource.rb
+- lib/spira/type.rb
+- lib/spira/types/boolean.rb
+- lib/spira.rb
+has_rdoc: false
+homepage: http://spira.rubyforge.org
+licenses: 
+- Public Domain
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 8
+      - 2
+      version: 1.8.2
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
+requirements: []
+
+rubyforge_project: spira
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A framework for using the information in RDF.rb repositories as model objects.
+test_files: []
+