sparql 1.1.9.1 → 1.99.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4f7b62f9060fc3abb46b979c2bce03fc815fcf5a
-  data.tar.gz: e90b9a87808f7ef03d982c037aad31f07aa3fe32
+  metadata.gz: 2e189418bc1c955e9fe52f7f43c5ae7cbb6f4ece
+  data.tar.gz: 24ea48aaf680166acce769a030f83313bd6c9bc8
 SHA512:
-  metadata.gz: 5f52c7e1ccba444cd171219a950f4a2622c9a75998104aeb16dada9a5fe543203210d6dda485e34cf3f5035287171cf59cb51d8f940e9f0b9f5c7c8a5448519d
-  data.tar.gz: bc73deb551eadb6d1569e7211de0d841deafc8152ae38e2df1963a6a234cb7ba368318529356a1864b77fbd435bee54a382017015fd2b315deb412a6e0238ab7
+  metadata.gz: 3490effdaf0bb46eb1f85b2971b92dd3b94167073f962abc430dde19dfe0e25bca03f05d9fcb9cacc08bc00a0752cd4ed32d3678f61f816b2fcd6fc4f453bb22
+  data.tar.gz: f28f4674050da2bb575f5134e479eaf86472153dac106d1908c281e9df72e94144916b4bde0aeafa10ba29c93a712ae166ae0e316a1972bcbe50c5416a5a0feb

data/VERSION

@@ -1 +1 @@
-1.1.9.1
+1.99.0

data/lib/sinatra/sparql.rb

@@ -60,16 +60,16 @@ module Sinatra
 
         # Contexts
         if repository.is_a?(RDF::Enumerable)
-          contexts = {}
+          graph_names = {}
           repository.each do |statement|
-            contexts[statement.context] ||= 0
-            contexts[statement.context] += 1
+            graph_names[statement.graph_name] ||= 0
+            graph_names[statement.graph_name] += 1
           end
           
-          contexts.each do |name, count|
+          graph_names.each do |name, count|
             bn = RDF::Node.new
             if name
-              # Add named contexts as namedGraphs
+              # Add named graphs as namedGraphs
               g << [ds, sd.join("#namedGraph"), bn]
               g << [bn, RDF.type, sd.join("#NamedGraph")]
               g << [bn, sd.join("#name"), name]

data/lib/sparql/algebra/expression.rb

@@ -264,7 +264,7 @@ module SPARQL; module Algebra
     # Returns `false`.
     #
     # @return [Boolean]
-    def has_blank_nodes?
+    def node?
       false
     end
 

data/lib/sparql/algebra/extensions.rb

@@ -86,8 +86,8 @@ class Array
   # Does this contain any nodes?
   #
   # @return [Boolean]
-  def has_blank_nodes?
-    any?(&:has_blank_nodes?)
+  def node?
+    any?(&:node?)
   end
   def evaluatable?; true; end
   def executable?; false; end
@@ -197,40 +197,6 @@ module RDF::Term
 
   def aggregate?; false; end
 
-  # Term compatibility according to SPARQL
-  #
-  # Compatibility of two arguments is defined as:
-  # * The arguments are simple literals or literals typed as xsd:string
-  # * The arguments are plain literals with identical language tags
-  # * The first argument is a plain literal with language tag and the second argument is a simple literal or literal typed as xsd:string
-  #
-  # @example
-  #     compatible?("abc"	"b")                         #=> true
-  #     compatible?("abc"	"b"^^xsd:string)             #=> true
-  #     compatible?("abc"^^xsd:string	"b")             #=> true
-  #     compatible?("abc"^^xsd:string	"b"^^xsd:string) #=> true
-  #     compatible?("abc"@en	"b")                     #=> true
-  #     compatible?("abc"@en	"b"^^xsd:string)         #=> true
-  #     compatible?("abc"@en	"b"@en)                  #=> true
-  #     compatible?("abc"@fr	"b"@ja)                  #=> false
-  #     compatible?("abc"	"b"@ja)                      #=> false
-  #     compatible?("abc"	"b"@en)                      #=> false
-  #     compatible?("abc"^^xsd:string	"b"@en)          #=> false
-  #
-  # @see http://www.w3.org/TR/sparql11-query/#func-arg-compatibility
-  def compatible?(other)
-    return false unless literal?  && other.literal? && plain? && other.plain?
-
-    dtr = other.datatype
-
-    # * The arguments are simple literals or literals typed as xsd:string
-    # * The arguments are plain literals with identical language tags
-    # * The first argument is a plain literal with language tag and the second argument is a simple literal or literal typed as xsd:string
-    has_language? ?
-      (language == other.language || dtr == RDF::XSD.string) :
-      dtr == RDF::XSD.string
-  end
-
   ##
   # Return the non-destinguished variables contained within this operator
   # @return [Array<RDF::Query::Variable>]
@@ -299,8 +265,8 @@ class RDF::Statement
   # Transform Statement Pattern into an SXP
   # @return [Array]
   def to_sxp_bin
-    if has_context?
-      [:quad, subject, predicate, object, context]
+    if has_graph?
+      [:quad, subject, predicate, object, graph_name]
     else
       [:triple, subject, predicate, object]
     end
@@ -313,7 +279,8 @@ class RDF::Query
   #   Same Context
   # @return [Boolean]
   def ==(other)
-    other.is_a?(RDF::Query) && patterns == other.patterns && context == context
+    # FIXME: this should be graph_name == other.graph_name
+    other.is_a?(RDF::Query) && patterns == other.patterns && graph_name == graph_name
   end
       
   ##
@@ -332,10 +299,10 @@ class RDF::Query
   # @return [Array]
   def to_sxp_bin
     if options[:as_container]
-      [:graph, context] + [patterns.map(&:to_sxp_bin)]
+      [:graph, graph_name] + [patterns.map(&:to_sxp_bin)]
     else
       res = [:bgp] + patterns.map(&:to_sxp_bin)
-      (context ? [:graph, context, res] : res)
+      (graph_name ? [:graph, graph_name, res] : res)
     end
   end
 
@@ -376,8 +343,8 @@ class RDF::Query::Pattern
   # Transform Query Pattern into an SXP
   # @return [Array]
   def to_sxp_bin
-    if has_context?
-      [:quad, subject, predicate, object, context]
+    if has_graph?
+      [:quad, subject, predicate, object, graph_name]
     else
       [:triple, subject, predicate, object]
     end

data/lib/sparql/algebra/operator/add.rb

@@ -45,7 +45,7 @@ module SPARQL; module Algebra
         else
           src.each do |statement|
             statement = statement.dup
-            statement.context = (dest_name unless dest_name == :default)
+            statement.graph_name = (dest_name unless dest_name == :default)
             queryable << statement
           end
         end

data/lib/sparql/algebra/operator/bgp.rb

@@ -3,7 +3,7 @@ module SPARQL; module Algebra
     ##
     # The SPARQL GraphPattern `bgp` operator.
     #
-    # Query with `context` set to false.
+    # Query with `graph_name` set to false.
     #
     # @example
     #   (prefix ((: <http://example/>))
@@ -13,7 +13,7 @@ module SPARQL; module Algebra
     class BGP < Operator
       NAME = [:bgp]
       ##
-      # A `graph` is an RDF::Query with a context.
+      # A `graph` is an RDF::Query with a graph_name.
       #
       # @overload self.new(*patterns)
       #   @param [Array<RDF::Query::Pattern>] patterns
@@ -23,7 +23,7 @@ module SPARQL; module Algebra
       # @yieldreturn [void] ignored
       # @return [RDF::Query]
       def self.new(*patterns, &block)
-        RDF::Query.new(*(patterns + [{context: false}]), &block)
+        RDF::Query.new(*(patterns + [{graph_name: false}]), &block)
       end
     end # BGP
   end # Operator

data/lib/sparql/algebra/operator/clear.rb

@@ -38,16 +38,16 @@ module SPARQL; module Algebra
         case operands.last
         when :default
           queryable.each_graph do |g|
-            g.clear! unless g.context
+            g.clear! unless g.graph_name
           end
         when :named
           queryable.each_graph do |g|
-            g.clear! if g.context
+            g.clear! if g.graph_name
           end
         when :all
           queryable.clear!
         when RDF::URI
-          if g = queryable.each_graph.detect {|c| c.context == operands.last}
+          if g = queryable.each_graph.detect {|c| c.graph_name == operands.last}
             g.clear!
           else
             raise IOError, "clear operation graph does not exist" unless silent

data/lib/sparql/algebra/operator/copy.rb

@@ -50,10 +50,10 @@ module SPARQL; module Algebra
           # Clear destination first
           dest.clear! if dest
 
-          # Copy statements using destination context
+          # Copy statements using destination graph_name
           src.each do |statement|
             statement = statement.dup
-            statement.context = (dest_name unless dest_name == :default)
+            statement.graph_name = (dest_name unless dest_name == :default)
             queryable << statement
           end
         end

data/lib/sparql/algebra/operator/create.rb

@@ -38,7 +38,7 @@ module SPARQL; module Algebra
 
         iri = operands.first
         raise ArgumentError, "clear expected a single IRI" if operands.length != 1 || !iri.is_a?(RDF::URI)
-        if queryable.has_context?(iri)
+        if queryable.has_graph?(iri)
           raise IOError, "create operation graph #{iri.to_ntriples} exists" unless silent
         end
         queryable

data/lib/sparql/algebra/operator/dataset.rb

@@ -141,8 +141,8 @@ module SPARQL; module Algebra
             debug(options) {"=> default data source #{uri}"}
             default_datasets << uri
           end
-          load_opts = {debug: options.fetch(:debug, nil), context: uri, base_uri: uri}
-          unless queryable.has_context?(uri)
+          load_opts = {debug: options.fetch(:debug, nil), graph_name: uri, base_uri: uri}
+          unless queryable.has_graph?(uri)
             debug(options) {"=> load #{uri}"}
             queryable.load(uri.to_s, load_opts)
           end
@@ -154,8 +154,8 @@ module SPARQL; module Algebra
 
         # Create an aggregate based on queryable having just the bits we want
         aggregate = RDF::AggregateRepo.new(queryable)
-        named_datasets.each {|name| aggregate.named(name) if queryable.has_context?(name)}
-        aggregate.default(*default_datasets.select {|name| queryable.has_context?(name)})
+        named_datasets.each {|name| aggregate.named(name) if queryable.has_graph?(name)}
+        aggregate.default(*default_datasets.select {|name| queryable.has_graph?(name)})
         aggregate.query(operands.last, options.merge(depth: options[:depth].to_i + 1), &base)
       end
       

data/lib/sparql/algebra/operator/drop.rb

@@ -41,16 +41,16 @@ module SPARQL; module Algebra
         case operands.last
         when :default
           queryable.each_graph do |g|
-            g.clear! unless g.context
+            g.clear! unless g.graph_name
           end
         when :named
           queryable.each_graph do |g|
-            g.clear! if g.context
+            g.clear! if g.graph_name
           end
         when :all
           queryable.clear!
         when RDF::URI
-          if g = queryable.each_graph.detect {|c| c.context == operands.last}
+          if g = queryable.each_graph.detect {|c| c.graph_name == operands.last}
             g.clear!
           else
             raise IOError, "drop operation graph does not exist" unless silent

data/lib/sparql/algebra/operator/filter.rb

@@ -64,7 +64,7 @@ module SPARQL; module Algebra
       def validate!
         unless (join = operands.last).is_a?(Join) &&
                 join.operands.all? {|op| op.is_a?(RDF::Query)} &&
-                join.operands.map(&:context).uniq.length == 1
+                join.operands.map(&:graph_name).uniq.length == 1
           operands.last.validate!
         end
         self

data/lib/sparql/algebra/operator/graph.rb

@@ -1,10 +1,9 @@
-# FIXME: This depends on an update to RDF::Query#execute to be able to pass the context as an option.
 module SPARQL; module Algebra
   class Operator
     ##
     # The SPARQL GraphPattern `graph` operator.
     #
-    # This is a wrapper to add a `context` to the query, or an array of statements.
+    # This is a wrapper to add a `graph_name` to the query, or an array of statements.
     #
     # @example of a query
     #   (prefix ((: <http://example/>))
@@ -22,7 +21,7 @@ module SPARQL; module Algebra
       
       NAME = [:graph]
       ##
-      # A `graph` is an RDF::Query with a context. It can also be used as a container of statements or patterns, or other queryable operators (see GraphGraphPattern)
+      # A `graph` is an RDF::Query with a graph_name. It can also be used as a container of statements or patterns, or other queryable operators (see GraphGraphPattern)
       #
       # @overload self.new(name, bgp)
       #   @param [RDF::Resource] name
@@ -41,18 +40,18 @@ module SPARQL; module Algebra
         case patterns
         when RDF::Query
           # Record that the argument as a (bgp) for re-serialization back to SSE
-          RDF::Query.new(*(patterns.patterns + [{context: name,}]), &block)
+          RDF::Query.new(*(patterns.patterns + [{graph_name: name,}]), &block)
         when Operator
           super
         else
-          RDF::Query.new(*(patterns + [{context: name, as_container: true}]), &block)
+          RDF::Query.new(*(patterns + [{graph_name: name, as_container: true}]), &block)
         end
       end
 
       ##
       # If the second operand is a Query operator:
       #   Executes this query on the given `queryable` graph or repository.
-      #   Applies the given `context` to the query, limiting the scope of the query to the specified `context`, which may be an `RDF::URI` or `RDF::Query::Variable`.
+      #   Applies the given `graph_name` to the query, limiting the scope of the query to the specified `graph`, which may be an `RDF::URI` or `RDF::Query::Variable`.
       #
       # @param  [RDF::Queryable] queryable
       #   the graph or repository to query
@@ -67,8 +66,8 @@ module SPARQL; module Algebra
       # @see    http://www.w3.org/TR/rdf-sparql-query/#sparqlAlgebra
       def execute(queryable, options = {}, &block)
         debug(options) {"Graph #{operands.first}"}
-        context, query = operands.first, operands.last
-        @solutions = queryable.query(query, options.merge(context: context), &block)
+        graph_name, query = operands.first, operands.last
+        @solutions = queryable.query(query, options.merge(graph_name: graph_name), &block)
       end
       
       ##

data/lib/sparql/algebra/operator/load.rb

@@ -37,7 +37,7 @@ module SPARQL; module Algebra
         raise ArgumentError, "load expected one or two operands, got #{operands.length}" unless [1,2].include?(operands.length)
 
         location, name = operands
-        queryable.load(location, context: name)
+        queryable.load(location, graph_name: name)
       rescue IOError, Errno::ENOENT
         raise unless silent
       ensure

data/lib/sparql/algebra/operator/move.rb

@@ -50,10 +50,10 @@ module SPARQL; module Algebra
           # Clear destination first
           dest.clear! if dest
 
-          # Copy statements using destination context
+          # Copy statements using destination graph
           src.each do |statement|
             statement = statement.dup
-            statement.context = (dest_name unless dest_name == :default)
+            statement.graph_name = (dest_name unless dest_name == :default)
             queryable << statement
           end
 

data/lib/sparql/algebra/operator/path.rb

@@ -34,7 +34,7 @@ module SPARQL; module Algebra
         path_op.execute(queryable, options.merge(
           subject: subject,
           object: object,
-          context: options.fetch(:context, false),
+          graph_name: options.fetch(:graph_name, false),
           depth: options[:depth].to_i + 1)
         ) do |solution|
           @solutions << solution

data/lib/sparql/algebra/operator/with.rb

@@ -20,7 +20,7 @@ module SPARQL; module Algebra
       ##
       # Executes this upate on the given `writable` graph or repository.
       #
-      # Effectively filters results by setting a default `__context__` variable so that it is used when binding to perform update operations on the appropriate triples.
+      # Effectively filters results by setting a default `__graph_name__` variable so that it is used when binding to perform update operations on the appropriate triples.
       #
       # @param  [RDF::Queryable] queryable
       #   the graph or repository to write
@@ -38,20 +38,20 @@ module SPARQL; module Algebra
         # Bound variable
         name = operands.shift
 
-        unless queryable.has_context?(name)
+        unless queryable.has_graph?(name)
           debug(options) {"=> default data source #{name}"}
           load_opts = {debug: options.fetch(:debug, nil), base_uri: name}
           debug(options) {"=> load #{name}"}
           queryable.load(name.to_s, load_opts)
         end
 
-        # Set name for RDF::Graph descendants having no context to the name variable
+        # Set name for RDF::Graph descendants having no graph_name to the name variable
         each_descendant do |op|
           case op
           when RDF::Query, RDF::Query::Pattern
-            unless op.context
-              debug(options) {"set context on #{op.to_sse}"}
-              op.context = RDF::Query::Variable.new(:__context__, name)
+            unless op.graph_name
+              debug(options) {"set graph_name on #{op.to_sse}"}
+              op.graph_name = RDF::Query::Variable.new(:__graph_name__, name)
             end
           end
         end

data/lib/sparql/algebra/operator.rb

@@ -442,9 +442,9 @@ module SPARQL; module Algebra
     # otherwise.
     #
     # @return [Boolean]
-    def has_blank_nodes?
+    def node?
       operands.any? do |operand|
-        operand.respond_to?(:has_blank_nodes?) ? operand.has_blank_nodes? : operand.node?
+        operand.respond_to?(:node?) ? operand.node? : operand.node?
       end
     end
 

data/lib/sparql/algebra/query.rb

@@ -40,7 +40,7 @@ module SPARQL; module Algebra
     #   any additional keyword options
     # @option options [Boolean] debug
     #   Query execution debugging
-    # @option options [RDF::Term, RDF::Query::Variable] :context
+    # @option options [RDF::Term, RDF::Query::Variable] :graph_name
     # @yield  [solution]
     #   each matching solution, statement or boolean
     # @yieldparam  [RDF::Statement, RDF::Query::Solution, Boolean] solution
@@ -54,12 +54,12 @@ module SPARQL; module Algebra
       raise NotImplementedError, "#{self.class}#execute(#{queryable})"
     end
 
-    # Add context to sub-items, unless they already have a context
+    # Add graph_name to sub-items, unless they already have a graph_name
     # @param [RDF::URI, RDF::Query::Variable] value
     # @return [RDF::URI, RDF::Query::Variable]
-    def context=(value)
+    def graph_name=(value)
       operands.each do |operand|
-        operand.context = value if operand.respond_to?(:context) && operand.context != false
+        operand.graph_name = value if operand.respond_to?(:graph_name) && operand.graph_name != false
       end
       value
     end

data/lib/sparql/algebra/update.rb

@@ -43,12 +43,12 @@ module SPARQL; module Algebra
       raise NotImplementedError, "#{self.class}#execute(#{queryable})"
     end
 
-    # Add context to sub-items, unless they already have a context
+    # Add graph_name to sub-items, unless they already have a graph_name
     # @param [RDF::URI, RDF::Query::Variable] value
     # @return [RDF::URI, RDF::Query::Variable]
-    def context=(value)
+    def graph_name=(value)
       operands.each do |operand|
-        operand.context = value if operand.respond_to?(:context) && operand.context != false
+        operand.graph_name = value if operand.respond_to?(:graph_name) && operand.graph_name != false
       end
       value
     end

data/lib/sparql/grammar/parser11.rb

@@ -476,28 +476,39 @@ module SPARQL::Grammar
     end
 
     # [38]	InsertData	::=	"INSERT DATA" QuadData
+    start_production(:InsertData) do |input, data, callback|
+      # Freeze existing bnodes, so that if an attempt is made to re-use such a node, and error is raised
+      self.freeze_bnodes
+    end
     production(:InsertData) do |input, data, callback|
       input[:update_op] = SPARQL::Algebra::Expression(:insertData, data[:pattern])
     end
 
     # [39]	DeleteData	::=	"DELETE DATA" QuadData
+    start_production(:DeleteData) do |input, data, callback|
+      # Generate BNodes instead of non-distinguished variables. BNodes are not legal, but this will generate them rather than non-distinguished variables so they can be detected.
+      self.gen_bnodes
+    end
     production(:DeleteData) do |input, data, callback|
-      raise Error, "DeleteData contains BNode operands: #{data[:pattern].to_sse}" if data[:pattern].first.has_blank_nodes?
+      raise Error, "DeleteData contains BNode operands: #{data[:pattern].to_sse}" if data[:pattern].first.node?
       input[:update_op] = SPARQL::Algebra::Expression(:deleteData, data[:pattern])
     end
 
     # [40]	DeleteWhere	::=	"DELETE WHERE" QuadPattern
     start_production(:DeleteWhere) do |input, data, callback|
       # Generate BNodes instead of non-distinguished variables. BNodes are not legal, but this will generate them rather than non-distinguished variables so they can be detected.
-      self.clear_bnode_cache
+      self.gen_bnodes
     end
     production(:DeleteWhere) do |input, data, callback|
-      raise Error, "DeleteWhere contains BNode operands: #{data[:pattern].to_sse}" if data[:pattern].first.has_blank_nodes?
-      self.nd_var_gen = "0"
+      raise Error, "DeleteWhere contains BNode operands: #{data[:pattern].to_sse}" if data[:pattern].first.node?
+      self.gen_bnodes(false)
       input[:update_op] = SPARQL::Algebra::Expression(:deleteWhere, data[:pattern])
     end
 
     # [41]	Modify	::=	("WITH" iri)? ( DeleteClause InsertClause? | InsertClause) UsingClause* "WHERE" GroupGraphPattern
+    start_production(:Modify) do |input, data, callback|
+      self.clear_bnode_cache
+    end
     production(:Modify) do |input, data, callback|
       query = data[:query].first if data[:query]
       query = SPARQL::Algebra::Expression.for(:using, data[:using], query) if data[:using]
@@ -509,16 +520,21 @@ module SPARQL::Grammar
     # [42]	DeleteClause	::=	"DELETE" QuadPattern
     start_production(:DeleteClause) do |input, data, callback|
       # Generate BNodes instead of non-distinguished variables. BNodes are not legal, but this will generate them rather than non-distinguished variables so they can be detected.
-      self.clear_bnode_cache
+      self.gen_bnodes
     end
     production(:DeleteClause) do |input, data, callback|
-      raise Error, "DeleteClause contains BNode operands: #{data[:pattern].to_sse}" if data[:pattern].first.has_blank_nodes?
-      self.nd_var_gen = "0"
+      raise Error, "DeleteClause contains BNode operands: #{data[:pattern].to_sse}" if data[:pattern].first.node?
+      self.gen_bnodes(false)
       input[:delete] = SPARQL::Algebra::Expression(:delete, data[:pattern])
     end
 
     # [43]	InsertClause	::=	"INSERT" QuadPattern
+    start_production(:InsertClause) do |input, data, callback|
+      # Generate BNodes instead of non-distinguished variables.
+      self.gen_bnodes
+    end
     production(:InsertClause) do |input, data, callback|
+      self.gen_bnodes(false)
       input[:insert] = SPARQL::Algebra::Expression(:insert, data[:pattern])
     end
 
@@ -548,13 +564,13 @@ module SPARQL::Grammar
     # QuadData is like QuadPattern, except without BNodes
     start_production(:QuadData) do |input, data, callback|
       # Generate BNodes instead of non-distinguished variables
-      self.clear_bnode_cache
+      self.gen_bnodes
     end
     production(:QuadData) do |input, data, callback|
       # Transform using statements instead of patterns, and verify there are no variables
       raise Error, "QuadData empty" unless data[:pattern]
       raise Error, "QuadData contains variable operands: #{data[:pattern].to_sse}" if data[:pattern].first.variable?
-      self.nd_var_gen = "0"
+      self.gen_bnodes(false)
       input[:pattern] = data[:pattern]
     end
 
@@ -783,11 +799,11 @@ module SPARQL::Grammar
     # [73]  	ConstructTemplate	  ::=  	'{' ConstructTriples? '}'
     start_production(:ConstructTemplate) do |input, data, callback|
       # Generate BNodes instead of non-distinguished variables
-      self.clear_bnode_cache
+      self.gen_bnodes
     end
     production(:ConstructTemplate) do |input, data, callback|
       # Generate BNodes instead of non-distinguished variables
-      self.nd_var_gen = "0"
+      self.gen_bnodes(false)
       add_prod_datum(:ConstructTemplate, data[:pattern])
       add_prod_datum(:ConstructTemplate, data[:ConstructTemplate])
     end
@@ -1637,12 +1653,26 @@ module SPARQL::Grammar
     # Used for generating BNode labels
     attr_accessor :nd_var_gen
 
-    # Reset the bnode cache, always generating new nodes, and start generating BNodes instead of non-distinguished variables
+    # Generate BNodes, not non-distinguished variables
+    # @param [Boolean] value
+    # @return [void]
+    def gen_bnodes(value = true)
+      @nd_var_gen = value ? false : "0"
+    end
+
+    # Clear cached BNodes
+    # @return [void]
     def clear_bnode_cache
-      @nd_var_gen = false
       @bnode_cache = {}
     end
 
+    # Freeze BNodes, which allows us to detect if they're re-used
+    # @return [void]
+    def freeze_bnodes
+      @bnode_cache ||= {}
+      @bnode_cache.each_value(&:freeze)
+    end
+
     # Generate a BNode identifier
     def bnode(id = nil)
       if @nd_var_gen
@@ -1653,7 +1683,9 @@ module SPARQL::Grammar
           id = @options[:anon_base]
           @options[:anon_base] = @options[:anon_base].succ
         end
-        (@bnode_cache ||= {})[id.to_s] ||= RDF::Node.new(id)
+        @bnode_cache ||= {}
+        raise Error, "Illegal attempt to reuse a BNode" if @bnode_cache[id] && @bnode_cache[id].frozen?
+        @bnode_cache[id] ||= RDF::Node.new(id)
       end
     end
 

data/lib/sparql.rb

@@ -55,11 +55,11 @@ module SPARQL
   # @param  [Hash{Symbol => Object}] options
   # @option options  [RDF::Queryable]  :queryable
   # @option options [RDF::URI, String, Array<RDF::URI, String>] :load_datasets
-  #   One or more URIs used to initialize a new instance of `queryable` in the default context.
+  #   One or more URIs used to initialize a new instance of `queryable` in the default graph.
   # @option options [RDF::URI, String, Array<RDF::URI, String>] :default_graph_uri
-  #   One or more URIs used to initialize a new instance of `queryable` in the default context.
+  #   One or more URIs used to initialize a new instance of `queryable` in the default graph.
   # @option options [RDF::URI, String, Array<RDF::URI, String>] :named_graph_uri
-  #   One or more URIs used to initialize the `queryable` as a named context.
+  #   One or more URIs used to initialize the `queryable` as a named graph.
   # @yield  [solution]
   #   each matching solution, statement or boolean
   # @yieldparam  [RDF::Statement, RDF::Query::Solution, Boolean] solution
@@ -84,7 +84,7 @@ module SPARQL
         queryable.load(uri)
       end
       [options[:named_graph_uri]].flatten.each do |uri|
-        queryable.load(uri, context: uri)
+        queryable.load(uri, graph_name: uri)
       end
     end
     query.execute(queryable, &block)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: sparql
 version: !ruby/object:Gem::Version
-  version: 1.1.9.1
+  version: 1.99.0
 platform: ruby
 authors:
 - Gregg Kellogg
@@ -9,19 +9,13 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-09 00:00:00.000000000 Z
+date: 2015-10-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.1.13
-    - - "<"
       - !ruby/object:Gem::Version
         version: '1.99'
   type: :runtime
@@ -29,12 +23,6 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.1.13
-    - - "<"
       - !ruby/object:Gem::Version
         version: '1.99'
 - !ruby/object:Gem::Dependency
@@ -42,12 +30,6 @@ dependencies:
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.1.0
-    - - "<"
       - !ruby/object:Gem::Version
         version: '1.99'
   type: :runtime
@@ -55,12 +37,6 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 1.1.0
-    - - "<"
       - !ruby/object:Gem::Version
         version: '1.99'
 - !ruby/object:Gem::Dependency
@@ -112,9 +88,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '1.99'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -122,9 +95,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '1.99'
 - !ruby/object:Gem::Dependency
   name: rdf-xsd
   requirement: !ruby/object:Gem::Requirement
@@ -132,9 +102,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '1.99'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -142,9 +109,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '1.99'
 - !ruby/object:Gem::Dependency
   name: sinatra
   requirement: !ruby/object:Gem::Requirement
@@ -200,9 +164,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '1.99'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -210,17 +171,11 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.1'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '1.99'
 - !ruby/object:Gem::Dependency
   name: rdf-spec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
-    - - "<"
       - !ruby/object:Gem::Version
         version: '1.99'
   type: :development
@@ -228,9 +183,6 @@ dependencies:
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.1'
-    - - "<"
       - !ruby/object:Gem::Version
         version: '1.99'
 - !ruby/object:Gem::Dependency