Finish 1.1.1.

Performance update for toRDF.

Author: gkellogg

.gemspec

@@ -38,15 +38,5 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'rdf-isomorphic'
   gem.add_development_dependency 'rdf-xsd'
 
-  # Rubinius has it's own dependencies
-  if RUBY_ENGINE == "rbx" && RUBY_VERSION >= "2.1.0"
-    #gem.add_runtime_dependency     "rubysl-bigdecimal"
-    gem.add_development_dependency "rubysl-base64"
-    gem.add_development_dependency "rubysl-open-uri"
-    gem.add_development_dependency "rubysl-prettyprint"
-    gem.add_development_dependency "rubysl-rexml"
-    gem.add_development_dependency "racc"
-  end
-
   gem.post_install_message  = nil
 end

.travis.yml

@@ -8,3 +8,4 @@ rvm:
   - 2.0.0
   - jruby-19mode
   - rbx
+cache: bundler

Gemfile

@@ -14,3 +14,8 @@ group :debug do
   gem "wirble"
   gem "debugger", :platforms => [:mri_19, :mri_20]
 end
+
+platforms :rbx do
+  gem 'rubysl', '~> 2.0'
+  gem 'rubinius', '~> 2.0'
+end

VERSION

@@ -1 +1 @@
-1.1.0
+1.1.1

lib/json/ld.rb

@@ -1,6 +1,5 @@
 $:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..')))
 require 'rdf' # @see http://rubygems.org/gems/rdf
-require 'backports' if RUBY_VERSION < "1.9"
 
 module JSON
   ##

lib/json/ld/api.rb

@@ -80,7 +80,6 @@ def initialize(input, context, options = {}, &block)
       @options[:documentLoader] ||= self.class.method(:documentLoader)
       options[:rename_bnodes] ||= true
       @namer = options[:rename_bnodes] ? BlankNodeNamer.new("b") : BlankNodeMapper.new
-      content_type = nil
       @value = case input
       when Array, Hash then input.dup
       when IO, StringIO
@@ -219,8 +218,7 @@ def self.flatten(input, context, options = {})
         debug(".flatten") {"expanded input: #{value.to_json(JSON_STATE)}"}
 
         # Initialize node map to a JSON object consisting of a single member whose key is @default and whose value is an empty JSON object.
-        node_map = Hash.ordered
-        node_map['@default'] = Hash.ordered
+        node_map = {'@default' => {}}
         self.generate_node_map(value, node_map)
 
         default_graph = node_map['@default']
@@ -281,7 +279,6 @@ def self.flatten(input, context, options = {})
     # @see http://json-ld.org/spec/latest/json-ld-api/#framing-algorithm
     def self.frame(input, frame, options = {})
       result = nil
-      match_limit = 0
       framing_state = {
         :embed       => true,
         :explicit    => false,
@@ -319,7 +316,7 @@ def self.frame(input, frame, options = {})
         debug(".frame") {"expanded input: #{value.to_json(JSON_STATE)}"}
 
         # Get framing nodes from expanded input, replacing Blank Node identifiers as necessary
-        all_nodes = Hash.ordered
+        all_nodes = {}
         old_dbg, @options[:debug] = @options[:debug], nil
         depth do
           generate_node_map(value, all_nodes)
@@ -360,24 +357,28 @@ def self.frame(input, frame, options = {})
     # @option options [Boolean] :produceGeneralizedRdf (false)
     #   If true, output will include statements having blank node predicates, otherwise they are dropped.
     # @raise [JsonLdError]
-    # @return [Array<RDF::Statement>] if no block given
     # @yield statement
     # @yieldparam [RDF::Statement] statement
     def self.toRdf(input, options = {}, &block)
-      results = []
-      results.extend(RDF::Enumerable)
+      unless block_given?
+        results = []
+        results.extend(RDF::Enumerable)
+        self.toRdf(input, options) do |stmt|
+          results << stmt
+        end
+        return results
+      end
 
       # Expand input to simplify processing
-      expanded_input = API.expand(input, options)
+      expanded_input = API.expand(input, options.merge(:ordered => false))
 
       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)}"}
 
         # Generate _nodeMap_
-        node_map = Hash.ordered
-        node_map['@default'] = Hash.ordered
+        node_map = {'@default' => {}}
         generate_node_map(expanded_input, node_map)
         debug(".toRdf") {"node map: #{node_map.to_json(JSON_STATE)}"}
 
@@ -390,7 +391,7 @@ def self.toRdf(input, options = {}, &block)
             debug(".toRdf") {"drop relative graph_name: #{statement.to_ntriples}"}
             next
           end
-          graph_to_rdf(graph).each do |statement|
+          graph_to_rdf(graph) do |statement|
             next if statement.predicate.node? && !options[:produceGeneralizedRdf]
             # Drop results with relative IRIs
             relative = statement.to_a.any? do |r|

lib/json/ld/compact.rb

@@ -156,9 +156,7 @@ def compact(element, property = nil)
         end
 
         # Re-order result keys
-        r = Hash.ordered
-        result.keys.kw_sort.each {|kk| r[kk] = result[kk]}
-        r
+        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}

lib/json/ld/expand.rb

@@ -11,8 +11,11 @@ module Expand
     # @param [String] active_property
     # @param [Context] context
     # @param [Hash{Symbol => Object}] options
+    # @option options [Boolean] :ordered (true)
+    #   Ensure output objects have keys ordered properly
     # @return [Array, Hash]
     def expand(input, active_property, context, options = {})
+      options = {:ordered => true}.merge(options)
       debug("expand") {"input: #{input.inspect}, active_property: #{active_property.inspect}, context: #{context.inspect}"}
       result = case input
       when Array
@@ -40,9 +43,10 @@ def expand(input, active_property, context, options = {})
         end
 
         depth do
-          output_object = Hash.ordered
+          output_object = {}
           # Then, proceed and process each property and value in element as follows:
-          input.keys.kw_sort.each do |key|
+          keys = options[:ordered] ? input.keys.kw_sort : input.keys
+          keys.each do |key|
             # For each key and value in element, ordered lexicographically by key:
             value = input[key]
             expanded_property = context.expand_iri(key, :vocab => true, :depth => @depth)
@@ -199,7 +203,8 @@ def expand(input, active_property, context, options = {})
               ary = []
 
               # For each key-value pair language-language value in value, ordered lexicographically by language
-              value.keys.sort.each do |k|
+              keys = options[:ordered] ? value.keys.sort : value.keys
+              keys.each do |k|
                 [value[k]].flatten.each do |item|
                   # item must be a string, otherwise an invalid language map value error has been detected and processing is aborted.
                   raise JsonLdError::InvalidLanguageMapValue,
@@ -221,7 +226,8 @@ def expand(input, active_property, context, options = {})
               ary = []
 
               # For each key-value in the object:
-              value.keys.sort.each do |k|
+              keys = options[:ordered] ? value.keys.sort : value.keys
+              keys.each do |k|
                 # Initialize index value to the result of using this algorithm recursively, passing active context, key as active property, and index value as element.
                 index_value = depth { expand([value[k]].flatten, key, context, options) }
                 index_value.each do |item|
@@ -322,10 +328,12 @@ def expand(input, active_property, context, options = {})
             return nil
           end
 
-          # Re-order result keys
-          r = Hash.ordered
-          output_object.keys.kw_sort.each {|k| r[k] = output_object[k]}
-          r
+          # Re-order result keys if ordering
+          if options[:ordered]
+            output_object.keys.kw_sort.inject({}) {|map, kk| map[kk] = output_object[kk]; map}
+          else
+            output_object
+          end
         end
       else
         # Otherwise, unless the value is a number, expand the value according to the Value Expansion rules, passing active property.

lib/json/ld/extensions.rb

@@ -66,82 +66,3 @@ def term_sort
     end
   end
 end
-
-if RUBY_VERSION < "1.9"
-  class InsertOrderPreservingHash < Hash
-    include Enumerable
-
-    def initialize(*args, &block)
-      super
-      @ordered_keys = []
-    end
-
-    def []=(key, val)
-      @ordered_keys << key unless has_key? key
-      super
-    end
-
-    def each
-      @ordered_keys.each {|k| yield(k, self[k])}
-    end
-    alias :each_pair :each
-
-    def each_value
-      @ordered_keys.each {|k| yield(super[k])}
-    end
-
-    def each_key
-      @ordered_keys.each {|k| yield k}
-    end
-
-    def keys
-      @ordered_keys
-    end
-
-    def clear
-      @ordered_keys.clear
-      super
-    end
-
-    def delete(k, &block)
-      @ordered_keys.delete(k)
-      super
-    end
-
-    def reject!
-      del = []
-      each_pair {|k,v| del << k if yield k,v}
-      del.each {|k| delete k}
-      del.empty? ? nil : self
-    end
-
-    def delete_if(&block)
-      reject!(&block)
-      self
-    end
-
-    def merge!(other)
-      new_keys = other.instance_variable_get(:@ordered_keys) || other.keys
-      new_keys -= @ordered_keys
-      @ordered_keys += new_keys
-      super
-      self
-    end
-    
-    def merge(other)
-      self.dup.merge!(other)
-    end
-  end
-  
-  class Hash
-    def self.ordered(obj = nil, &block)
-      InsertOrderPreservingHash.new(obj, &block)
-    end
-  end
-else
-  class Hash
-    def self.ordered(obj = nil, &block)
-      Hash.new(obj, &block)
-    end
-  end
-end

lib/json/ld/flatten.rb

@@ -147,7 +147,8 @@ def generate_node_map(element,
             end
 
             # Finally, for each key-value pair property-value in element ordered by property perform the following steps:
-            element.keys.sort.each do |property|
+            # Note: Not ordering doesn't seem to affect results and is more performant
+            element.keys.each do |property|
               value = element[property]
 
               # If property is a blank node identifier, replace it with a newly generated blank node identifier passing property for identifier.