json-ld 0.1.3 → 0.1.4

data/History.markdown

@@ -1,3 +1,6 @@
+=== 0.1.4
+* Added bin/jsonld for command-line manipulation of JSON-LD files and to perform RDF transformations.
+
 === 0.1.3
 * Progress release syncing with the spec. Most expansion and compaction tests pass. RDF is okay, framing has many issues.
 

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.1.4

data/bin/jsonld

@@ -0,0 +1,134 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "..", 'lib')))
+begin
+  require 'linkeddata'
+rescue LoadError
+end
+require 'json/ld'
+require 'getoptlong'
+require 'open-uri'
+
+def run(input, options)
+  reader_class = RDF::Reader.for(options[:input_format].to_sym)
+  raise "Reader not found for #{options[:input_format]}" unless reader_class
+
+  # Override default (or specified) output format when framing
+  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)
+  end
+
+  prefixes = {}
+  start = Time.new
+  if options[:expand]
+    output = JSON::LD::API.expand(input, options[:context], nil, 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]
+    output = JSON::LD::API.compact(input, options[:context], nil, 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[:frame]
+    output = JSON::LD::API.frame(input, options[:frame], nil, 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
+    r = reader_class.new(input, options[:parser_options])
+    g = RDF::Repository.new << r
+    secs = Time.new - start
+    num = g.count
+    parser_options = options[:parser_options].merge(:prefixes => r.prefixes, :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
+  fname = input.respond_to?(:path) ? input.path : "-stdin-"
+  STDERR.puts("Error in #{fname}")
+  raise
+end
+
+parser_options = {
+  :base     => "",
+  :progress => false,
+  :validate => false,
+  :strict   => false,
+}
+
+options = {
+  :parser_options => parser_options,
+  :output        => STDOUT,
+  :output_format => :turtle,
+  :input_format  => :jsonld,
+}
+input = nil
+
+OPT_ARGS = [
+  ["--dbg",           GetoptLong::NO_ARGUMENT,      "Turn on verbose debugging"],
+  ["--compact",       GetoptLong::NO_ARGUMENT,      "Compact document, using --context"],
+  ["--context",       GetoptLong::REQUIRED_ARGUMENT,"Context to apply for expand, compact and converting from RDF"],
+  ["--evaluate","-e", GetoptLong::REQUIRED_ARGUMENT,"Evaluate argument as a JSON-LD document"],
+  ["--expand",        GetoptLong::NO_ARGUMENT,      "Expand document, using an optional --context"],
+  ["--format",        GetoptLong::REQUIRED_ARGUMENT,"Specify output format when converting to RDF"],
+  ["--frame",         GetoptLong::REQUIRED_ARGUMENT,"Frame document, using the file or URL as a frame specification"],
+  ["--input-format",  GetoptLong::REQUIRED_ARGUMENT,"Format of the input document, when converting from RDF."],
+  ["--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"],
+  ["--uri",           GetoptLong::REQUIRED_ARGUMENT,"URI to be used as the document base"],
+  ["--verbose",       GetoptLong::NO_ARGUMENT,      "Detail on execution"],
+  ["--help", "-?",    GetoptLong::NO_ARGUMENT,      "This message"]
+]
+def usage
+  STDERR.puts %{Usage: #{$0} [options] file ...}
+  width = OPT_ARGS.map do |o|
+    l = o.first.length
+    l += o[1].length + 2 if o[1].is_a?(String)
+    l
+  end.max
+  OPT_ARGS.each do |o|
+    s = "  %-*s  " % [width, (o[1].is_a?(String) ? "#{o[0,2].join(', ')}" : o[0])]
+    s += o.last
+    STDERR.puts s
+  end
+  exit(1)
+end
+
+
+opts = GetoptLong.new(*OPT_ARGS.map {|o| o[0..-2]})
+
+opts.each do |opt, arg|
+  case opt
+  when '--dbg'          then parser_options[:debug] = ::JSON::LD::debug = true
+  when '--compact'      then options[:compact] = true
+  when '--context'      then options[:context] = arg
+  when '--execute'      then input = arg
+  when '--expand'       then options[:expand] = true
+  when '--format'       then options[:output_format] = arg.to_sym
+  when '--frame'        then options[:frame] = arg
+  when '--input-format' then options[:input_format] = arg.to_sym
+  when '--output'       then options[:output] = File.open(arg, "w")
+  when '--parse-only'   then options[:parse_only] = true
+  when '--quiet'        then options[:quiet] = true
+  when '--uri'          then parser_options[:base] = arg
+  when '--verbose'      then $verbose = true
+  when '--help'         then usage
+  end
+end
+
+if ARGV.empty?
+  s = input ? input : $stdin.read
+  run(StringIO.new(s), options)
+else
+  ARGV.each do |file|
+    run(Kernel.open(file), options)
+  end
+end
+puts

data/lib/json/ld/api.rb

@@ -129,7 +129,7 @@ module JSON::LD
 
       # 1) Perform the Expansion Algorithm on the JSON-LD input.
       #    This removes any existing context to allow the given context to be cleanly applied.
-      expanded = API.expand(input, nil, nil, options)
+      expanded = API.expand(input, nil, nil, options.merge(:debug => nil))
 
       API.new(expanded, context, options) do
         debug(".compact") {"expanded input: #{expanded.to_json(JSON_STATE)}"}
@@ -215,9 +215,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") {"expanded frame: #{expanded_frame.to_json(JSON_STATE)}"}
-        debug(".frame") {"expanded input: #{value.to_json(JSON_STATE)}"}
+        #debug(".frame") {"context from frame: #{context.inspect}"}
+        #debug(".frame") {"expanded frame: #{expanded_frame.to_json(JSON_STATE)}"}
+        #debug(".frame") {"expanded input: #{value.to_json(JSON_STATE)}"}
 
         # Get framing subjects from expanded input, replacing Blank Node identifiers as necessary
         @subjects = Hash.ordered

data/lib/json/ld/frame.rb

@@ -343,7 +343,8 @@ module JSON::LD
     
     # Return value of @name in frame, or default from state if it doesn't exist
     def get_frame_flag(state, frame, name)
-      !!(frame.fetch("@#{name}", [state[name.to_sym]]).first)
+      value = frame.fetch("@#{name}", [state[name.to_sym]]).first
+      !!(value?(value) ? value['@value'] : value)
     end
 
     ##

data/lib/json/ld/from_rdf.rb

@@ -8,7 +8,7 @@ module JSON::LD
     # Generate a JSON-LD array representation from an array of `RDF::Statement`.
     # Representation is in expanded form
     #
-    # @param [Array<RDF::Statement>] input
+    # @param [Array<RDF::Statement>, RDF::Enumerable] input
     # @return [Array<Hash>] the JSON-LD document in normalized form
     def from_statements(input)
       defaultGraph = {:subjects => {}, :listMap => {}, :name => ''}

data/spec/api_spec.rb

@@ -0,0 +1,66 @@
+# coding: utf-8
+$:.unshift "."
+require 'spec_helper'
+
+describe JSON::LD::API do
+  before(:each) { @debug = []}
+
+  context "callbacks" do
+    describe ".compact" do
+      it "needs to be implemented"
+    end
+
+    describe ".expand" do
+      it "needs to be implemented"
+    end
+
+    describe ".frame" do
+      it "needs to be implemented"
+    end
+
+    describe ".fromRDF" do
+      it "needs to be implemented"
+    end
+
+    describe ".toRDF" do
+      it "needs to be implemented"
+    end
+  end
+
+  context "Test Files" do
+    Dir.glob(File.expand_path(File.join(File.dirname(__FILE__), 'test-files/*-input.*'))) do |filename|
+      test = File.basename(filename).sub(/-input\..*$/, '')
+      frame = filename.sub(/-input\..*$/, '-frame.json')
+      framed = filename.sub(/-input\..*$/, '-framed.json')
+      compacted = filename.sub(/-input\..*$/, '-compacted.json')
+      context = filename.sub(/-input\..*$/, '-context.json')
+      expanded = filename.sub(/-input\..*$/, '-expanded.json')
+      automatic = filename.sub(/-input\..*$/, '-automatic.json')
+      ttl = filename.sub(/-input\..*$/, '-rdf.ttl')
+      
+      context test do
+        before(:all) do
+        end
+
+        it "expands" do
+          jld = JSON::LD::API.expand(File.open(filename), (File.open(context) if context), nil, :debug => @debug)
+          jld.should produce(JSON.load(File.open(expanded)), @debug)
+        end if File.exist?(expanded)
+        
+        it "compacts" do
+          jld = JSON::LD::API.compact(File.open(filename), File.open(context), nil, :debug => @debug)
+          jld.should produce(JSON.load(File.open(compacted)), @debug)
+        end if File.exist?(compacted) && File.exist?(context)
+        
+        it "frame" do
+          jld = JSON::LD::API.frame(File.open(filename), File.open(frame), nil, :debug => @debug)
+          jld.should produce(JSON.load(File.open(framed)), @debug)
+        end if File.exist?(framed) && File.exist?(frame)
+
+        it "toRDF" do
+          RDF::Graph.load(filename, :debug => @debug).should be_equivalent_graph(RDF::Graph.load(ttl), :trace => @debug)
+        end if File.exist?(ttl)
+      end
+    end
+  end
+end

data/spec/compact_spec.rb

@@ -0,0 +1,420 @@
+# coding: utf-8
+$:.unshift "."
+require 'spec_helper'
+
+describe JSON::LD::API do
+  before(:each) { @debug = []}
+
+  describe ".compact" do
+    {
+      "prefix" => {
+        :input => {
+          "@id" => "http://example.com/a",
+          "http://example.com/b" => {"@id" => "http://example.com/c"}
+        },
+        :context => {"ex" => "http://example.com/"},
+        :output => {
+          "@context" => {"ex" => "http://example.com/"},
+          "@id" => "ex:a",
+          "ex:b" => {"@id" => "ex:c"}
+        }
+      },
+      "term" => {
+        :input => {
+          "@id" => "http://example.com/a",
+          "http://example.com/b" => {"@id" => "http://example.com/c"}
+        },
+        :context => {"b" => "http://example.com/b"},
+        :output => {
+          "@context" => {"b" => "http://example.com/b"},
+          "@id" => "http://example.com/a",
+          "b" => {"@id" => "http://example.com/c"}
+        }
+      },
+      "integer value" => {
+        :input => {
+          "@id" => "http://example.com/a",
+          "http://example.com/b" => {"@value" => 1}
+        },
+        :context => {"b" => "http://example.com/b"},
+        :output => {
+          "@context" => {"b" => "http://example.com/b"},
+          "@id" => "http://example.com/a",
+          "b" => 1
+        }
+      },
+      "boolean value" => {
+        :input => {
+          "@id" => "http://example.com/a",
+          "http://example.com/b" => {"@value" => true}
+        },
+        :context => {"b" => "http://example.com/b"},
+        :output => {
+          "@context" => {"b" => "http://example.com/b"},
+          "@id" => "http://example.com/a",
+          "b" => true
+        }
+      },
+      "@id" => {
+        :input => {"@id" => "http://example.org/test#example"},
+        :context => {},
+        :output => {"@id" => "http://example.org/test#example"}
+      },
+      "@id coercion" => {
+        :input => {
+          "@id" => "http://example.com/a",
+          "http://example.com/b" => {"@id" => "http://example.com/c"}
+        },
+        :context => {"b" => {"@id" => "http://example.com/b", "@type" => "@id"}},
+        :output => {
+          "@context" => {"b" => {"@id" => "http://example.com/b", "@type" => "@id"}},
+          "@id" => "http://example.com/a",
+          "b" => "http://example.com/c"
+        }
+      },
+      "xsd:date coercion" => {
+        :input => {
+          "http://example.com/b" => {"@value" => "2012-01-04", "@type" => RDF::XSD.date.to_s}
+        },
+        :context => {
+          "xsd" => RDF::XSD.to_s,
+          "b" => {"@id" => "http://example.com/b", "@type" => "xsd:date"}
+        },
+        :output => {
+          "@context" => {
+            "xsd" => RDF::XSD.to_s,
+            "b" => {"@id" => "http://example.com/b", "@type" => "xsd:date"}
+          },
+          "b" => "2012-01-04"
+        }
+      },
+      "@list coercion" => {
+        :input => {
+          "http://example.com/b" => {"@list" => ["c", "d"]}
+        },
+        :context => {"b" => {"@id" => "http://example.com/b", "@container" => "@list"}},
+        :output => {
+          "@context" => {"b" => {"@id" => "http://example.com/b", "@container" => "@list"}},
+          "b" => ["c", "d"]
+        }
+      },
+      "@list coercion (integer)" => {
+        :input => {
+          "http://example.com/term" => [
+            {"@list" => [1]},
+          ]
+        },
+        :context => {
+          "term4" => {"@id" => "http://example.com/term", "@container" => "@list"},
+          "@language" => "de"
+        },
+        :output => {
+          "@context" => {
+            "term4" => {"@id" => "http://example.com/term", "@container" => "@list"},
+            "@language" => "de"
+          },
+          "term4" => [1],
+        }
+      },
+      "@set coercion" => {
+        :input => {
+          "http://example.com/b" => {"@set" => ["c"]}
+        },
+        :context => {"b" => {"@id" => "http://example.com/b", "@container" => "@set"}},
+        :output => {
+          "@context" => {"b" => {"@id" => "http://example.com/b", "@container" => "@set"}},
+          "b" => ["c"]
+        }
+      },
+      "empty @set coercion" => {
+        :input => {
+          "http://example.com/b" => []
+        },
+        :context => {"b" => {"@id" => "http://example.com/b", "@container" => "@set"}},
+        :output => {
+          "@context" => {"b" => {"@id" => "http://example.com/b", "@container" => "@set"}},
+          "b" => []
+        }
+      },
+      "empty term" => {
+        :input => {
+          "@id" => "http://example.com/",
+          "@type" => "#{RDF::RDFS.Resource}"
+        },
+        :context => {"" => "http://example.com/"},
+        :output => {
+          "@context" => {"" => "http://example.com/"},
+          "@id" => "",
+          "@type" => "#{RDF::RDFS.Resource}"
+        },
+      },
+      "@type with string @id" => {
+        :input => {
+          "@id" => "http://example.com/",
+          "@type" => "#{RDF::RDFS.Resource}"
+        },
+        :context => {},
+        :output => {
+          "@id" => "http://example.com/",
+          "@type" => "#{RDF::RDFS.Resource}"
+        },
+      },
+      "@type with array @id" => {
+        :input => {
+          "@id" => "http://example.com/",
+          "@type" => ["#{RDF::RDFS.Resource}"]
+        },
+        :context => {},
+        :output => {
+          "@id" => "http://example.com/",
+          "@type" => "#{RDF::RDFS.Resource}"
+        },
+      },
+      "default language" => {
+        :input => {
+          "http://example.com/term" => [
+            "v5",
+            {"@value" => "plain literal"}
+          ]
+        },
+        :context => {
+          "term5" => {"@id" => "http://example.com/term", "@language" => nil},
+          "@language" => "de"
+        },
+        :output => {
+          "@context" => {
+            "term5" => {"@id" => "http://example.com/term", "@language" => nil},
+            "@language" => "de"
+          },
+          "term5" => [ "v5", "plain literal" ]
+        }
+      },
+    }.each_pair do |title, params|
+      it title do
+        jld = JSON::LD::API.compact(params[:input], params[:context], nil, :debug => @debug)
+        jld.should produce(params[:output], @debug)
+      end
+    end
+
+    context "keyword aliasing" do
+      {
+        "@id" => {
+          :input => {
+            "@id" => "",
+            "@type" => "#{RDF::RDFS.Resource}"
+          },
+          :context => {"id" => "@id"},
+          :output => {
+            "@context" => {"id" => "@id"},
+            "id" => "",
+            "@type" => "#{RDF::RDFS.Resource}"
+          }
+        },
+        "@type" => {
+          :input => {
+            "@type" => RDF::RDFS.Resource.to_s,
+            "http://example.org/foo" => {"@value" => "bar", "@type" => "http://example.com/type"}
+          },
+          :context => {"type" => "@type"},
+          :output => {
+            "@context" => {"type" => "@type"},
+            "type" => RDF::RDFS.Resource.to_s,
+            "http://example.org/foo" => {"@value" => "bar", "type" => "http://example.com/type"}
+          }
+        },
+        "@language" => {
+          :input => {
+            "http://example.org/foo" => {"@value" => "bar", "@language" => "baz"}
+          },
+          :context => {"language" => "@language"},
+          :output => {
+            "@context" => {"language" => "@language"},
+            "http://example.org/foo" => {"@value" => "bar", "language" => "baz"}
+          }
+        },
+        "@value" => {
+          :input => {
+            "http://example.org/foo" => {"@value" => "bar", "@language" => "baz"}
+          },
+          :context => {"literal" => "@value"},
+          :output => {
+            "@context" => {"literal" => "@value"},
+            "http://example.org/foo" => {"literal" => "bar", "@language" => "baz"}
+          }
+        },
+        "@list" => {
+          :input => {
+            "http://example.org/foo" => {"@list" => ["bar"]}
+          },
+          :context => {"list" => "@list"},
+          :output => {
+            "@context" => {"list" => "@list"},
+            "http://example.org/foo" => {"list" => ["bar"]}
+          }
+        },
+      }.each do |title, params|
+        it title do
+          jld = JSON::LD::API.compact(params[:input], params[:context], nil, :debug => @debug)
+          jld.should produce(params[:output], @debug)
+        end
+      end
+    end
+
+    context "term selection" do
+      {
+        #"Uses term with nil language when two terms conflict on language" => {
+        #  :input => [{
+        #    "http://example.com/term" => {"@value" => "v1", "@language" => nil}
+        #  }],
+        #  :context => {
+        #    "term5" => {"@id" => "http://example.com/term","@language" => nil},
+        #    "@language" => "de"
+        #  },
+        #  :output => {
+        #    "@context" => {
+        #      "term5" => {"@id" => "http://example.com/term","@language" => nil},
+        #      "@language" => "de"
+        #    },
+        #    "term5" => "v1",
+        #  }
+        #},
+        "Uses subject alias" => {
+          :input => [{
+            "@id" => "http://example.com/id1"
+          }],
+          :context => {
+            "id1" => "http://example.com/id1",
+            "@language" => "de"
+          },
+          :output => {
+            "@context" => {
+              "id1" => "http://example.com/id1",
+              "@language" => "de"
+            },
+            "@id" => "id1",
+          }
+        },
+        "Allows IRI to be aliased to null, but still output term using IRI" => {
+          :context => {
+            "http://example.com/comment" => nil,
+            "comment_en" => {"@id" => "http://example.com/comment", "@language" => "en"}
+          },
+          :input => [{
+            "http://example.com/comment" => [
+               {"@value" => "comment in english", "@language" => "en"},
+               {"@value" => "commentar auf deutsch", "@language" => "de"},
+               {"@value" => "日本語でのコメント", "@language" => "ja"},
+             ]
+          }],
+          :output => {
+            "@context" => {
+              "http://example.com/comment" => nil,
+              "comment_en" => {"@id" => "http://example.com/comment", "@language" => "en"}
+            },
+            "comment_en" => "comment in english",
+          }
+        },
+      }.each_pair do |title, params|
+        it title do
+          jld = JSON::LD::API.compact(params[:input], params[:context], nil, :debug => @debug)
+          jld.should produce(params[:output], @debug)
+        end
+      end
+    end
+
+    context "context as value" do
+      it "includes the context in the output document" do
+        ctx = {
+          "foo" => "http://example.com/"
+        }
+        input = {
+          "http://example.com/" => "bar"
+        }
+        expected = {
+          "@context" => {
+            "foo" => "http://example.com/"
+          },
+          "foo" => "bar"
+        }
+        jld = JSON::LD::API.compact(input, ctx, nil, :debug => @debug, :validate => true)
+        jld.should produce(expected, @debug)
+      end
+    end
+
+    context "context as reference" do
+      it "uses referenced context" do
+        ctx = StringIO.new(%q({"@context": {"b": "http://example.com/b"}}))
+        input = {
+          "http://example.com/b" => "c"
+        }
+        expected = {
+          "@context" => "http://example.com/context",
+          "b" => "c"
+        }
+        RDF::Util::File.stub(:open_file).with("http://example.com/context").and_yield(ctx)
+        jld = JSON::LD::API.compact(input, "http://example.com/context", nil, :debug => @debug, :validate => true)
+        jld.should produce(expected, @debug)
+      end
+    end
+
+    context "@graph" do
+      {
+        "Uses @graph given mutliple inputs" => {
+          :input => [
+            {"http://example.com/foo" => ["foo"]},
+            {"http://example.com/bar" => ["bar"]}
+          ],
+          :context => {"ex" => "http://example.com/"},
+          :output => {
+            "@context" => {"ex" => "http://example.com/"},
+            "@graph" => [
+              {"ex:foo"  => "foo"},
+              {"ex:bar" => "bar"}
+            ]
+          }
+        },
+        "Uses expanded subject definitions for subject references" => {
+          :input => [
+            {"@id" => "http://example.com/foo"},
+            {"@id" => "http://example.com/bar"}
+          ],
+          :context => {"ex" => "http://example.com/"},
+          :output => {
+            "@context" => {"ex" => "http://example.com/"},
+            "@graph" => [
+              {"@id" => "ex:foo"},
+              {"@id" => "ex:bar"}
+            ]
+          }
+        },
+      }.each_pair do |title, params|
+        it title do
+          jld = JSON::LD::API.compact(params[:input], params[:context], nil, :debug => @debug)
+          jld.should produce(params[:output], @debug)
+        end
+      end
+    end
+
+    context "exceptions" do
+      {
+        "@list containing @list" => {
+          :input => {
+            "http://example.org/foo" => {"@list" => [{"@list" => ["baz"]}]}
+          },
+          :exception => JSON::LD::ProcessingError::ListOfLists
+        },
+        "@list containing @list (with coercion)" => {
+          :input => {
+            "@context" => {"http://example.org/foo" => {"@container" => "@list"}},
+            "http://example.org/foo" => [{"@list" => ["baz"]}]
+          },
+          :exception => JSON::LD::ProcessingError::ListOfLists
+        },
+      }.each do |title, params|
+        it title do
+          lambda {JSON::LD::API.compact(params[:input], {}, nil)}.should raise_error(params[:exception])
+        end
+      end
+    end
+  end
+end