pius-rdfs 0.3.0

data/AUTHORS

@@ -0,0 +1,2 @@
+* Arto Bendiken <arto.bendiken@gmail.com> (Lead developer)
+* Pius Uzamere <pius@alum.mit.edu>

data/README

@@ -0,0 +1,84 @@
+RDFS.rb: RDF Schema Reasoner for Ruby
+=====================================
+
+This is a pure-Ruby forward-chaining inference engine supporting RDFS
+and RDFS++ entailment rules. It is intended to be used together with the
+[RDF.rb](http://rdf.rubyforge.org/) library.
+
+### About RDF Schema (RDFS)
+
+* <http://www.w3.org/TR/rdf-schema/>
+* <http://www.w3.org/TR/rdf-mt/>
+* <http://en.wikipedia.org/wiki/RDF_Schema>
+
+Examples
+--------
+
+    require 'rdfs'
+
+### Defining an RDFS entailment rule class
+
+    # @see http://www.w3.org/TR/rdf-mt/#RDFRules
+    class RDF1 < RDFS::Rule
+      antecedent :uuu, :aaa, :yyy
+      consequent :aaa, RDF.type, RDF.Property
+    end
+
+### Defining an RDFS entailment rule instance
+
+    # @see http://www.w3.org/TR/rdf-mt/#RDFRules
+    rdf1 = RDFS::Rule.new do
+      antecedent :uuu, :aaa, :yyy
+      consequent :aaa, RDF.type, RDF.Property
+    end
+
+Documentation
+-------------
+
+* <http://rdfs.rubyforge.org/>
+
+Download
+--------
+
+To get a local working copy of the development repository, do:
+
+    % git clone git://github.com/bendiken/rdfs.git
+
+Alternatively, you can download the latest development version as a tarball
+as follows:
+
+    % wget http://github.com/bendiken/rdfs/tarball/master
+
+Dependencies
+------------
+
+* [RDF.rb](http://rdf.rubyforge.org/) (>= 0.0.5)
+
+Installation
+------------
+
+The recommended installation method is via RubyGems. To install the latest
+official release from Gemcutter, do:
+
+    % [sudo] gem install rdfs
+
+Resources
+---------
+
+* <http://rdfs.rubyforge.org/>
+* <http://github.com/bendiken/rdfs>
+* <http://gemcutter.org/gems/rdfs>
+* <http://rubyforge.org/projects/rdfs/>
+* <http://raa.ruby-lang.org/project/rdfs/>
+
+Authors
+------
+
+* [Arto Bendiken](mailto:arto.bendiken@gmail.com) - <http://ar.to/>
+* [Pius Uzamere](mailto:pius@alum.mit.edu) - <http://pius.me/>
+
+License
+-------
+
+RDFS.rb is free and unencumbered public domain software. For more
+information, see <http://unlicense.org/> or the accompanying UNLICENSE file.

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.3.0

data/lib/rdfs.rb

@@ -0,0 +1,38 @@
+require 'rubygems'
+require 'rdf'
+require 'rdfs/version'
+# require 'lib/rdfs/semantics'
+# require 'lib/rdfs/rule'
+# require 'lib/rdfs/repository'
+
+##
+# RDF Schema (RDFS) support.
+#
+# @see http://www.w3.org/TR/rdf-schema/
+module RDFS
+  include RDF
+
+  autoload :Reasoner,   'rdfs/reasoner'
+  autoload :Repository, 'rdfs/repository'
+  autoload :Rule,       'rdfs/rule'
+  autoload :Semantics,  'rdfs/semantics'
+
+  ##
+  # @return [#to_s] property
+  # @return [URI]
+  def self.[](property)
+    ::RDF::RDFS[property]
+  end
+
+  ##
+  # @param  [Symbol] property
+  # @return [URI]
+  # @raise  [NoMethodError]
+  def self.method_missing(property, *args, &block)
+    if args.empty?
+      ::RDF::RDFS[property]
+    else
+      super
+    end
+  end
+end

data/lib/rdfs/reasoner.rb

@@ -0,0 +1,7 @@
+module RDFS
+  ##
+  # A rule-based forward-chaining RDFS inference engine.
+  class Reasoner
+    # TODO
+  end
+end

data/lib/rdfs/repository.rb

@@ -0,0 +1,7 @@
+module RDFS
+  ##
+  # An RDF repository with RDFS entailment rules.
+  class Repository < RDF::Repository
+    include RDFS::Semantics
+  end
+end

data/lib/rdfs/rule.rb

@@ -0,0 +1,197 @@
+module RDF
+  class Statement
+    PLACEHOLDERS = (p = [:aaa, :bbb, :ccc, :ddd, :uuu, :vvv, :xxx, :yyy, :zzz]) + p.collect {|pl| RDF::Literal.new(pl)}  + p.collect {|pl| RDF::Node.new(pl)}
+    
+    #TODO: consider moving these methods into the RDF gem instead of reopening RDF::Statement here
+    def with_substitutions(assignment_hash)
+      return self unless assignment_hash
+      statement_hash = to_hash
+      [:subject, :object, :predicate].each { |place_in_statement|
+        bound_variables, variable = assignment_hash.keys, statement_hash[place_in_statement]
+        statement_hash[place_in_statement] = assignment_hash[variable] if bound_variables.collect(&:to_s).include?(variable.to_s)
+        #TODO: fix node equality so I don't need to use to_s above
+        }
+      Statement.new(statement_hash)
+    end
+  
+    def generality
+      to_hash.values.select {|k| PLACEHOLDERS.include? k}.size
+    end
+    
+    def has_placeholder?
+      to_hash.values.detect {|k| PLACEHOLDERS.include? k}
+    end
+    
+    def specificity
+      3-generality
+    end
+  end
+end
+
+module RDFS
+  ##
+  # An RDFS entailment rule.
+  class Rule
+    include RDF
+
+    PLACEHOLDERS = (p = [:aaa, :bbb, :ccc, :ddd, :uuu, :vvv, :xxx, :yyy, :zzz]) + p.collect {|pl| RDF::Literal.new(pl)}  + p.collect {|pl| RDF::Node.new(pl)}
+    
+    # @return [Array<Statement>]
+    attr_reader :antecedents
+
+    # @return [Hash{Symbol => Class}]
+    attr_reader :constraints
+
+    # @return [Array<Statement>]
+    attr_reader :consequents
+
+    ##
+    # @option options [Array<Statement>]      :antecedents ([])
+    # @option options [Hash{Symbol => Class}] :constraints ({})
+    # @option options [Array<Statement>]      :consequents ([])
+    # @yield  [rule]
+    # @yieldparam [Rule]
+    def initialize(options = {}, &block)
+      @antecedents = (@@antecedents[self.class] || []).concat(options[:antecedents] || [])
+      @constraints = (@@constraints[self.class] || {}).merge( options[:constraints] || {})
+      @consequents = (@@consequents[self.class] || []).concat(options[:consequents] || [])
+
+      if block_given?
+        case block.arity
+          when 1 then block.call(self)
+          else instance_eval(&block)
+        end
+      end
+    end
+
+    
+    def match(statement1, statement2=nil, noisy = false)
+      statements = [statement1, statement2].compact      
+      
+      return false unless antecedents.size == statements.size
+      if antecedents.size == 1
+        return false unless (@subs = self.class.unitary_match(antecedents.first, statements.first))
+        return Rule.substitute(consequents, @subs)
+        
+      elsif (implied_assignments = Rule.unitary_match(antecedents_ordered_by_decreasing_specificity.first, statements.first))
+        q = Rule.unitary_match(antecedents_ordered_by_decreasing_specificity.last.with_substitutions(implied_assignments), 
+                               statements.last.with_substitutions(implied_assignments))
+        assignments = q ? q.merge(implied_assignments) : q
+        return Rule.substitute(consequents, assignments)
+      elsif implied_assignments = Rule.unitary_match(antecedents_ordered_by_decreasing_specificity.first, statements.last)
+        q = Rule.unitary_match(antecedents_ordered_by_decreasing_specificity.last.with_substitutions(implied_assignments), 
+                               statements.first.with_substitutions(implied_assignments))
+        assignments = q ? q.merge(implied_assignments) : q
+        return Rule.substitute(consequents, assignments)
+      else
+        return false
+      end
+    end
+    alias_method :[], :match
+  
+  
+    #returns either false or the assignment hash of the match 
+    def self.unitary_match(antecedent, statement)
+      a, s = antecedent.to_hash, statement.to_hash
+      #may need to exclude context
+      bound = {}
+      a.values.zip(s.values) {|antecedent_value, statement_value| 
+        if PLACEHOLDERS.include?(antecedent_value) and !bound[antecedent_value]
+          bound[antecedent_value] = statement_value
+        elsif PLACEHOLDERS.include?(antecedent_value) and bound[antecedent_value]
+          return false unless bound[antecedent_value] == statement_value
+        else
+          return false unless antecedent_value == statement_value
+        end
+        }
+      return bound
+    end
+
+    def antecedents_ordered_by_decreasing_specificity
+      a ||= antecedents.sort_by(&:generality)
+    end
+  
+    def self.substitute(consequents, assignment_hash)
+      return nil if assignment_hash.nil?
+      c = consequents.collect{|c| c.with_substitutions(assignment_hash)}
+      return c.detect(&:has_placeholder?) ? false : c
+      
+      #perhaps add an integrity check to Rule to make sure that the consequents are fully substituted by the antecedents
+    end
+    
+    ##
+    # Defines an antecedent for this rule.
+    #
+    # @param  [Symbol, URI] s
+    # @param  [Symbol, URI] p
+    # @param  [Symbol, URI] o
+    # @return [void]
+    def antecedent(s, p, o)
+      @antecedents << RDF::Statement.new(s, p, o)
+    end
+
+    ##
+    # Defines a type constraint for this rule.
+    #
+    # @param  [Hash{Symbol => Class}] types
+    # @return [void]
+    def constraint(types = {})
+      @constraints.merge!(types)
+    end
+
+    ##
+    # Defines the consequent of this rule.
+    #
+    # @param  [Symbol, URI] s
+    # @param  [Symbol, URI] p
+    # @param  [Symbol, URI] o
+    # @return [void]
+    def consequent(s, p, o)
+      @consequents << RDF::Statement.new(s, p, o)
+    end
+
+    protected
+      @@antecedents = {} # @private
+      @@constraints = {} # @private
+      @@consequents = {} # @private
+
+      ##
+      # @private
+      def self.inherited(subclass)
+        @@antecedents[subclass] = []
+        @@constraints[subclass] = {}
+        @@consequents[subclass] = []
+      end
+
+      ##
+      # Defines an antecedent for this rule class.
+      #
+      # @param  [Symbol, URI] s
+      # @param  [Symbol, URI] p
+      # @param  [Symbol, URI] o
+      # @return [void]
+      def self.antecedent(s, p, o)
+        @@antecedents[self] << RDF::Statement.new(s, p, o)
+      end
+
+      ##
+      # Defines a type constraint for this rule class.
+      #
+      # @param  [Hash{Symbol => Class}] types
+      # @return [void]
+      def self.constraint(types = {})
+        @@constraints[self].merge!(types)
+      end
+
+      ##
+      # Defines the consequent of this rule class.
+      #
+      # @param  [Symbol, URI] s
+      # @param  [Symbol, URI] p
+      # @param  [Symbol, URI] o
+      # @return [void]
+      def self.consequent(s, p, o)
+        @@consequents[self] << RDF::Statement.new(s, p, o)
+      end
+  end
+end

data/lib/rdfs/semantics.rb

@@ -0,0 +1,140 @@
+module RDFS
+  ##
+  # The RDFS entailment rules.
+  #
+  # @see http://www.w3.org/TR/rdf-mt/
+  module Semantics
+    ##
+    # RDF entailment rule `rdf1`.
+    #
+    # @see http://www.w3.org/TR/rdf-mt/#RDFRules
+    class RDF1 < Rule
+      antecedent :uuu, :aaa, :yyy
+      consequent :aaa, RDF.type, RDF.Property
+    end
+
+    ##
+    # RDFS entailment rule `rdfs2` for `rdfs:domain`.
+    #
+    # @see http://www.w3.org/TR/rdf-mt/#RDFSRules
+    class RDFS2 < Rule
+      antecedent :aaa, RDFS.domain, :xxx
+      antecedent :uuu, :aaa, :yyy
+      consequent :uuu, RDF.type, :xxx
+    end
+
+    ##
+    # RDFS entailment rule `rdfs3` for `rdfs:range`.
+    #
+    # @see http://www.w3.org/TR/rdf-mt/#RDFSRules
+    class RDFS3 < Rule
+      antecedent :aaa, RDFS.range, :xxx
+      antecedent :uuu, :aaa, :vvv
+      consequent :vvv, RDF.type, :xxx
+    end
+
+    ##
+    # RDFS entailment rule `rdfs4a`.
+    #
+    # @see http://www.w3.org/TR/rdf-mt/#RDFSRules
+    class RDFS4a < Rule
+      antecedent :uuu, :aaa, :xxx
+      consequent :uuu, RDF.type, RDFS.Resource
+    end
+
+    ##
+    # RDFS entailment rule `rdfs4b`.
+    #
+    # @see http://www.w3.org/TR/rdf-mt/#RDFSRules
+    class RDFS4b < Rule
+      antecedent :uuu, :aaa, :vvv
+      constraint :vvv => RDF::Node
+      consequent :vvv, RDF.type, RDFS.Resource
+    end
+
+    ##
+    # RDFS entailment rule `rdfs5` for `rdfs:subPropertyOf`.
+    #
+    # @see http://www.w3.org/TR/rdf-mt/#RDFSRules
+    class RDFS5 < Rule
+      antecedent :uuu, RDFS.subPropertyOf, :vvv
+      antecedent :vvv, RDFS.subPropertyOf, :xxx
+      consequent :uuu, RDFS.subPropertyOf, :xxx
+    end
+
+    ##
+    # RDFS entailment rule `rdfs6` for `rdfs:subPropertyOf`.
+    #
+    # @see http://www.w3.org/TR/rdf-mt/#RDFSRules
+    class RDFS6 < Rule
+      antecedent :uuu, RDF.type, RDF.Property
+      consequent :uuu, RDFS.subPropertyOf, :uuu
+    end
+
+    ##
+    # RDFS entailment rule `rdfs7` for `rdfs:subPropertyOf`.
+    #
+    # @see http://www.w3.org/TR/rdf-mt/#RDFSRules
+    class RDFS7 < Rule
+      antecedent :aaa, RDFS.subPropertyOf, :bbb
+      antecedent :uuu, :aaa, :yyy
+      consequent :uuu, :bbb, :yyy
+    end
+
+    ##
+    # RDFS entailment rule `rdfs8` for `rdfs:subClassOf`.
+    #
+    # @see http://www.w3.org/TR/rdf-mt/#RDFSRules
+    class RDFS8 < Rule
+      antecedent :uuu, RDF.type, RDFS.Class
+      consequent :uuu, RDFS.subClassOf, RDFS.Resource
+    end
+
+    ##
+    # RDFS entailment rule `rdfs9` for `rdfs:subClassOf`.
+    #
+    # @see http://www.w3.org/TR/rdf-mt/#RDFSRules
+    class RDFS9 < Rule
+      antecedent :uuu, RDFS.subClassOf, :xxx
+      antecedent :vvv, RDF.type, :uuu
+      consequent :vvv, RDF.type, :xxx
+    end
+
+    ##
+    # RDFS entailment rule `rdfs10` for `rdfs:subClassOf`.
+    #
+    # @see http://www.w3.org/TR/rdf-mt/#RDFSRules
+    class RDFS10 < Rule
+      antecedent :uuu, RDF.type, RDFS.Class
+      consequent :uuu, RDFS.subClassOf, :uuu
+    end
+
+    ##
+    # RDFS entailment rule `rdfs11` for `rdfs:subClassOf`.
+    #
+    # @see http://www.w3.org/TR/rdf-mt/#RDFSRules
+    class RDFS11 < Rule
+      antecedent :uuu, RDFS.subClassOf, :vvv
+      antecedent :vvv, RDFS.subClassOf, :xxx
+      consequent :uuu, RDFS.subClassOf, :xxx
+    end
+
+    ##
+    # RDFS entailment rule `rdfs12`.
+    #
+    # @see http://www.w3.org/TR/rdf-mt/#RDFSRules
+    class RDFS12 < Rule
+      antecedent :uuu, RDF.type, RDFS.ContainerMembershipProperty
+      consequent :uuu, RDFS.subPropertyOf, RDFS.member
+    end
+
+    ##
+    # RDFS entailment rule `rdfs13`.
+    #
+    # @see http://www.w3.org/TR/rdf-mt/#RDFSRules
+    class RDFS13 < Rule
+      antecedent :uuu, RDF.type, RDFS.Datatype
+      consequent :uuu, RDFS.subClassOf, RDFS.Literal
+    end
+  end
+end

data/lib/rdfs/version.rb

@@ -0,0 +1,19 @@
+module RDFS
+  module VERSION
+    MAJOR = 0
+    MINOR = 1
+    TINY  = 0
+    EXTRA = nil
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+    STRING << "-#{EXTRA}" if EXTRA
+
+    ##
+    # @return [String]
+    def self.to_s()   STRING end
+
+    ##
+    # @return [String]
+    def self.to_str() STRING end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'pathname'
+require 'rdf'
+require 'rdfs'
+require 'rdfs/rule'
+
+class Pathname
+  def /(path)
+    (self + path).expand_path
+  end
+end # class Pathname
+
+spec_dir_path = Pathname(__FILE__).dirname.expand_path
+require spec_dir_path.parent + 'lib/rdfs'
+
+# # require fixture resources
+Dir[spec_dir_path + "lib/rdfs/*.rb"].each do |fixture_file|
+  require fixture_file
+end
+
+# # require fixture resources
+# Dir[spec_dir_path + "fixtures/*.rb"].each do |fixture_file|
+#   require fixture_file
+# end
+
+
+require 'rspec'
+# optionally add autorun support
+#require 'rspec/autorun'
+
+Rspec.configure do |c|
+  c.mock_with :rspec
+end

data/spec/unit/rule_spec.rb

@@ -0,0 +1,104 @@
+#require 'spec_helper'
+require 'rdf'
+
+require 'rdfs'
+require 'rdfs/rule'
+include RDF
+include ::RDFS::Semantics
+
+describe ::RDF::Statement do
+  it "should be able to substitute a mapping into itself" do
+    statement = Statement.new(:aaa, :xxx, FOAF.person)
+    mapping = {RDF::Node.new(:aaa) => 'rdf:friend', RDF::Node.new(:xxx) => 'rdf:knows'}
+    a = statement.with_substitutions(mapping)
+    a.should eql Statement.new('rdf:friend', 'rdf:knows', FOAF.person)
+  end
+  
+  it "should know its specificity" do
+    a1 = Statement.new(:aaa, RDFS.domain, :xxx)
+    a2 = Statement.new(:uuu, :aaa, :yyy)
+  
+    [a1, a2].collect(&:specificity).should == [1,0]
+    [a1, a2].sort_by(&:specificity).should == [a2,a1]
+  end
+  
+end
+  
+
+describe ::RDFS::Rule do
+  
+  before(:each) do
+    @rule1 = RDF1.new
+    @statement1 = Statement.new('joe:shmoe', 'rdf:jerk', 'schmuck')
+    @matching_statements_1 = [Statement.new('rdf:jerk', RDF.type, RDF.Property)]
+    
+    @rule2 = RDFS2.new
+    @statement2 = Statement.new('rdf:annoys', RDFS.domain, FOAF.person)
+    @statement3 = Statement.new('tom', 'rdf:annoys', 'jerry')
+    @statement4 = Statement.new('tom', RDF.type, FOAF.person)
+  end
+  
+  it "should know its antecedents" do
+    @rule1.antecedents.should eql([Statement.new(:uuu, :aaa, :yyy)])
+  end
+  
+  it "should know its consequents" do
+    @rule1.consequents.should eql([Statement.new(:aaa, RDF.type, RDF.Property)])
+  end
+  
+  it "should be able to substitute a mapping into consequents" do
+    consequents = [Statement.new(:aaa, :xxx, FOAF.person)]
+    mapping = {RDF::Node.new(:aaa) => 'rdf:friend', RDF::Node.new(:xxx) => 'rdf:knows'}
+    a = ::RDFS::Rule.substitute(consequents, mapping)
+    a.should eql [Statement.new('rdf:friend', 'rdf:knows', FOAF.person)]
+  end
+  
+  it "should be able to do unitary matches" do
+    antecedent = Statement.new :uuu, :aaa, :yyy
+    @statement1 = Statement.new('joe:shmoe', 'rdf:jerk', 'schmuck')
+    ::RDFS::Rule.unitary_match(antecedent, @statement1).should be_true
+  end
+
+  it "should not unitary match if non-placeholders are different" do
+    a1 = Statement.new(:aaa, RDFS.domain, :xxx)
+    s1 = Statement.new('rdf:annoys', RDFS.subPropertyOf, FOAF.person)
+    ::RDFS::Rule.unitary_match(a1, s1).should be_false
+  end
+
+    
+  context "should generate consequents from pairs of statements that match the antecedents" do
+    
+    it "with just one antecedent and one consequent" do
+      @rule1[@statement1].should eql(@matching_statements_1)
+      
+      @rule_rdfs4a = RDFS4a.new
+      @statements_matching_rule_rdfs4a = [Statement.new('rdf:annoys', RDF.type, RDFS.Resource)]
+      @rule_rdfs4a[@statement2].should eql @statements_matching_rule_rdfs4a
+    end
+    
+    it "matching should be commutative" do
+      @rule2[@statement2,@statement3].should eql @rule2[@statement3,@statement2]
+    end
+    
+    it "with multiple antecedents and one consequent" do  
+      @rule2 = RDFS2.new
+      @rule2[@statement2,@statement3].should eql([@statement4])
+    end
+
+    it "with multiple antecedents" do
+      @rule2[@statement2,@statement3].should eql [Statement.new('tom', RDF.type, FOAF.person)]
+      @rule2[@statement3,@statement2].should eql [Statement.new('tom', RDF.type, FOAF.person)]
+    end
+
+  end
+    
+  context "should not generate consequents from pairs of statements that don't match the antecedents" do
+    it "with multiple antecedents" do
+      @rule2 = RDFS2.new
+
+      @statement2 = Statement.new('rdf:annoys', RDFS.domain, FOAF.person)
+      d = Statement.new('foo', 'bar', 'baz')
+      @rule2[@statement2,d].should be_false
+    end
+  end
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification 
+name: pius-rdfs
+version: !ruby/object:Gem::Version 
+  hash: -1713379756426313520
+  prerelease: false
+  segments: 
+  - 0
+  - 3
+  - 0
+  version: 0.3.0
+platform: ruby
+authors: 
+- Arto Bendiken
+- Pius Uzamere
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-09 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rdf-spec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 363868379743904425
+        segments: 
+        - 0
+        - 2
+        - 0
+        version: 0.2.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: -2689461885439978514
+        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 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: -1257173255691836839
+        segments: 
+        - 0
+        - 5
+        - 6
+        version: 0.5.6
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rdf
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 363868379743904425
+        segments: 
+        - 0
+        - 2
+        - 0
+        version: 0.2.0
+  type: :runtime
+  version_requirements: *id004
+description: RDFS.rb is a forward-chaining inference engine that implements the RDF Schema (RDFS) entailment rules.
+email: pius@alum.mit.edu
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- AUTHORS
+- README
+- UNLICENSE
+- VERSION
+- lib/rdfs/reasoner.rb
+- lib/rdfs/repository.rb
+- lib/rdfs/rule.rb
+- lib/rdfs/semantics.rb
+- lib/rdfs/version.rb
+- lib/rdfs.rb
+- spec/spec_helper.rb
+- spec/unit/rule_spec.rb
+has_rdoc: true
+homepage: http://rdfs.rubyforge.org/
+licenses: 
+- Public Domain
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -2660243542901265017
+      segments: 
+      - 1
+      - 8
+      - 2
+      version: 1.8.2
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -2953524206653324603
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: rdfs
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A forward-chaining inference engine that implements the RDFS entailment rules.
+test_files: 
+- spec/spec_helper.rb
+- spec/unit/rule_spec.rb