rdf 3.1.11 → 3.2.1

data/lib/rdf/query/solutions.rb

@@ -78,16 +78,25 @@ module RDF; class Query
     end
 
     ##
-    # Returns `true` if this solution sequence contains bindings for any of
+    # @overload variable?
+    #   Returns `false`.
+    #
+    #   @return [Boolean]
+    # @overload variable?(variables)
+    #   Returns `true` if this solution sequence contains bindings for any of
     # the given `variables`.
     #
-    # @param  [Array<Symbol, #to_sym>] variables
-    #   an array of variables to check
-    # @return [Boolean] `true` or `false`
+    #   @param  [Array<Symbol, #to_sym>] variables
+    #   @return [Boolean]
     # @see    RDF::Query::Solution#variable?
     # @see    RDF::Query#execute
-    def variable?(variables)
-      self.any? { |solution| solution.variables?(variables) }
+    def variable?(*args)
+      case args.length
+      when 0 then false
+      when 1
+        self.any? { |solution| solution.variables?(args.first) }
+      else raise ArgumentError("wrong number of arguments (given #{args.length}, expected 0 or 1)")
+      end
     end
     alias_method :variables?, :variable?
     alias_method :have_variables?, :variable?

data/lib/rdf/query/variable.rb

@@ -87,13 +87,27 @@ class RDF::Query
     end
 
     ##
-    # Returns `true`.
+    # @overload variable?
+    #   Returns `true` if `self` is a {RDF::Query::Variable}, or does it contain a variable?
     #
-    # @return [Boolean]
-    # @see    RDF::Term#variable?
+    #   @return [Boolean]
+    # @overload variable?(variable)
+    #   Returns `true` if `self` contains the given variable.
+    #
+    #   @param  [RDF::Resource] value
+    #   @return [Boolean]
     # @since  0.1.7
-    def variable? 
-      true
+    def variable?(*args)
+      case args.length
+      when 0 then true
+      when 1
+        case variable = args.first
+        when RDF::Query::Variable then self == variable
+        when Symbol then to_sym == variable
+        else false
+        end
+      else raise ArgumentError("wrong number of arguments (given #{args.length}, expected 0 or 1)")
+      end
     end
 
     ##

data/lib/rdf/query.rb

@@ -443,11 +443,22 @@ module RDF
     end
 
     ##
-    # Returns `true` if any pattern contains a variable.
+    # @overload variable?
+    #   Returns `true` if any pattern contains a variable.
     #
-    # @return [Boolean]
-    def variable?
-      !variables.empty?
+    #   @return [Boolean]
+    # @overload variable?(variables)
+    #   Returns `true` if any pattern contains any of the variables.
+    #
+    #   @param  [Array<Symbol, #to_sym>] variables
+    #   @return [Boolean]
+    def variable?(*args)
+      case args.length
+      when 0 then !variables.empty?
+      when 1
+        patterns.any? {|p| p.variable?(*args)}
+      else raise ArgumentError("wrong number of arguments (given #{args.length}, expected 0 or 1)")
+      end
     end
     alias_method :variables?, :variable?
     alias_method :has_variables?, :variable?

data/lib/rdf/reader.rb

@@ -647,7 +647,7 @@ module RDF
     ##
     # @return [String]
     def readline
-      @line = @line_rest || @input.readline
+      @line = instance_variable_defined?(:@line_rest) && @line_rest || @input.readline
       @line, @line_rest = @line.split("\r", 2)
       @line = String.new if @line.nil? # not frozen
       @line.chomp!

data/lib/rdf/repository.rb

@@ -243,17 +243,16 @@ module RDF
     #
     # @see RDF::Repository
     module Implementation
-      require 'hamster'
       DEFAULT_GRAPH = false
 
       ##
       # @private
       def self.extend_object(obj)
         obj.instance_variable_set(:@data, obj.options.delete(:data) || 
-                                          Hamster::Hash.new)
+                                          Hash.new)
         obj.instance_variable_set(:@tx_class, 
                                   obj.options.delete(:transaction_class) || 
-                                  SerializedTransaction)
+                                  RDF::Transaction::SerializedTransaction)
         super
       end
 
@@ -263,7 +262,6 @@ module RDF
       def supports?(feature)
         case feature.to_sym
         when :graph_name       then @options[:with_graph_name]
-        when :inference        then false  # forward-chaining inference
         when :validity         then @options.fetch(:with_validity, true)
         when :literal_equality then true
         when :atomic_write     then true
@@ -287,10 +285,22 @@ module RDF
       end
       
       ##
-      # @private
-      # @see RDF::Enumerable#graph?      
-      def graph?(graph)
-        @data.key?(graph)
+      # @overload graph?
+      #   Returns `false` to indicate that this is not a graph.
+      #
+      #   @return [Boolean]
+      # @overload graph?(name)
+      #   Returns `true` if `self` contains the given RDF graph_name.
+      #
+      #   @param  [RDF::Resource, false] graph_name
+      #     Use value `false` to query for the default graph_name
+      #   @return [Boolean]
+      def graph?(*args)
+        case args.length
+        when 0 then false
+        when 1 then @data.key?(args.first)
+        else raise ArgumentError("wrong number of arguments (given #{args.length}, expected 0 or 1)")
+        end
       end
       alias_method :has_graph?, :graph?
 
@@ -322,8 +332,12 @@ module RDF
       # @overload statement?(statement)
       #   @private
       #   @see    RDF::Enumerable#statement?
-      def statement?(statement = nil)
-        statement && statement_in?(@data, statement)
+      def statement?(*args)
+        case args.length
+        when 0 then false
+        when 1 then args.first && statement_in?(@data, args.first)
+        else raise ArgumentError("wrong number of arguments (given #{args.length}, expected 0 or 1)")
+        end
       end
       alias_method :has_statement?, :statement?
 
@@ -365,7 +379,7 @@ module RDF
       ##
       # @see RDF::Dataset#isolation_level
       def isolation_level
-        :serializable
+        :snapshot
       end
 
       ##
@@ -455,7 +469,7 @@ module RDF
       # @private
       # @see RDF::Mutable#clear
       def clear_statements
-        @data = @data.clear
+        @data = @data.class.new
       end
 
       ##
@@ -497,14 +511,11 @@ module RDF
         unless statement_in?(data, statement)
           s, p, o, c = statement.to_quad
           c ||= DEFAULT_GRAPH
-          
-          return data.put(c) do |subs|
-            (subs || Hamster::Hash.new).put(s) do |preds|
-              (preds || Hamster::Hash.new).put(p) do |objs|
-                (objs || Hamster::Hash.new).put(o, statement.options)
-              end
-            end
-          end
+
+          data          = data.has_key?(c)       ? data.dup       : data.merge(c => {})
+          data[c]       = data[c].has_key?(s)    ? data[c].dup    : data[c].merge(s => {})
+          data[c][s]    = data[c][s].has_key?(p) ? data[c][s].dup : data[c][s].merge(p => {})
+          data[c][s][p] = data[c][s][p].merge(o => statement.options)
         end
         data
       end
@@ -513,93 +524,18 @@ module RDF
       # @private
       # @return [Hamster::Hash] a new, updated hamster hash 
       def delete_from(data, statement)
-        if statement_in?(data, statement)
+        if has_statement_in?(data, statement)
           s, p, o, g = statement.to_quad
           g = DEFAULT_GRAPH unless supports?(:graph_name)
           g ||= DEFAULT_GRAPH
 
-          os   = data[g][s][p].delete(o)
-          ps   = os.empty? ? data[g][s].delete(p) : data[g][s].put(p, os)
-          ss   = ps.empty? ? data[g].delete(s)    : data[g].put(s, ps)
-          return ss.empty? ? data.delete(g) : data.put(g, ss)
+          os   = data[g][s][p].dup.delete_if {|k,v| k == o}
+          ps   = os.empty? ? data[g][s].dup.delete_if {|k,v| k == p} : data[g][s].merge(p => os)
+          ss   = ps.empty? ? data[g].dup.delete_if    {|k,v| k == s} : data[g].merge(s => ps)
+          return ss.empty? ? data.dup.delete_if       {|k,v| k == g} : data.merge(g => ss)
         end
         data
       end
-
-      ##
-      # A transaction for the Hamster-based `RDF::Repository::Implementation` 
-      # with full serializability.
-      # 
-      # @todo refactor me!
-      # @see RDF::Transaction
-      class SerializedTransaction < Transaction
-        ##
-        # @see Transaction#initialize
-        def initialize(*args, **options, &block)
-          super(*args, **options, &block)
-          @base_snapshot = @snapshot
-        end
-        
-        ##
-        # Inserts the statement to the transaction's working snapshot.
-        #
-        # @see Transaction#insert_statement
-        def insert_statement(statement)
-          @snapshot = @snapshot.class
-            .new(data: @snapshot.send(:insert_to, 
-                                      @snapshot.send(:data), 
-                                      process_statement(statement)))
-        end
-
-        ##
-        # Deletes the statement from the transaction's working snapshot.
-        #
-        # @see Transaction#insert_statement
-        def delete_statement(statement)
-          @snapshot = @snapshot.class
-            .new(data: @snapshot.send(:delete_from, 
-                                      @snapshot.send(:data), 
-                                      process_statement(statement)))
-        end
-
-        ##
-        # @see RDF::Dataset#isolation_level
-        def isolation_level
-          :serializable
-        end
-        
-        ##
-        # @note this is a simple object equality check.
-        # 
-        # @see RDF::Transaction#mutated?
-        def mutated?
-          !@snapshot.send(:data).equal?(repository.send(:data))
-        end
-        
-        ##
-        # Replaces repository data with the transaction's snapshot in a safely 
-        # serializable fashion.
-        # 
-        # @note this transaction uses a pessimistic merge strategy which 
-        #   fails the transaction if any data has changed in the repository
-        #   since transaction start time. However, the specific guarantee is 
-        #   softer: multiple concurrent conflicting transactions will not 
-        #   succeed. We may choose to implement a less pessimistic merge 
-        #   strategy as a non-breaking change.
-        # 
-        # @raise [TransactionError] when the transaction can't be merged.
-        # @see Transaction#execute
-        def execute
-          raise TransactionError, 'Cannot execute a rolled back transaction. ' \
-                                  'Open a new one instead.' if @rolledback
-
-          raise TransactionError, 'Error merging transaction. Repository' \
-                                  'has changed during transaction time.' unless 
-            repository.send(:data).equal? @base_snapshot.send(:data)
-
-          repository.send(:data=, @snapshot.send(:data))
-        end
-      end
     end # Implementation
   end # Repository
 end # RDF

data/lib/rdf/transaction.rb

@@ -213,8 +213,12 @@ module RDF
     #   @see RDF::Value#statement?
     # @overload statement?(statement)
     #   @see    RDF::Enumerable#statement?
-    def statement?(statement = nil)
-      statement && read_target.has_statement?(statement)
+    def statement?(*args)
+      case args.length
+      when 0 then false
+      when 1 then read_target.statement?(*args)
+      else raise ArgumentError("wrong number of arguments (given #{args.length}, expected 0 or 1)")
+      end
     end
     alias_method :has_statement?, :statement?
 
@@ -243,7 +247,7 @@ module RDF
     # @raise [TransactionError] if the transaction can't be applied
     def execute
       raise TransactionError, 'Cannot execute a rolled back transaction. ' \
-                              'Open a new one instead.' if @rolledback
+                              'Open a new one instead.' if instance_variable_defined?(:@rolledback) && @rolledback
       @changes.apply(@repository)
     end
 
@@ -318,7 +322,81 @@ module RDF
     end
 
     public
-    
+
+    ##
+    # A transaction with full serializability.
+    # 
+    # @todo refactor me!
+    # @see RDF::Transaction
+    class SerializedTransaction < Transaction
+      ##
+      # @see Transaction#initialize
+      def initialize(*args, **options, &block)
+        super(*args, **options, &block)
+        @base_snapshot = @snapshot
+      end
+      
+      ##
+      # Inserts the statement to the transaction's working snapshot.
+      #
+      # @see Transaction#insert_statement
+      def insert_statement(statement)
+        @snapshot = @snapshot.class
+          .new(data: @snapshot.send(:insert_to, 
+                                    @snapshot.send(:data), 
+                                    process_statement(statement)))
+      end
+
+      ##
+      # Deletes the statement from the transaction's working snapshot.
+      #
+      # @see Transaction#insert_statement
+      def delete_statement(statement)
+        @snapshot = @snapshot.class
+          .new(data: @snapshot.send(:delete_from, 
+                                    @snapshot.send(:data), 
+                                    process_statement(statement)))
+      end
+
+      ##
+      # @see RDF::Dataset#isolation_level
+      def isolation_level
+        :serializable
+      end
+      
+      ##
+      # @note this is a simple object equality check.
+      # 
+      # @see RDF::Transaction#mutated?
+      def mutated?
+        !@snapshot.send(:data).equal?(repository.send(:data))
+      end
+      
+      ##
+      # Replaces repository data with the transaction's snapshot in a safely 
+      # serializable fashion.
+      # 
+      # @note this transaction uses a pessimistic merge strategy which 
+      #   fails the transaction if any data has changed in the repository
+      #   since transaction start time. However, the specific guarantee is 
+      #   softer: multiple concurrent conflicting transactions will not 
+      #   succeed. We may choose to implement a less pessimistic merge 
+      #   strategy as a non-breaking change.
+      # 
+      # @raise [TransactionError] when the transaction can't be merged.
+      # @see Transaction#execute
+      def execute
+        raise TransactionError, 'Cannot execute a rolled back transaction. ' \
+                                'Open a new one instead.' if instance_variable_defined?(:@rolledback) && @rolledback
+
+        raise TransactionError, 'Error merging transaction. Repository' \
+                                'has changed during transaction time.' unless 
+          repository.send(:data).equal? @base_snapshot.send(:data)
+
+        repository.send(:data=, @snapshot.send(:data))
+      end
+    end # SerializedTransaction
+
     ##
     # An error class for transaction failures.
     # 

data/lib/rdf/util/file.rb

@@ -98,7 +98,7 @@ module RDF; module Util
               headers:      response.headers
             }
 
-            remote_document = RemoteDocument.new(response.body, document_options)
+            RemoteDocument.new(response.body, document_options)
           when 300..399
             # Document base is redirected location
             # Location may be relative
@@ -215,7 +215,7 @@ module RDF; module Util
             headers:      response.headers
           }
 
-          remote_document = RemoteDocument.new(response.body, document_options)
+          RemoteDocument.new(response.body, document_options)
         else
           raise IOError, "<#{base_uri}>: #{response.status}"
         end

data/lib/rdf/util/logger.rb

@@ -17,17 +17,20 @@ module RDF; module Util
     # @param [Hash{Symbol => Object}] options
     # @option options [Logger, #<<] :logger
     # @return [Logger, #write, #<<]
-    def logger(**options)
-      logger = options.fetch(:logger, @logger)
-      logger = @options[:logger] if logger.nil? && @options
+    def logger(logger: nil, **options)
+      # Guard against undefined instance variables, which may be a warning if used.
+      @options = {} unless instance_variable_defined?(:@options) || frozen?
+      logger ||= @logger if instance_variable_defined?(:@logger)
+      logger = @options[:logger] if logger.nil? && instance_variable_defined?(:@options) && @options
       if logger.nil?
         # Unless otherwise specified, use $stderr
-        logger = (@options || options)[:logger] = IOWrapper.new($stderr)
+        logger = IOWrapper.new($stderr)
 
         # Reset log_statistics so that it's not inherited across different instances
         logger.log_statistics.clear if logger.respond_to?(:log_statistics)
       end
-      logger = (@options || options)[:logger] = ::Logger.new(::File.open(::File::NULL, "w"))  unless logger # Incase false was used, which is frozen
+      logger = ::Logger.new(::File.open(::File::NULL, "w"))  unless logger # Incase false was used, which is frozen
+      @options[:logger] ||= logger if instance_variable_defined?(:@options)
       logger.extend(LoggerBehavior) unless logger.is_a?(LoggerBehavior)
       logger
     end

data/lib/rdf/vocabulary.rb

@@ -70,7 +70,7 @@ module RDF
       # @return [Enumerator]
       def each(&block)
         if self.equal?(Vocabulary)
-          if @vocabs
+          if instance_variable_defined?(:@vocabs) && @vocabs
             @vocabs.select(&:name).each(&block)
           else
             # This is needed since all vocabulary classes are defined using
@@ -356,7 +356,7 @@ module RDF
       def ontology(*args)
         case args.length
         when 0
-          @ontology
+          @ontology if instance_variable_defined?(:@ontology)
         else
           uri, options = args
           URI.cache.delete(uri.to_s.to_sym)  # Clear any previous entry
@@ -507,7 +507,7 @@ module RDF
         end
 
         # Also include the ontology, if it's not also a property
-        @ontology.each_statement(&block) if @ontology && @ontology != self
+        @ontology.each_statement(&block) if self.ontology && self.ontology != self
       end
 
       ##
@@ -574,6 +574,7 @@ module RDF
           term_defs
         end
 
+        #require 'byebug'; byebug
         # Pass over embedded_defs with anonymous references, once
         embedded_defs.each do |term, attributes|
           attributes.each do |ak, avs|
@@ -1234,16 +1235,16 @@ module RDF
           values = values.map do |value|
             if value.is_a?(Literal) && %w(: comment definition notation note editorialNote).include?(k.to_s)
               "%(#{value.to_s.gsub('(', '\(').gsub(')', '\)')}).freeze"
-            # elsif value.is_a?(RDF::Vocabulary::Term)
-            #  value.to_ruby(indent: indent + "  ")
+            elsif value.node? && value.is_a?(RDF::Vocabulary::Term)
+              "#{value.to_ruby(indent: indent + "  ")}.freeze"
             elsif value.is_a?(RDF::Term)
               "#{value.to_s.inspect}.freeze"
             elsif value.is_a?(RDF::List)
               list_elements = value.map do |u|
                 if u.uri?
                   "#{u.to_s.inspect}.freeze"
-                # elsif u.respond_to?(:to_ruby)
-                #  u.to_ruby(indent: indent + "  ")
+                elsif u.node? && u.respond_to?(:to_ruby)
+                  u.to_ruby(indent: indent + "  ")
                 else
                   "#{u.to_s.inspect}.freeze"
                 end

data/lib/rdf/writer.rb

@@ -516,7 +516,7 @@ module RDF
         when RDF::Literal   then format_literal(term, **options)
         when RDF::URI       then format_uri(term, **options)
         when RDF::Node      then format_node(term, **options)
-        when RDF::Statement then format_embTriple(term, **options)
+        when RDF::Statement then format_quotedTriple(term, **options)
         else nil
       end
     end
@@ -574,7 +574,7 @@ module RDF
     # @return [String]
     # @raise  [NotImplementedError] unless implemented in subclass
     # @abstract
-    def format_embTriple(value, **options)
+    def format_quotedTriple(value, **options)
       raise NotImplementedError.new("#{self.class}#format_statement") # override in subclasses
     end