activerdf_net7 1.6.16 → 1.7.0

data/lib/active_rdf/objectmanager/resource_like.rb

@@ -1,4 +1,4 @@
-module RDFS
+module ActiveRDF
   
   # Helper Module that contains same additional methods that
   # are expected from classes that want to behave like
@@ -19,7 +19,7 @@ module RDFS
     end
     
     # NTriple representation of element
-    def to_ntriple
+    def to_literal_s
       "<#{uri}>"
     end
     

data/lib/active_rdf/objectmanager/resource_query.rb

@@ -0,0 +1,85 @@
+module ActiveRDF
+  # Search for resources of a given type, with given property restrictions.
+  # Usage:
+  #   ResourceQuery.new(TEST::Person).execute                                         # find all TEST::Person resources
+  #   ResourceQuery.new(TEST::Person).age.execute                                     # find TEST::Person resources that have the property age
+  #   ResourceQuery.new(TEST::Person).age(27).execute                                 # find TEST::Person resources with property matching the supplied value
+  #   ResourceQuery.new(TEST::Person).age(27,:context => context_resource).execute    # find TEST::Person resources with property matching supplied value and context
+  #   ResourceQuery.new(TEST::Person).email('personal@email','work@email').execute    # find TEST::Person resources with property matching the supplied values
+  #   ResourceQuery.new(TEST::Person).email(['personal@email','work@email']).execute  # find TEST::Person resources with property matching the supplied values
+  #   ResourceQuery.new(TEST::Person).eye('blue').execute(:all_types => true)         # find TEST::Person resources with property matching the supplied value ignoring lang/datatypes
+  #   ResourceQuery.new(TEST::Person).eye(LocalizedString('blue','en')).execute       # find TEST::Person resources with property matching the supplied value
+  #   ResourceQuery.new(TEST::Person).eye(:regex => /lu/).execute                     # find TEST::Person resources with property matching the specified regex
+  #   ResourceQuery.new(TEST::Person).eye(:lang => '@en').execute                     # find TEST::Person resources with property having the specified language
+  #   ResourceQuery.new(TEST::Person).age(:datatype => XSD::Integer).execute          # find TEST::Person resources with property having the specified datatype
+  #   ResourceQuery.new(RDFS::Resource).test::age(27).execute                         # find RDFS::Resources having the fully qualified property and value
+  #   ResourceQuery.new(TEST::Person).age(27).eye(LocalizedString('blue','en')).execute  # chain multiple properties together, ANDing restrictions
+  class ResourceQuery
+    private(:type)
+
+    def initialize(type,context = nil)
+      @ns = nil
+      @type = type
+      @query = Query.new.distinct(:s).where(:s,RDF::type,@type,context)
+      @var_idx = -1
+    end
+
+    def execute(options = {}, &blk)
+      if truefalse(options[:all_types])
+        if @query.filter_clauses.values.any?{|operator,operand| operator == :lang or operator == :datatype}
+          raise ActiveRdfError, "all_types may not be specified in conjunction with any lang or datatype restrictions"
+        end
+        @query = @query.dup.all_types
+      end
+      @query.execute(options, &blk)
+    end
+
+    def method_missing(ns_or_property, *values)
+      # if the namespace has been seen, lookup the property
+      if !@ns and Namespace.include?(ns_or_property)
+        @ns = ns_or_property
+        return self
+      end
+
+      property_name = ns_or_property.to_s
+      property =
+        if @ns
+          Namespace.lookup(@ns, property_name)
+        else
+          @type.instance_predicates.find{|prop| Namespace.localname(prop) == property_name}
+        end
+      raise ActiveRdfError, "no suitable predicate matching '#{property_name}' found. Maybe you are missing some schema information?" unless property
+      @ns = nil
+
+      # restrict by values if provided
+      options = values.extract_options!
+      values.flatten!
+      if values.size > 0 then values.each do |value|
+          @query.where(:s,property,value,options[:context])
+        end
+      # otherwise restrict by property occurance only
+      else
+        var = "rq#{@var_idx += 1}".to_sym
+        @query.where(:s,property,var,options[:context])
+
+        # add filters
+        if options[:lang] && options[:datatype]
+          raise ActiveRdfError, "only lang or datatype may be specified, not both"
+        elsif options[:lang]
+          @query.lang(var,options[:lang])
+        elsif options[:datatype]
+          @query.datatype(var,options[:datatype])
+        end
+        if options[:regex]
+          @query.regex(var,options[:regex])
+        end
+      end
+
+      self
+    end
+
+    def to_s
+      @query.to_s
+    end
+  end
+end

data/lib/active_rdf/queryengine/ntriples_parser.rb

@@ -5,86 +5,93 @@
 require 'uuidtools'
 require 'strscan'
 
-# ntriples parser
-class NTriplesParser
+module ActiveRDF
+  # ntriples parser
+  class NTriplesParser
   def self.parse_node(input, resource_class = RDFS::Resource)
-    case input
-    when MatchBNode
-      resource_class.new("http://www.activerdf.org/bnode/#{UUID.random_create}/#$1")
-    when MatchLiteral
-      value = fix_unicode($1)
-      if $2
-        Literal.typed(value, resource_class.new($2))
-      else
-        value
-      end
-    when MatchResource
-      resource_class.new($1)
-    else
-      nil
-    end
-  end
-
-  # parses an input string of ntriples and returns a nested array of [s, p, o] 
-  # (which are in turn ActiveRDF objects)
-  def self.parse(input)
-    # need unique identifier for this batch of triples (to detect occurence of 
-    # same bnodes _:#1
-    uuid = UUID.random_create.to_s
-
-    input.collect do |triple|
-      nodes = []
-      scanner = StringScanner.new(triple)
-      scanner.skip(/\s+/)
-      while not scanner.eos?
-        nodes << scanner.scan(MatchNode)
-        scanner.skip(/\s+/)
-        scanner.terminate if nodes.size == 3 
-      end
-
-      # handle bnodes if necessary (bnodes need to have uri generated)
-      subject = case nodes[0]
+      case input
       when MatchBNode
-        RDFS::Resource.new("http://www.activerdf.org/bnode/#{uuid}/#$1")
-      when MatchResource
-        RDFS::Resource.new($1)
-      end
-
-      predicate = case nodes[1]
-      when MatchResource
-        RDFS::Resource.new($1)
-      end
-
-      # handle bnodes and literals if necessary (literals need unicode fixing)
-      object = case nodes[2]
-      when MatchBNode
-        RDFS::Resource.new("http://www.activerdf.org/bnode/#{uuid}/#$1")
+      resource_class.new("http://www.activerdf.org/bnode/#{UUIDTools::UUID.random_create}/#$1")
       when MatchLiteral
         value = fix_unicode($1)
         if $2
-          Literal.typed(value, RDFS::Resource.new($2))
+        RDFS::Literal.typed(value, resource_class.new($2))
+        elsif $3
+          LocalizedString.new(value,$3)
         else
           value
         end
       when MatchResource
-        RDFS::Resource.new($1)
+      resource_class.new($1)
+      else
+        nil
       end
+    end
+
+    # parses an input string of ntriples and returns a nested array of [s, p, o]
+    # (which are in turn ActiveRDF objects)
+  def self.parse(input, result_type = RDFS::Resource)
+      # need unique identifier for this batch of triples (to detect occurence of
+      # same bnodes _:#1
+    uuid = UUIDTools::UUID.random_create.to_s
+
+      input.split(/\r|\n/).collect do |triple|
+        next if  triple =~ /^\s*#|^\s*$/
+        nodes = []
+        scanner = StringScanner.new(triple)
+        scanner.skip(/\s+/)
+        while not scanner.eos?
+          nodes << scanner.scan(MatchNode)
+          scanner.skip(/\s+/)
+          scanner.terminate if nodes.size == 3
+        end
+
+        # handle bnodes if necessary (bnodes need to have uri generated)
+        subject = case nodes[0]
+                  when MatchBNode
+        result_type.new("http://www.activerdf.org/bnode/#{uuid}/#$1")
+                  when MatchResource
+        result_type.new($1)
+                  end
+
+        predicate = case nodes[1]
+                    when MatchResource
+        result_type.new($1)
+                    end
 
-      # collect s, p, o into array to be returned
-      [subject, predicate, object]
+        # handle bnodes and literals if necessary (literals need unicode fixing)
+        object = case nodes[2]
+                 when MatchBNode
+        result_type.new("http://www.activerdf.org/bnode/#{uuid}/#$1")
+                 when MatchLiteral
+                   value = fix_unicode($1)
+                   if $2
+          RDFS::Literal.typed(value, result_type.new($2))
+                   elsif $3
+                     LocalizedString.new(value, $3)
+                   else
+                     value
+                   end
+                 when MatchResource
+        result_type.new($1)
+                 end
+
+        # collect s, p, o into array to be returned
+        [subject, predicate, object]
+      end.compact
     end
-  end
 
-  private
-  # constants for extracting resources/literals from sql results
-  MatchNode = Regexp.union(/"(?:\\"|[^"])*"(?:\^\^\S+)?/,/_:\S*/,/<[^>]*>/)
-  MatchBNode = /_:(\S*)/
-  MatchResource = /<([^>]*)>/
-  MatchLiteral = /"((?:\\"|[^"])*)"(?:\^\^<(\S+)>)?/
+    private
+    # constants for extracting resources/literals from sql results
+    MatchBNode = /_:(\S*)/
+    MatchResource = /<([^>]*)>/
+    MatchLiteral = /"((?:\\"|[^"])*)"(?:\^\^<(\S+)>|@(\S+))?/
+    MatchNode = Regexp.union(MatchBNode,MatchResource,MatchLiteral)
 
-  # fixes unicode characters in literals (because we parse them wrongly somehow)
-  def self.fix_unicode(str)
-    tmp = str.gsub(/\\\u([0-9a-fA-F]{4,4})/u){ "U+#$1" }
-    tmp.gsub(/U\+([0-9a-fA-F]{4,4})/u){["#$1".hex ].pack('U*')}
+    # fixes unicode characters in literals (because we parse them wrongly somehow)
+    def self.fix_unicode(str)
+      tmp = str.gsub(/\\\u([0-9a-fA-F]{4,4})/u){ "U+#$1" }
+      tmp.gsub(/U\+([0-9a-fA-F]{4,4})/u){["#$1".hex ].pack('U*')}
+    end
   end
-end
+end