rdfs.rb in rdf-reasoner-0.4.0.beta1

- old
+ new

@@ -56,11 +56,11 @@
       when RDF::Statement
         statements = []
         if self.predicate == RDF.type
           if term = (RDF::Vocabulary.find_term(self.object) rescue nil)
             term._entail_subClassOf do |t|
-              statements << RDF::Statement.new(self.to_hash.merge(object: t))
+              statements << RDF::Statement(self.to_hash.merge(object: t))
             end
           end
           #$stderr.puts("subClassf(#{self.predicate.pname}): #{statements.map(&:object).map {|r| r.respond_to?(:pname) ? r.pname : r.to_ntriples}}}")
         end
         statements.each {|s| yield s} if block_given?
@@ -125,11 +125,11 @@
         terms
       when RDF::Statement
         statements = []
         if term = (RDF::Vocabulary.find_term(self.predicate) rescue nil)
           term._entail_subPropertyOf do |t|
-            statements << RDF::Statement.new(self.to_hash.merge(predicate: t))
+            statements << RDF::Statement(self.to_hash.merge(predicate: t))
           end
           #$stderr.puts("subPropertyOf(#{self.predicate.pname}): #{statements.map(&:object).map {|r| r.respond_to?(:pname) ? r.pname : r.to_ntriples}}}")
         end
         statements.each {|s| yield s} if block_given?
         statements
@@ -144,11 +144,11 @@
       case self
       when RDF::Statement
         statements = []
         if term = (RDF::Vocabulary.find_term(self.predicate) rescue nil)
           term.domain.each do |t|
-            statements << RDF::Statement.new(self.to_hash.merge(predicate: RDF.type, object: t))
+            statements << RDF::Statement(self.to_hash.merge(predicate: RDF.type, object: t))
           end
         end
         #$stderr.puts("domain(#{self.predicate.pname}): #{statements.map(&:object).map {|r| r.respond_to?(:pname) ? r.pname : r.to_ntriples}}}")
         statements.each {|s| yield s} if block_given?
         statements
@@ -163,11 +163,11 @@
       case self
       when RDF::Statement
         statements = []
         if object.resource? && term = (RDF::Vocabulary.find_term(self.predicate) rescue nil)
           term.range.each do |t|
-            statements << RDF::Statement.new(self.to_hash.merge(subject: self.object, predicate: RDF.type, object: t))
+            statements << RDF::Statement(self.to_hash.merge(subject: self.object, predicate: RDF.type, object: t))
           end
         end
         #$stderr.puts("range(#{self.predicate.pname}): #{statements.map(&:object).map {|r| r.respond_to?(:pname) ? r.pname : r.to_ntriples}}")
         statements.each {|s| yield s} if block_given?
         statements
@@ -225,43 +225,43 @@
               true  # Don't bother checking for validity
             elsif range.start_with?(RDF::XSD)
               # XSD types are valid if the datatype matches, or they are plain and valid according to the grammar of the range
                 resource.datatype == range ||
                 resource.plain? && RDF::Literal.new(resource.value, datatype: range).valid?
-            elsif range.start_with?(RDF::OGC)
+            elsif range.start_with?(RDF::Vocab::OGC)
               case range
-              when RDF::OGC.boolean_str
-                [RDF::OGC.boolean_str, RDF::XSD.boolean].include?(resource.datatype) ||
+              when RDF::Vocab::OGC.boolean_str
+                [RDF::Vocab::OGC.boolean_str, RDF::XSD.boolean].include?(resource.datatype) ||
                 resource.plain? && RDF::Literal::Boolean.new(resource.value).valid?
-              when RDF::OGC.date_time_str
+              when RDF::Vocab::OGC.date_time_str
                 # Schema.org date based on ISO 8601, mapped to appropriate XSD types for validation
                 case resource
                 when RDF::Literal::Date, RDF::Literal::Time, RDF::Literal::DateTime, RDF::Literal::Duration
                   resource.valid?
                 else
                   ISO_8601.match(resource.value)
                 end
-              when RDF::OGC.determiner_str
+              when RDF::Vocab::OGC.determiner_str
                 # The lexical space: "", "the", "a", "an", and "auto".
                 resource.plain? && (%w(the a an auto) + [""]).include?(resource.value)
-              when RDF::OGC.float_str
+              when RDF::Vocab::OGC.float_str
                 # A string representation of a 64-bit signed floating point number.  Example lexical values include "1.234", "-1.234", "1.2e3", "-1.2e3", and "7E-10".
-                [RDF::OGC.float_str, RDF::Literal::Double, RDF::Literal::Float].include?(resource.datatype) ||
+                [RDF::Vocab::OGC.float_str, RDF::Literal::Double, RDF::Literal::Float].include?(resource.datatype) ||
                 resource.plain? && RDF::Literal::Double.new(resource.value).valid?
-              when RDF::OGC.integer_str
+              when RDF::Vocab::OGC.integer_str
                 resource.is_a?(RDF::Literal::Integer) ||
-                [RDF::OGC.integer_str].include?(resource.datatype) ||
+                [RDF::Vocab::OGC.integer_str].include?(resource.datatype) ||
                 resource.plain? && RDF::Literal::Integer.new(resource.value).valid?
-              when RDF::OGC.mime_type_str
+              when RDF::Vocab::OGC.mime_type_str
                 # Valid mime type strings \(e.g., "application/mp3"\).
-                [RDF::OGC.mime_type_str].include?(resource.datatype) ||
+                [RDF::Vocab::OGC.mime_type_str].include?(resource.datatype) ||
                 resource.plain? && resource.value =~ %r(^[\w\-\+]+/[\w\-\+]+$)
-              when RDF::OGC.string
+              when RDF::Vocab::OGC.string
                 resource.plain?
-              when RDF::OGC.url
+              when RDF::Vocab::OGC.url
                 # A string of Unicode characters forming a valid URL having the http or https scheme.
                 u = RDF::URI(resource.value)
-                resource.datatype == RDF::OGC.url ||
+                resource.datatype == RDF::Vocab::OGC.url ||
                 resource.datatype == RDF::XSD.anyURI ||
                 resource.simple? && u.valid? && u.scheme.to_s =~ /^https?$/
               else
                 # Unknown datatype
                 false
\ No newline at end of file