json-ld 1.1.7 → 1.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b6c779ef87a832a22299e041f6247302d291701d
-  data.tar.gz: 1dea55d7a1187607566c39865ed76ca4dbc8131a
+  metadata.gz: 1f6790b14a0a5f9c477e63ad9b8788b03be1eabe
+  data.tar.gz: 8fc23868782eb98f4c375607ff6bf01813a5aa78
 SHA512:
-  metadata.gz: 2e8560d7338e1d891bf5dc2d0959d1a767b5fa1e73a89be5533f5b064dbc135187a755f0f736683945e2ea52fe89fece40bed2f24e5dd075cd10790634c4a7a8
-  data.tar.gz: 987d781688176b608e3f0d70f18e50936376096857176293f14b995d061982ec5c9bc1e64e75fdbca7e797d5a3069ffe6002658e5c623205b605d796430a770f
+  metadata.gz: 7134666ce6f5e0c47148c6a032e1fb13be5c272abd5db50b1a84b7925857b7a86e3f3444718cb2b0d7717eed49a4d24f70bb6a3beaa3da6b394ad68aab1c6140
+  data.tar.gz: 88f96434d3c7b342e7be136c3b9b20ded52c93f4d8234af446e164336decc7a6b9dbd99f59d362619a8fe6f95a7855adbc8feacb929c99601e41a415a7739ded

data/README.md

@@ -13,6 +13,12 @@ JSON::LD can now be used to create a _context_ from an RDFS/OWL definition, and
 
 Install with `gem install json-ld`
 
+### JSON-LD Streaming Profile
+This gem implements an optimized streaming writer used for generating JSON-LD from large repositories. Such documents result in the JSON-LD Streaming Profile:
+
+* Each statement written as a separate node in expanded/flattened form.
+* RDF Lists are written as separate nodes using `rdf:first` and `rdf:rest` properties.
+
 ## Examples
 
     require 'rubygems'
@@ -165,7 +171,7 @@ Install with `gem install json-ld`
     graph = RDF::Graph.new << JSON::LD::API.toRdf(input)
 
     require 'rdf/turtle'
-    graph.dump(:ttl, :prefixes => {:foaf => "http://xmlns.com/foaf/0.1/"})
+    graph.dump(:ttl, prefixes: {foaf: "http://xmlns.com/foaf/0.1/"})
     @prefix foaf: <http://xmlns.com/foaf/0.1/> .
 
     <http://example.org/people#joebob> a foaf:Person;
@@ -213,8 +219,8 @@ Install with `gem install json-ld`
 ## RDF Reader and Writer
 {JSON::LD} also acts as a normal RDF reader and writer, using the standard RDF.rb reader/writer interfaces:
 
-    graph = RDF::Graph.load("etc/doap.jsonld", :format => :jsonld)
-    graph.dump(:jsonld, :standard_prefixes => true)
+    graph = RDF::Graph.load("etc/doap.jsonld", format: :jsonld)
+    graph.dump(:jsonld, standard_prefixes: true)
 
 `RDF::GRAPH#dump` can also take a `:context` option to use a separately defined context
 

data/VERSION

@@ -1 +1 @@
-1.1.7
+1.1.8

data/bin/jsonld

@@ -1,10 +1,10 @@
 #!/usr/bin/env ruby
 require 'rubygems'
-$:.unshift(File.expand_path("../../lib", __FILE__))
 begin
   require 'linkeddata'
 rescue LoadError
 end
+$:.unshift(File.expand_path("../../lib", __FILE__))
 require 'json/ld'
 require 'getoptlong'
 require 'open-uri'
@@ -17,42 +17,49 @@ def run(input, options)
   options[:format] = :jsonld if options[:compact] || options[:frame]
 
   # If input format is not JSON-LD, transform input to JSON-LD first
-  if options[:format] == :jsonld && options[:input_format] != :jsonld
-    r = reader_class.new(input, options[:parser_options])
-    g = RDF::Repository.new << r
-    input = JSON::LD::API.fromRdf(g)
+  reader = if options[:input_format] != :jsonld
+    reader_class.new(input, options[:parser_options])
   end
 
   prefixes = {}
   start = Time.new
   if options[:expand]
-    options = options.merge(:expandContext => options.delete(:context)) if options.has_key?(:context)
+    options = options.merge(expandContext: options.delete(:context)) if options.has_key?(:context)
+    input = JSON::LD::API.fromRdf(reader) if reader
     output = JSON::LD::API.expand(input, options)
     secs = Time.new - start
     options[:output].puts output.to_json(JSON::LD::JSON_STATE)
     STDERR.puts "Expanded in #{secs} seconds." unless options[:quiet]
   elsif options[:compact]
+    input = JSON::LD::API.fromRdf(reader) if reader
     output = JSON::LD::API.compact(input, options[:context], options)
     secs = Time.new - start
     options[:output].puts output.to_json(JSON::LD::JSON_STATE)
     STDERR.puts "Compacted in #{secs} seconds." unless options[:quiet]
   elsif options[:flatten]
+    input = JSON::LD::API.fromRdf(reader) if reader
     output = JSON::LD::API.flatten(input, options[:context], options)
     secs = Time.new - start
     options[:output].puts output.to_json(JSON::LD::JSON_STATE)
     STDERR.puts "Flattened in #{secs} seconds." unless options[:quiet]
   elsif options[:frame]
+    input = JSON::LD::API.fromRdf(reader) if reader
     output = JSON::LD::API.frame(input, options[:frame], options)
     secs = Time.new - start
     options[:output].puts output.to_json(JSON::LD::JSON_STATE)
     STDERR.puts "Framed in #{secs} seconds." unless options[:quiet]
   else
-    options = options.merge(:expandContext => options.delete(:context)) if options.has_key?(:context)
-    g = JSON::LD::API.toRdf(input, options)
+    options = options.merge(expandContext: options.delete(:context)) if options.has_key?(:context)
+    parser_options = options[:parser_options].merge(standard_prefixes: true)
+    reader ||= JSON::LD::Reader.new(input, parser_options)
+    num = 0
+    RDF::Writer.for(options[:output_format]).new(options[:output], parser_options) do |w|
+      reader.each do |statement|
+        num += 1
+        w << statement
+      end
+    end
     secs = Time.new - start
-    num = g.count
-    parser_options = options[:parser_options].merge(:standard_prefixes => true)
-    options[:output].puts g.dump(options[:output_format], parser_options)
     STDERR.puts "\nParsed #{num} statements in #{secs} seconds @ #{num/secs} statements/second." unless options[:quiet]
   end
 rescue
@@ -62,17 +69,18 @@ rescue
 end
 
 parser_options = {
-  :base     => nil,
-  :progress => false,
-  :validate => false,
-  :strict   => false,
+  base:     nil,
+  progress: false,
+  validate: false,
+  stream:   false,
+  strict:   false,
 }
 
 options = {
-  :parser_options => parser_options,
-  :output        => STDOUT,
-  :output_format => :turtle,
-  :input_format  => :jsonld,
+  parser_options: parser_options,
+  output:         STDOUT,
+  output_format:  :jsonld,
+  input_format:   :jsonld,
 }
 input = nil
 
@@ -89,8 +97,9 @@ OPT_ARGS = [
   ["--output", "-o",  GetoptLong::REQUIRED_ARGUMENT,"Output to the specified file path"],
   ["--parse-only",    GetoptLong::NO_ARGUMENT,      "Parse the document for well-formedness only"],
   ["--quiet",         GetoptLong::NO_ARGUMENT,      "Supress most output other than progress indicators"],
+  ["--stream",        GetoptLong::NO_ARGUMENT,      "Use Streaming reader/writer"],
   ["--uri",           GetoptLong::REQUIRED_ARGUMENT,"URI to be used as the document base"],
-  ["--verbose",       GetoptLong::NO_ARGUMENT,      "Detail on execution"],
+  ["--validate",      GetoptLong::NO_ARGUMENT,      "Validate while processing"],
   ["--help", "-?",    GetoptLong::NO_ARGUMENT,      "This message"]
 ]
 def usage
@@ -108,7 +117,6 @@ def usage
   exit(1)
 end
 
-
 opts = GetoptLong.new(*OPT_ARGS.map {|o| o[0..-2]})
 
 opts.each do |opt, arg|
@@ -125,18 +133,29 @@ opts.each do |opt, arg|
   when '--output'       then options[:output] = File.open(arg, "w")
   when '--parse-only'   then options[:parse_only] = true
   when '--quiet'        then options[:quiet] = true
+  when '--stream'       then parser_options[:stream] = true
   when '--uri'          then parser_options[:base] = arg
-  when '--verbose'      then $verbose = true
+  when '--validate'     then parser_options[:validate] = true
   when '--help'         then usage
   end
 end
 
+# Hack
+options[:parser_options][:context] = options[:context] if parser_options[:stream]
+
+if !(options.keys & [:expand, :compact, :flatten, :frame]).empty? &&
+   (parser_options[:stream] || options[:output_format] != :jsonld)
+   STDERR.puts "Incompatible options"
+   exit(1)
+end
+
 if ARGV.empty?
   s = input ? input : $stdin.read
   run(StringIO.new(s), options)
 else
   ARGV.each do |file|
-    run(file, options)
+    # Call with opened files
+    RDF::Util::File.open_file(file, options) {|f| run(f, options)}
   end
 end
 puts

data/lib/json/ld.rb

@@ -25,7 +25,7 @@ module JSON
     require 'json/ld/format'
     require 'json/ld/utils'
     autoload :API,                'json/ld/api'
-    autoload :Context,  'json/ld/context'
+    autoload :Context,            'json/ld/context'
     autoload :Normalize,          'json/ld/normalize'
     autoload :Reader,             'json/ld/reader'
     autoload :Resource,           'json/ld/resource'
@@ -77,11 +77,11 @@ module JSON
     NATIVE_DATATYPES = [RDF::XSD.integer.to_s, RDF::XSD.boolean.to_s, RDF::XSD.double.to_s]
 
     JSON_STATE = JSON::State.new(
-      :indent       => "  ",
-      :space        => " ",
-      :space_before => "",
-      :object_nl    => "\n",
-      :array_nl     => "\n"
+      indent:       "  ",
+      space:        " ",
+      space_before: "",
+      object_nl:    "\n",
+      array_nl:     "\n"
     )
 
     def self.debug?; @debug; end

data/lib/json/ld/api.rb

@@ -26,7 +26,7 @@ module JSON::LD
 
     # Options used for open_file
     OPEN_OPTS = {
-      :headers => {"Accept" => "application/ld+json, application/json"}
+      headers: {"Accept" => "application/ld+json, application/json"}
     }
 
     # Current input
@@ -79,21 +79,32 @@ module JSON::LD
     # @yield [api]
     # @yieldparam [API]
     def initialize(input, context, options = {}, &block)
-      @options = {:compactArrays => true}.merge(options)
+      @options = {compactArrays: true, rename_bnodes: true}.merge(options)
       @options[:validate] = true if @options[:processingMode] == "json-ld-1.0"
       @options[:documentLoader] ||= self.class.method(:documentLoader)
-      options[:rename_bnodes] ||= true
-      @namer = options[:unique_bnodes] ? BlankNodeUniqer.new : (options[:rename_bnodes] ? BlankNodeNamer.new("b") : BlankNodeMapper.new)
+      @namer = options[:unique_bnodes] ? BlankNodeUniqer.new : (@options[:rename_bnodes] ? BlankNodeNamer.new("b") : BlankNodeMapper.new)
+
+      # For context via Link header
+      context_ref = nil
+
       @value = case input
       when Array, Hash then input.dup
       when IO, StringIO
-        @options = {:base => input.base_uri}.merge(@options) if input.respond_to?(:base_uri)
+        @options = {base: input.base_uri}.merge(@options) if input.respond_to?(:base_uri)
+
+        # if input impelements #links, attempt to get a contextUrl from that link
+        content_type = input.respond_to?(:content_type) ? input.content_type : "application/json"
+        context_ref = if content_type.start_with?('application/json') && input.respond_to?(:links)
+          link = input.links.find_link(%w(rel http://www.w3.org/ns/json-ld#context))
+          link.href if link
+        end
+
         JSON.parse(input.read)
       when String
         remote_doc = @options[:documentLoader].call(input, @options)
 
-        @options = {:base => remote_doc.documentUrl}.merge(@options)
-        context = context ? [context, remote_doc.contextUrl].compact : remote_doc.contextUrl
+        @options = {base: remote_doc.documentUrl}.merge(@options)
+        context_ref = remote_doc.contextUrl
 
         case remote_doc.document
         when String then JSON.parse(remote_doc.document)
@@ -103,6 +114,9 @@ module JSON::LD
 
       # Update calling context :base option, if not defined
       options[:base] ||= @options[:base] if @options[:base]
+
+      # If not provided, first use context from document, or from a Link header
+      context ||= (@value['@context'] if @value.is_a?(Hash)) || context_ref
       @context = Context.new(@options)
       @context = @context.parse(context) if context
       
@@ -177,13 +191,13 @@ module JSON::LD
       expanded = API.expand(input, options)
 
       API.new(expanded, context, options) do
-        debug(".compact") {"expanded input: #{expanded.to_json(JSON_STATE)}"}
+        debug(".compact") {"expanded input: #{expanded.to_json(JSON_STATE) rescue 'malformed json'}"}
         result = compact(value, nil)
 
         # xxx) Add the given context to the output
         ctx = self.context.serialize
         if result.is_a?(Array)
-          kwgraph = self.context.compact_iri('@graph', :vocab => true, :quiet => true)
+          kwgraph = self.context.compact_iri('@graph', vocab: true, quiet: true)
           result = result.empty? ? {} : {kwgraph => result}
         end
         result = ctx.merge(result) unless ctx.empty?
@@ -219,7 +233,7 @@ module JSON::LD
 
       # Initialize input using frame as context
       API.new(expanded_input, context, options) do
-        debug(".flatten") {"expanded input: #{value.to_json(JSON_STATE)}"}
+        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.
         node_map = {'@default' => {}}
@@ -242,7 +256,7 @@ module JSON::LD
           # 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 = [compacted] unless compacted.is_a?(Array)
-          kwgraph = self.context.compact_iri('@graph', :quiet => true)
+          kwgraph = self.context.compact_iri('@graph', quiet: true)
           flattened = self.context.serialize.merge(kwgraph => compacted)
         end
       end
@@ -284,10 +298,10 @@ module JSON::LD
     def self.frame(input, frame, options = {})
       result = nil
       framing_state = {
-        :embed       => true,
-        :explicit    => false,
-        :omitDefault => false,
-        :embeds      => nil,
+        embed:       true,
+        explicit:    false,
+        omitDefault: false,
+        embeds:      nil,
       }
       framing_state[:embed] = options[:embed] if options.has_key?(:embed)
       framing_state[:explicit] = options[:explicit] if options.has_key?(:explicit)
@@ -315,9 +329,9 @@ module JSON::LD
       # Initialize input using frame as context
       API.new(expanded_input, nil, options) do
         #debug(".frame") {"context from frame: #{context.inspect}"}
-        debug(".frame") {"raw frame: #{frame.to_json(JSON_STATE)}"}
-        debug(".frame") {"expanded frame: #{expanded_frame.to_json(JSON_STATE)}"}
-        debug(".frame") {"expanded input: #{value.to_json(JSON_STATE)}"}
+        debug(".frame") {"raw frame: #{frame.to_json(JSON_STATE) rescue 'malformed json'}"}
+        debug(".frame") {"expanded frame: #{expanded_frame.to_json(JSON_STATE) rescue 'malformed json'}"}
+        debug(".frame") {"expanded input: #{value.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         # Get framing nodes from expanded input, replacing Blank Node identifiers as necessary
         all_nodes = {}
@@ -327,11 +341,11 @@ module JSON::LD
         end
         @options[:debug] = old_dbg
         @node_map = all_nodes['@default']
-        debug(".frame") {"node_map: #{@node_map.to_json(JSON_STATE)}"}
+        debug(".frame") {"node_map: #{@node_map.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         result = []
         frame(framing_state, @node_map, (expanded_frame.first || {}), parent: result)
-        debug(".frame") {"after frame: #{result.to_json(JSON_STATE)}"}
+        debug(".frame") {"after frame: #{result.to_json(JSON_STATE) rescue 'malformed json'}"}
         
         # Initalize context from frame
         @context = depth {@context.parse(frame['@context'])}
@@ -340,9 +354,9 @@ module JSON::LD
         compacted = [compacted] unless compacted.is_a?(Array)
 
         # Add the given context to the output
-        kwgraph = context.compact_iri('@graph', :quiet => true)
+        kwgraph = context.compact_iri('@graph', quiet: true)
         result = context.serialize.merge({kwgraph => compacted})
-        debug(".frame") {"after compact: #{result.to_json(JSON_STATE)}"}
+        debug(".frame") {"after compact: #{result.to_json(JSON_STATE) rescue 'malformed json'}"}
         result = cleanup_preserve(result)
       end
 
@@ -374,17 +388,17 @@ module JSON::LD
       end
 
       # Expand input to simplify processing
-      expanded_input = API.expand(input, options.merge(:ordered => false))
+      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)}"}
+        debug(".toRdf") {"expanded input: #{expanded_input.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         # Generate _nodeMap_
         node_map = {'@default' => {}}
         generate_node_map(expanded_input, node_map)
-        debug(".toRdf") {"node map: #{node_map.to_json(JSON_STATE)}"}
+        debug(".toRdf") {"node map: #{node_map.to_json(JSON_STATE) rescue 'malformed json'}"}
 
         # Start generating statements
         node_map.each do |graph_name, graph|
@@ -439,7 +453,7 @@ module JSON::LD
     # @return [Array<Hash>]
     #   The JSON-LD document in expanded form
     def self.fromRdf(input, options = {}, &block)
-      options = {:useNativeTypes => false}.merge(options)
+      options = {useNativeTypes: false}.merge(options)
       result = nil
 
       API.new(nil, nil, options) do |api|
@@ -461,78 +475,39 @@ module JSON::LD
     # @yieldparam [RemoteDocument] remote_document
     # @raise [JsonLdError]
     def self.documentLoader(url, options = {})
-      require 'net/http' unless defined?(Net::HTTP)
-      remote_document = nil
-      options[:headers] ||= OPEN_OPTS[:headers]
-
-      url = url.to_s[5..-1] if url.to_s.start_with?("file:")
-      case url.to_s
-      when /^http/
-        parsed_url = ::URI.parse(url.to_s)
-        until remote_document do
-          Net::HTTP::start(parsed_url.host, parsed_url.port,
-                          open_timeout: 60 * 1000,
-                          use_ssl: parsed_url.scheme == 'https',
-                          verify_mode: OpenSSL::SSL::VERIFY_NONE
-                          ) do |http|
-            request = Net::HTTP::Get.new(parsed_url.request_uri, options[:headers])
-            http.request(request) do |response|
-              case response
-              when Net::HTTPSuccess
-                # found object
-                content_type, ct_param = response.content_type.to_s.downcase.split(";")
-
-                # If the passed input is a DOMString representing the IRI of a remote document, dereference it. If the retrieved document's content type is neither application/json, nor application/ld+json, nor any other media type using a +json suffix as defined in [RFC6839], reject the promise passing an loading document failed error.
-                if content_type && options[:validate]
-                  main, sub = content_type.split("/")
-                  raise JSON::LD::JsonLdError::LoadingDocumentFailed, "content_type: #{content_type}" if
-                    main != 'application' ||
-                    sub !~ /^(.*\+)?json$/
-                end
-
-                remote_document = RemoteDocument.new(parsed_url.to_s, response.body)
-
-                # If the input has been retrieved, the response has an HTTP Link Header [RFC5988] using the http://www.w3.org/ns/json-ld#context link relation and a content type of application/json or any media type with a +json suffix as defined in [RFC6839] except application/ld+json, update the active context using the Context Processing algorithm, passing the context referenced in the HTTP Link Header as local context. The HTTP Link Header is ignored for documents served as application/ld+json If multiple HTTP Link Headers using the http://www.w3.org/ns/json-ld#context link relation are found, the promise is rejected with a JsonLdError whose code is set to multiple context link headers and processing is terminated.
-                unless content_type.to_s.start_with?("application/ld+json")
-                  links = response["link"].to_s.
-                    split(",").
-                    map(&:strip).
-                    select {|h| h =~ %r{rel=\"http://www.w3.org/ns/json-ld#context\"}}
-                  case links.length
-                  when 0  then #nothing to do
-                  when 1
-                    remote_document.contextUrl = links.first.match(/<([^>]*)>/) && $1
-                  else
-                    raise JSON::LD::JsonLdError::MultipleContextLinkHeaders,
-                      "expected at most 1 Link header with rel=jsonld:context, got #{links.length}"
-                  end
-                end
-
-                return block_given? ? yield(remote_document) : remote_document
-              when Net::HTTPRedirection
-                # Follow redirection
-                parsed_url = ::URI.parse(response["Location"])
-              else
-                raise JSON::LD::JsonLdError::LoadingDocumentFailed, "<#{parsed_url}>: #{response.msg}(#{response.code})"
-              end
-            end
-          end
+      options = OPEN_OPTS.merge(options)
+      RDF::Util::File.open_file(url, options) do |remote_doc|
+        content_type = remote_doc.content_type if remote_doc.respond_to?(:content_type)
+        # If the passed input is a DOMString representing the IRI of a remote document, dereference it. If the retrieved document's content type is neither application/json, nor application/ld+json, nor any other media type using a +json suffix as defined in [RFC6839], reject the promise passing an loading document failed error.
+        if content_type && options[:validate]
+          main, sub = content_type.split("/")
+          raise JSON::LD::JsonLdError::LoadingDocumentFailed, "content_type: #{content_type}" if
+            main != 'application' ||
+            sub !~ /^(.*\+)?json$/
         end
-      else
-        # Use regular open
-        RDF::Util::File.open_file(url, options) do |f|
-          remote_document = RemoteDocument.new(url, f.read)
-          content_type, ct_param = f.content_type.to_s.downcase.split(";") if f.respond_to?(:content_type)
-          if content_type && options[:validate]
-            main, sub = content_type.split("/")
-            raise JSON::LD::JsonLdError::LoadingDocumentFailed, "content_type: #{content_type}" if
-              main != 'application' ||
-              sub !~ /^(.*\+)?json$/
+
+        # If the input has been retrieved, the response has an HTTP Link Header [RFC5988] using the http://www.w3.org/ns/json-ld#context link relation and a content type of application/json or any media type with a +json suffix as defined in [RFC6839] except application/ld+json, update the active context using the Context Processing algorithm, passing the context referenced in the HTTP Link Header as local context. The HTTP Link Header is ignored for documents served as application/ld+json If multiple HTTP Link Headers using the http://www.w3.org/ns/json-ld#context link relation are found, the promise is rejected with a JsonLdError whose code is set to multiple context link headers and processing is terminated.
+        contextUrl = unless content_type.nil? || content_type.start_with?("application/ld+json")
+          # Get context link(s)
+          # Note, we can't simply use #find_link, as we need to detect multiple
+          links = remote_doc.links.links.select do |link|
+            link.attr_pairs.include?(%w(rel http://www.w3.org/ns/json-ld#context))
           end
+          raise JSON::LD::JsonLdError::MultipleContextLinkHeaders,
+            "expected at most 1 Link header with rel=jsonld:context, got #{links.length}" if links.length > 1
+          Array(links.first).first
+        end
 
-          return block_given? ? yield(remote_document) : remote_document
+        doc_uri = remote_doc.base_uri rescue url
+        doc = RemoteDocument.new(doc_uri, remote_doc.read, contextUrl)
+        if block_given?
+          yield(doc)
+        else
+          doc
         end
       end
+    rescue IOError => e
+      raise JSON::LD::JsonLdError::LoadingDocumentFailed, e.message
     end
 
     # Add class method aliases for backwards compatibility