rdf-normalize 0.1.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: d7076dcfeccdbfc0b35ec046d0b338a6ad41d776
-  data.tar.gz: cd5f278797b575a3a6cced04890b9014c2350f42
+SHA256:
+  metadata.gz: 4228bee01dba3de0d611ae8431824ebf1f6f09ae6039a5570ea3e86f4cb8c467
+  data.tar.gz: c932b23a352bf3771a5e426c0976050b128f41473a8ea6cea675c1a7bc26ef5a
 SHA512:
-  metadata.gz: 2510cec72f19af6eef55678382f688a5948b59fad4c6be18465c53a66d16b25bb543dadbd5a5148675d291afac133c8cc7d5399650ad9043b858c1a1f6165291
-  data.tar.gz: f785bd00b4abacf7da181daae96e2101aa449b19791a08742654451cf9a3b25abdf368dd77d99a86c4f74a49084b2d9af6464ea30bbed45589f87713e899ee63
+  metadata.gz: 0d5995bdc3c593385a74ba69bf367c01a2d5b44fd7d0b5aab9f8495ebc14d16c3b709ceff21c2294c951613726190c49eab41098feaac0c2ba350afd25552fc4
+  data.tar.gz: e0e70f5aa3bdfb49bc0679cae8e362fa3191d9452a2ca3aaa004b995622837865dca6d61aaa264407c8fc0d4197fadfbfee6dd91a19cf9e46f399b57e587634c

data/README.md

@@ -15,12 +15,12 @@ to serialize normalized statements.
 Algorithms implemented:
 
 * [URGNA2012](http://json-ld.github.io/normalization/spec/index.html#dfn-urgna2012)
-* [URDNA2014](http://json-ld.github.io/normalization/spec/index.html#dfn-urdna2015)
+* [URDNA2015](http://json-ld.github.io/normalization/spec/index.html#dfn-urdna2015)
 
 Install with `gem install rdf-normalize`
 
 * 100% free and unencumbered [public domain](http://unlicense.org/) software.
-* Compatible with  Ruby >= 1.9.3.
+* Compatible with  Ruby >= 2.4.
 
 ## Usage
 
@@ -38,8 +38,8 @@ Full documentation available on [Rubydoc.info][Normalize doc]
 
 ## Dependencies
 
-* [Ruby](http://ruby-lang.org/) (>= 1.9.2)
-* [RDF.rb](http://rubygems.org/gems/rdf) (~> 1.1)
+* [Ruby](http://ruby-lang.org/) (>= 2.4)
+* [RDF.rb](http://rubygems.org/gems/rdf) (~> 3.1)
 
 ## Installation
 
@@ -79,4 +79,4 @@ see  or the accompanying {file:LICENSE} file.
 [RDF.rb]:       http://rubydoc.info/github/ruby-rdf/rdf-normalize
 [N-Triples]:    http://www.w3.org/TR/rdf-testcases/#ntriples
 [RDF Normalize]:http://json-ld.github.io/normalization/spec/
-[Normalize doc]:http://rubydoc.info/github/ruby-rdf/rdf-normalize/master/file/README.markdown
+[Normalize doc]:http://rubydoc.info/github/ruby-rdf/rdf-normalize/master

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.4.0

data/lib/rdf/normalize.rb

@@ -28,7 +28,6 @@ module RDF
   # @author [Gregg Kellogg](http://greggkellogg.net/)
   module Normalize
     require  'rdf/normalize/format'
-    require  'rdf/normalize/utils'
     autoload :Base,       'rdf/normalize/base'
     autoload :Carroll2001,'rdf/normalize/carroll2001'
     autoload :URGNA2012,  'rdf/normalize/urgna2012'
@@ -54,11 +53,11 @@ module RDF
     #   One of `:carroll2001`, `:urgna2012`, or `:urdna2015`
     # @return [RDF::Normalize::Base]
     # @raise [ArgumentError] selected algorithm not defined
-    def new(enumerable, options = {})
+    def new(enumerable, **options)
       algorithm = options.fetch(:algorithm, :urdna2015)
       raise ArgumentError, "No algoritm defined for #{algorithm.to_sym}" unless ALGORITHMS.has_key?(algorithm)
       algorithm_class = const_get(ALGORITHMS[algorithm])
-      algorithm_class.new(enumerable, options)
+      algorithm_class.new(enumerable, **options)
     end
     module_function :new
 

data/lib/rdf/normalize/carroll2001.rb

@@ -9,7 +9,7 @@ module RDF::Normalize
     #
     # @param [RDF::Enumerable] enumerable
     # @return [RDF::Enumerable]
-    def initialize(enumerable, options)
+    def initialize(enumerable, **options)
       @dataset = enumerable
     end
 

data/lib/rdf/normalize/format.rb

@@ -2,6 +2,7 @@ require 'rdf/nquads'
 
 module RDF::Normalize
   class Format < RDF::Format
+    content_type     'application/normalized+n-quads', alias: 'application/x-normalized+n-quads'
     content_encoding 'utf-8'
 
     # It reads like normal N-Quads

data/lib/rdf/normalize/urdna2015.rb

@@ -1,15 +1,15 @@
 module RDF::Normalize
   class URDNA2015
     include RDF::Enumerable
+    include RDF::Util::Logger
     include Base
-    include Utils
 
     ##
     # Create an enumerable with grounded nodes
     #
     # @param [RDF::Enumerable] enumerable
     # @return [RDF::Enumerable]
-    def initialize(enumerable, options)
+    def initialize(enumerable, **options)
       @dataset, @options = enumerable, options
     end
 
@@ -35,8 +35,8 @@ module RDF::Normalize
 
         # Calculate hashes for first degree nodes
         non_normalized_identifiers.each do |node|
-          hash = depth {ns.hash_first_degree_quads(node)}
-          debug("1deg") {"hash: #{hash}"}
+          hash = log_depth {ns.hash_first_degree_quads(node)}
+          log_debug("1deg") {"hash: #{hash}"}
           ns.add_bnode_hash(node, hash)
         end
 
@@ -46,7 +46,7 @@ module RDF::Normalize
           next if identifier_list.length > 1
           node = identifier_list.first
           id = ns.canonical_issuer.issue_identifier(node)
-          debug("single node") {"node: #{node.to_ntriples}, hash: #{hash}, id: #{id}"}
+          log_debug("single node") {"node: #{node.to_ntriples}, hash: #{hash}, id: #{id}"}
           non_normalized_identifiers -= identifier_list
           ns.hash_to_bnodes.delete(hash)
           simple = true
@@ -57,7 +57,7 @@ module RDF::Normalize
       ns.hash_to_bnodes.keys.sort.each do |hash|
         identifier_list = ns.hash_to_bnodes[hash]
 
-        debug("multiple nodes") {"node: #{identifier_list.map(&:to_ntriples).join(",")}, hash: #{hash}"}
+        log_debug("multiple nodes") {"node: #{identifier_list.map(&:to_ntriples).join(",")}, hash: #{hash}"}
         hash_path_list = []
 
         # Create a hash_path_list for all bnodes using a temporary identifier used to create canonical replacements
@@ -65,15 +65,15 @@ module RDF::Normalize
           next if ns.canonical_issuer.issued.include?(identifier)
           temporary_issuer = IdentifierIssuer.new("_:b")
           temporary_issuer.issue_identifier(identifier)
-          hash_path_list << depth {ns.hash_n_degree_quads(identifier, temporary_issuer)}
+          hash_path_list << log_depth {ns.hash_n_degree_quads(identifier, temporary_issuer)}
         end
-        debug("->") {"hash_path_list: #{hash_path_list.map(&:first).inspect}"}
+        log_debug("->") {"hash_path_list: #{hash_path_list.map(&:first).inspect}"}
 
         # Create canonical replacements for nodes
         hash_path_list.sort_by(&:first).map(&:last).each do |issuer|
           issuer.issued.each do |node|
             id = ns.canonical_issuer.issue_identifier(node)
-            debug("-->") {"node: #{node.to_ntriples}, id: #{id}"}
+            log_debug("-->") {"node: #{node.to_ntriples}, id: #{id}"}
           end
         end
       end
@@ -94,7 +94,7 @@ module RDF::Normalize
   private
 
     class NormalizationState
-      include Utils
+      include RDF::Util::Logger
 
       attr_accessor :bnode_to_statements
       attr_accessor :hash_to_bnodes
@@ -116,7 +116,7 @@ module RDF::Normalize
       end
 
       # @param [RDF::Node] node
-      # @return [String] the SHA1 hexdigest hash of statements using this node, with replacements
+      # @return [String] the SHA256 hexdigest hash of statements using this node, with replacements
       def hash_first_degree_quads(node)
         quads = bnode_to_statements[node].
           map do |statement|
@@ -130,7 +130,7 @@ module RDF::Normalize
             RDF::NQuads::Writer.serialize(RDF::Statement.from(quad))
           end
 
-        debug("1deg") {"node: #{node}, quads: #{quads}"}
+        log_debug("1deg") {"node: #{node}, quads: #{quads}"}
         hexdigest(quads.sort.join)
       end
 
@@ -138,7 +138,7 @@ module RDF::Normalize
       # @param [RDF::Statement] statement
       # @param [IdentifierIssuer] issuer
       # @param [String] position one of :s, :o, or :g
-      # @return [String] the SHA1 hexdigest hash
+      # @return [String] the SHA256 hexdigest hash
       def hash_related_node(related, statement, issuer, position)
         identifier = canonical_issuer.identifier(related) ||
                      issuer.identifier(related) ||
@@ -146,7 +146,7 @@ module RDF::Normalize
         input = position.to_s
         input << statement.predicate.to_ntriples unless position == :g
         input << identifier
-        debug("hrel") {"input: #{input.inspect}, hash: #{hexdigest(input)}"}
+        log_debug("hrel") {"input: #{input.inspect}, hash: #{hexdigest(input)}"}
         hexdigest(input)
       end
 
@@ -154,7 +154,7 @@ module RDF::Normalize
       # @param [IdentifierIssuer] issuer
       # @return [Array<String,IdentifierIssuer>] the Hash and issuer
       def hash_n_degree_quads(identifier, issuer)
-        debug("ndeg") {"identifier: #{identifier.to_ntriples}"}
+        log_debug("ndeg") {"identifier: #{identifier.to_ntriples}"}
 
         # hash to related blank nodes map
         map = {}
@@ -165,8 +165,8 @@ module RDF::Normalize
 
         data_to_hash = ""
 
-        debug("ndeg") {"map: #{map.map {|h,l| "#{h}: #{l.map(&:to_ntriples)}"}.join('; ')}"}
-        depth do
+        log_debug("ndeg") {"map: #{map.map {|h,l| "#{h}: #{l.map(&:to_ntriples)}"}.join('; ')}"}
+        log_depth do
           map.keys.sort.each do |hash|
             list = map[hash]
             # Iterate over related nodes
@@ -174,7 +174,7 @@ module RDF::Normalize
             data_to_hash += hash
 
             list.permutation do |permutation|
-              debug("ndeg") {"perm: #{permutation.map(&:to_ntriples).join(",")}"}
+              log_debug("ndeg") {"perm: #{permutation.map(&:to_ntriples).join(",")}"}
               issuer_copy, path, recursion_list = issuer.dup, "", []
 
               permutation.each do |related|
@@ -188,10 +188,10 @@ module RDF::Normalize
                 # Skip to the next permutation if chosen path isn't empty and the path is greater than the chosen path
                 break if !chosen_path.empty? && path.length >= chosen_path.length
               end
-              debug("ndeg") {"hash: #{hash}, path: #{path}, recursion: #{recursion_list.map(&:to_ntriples)}"}
+              log_debug("ndeg") {"hash: #{hash}, path: #{path}, recursion: #{recursion_list.map(&:to_ntriples)}"}
 
               recursion_list.each do |related|
-                result = depth {hash_n_degree_quads(related, issuer_copy)}
+                result = log_depth {hash_n_degree_quads(related, issuer_copy)}
                 path << issuer_copy.issue_identifier(related)
                 path << "<#{result.first}>"
                 issuer_copy = result.last
@@ -208,23 +208,22 @@ module RDF::Normalize
           end
         end
 
-        debug("ndeg") {"datatohash: #{data_to_hash.inspect}, hash: #{hexdigest(data_to_hash)}"}
+        log_debug("ndeg") {"datatohash: #{data_to_hash.inspect}, hash: #{hexdigest(data_to_hash)}"}
         return [hexdigest(data_to_hash), issuer]
       end
 
       protected
 
-      # FIXME: should be SHA-256.
       def hexdigest(val)
-        Digest::SHA1.hexdigest(val)
+        Digest::SHA256.hexdigest(val)
       end
 
       # Group adjacent bnodes by hash
       def hash_related_statement(identifier, statement, issuer, map)
-        statement.to_hash(:s, :p, :o, :g).each do |pos, term|
+        statement.to_h(:s, :p, :o, :g).each do |pos, term|
           next if !term.is_a?(RDF::Node) || term == identifier
 
-          hash = depth {hash_related_node(term, statement, issuer, pos)}
+          hash = log_depth {hash_related_node(term, statement, issuer, pos)}
           map[hash] ||= []
           map[hash] << term unless map[hash].include?(term)
         end
@@ -261,4 +260,4 @@ module RDF::Normalize
       end
     end
   end
-end
+end

data/lib/rdf/normalize/urgna2012.rb

@@ -26,18 +26,18 @@ module RDF::Normalize
         input = position.to_s
         input << statement.predicate.to_s
         input << identifier
-        debug("hrel") {"input: #{input.inspect}, hash: #{hexdigest(input)}"}
+        log_debug("hrel") {"input: #{input.inspect}, hash: #{hexdigest(input)}"}
         hexdigest(input)
       end
 
       # In URGNA2012, the position parameter passed to the Hash Related Blank Node algorithm was instead modeled as a direction parameter, where it could have the value p, for property, when the related blank node was a `subject` and the value r, for reverse or reference, when the related blank node was an `object`. Since URGNA2012 only normalized graphs, not datasets, there was no use of the `graph` position.
       def hash_related_statement(identifier, statement, issuer, map)
         if statement.subject.node? && statement.subject != identifier
-          hash = depth {hash_related_node(statement.subject, statement, issuer, :p)}
+          hash = log_depth {hash_related_node(statement.subject, statement, issuer, :p)}
           map[hash] ||= []
           map[hash] << statement.subject unless map[hash].include?(statement.subject)
         elsif statement.object.node? && statement.object != identifier
-          hash = depth {hash_related_node(statement.object, statement, issuer, :r)}
+          hash = log_depth {hash_related_node(statement.object, statement, issuer, :r)}
           map[hash] ||= []
           map[hash] << statement.object unless map[hash].include?(statement.object)
         end

data/lib/rdf/normalize/version.rb

@@ -0,0 +1,18 @@
+module RDF::Normalize::VERSION
+  VERSION_FILE = File.join(File.expand_path(File.dirname(__FILE__)), "..", "..", "..", "VERSION")
+  MAJOR, MINOR, TINY, EXTRA = File.read(VERSION_FILE).chop.split(".")
+
+  STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.')
+
+  ##
+  # @return [String]
+  def self.to_s()   STRING end
+
+  ##
+  # @return [String]
+  def self.to_str() STRING end
+
+  ##
+  # @return [Array(Integer, Integer, Integer)]
+  def self.to_a() STRING.split(".") end
+end

data/lib/rdf/normalize/writer.rb

@@ -23,9 +23,8 @@ module RDF::Normalize
     # @yieldreturn [void]
     # @yield  [writer]
     # @yieldparam [RDF::Writer] writer
-    def initialize(output = $stdout, options = {}, &block)
+    def initialize(output = $stdout, **options, &block)
       super do
-        @options[:depth] ||= 0
         @repo = RDF::Repository.new
         if block_given?
           case block.arity
@@ -36,10 +35,17 @@ module RDF::Normalize
       end
     end
 
+
     ##
-    # Defer writing to epilogue
-    def write_statement(statement)
-      self
+    # Adds statements to the repository to be serialized in epilogue.
+    #
+    # @param  [RDF::Resource] subject
+    # @param  [RDF::URI]      predicate
+    # @param  [RDF::Value]    object
+    # @param  [RDF::Resource] graph_name
+    # @return [void]
+    def write_quad(subject, predicate, object, graph_name)
+      @repo.insert(RDF::Statement(subject, predicate, object, graph_name: graph_name))
     end
 
     ##
@@ -47,7 +53,7 @@ module RDF::Normalize
     #
     # @return [void]
     def write_epilogue
-      statements = RDF::Normalize.new(@repo, @options).
+      statements = RDF::Normalize.new(@repo, **@options).
         statements.
         reject(&:variable?).
         map {|s| format_statement(s)}.
@@ -55,18 +61,11 @@ module RDF::Normalize
         each do |line|
           puts line
         end
+      super
     end
 
     protected
 
-    ##
-    # Adds a statement to be serialized
-    # @param  [RDF::Statement] statement
-    # @return [void]
-    def insert_statement(statement)
-      @repo.insert(statement)
-    end
-
     ##
     # Insert an Enumerable
     #

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rdf-normalize
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Gregg Kellogg
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-20 00:00:00.000000000 Z
+date: 2019-12-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdf
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '3.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: rdf-spec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: open-uri-cached
   requirement: !ruby/object:Gem::Requirement
@@ -64,56 +64,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.9'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.9'
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '3.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.17'
+        version: '3.7'
 - !ruby/object:Gem::Dependency
   name: json-ld
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '3.1'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: 0.9.20
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: 0.9.20
 description: RDF::Normalize is a Graph normalizer for the RDF.rb library suite.
 email: public-rdf-ruby@w3.org
 executables: []
@@ -130,11 +130,11 @@ files:
 - lib/rdf/normalize/format.rb
 - lib/rdf/normalize/urdna2015.rb
 - lib/rdf/normalize/urgna2012.rb
-- lib/rdf/normalize/utils.rb
+- lib/rdf/normalize/version.rb
 - lib/rdf/normalize/writer.rb
 homepage: http://github.com/gkellogg/rdf-normalize
 licenses:
-- Public Domain
+- Unlicense
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -144,17 +144,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.2
+      version: '2.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: rdf-normalize
-rubygems_version: 2.4.7
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: RDF Graph normalizer for Ruby.
 test_files: []
-has_rdoc: false

data/lib/rdf/normalize/utils.rb

@@ -1,33 +0,0 @@
-module RDF::Normalize
-  module Utils
-    # Add debug event to debug array, if specified
-    #
-    #   param [String] message
-    #   yieldreturn [String] appended to message, to allow for lazy-evaulation of message
-    def debug(*args)
-      options = args.last.is_a?(Hash) ? args.pop : {}
-      return unless options[:debug] || @options[:debug]
-      depth = options[:depth] || @options[:depth]
-      d_str = depth > 100 ? ' ' * 100 + '+' : ' ' * depth
-      list = args
-      list << yield if block_given?
-      message = d_str + (list.empty? ? "" : list.join(": "))
-      options[:debug] << message if options[:debug].is_a?(Array)
-      @options[:debug] << message if @options[:debug].is_a?(Array)
-      $stderr.puts(message) if @options[:debug] == TrueClass
-    end
-    module_function :debug
-
-    # Increase depth around a method invocation
-    # @yield
-    #   Yields with no arguments
-    # @yieldreturn [Object] returns the result of yielding
-    # @return [Object]
-    def depth
-      @options[:depth] += 1
-      ret = yield
-      @options[:depth] -= 1
-      ret
-    end
-  end
-end