rdf 2.0.0.beta1 → 2.0.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d6b5ce1d8969fb6463efd82a7fe9826589bac799
-  data.tar.gz: e0c0066693ddc81d5089bf63f7502527750d1380
+  metadata.gz: 93fe92b9d0141e5c9537bdd33df4ac48b16dd614
+  data.tar.gz: 48c1f403490e61487a6d66cc2b9434e1199ddd2f
 SHA512:
-  metadata.gz: f866ac2a48e98e154bd786f6e0c30f5298e70c01de47847c660fded022f14ef58f19b0a727e20a53704d0d46f610cae4f53a08b5b2b94dc5f82d85da006e9d0b
-  data.tar.gz: ccede9fff108419d7d0df702df4dd8e8a24bd53be1e0aa0bd1a1986158ff5dcdbfd7bb824eb36cbe1dc0ea41243732bb49f0aec5dbbf869721595911e7f39709
+  metadata.gz: 766b89bac9456158ba2e3bc4640e5b3e4c361e4a20ac72737d259146223f224523f059f302331edb9a58ade726a03fc3f45e0672a404e47f73b9044529548aaa
+  data.tar.gz: e5327946f1f6b1d41e05b262b8fb64a4efeec329aafb14107e2e46a92c15b0e7cd217fded4e4339f83f034b6f87a690d1c387ebe21f8923e731e2006e4fc4201

data/README.md

@@ -79,12 +79,13 @@ Notably, {RDF::Queryable#query} and {RDF::Query#execute} are now completely symm
 When installed, RDF.rb includes a `rdf` shell script which acts as a wrapper to perform a number of different
 operations on RDF files using available readers and writers.
 
-* `serialize`: Parse an RDF input and re-serializing to [N-Triples][] or another available format using `--output-format` option.
 * `count`: Parse and RDF input and count the number of statements.
-* `subjects`: Returns unique subjects from parsed input.
-* `objects`: Returns unique objects from parsed input.
 * `predicates`: Returns unique objects from parsed input.
+* `objects`: Returns unique objects from parsed input.
+* `serialize`: Parse an RDF input and re-serializing to [N-Triples][] or another available format using `--output-format` option.
+* `subjects`: Returns unique subjects from parsed input.
 
+The `serialize` command can also be used to serialize as a vocabulary
 ## Examples
 
     require 'rdf'

data/VERSION

@@ -1 +1 @@
-2.0.0.beta1
+2.0.0.beta2

data/bin/rdf

@@ -11,8 +11,19 @@ options = RDF::CLI.options do
   self.on('-V', '--version', 'Display the RDF.rb version and exit.') do
     puts RDF::VERSION; exit
   end
+
+  ARGV.select {|a| RDF::CLI.commands.include?(a)}.each do |cmd|
+    # Load command-specific options
+    Array(RDF::CLI::COMMANDS[cmd.to_sym][:options]).each do |cli_opt|
+      on_args = cli_opt.on || []
+      on_args << cli_opt.description if cli_opt.description
+      self.on(*on_args) do |arg|
+        self.options[cli_opt.symbol] = cli_opt.call(arg)
+      end
+    end
+  end
 end
 
 abort options.banner if ARGV.empty? && !options.options[:evaluate]
 
-RDF::CLI.exec_command(command = ARGV.shift, ARGV, options.options)
+RDF::CLI.exec(ARGV, options.options)

data/lib/rdf/cli.rb

@@ -1,24 +1,19 @@
 require 'rdf'
 require 'rdf/ntriples'
 require 'rdf/nquads'
+require 'rdf/vocab/writer'
 require 'logger'
 require 'optparse'
 begin
-  gem 'linkeddata'
   require 'linkeddata'
 rescue LoadError
   # Silently load without linkeddata, but try some others
-  %w(rdfa rdfxml turtle).each do |ser|
+  %w(reasoner rdfa rdfxml turtle json/ld ld/patch).each do |ser|
     begin
-      require "rdf/#{ser}"
+      require ser.include?('/') ? ser : "rdf/#{ser}"
     rescue LoadError
     end
   end
-
-  begin
-    require 'json/ld'
-  rescue LoadError
-  end
 end
 
 class OptionParser
@@ -29,6 +24,10 @@ end
 module RDF
   # Individual formats can modify options by updating {Reader.options} or {Writer.options}. Format-specific commands are taken from {Format.cli_commands} for each loaded format, which returns an array of lambdas taking arguments and options.
   #
+  # Other than `help`, all commands parse an input file.
+  #
+  # Multiple commands may be added in sequence to execute a pipeline.
+  #
   # @example Creating Reader-specific options:
   #   class Reader
   #     def self.options
@@ -38,7 +37,11 @@ module RDF
   #           datatype: TrueClass,
   #           on: ["--canonicalize"],
   #           description: "Canonicalize input/output.") {true},
-  #         ...
+  #         RDF::CLI::Option.new(
+  #           symbol: :uri,
+  #           datatype: RDF::URI,
+  #           on: ["--uri STRING"],
+  #           description: "URI.") {|v| RDF::URI(v)},
   #       ]
   #     end
   #
@@ -46,18 +49,27 @@ module RDF
   #   class Format
   #     def self.cli_commands
   #       {
-  #         count: ->(argv, opts) do
-  #           count = 0
-  #           RDF::CLI.parse(argv, opts) do |reader|
-  #             reader.each_statement do |statement|
-  #               count += 1
-  #             end
-  #           end
-  #           $stdout.puts "Parsed #{count} statements"
-  #         end,
+  #         count: {
+  #           description: "",
+  #           parse: true,
+  #           lambda: ->(argv, opts) {}
+  #         },
   #       }
   #     end
   #
+  # @example Adding a command manually
+  #   class MyCommand
+  #     RDF::CLI.add_command(:count, description: "Count statements") do |argv, opts|
+  #       count = 0
+  #       RDF::CLI.parse(argv, opts) do |reader|
+  #         reader.each_statement do |statement|
+  #           count += 1
+  #         end
+  #       end
+  #       $stdout.puts "Parsed #{count} statements"
+  #     end
+  #   end
+  #     
   # Format-specific commands should verify that the reader and/or output format are appropriate for the command.
   class CLI
 
@@ -107,78 +119,102 @@ module RDF
 
     # @private
     COMMANDS = {
-      count: ->(argv, opts) do
-        start = Time.new
-        count = 0
-        self.parse(argv, opts) do |reader|
-          reader.each_statement do |statement|
-            count += 1
+      count: {
+        description: "Count statements in parsed input",
+        parse: false,
+        help: "count [options] [args...]\nreturns number of parsed statements",
+        lambda: ->(argv, opts) do
+          unless repository.count > 0
+            start = Time.new
+            count = 0
+            self.parse(argv, opts) do |reader|
+              reader.each_statement do |statement|
+                count += 1
+              end
+            end
+            secs = Time.new - start
+            $stdout.puts "Parsed #{count} statements with #{@readers.join(', ')} in #{secs} seconds @ #{count/secs} statements/second."
           end
         end
-        secs = Time.new - start
-        $stdout.puts "Parsed #{count} statements with #{@readers.join(', ')} in #{secs} seconds @ #{count/secs} statements/second."
-      end,
-      help: ->(argv, opts) do
-        self.usage(self.options)
-      end,
-      lenghts: ->(argv, opts) do
-        self.parse(argv, opts) do |reader|
-          reader.each_statement do |statement|
+      },
+      help: {
+        description: "This message",
+        parse: false,
+        lambda: ->(argv, opts) {self.usage(self.options)}
+      },
+      lengths: {
+        description: "Lengths of each parsed statement",
+        parse: true,
+        help: "lengths [options] [args...]\nreturns statement lengths",
+        lambda: ->(argv, opts) do
+          repository.each_statement do |statement|
             $stdout.puts statement.to_s.size
           end
         end
-      end,
-      objects: ->(argv, opts) do
-        $stdout.set_encoding(Encoding::UTF_8) if RUBY_PLATFORM == "java"
-        self.parse(argv, opts) do |reader|
-          reader.each_statement do |statement|
-            $stdout.puts statement.object.to_ntriples
+      },
+      objects: {
+        description: "Serialize each parsed object to N-Triples",
+        parse: true,
+        help: "objects [options] [args...]\nreturns unique objects",
+        lambda: ->(argv, opts) do
+          $stdout.puts "Objects"
+          repository.each_object do |object|
+            $stdout.puts object.to_ntriples
           end
         end
-      end,
-      predicates: ->(argv, opts) do
-        $stdout.set_encoding(Encoding::UTF_8) if RUBY_PLATFORM == "java"
-        self.parse(argv, opts) do |reader|
-          reader.each_statement do |statement|
-            $stdout.puts statement.predicate.to_ntriples
+      },
+      predicates: {
+        description: "Serialize each parsed predicate to N-Triples",
+        parse: true,
+        help: "predicates [options] [args...]\nreturns unique predicates",
+        lambda: ->(argv, opts) do
+          $stdout.puts "Predicates"
+          repository.each_predicate do |predicate|
+            $stdout.puts predicate.to_ntriples
           end
         end
-      end,
-      serialize: ->(argv, opts) do
-        writer_class = RDF::Writer.for(opts[:output_format]) || RDF::NTriples::Writer
-        out = opts[:output] || $stdout
-        out.set_encoding(Encoding::UTF_8) if out.respond_to?(:set_encoding) && RUBY_PLATFORM == "java"
-        opts = opts.merge(prefixes: {})
-        writer_opts = opts.merge(standard_prefixes: true)
-        self.parse(argv, opts) do |reader|
+      },
+      serialize: {
+        description: "Serialize each parsed statement to N-Triples, or the specified output format",
+        parse: true,
+        help: "serialize [options] [args...]\nserialize output using specified format (or n-triples if not specified)",
+        lambda: ->(argv, opts) do
+          writer_class = RDF::Writer.for(opts[:output_format]) || RDF::NTriples::Writer
+          out = opts[:output] || $stdout
+          opts = opts.merge(prefixes: {})
+          writer_opts = opts.merge(standard_prefixes: true)
           writer_class.new(out, writer_opts) do |writer|
-            writer << reader
+            writer << repository
           end
         end
-      end,
-      subjects: ->(argv, opts) do
-        $stdout.set_encoding(Encoding::UTF_8) if RUBY_PLATFORM == "java"
-        self.parse(argv, opts) do |reader|
-          reader.each_statement do |statement|
-            $stdout.puts statement.subject.to_ntriples
+      },
+      subjects: {
+        description: "Serialize each parsed subject to N-Triples",
+        parse: true,
+        help: "subjects [options] [args...]\nreturns unique subjects",
+        lambda: ->(argv, opts) do
+          $stdout.puts "Subjects"
+          repository.each_subject do |subject|
+            $stdout.puts subject.to_ntriples
           end
         end
-      end,
-      validate: ->(argv, opts) do
-        start = Time.new
-        count = 0
-        valid = true
-        self.parse(argv, opts) do |reader|
-          reader.each_statement do |statement|
-            count += 1
-            valid = false if statement.invalid?
-          end
+      },
+      validate: {
+        description: "Validate parsed input",
+        parse: true,
+        help: "validate [options] [args...]\nvalidates parsed input (may also be used with --validate)",
+        lambda: ->(argv, opts) do
+          $stdout.puts "Input is " + (repository.valid? ? "" :"in") + "valid"
         end
-        secs = Time.new - start
-        $stdout.puts "Validated #{count} statements with #{@readers.join(', ')} in #{secs} seconds @ #{count/secs} statements/second."
-      end
+      }
     }
 
+    class << self
+      # Repository containing parsed statements
+      # @return [RDF::Repository]
+      attr_accessor :repository
+    end
+
     ##
     # @return [String]
     def self.basename() File.basename($0) end
@@ -226,7 +262,7 @@ module RDF
           else options.instance_eval(&block)
         end
       end
-      options.banner ||= "Usage: #{self.basename} [options] command [args...]"
+      options.banner = "Usage: #{self.basename} command+ [options] [args...]"
 
       options.on('-d', '--debug',   'Enable debug output for troubleshooting.') do
         opts[:logger].level = Logger::DEBUG
@@ -276,6 +312,7 @@ module RDF
 
       options.on_tail("-h", "--help", "Show this message") do
         self.usage(options)
+        exit(0)
       end
 
       begin
@@ -289,7 +326,8 @@ module RDF
 
     ##
     # Output usage message
-    def self.usage(options)
+    def self.usage(options, banner: nil)
+      options.banner = banner if banner
       $stdout.puts options
       $stdout.puts "Note: available commands and options may be different depending on selected --input-format and/or --output-format."
       $stdout.puts "Available commands:\n\t#{self.commands.join("\n\t")}"
@@ -297,15 +335,47 @@ module RDF
     end
 
     ##
-    # @param  [#to_sym] command
+    # Execute one or more commands, parsing input as necessary
+    #
     # @param  [Array<String>] args
     # @return [Boolean]
-    def self.exec_command(command, args, options = {})
-      unless commands.include?(command.to_s)
-        abort "unknown command `#{command}'"
+    def self.exec(args, options = {})
+      out = options[:output] || $stdout
+      out.set_encoding(Encoding::UTF_8) if out.respond_to?(:set_encoding) && RUBY_PLATFORM == "java"
+      cmds, args = args.partition {|e| commands.include?(e.to_s)}
+
+      if cmds.empty?
+        usage(options)
+        abort "No command given"
+      end
+
+      if cmds.first == 'help'
+        on_cmd = cmds[1]
+        if on_cmd && COMMANDS.fetch(on_cmd.to_sym, {})[:help]
+          usage(self.options, banner: "Usage: #{self.basename.split('/').last} #{COMMANDS[on_cmd.to_sym][:help]}")
+        else
+          usage(self.options)
+        end
+        return
+      end
+
+      @repository = RDF::Repository.new
+
+      # Parse input files if any command requires it
+      if cmds.any? {|c| COMMANDS[c.to_sym][:parse]}
+        start = Time.new
+        count = 0
+        self.parse(args, options) do |reader|
+          @repository << reader
+        end
+        secs = Time.new - start
+        $stdout.puts "Parsed #{repository.count} statements with #{@readers.join(', ')} in #{secs} seconds @ #{count/secs} statements/second."
       end
 
-      COMMANDS[command.to_sym].call(args, options)
+      # Run each command in sequence
+      cmds.each do |command|
+        COMMANDS[command.to_sym][:lambda].call(args, options)
+      end
     rescue ArgumentError => e
       abort e.message
     end
@@ -316,8 +386,9 @@ module RDF
       # First, load commands from other formats
       unless @commands_loaded
         RDF::Format.each do |format|
-          format.cli_commands.each do |command, lambda|
-            COMMANDS[command] ||= lambda
+          format.cli_commands.each do |command, options|
+            options = {lambda: options} unless options.is_a?(Hash)
+            add_command(command, options)
           end
         end
         @commands_loaded = true
@@ -325,11 +396,29 @@ module RDF
       COMMANDS.keys.map(&:to_s).sort
     end
 
+    ##
+    # Add a command.
+    #
+    # @param [#to_sym] command
+    # @param [Hash{Symbol => String}] options
+    # @option options [String] description
+    # @option options [String] help string to display for help
+    # @option options [Boolean] parse parse input files in to Repository, or not.
+    # @option options [Array<RDF::CLI::Option>] options specific to this command
+    # @yield argv, opts
+    # @yieldparam [Array<String>] argv
+    # @yieldparam [Hash] opts
+    # @yieldreturn [void]
+    def self.add_command(command, options = {}, &block)
+      options[:lambda] = block if block_given?
+      COMMANDS[command.to_sym] ||= options
+    end
+
     ##
     # @return [Array<String>] list of available formats
     def self.formats(reader: false, writer: false)
-      f = RDF::Format.each.
-        select {|f| (reader ? f.reader : (writer ? f.writer : true))}.
+      f = RDF::Format.sort_by(&:to_sym).each.
+        select {|f| (reader ? f.reader : (writer ? f.writer : (f.reader || f.writer)))}.
         inject({}) do |memo, reader|
           memo.merge(reader.to_sym => reader.name)
       end

data/lib/rdf/format.rb

@@ -361,7 +361,7 @@ module RDF
 
     ##
     # Hash of CLI commands appropriate for this format
-    # @return [Hash{Symbol => Lambda(Array, Hash)}]
+    # @return [Hash{Symbol => {description: String, lambda: Lambda(Array, Hash)}}]
     def self.cli_commands
       {}
     end

data/lib/rdf/mixin/enumerable.rb

@@ -761,6 +761,15 @@ module RDF
       end
     end
 
+    ##
+    # @note this instantiates an writer; it could probably be done more 
+    #   efficiently by refactoring `RDF::Reader` and/or `RDF::Format` to expose
+    #   a list of valid format symbols.
+    def respond_to_missing?(name, include_private = false)
+      return RDF::Writer.for(name.to_s[3..-1].to_sym) if name.to_s[0,3] == 'to_'
+      super
+    end
+
     ##
     # @private
     # @param  [Symbol, #to_sym] method

data/lib/rdf/mixin/enumerator.rb

@@ -31,14 +31,11 @@ module RDF
       include Queryable
       include Enumerable
 
-      def method_missing(method, *args)
-        self.to_a if method.to_sym == :to_ary
-      end
-
       # Make sure returned arrays are also queryable
       def to_a
         return super.to_a.extend(RDF::Queryable, RDF::Enumerable)
       end
+      alias_method :to_ary, :to_a
     end
   end
-end
+end

data/lib/rdf/mixin/mutable.rb

@@ -260,6 +260,16 @@ module RDF
         super
       end
     end
+
+    ##
+    # @note this instantiates an entire reader; it could probably be done more 
+    #   efficiently by refactoring `RDF::Reader` and/or `RDF::Format` to expose
+    #   a list of valid format symbols.
+    def respond_to_missing?(name, include_private = false)
+      return RDF::Reader.for(name.to_s[5..-1].to_sym) if name.to_s[0,5] == 'from_'
+      super 
+    end
+
   protected
 
     ##

data/lib/rdf/mixin/transactable.rb

@@ -20,22 +20,37 @@ module RDF
     # Executes the given block in a transaction.
     #
     # @example running a transaction
-    #   repository.transaction do |tx|
+    #   repository.transaction(mutable: true) do |tx|
     #     tx.insert [RDF::URI("http://rubygems.org/gems/rdf"), RDF::RDFS.label, "RDF.rb"]
     #   end
     #
     # Raising an error within the transaction block causes automatic rollback.
     #
-    # @param mutable [Boolean] 
-    #   allows changes to the transaction, otherwise it is a read-only snapshot of the underlying repository.
-    # @yield  [tx]
-    # @yieldparam  [RDF::Transaction] tx
-    # @yieldreturn [void] ignored
-    # @return [self]
+    # @example manipulating a live transaction
+    #   tx = repository.transaction(mutable: true)
+    #   tx.insert [RDF::URI("http://rubygems.org/gems/rdf"), RDF::RDFS.label, "RDF.rb"]
+    #   tx.execute
+    #
+    # @overload transaction(mutable: false)
+    #   @param mutable [Boolean]
+    #   @return [RDF::Transaction] an open transaction; the client is 
+    #     responsible for closing the transaction via #execute or #rollback
+    #
+    # @overload transaction(mutable: false, &block)
+    #   @param mutable [Boolean] 
+    #     allows changes to the transaction, otherwise it is a read-only 
+    #     snapshot of the underlying repository.
+    #   @yield  [tx]
+    #   @yieldparam  [RDF::Transaction] tx
+    #   @yieldreturn [void] ignored
+    #   @return [self]
+    #
     # @see    RDF::Transaction
     # @since  0.3.0
     def transaction(mutable: false, &block)
       tx = begin_transaction(mutable: mutable)
+      return tx unless block_given?
+
       begin
         case block.arity
           when 1 then block.call(tx)

data/lib/rdf/model/literal/double.rb

@@ -27,7 +27,7 @@ module RDF; class Literal
           when 'INF'  then 1/0.0
           when '-INF' then -1/0.0
           when 'NaN'  then 0/0.0
-          else Float(value) rescue nil
+          else Float(value.sub(/\.[eE]/, '.0E')) rescue nil
         end
         when value.is_a?(::Float)     then value
         when value.respond_to?(:to_f) then value.to_f

data/lib/rdf/model/literal.rb

@@ -162,13 +162,13 @@ module RDF
     # @see http://www.w3.org/TR/rdf11-concepts/#section-Graph-Literal
     # @see http://www.w3.org/TR/rdf11-concepts/#section-Datatypes
     def initialize(value, options = {})
-      @object   = value
+      @object   = value.freeze
       @string   = options[:lexical] if options[:lexical]
       @string   = value if !defined?(@string) && value.is_a?(String)
-      @string   = @string.encode(Encoding::UTF_8) if @string
+      @string   = @string.encode(Encoding::UTF_8).freeze if @string
       @object   = @string if @string && @object.is_a?(String)
       @language = options[:language].to_s.downcase.to_sym if options[:language]
-      @datatype = RDF::URI(options[:datatype]) if options[:datatype]
+      @datatype = RDF::URI(options[:datatype]).freeze if options[:datatype]
       @datatype ||= self.class.const_get(:DATATYPE) if self.class.const_defined?(:DATATYPE)
       @datatype ||= @language ? RDF.langString : RDF::XSD.string
       raise ArgumentError, "datatype of rdf:langString requires a language" if !@language && @datatype == RDF::langString
@@ -425,7 +425,8 @@ module RDF
              gsub("\n", '\\n').
              gsub("\r", '\\r').
              gsub("\f", '\\f').
-             gsub('"', '\\"')
+             gsub('"', '\\"').
+             freeze
     end
 
     ##
@@ -433,7 +434,7 @@ module RDF
     #
     # @return [String]
     def to_s
-      @object.to_s
+      @object.to_s.freeze
     end
 
     ##
@@ -442,7 +443,7 @@ module RDF
     # @return [String]
     # @since 1.1.6
     def humanize(lang = :en)
-      to_s
+      to_s.freeze
     end
 
     ##

data/lib/rdf/model/node.rb

@@ -55,7 +55,7 @@ module RDF
     # @return [RDF::Node]
     # @since  0.2.0
     def self.intern(id)
-      (cache[id = id.to_s] ||= self.new(id)).freeze
+      (cache[(id = id.to_s).to_sym] ||= self.new(id)).freeze
     end
 
     ##
@@ -82,7 +82,7 @@ module RDF
     # @param  [#to_s] id
     def initialize(id = nil)
       id = nil if id.to_s.empty?
-      @id = (id || "g#{__id__.to_i.abs}").to_s
+      @id = (id || "g#{__id__.to_i.abs}").to_s.freeze
     end
 
     ##

data/lib/rdf/model/term.rb

@@ -56,14 +56,6 @@ module RDF
       super
     end
 
-    ##
-    # Returns a base representation of `self`.
-    #
-    # @return [RDF::Value]
-    def to_base
-      self
-    end
-
     ##
     # Returns `true` if `self` is a {RDF::Term}.
     #
@@ -85,7 +77,7 @@ module RDF
     #
     # @return [Sring]
     def to_base
-      RDF::NTriples.serialize(self)
+      RDF::NTriples.serialize(self).freeze
     end
 
     ##

data/lib/rdf/model/uri.rb

@@ -143,7 +143,7 @@ module RDF
     # @return [RDF::URI] an immutable, frozen URI object
     def self.intern(*args)
       str = args.first
-      (cache[str = str.to_s] ||= self.new(*args)).freeze
+      (cache[(str = str.to_s).to_sym] ||= self.new(*args)).freeze
     end
 
     ##
@@ -229,6 +229,7 @@ module RDF
         if @value.encoding != Encoding::UTF_8
           @value = @value.dup if @value.frozen?
           @value.force_encoding(Encoding::UTF_8)
+          @value.freeze
         end
       else
         %w(
@@ -815,7 +816,7 @@ module RDF
         path,
         ("?#{query}" if query),
         ("##{fragment}" if fragment)
-      ].compact.join("")
+      ].compact.join("").freeze
     end
 
     ##

data/lib/rdf/query/solution.rb

@@ -273,5 +273,11 @@ class RDF::Query
         super # raises NoMethodError
       end
     end
+
+    ##
+    # @return [Boolean]
+    def respond_to_missing?(name, include_private = false)
+      @bindings.has_key?(name.to_sym) || super
+    end
   end # Solution
 end # RDF::Query

data/lib/rdf/util/logger.rb

@@ -16,7 +16,13 @@ module RDF; module Util
     def logger(options = {})
       logger = options.fetch(:logger, @logger)
       logger = @options[:logger] if logger.nil? && @options
-      logger = (@options || options)[:logger] = $stderr if logger.nil?
+      if logger.nil?
+        # Unless otherwise specified, use $stderr
+        logger = (@options || options)[:logger] = $stderr
+
+        # Reset log_statistics so that it's not inherited across different instances
+        logger.log_statistics.clear if logger.respond_to?(:log_statistics)
+      end
       logger = (@options || options)[:logger] = ::Logger.new(::File.open(::File::NULL, "w"))  unless logger # Incase false was used, which is frozen
       logger.extend(LoggerBehavior) unless logger.is_a?(LoggerBehavior)
       logger
@@ -267,6 +273,13 @@ module RDF; module Util
           super
         end
       end
+      
+      def respond_to_missing?(name, include_private = false)
+        return true if 
+          [:fatal, :error, :warn, :info, :debug, :level, :sev_threshold]
+          .include?(name.to_sym)
+        super
+      end
     end
   end # Logger
 end; end # RDF::Util

data/lib/rdf/vocab/writer.rb

@@ -0,0 +1,176 @@
+require 'rdf'
+require 'rdf/vocabulary'
+
+module RDF
+  ##
+  # Vocabulary format specification. This can be used to generate a Ruby class definition from a loaded vocabulary.
+  #
+  class Vocabulary
+    class Format < RDF::Format
+      content_encoding 'utf-8'
+      writer { RDF::Vocabulary::Writer }
+    end
+
+    class Writer < RDF::Writer
+      include RDF::Util::Logger
+      format RDF::Vocabulary::Format
+
+      attr_accessor :class_name, :module_name
+
+      def self.options
+        [
+          RDF::CLI::Option.new(
+            symbol: :class_name,
+            datatype: String,
+            on: ["--class-name NAME"],
+            description: "Name of created Ruby class (vocabulary format)."),
+          RDF::CLI::Option.new(
+            symbol: :module_name,
+            datatype: String,
+            on: ["--module-name NAME"],
+            description: "Name of Ruby module containing class-name (vocabulary format)."),
+          RDF::CLI::Option.new(
+            symbol: :strict,
+            datatype: TrueClass,
+            on: ["--strict"],
+            description: "Make strict vocabulary"
+          ) {true},
+          RDF::CLI::Option.new(
+            symbol: :extra,
+            datatype: String,
+            on: ["--extra URIEncodedJSON"],
+            description: "URI Encoded JSON representation of extra data"
+          ) {|arg| ::JSON.parse(::URI.decode(arg))},
+        ]
+      end
+
+      ##
+      # Initializes the writer.
+      #
+      # @param  [IO, File] output
+      #   the output stream
+      # @param  [Hash{Symbol => Object}] options = ({})
+      #   any additional options. See {RDF::Writer#initialize}
+      # @option options [RDF::URI]  :base_uri
+      #   URI of this vocabulary
+      # @option options [String]  :class_name
+      #   Class name for this vocabulary
+      # @option options [String]  :module_name ("RDF")
+      #   Module name for this vocabulary
+      # @option options [Hash] extra
+      #   Extra properties to add to the output (programatic only)
+      # @option options [String] patch
+      #   An LD Patch to run against the graph before writing
+      # @option options [Boolean] strict (false)
+      #   Create an RDF::StrictVocabulary instead of an RDF::Vocabulary
+      # @yield  [writer] `self`
+      # @yieldparam  [RDF::Writer] writer
+      # @yieldreturn [void]
+      def initialize(output = $stdout, options = {}, &block)
+        options.fetch(:base_uri) {raise ArgumentError, "base_uri option required"}
+        @graph = RDF::Repository.new
+        super
+      end
+
+      def write_triple(subject, predicate, object)
+        @graph << RDF::Statement(subject, predicate, object)
+      end
+
+      # Generate vocabulary
+      #
+      def write_epilogue
+        class_name = options[:class_name]
+        module_name = options.fetch(:module_name, "RDF")
+        source = options.fetch(:location, base_uri)
+        strict = options.fetch(:strict, false)
+
+        # Passing a graph for the location causes it to serialize the written triples.
+        vocab = RDF::Vocabulary.from_graph(@graph,
+                                           url: base_uri,
+                                           class_name: class_name,
+                                           extra: options[:extra])
+
+        @output.print %(# -*- encoding: utf-8 -*-
+          # frozen_string_literal: true
+          # This file generated automatically using vocab-fetch from #{source}
+          require 'rdf'
+          module #{module_name}
+            # @!parse
+            #   # Vocabulary for <#{base_uri}>
+            #   class #{vocab.name} < RDF::#{"Strict" if strict}Vocabulary
+            #   end
+            class #{vocab.name} < RDF::#{"Strict" if strict}Vocabulary("#{base_uri}")
+          ).gsub(/^          /, '')
+
+        # Split nodes into Class/Property/Datatype/Other
+        term_nodes = {
+          class: {},
+          property: {},
+          datatype: {},
+          other: {}
+        }
+
+        vocab.each.to_a.sort.each do |term|
+          name = term.to_s[base_uri.length..-1].to_sym
+          kind = begin
+            case term.type.to_s
+            when /Class/    then :class
+            when /Property/ then :property
+            when /Datatype/ then :datatype
+            else                 :other
+            end
+          rescue KeyError
+            # This can try to resolve referenced terms against the previous version of this vocabulary, which may be strict, and fail if the referenced term hasn't been created yet.
+            :other
+          end
+          term_nodes[kind][name] = term.attributes
+        end
+
+        {
+          class: "Class definitions",
+          property: "Property definitions",
+          datatype: "Datatype definitions",
+          other: "Extra definitions"
+        }.each do |tt, comment|
+          next if term_nodes[tt].empty?
+          @output.puts "\n    # #{comment}"
+          term_nodes[tt].each {|name, attributes| from_node name, attributes, tt}
+        end
+
+        # Query the vocabulary to extract property and class definitions
+        @output.puts "  end\nend"
+      end
+
+    private
+      ##
+      # Turn a node definition into a property/term expression
+      def from_node(name, attributes, term_type)
+        op = term_type == :property ? "property" : "term"
+
+        components = ["    #{op} #{name.to_sym.inspect}"]
+        attributes.keys.sort_by(&:to_s).map(&:to_sym).each do |key|
+          next if key == :vocab
+          value = Array(attributes[key])
+          component = key.inspect.start_with?(':"') ? "#{key.inspect} => " : "#{key.to_s}: "
+          value = value.first if value.length == 1
+          component << if value.is_a?(Array)
+            '[' + value.map {|v| serialize_value(v, key)}.sort.join(", ") + "]"
+          else
+            serialize_value(value, key)
+          end
+          components << component
+        end
+        @output.puts components.join(",\n      ")
+      end
+
+      def serialize_value(value, key)
+        case key.to_s
+        when "comment", /:/
+          "%(#{value.gsub('(', '\(').gsub(')', '\)')}).freeze"
+        else
+          "#{value.inspect}.freeze"
+        end
+      end
+    end
+  end
+end

data/lib/rdf/vocabulary.rb

@@ -263,27 +263,24 @@ module RDF
       end
 
       ##
-      # Load a vocabulary, optionally from a separate location.
+      # Load an RDFS vocabulary, optionally from a separate location.
       #
       # @param [URI, #to_s] url
       # @param [String] class_name
       #   The class_name associated with the vocabulary, used for creating the class name of the vocabulary. This will create a new class named with a top-level constant based on `class_name`.
-      # @param [URI, #to_s] location
-      #   Location from which to load the vocabulary, if not from `uri`.
+      # @param [RDF::Queryable, URI, #to_s] location
+      #   Location from which to load the vocabulary, or Queryable containing already loaded vocabulary triples, if not from `uri`.
       # @param [Array<Symbol>, Hash{Symbol => Hash}] extra
       #   Extra terms to add to the vocabulary. In the first form, it is an array of symbols, for which terms are created. In the second, it is a Hash mapping symbols to property attributes, as described in {RDF::Vocabulary.property}.
       # @param [String] patch
       #   A patch to run on the graph after loading. Requires the `ld-patch` gem to be available.
       # @return [RDF::Vocabulary] the loaded vocabulary
+      # @deprecated Use Vocabulary.from_graph
       def load(url, class_name: nil, location: nil, extra: nil, patch: nil)
+        warn "[DEPRECATION] Vocabulary.load is deprecated, use Vocabulary.from_graph instead. Called from #{Gem.location_of_caller.join(':')}"
         source = location || url
-        vocab = if class_name
-          Object.const_set(class_name, Class.new(self.create(url)))
-        else
-          Class.new(self.create(url))
-        end
 
-        graph = RDF::Repository.load(source)
+        graph = source.is_a?(RDF::Queryable) ? source : RDF::Repository.load(source)
 
         if patch
           begin
@@ -294,6 +291,27 @@ module RDF
             raise ArgumentError, "patching vocabulary requires the ld-patch gem"
           end
         end
+
+        from_graph(graph, url: url, class_name: nil, extra: extra)
+      end
+
+      ##
+      # Create a vocabulary from a graph or enumerable
+      #
+      # @param [RDF::Enumerable] graph
+      # @param [URI, #to_s] url
+      # @param [String] class_name
+      #   The class_name associated with the vocabulary, used for creating the class name of the vocabulary. This will create a new class named with a top-level constant based on `class_name`.
+      # @param [Array<Symbol>, Hash{Symbol => Hash}] extra
+      #   Extra terms to add to the vocabulary. In the first form, it is an array of symbols, for which terms are created. In the second, it is a Hash mapping symbols to property attributes, as described in {RDF::Vocabulary.property}.
+      # @return [RDF::Vocabulary] the loaded vocabulary
+      def from_graph(graph, url: nil, class_name: nil, extra: nil)
+        vocab = if class_name
+          Object.const_set(class_name, Class.new(self.create(url)))
+        else
+          Class.new(self.create(url))
+        end
+
         term_defs = {}
         graph.each do |statement|
           next unless statement.subject.uri? && statement.subject.start_with?(url)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rdf
 version: !ruby/object:Gem::Version
-  version: 2.0.0.beta1
+  version: 2.0.0.beta2
 platform: ruby
 authors:
 - Arto Bendiken
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-22 00:00:00.000000000 Z
+date: 2016-04-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: link_header
@@ -38,14 +38,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rdf-spec
   requirement: !ruby/object:Gem::Requirement
@@ -223,7 +223,6 @@ files:
 - lib/rdf.rb
 - lib/rdf/changeset.rb
 - lib/rdf/cli.rb
-- lib/rdf/cli/vocab-loader.rb
 - lib/rdf/format.rb
 - lib/rdf/mixin/countable.rb
 - lib/rdf/mixin/durable.rb
@@ -279,6 +278,7 @@ files:
 - lib/rdf/vocab/owl.rb
 - lib/rdf/vocab/rdfs.rb
 - lib/rdf/vocab/rdfv.rb
+- lib/rdf/vocab/writer.rb
 - lib/rdf/vocab/xsd.rb
 - lib/rdf/vocabulary.rb
 - lib/rdf/writer.rb
@@ -302,7 +302,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: rdf
-rubygems_version: 2.5.1
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: A Ruby library for working with Resource Description Framework (RDF) data.

data/lib/rdf/cli/vocab-loader.rb

@@ -1,192 +0,0 @@
-require 'rdf'
-require 'linkeddata'
-require 'optparse'
-
-module RDF
-  # Utility class to load RDF vocabularies from files or their canonical
-  # definitions and emit either a class file for RDF::StrictVocabulary,
-  # RDF::Vocabulary or the raw RDF vocabulary
-  class VocabularyLoader
-    def initialize(class_name = nil)
-      @class_name = class_name
-      @module_name = "RDF"
-      @output = $stdout
-      @output_class_file = true
-      @uri = nil
-      @strict = true
-      @extra = []
-    end
-    attr_accessor :class_name, :module_name, :output, :output_class_file
-    attr_reader :uri, :source
-
-    # Set the URI for the loaded RDF file - by default, sets the source as
-    # well
-    def uri=(uri)
-      @uri = uri
-      @source ||= uri
-    end
-
-    # Set the source for the loaded RDF - by default, sets the URI as well
-    def source=(uri)
-      @source = uri
-      @uri ||= uri
-    end
-
-    # Set output
-    def output=(out)
-      @output = out
-    end
-
-    # Extra properties to define
-    def extra=(extra)
-      @extra = extra
-    end
-
-    # patch to run over loaded vocabulary
-    def patch=(patch)
-      @patch = patch
-    end
-
-    # Use StrictVocabulary or Vocabulary
-    def strict=(strict)
-      @strict = strict
-    end
-
-    # Parses arguments, for use in a command line tool
-    def parse_options(argv)
-      opti = OptionParser.new
-      opti.banner = "Usage: #{File.basename($0)} [options] [uri]\nFetch an RDFS file and produce an RDF::StrictVocabulary with it.\n\n"
-
-      opti.on("--uri URI", "The URI for the fetched RDF vocabulary") do |uri|
-        self.uri = uri
-      end
-
-      opti.on("--source SOURCE", "The source URI or file for the vocabulary") do |uri|
-        self.source = uri
-      end
-
-      opti.on("--class-name NAME", "The class name for the output StrictVocabulary subclass") do |name|
-        self.class_name = name
-      end
-
-      opti.on("--module-name NAME", "The module name for the output StrictVocabulary subclass") do |name|
-        self.module_name = name
-      end
-
-      opti.on("--raw", "Don't output an output file - just the RDF") do
-        @output_class_file = false
-      end
-
-      opti.on_tail("--help", "This help text") do
-        $stdout.puts opti
-        exit 1
-      end
-
-      others = opti.parse(argv)
-
-      if @class_name.nil? and @output_class_file
-        raise "Class name (--class-name) is required!"
-      end
-
-      uri ||= others.first
-    end
-
-    # Parse command line arguments and run the load-and-emit process
-    def go(argv)
-      parse_options(argv)
-      run
-
-      if @output != $stdout
-        @output.close
-      end
-    end
-
-    ##
-    # Turn a node definition into a property/term expression
-    def from_node(name, attributes, term_type)
-      op = term_type == :property ? "property" : "term"
-
-      components = ["    #{op} #{name.to_sym.inspect}"]
-      attributes.keys.sort_by(&:to_s).each do |key|
-        next if key == :vocab
-        value = Array(attributes[key])
-        component = key.is_a?(Symbol) ? "#{key}: " : ":#{key.inspect} => "
-        value = value.first if value.length == 1
-        component << if value.is_a?(Array)
-          '[' + value.map {|v| serialize_value(v, key)}.sort.join(", ") + "]"
-        else
-          serialize_value(value, key)
-        end
-        components << component
-      end
-      @output.puts components.join(",\n      ")
-    end
-
-    def serialize_value(value, key)
-      case key
-      when :comment, String
-        "%(#{value.gsub('(', '\(').gsub(')', '\)')}).freeze"
-      else
-        "#{value.inspect}.freeze"
-      end
-    end
-
-    # Actually executes the load-and-emit process - useful when using this
-    # class outside of a command line - instantiate, set attributes manually,
-    # then call #run
-    def run
-      @output.print %(# -*- encoding: utf-8 -*-
-        # frozen_string_literal: true
-        # This file generated automatically using vocab-fetch from #{source}
-        require 'rdf'
-        module #{module_name}
-          # @!parse
-          #   # Vocabulary for <#{uri}>
-          #   class #{class_name} < RDF::#{"Strict" if @strict}Vocabulary
-          #   end
-          class #{class_name} < RDF::#{"Strict" if @strict}Vocabulary("#{uri}")
-        ).gsub(/^        /, '') if @output_class_file
-
-      # Extract statements with subjects that have the vocabulary prefix and organize into a hash of properties and values
-      vocab = RDF::Vocabulary.load(uri, location: source, extra: @extra, patch: @patch)
-
-      # Split nodes into Class/Property/Datatype/Other
-      term_nodes = {
-        class: {},
-        property: {},
-        datatype: {},
-        other: {}
-      }
-
-      vocab.each.to_a.sort.each do |term|
-        name = term.to_s[uri.length..-1].to_sym
-        kind = begin
-          case term.type.to_s
-          when /Class/    then :class
-          when /Property/ then :property
-          when /Datatype/ then :datatype
-          else                 :other
-          end
-        rescue KeyError
-          # This can try to resolve referenced terms against the previous version of this vocabulary, which may be strict, and fail if the referenced term hasn't been created yet.
-          :other
-        end
-        term_nodes[kind][name] = term.attributes
-      end
-
-      {
-        class: "Class definitions",
-        property: "Property definitions",
-        datatype: "Datatype definitions",
-        other: "Extra definitions"
-      }.each do |tt, comment|
-        next if term_nodes[tt].empty?
-        @output.puts "\n    # #{comment}"
-        term_nodes[tt].each {|name, attributes| from_node name, attributes, tt}
-      end
-
-      # Query the vocabulary to extract property and class definitions
-      @output.puts "  end\nend" if @output_class_file
-    end
-  end
-end