Finish 2.0.0.beta1

Author: gkellogg

.gitignore

@@ -8,3 +8,4 @@
 /.rbx/
 /.bundle/
 Gemfile.lock
+/.byebug_history

.travis.yml

@@ -4,14 +4,17 @@ script: "bundle exec rspec spec"
 env:
   - CI=true
 rvm:
-  - 1.9.3
   - 2.0
   - 2.1
-  - 2.2.1
-  - jruby
+  - 2.2.4
+  - 2.3.0
+  - jruby-9.0.4.0
+  - rbx-2
 cache: bundler
 sudo: false
 matrix:
   allow_failures:
-    - rbx-2
+    - rvm: rbx-2
+    - rvm: jruby-9.0.4.0
+
 

Gemfile

@@ -1,27 +1,30 @@
 source "https://rubygems.org"
 
 gemspec
-gem 'rdf',              git: "git://github.com/ruby-rdf/rdf.git", branch: "develop"
-gem 'rdf-spec',         git: "git://github.com/ruby-rdf/rdf-spec.git", branch: "develop"
+gem 'rdf',              git: "git://github.com/ruby-rdf/rdf.git",       branch: "develop"
+gem 'rdf-spec',         git: "git://github.com/ruby-rdf/rdf-spec.git",  branch: "develop"
 gem 'jsonlint',         git: "git://github.com/dougbarth/jsonlint.git", platforms: [:rbx, :mri]
 
 group :development do
-  gem 'rdf-turtle',     git: "git://github.com/ruby-rdf/rdf-turtle.git", branch: "develop"
-  gem 'rdf-trig',       git: "git://github.com/ruby-rdf/rdf-trig.git", branch: "develop"
-  gem 'rdf-vocab',      git: "git://github.com/ruby-rdf/rdf-vocab.git", branch: "develop"
+  gem 'ebnf',           git: "git://github.com/gkellogg/ebnf.git",        branch: "develop"
+  gem 'sxp',            git: "git://github.com/gkellogg/sxp-ruby.git"
+  gem 'rdf-isomorphic', git: "git://github.com/ruby-rdf/rdf-isomorphic.git", branch: "develop"
+  gem 'rdf-turtle',     git: "git://github.com/ruby-rdf/rdf-turtle.git",  branch: "develop"
+  gem 'rdf-trig',       git: "git://github.com/ruby-rdf/rdf-trig.git",    branch: "develop"
+  gem 'rdf-vocab',      git: "git://github.com/ruby-rdf/rdf-vocab.git",   branch: "develop"
+  gem 'rdf-xsd',        git: "git://github.com/ruby-rdf/rdf-xsd.git",     branch: "develop"
   gem 'fasterer'
 end
 
 group :development, :test do
-  gem 'simplecov', require: false
-  gem 'coveralls', require: false
-  gem 'psych', :platforms => [:mri, :rbx]
+  gem 'simplecov',  require: false, platform: :mri
+  gem 'coveralls',  require: false, platform: :mri
+  gem 'psych',      platforms: [:mri, :rbx]
 end
 
 group :debug do
   gem "wirble"
-  gem "linkeddata"
-  gem "byebug", platforms: [:mri_20, :mri_21]
+  gem "byebug", platforms: :mri
 end
 
 platforms :rbx do

README.md

@@ -274,8 +274,8 @@ Note, the API method signatures differed in versions before 1.0, in that they al
   * {JSON::LD::Writer}
 
 ## Dependencies
-* [Ruby](http://ruby-lang.org/) (>= 1.9.2)
-* [RDF.rb](http://rubygems.org/gems/rdf) (>= 1.0)
+* [Ruby](http://ruby-lang.org/) (>= 2.0)
+* [RDF.rb](http://rubygems.org/gems/rdf) (>= 2.0)
 * [JSON](https://rubygems.org/gems/json) (>= 1.5)
 
 ## Installation

VERSION

@@ -1 +1 @@
-1.99.0
+2.0.0.beta1

json-ld.gemspec

@@ -25,22 +25,22 @@ Gem::Specification.new do |gem|
   gem.test_files            = Dir.glob('spec/**/*.rb') + Dir.glob('spec/test-files/*')
   gem.has_rdoc              = false
 
-  gem.required_ruby_version = '>= 1.9.2'
+  gem.required_ruby_version = '>= 2.0'
   gem.requirements          = []
-  gem.add_runtime_dependency     'rdf',             '~> 1.99'
+  gem.add_runtime_dependency     'rdf',             '>= 2.0.0.beta', '< 3'
   gem.add_runtime_dependency     'multi_json',      '~> 1.11'
   gem.add_development_dependency 'jsonlint',        '~> 0.1.0' unless RUBY_ENGINE == "jruby"
   gem.add_development_dependency 'oj',              '~> 2.12'  unless RUBY_ENGINE == "jruby"
   gem.add_development_dependency 'yajl-ruby',       '~> 1.2' unless RUBY_ENGINE == "jruby"
   gem.add_development_dependency "rack-cache",      '~> 1.2'
   gem.add_development_dependency "rest-client",     '~> 1.8'
   gem.add_development_dependency "rest-client-components", '~> 1.4'
-  gem.add_development_dependency 'rdf-isomorphic',  '~> 1.1'
-  gem.add_development_dependency 'rdf-spec',        '~> 1.99'
-  gem.add_development_dependency 'rdf-trig',        '~> 1.99'
-  gem.add_development_dependency 'rdf-turtle',      '~> 1.99'
-  gem.add_development_dependency 'rdf-vocab',       '~> 0.8'
-  gem.add_development_dependency 'rdf-xsd',         '~> 1.1'
+  gem.add_development_dependency 'rdf-isomorphic',  '>= 2.0.0.beta', '< 3'
+  gem.add_development_dependency 'rdf-spec',        '>= 2.0.0.beta', '< 3'
+  gem.add_development_dependency 'rdf-trig',        '>= 1.99', '< 3'
+  gem.add_development_dependency 'rdf-turtle',      '>= 1.99', '< 3'
+  gem.add_development_dependency 'rdf-vocab',       '>= 0.8'
+  gem.add_development_dependency 'rdf-xsd',         '>= 1.99', '< 3'
   gem.add_development_dependency 'rspec',           '~> 3.2'
   gem.add_development_dependency 'rspec-its',       '~> 1.0'
   gem.add_development_dependency 'yard' ,           '~> 0.8'

lib/json/ld.rb

@@ -85,9 +85,6 @@ module LD
       array_nl:     "\n"
     )
 
-    def self.debug?; @debug; end
-    def self.debug=(value); @debug = value; end
-    
     class JsonLdError < Exception
       def to_s
         "#{self.class.instance_variable_get :@code}: #{super}"

lib/json/ld/api.rb

@@ -28,6 +28,7 @@ class API
     include Flatten
     include FromRDF
     include Frame
+    include RDF::Util::Logger
 
     # Options used for open_file
     OPEN_OPTS = {
@@ -206,7 +207,7 @@ def self.compact(input, context, options = {})
       expanded = options[:expanded] ? input : API.expand(input, options)
 
       API.new(expanded, context, options) do
-        debug(".compact") {"expanded input: #{expanded.to_json(JSON_STATE) rescue 'malformed json'}"}
+        log_debug(".compact") {"expanded input: #{expanded.to_json(JSON_STATE) rescue 'malformed json'}"}
         result = compact(value, nil)
 
         # xxx) Add the given context to the output
@@ -248,7 +249,7 @@ def self.flatten(input, context, options = {})
 
       # Initialize input using
       API.new(expanded_input, context, options) do
-        debug(".flatten") {"expanded input: #{value.to_json(JSON_STATE) rescue 'malformed json'}"}
+        log_debug(".flatten") {"expanded input: #{value.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         # Initialize node map to a JSON object consisting of a single member whose key is @default and whose value is an empty JSON object.
         graphs = {'@default' => {}}
@@ -269,7 +270,7 @@ def self.flatten(input, context, options = {})
 
         if context && !flattened.empty?
           # Otherwise, return the result of compacting flattened according the Compaction algorithm passing context ensuring that the compaction result uses the @graph keyword (or its alias) at the top-level, even if the context is empty or if there is only one element to put in the @graph array. This ensures that the returned document has a deterministic structure.
-          compacted = depth {compact(flattened, nil)}
+          compacted = log_depth {compact(flattened, nil)}
           compacted = [compacted] unless compacted.is_a?(Array)
           kwgraph = self.context.compact_iri('@graph', quiet: true)
           flattened = self.context.serialize.merge(kwgraph => compacted)
@@ -350,30 +351,30 @@ def self.frame(input, frame, options = {})
 
       # Initialize input using frame as context
       API.new(expanded_input, nil, options) do
-        #debug(".frame") {"context from frame: #{context.inspect}"}
-        debug(".frame") {"expanded frame: #{expanded_frame.to_json(JSON_STATE) rescue 'malformed json'}"}
+        #log_debug(".frame") {"context from frame: #{context.inspect}"}
+        log_debug(".frame") {"expanded frame: #{expanded_frame.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         # Get framing nodes from expanded input, replacing Blank Node identifiers as necessary
-        old_dbg, @options[:debug] = @options[:debug], nil
+        old_logger, @options[:logger] = @options[:logger], []
         create_node_map(value, framing_state[:graphs], '@merged')
-        @options[:debug] = old_dbg
+        @options[:logger] = old_logger
         framing_state[:subjects] = framing_state[:graphs]['@merged']
-        debug(".frame") {"subjects: #{framing_state[:subjects].to_json(JSON_STATE) rescue 'malformed json'}"}
+        log_debug(".frame") {"subjects: #{framing_state[:subjects].to_json(JSON_STATE) rescue 'malformed json'}"}
 
         result = []
         frame(framing_state, framing_state[:subjects].keys.sort, (expanded_frame.first || {}), options.merge(parent: result))
-        debug(".frame") {"after frame: #{result.to_json(JSON_STATE) rescue 'malformed json'}"}
+        log_debug(".frame") {"after frame: #{result.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         # Initalize context from frame
-        @context = depth {@context.parse(frame['@context'])}
+        @context = log_depth {@context.parse(frame['@context'])}
         # Compact result
-        compacted = depth {compact(result, nil)}
+        compacted = log_depth {compact(result, nil)}
         compacted = [compacted] unless compacted.is_a?(Array)
 
         # Add the given context to the output
         kwgraph = context.compact_iri('@graph', quiet: true)
         result = context.serialize.merge({kwgraph => compacted})
-        debug(".frame") {"after compact: #{result.to_json(JSON_STATE) rescue 'malformed json'}"}
+        log_debug(".frame") {"after compact: #{result.to_json(JSON_STATE) rescue 'malformed json'}"}
         result = cleanup_preserve(result)
       end
 
@@ -411,20 +412,20 @@ def self.toRdf(input, options = {}, &block)
       API.new(expanded_input, nil, options) do
         # 1) Perform the Expansion Algorithm on the JSON-LD input.
         #    This removes any existing context to allow the given context to be cleanly applied.
-        debug(".toRdf") {"expanded input: #{expanded_input.to_json(JSON_STATE) rescue 'malformed json'}"}
+        log_debug(".toRdf") {"expanded input: #{expanded_input.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         # Generate _nodeMap_
         graphs = {'@default' => {}}
         create_node_map(expanded_input, graphs)
-        debug(".toRdf") {"node map: #{graphs.to_json(JSON_STATE) rescue 'malformed json'}"}
+        log_debug(".toRdf") {"node map: #{graphs.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         # Start generating statements
         graphs.each do |graph_name, graph|
           context = as_resource(graph_name) unless graph_name == '@default'
-          debug(".toRdf") {"graph_name: #{context ? context.to_ntriples : 'null'}"}
+          log_debug(".toRdf") {"graph_name: #{context ? context.to_ntriples : 'null'}"}
           # Drop results for graphs which are named with relative IRIs
           if graph_name.is_a?(RDF::URI) && !graph_name.absolute
-            debug(".toRdf") {"drop relative graph_name: #{statement.to_ntriples}"}
+            log_debug(".toRdf") {"drop relative graph_name: #{statement.to_ntriples}"}
             next
           end
           graph_to_rdf(graph) do |statement|
@@ -441,7 +442,7 @@ def self.toRdf(input, options = {}, &block)
               end
             end
             if relative
-              debug(".toRdf") {"drop statement with relative IRIs: #{statement.to_ntriples}"}
+              log_debug(".toRdf") {"drop statement with relative IRIs: #{statement.to_ntriples}"}
               next
             end
 

lib/json/ld/compact.rb

@@ -10,23 +10,23 @@ module Compact
     # @return [Array, Hash]
     def compact(element, property = nil)
       if property.nil?
-        debug("compact") {"element: #{element.inspect}, ec: #{context.inspect}"}
+        log_debug("compact") {"element: #{element.inspect}, ec: #{context.inspect}"}
       else
-        debug("compact") {"property: #{property.inspect}"}
+        log_debug("compact") {"property: #{property.inspect}"}
       end
       case element
       when Array
-        debug("") {"Array #{element.inspect}"}
-        result = depth {element.map {|item| compact(item, property)}.compact}
+        log_debug("") {"Array #{element.inspect}"}
+        result = log_depth {element.map {|item| compact(item, property)}.compact}
 
         # If element has a single member and the active property has no
         # @container mapping to @list or @set, the compacted value is that
         # member; otherwise the compacted value is element
         if result.length == 1 && context.container(property).nil? && @options[:compactArrays]
-          debug("=> extract single element: #{result.first.inspect}")
+          log_debug("=> extract single element: #{result.first.inspect}")
           result.first
         else
-          debug("=> array result: #{result.inspect}")
+          log_debug("=> array result: #{result.inspect}")
           result
         end
       when Hash
@@ -36,9 +36,9 @@ def compact(element, property = nil)
         return nil if element.has_key?('@null')
 
         if element.keys.any? {|k| %w(@id @value).include?(k)}
-          result = context.compact_value(property, element, depth: @depth)
+          result = context.compact_value(property, element, log_depth: @options[:log_depth])
           unless result.is_a?(Hash)
-            debug("") {"=> scalar result: #{result.inspect}"}
+            log_debug("") {"=> scalar result: #{result.inspect}"}
             return result
           end
         end
@@ -48,61 +48,61 @@ def compact(element, property = nil)
 
         element.each_key do |expanded_property|
           expanded_value = element[expanded_property]
-          debug("") {"#{expanded_property}: #{expanded_value.inspect}"}
+          log_debug("") {"#{expanded_property}: #{expanded_value.inspect}"}
 
           if %w(@id @type).include?(expanded_property)
             compacted_value = [expanded_value].flatten.compact.map do |expanded_type|
-              depth {context.compact_iri(expanded_type, vocab: (expanded_property == '@type'), depth: @depth)}
+              log_depth {context.compact_iri(expanded_type, vocab: (expanded_property == '@type'), log_depth: @options[:log_depth])}
             end
             compacted_value = compacted_value.first if compacted_value.length == 1
 
             al = context.compact_iri(expanded_property, vocab: true, quiet: true)
-            debug(expanded_property) {"result[#{al}] = #{compacted_value.inspect}"}
+            log_debug(expanded_property) {"result[#{al}] = #{compacted_value.inspect}"}
             result[al] = compacted_value
             next
           end
 
           if expanded_property == '@reverse'
-            compacted_value = depth {compact(expanded_value, '@reverse')}
-            debug("@reverse") {"compacted_value: #{compacted_value.inspect}"}
+            compacted_value = log_depth {compact(expanded_value, '@reverse')}
+            log_debug("@reverse") {"compacted_value: #{compacted_value.inspect}"}
             compacted_value.each do |prop, value|
               if context.reverse?(prop)
                 value = [value] if !value.is_a?(Array) &&
                   (context.container(prop) == '@set' || !@options[:compactArrays])
-                debug("") {"merge #{prop} => #{value.inspect}"}
+                log_debug("") {"merge #{prop} => #{value.inspect}"}
                 merge_compacted_value(result, prop, value)
                 compacted_value.delete(prop)
               end
             end
 
             unless compacted_value.empty?
               al = context.compact_iri('@reverse', quiet: true)
-              debug("") {"remainder: #{al} => #{compacted_value.inspect}"}
+              log_debug("") {"remainder: #{al} => #{compacted_value.inspect}"}
               result[al] = compacted_value
             end
             next
           end
 
           if expanded_property == '@index' && context.container(property) == '@index'
-            debug("@index") {"drop @index"}
+            log_debug("@index") {"drop @index"}
             next
           end
 
           # Otherwise, if expanded property is @index, @value, or @language:
           if %w(@index @value @language).include?(expanded_property)
             al = context.compact_iri(expanded_property, vocab: true, quiet: true)
-            debug(expanded_property) {"#{al} => #{expanded_value.inspect}"}
+            log_debug(expanded_property) {"#{al} => #{expanded_value.inspect}"}
             result[al] = expanded_value
             next
           end
 
           if expanded_value == []
-            item_active_property = depth do
+            item_active_property = log_depth do
               context.compact_iri(expanded_property,
                                   value: expanded_value,
                                   vocab: true,
                                   reverse: inside_reverse,
-                                  depth: @depth)
+                                  log_depth: @options[:log_depth])
             end
 
             iap = result[item_active_property] ||= []
@@ -111,17 +111,17 @@ def compact(element, property = nil)
 
           # At this point, expanded value must be an array due to the Expansion algorithm.
           expanded_value.each do |expanded_item|
-            item_active_property = depth do
+            item_active_property = log_depth do
               context.compact_iri(expanded_property,
                                   value: expanded_item,
                                   vocab: true,
                                   reverse: inside_reverse,
-                                  depth: @depth)
+                                  log_depth: @options[:log_depth])
             end
             container = context.container(item_active_property)
             value = list?(expanded_item) ? expanded_item['@list'] : expanded_item
-            compacted_item = depth {compact(value, item_active_property)}
-            debug("") {" => compacted key: #{item_active_property.inspect} for #{compacted_item.inspect}"}
+            compacted_item = log_depth {compact(value, item_active_property)}
+            log_debug("") {" => compacted key: #{item_active_property.inspect} for #{compacted_item.inspect}"}
 
             if list?(expanded_item)
               compacted_item = [compacted_item] unless compacted_item.is_a?(Array)
@@ -159,7 +159,7 @@ def compact(element, property = nil)
         result.keys.kw_sort.inject({}) {|map, kk| map[kk] = result[kk]; map}
       else
         # For other types, the compacted value is the element value
-        debug("compact") {element.class.to_s}
+        log_debug("compact") {element.class.to_s}
         element
       end
     end