gist 4.6.0 → 6.0.0

data/spec/ghe_spec.rb

@@ -5,10 +5,10 @@ describe '...' do
   MOCK_USER         = 'foo'
   MOCK_PASSWORD     = 'bar'
 
-  MOCK_AUTHZ_GHE_URL    = "#{MOCK_GHE_PROTOCOL}://#{MOCK_USER}:#{MOCK_PASSWORD}@#{MOCK_GHE_HOST}/api/v3/"
+  MOCK_AUTHZ_GHE_URL    = "#{MOCK_GHE_PROTOCOL}://#{MOCK_GHE_HOST}/api/v3/"
   MOCK_GHE_URL          = "#{MOCK_GHE_PROTOCOL}://#{MOCK_GHE_HOST}/api/v3/"
-  MOCK_AUTHZ_GITHUB_URL = "https://#{MOCK_USER}:#{MOCK_PASSWORD}@api.github.com/"
   MOCK_GITHUB_URL       = "https://api.github.com/"
+  MOCK_LOGIN_URL        = "https://github.com/"
 
   before do
     @saved_env = ENV[Gist::URL_ENV_NAME]
@@ -20,8 +20,15 @@ describe '...' do
     # stub requests for /authorizations
     stub_request(:post, /#{MOCK_AUTHZ_GHE_URL}authorizations/).
       to_return(:status => 201, :body => '{"token": "asdf"}')
-    stub_request(:post, /#{MOCK_AUTHZ_GITHUB_URL}authorizations/).
+    stub_request(:post, /#{MOCK_GITHUB_URL}authorizations/).
+      with(headers: {'Authorization'=>'Basic Zm9vOmJhcg=='}).
       to_return(:status => 201, :body => '{"token": "asdf"}')
+
+    stub_request(:post, /#{MOCK_LOGIN_URL}login\/device\/code/).
+      to_return(:status => 200, :body => '{"interval": "0.1", "user_code":"XXXX-XXXX", "device_code": "xxxx", "verification_uri": "https://github.com/login/device"}')
+
+    stub_request(:post, /#{MOCK_LOGIN_URL}login\/oauth\/access_token/).
+      to_return(:status => 200, :body => '{"access_token":"zzzz"}')
   end
 
   after do
@@ -48,7 +55,7 @@ describe '...' do
 
       Gist.login!
 
-      assert_requested(:post, /#{MOCK_AUTHZ_GITHUB_URL}authorizations/)
+      assert_requested(:post, /#{MOCK_LOGIN_URL}login\/oauth\/access_token/)
     end
 
     it "should access to #{MOCK_GHE_HOST} when $#{Gist::URL_ENV_NAME} was set" do
@@ -65,7 +72,7 @@ describe '...' do
         $stdin = StringIO.new "#{MOCK_USER}_wrong\n#{MOCK_PASSWORD}_wrong\n"
         Gist.login! :username => MOCK_USER, :password => MOCK_PASSWORD
 
-        assert_requested(:post, /#{MOCK_AUTHZ_GITHUB_URL}authorizations/)
+        assert_requested(:post, /#{MOCK_GITHUB_URL}authorizations/)
       end
 
     end

data/spec/rawify_spec.rb

@@ -6,7 +6,16 @@ describe '...' do
   end
 
   it "should return the raw file url" do
-    Gist.gist("Test gist", :output => :raw_url, :anonymous => true).should == "https://gist.github.com/anonymous/XXXXXX/raw"
+    Gist.gist("Test gist", :output => :raw_url, :anonymous => false).should == "https://gist.github.com/anonymous/XXXXXX/raw"
+  end
+
+  it 'should raise an error when trying to do operations without being logged in' do
+    error_msg = 'Anonymous gists are no longer supported. Please log in with `gist --login`. ' \
+      '(GitHub now requires credentials to gist https://bit.ly/2GBBxKw)'
+
+    expect do
+      Gist.gist("Test gist", output: :raw_url, anonymous: true)
+    end.to raise_error(StandardError, error_msg)
   end
 end
 

data/spec/shorten_spec.rb

@@ -5,11 +5,20 @@ describe '...' do
 
   it "should return a shortened version of the URL when response is 200" do
     stub_request(:post, "https://git.io/create").to_return(:status => 200, :body => 'XXXXXX')
-    Gist.gist("Test gist", :output => :short_url, :anonymous => true).should == "https://git.io/XXXXXX"
+    Gist.gist("Test gist", :output => :short_url, anonymous: false).should == "https://git.io/XXXXXX"
   end
 
   it "should return a shortened version of the URL when response is 201" do
     stub_request(:post, "https://git.io/create").to_return(:status => 201, :headers => { 'Location' => 'https://git.io/XXXXXX' })
-    Gist.gist("Test gist", :output => :short_url, :anonymous => true).should == "https://git.io/XXXXXX"
+    Gist.gist("Test gist", :output => :short_url, anonymous: false).should == "https://git.io/XXXXXX"
+  end
+
+  it 'should raise an error when trying to get short urls without being logged in' do
+    error_msg = 'Anonymous gists are no longer supported. Please log in with `gist --login`. ' \
+      '(GitHub now requires credentials to gist https://bit.ly/2GBBxKw)'
+
+    expect do
+      Gist.gist("Test gist", output: :short_url, anonymous: true)
+    end.to raise_error(StandardError, error_msg)
   end
 end

data/spec/spec_helper.rb

@@ -11,7 +11,7 @@ RSpec.configure do |config|
     mocks.syntax = :should
   end
   config.expect_with :rspec do |expectations|
-    expectations.syntax = :should
+    expectations.syntax = [:should, :expect]
   end
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gist
 version: !ruby/object:Gem::Version
-  version: 4.6.0
+  version: 6.0.0
 platform: ruby
 authors:
 - Conrad Irwin
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-16 00:00:00.000000000 Z
+date: 2020-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -76,15 +76,12 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
 - ".rspec"
 - Gemfile
 - LICENSE.MIT
 - README.md
 - Rakefile
 - bin/gist
-- build/gist
-- build/gist.1
 - gist.gemspec
 - lib/gist.rb
 - spec/auth_token_file_spec.rb
@@ -96,7 +93,6 @@ files:
 - spec/shorten_spec.rb
 - spec/spec_helper.rb
 - vendor/json.rb
-- vendor/netrc.rb
 homepage: https://github.com/defunkt/gist
 licenses:
 - MIT
@@ -116,8 +112,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Just allows you to upload gists

data/.gitignore

@@ -1,8 +0,0 @@
-.rvmrc
-Gemfile.lock
-
-# OS X
-.DS_Store
-.yardoc
-doc
-*.gem

data/build/gist

@@ -1,2357 +0,0 @@
-#!/usr/bin/env ruby
-# This is generated from https://github.com/defunkt/gist using 'rake standalone'
-# any changes will be overwritten.
-require 'net/https'
-require 'cgi'
-require 'uri'
-
-begin
-  require 'strscan'
-
-module JSON
-  module Pure
-    # This class implements the JSON parser that is used to parse a JSON string
-    # into a Ruby data structure.
-    class Parser < StringScanner
-      STRING                = /" ((?:[^\x0-\x1f"\\] |
-                                   # escaped special characters:
-                                  \\["\\\/bfnrt] |
-                                  \\u[0-9a-fA-F]{4} |
-                                   # match all but escaped special characters:
-                                  \\[\x20-\x21\x23-\x2e\x30-\x5b\x5d-\x61\x63-\x65\x67-\x6d\x6f-\x71\x73\x75-\xff])*)
-                              "/nx
-      INTEGER               = /(-?0|-?[1-9]\d*)/
-      FLOAT                 = /(-?
-                                (?:0|[1-9]\d*)
-                                (?:
-                                  \.\d+(?i:e[+-]?\d+) |
-                                  \.\d+ |
-                                  (?i:e[+-]?\d+)
-                                )
-                                )/x
-      NAN                   = /NaN/
-      INFINITY              = /Infinity/
-      MINUS_INFINITY        = /-Infinity/
-      OBJECT_OPEN           = /\{/
-      OBJECT_CLOSE          = /\}/
-      ARRAY_OPEN            = /\[/
-      ARRAY_CLOSE           = /\]/
-      PAIR_DELIMITER        = /:/
-      COLLECTION_DELIMITER  = /,/
-      TRUE                  = /true/
-      FALSE                 = /false/
-      NULL                  = /null/
-      IGNORE                = %r(
-        (?:
-         //[^\n\r]*[\n\r]| # line comments
-         /\*               # c-style comments
-         (?:
-          [^*/]|        # normal chars
-          /[^*]|        # slashes that do not start a nested comment
-          \*[^/]|       # asterisks that do not end this comment
-          /(?=\*/)      # single slash before this comment's end
-         )*
-           \*/               # the End of this comment
-           |[ \t\r\n]+       # whitespaces: space, horicontal tab, lf, cr
-        )+
-      )mx
-
-      UNPARSED = Object.new
-
-      # Creates a new JSON::Pure::Parser instance for the string _source_.
-      #
-      # It will be configured by the _opts_ hash. _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|nil|0,
-      #   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.
-      # * *symbolize_names*: If set to true, returns symbols for the names
-      #   (keys) in a JSON object. Otherwise strings are returned, which is also
-      #   the default.
-      # * *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.
-      # * *object_class*: Defaults to Hash
-      # * *array_class*: Defaults to Array
-      # * *quirks_mode*: Enables quirks_mode for parser, that is for example
-      #   parsing single JSON values instead of documents is possible.
-      def initialize(source, opts = {})
-        opts ||= {}
-        unless @quirks_mode = opts[:quirks_mode]
-          source = convert_encoding source
-        end
-        super source
-        if !opts.key?(:max_nesting) # defaults to 19
-          @max_nesting = 19
-        elsif opts[:max_nesting]
-          @max_nesting = opts[:max_nesting]
-        else
-          @max_nesting = 0
-        end
-        @allow_nan = !!opts[:allow_nan]
-        @symbolize_names = !!opts[:symbolize_names]
-        if opts.key?(:create_additions)
-          @create_additions = !!opts[:create_additions]
-        else
-          @create_additions = true
-        end
-        @create_id = @create_additions ? JSON.create_id : nil
-        @object_class = opts[:object_class] || Hash
-        @array_class  = opts[:array_class] || Array
-        @match_string = opts[:match_string]
-      end
-
-      alias source string
-
-      def quirks_mode?
-        !!@quirks_mode
-      end
-
-      def reset
-        super
-        @current_nesting = 0
-      end
-
-      # Parses the current JSON string _source_ and returns the complete data
-      # structure as a result.
-      def parse
-        reset
-        obj = nil
-        if @quirks_mode
-          while !eos? && skip(IGNORE)
-          end
-          if eos?
-            raise ParserError, "source did not contain any JSON!"
-          else
-            obj = parse_value
-            obj == UNPARSED and raise ParserError, "source did not contain any JSON!"
-          end
-        else
-          until eos?
-            case
-            when scan(OBJECT_OPEN)
-              obj and raise ParserError, "source '#{peek(20)}' not in JSON!"
-              @current_nesting = 1
-              obj = parse_object
-            when scan(ARRAY_OPEN)
-              obj and raise ParserError, "source '#{peek(20)}' not in JSON!"
-              @current_nesting = 1
-              obj = parse_array
-            when skip(IGNORE)
-              ;
-            else
-              raise ParserError, "source '#{peek(20)}' not in JSON!"
-            end
-          end
-          obj or raise ParserError, "source did not contain any JSON!"
-        end
-        obj
-      end
-
-      private
-
-      def convert_encoding(source)
-        if source.respond_to?(:to_str)
-          source = source.to_str
-        else
-          raise TypeError, "#{source.inspect} is not like a string"
-        end
-        if defined?(::Encoding)
-          if source.encoding == ::Encoding::ASCII_8BIT
-            b = source[0, 4].bytes.to_a
-            source =
-              case
-              when b.size >= 4 && b[0] == 0 && b[1] == 0 && b[2] == 0
-                source.dup.force_encoding(::Encoding::UTF_32BE).encode!(::Encoding::UTF_8)
-              when b.size >= 4 && b[0] == 0 && b[2] == 0
-                source.dup.force_encoding(::Encoding::UTF_16BE).encode!(::Encoding::UTF_8)
-              when b.size >= 4 && b[1] == 0 && b[2] == 0 && b[3] == 0
-                source.dup.force_encoding(::Encoding::UTF_32LE).encode!(::Encoding::UTF_8)
-              when b.size >= 4 && b[1] == 0 && b[3] == 0
-                source.dup.force_encoding(::Encoding::UTF_16LE).encode!(::Encoding::UTF_8)
-              else
-                source.dup
-              end
-          else
-            source = source.encode(::Encoding::UTF_8)
-          end
-          source.force_encoding(::Encoding::ASCII_8BIT)
-        else
-          b = source
-          source =
-            case
-            when b.size >= 4 && b[0] == 0 && b[1] == 0 && b[2] == 0
-              JSON.iconv('utf-8', 'utf-32be', b)
-            when b.size >= 4 && b[0] == 0 && b[2] == 0
-              JSON.iconv('utf-8', 'utf-16be', b)
-            when b.size >= 4 && b[1] == 0 && b[2] == 0 && b[3] == 0
-              JSON.iconv('utf-8', 'utf-32le', b)
-            when b.size >= 4 && b[1] == 0 && b[3] == 0
-              JSON.iconv('utf-8', 'utf-16le', b)
-            else
-              b
-            end
-        end
-        source
-      end
-
-      # Unescape characters in strings.
-      UNESCAPE_MAP = Hash.new { |h, k| h[k] = k.chr }
-      UNESCAPE_MAP.update({
-        ?"  => '"',
-        ?\\ => '\\',
-        ?/  => '/',
-        ?b  => "\b",
-        ?f  => "\f",
-        ?n  => "\n",
-        ?r  => "\r",
-        ?t  => "\t",
-        ?u  => nil,
-      })
-
-      EMPTY_8BIT_STRING = ''
-      if ::String.method_defined?(:encode)
-        EMPTY_8BIT_STRING.force_encoding Encoding::ASCII_8BIT
-      end
-
-      def parse_string
-        if scan(STRING)
-          return '' if self[1].empty?
-          string = self[1].gsub(%r((?:\\[\\bfnrt"/]|(?:\\u(?:[A-Fa-f\d]{4}))+|\\[\x20-\xff]))n) do |c|
-            if u = UNESCAPE_MAP[$&[1]]
-              u
-            else # \uXXXX
-              bytes = EMPTY_8BIT_STRING.dup
-              i = 0
-              while c[6 * i] == ?\\ && c[6 * i + 1] == ?u
-                bytes << c[6 * i + 2, 2].to_i(16) << c[6 * i + 4, 2].to_i(16)
-                i += 1
-              end
-              JSON.iconv('utf-8', 'utf-16be', bytes)
-            end
-          end
-          if string.respond_to?(:force_encoding)
-            string.force_encoding(::Encoding::UTF_8)
-          end
-          if @create_additions and @match_string
-            for (regexp, klass) in @match_string
-              klass.json_creatable? or next
-              string =~ regexp and return klass.json_create(string)
-            end
-          end
-          string
-        else
-          UNPARSED
-        end
-      rescue => e
-        raise ParserError, "Caught #{e.class} at '#{peek(20)}': #{e}"
-      end
-
-      def parse_value
-        case
-        when scan(FLOAT)
-          Float(self[1])
-        when scan(INTEGER)
-          Integer(self[1])
-        when scan(TRUE)
-          true
-        when scan(FALSE)
-          false
-        when scan(NULL)
-          nil
-        when (string = parse_string) != UNPARSED
-          string
-        when scan(ARRAY_OPEN)
-          @current_nesting += 1
-          ary = parse_array
-          @current_nesting -= 1
-          ary
-        when scan(OBJECT_OPEN)
-          @current_nesting += 1
-          obj = parse_object
-          @current_nesting -= 1
-          obj
-        when @allow_nan && scan(NAN)
-          NaN
-        when @allow_nan && scan(INFINITY)
-          Infinity
-        when @allow_nan && scan(MINUS_INFINITY)
-          MinusInfinity
-        else
-          UNPARSED
-        end
-      end
-
-      def parse_array
-        raise NestingError, "nesting of #@current_nesting is too deep" if
-          @max_nesting.nonzero? && @current_nesting > @max_nesting
-        result = @array_class.new
-        delim = false
-        until eos?
-          case
-          when (value = parse_value) != UNPARSED
-            delim = false
-            result << value
-            skip(IGNORE)
-            if scan(COLLECTION_DELIMITER)
-              delim = true
-            elsif match?(ARRAY_CLOSE)
-              ;
-            else
-              raise ParserError, "expected ',' or ']' in array at '#{peek(20)}'!"
-            end
-          when scan(ARRAY_CLOSE)
-            if delim
-              raise ParserError, "expected next element in array at '#{peek(20)}'!"
-            end
-            break
-          when skip(IGNORE)
-            ;
-          else
-            raise ParserError, "unexpected token in array at '#{peek(20)}'!"
-          end
-        end
-        result
-      end
-
-      def parse_object
-        raise NestingError, "nesting of #@current_nesting is too deep" if
-          @max_nesting.nonzero? && @current_nesting > @max_nesting
-        result = @object_class.new
-        delim = false
-        until eos?
-          case
-          when (string = parse_string) != UNPARSED
-            skip(IGNORE)
-            unless scan(PAIR_DELIMITER)
-              raise ParserError, "expected ':' in object at '#{peek(20)}'!"
-            end
-            skip(IGNORE)
-            unless (value = parse_value).equal? UNPARSED
-              result[@symbolize_names ? string.to_sym : string] = value
-              delim = false
-              skip(IGNORE)
-              if scan(COLLECTION_DELIMITER)
-                delim = true
-              elsif match?(OBJECT_CLOSE)
-                ;
-              else
-                raise ParserError, "expected ',' or '}' in object at '#{peek(20)}'!"
-              end
-            else
-              raise ParserError, "expected value in object at '#{peek(20)}'!"
-            end
-          when scan(OBJECT_CLOSE)
-            if delim
-              raise ParserError, "expected next name, value pair in object at '#{peek(20)}'!"
-            end
-            if @create_additions and klassname = result[@create_id]
-              klass = JSON.deep_const_get klassname
-              break unless klass and klass.json_creatable?
-              result = klass.json_create(result)
-            end
-            break
-          when skip(IGNORE)
-            ;
-          else
-            raise ParserError, "unexpected token in object at '#{peek(20)}'!"
-          end
-        end
-        result
-      end
-    end
-  end
-end
-
-module JSON
-  MAP = {
-    "\x0" => '\u0000',
-    "\x1" => '\u0001',
-    "\x2" => '\u0002',
-    "\x3" => '\u0003',
-    "\x4" => '\u0004',
-    "\x5" => '\u0005',
-    "\x6" => '\u0006',
-    "\x7" => '\u0007',
-    "\b"  =>  '\b',
-    "\t"  =>  '\t',
-    "\n"  =>  '\n',
-    "\xb" => '\u000b',
-    "\f"  =>  '\f',
-    "\r"  =>  '\r',
-    "\xe" => '\u000e',
-    "\xf" => '\u000f',
-    "\x10" => '\u0010',
-    "\x11" => '\u0011',
-    "\x12" => '\u0012',
-    "\x13" => '\u0013',
-    "\x14" => '\u0014',
-    "\x15" => '\u0015',
-    "\x16" => '\u0016',
-    "\x17" => '\u0017',
-    "\x18" => '\u0018',
-    "\x19" => '\u0019',
-    "\x1a" => '\u001a',
-    "\x1b" => '\u001b',
-    "\x1c" => '\u001c',
-    "\x1d" => '\u001d',
-    "\x1e" => '\u001e',
-    "\x1f" => '\u001f',
-    '"'   =>  '\"',
-    '\\'  =>  '\\\\',
-  } # :nodoc:
-
-  # Convert a UTF8 encoded Ruby string _string_ to a JSON string, encoded with
-  # UTF16 big endian characters as \u????, and return it.
-  if defined?(::Encoding)
-    def utf8_to_json(string) # :nodoc:
-      string = string.dup
-      string << '' # XXX workaround: avoid buffer sharing
-      string.force_encoding(::Encoding::ASCII_8BIT)
-      string.gsub!(/["\\\x0-\x1f]/) { MAP[$&] }
-      string.force_encoding(::Encoding::UTF_8)
-      string
-    end
-
-    def utf8_to_json_ascii(string) # :nodoc:
-      string = string.dup
-      string << '' # XXX workaround: avoid buffer sharing
-      string.force_encoding(::Encoding::ASCII_8BIT)
-      string.gsub!(/["\\\x0-\x1f]/) { MAP[$&] }
-      string.gsub!(/(
-                      (?:
-                        [\xc2-\xdf][\x80-\xbf]    |
-                        [\xe0-\xef][\x80-\xbf]{2} |
-                        [\xf0-\xf4][\x80-\xbf]{3}
-                      )+ |
-                      [\x80-\xc1\xf5-\xff]       # invalid
-                    )/nx) { |c|
-                      c.size == 1 and raise GeneratorError, "invalid utf8 byte: '#{c}'"
-                      s = JSON.iconv('utf-16be', 'utf-8', c).unpack('H*')[0]
-                      s.gsub!(/.{4}/n, '\\\\u\&')
-                    }
-      string.force_encoding(::Encoding::UTF_8)
-      string
-    rescue => e
-      raise GeneratorError, "Caught #{e.class}: #{e}"
-    end
-  else
-    def utf8_to_json(string) # :nodoc:
-      string.gsub(/["\\\x0-\x1f]/) { MAP[$&] }
-    end
-
-    def utf8_to_json_ascii(string) # :nodoc:
-      string = string.gsub(/["\\\x0-\x1f]/) { MAP[$&] }
-      string.gsub!(/(
-                      (?:
-                        [\xc2-\xdf][\x80-\xbf]    |
-                        [\xe0-\xef][\x80-\xbf]{2} |
-                        [\xf0-\xf4][\x80-\xbf]{3}
-                      )+ |
-                      [\x80-\xc1\xf5-\xff]       # invalid
-                    )/nx) { |c|
-        c.size == 1 and raise GeneratorError, "invalid utf8 byte: '#{c}'"
-        s = JSON.iconv('utf-16be', 'utf-8', c).unpack('H*')[0]
-        s.gsub!(/.{4}/n, '\\\\u\&')
-      }
-      string
-    rescue => e
-      raise GeneratorError, "Caught #{e.class}: #{e}"
-    end
-  end
-  module_function :utf8_to_json, :utf8_to_json_ascii
-
-  module Pure
-    module Generator
-      # This class is used to create State instances, that are use to hold data
-      # while generating a JSON text from a Ruby data structure.
-      class State
-        # Creates a State object from _opts_, which ought to be Hash to create
-        # a new State instance configured by _opts_, something else to create
-        # an unconfigured instance. If _opts_ is a State object, it is just
-        # returned.
-        def self.from_state(opts)
-          case
-          when self === opts
-            opts
-          when opts.respond_to?(:to_hash)
-            new(opts.to_hash)
-          when opts.respond_to?(:to_h)
-            new(opts.to_h)
-          else
-            SAFE_STATE_PROTOTYPE.dup
-          end
-        end
-
-        # Instantiates a new State object, configured by _opts_.
-        #
-        # _opts_ 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 JSON object (default: ''),
-        # * *array_nl*: a string that is put at the end of a JSON array (default: ''),
-        # * *check_circular*: is deprecated now, use the :max_nesting option instead,
-        # * *max_nesting*: sets the maximum level of data structure nesting in
-        #   the generated JSON, max_nesting = 0 if no maximum should be checked.
-        # * *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.
-        # * *quirks_mode*: Enables quirks_mode for parser, that is for example
-        #   generating single JSON values instead of documents is possible.
-        def initialize(opts = {})
-          @indent                = ''
-          @space                 = ''
-          @space_before          = ''
-          @object_nl             = ''
-          @array_nl              = ''
-          @allow_nan             = false
-          @ascii_only            = false
-          @quirks_mode           = false
-          @buffer_initial_length = 1024
-          configure opts
-        end
-
-        # This string is used to indent levels in the JSON text.
-        attr_accessor :indent
-
-        # This string is used to insert a space between the tokens in a JSON
-        # string.
-        attr_accessor :space
-
-        # This string is used to insert a space before the ':' in JSON objects.
-        attr_accessor :space_before
-
-        # This string is put at the end of a line that holds a JSON object (or
-        # Hash).
-        attr_accessor :object_nl
-
-        # This string is put at the end of a line that holds a JSON array.
-        attr_accessor :array_nl
-
-        # This integer returns the maximum level of data structure nesting in
-        # the generated JSON, max_nesting = 0 if no maximum is checked.
-        attr_accessor :max_nesting
-
-        # If this attribute is set to true, quirks mode is enabled, otherwise
-        # it's disabled.
-        attr_accessor :quirks_mode
-
-        # :stopdoc:
-        attr_reader :buffer_initial_length
-
-        def buffer_initial_length=(length)
-          if length > 0
-            @buffer_initial_length = length
-          end
-        end
-        # :startdoc:
-
-        # This integer returns the current depth data structure nesting in the
-        # generated JSON.
-        attr_accessor :depth
-
-        def check_max_nesting # :nodoc:
-          return if @max_nesting.zero?
-          current_nesting = depth + 1
-          current_nesting > @max_nesting and
-            raise NestingError, "nesting of #{current_nesting} is too deep"
-        end
-
-        # Returns true, if circular data structures are checked,
-        # otherwise returns false.
-        def check_circular?
-          !@max_nesting.zero?
-        end
-
-        # Returns true if NaN, Infinity, and -Infinity should be considered as
-        # valid JSON and output.
-        def allow_nan?
-          @allow_nan
-        end
-
-        # Returns true, if only ASCII characters should be generated. Otherwise
-        # returns false.
-        def ascii_only?
-          @ascii_only
-        end
-
-        # Returns true, if quirks mode is enabled. Otherwise returns false.
-        def quirks_mode?
-          @quirks_mode
-        end
-
-        # Configure this State instance with the Hash _opts_, and return
-        # itself.
-        def configure(opts)
-          @indent         = opts[:indent] if opts.key?(:indent)
-          @space          = opts[:space] if opts.key?(:space)
-          @space_before   = opts[:space_before] if opts.key?(:space_before)
-          @object_nl      = opts[:object_nl] if opts.key?(:object_nl)
-          @array_nl       = opts[:array_nl] if opts.key?(:array_nl)
-          @allow_nan      = !!opts[:allow_nan] if opts.key?(:allow_nan)
-          @ascii_only     = opts[:ascii_only] if opts.key?(:ascii_only)
-          @depth          = opts[:depth] || 0
-          @quirks_mode    = opts[:quirks_mode] if opts.key?(:quirks_mode)
-          if !opts.key?(:max_nesting) # defaults to 19
-            @max_nesting = 19
-          elsif opts[:max_nesting]
-            @max_nesting = opts[:max_nesting]
-          else
-            @max_nesting = 0
-          end
-          self
-        end
-        alias merge configure
-
-        # Returns the configuration instance variables as a hash, that can be
-        # passed to the configure method.
-        def to_h
-          result = {}
-          for iv in %w[indent space space_before object_nl array_nl allow_nan max_nesting ascii_only quirks_mode buffer_initial_length depth]
-            result[iv.intern] = instance_variable_get("@#{iv}")
-          end
-          result
-        end
-
-        # Generates a valid JSON document from object +obj+ and returns the
-        # result. If no valid JSON document can be created this method raises a
-        # GeneratorError exception.
-        def generate(obj)
-          result = obj.to_json(self)
-          unless @quirks_mode
-            unless result =~ /\A\s*\[/ && result =~ /\]\s*\Z/ ||
-              result =~ /\A\s*\{/ && result =~ /\}\s*\Z/
-            then
-              raise GeneratorError, "only generation of JSON objects or arrays allowed"
-            end
-          end
-          result
-        end
-
-        # Return the value returned by method +name+.
-        def [](name)
-          __send__ name
-        end
-      end
-
-      module GeneratorMethods
-        module Object
-          # Converts this object to a string (calling #to_s), converts
-          # it to a JSON string, and returns the result. This is a fallback, if no
-          # special method #to_json was defined for some object.
-          def to_json(*) to_s.to_json end
-        end
-
-        module Hash
-          # Returns a JSON string containing a JSON object, that is unparsed from
-          # this Hash instance.
-          # _state_ is a JSON::State object, that can also be used to configure the
-          # produced JSON string output further.
-          # _depth_ is used to find out nesting depth, to indent accordingly.
-          def to_json(state = nil, *)
-            state = State.from_state(state)
-            state.check_max_nesting
-            json_transform(state)
-          end
-
-          private
-
-          def json_shift(state)
-            state.object_nl.empty? or return ''
-            state.indent * state.depth
-          end
-
-          def json_transform(state)
-            delim = ','
-            delim << state.object_nl
-            result = '{'
-            result << state.object_nl
-            depth = state.depth += 1
-            first = true
-            indent = !state.object_nl.empty?
-            each { |key,value|
-              result << delim unless first
-              result << state.indent * depth if indent
-              result << key.to_s.to_json(state)
-              result << state.space_before
-              result << ':'
-              result << state.space
-              result << value.to_json(state)
-              first = false
-            }
-            depth = state.depth -= 1
-            result << state.object_nl
-            result << state.indent * depth if indent if indent
-            result << '}'
-            result
-          end
-        end
-
-        module Array
-          # Returns a JSON string containing a JSON array, that is unparsed from
-          # this Array instance.
-          # _state_ is a JSON::State object, that can also be used to configure the
-          # produced JSON string output further.
-          def to_json(state = nil, *)
-            state = State.from_state(state)
-            state.check_max_nesting
-            json_transform(state)
-          end
-
-          private
-
-          def json_transform(state)
-            delim = ','
-            delim << state.array_nl
-            result = '['
-            result << state.array_nl
-            depth = state.depth += 1
-            first = true
-            indent = !state.array_nl.empty?
-            each { |value|
-              result << delim unless first
-              result << state.indent * depth if indent
-              result << value.to_json(state)
-              first = false
-            }
-            depth = state.depth -= 1
-            result << state.array_nl
-            result << state.indent * depth if indent
-            result << ']'
-          end
-        end
-
-        module Integer
-          # Returns a JSON string representation for this Integer number.
-          def to_json(*) to_s end
-        end
-
-        module Float
-          # Returns a JSON string representation for this Float number.
-          def to_json(state = nil, *)
-            state = State.from_state(state)
-            case
-            when infinite?
-              if state.allow_nan?
-                to_s
-              else
-                raise GeneratorError, "#{self} not allowed in JSON"
-              end
-            when nan?
-              if state.allow_nan?
-                to_s
-              else
-                raise GeneratorError, "#{self} not allowed in JSON"
-              end
-            else
-              to_s
-            end
-          end
-        end
-
-        module String
-          if defined?(::Encoding)
-            # This string should be encoded with UTF-8 A call to this method
-            # returns a JSON string encoded with UTF16 big endian characters as
-            # \u????.
-            def to_json(state = nil, *args)
-              state = State.from_state(state)
-              if encoding == ::Encoding::UTF_8
-                string = self
-              else
-                string = encode(::Encoding::UTF_8)
-              end
-              if state.ascii_only?
-                '"' << JSON.utf8_to_json_ascii(string) << '"'
-              else
-                '"' << JSON.utf8_to_json(string) << '"'
-              end
-            end
-          else
-            # This string should be encoded with UTF-8 A call to this method
-            # returns a JSON string encoded with UTF16 big endian characters as
-            # \u????.
-            def to_json(state = nil, *args)
-              state = State.from_state(state)
-              if state.ascii_only?
-                '"' << JSON.utf8_to_json_ascii(self) << '"'
-              else
-                '"' << JSON.utf8_to_json(self) << '"'
-              end
-            end
-          end
-
-          # Module that holds the extinding methods if, the String module is
-          # included.
-          module Extend
-            # Raw Strings are JSON Objects (the raw bytes are stored in an
-            # array for the key "raw"). The Ruby String can be created by this
-            # module method.
-            def json_create(o)
-              o['raw'].pack('C*')
-            end
-          end
-
-          # Extends _modul_ with the String::Extend module.
-          def self.included(modul)
-            modul.extend Extend
-          end
-
-          # This method creates a raw object hash, that can be nested into
-          # other data structures and will be unparsed as a raw string. This
-          # method should be used, if you want to convert raw strings to JSON
-          # instead of UTF-8 strings, e. g. binary data.
-          def to_json_raw_object
-            {
-              JSON.create_id  => self.class.name,
-              'raw'           => self.unpack('C*'),
-            }
-          end
-
-          # This method creates a JSON text from the result of
-          # a call to to_json_raw_object of this String.
-          def to_json_raw(*args)
-            to_json_raw_object.to_json(*args)
-          end
-        end
-
-        module TrueClass
-          # Returns a JSON string for true: 'true'.
-          def to_json(*) 'true' end
-        end
-
-        module FalseClass
-          # Returns a JSON string for false: 'false'.
-          def to_json(*) 'false' end
-        end
-
-        module NilClass
-          # Returns a JSON string for nil: 'null'.
-          def to_json(*) 'null' end
-        end
-      end
-    end
-  end
-end
-
-module JSON
-  class << self
-    # If _object_ is string-like, parse the string and return the parsed result
-    # as a Ruby data structure. Otherwise generate a JSON 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
-        JSON.parse(object.to_str, opts)
-      else
-        JSON.generate(object, opts)
-      end
-    end
-
-    # Returns the JSON parser class that is used by JSON. This is either
-    # JSON::Ext::Parser or JSON::Pure::Parser.
-    attr_reader :parser
-
-    # Set the JSON parser class _parser_ to be used by JSON.
-    def parser=(parser) # :nodoc:
-      @parser = parser
-      remove_const :Parser if JSON.const_defined_in?(self, :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.to_s.split(/::/).inject(Object) do |p, c|
-        case
-        when c.empty?                     then p
-        when JSON.const_defined_in?(p, c) then p.const_get(c)
-        else
-          begin
-            p.const_missing(c)
-          rescue NameError => e
-            raise ArgumentError, "can't get const #{path}: #{e}"
-          end
-        end
-      end
-    end
-
-    # Set the module _generator_ to be used by JSON.
-    def generator=(generator) # :nodoc:
-      old, $VERBOSE = $VERBOSE, nil
-      @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_json' and remove_method m
-          end
-          include modul
-        end
-      end
-      self.state = generator::State
-      const_set :State, self.state
-      const_set :SAFE_STATE_PROTOTYPE, State.new
-      const_set :FAST_STATE_PROTOTYPE, State.new(
-        :indent         => '',
-        :space          => '',
-        :object_nl      => "",
-        :array_nl       => "",
-        :max_nesting    => false
-      )
-      const_set :PRETTY_STATE_PROTOTYPE, State.new(
-        :indent         => '  ',
-        :space          => ' ',
-        :object_nl      => "\n",
-        :array_nl       => "\n"
-      )
-    ensure
-      $VERBOSE = old
-    end
-
-    # Returns the JSON generator module that is used by JSON. This is
-    # either JSON::Ext::Generator or JSON::Pure::Generator.
-    attr_reader :generator
-
-    # Returns the JSON generator state class that is used by JSON. This is
-    # either JSON::Ext::Generator::State or JSON::Pure::Generator::State.
-    attr_accessor :state
-
-    # This is create identifier, which 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           = 0.0/0
-
-  Infinity      = 1.0/0
-
-  MinusInfinity = -Infinity
-
-  # The base exception for JSON errors.
-  class JSONError < StandardError; end
-
-  # This exception is raised if a parser error occurs.
-  class ParserError < JSONError; end
-
-  # This exception is raised if the nesting of parsed data structures is too
-  # deep.
-  class NestingError < ParserError; end
-
-  # :stopdoc:
-  class CircularDatastructure < NestingError; end
-  # :startdoc:
-
-  # This exception is raised if a generator or unparser error occurs.
-  class GeneratorError < JSONError; end
-  # For backwards compatibility
-  UnparserError = GeneratorError
-
-  # 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 < JSONError; end
-
-  module_function
-
-  # Parse the JSON document _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.
-  # * *symbolize_names*: If set to true, returns symbols for the names
-  #   (keys) in a JSON object. Otherwise strings are returned. Strings are
-  #   the default.
-  # * *create_additions*: If set to false, the Parser doesn't create
-  #   additions even if a matching class and create_id was found. This option
-  #   defaults to true.
-  # * *object_class*: Defaults to Hash
-  # * *array_class*: Defaults to Array
-  def parse(source, opts = {})
-    Parser.new(source, opts).parse
-  end
-
-  # Parse the JSON document _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_ documents.
-  #
-  # _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 matching class and create_id was found. This option
-  #   defaults to true.
-  def parse!(source, opts = {})
-    opts = {
-      :max_nesting  => false,
-      :allow_nan    => true
-    }.update(opts)
-    Parser.new(source, opts).parse
-  end
-
-  # Generate a JSON document from the Ruby data structure _obj_ and return
-  # it. _state_ is * a JSON::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 JSON 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 JSON object (default: ''),
-  # * *array_nl*: a string that is put at the end of a JSON array (default: ''),
-  # * *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 JSON 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 pretty output.
-  def generate(obj, opts = nil)
-    if State === opts
-      state, opts = opts, nil
-    else
-      state = SAFE_STATE_PROTOTYPE.dup
-    end
-    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 = state.configure(opts)
-    end
-    state.generate(obj)
-  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:
-
-  # Generate a JSON document from the Ruby data structure _obj_ and return it.
-  # This method disables the checks for circles in Ruby objects.
-  #
-  # *WARNING*: Be careful not to pass any Ruby data structures with circles as
-  # _obj_ argument because this will cause JSON to go into an infinite loop.
-  def fast_generate(obj, opts = nil)
-    if State === opts
-      state, opts = opts, nil
-    else
-      state = FAST_STATE_PROTOTYPE.dup
-    end
-    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
-    state.generate(obj)
-  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:
-
-  # Generate a JSON document from the Ruby data structure _obj_ and return it.
-  # The returned document is a prettier form of the document 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)
-    if State === opts
-      state, opts = opts, nil
-    else
-      state = PRETTY_STATE_PROTOTYPE.dup
-    end
-    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
-    state.generate(obj)
-  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:
-
-  class << self
-    # The global default options for the JSON.load method:
-    #  :max_nesting: false
-    #  :allow_nan:   true
-    #  :quirks_mode: true
-    attr_accessor :load_default_options
-  end
-  self.load_default_options = {
-    :max_nesting => false,
-    :allow_nan   => true,
-    :quirks_mode => true,
-  }
-
-  # Load a ruby data structure from a JSON _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. The default
-  # options for the parser can be changed via the load_default_options method.
-  #
-  # This method is part of the implementation of the load/dump interface of
-  # Marshal and YAML.
-  def load(source, proc = nil)
-    opts = load_default_options
-    if source.respond_to? :to_str
-      source = source.to_str
-    elsif source.respond_to? :to_io
-      source = source.to_io.read
-    elsif source.respond_to?(:read)
-      source = source.read
-    end
-    if opts[:quirks_mode] && (source.nil? || source.empty?)
-      source = 'null'
-    end
-    result = parse(source, opts)
-    recurse_proc(result, &proc) if proc
-    result
-  end
-
-  # Recursively calls passed _Proc_ if the parsed data structure is an _Array_ or _Hash_
-  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
-
-  alias restore load
-  module_function :restore
-
-  class << self
-    # The global default options for the JSON.dump method:
-    #  :max_nesting: false
-    #  :allow_nan:   true
-    #  :quirks_mode: true
-    attr_accessor :dump_default_options
-  end
-  self.dump_default_options = {
-    :max_nesting => false,
-    :allow_nan   => true,
-    :quirks_mode => true,
-  }
-
-  # Dumps _obj_ as a JSON 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 JSON 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.
-  #
-  # The default options for the generator can be changed via the
-  # dump_default_options method.
-  #
-  # 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
-    opts = JSON.dump_default_options
-    limit and opts.update(:max_nesting => limit)
-    result = generate(obj, opts)
-    if anIO
-      anIO.write result
-      anIO
-    else
-      result
-    end
-  rescue JSON::NestingError
-    raise ArgumentError, "exceed depth limit"
-  end
-
-  # Swap consecutive bytes of _string_ in place.
-  def self.swap!(string) # :nodoc:
-    0.upto(string.size / 2) do |i|
-      break unless string[2 * i + 1]
-      string[2 * i], string[2 * i + 1] = string[2 * i + 1], string[2 * i]
-    end
-    string
-  end
-
-  # Shortuct for iconv.
-  if ::String.method_defined?(:encode)
-    # Encodes string using Ruby's _String.encode_
-    def self.iconv(to, from, string)
-      string.encode(to, from)
-    end
-  else
-    require 'iconv'
-    # Encodes string using _iconv_ library
-    def self.iconv(to, from, string)
-      Iconv.conv(to, from, string)
-    end
-  end
-
-  if ::Object.method(:const_defined?).arity == 1
-    def self.const_defined_in?(modul, constant)
-      modul.const_defined?(constant)
-    end
-  else
-    def self.const_defined_in?(modul, constant)
-      modul.const_defined?(constant, false)
-    end
-  end
-end
-
-module ::Kernel
-  private
-
-  # Outputs _objs_ to STDOUT as JSON strings in the shortest form, that is in
-  # one line.
-  def j(*objs)
-    objs.each do |obj|
-      puts JSON::generate(obj, :allow_nan => true, :max_nesting => false)
-    end
-    nil
-  end
-
-  # Ouputs _objs_ to STDOUT as JSON strings in a pretty format, with
-  # indentation and over many lines.
-  def jj(*objs)
-    objs.each do |obj|
-      puts 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 JSON 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 JSON(object, *args)
-    if object.respond_to? :to_str
-      JSON.parse(object.to_str, args.first)
-    else
-      JSON.generate(object, args.first)
-    end
-  end
-end
-
-# Extends any Class to include _json_creatable?_ method.
-class ::Class
-  # Returns true if this class can be used to create an instance
-  # from a serialised JSON string. The class has to implement a class
-  # method _json_create_ that expects a hash as first parameter. The hash
-  # should include the required data.
-  def json_creatable?
-    respond_to?(:json_create)
-  end
-end
-
-JSON.generator = JSON::Pure::Generator
-JSON.parser    = JSON::Pure::Parser
-rescue LoadError
-  require File.join File.dirname(File.dirname(__FILE__)), 'vendor', 'json.rb'
-end
-
-begin
-  
-# The netrc library (https://github.com/heroku/netrc) is reproduced below, along
-# with its copyright and license:
-# - https://raw.githubusercontent.com/heroku/netrc/262ef111/LICENSE.md
-# - https://raw.githubusercontent.com/heroku/netrc/262ef111/lib/netrc.rb
-
-# The MIT License (MIT)
-#
-# Copyright (c) 2011-2014 [CONTRIBUTORS.md](https://github.com/geemus/netrc/blob/master/CONTRIBUTORS.md)
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of
-# this software and associated documentation files (the "Software"), to deal in
-# the Software without restriction, including without limitation the rights to
-# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
-# the Software, and to permit persons to whom the Software is furnished to do so,
-# subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
-# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
-# COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
-# IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
-# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-require 'rbconfig'
-require 'io/console'
-
-class Netrc
-  VERSION = "0.11.0"
-
-  # see http://stackoverflow.com/questions/4871309/what-is-the-correct-way-to-detect-if-ruby-is-running-on-windows
-  WINDOWS = RbConfig::CONFIG["host_os"] =~ /mswin|mingw|cygwin/
-  CYGWIN  = RbConfig::CONFIG["host_os"] =~ /cygwin/
-
-  def self.default_path
-    File.join(ENV['NETRC'] || home_path, netrc_filename)
-  end
-
-  def self.home_path
-    home = Dir.respond_to?(:home) ? Dir.home : ENV['HOME']
-
-    if WINDOWS && !CYGWIN
-      home ||= File.join(ENV['HOMEDRIVE'], ENV['HOMEPATH']) if ENV['HOMEDRIVE'] && ENV['HOMEPATH']
-      home ||= ENV['USERPROFILE']
-      # XXX: old stuff; most likely unnecessary
-      home = home.tr("\\", "/") unless home.nil?
-    end
-
-    (home && File.readable?(home)) ? home : Dir.pwd
-  rescue ArgumentError
-    return Dir.pwd
-  end
-
-  def self.netrc_filename
-    WINDOWS && !CYGWIN ? "_netrc" : ".netrc"
-  end
-
-  def self.config
-    @config ||= {}
-  end
-
-  def self.configure
-    yield(self.config) if block_given?
-    self.config
-  end
-
-  def self.check_permissions(path)
-    perm = File.stat(path).mode & 0777
-    if perm != 0600 && !(WINDOWS) && !(Netrc.config[:allow_permissive_netrc_file])
-      raise Error, "Permission bits for '#{path}' should be 0600, but are "+perm.to_s(8)
-    end
-  end
-
-  # Reads path and parses it as a .netrc file. If path doesn't
-  # exist, returns an empty object. Decrypt paths ending in .gpg.
-  def self.read(path=default_path)
-    check_permissions(path)
-    data = if path =~ /\.gpg$/
-      decrypted = if ENV['GPG_AGENT_INFO']
-        `gpg --batch --quiet --decrypt #{path}`
-      else
-         print "Enter passphrase for #{path}: "
-         STDIN.noecho do
-           `gpg --batch --passphrase-fd 0 --quiet --decrypt #{path}`
-         end
-      end
-      if $?.success?
-        decrypted
-      else
-        raise Error.new("Decrypting #{path} failed.") unless $?.success?
-      end
-    else
-      File.read(path)
-    end
-    new(path, parse(lex(data.lines.to_a)))
-  rescue Errno::ENOENT
-    new(path, parse(lex([])))
-  end
-
-  class TokenArray < Array
-    def take
-      if length < 1
-        raise Error, "unexpected EOF"
-      end
-      shift
-    end
-
-    def readto
-      l = []
-      while length > 0 && ! yield(self[0])
-        l << shift
-      end
-      return l.join
-    end
-  end
-
-  def self.lex(lines)
-    tokens = TokenArray.new
-    for line in lines
-      content, comment = line.split(/(\s*#.*)/m)
-      content.each_char do |char|
-        case char
-        when /\s/
-          if tokens.last && tokens.last[-1..-1] =~ /\s/
-            tokens.last << char
-          else
-            tokens << char
-          end
-        else
-          if tokens.last && tokens.last[-1..-1] =~ /\S/
-            tokens.last << char
-          else
-            tokens << char
-          end
-        end
-      end
-      if comment
-        tokens << comment
-      end
-    end
-    tokens
-  end
-
-  def self.skip?(s)
-    s =~ /^\s/
-  end
-
-
-
-  # Returns two values, a header and a list of items.
-  # Each item is a tuple, containing some or all of:
-  # - machine keyword (including trailing whitespace+comments)
-  # - machine name
-  # - login keyword (including surrounding whitespace+comments)
-  # - login
-  # - password keyword (including surrounding whitespace+comments)
-  # - password
-  # - trailing chars
-  # This lets us change individual fields, then write out the file
-  # with all its original formatting.
-  def self.parse(ts)
-    cur, item = [], []
-
-    unless ts.is_a?(TokenArray)
-      ts = TokenArray.new(ts)
-    end
-
-    pre = ts.readto{|t| t == "machine" || t == "default"}
-
-    while ts.length > 0
-      if ts[0] == 'default'
-        cur << ts.take.to_sym
-        cur << ''
-      else
-        cur << ts.take + ts.readto{|t| ! skip?(t)}
-        cur << ts.take
-      end
-
-      if ts.include?('login')
-        cur << ts.readto{|t| t == "login"} + ts.take + ts.readto{|t| ! skip?(t)}
-        cur << ts.take
-      end
-
-      if ts.include?('password')
-        cur << ts.readto{|t| t == "password"} + ts.take + ts.readto{|t| ! skip?(t)}
-        cur << ts.take
-      end
-
-      cur << ts.readto{|t| t == "machine" || t == "default"}
-
-      item << cur
-      cur = []
-    end
-
-    [pre, item]
-  end
-
-  def initialize(path, data)
-    @new_item_prefix = ''
-    @path = path
-    @pre, @data = data
-
-    if @data && @data.last && :default == @data.last[0]
-      @default = @data.pop
-    else
-      @default = nil
-    end
-  end
-
-  attr_accessor :new_item_prefix
-
-  def [](k)
-    if item = @data.detect {|datum| datum[1] == k}
-      Entry.new(item[3], item[5])
-    elsif @default
-      Entry.new(@default[3], @default[5])
-    end
-  end
-
-  def []=(k, info)
-    if item = @data.detect {|datum| datum[1] == k}
-      item[3], item[5] = info
-    else
-      @data << new_item(k, info[0], info[1])
-    end
-  end
-
-  def length
-    @data.length
-  end
-
-  def delete(key)
-    datum = nil
-    for value in @data
-      if value[1] == key
-        datum = value
-        break
-      end
-    end
-    @data.delete(datum)
-  end
-
-  def each(&block)
-    @data.each(&block)
-  end
-
-  def new_item(m, l, p)
-    [new_item_prefix+"machine ", m, "\n  login ", l, "\n  password ", p, "\n"]
-  end
-
-  def save
-    if @path =~ /\.gpg$/
-      e = IO.popen("gpg -a --batch --default-recipient-self -e", "r+") do |gpg|
-        gpg.puts(unparse)
-        gpg.close_write
-        gpg.read
-      end
-      raise Error.new("Encrypting #{@path} failed.") unless $?.success?
-      File.open(@path, 'w', 0600) {|file| file.print(e)}
-    else
-      File.open(@path, 'w', 0600) {|file| file.print(unparse)}
-    end
-  end
-
-  def unparse
-    @pre + @data.map do |datum|
-      datum = datum.join
-      unless datum[-1..-1] == "\n"
-        datum << "\n"
-      else
-        datum
-      end
-    end.join
-  end
-
-  Entry = Struct.new(:login, :password) do
-    alias to_ary to_a
-  end
-
-end
-
-class Netrc::Error < ::StandardError
-end
-rescue LoadError
-  require File.join File.dirname(File.dirname(__FILE__)), 'vendor', 'netrc.rb'
-end
-
-# It just gists.
-module Gist
-  extend self
-
-  VERSION = '4.6.0'
-
-  # A list of clipboard commands with copy and paste support.
-  CLIPBOARD_COMMANDS = {
-    'pbcopy'  => 'pbpaste',
-    'xclip'   => 'xclip -o',
-    'xsel -i' => 'xsel -o',
-    'putclip' => 'getclip',
-  }
-
-  GITHUB_API_URL   = URI("https://api.github.com/")
-  GIT_IO_URL       = URI("https://git.io")
-
-  GITHUB_BASE_PATH = ""
-  GHE_BASE_PATH    = "/api/v3"
-
-  URL_ENV_NAME     = "GITHUB_URL"
-
-  USER_AGENT       = "gist/#{VERSION} (Net::HTTP, #{RUBY_DESCRIPTION})"
-
-  # Exception tag for errors raised while gisting.
-  module Error;
-    def self.exception(*args)
-      RuntimeError.new(*args).extend(self)
-    end
-  end
-  class ClipboardError < RuntimeError; include Error end
-
-  # helper module for authentication token actions
-  module AuthTokenFile
-    def self.filename
-      if ENV.key?(URL_ENV_NAME)
-        File.expand_path "~/.gist.#{ENV[URL_ENV_NAME].gsub(/:/, '.').gsub(/[^a-z0-9.]/, '')}"
-      else
-        File.expand_path "~/.gist"
-      end
-    end
-
-    def self.read
-      File.read(filename).chomp
-    end
-
-    def self.write(token)
-      File.open(filename, 'w', 0600) do |f|
-        f.write token
-      end
-    end
-  end
-
-  # auth token for authentication
-  #
-  # @return [String] string value of access token or `nil`, if not found
-  def auth_token
-    @token ||= AuthTokenFile.read rescue nil || Netrc.read[self.api_url.host][1]
-  end
-
-  # Upload a gist to https://gist.github.com
-  #
-  # @param [String] content  the code you'd like to gist
-  # @param [Hash] options  more detailed options, see
-  #   the documentation for {multi_gist}
-  #
-  # @see http://developer.github.com/v3/gists/
-  def gist(content, options = {})
-    filename = options[:filename] || "a.rb"
-    multi_gist({filename => content}, options)
-  end
-
-  # Upload a gist to https://gist.github.com
-  #
-  # @param [Hash] files  the code you'd like to gist: filename => content
-  # @param [Hash] options  more detailed options
-  #
-  # @option options [String] :description  the description
-  # @option options [Boolean] :public  (false) is this gist public
-  # @option options [Boolean] :anonymous  (false) is this gist anonymous
-  # @option options [String] :access_token  (`File.read("~/.gist")`) The OAuth2 access token.
-  # @option options [String] :update  the URL or id of a gist to update
-  # @option options [Boolean] :copy  (false) Copy resulting URL to clipboard, if successful.
-  # @option options [Boolean] :open  (false) Open the resulting URL in a browser.
-  # @option options [Symbol] :output (:all) The type of return value you'd like:
-  #   :html_url gives a String containing the url to the gist in a browser
-  #   :short_url gives a String contianing a  git.io url that redirects to html_url
-  #   :javascript gives a String containing a script tag suitable for embedding the gist
-  #   :all gives a Hash containing the parsed json response from the server
-  #
-  # @return [String, Hash]  the return value as configured by options[:output]
-  # @raise [Gist::Error]  if something went wrong
-  #
-  # @see http://developer.github.com/v3/gists/
-  def multi_gist(files, options={})
-    json = {}
-
-    json[:description] = options[:description] if options[:description]
-    json[:public] = !!options[:public]
-    json[:files] = {}
-
-    files.each_pair do |(name, content)|
-      raise "Cannot gist empty files" if content.to_s.strip == ""
-      json[:files][File.basename(name)] = {:content => content}
-    end
-
-    existing_gist = options[:update].to_s.split("/").last
-    if options[:anonymous]
-      access_token = nil
-    else
-      access_token = (options[:access_token] || auth_token())
-    end
-
-    url = "#{base_path}/gists"
-    url << "/" << CGI.escape(existing_gist) if existing_gist.to_s != ''
-    url << "?access_token=" << CGI.escape(access_token) if access_token.to_s != ''
-
-    request = Net::HTTP::Post.new(url)
-    request.body = JSON.dump(json)
-    request.content_type = 'application/json'
-
-    retried = false
-
-    begin
-      response = http(api_url, request)
-      if Net::HTTPSuccess === response
-        on_success(response.body, options)
-      else
-        raise "Got #{response.class} from gist: #{response.body}"
-      end
-    rescue => e
-      raise if retried
-      retried = true
-      retry
-    end
-
-  rescue => e
-    raise e.extend Error
-  end
-
-  # List all gists(private also) for authenticated user
-  # otherwise list public gists for given username (optional argument)
-  #
-  # @param [String] user
-  # @deprecated
-  #
-  # see https://developer.github.com/v3/gists/#list-gists
-  def list_gists(user = "")
-    url = "#{base_path}"
-
-    if user == ""
-      access_token = auth_token()
-      if access_token.to_s != ''
-        url << "/gists?access_token=" << CGI.escape(access_token)
-
-        request = Net::HTTP::Get.new(url)
-        response = http(api_url, request)
-
-        pretty_gist(response)
-
-      else
-        raise Error, "Not authenticated. Use 'gist --login' to login or 'gist -l username' to view public gists."
-      end
-
-    else
-      url << "/users/#{user}/gists"
-
-      request = Net::HTTP::Get.new(url)
-      response = http(api_url, request)
-
-      pretty_gist(response)
-    end
-  end
-
-  def list_all_gists(user = "")
-    url = "#{base_path}"
-
-    if user == ""
-      access_token = auth_token()
-      if access_token.to_s != ''
-        url << "/gists?per_page=100&access_token=" << CGI.escape(access_token)
-        get_gist_pages(url)
-      else
-        raise Error, "Not authenticated. Use 'gist --login' to login or 'gist -l username' to view public gists."
-      end
-
-    else
-      url << "/users/#{user}/gists?per_page=100"
-      get_gist_pages(url)
-    end
-
-  end
-
-  def read_gist(id, file_name=nil)
-    url = "#{base_path}/gists/#{id}"
-    request = Net::HTTP::Get.new(url)
-    response = http(api_url, request)
-
-    if response.code == '200'
-      body = JSON.parse(response.body)
-      files = body["files"]
-
-      if file_name
-        file = files[file_name]
-        raise Error, "Gist with id of #{id} and file #{file_name} does not exist." unless file
-      else
-        file = files.values.first
-      end
-
-      puts file["content"]
-    else
-      raise Error, "Gist with id of #{id} does not exist."
-    end
-  end
-
-  def delete_gist(id)
-    id = id.split("/").last
-    url = "#{base_path}/gists/#{id}"
-
-    access_token = auth_token()
-    if access_token.to_s != ''
-      url << "?access_token=" << CGI.escape(access_token)
-
-      request = Net::HTTP::Delete.new(url)
-      response = http(api_url, request)
-    else
-      raise Error, "Not authenticated. Use 'gist --login' to login."
-    end
-
-    if response.code == '204'
-      puts "Deleted!"
-    else
-      raise Error, "Gist with id of #{id} does not exist."
-    end
-  end
-
-  def get_gist_pages(url)
-
-    request = Net::HTTP::Get.new(url)
-    response = http(api_url, request)
-    pretty_gist(response)
-
-    link_header = response.header['link']
-
-    if link_header
-      links = Hash[ link_header.gsub(/(<|>|")/, "").split(',').map { |link| link.split('; rel=') } ].invert
-      get_gist_pages(links['next']) if links['next']
-    end
-
-  end
-
-  # return prettified string result of response body for all gists
-  #
-  # @params [Net::HTTPResponse] response
-  # @return [String] prettified result of listing all gists
-  #
-  # see https://developer.github.com/v3/gists/#response
-  def pretty_gist(response)
-    body = JSON.parse(response.body)
-    if response.code == '200'
-      body.each do |gist|
-        description = "#{gist['description'] || gist['files'].keys.join(" ")} #{gist['public'] ? '' : '(secret)'}"
-        puts "#{gist['html_url']} #{description.tr("\n", " ")}\n"
-        $stdout.flush
-      end
-
-    else
-      raise Error, body['message']
-    end
-  end
-
-  # Convert long github urls into short git.io ones
-  #
-  # @param [String] url
-  # @return [String] shortened url, or long url if shortening fails
-  def shorten(url)
-    request = Net::HTTP::Post.new("/create")
-    request.set_form_data(:url => url)
-    response = http(GIT_IO_URL, request)
-    case response.code
-    when "200"
-      URI.join(GIT_IO_URL, response.body).to_s
-    when "201"
-      response['Location']
-    else
-      url
-    end
-  end
-
-  # Convert github url into raw file url
-  #
-  # Unfortunately the url returns from github's api is legacy,
-  # we have to taking a HTTPRedirection before appending it
-  # with '/raw'. Let's looking forward for github's api fix :)
-  #
-  # @param [String] url
-  # @return [String] the raw file url
-  def rawify(url)
-    uri = URI(url)
-    request = Net::HTTP::Get.new(uri.path)
-    response = http(uri, request)
-    if Net::HTTPSuccess === response
-      url + '/raw'
-    elsif Net::HTTPRedirection === response
-      rawify(response.header['location'])
-    end
-  end
-
-  # Log the user into gist.
-  #
-  # This method asks the user for a username and password, and tries to obtain
-  # and OAuth2 access token, which is then stored in ~/.gist
-  #
-  # @raise [Gist::Error]  if something went wrong
-  # @param [Hash] credentials  login details
-  # @option credentials [String] :username
-  # @option credentials [String] :password
-  # @see http://developer.github.com/v3/oauth/
-  def login!(credentials={})
-    puts "Obtaining OAuth2 access_token from github."
-    loop do
-      print "GitHub username: "
-      username = credentials[:username] || $stdin.gets.strip
-      print "GitHub password: "
-      password = credentials[:password] || begin
-        `stty -echo` rescue nil
-        $stdin.gets.strip
-      ensure
-        `stty echo` rescue nil
-      end
-      puts ""
-
-      request = Net::HTTP::Post.new("#{base_path}/authorizations")
-      request.body = JSON.dump({
-        :scopes => [:gist],
-        :note => "The gist gem (#{Time.now})",
-        :note_url => "https://github.com/ConradIrwin/gist"
-      })
-      request.content_type = 'application/json'
-      request.basic_auth(username, password)
-
-      response = http(api_url, request)
-
-      if Net::HTTPUnauthorized === response && response['X-GitHub-OTP']
-        print "2-factor auth code: "
-        twofa_code = $stdin.gets.strip
-        puts ""
-
-        request['X-GitHub-OTP'] = twofa_code
-        response = http(api_url, request)
-      end
-
-      if Net::HTTPCreated === response
-        AuthTokenFile.write JSON.parse(response.body)['token']
-        puts "Success! #{ENV[URL_ENV_NAME] || "https://github.com/"}settings/tokens"
-        return
-      elsif Net::HTTPUnauthorized === response
-        puts "Error: #{JSON.parse(response.body)['message']}"
-        next
-      else
-        raise "Got #{response.class} from gist: #{response.body}"
-      end
-    end
-  rescue => e
-    raise e.extend Error
-  end
-
-  # Return HTTP connection
-  #
-  # @param [URI::HTTP] The URI to which to connect
-  # @return [Net::HTTP]
-  def http_connection(uri)
-    env = ENV['http_proxy'] || ENV['HTTP_PROXY']
-    connection = if env
-                   proxy = URI(env)
-                   Net::HTTP::Proxy(proxy.host, proxy.port).new(uri.host, uri.port)
-                 else
-                   Net::HTTP.new(uri.host, uri.port)
-                 end
-    if uri.scheme == "https"
-      connection.use_ssl = true
-      connection.verify_mode = OpenSSL::SSL::VERIFY_NONE
-    end
-    connection.open_timeout = 10
-    connection.read_timeout = 10
-    connection
-  end
-
-  # Run an HTTP operation
-  #
-  # @param [URI::HTTP] The URI to which to connect
-  # @param [Net::HTTPRequest] The request to make
-  # @return [Net::HTTPResponse]
-  def http(url, request)
-    request['User-Agent'] = USER_AGENT
-
-    http_connection(url).start do |http|
-      http.request request
-    end
-  rescue Timeout::Error
-    raise "Could not connect to #{api_url}"
-  end
-
-  # Called after an HTTP response to gist to perform post-processing.
-  #
-  # @param [String] body  the text body from the github api
-  # @param [Hash] options  more detailed options, see
-  #   the documentation for {multi_gist}
-  def on_success(body, options={})
-    json = JSON.parse(body)
-
-    output = case options[:output]
-             when :javascript
-               %Q{<script src="#{json['html_url']}.js"></script>}
-             when :html_url
-               json['html_url']
-             when :raw_url
-               rawify(json['html_url'])
-             when :short_url
-               shorten(json['html_url'])
-             when :short_raw_url
-               shorten(rawify(json['html_url']))
-             else
-               json
-             end
-
-    Gist.copy(output.to_s) if options[:copy]
-    Gist.open(json['html_url']) if options[:open]
-
-    output
-  end
-
-  # Copy a string to the clipboard.
-  #
-  # @param [String] content
-  # @raise [Gist::Error] if no clipboard integration could be found
-  #
-  def copy(content)
-    IO.popen(clipboard_command(:copy), 'r+') { |clip| clip.print content }
-
-    unless paste == content
-      message = 'Copying to clipboard failed.'
-
-      if ENV["TMUX"] && clipboard_command(:copy) == 'pbcopy'
-        message << "\nIf you're running tmux on a mac, try http://robots.thoughtbot.com/post/19398560514/how-to-copy-and-paste-with-tmux-on-mac-os-x"
-      end
-
-      raise Error, message
-    end
-  rescue Error => e
-    raise ClipboardError, e.message + "\nAttempted to copy: #{content}"
-  end
-
-  # Get a string from the clipboard.
-  #
-  # @param [String] content
-  # @raise [Gist::Error] if no clipboard integration could be found
-  def paste
-    `#{clipboard_command(:paste)}`
-  end
-
-  # Find command from PATH environment.
-  #
-  # @param [String] cmd  command name to find
-  # @param [String] options  PATH environment variable
-  # @return [String]  the command found
-  def which(cmd, path=ENV['PATH'])
-    if RUBY_PLATFORM.downcase =~ /mswin(?!ce)|mingw|bccwin|cygwin/
-      path.split(File::PATH_SEPARATOR).each {|dir|
-        f = File.join(dir, cmd+".exe")
-        return f if File.executable?(f) && !File.directory?(f)
-      }
-      nil
-    else
-      return system("which #{cmd} > /dev/null 2>&1")
-    end
-  end
-
-  # Get the command to use for the clipboard action.
-  #
-  # @param [Symbol] action  either :copy or :paste
-  # @return [String]  the command to run
-  # @raise [Gist::ClipboardError] if no clipboard integration could be found
-  def clipboard_command(action)
-    command = CLIPBOARD_COMMANDS.keys.detect do |cmd|
-      which cmd
-    end
-    raise ClipboardError, <<-EOT unless command
-Could not find copy command, tried:
-    #{CLIPBOARD_COMMANDS.values.join(' || ')}
-    EOT
-    action == :copy ? command : CLIPBOARD_COMMANDS[command]
-  end
-
-  # Open a URL in a browser.
-  #
-  # @param [String] url
-  # @raise [RuntimeError] if no browser integration could be found
-  #
-  # This method was heavily inspired by defunkt's Gist#open,
-  # @see https://github.com/defunkt/gist/blob/bca9b29/lib/gist.rb#L157
-  def open(url)
-    command = if ENV['BROWSER']
-                ENV['BROWSER']
-              elsif RUBY_PLATFORM =~ /darwin/
-                'open'
-              elsif RUBY_PLATFORM =~ /linux/
-                %w(
-                  sensible-browser
-                  xdg-open
-                  firefox
-                  firefox-bin
-                ).detect do |cmd|
-                  which cmd
-                end
-              elsif ENV['OS'] == 'Windows_NT' || RUBY_PLATFORM =~ /djgpp|(cyg|ms|bcc)win|mingw|wince/i
-                'start ""'
-              else
-                raise "Could not work out how to use a browser."
-              end
-
-    `#{command} #{url}`
-  end
-
-  # Get the API base path
-  def base_path
-    ENV.key?(URL_ENV_NAME) ? GHE_BASE_PATH : GITHUB_BASE_PATH
-  end
-
-  # Get the API URL
-  def api_url
-    ENV.key?(URL_ENV_NAME) ? URI(ENV[URL_ENV_NAME]) : GITHUB_API_URL
-  end
-
-  def legacy_private_gister?
-    return unless which('git')
-    `git config --global gist.private` =~ /\Ayes|1|true|on\z/i
-  end
-
-  def should_be_public?(options={})
-    if options.key? :private
-      !options[:private]
-    else
-      !Gist.legacy_private_gister?
-    end
-  end
-end
-#!/usr/bin/env ruby
-
-# Silence Ctrl-C's
-trap('INT'){ exit 1 }
-
-if Signal.list.include? 'PIPE'
-  trap('PIPE', 'EXIT')
-end
-
-require 'optparse'
-
-# For the holdings of options.
-options = {}
-filenames = []
-
-OptionParser.new do |opts|
-  executable_name = File.split($0)[1]
-  opts.banner = <<-EOS
-Gist (v#{Gist::VERSION}) lets you upload to https://gist.github.com/
-
-The content to be uploaded can be passed as a list of files, if none are
-specified STDIN will be read. The default filename for STDIN is "a.rb", and all
-filenames can be overridden by repeating the "-f" flag. The most useful reason
-to do this is to change the syntax highlighting.
-
-If you'd like your gists to be associated with your GitHub account, so that you
-can edit them and find them in future, first use `gist --login` to obtain an
-Oauth2 access token. This is stored and used by gist in the future.
-
-Private gists do not have guessable URLs and can be created with "-p", you can
-also set the description at the top of the gist by passing "-d".
-
-Anonymous gists are not associated with your GitHub account, they can be created
-with "-a" even after you have used "gist --login".
-
-If you would like to shorten the resulting gist URL, use the -s flag. This will
-use GitHub's URL shortener, git.io. You can also use -R to get the link to the
-raw gist.
-
-To copy the resulting URL to your clipboard you can use the -c option, or to
-just open it directly in your browser, use -o. Using the -e option will copy the
-embeddable URL to the clipboard. You can add `alias gist='gist -c'` to your
-shell's rc file to configure this behaviour by default.
-
-Instead of creating a new gist, you can update an existing one by passing its ID
-or URL with "-u". For this to work, you must be logged in, and have created the
-original gist with the same GitHub account.
-
-Usage: #{executable_name} [-o|-c|-e] [-p] [-s] [-R] [-d DESC] [-a] [-u URL] [-P] [-f NAME|-t EXT]* FILE*
-       #{executable_name} --login
-       #{executable_name} [-l|-r]
-
-  EOS
-
-  opts.on("--login", "Authenticate gist on this computer.") do
-    Gist.login!
-    exit
-  end
-
-  opts.on("-f", "--filename [NAME.EXTENSION]", "Sets the filename and syntax type.") do |filename|
-    filenames << filename
-    options[:filename] = filename
-  end
-
-  opts.on("-t", "--type [EXTENSION]", "Sets the file extension and syntax type.") do |extension|
-    filenames << "foo.#{extension}"
-    options[:filename] = "foo.#{extension}"
-  end
-
-  opts.on("-p", "--private", "Makes your gist private.") do
-    options[:private] = true
-  end
-
-  opts.on("--no-private") do
-    options[:private] = false
-  end
-
-  opts.on("-d", "--description DESCRIPTION", "Adds a description to your gist.") do |description|
-    options[:description] = description
-  end
-
-  opts.on("-s", "--shorten", "Shorten the gist URL using git.io.") do |shorten|
-    options[:shorten] = shorten
-  end
-
-  opts.on("-u", "--update [ URL | ID ]", "Update an existing gist.") do |update|
-    options[:update] = update
-  end
-
-  opts.on("-a", "--anonymous", "Create an anonymous gist.") do
-    options[:anonymous] = true
-  end
-
-  opts.on("-c", "--copy", "Copy the resulting URL to the clipboard") do
-    options[:copy] = true
-  end
-
-  opts.on("-e", "--embed", "Copy the embed code for the gist to the clipboard") do
-    options[:embed] = true
-    options[:copy] = true
-  end
-
-  opts.on("-o", "--open", "Open the resulting URL in a browser") do
-    options[:open] = true
-  end
-
-  opts.on("--no-open")
-
-  opts.on("-P", "--paste", "Paste from the clipboard to gist") do
-    options[:paste] = true
-  end
-
-  opts.on("-R", "--raw", "Display raw URL of the new gist") do
-    options[:raw] = true
-  end
-
-  opts.on("-l", "--list [USER]", "List all gists for user") do |user|
-    options[:list] = user
-  end
-
-  opts.on("-r", "--read ID [FILENAME]", "Read a gist and print out the contents") do |id|
-    options[:read] = id
-  end
-
-  opts.on("--delete [ URL | ID ]", "Delete a gist") do |id|
-    options[:delete] = id
-  end
-
-  opts.on_tail("-h","--help", "Show this message.") do
-    puts opts
-    exit
-  end
-
-  opts.on_tail("-v", "--version", "Print the version.") do
-    puts "gist v#{Gist::VERSION}"
-    exit
-  end
-
-end.parse!
-
-begin
-  options[:output] = if options[:embed] && options[:shorten]
-                       raise Gist::Error, "--embed does not make sense with --shorten"
-                     elsif options[:embed]
-                       :javascript
-                     elsif options[:shorten] and options[:raw]
-                       :short_raw_url
-                     elsif options[:shorten]
-                       :short_url
-                     elsif options[:raw]
-                       :raw_url
-                     else
-                       :html_url
-                     end
-
-  options[:public] = Gist.should_be_public?(options)
-
-  if options.key? :list
-    if options[:list]
-      Gist.list_all_gists(options[:list])
-    else
-      Gist.list_all_gists
-    end
-    exit
-  end
-
-  if options.key? :read
-    file_name = ARGV.first
-    Gist.read_gist(options[:read], file_name)
-    exit
-  end
-
-  if options.key? :delete
-    Gist.delete_gist(options[:delete])
-    exit
-  end
-
-  if options[:paste]
-    puts Gist.gist(Gist.paste, options)
-  else
-    to_read = ARGV.empty? ? ['-'] : ARGV
-    files = {}
-    to_read.zip(filenames).each do |(file, name)|
-      files[name || file] =
-        begin
-          if file == '-'
-            $stderr.puts "(type a gist. <ctrl-c> to cancel, <ctrl-d> when done)" if $stdin.tty?
-            STDIN.read
-          else
-            File.read(File.expand_path(file))
-          end
-        rescue => e
-          raise e.extend(Gist::Error)
-        end
-    end
-
-    puts Gist.multi_gist(files, options)
-  end
-
-rescue Gist::Error => e
-  puts "Error: #{e.message}"
-  exit 1
-end