fiveruns-dash-ruby 0.8.3 → 0.8.4

data/README.rdoc

@@ -18,10 +18,6 @@ See the Ruby support pages, http://support.fiveruns.com/faqs/dash/ruby, for info
 
 The FiveRuns Development Team & Dash community
 
-== Dependencies
-
-* The json gem
-
 == Platforms
 
 This library has only been tested on OSX and Linux.  The `ruby' recipe (which collects metrics on the Ruby process) currently relies on `ps' -- so will not work on Windows.  We're actively looking for contributions to widen the number of platforms we support; please help!
@@ -40,6 +36,11 @@ Please join the dash-users Google group, http://groups.google.com/group/dash-use
 
 You can also contact us via Twitter, Campfire, or email; see the main help page, http://support.fiveruns.com, for details.
 
+== Note
+
+This project contains a modified copy of the json_pure gem source code, which is distributed under
+the Ruby license <http://www.ruby-lang.org/en/LICENSE.txt> by Florian Frank <flori@ping.de>.
+
 == License
 
   # (The FiveRuns License)

data/Rakefile

@@ -19,7 +19,6 @@ begin
     s.description = "Provides an API to send metrics to the FiveRuns Dash service" 
     s.authors = ["FiveRuns Development Team"] 
     s.files =  FileList['README.rdoc', 'Rakefile', 'version.yml', "{lib,test,recipes,examples}/**/*", ] 
-    s.add_dependency 'json' 
   end 
 rescue LoadError 
   puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com" 
@@ -35,4 +34,4 @@ task :coverage do
     FileUtils.cp_r 'coverage', ccout
   end
   system "open coverage/index.html" if PLATFORM['darwin']
-end
+end

data/lib/fiveruns/dash.rb

@@ -1,5 +1,9 @@
 require 'rubygems'
-require 'json'
+
+module Fiveruns; end
+
+# Pull in our forked copy of the pure JSON gem
+require 'fiveruns/json'
 
 require 'pathname'
 require 'thread'
@@ -10,9 +14,6 @@ $:.unshift(File.dirname(__FILE__))
 
 # NB: Pre-load ALL Dash files here so we do not accidentally
 # use ActiveSupport's autoloading.
-
-module Fiveruns; end
-
 require 'dash/version'
 require 'dash/util'
 require 'dash/configuration'

data/lib/fiveruns/dash/metric.rb

@@ -47,8 +47,9 @@ module Fiveruns::Dash
           Please set the :ar_total_time option when configuring Dash:
 
           # Define an application-specific metric cooresponding to the total processing time for this app.
+          # You must mark this time so Dash can ignore any AR activity outside of the call stack.
           Fiveruns::Dash.register_recipe :loader, :url => 'http://dash.fiveruns.com' do |recipe|
-            recipe.time :total_time, 'Load Time', :method => 'Loader::Engine#load'
+            recipe.time :total_time, 'Load Time', :method => 'Loader::Engine#load', :mark => true
           end
 
           # Pass the name of this custom metric to Dash so it will be used in the AR metric calculations.

data/lib/fiveruns/dash/reporter.rb

@@ -51,7 +51,7 @@ module Fiveruns::Dash
     def send_trace(trace)
       if trace.data
         payload = TracePayload.new(trace)
-        Fiveruns::Dash.logger.debug "Sending trace: #{payload.to_json}"
+        Fiveruns::Dash.logger.debug "Sending trace: #{payload.to_fjson}"
         Thread.new { Update.new(payload).store(*update_locations) }
       else
         Fiveruns::Dash.logger.debug "No trace to send"      
@@ -81,7 +81,9 @@ module Fiveruns::Dash
       %w(INT TERM).each do |sym|
         TRAPS[sym] = Signal.trap(sym) do
           stop
-          TRAPS[sym].call if TRAPS[sym]
+          if TRAPS[sym] and TRAPS[sym].respond_to?(:call)
+            TRAPS[sym].call
+          end
         end
       end
     end
@@ -134,7 +136,7 @@ module Fiveruns::Dash
     def send_info_update
       @info_update_sent ||= begin
         payload = InfoPayload.new(@session.info, @started_at)
-        Fiveruns::Dash.logger.debug "Sending info: #{payload.to_json}"
+        Fiveruns::Dash.logger.debug "Sending info: #{payload.to_fjson}"
         result = Update.new(payload).store(*update_locations)
         send_fake_info(payload)
         result
@@ -148,7 +150,7 @@ module Fiveruns::Dash
           Fiveruns::Dash.logger.debug "No exceptions for this interval"
         else
           payload = ExceptionsPayload.new(data)
-          Fiveruns::Dash.logger.debug "Sending exceptions: #{payload.to_json}"
+          Fiveruns::Dash.logger.debug "Sending exceptions: #{payload.to_fjson}"
           Update.new(payload).store(*update_locations)
         end        
       else
@@ -162,7 +164,7 @@ module Fiveruns::Dash
       if @info_update_sent
         data = @session.data
         payload = DataPayload.new(data)
-        Fiveruns::Dash.logger.debug "Sending data: #{payload.to_json}"
+        Fiveruns::Dash.logger.debug "Sending data: #{payload.to_fjson}"
         result = Update.new(payload).store(*update_locations)
         send_fake_data(payload)
         result
@@ -184,7 +186,7 @@ module Fiveruns::Dash
     def send_fake_data(payload)
       fake_host_count.times do |idx|
         payload.params[:process_id] = Fiveruns::Dash.process_ids[idx+1]
-        Fiveruns::Dash.logger.debug "Sending data: #{payload.to_json}"
+        Fiveruns::Dash.logger.debug "Sending data: #{payload.to_fjson}"
         Update.new(payload).store(*update_locations)
       end
     end
@@ -194,7 +196,7 @@ module Fiveruns::Dash
       fake_host_count.times do |idx|
         payload.params[:mac] += idx.to_s
         payload.params[:hostname] = host + idx.to_s
-        Fiveruns::Dash.logger.debug "Sending info: #{payload.to_json}"
+        Fiveruns::Dash.logger.debug "Sending info: #{payload.to_fjson}"
         Update.new(payload).store(*update_locations)
       end
     end

data/lib/fiveruns/dash/store/file.rb

@@ -10,7 +10,7 @@ module Fiveruns::Dash::Store
     end
     
     def write_to(path)
-      ::File.open(path, 'w') { |f| f.write @payload.to_json }
+      ::File.open(path, 'w') { |f| f.write @payload.to_fjson }
     end
     
     def filename(directory)

data/lib/fiveruns/dash/store/http.rb

@@ -68,8 +68,8 @@ module Fiveruns::Dash::Store
       end
       case response.code.to_i
       when 201
-        data = JSON.load(response.body)
-        set_trace_contexts(data)
+        # data = Fiveruns::JSON.load(response.body)
+        # set_trace_contexts(data)
         true
       when 400..499
         Fiveruns::Dash.logger.warn "Could not access Dash service (#{response.code.to_i}, #{response.body.inspect})"
@@ -78,9 +78,9 @@ module Fiveruns::Dash::Store
         Fiveruns::Dash.logger.debug "Received unknown response from Dash service (#{response.inspect})"
         false
       end
-    rescue JSON::ParserError => e
+    rescue Fiveruns::JSON::ParserError => e
       puts response.body
-      Fiveruns::Dash.logger.error "Received non-JSON response (#{response.inspect})"
+      Fiveruns::Dash.logger.error "Received non-FiverunsJSON response (#{response.inspect})"
       false
     end
     

data/lib/fiveruns/dash/trace.rb

@@ -27,10 +27,10 @@ module Fiveruns::Dash
       end
     end
         
-    def to_json
+    def to_fjson
       { :context => context,
         :data => (@data || {})
-      }.to_json
+      }.to_fjson
     end
     
     private
@@ -51,11 +51,11 @@ module Fiveruns::Dash
         @children ||= []
       end
             
-      def to_json
+      def to_fjson
         {
           :metrics => metrics,
           :children => children,
-        }.to_json
+        }.to_fjson
       end
       
     end

data/lib/fiveruns/dash/update.rb

@@ -27,7 +27,7 @@ module Fiveruns::Dash
         response = http.post("/apps/#{token}/ping", multipart.to_s, "Content-Type" => multipart.content_type)
         case response.code.to_i
         when 201
-          data = JSON.load(response.body)
+          data = ::Fiveruns::JSON.load(response.body)
           [:success, "Found application '#{data['name']}'"]
         else
           # Error message
@@ -133,8 +133,8 @@ module Fiveruns::Dash
       {}
     end
     
-    def to_json
-      @data.to_json
+    def to_fjson
+      @data.to_fjson
     end
     
     #######
@@ -146,7 +146,7 @@ module Fiveruns::Dash
     end
 
     def compressed
-      Zlib::Deflate.deflate(to_json)
+      Zlib::Deflate.deflate(to_fjson)
     end
 
   end

data/lib/fiveruns/json.rb

@@ -0,0 +1,15 @@
+# Private copy of JSON for FiveRuns Dash as the current state of JSON/Ruby is
+# nightmarish for library authors.  ActiveSupport and JSON have incompatability
+# issues and supporting/fixing them is not worth it.
+#
+# == Authors
+#
+# Florian Frank <mailto:flori@ping.de>
+# FiveRuns Development Team
+
+require 'fiveruns/json/version'
+require 'fiveruns/json/common'
+require 'fiveruns/json/generator'
+require 'fiveruns/json/pure'
+require 'fiveruns/json/add/core'
+require 'fiveruns/json/add/rails'

data/lib/fiveruns/json/add/core.rb

@@ -0,0 +1,131 @@
+# This file contains implementations of ruby core's custom objects for
+# serialisation/deserialisation.
+
+require 'date'
+
+class Time
+  def self.fjson_create(object)
+    if usec = object.delete('u') # used to be tv_usec -> tv_nsec
+      object['n'] = usec * 1000
+    end
+    if respond_to?(:tv_nsec)
+      at(*object.values_at('s', 'n'))
+    else
+      at(object['s'], object['n'] / 1000)
+    end
+  end
+
+  def to_fjson(*args)
+    {
+      'json_class' => self.class.name,
+      's' => tv_sec,
+      'n' => respond_to?(:tv_nsec) ? tv_nsec : tv_usec * 1000
+    }.to_fjson(*args)
+  end
+end
+
+class Date
+  def self.fjson_create(object)
+    civil(*object.values_at('y', 'm', 'd', 'sg'))
+  end
+
+  alias start sg unless method_defined?(:start)
+
+  def to_fjson(*args)
+    {
+      'json_class' => self.class.name,
+      'y' => year,
+      'm' => month,
+      'd' => day,
+      'sg' => start,
+    }.to_fjson(*args)
+  end
+end
+
+class DateTime
+  def self.fjson_create(object)
+    args = object.values_at('y', 'm', 'd', 'H', 'M', 'S')
+    of_a, of_b = object['of'].split('/')
+    if of_b and of_b != '0'
+      args << Rational(of_a.to_i, of_b.to_i)
+    else
+      args << of_a
+    end
+    args << object['sg']
+    civil(*args)
+  end
+
+  alias start sg unless method_defined?(:start)
+
+  def to_fjson(*args)
+    {
+      'json_class' => self.class.name,
+      'y' => year,
+      'm' => month,
+      'd' => day,
+      'H' => hour,
+      'M' => min,
+      'S' => sec,
+      'of' => offset.to_s,
+      'sg' => start,
+    }.to_fjson(*args)
+  end
+end
+
+class Range
+  def self.fjson_create(object)
+    new(*object['a'])
+  end
+
+  def to_fjson(*args)
+    {
+      'json_class'   => self.class.name,
+      'a'         => [ first, last, exclude_end? ]
+    }.to_fjson(*args)
+  end
+end
+
+class Struct
+  def self.fjson_create(object)
+    new(*object['v'])
+  end
+
+  def to_fjson(*args)
+    klass = self.class.name
+    klass.empty? and raise Fiveruns::JSON::JSONError, "Only named structs are supported!"
+    {
+      'json_class' => klass,
+      'v'     => values,
+    }.to_fjson(*args)
+  end
+end
+
+class Exception
+  def self.fjson_create(object)
+    result = new(object['m'])
+    result.set_backtrace object['b']
+    result
+  end
+
+  def to_fjson(*args)
+    {
+      'json_class' => self.class.name,
+      'm'   => message,
+      'b' => backtrace,
+    }.to_fjson(*args)
+  end
+end
+
+class Regexp
+  def self.fjson_create(object)
+    new(object['s'], object['o'])
+  end
+
+  def to_fjson(*)
+    {
+      'json_class' => self.class.name,
+      'o' => options,
+      's' => source,
+    }.to_fjson
+  end
+end

data/lib/fiveruns/json/add/rails.rb

@@ -0,0 +1,55 @@
+# This file contains implementations of rails custom objects for
+# serialisation/deserialisation.
+
+require 'fiveruns/json'
+
+class Object
+  def self.fjson_create(object)
+    obj = new
+    for key, value in object
+      next if key == 'json_class'
+      instance_variable_set "@#{key}", value
+    end
+    obj
+  end
+
+  def to_fjson(*a)
+    result = {
+      'json_class' => self.class.name
+    }
+    instance_variables.inject(result) do |r, name|
+      r[name[1..-1]] = instance_variable_get name
+      r
+    end
+    result.to_fjson(*a)
+  end
+end
+
+class Symbol
+  def to_fjson(*a)
+    to_s.to_fjson(*a)
+  end
+end
+
+module Enumerable
+  def to_fjson(*a)
+    to_a.to_fjson(*a)
+  end
+end
+
+# class Regexp
+#   def to_json(*)
+#     inspect
+#   end
+# end
+#
+# The above rails definition has some problems:
+#
+# 1. { 'foo' => /bar/ }.to_json # => "{foo: /bar/}"
+#    This isn't valid FiverunsJSON, because the regular expression syntax is not
+#    defined in RFC 4627. (And unquoted strings are disallowed there, too.)
+#    Though it is valid Javascript.
+#
+# 2. { 'foo' => /bar/mix }.to_json # => "{foo: /bar/mix}"
+#    This isn't even valid Javascript.
+

data/lib/fiveruns/json/common.rb

@@ -0,0 +1,352 @@
+module Fiveruns::JSON
+  class << self
+    # If _object_ is string-like parse the string and return the parsed result
+    # as a Ruby data structure. Otherwise generate a FiverunsJSON text from the Ruby
+    # data structure object and return it.
+    #
+    # The _opts_ argument is passed through to generate/parse respectively, see
+    # generate and parse for their documentation.
+    def [](object, opts = {})
+      if object.respond_to? :to_str
+        ::Fiveruns::JSON.parse(object.to_str, opts => {})
+      else
+        ::Fiveruns::JSON.generate(object, opts => {})
+      end
+    end
+
+    # Returns the FiverunsJSON parser class, that is used by FiverunsJSON. This might be either
+    # FiverunsJSON::Ext::Parser or FiverunsJSON::Pure::Parser.
+    attr_reader :parser
+
+    # Set the FiverunsJSON parser class _parser_ to be used by FiverunsJSON.
+    # def parser=(parser) # :nodoc:
+    #   @parser = parser
+    #   remove_const :Parser if const_defined? :Parser
+    #   const_set :Parser, parser
+    # end
+
+    # Return the constant located at _path_. The format of _path_ has to be
+    # either ::A::B::C or A::B::C. In any case A has to be located at the top
+    # level (absolute namespace path?). If there doesn't exist a constant at
+    # the given path, an ArgumentError is raised.
+    def deep_const_get(path) # :nodoc:
+      path = path.to_s
+      path.split(/::/).inject(Object) do |p, c|
+        case
+        when c.empty?             then p
+        when p.const_defined?(c)  then p.const_get(c)
+        else                      raise ArgumentError, "can't find const #{path}"
+        end
+      end
+    end
+
+    # Set the module _generator_ to be used by FiverunsJSON.
+    def generator=(generator) # :nodoc:
+      @generator = generator
+      generator_methods = generator::GeneratorMethods
+      for const in generator_methods.constants
+        klass = deep_const_get(const)
+        modul = generator_methods.const_get(const)
+        klass.class_eval do
+          instance_methods(false).each do |m|
+            m.to_s == 'to_fjson' and remove_method m
+          end
+          include modul
+        end
+      end
+      self.state = generator::State
+      const_set :State, self.state
+    end
+
+    # Returns the FiverunsJSON generator modul, that is used by FiverunsJSON. This might be
+    # either FiverunsJSON::Ext::Generator or FiverunsJSON::Pure::Generator.
+    attr_reader :generator
+
+    # Returns the FiverunsJSON generator state class, that is used by FiverunsJSON. This might
+    # be either FiverunsJSON::Ext::Generator::State or FiverunsJSON::Pure::Generator::State.
+    attr_accessor :state
+
+    # This is create identifier, that is used to decide, if the _json_create_
+    # hook of a class should be called. It defaults to 'json_class'.
+    attr_accessor :create_id
+  end
+  self.create_id = 'json_class'
+
+  NaN           = (-1.0) ** 0.5
+
+  Infinity      = 1.0/0
+
+  MinusInfinity = -Infinity
+
+  # The base exception for FiverunsJSON errors.
+  class JSONError < StandardError; end
+
+  # This exception is raised, if a parser error occurs.
+  class ParserError < ::Fiveruns::JSON::JSONError; end
+
+  # This exception is raised, if the nesting of parsed datastructures is too
+  # deep.
+  class NestingError < ParserError; end
+
+  # This exception is raised, if a generator or unparser error occurs.
+  class GeneratorError < ::Fiveruns::JSON::JSONError; end
+  # For backwards compatibility
+  UnparserError = GeneratorError
+
+  # If a circular data structure is encountered while unparsing
+  # this exception is raised.
+  class CircularDatastructure < GeneratorError; end
+
+  # This exception is raised, if the required unicode support is missing on the
+  # system. Usually this means, that the iconv library is not installed.
+  class MissingUnicodeSupport < ::Fiveruns::JSON::JSONError; end
+
+  module_function
+
+  # Parse the FiverunsJSON string _source_ into a Ruby data structure and return it.
+  #
+  # _opts_ can have the following
+  # keys:
+  # * *max_nesting*: The maximum depth of nesting allowed in the parsed data
+  #   structures. Disable depth checking with :max_nesting => false, it defaults
+  #   to 19.
+  # * *allow_nan*: If set to true, allow NaN, Infinity and -Infinity in
+  #   defiance of RFC 4627 to be parsed by the Parser. This option defaults
+  #   to false.
+  # * *create_additions*: If set to false, the Parser doesn't create
+  #   additions even if a matchin class and create_id was found. This option
+  #   defaults to true.
+  # def parse(source, opts = {})
+  #   ::Fiveruns::JSON.parser.new(source, opts).parse
+  # end
+
+  # Parse the FiverunsJSON string _source_ into a Ruby data structure and return it.
+  # The bang version of the parse method, defaults to the more dangerous values
+  # for the _opts_ hash, so be sure only to parse trusted _source_ strings.
+  #
+  # _opts_ can have the following keys:
+  # * *max_nesting*: The maximum depth of nesting allowed in the parsed data
+  #   structures. Enable depth checking with :max_nesting => anInteger. The parse!
+  #   methods defaults to not doing max depth checking: This can be dangerous,
+  #   if someone wants to fill up your stack.
+  # * *allow_nan*: If set to true, allow NaN, Infinity, and -Infinity in
+  #   defiance of RFC 4627 to be parsed by the Parser. This option defaults
+  #   to true.
+  # * *create_additions*: If set to false, the Parser doesn't create
+  #   additions even if a matchin class and create_id was found. This option
+  #   defaults to true.
+  # def parse!(source, opts = {})
+  #   opts = {
+  #     :max_nesting => false,
+  #     :allow_nan => true
+  #   }.update(opts)
+  #   ::Fiveruns::JSON.parser.new(source, opts).parse
+  # end
+
+  # Unparse the Ruby data structure _obj_ into a single line FiverunsJSON string and
+  # return it. _state_ is
+  # * a FiverunsJSON::State object,
+  # * or a Hash like object (responding to to_hash),
+  # * an object convertible into a hash by a to_h method,
+  # that is used as or to configure a State object.
+  #
+  # It defaults to a state object, that creates the shortest possible FiverunsJSON text
+  # in one line, checks for circular data structures and doesn't allow NaN,
+  # Infinity, and -Infinity.
+  #
+  # A _state_ hash can have the following keys:
+  # * *indent*: a string used to indent levels (default: ''),
+  # * *space*: a string that is put after, a : or , delimiter (default: ''),
+  # * *space_before*: a string that is put before a : pair delimiter (default: ''),
+  # * *object_nl*: a string that is put at the end of a FiverunsJSON object (default: ''), 
+  # * *array_nl*: a string that is put at the end of a FiverunsJSON array (default: ''),
+  # * *check_circular*: true if checking for circular data structures
+  #   should be done (the default), false otherwise.
+  # * *allow_nan*: true if NaN, Infinity, and -Infinity should be
+  #   generated, otherwise an exception is thrown, if these values are
+  #   encountered. This options defaults to false.
+  # * *max_nesting*: The maximum depth of nesting allowed in the data
+  #   structures from which FiverunsJSON is to be generated. Disable depth checking
+  #   with :max_nesting => false, it defaults to 19.
+  #
+  # See also the fast_generate for the fastest creation method with the least
+  # amount of sanity checks, and the pretty_generate method for some
+  # defaults for a pretty output.
+  def generate(obj, state = nil)
+    if state
+      state = State.from_state(state)
+    else
+      state = State.new
+    end
+    obj.to_fjson(state)
+  end
+
+  # :stopdoc:
+  # I want to deprecate these later, so I'll first be silent about them, and
+  # later delete them.
+  alias unparse generate
+  module_function :unparse
+  # :startdoc:
+
+  # Unparse the Ruby data structure _obj_ into a single line FiverunsJSON string and
+  # return it. This method disables the checks for circles in Ruby objects, and
+  # also generates NaN, Infinity, and, -Infinity float values.
+  #
+  # *WARNING*: Be careful not to pass any Ruby data structures with circles as
+  # _obj_ argument, because this will cause FiverunsJSON to go into an infinite loop.
+  def fast_generate(obj)
+    obj.to_fjson(nil)
+  end
+
+  # :stopdoc:
+  # I want to deprecate these later, so I'll first be silent about them, and later delete them.
+  alias fast_unparse fast_generate
+  module_function :fast_unparse
+  # :startdoc:
+
+  # Unparse the Ruby data structure _obj_ into a FiverunsJSON string and return it. The
+  # returned string is a prettier form of the string returned by #unparse.
+  #
+  # The _opts_ argument can be used to configure the generator, see the
+  # generate method for a more detailed explanation.
+  def pretty_generate(obj, opts = nil)
+    state = ::Fiveruns::JSON.state.new(
+      :indent     => '  ',
+      :space      => ' ',
+      :object_nl  => "\n",
+      :array_nl   => "\n",
+      :check_circular => true
+    )
+    if opts
+      if opts.respond_to? :to_hash
+        opts = opts.to_hash
+      elsif opts.respond_to? :to_h
+        opts = opts.to_h
+      else
+        raise TypeError, "can't convert #{opts.class} into Hash"
+      end
+      state.configure(opts)
+    end
+    obj.to_fjson(state)
+  end
+
+  # :stopdoc:
+  # I want to deprecate these later, so I'll first be silent about them, and later delete them.
+  alias pretty_unparse pretty_generate
+  module_function :pretty_unparse
+  # :startdoc:
+
+  # Load a ruby data structure from a FiverunsJSON _source_ and return it. A source can
+  # either be a string-like object, an IO like object, or an object responding
+  # to the read method. If _proc_ was given, it will be called with any nested
+  # Ruby object as an argument recursively in depth first order.
+  #
+  # This method is part of the implementation of the load/dump interface of
+  # Marshal and YAML.
+  def load(source, proc = nil)
+    if source.respond_to? :to_str
+      source = source.to_str
+    elsif source.respond_to? :to_io
+      source = source.to_io.read
+    else
+      source = source.read
+    end
+    result = parse(source, :max_nesting => false, :allow_nan => true)
+    recurse_proc(result, &proc) if proc
+    result
+  end
+
+  def recurse_proc(result, &proc)
+    case result
+    when Array
+      result.each { |x| recurse_proc x, &proc }
+      proc.call result
+    when Hash
+      result.each { |x, y| recurse_proc x, &proc; recurse_proc y, &proc }
+      proc.call result
+    else
+      proc.call result
+    end
+  end
+  private :recurse_proc
+  module_function :recurse_proc
+
+  alias restore load
+  module_function :restore
+
+  # Dumps _obj_ as a FiverunsJSON string, i.e. calls generate on the object and returns
+  # the result.
+  #
+  # If anIO (an IO like object or an object that responds to the write method)
+  # was given, the resulting FiverunsJSON is written to it.
+  #
+  # If the number of nested arrays or objects exceeds _limit_ an ArgumentError
+  # exception is raised. This argument is similar (but not exactly the
+  # same!) to the _limit_ argument in Marshal.dump.
+  #
+  # This method is part of the implementation of the load/dump interface of
+  # Marshal and YAML.
+  def dump(obj, anIO = nil, limit = nil)
+    if anIO and limit.nil?
+      anIO = anIO.to_io if anIO.respond_to?(:to_io)
+      unless anIO.respond_to?(:write)
+        limit = anIO
+        anIO = nil
+      end
+    end
+    limit ||= 0
+    result = generate(obj, :allow_nan => true, :max_nesting => limit)
+    if anIO
+      anIO.write result
+      anIO
+    else
+      result
+    end
+  rescue ::Fiveruns::JSON::NestingError
+    raise ArgumentError, "exceed depth limit"
+  end
+end
+
+module ::Kernel
+  # Outputs _objs_ to STDOUT as FiverunsJSON strings in the shortest form, that is in
+  # one line.
+  def fj(*objs)
+    objs.each do |obj|
+      puts ::Fiveruns::JSON::generate(obj, :allow_nan => true, :max_nesting => false)
+    end
+    nil
+  end
+
+  # Ouputs _objs_ to STDOUT as FiverunsJSON strings in a pretty format, with
+  # indentation and over many lines.
+  def fjj(*objs)
+    objs.each do |obj|
+      puts ::Fiveruns::JSON::pretty_generate(obj, :allow_nan => true, :max_nesting => false)
+    end
+    nil
+  end
+
+  # If _object_ is string-like parse the string and return the parsed result as
+  # a Ruby data structure. Otherwise generate a FiverunsJSON text from the Ruby data
+  # structure object and return it.
+  #
+  # The _opts_ argument is passed through to generate/parse respectively, see
+  # generate and parse for their documentation.
+  def FJSON(object, opts = {})
+    # if object.respond_to? :to_str
+    #   ::Fiveruns::JSON.parse(object.to_str, opts)
+    # else
+      ::Fiveruns::JSON.generate(object, opts)
+    # end
+  end
+end
+
+class ::Class
+  # Returns true, if this class can be used to create an instance
+  # from a serialised FiverunsJSON string. The class has to implement a class
+  # method _json_create_ that expects a hash as first parameter, which includes
+  # the required data.
+  def fjson_creatable?
+    respond_to?(:fjson_create)
+  end
+end