rdf 3.1.0 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2daf8eddad46785b68f11f655491114ece3425f5af8e283ec5372f186fbf0494
-  data.tar.gz: d84668437ad7b0c703bf0cec3a0c2cd50a25f6a81e4e1b9289b87c33b70fe18f
+  metadata.gz: f11909f850c5c1de088d0fd736267556ea533ec2f14e7245676e0547ff22f4d8
+  data.tar.gz: 4cf062a4eb81399c761e60210dbb7e87a1b778c8aa46161f6086c3819c3b9b23
 SHA512:
-  metadata.gz: 30730b50722a1d159fdc4acc7d226253101a28475925451e0dffd599a20b837146a21202d539125aa513ded6dc7de50c290d570a273963052a4820c304a291eb
-  data.tar.gz: 611b837819f8470547ca79cd6d948201e39c288f2e8f2da25f6c39e557abd5efa4b39b3c549d47f09bd75db53af84de3e46fc43f8ebcbc082245556c0ed06b39
+  metadata.gz: eb6699ee27aceb7eff73b5b15a685abb3501b1de930ed3b5612662c2303af75239d1b76b3c6a0a721bf79577bfa357acefe71084db89851d2619ede8fcfc44cc
+  data.tar.gz: 94c48695d2c77cb6847a88aecabed96e6b31db07e5b7d3a70f43e54afc5d6910d090e41f26fe74e5acff6733f62c3321a6185336928f64d39bf5d3924d366465

data/VERSION

@@ -1 +1 @@
-3.1.0
+3.1.1

data/lib/rdf/changeset.rb

@@ -31,10 +31,11 @@ module RDF
   #
   # @since 2.0.0
   class Changeset
-    include RDF::Mutable
+    # include RDF::Mutable
+    include RDF::Util::Coercions
 
     ##
-    # Applies a changeset to the given mutable RDF::Enumerable .
+    # Applies a changeset to the given {RDF::Mutable} object.
     #
     # @param  [RDF::Mutable] mutable
     # @param  [Hash{Symbol => Object}] options
@@ -98,6 +99,24 @@ module RDF
       false
     end
 
+    ##
+    # Returns `false` as changesets are not {RDF::Writable}.
+    #
+    # @return [Boolean]
+    # @see    RDF::Writable#writable?
+    def writable?
+      false
+    end
+
+    ##
+    # Returns `false` as changesets are not {RDF::Mutable}.
+    #
+    # @return [Boolean]
+    # @see    RDF::Mutable#mutable?
+    def mutable?
+      false
+    end
+
     ##
     # Applies this changeset to the given mutable RDF::Enumerable.
     #
@@ -127,35 +146,77 @@ module RDF
 
     ##
     # Outputs a developer-friendly representation of this changeset to
-    # `stderr`.
+    # `$stderr`.
     #
     # @return [void]
     def inspect!
       $stderr.puts(self.inspect)
     end
 
-    protected
-
     ##
-    # Appends an RDF statement to the sequence to insert when applied.
+    # Returns the sum of both the `inserts` and `deletes` counts.
     #
-    # @param  [RDF::Statement] statement
-    # @return [void]
-    # @see    RDF::Writable#insert_statement
-    def insert_statement(statement)
-      self.inserts << statement
+    # @return [Integer]
+    def count
+      inserts.count + deletes.count
     end
 
+    # Append statements to `inserts`. Statements _should_ be constant
+    # as variable statements will at best be ignored or at worst raise
+    # an error when applied.
+    #
+    # @param statements [Enumerable, RDF::Statement] Some statements
+    # @return [self]
+    def insert(*statements)
+      coerce_statements(statements) do |stmts|
+        append_statements :inserts, stmts
+      end
+
+      self
+    end
+    alias_method :insert!, :insert
+    alias_method :<<, :insert
+
+    # Append statements to `deletes`. Statements _may_ contain
+    # variables, although support will depend on the {RDF::Mutable}
+    # target.
+    #
+    # @param statements [Enumerable, RDF::Statement] Some statements
+    # @return [self]
+    def delete(*statements)
+      coerce_statements(statements) do |stmts|
+        append_statements :deletes, stmts
+      end
+
+      self
+    end
+    alias_method :delete!, :delete
+    alias_method :>>, :delete
+
+    private
+
     ##
-    # Appends an RDF statement to the sequence to delete when applied.
+    # Append statements to the appropriate target. This is a little
+    # shim to go in between the other shim and the target.
     #
-    # @param  [RDF::Statement] statement
-    # @return [void]
-    # @see    RDF::Mutable#delete_statement
-    def delete_statement(statement)
-      self.deletes << statement
+    # @param target [Symbol] the method to send
+    # @param arg [Enumerable, RDF::Statement]
+    #
+    def append_statements(target, arg)
+      # coerce to an enumerator 
+      stmts = case
+              when arg.is_a?(RDF::Statement)
+                [arg]
+              when arg.respond_to?(:each_statement)
+                arg.each_statement
+              when arg.respond_to?(:each)
+                arg
+              else
+                raise ArgumentError, "Invalid statement: #{arg.class}"
+              end
+
+      stmts.each { |s| send(target) << s }
     end
 
-    undef_method :load, :update, :clear
   end # Changeset
 end # RDF

data/lib/rdf/mixin/mutable.rb

@@ -9,6 +9,7 @@ module RDF
     extend  RDF::Util::Aliasing::LateBound
     include RDF::Readable
     include RDF::Writable
+    include RDF::Util::Coercions
 
     ##
     # Returns `true` if `self` is mutable.
@@ -154,20 +155,9 @@ module RDF
     def delete(*statements)
       raise TypeError.new("#{self} is immutable") if immutable?
 
-      statements.map! do |value|
-        case
-          when value.respond_to?(:each_statement)
-            delete_statements(value)
-            nil
-          when (statement = Statement.from(value)).constant?
-            statement
-          else
-            delete_statements(query(value))
-            nil
-        end
+      coerce_statements(statements, query: true, constant: true) do |value|
+        delete_statements(value)
       end
-      statements.compact!
-      delete_statements(statements) unless statements.empty?
 
       return self
     end

data/lib/rdf/mixin/writable.rb

@@ -7,6 +7,7 @@ module RDF
   # @see RDF::Repository
   module Writable
     extend RDF::Util::Aliasing::LateBound
+    include RDF::Util::Coercions
 
     ##
     # Returns `true` if `self` is writable.
@@ -58,26 +59,13 @@ module RDF
     #   @param  [Enumerable<RDF::Statement>] statements
     #   @return [self]
     def insert(*statements)
-      statements.map! do |value|
-        case
-          when value.respond_to?(:each_statement)
-            insert_statements(value)
-            nil
-          when (statement = Statement.from(value))
-            statement
-          else
-            raise ArgumentError.new("not a valid statement: #{value.inspect}")
-        end
-      end
-      statements.compact!
-      insert_statements(statements) unless statements.empty?
+      coerce_statements(statements) { |value| insert_statements value }
 
       return self
     end
     alias_method :insert!, :insert
 
   protected
-
     ##
     # Inserts statements from the given RDF reader into the underlying
     # storage or output stream.

data/lib/rdf/repository.rb

@@ -340,7 +340,14 @@ module RDF
       # @see Mutable#apply_changeset
       def apply_changeset(changeset)
         data = @data
-        changeset.deletes.each { |del| data = delete_from(data, del) }
+        changeset.deletes.each do |del|
+          if del.constant?
+            data = delete_from(data, del)
+          else
+            # we need this condition to handle wildcard statements
+            query_pattern(del) { |stmt| data = delete_from(data, stmt) }
+          end
+        end
         changeset.inserts.each { |ins| data = insert_to(data, ins) }
         @data = data
       end

data/lib/rdf/util.rb

@@ -1,7 +1,8 @@
 module RDF; module Util
-  autoload :Aliasing, 'rdf/util/aliasing'
-  autoload :Cache,    'rdf/util/cache'
-  autoload :File,     'rdf/util/file'
-  autoload :Logger,   'rdf/util/logger'
-  autoload :UUID,     'rdf/util/uuid'
+  autoload :Aliasing,  'rdf/util/aliasing'
+  autoload :Cache,     'rdf/util/cache'
+  autoload :File,      'rdf/util/file'
+  autoload :Logger,    'rdf/util/logger'
+  autoload :UUID,      'rdf/util/uuid'
+  autoload :Coercions, 'rdf/util/coercions'
 end; end

data/lib/rdf/util/coercions.rb

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+module RDF
+  module Util
+    module Coercions
+      # This is a provisional module intended to house input
+      # coercions. Currently the only coercion is a statement
+      # preprocessor that is used in e.g. {RDF::Writable#insert} and
+      # {RDF::Mutable#delete}.
+
+      protected
+
+      ##
+      # Coerce an array of arguments into {RDF::Statement}, or
+      # {RDF::Enumerable} and then yield to a block. Note that this
+      # code was amalgamated from that which was sandwiched around
+      # both {RDF::Writable#insert_statements} and
+      # {RDF::Mutable#delete_statements}. The parameters `query` and
+      # `constant` are therefore present to handle the conditions
+      # where the statements contain wildcards and what to do about
+      # them.
+      # 
+      # @example
+      #  coerce_statements(statements) { |value| do_something(value) }
+      #
+      # @param statements [#map] The arbitrary-ish input to be manipulated
+      # @param query [false, true] Whether to call `query` before the block
+      #  (as expected by {Mutable#delete_statements})
+      # @param constant [false, true] Whether to test if the statements
+      #  are constant (as expected by {Mutable#delete_statements})
+      # @yield [RDF::Statement, RDF::Enumerable] 
+      # @return statements
+      def coerce_statements(statements, query: false, constant: false, &block)
+        raise ArgumentError, 'expecting a block' unless block_given?
+
+        statements = statements.map do |value|
+          case
+          when value.respond_to?(:each_statement)
+            block.call(value)
+            nil
+          when (statement = Statement.from(value)) &&
+              (!constant || statement.constant?)
+            statement
+          when query
+            # XXX note that this only makes sense when the module is include()d
+            block.call(self.query(value))
+            nil
+          else
+            raise ArgumentError, "Not a valid statement: #{value.inspect}"
+          end
+        end.compact
+
+        block.call(statements) unless statements.empty?
+
+        # eh might as well return these
+        statements
+      end
+
+    end
+  end
+end

data/lib/rdf/vocab/xsd.rb

@@ -190,7 +190,7 @@ module RDF
       comment: %(
     boolean represents the values of two-valued logic.
   ).freeze,
-      label: "base64Binary".freeze,
+      label: "boolean".freeze,
       subClassOf: "xsd:anyAtomicType".freeze,
       type: "rdfs:Datatype".freeze
     term :byte,

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdf
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.1.1
 platform: ruby
 authors:
 - Arto Bendiken
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-12-11 00:00:00.000000000 Z
+date: 2020-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: link_header
@@ -80,28 +80,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: rdf-xsd
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: rest-client
   requirement: !ruby/object:Gem::Requirement
@@ -267,6 +267,7 @@ files:
 - lib/rdf/util.rb
 - lib/rdf/util/aliasing.rb
 - lib/rdf/util/cache.rb
+- lib/rdf/util/coercions.rb
 - lib/rdf/util/file.rb
 - lib/rdf/util/logger.rb
 - lib/rdf/util/uuid.rb
@@ -302,7 +303,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.1.1
 signing_key: 
 specification_version: 4
 summary: A Ruby library for working with Resource Description Framework (RDF) data.