Skip to content

Instantly share code, notes, and snippets.

@maxwofford

maxwofford/gist

Created May 23, 2026 00:42
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save maxwofford/89eafe29732532d53c885feee36bc6af to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save maxwofford/89eafe29732532d53c885feee36bc6af to your computer and use it in GitHub Desktop.
Download ZIP
Raw
gist
#!/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
# It just gists.
module Gist
extend self
VERSION = '6.0.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/")
GITHUB_URL = URI("https://github.com/")
GIT_IO_URL = URI("https://git.io")
GITHUB_BASE_PATH = ""
GHE_BASE_PATH = "/api/v3"
GITHUB_CLIENT_ID = '4f7ec0d4eab38e74384e'
URL_ENV_NAME = "GITHUB_URL"
CLIENT_ID_ENV_NAME = "GIST_CLIENT_ID"
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
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] || default_filename
multi_gist({filename => content}, options)
end
def default_filename
"gistfile1.txt"
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 [Boolean] :skip_empty (false) Skip gisting empty files.
# @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={})
if options[:anonymous]
raise 'Anonymous gists are no longer supported. Please log in with `gist --login`. ' \
'(GitHub now requires credentials to gist https://bit.ly/2GBBxKw)'
else
access_token = (options[:access_token] || auth_token())
end
json = {}
json[:description] = options[:description] if options[:description]
json[:public] = !!options[:public]
json[:files] = {}
files.each_pair do |(name, content)|
if content.to_s.strip == ""
raise "Cannot gist empty files" unless options[:skip_empty]
else
name = name == "-" ? default_filename : File.basename(name)
json[:files][name] = {:content => content}
end
end
return if json[:files].empty? && options[:skip_empty]
existing_gist = options[:update].to_s.split("/").last
url = "#{base_path}/gists"
url << "/" << CGI.escape(existing_gist) if existing_gist.to_s != ''
request = Net::HTTP::Post.new(url)
request['Authorization'] = "token #{access_token}" if access_token.to_s != ''
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"
request = Net::HTTP::Get.new(url)
request['Authorization'] = "token #{access_token}"
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 == ""
url << "/gists?per_page=100"
else
url << "/users/#{user}/gists?per_page=100"
end
get_gist_pages(url, auth_token())
end
def read_gist(id, file_name=nil)
url = "#{base_path}/gists/#{id}"
access_token = auth_token()
request = Net::HTTP::Get.new(url)
request['Authorization'] = "token #{access_token}" if access_token.to_s != ''
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 != ''
request = Net::HTTP::Delete.new(url)
request["Authorization"] = "token #{access_token}"
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, access_token = "")
request = Net::HTTP::Get.new(url)
request['Authorization'] = "token #{access_token}" if access_token.to_s != ''
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'], access_token) 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.
#
def login!(credentials={})
if (login_url == GITHUB_URL || ENV.key?(CLIENT_ID_ENV_NAME)) && credentials.empty? && !ENV.key?('GIST_USE_USERNAME_AND_PASSWORD')
device_flow_login!
else
access_token_login!(credentials)
end
end
def device_flow_login!
puts "Requesting login parameters..."
request = Net::HTTP::Post.new("/login/device/code")
request.body = JSON.dump({
:scope => 'gist',
:client_id => client_id,
})
request.content_type = 'application/json'
request['accept'] = "application/json"
response = http(login_url, request)
if response.code != '200'
raise Error, "HTTP #{response.code}: #{response.body}"
end
body = JSON.parse(response.body)
puts "Please sign in at #{body['verification_uri']}"
puts " and enter code: #{body['user_code']}"
device_code = body['device_code']
interval = body['interval']
loop do
sleep(interval.to_i)
request = Net::HTTP::Post.new("/login/oauth/access_token")
request.body = JSON.dump({
:client_id => client_id,
:grant_type => 'urn:ietf:params:oauth:grant-type:device_code',
:device_code => device_code
})
request.content_type = 'application/json'
request['Accept'] = 'application/json'
response = http(login_url, request)
if response.code != '200'
raise Error, "HTTP #{response.code}: #{response.body}"
end
body = JSON.parse(response.body)
break unless body['error'] == 'authorization_pending'
end
if body['error']
raise Error, body['error_description']
end
AuthTokenFile.write JSON.parse(response.body)['access_token']
puts "Success! #{ENV[URL_ENV_NAME] || "https://github.com/"}settings/connections/applications/#{client_id}"
end
# Logs 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
# @see http://developer.github.com/v3/oauth/
def access_token_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)
if proxy.user
Net::HTTP::Proxy(proxy.host, proxy.port, proxy.user, proxy.password).new(uri.host, uri.port)
else
Net::HTTP::Proxy(proxy.host, proxy.port).new(uri.host, uri.port)
end
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
def login_url
ENV.key?(URL_ENV_NAME) ? URI(ENV[URL_ENV_NAME]) : GITHUB_URL
end
# Get the API URL
def api_url
ENV.key?(URL_ENV_NAME) ? URI(ENV[URL_ENV_NAME]) : GITHUB_API_URL
end
def client_id
ENV.key?(CLIENT_ID_ENV_NAME) ? URI(ENV[CLIENT_ID_ENV_NAME]) : GITHUB_CLIENT_ID
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.
All gists must to be associated with a GitHub account, so you will need to login with
`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".
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.
If you want to skip empty files, use the --skip-empty flag. If all files are
empty no gist will be created.
Usage: #{executable_name} [-o|-c|-e] [-p] [-s] [-R] [-d DESC] [-u URL]
[--skip-empty] [-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("-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("--skip-empty", "Skip gisting empty files") do
options[:skip_empty] = true
end
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
if Gist.auth_token.nil?
puts 'Please log in with `gist --login`. ' \
'(GitHub now requires credentials to gist https://bit.ly/2GBBxKw)'
exit(1)
end
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
output = Gist.multi_gist(files, options)
puts output if output
end
rescue Gist::Error => e
puts "Error: #{e.message}"
exit 1
end
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment