github-api-0.14.2/ 0000755 0001750 0001750 00000000000 12735456050 012234 5 ustar alee alee github-api-0.14.2/lib/ 0000755 0001750 0001750 00000000000 12735456050 013002 5 ustar alee alee github-api-0.14.2/lib/github_api/ 0000755 0001750 0001750 00000000000 12735456050 015115 5 ustar alee alee github-api-0.14.2/lib/github_api/deprecation.rb 0000644 0001750 0001750 00000001406 12735456050 017740 0 ustar alee alee # encoding: utf-8
module Github
DEPRECATION_PREFIX = "[GithubAPI] Deprecation warning:"
class << self
attr_writer :deprecation_tracker
def deprecation_tracker
@deprecation_tracker ||= []
end
# Displays deprecation message to the user.
# Each message is printed once.
def deprecate(method, alternate_method=nil)
return if deprecation_tracker.include? method
deprecation_tracker << method
message = <<-NOTICE
#{DEPRECATION_PREFIX}
* #{method} is deprecated.
NOTICE
if alternate_method
message << <<-ADDITIONAL
* please use #{alternate_method} instead.
ADDITIONAL
end
warn_deprecation(message)
end
def warn_deprecation(message)
send :warn, message
end
end
end # Github
github-api-0.14.2/lib/github_api/middleware.rb 0000644 0001750 0001750 00000002157 12735456050 017564 0 ustar alee alee # encoding: utf-8
require 'github_api/response'
require 'github_api/response/mashify'
require 'github_api/response/jsonize'
require 'github_api/response/atom_parser'
require 'github_api/response/raise_error'
require 'github_api/response/header'
module Github
class Middleware
def self.default(options = {})
api = options[:api]
proc do |builder|
builder.use Github::Request::Jsonize
builder.use Faraday::Request::Multipart
builder.use Faraday::Request::UrlEncoded
builder.use Github::Request::OAuth2, api.oauth_token if api.oauth_token?
builder.use Github::Request::BasicAuth, api.authentication if api.basic_authed?
builder.use Faraday::Response::Logger if ENV['DEBUG']
unless options[:raw]
builder.use Github::Response::Mashify
builder.use Github::Response::Jsonize
builder.use Github::Response::AtomParser
end
if api.stack
api.stack.call(builder)
end
builder.use Github::Response::RaiseError
builder.adapter options[:adapter]
end
end
end # Middleware
end # Github
github-api-0.14.2/lib/github_api/validations/ 0000755 0001750 0001750 00000000000 12735456050 017432 5 ustar alee alee github-api-0.14.2/lib/github_api/validations/token.rb 0000644 0001750 0001750 00000001657 12735456050 021110 0 ustar alee alee # encoding: utf-8
module Github
module Validations
module Token
TOKEN_REQUIRED = [
'get /user',
'get /user/emails',
'get /user/followers',
'get /user/following',
'get /user/keys',
'get /user/repos',
'patch /user',
'post /user/emails',
'post /user/keys',
'post /user/repos'
]
TOKEN_REQUIRED_REGEXP = [
/repos\/.*\/.*\/comments/,
]
# Ensures that required authentication token is present before
# request is sent.
#
def validates_token_for(method, path)
return true unless TOKEN_REQUIRED.grep("#{method} #{path}").empty?
token_required = false
TOKEN_REQUIRED_REGEXP.each do |regex|
if "#{method} #{path}" =~ regex
token_required = true
end
end
return token_required
end
end # Token
end # Validations
end # Github
github-api-0.14.2/lib/github_api/validations/format.rb 0000644 0001750 0001750 00000001340 12735456050 021245 0 ustar alee alee # encoding: utf-8
module Github
module Validations
module Format
# Ensures that value for a given key is of the correct form whether
# matching regular expression or set of predefined values.
#
def assert_valid_values(permitted, params)
params.each do |k, v|
next unless permitted.keys.include?(k)
if permitted[k].is_a?(Array) && !permitted[k].include?(params[k])
raise Github::Error::UnknownValue.new(k,v, permitted[k].join(', '))
elsif permitted[k].is_a?(Regexp) && !(permitted[k] =~ params[k])
raise Github::Error::UnknownValue.new(k,v, permitted[k])
end
end
end
end # Format
end # Validations
end # Github
github-api-0.14.2/lib/github_api/validations/presence.rb 0000644 0001750 0001750 00000001511 12735456050 021561 0 ustar alee alee # encoding: utf-8
module Github
module Validations
# A mixin to help validate presence of non-empty values
module Presence
# Ensure that esential arguments are present before request is made.
#
# == Parameters
# Hash/Array of arguments to be checked against nil and empty string
#
# == Example
# assert_presence_of user: '...', repo: '...'
# assert_presence_of user, repo
#
def assert_presence_of(*args)
hash = args.last.is_a?(::Hash) ? args.pop : {}
errors = hash.select { |key, val| val.to_s.empty? }
raise Github::Error::Validations.new(errors) unless errors.empty?
args.each do |arg|
raise ArgumentError, "parameter cannot be nil" if arg.nil?
end
end
end # Presence
end # Validations
end # Github
github-api-0.14.2/lib/github_api/validations/required.rb 0000644 0001750 0001750 00000001155 12735456050 021601 0 ustar alee alee # encoding: utf-8
module Github
module Validations
module Required
# Validate all keys present in a provided hash against required set,
# on mismatch raise Github::Error::RequiredParams
# Note that keys need to be in the same format i.e. symbols or strings,
# otherwise the comparison will fail.
#
# @api public
def assert_required_keys(*required, provided)
required.flatten.all? { |key|
provided.deep_key?(key.to_s)
} || (raise Github::Error::RequiredParams.new(provided, required))
end
end # Required
end # Validations
end # Github
github-api-0.14.2/lib/github_api/client.rb 0000644 0001750 0001750 00000003336 12735456050 016725 0 ustar alee alee # encoding: utf-8
module Github
class Client < API
require_all 'github_api/client',
'activity',
'authorizations',
'emojis',
'gists',
'gitignore',
'git_data',
'issues',
'markdown',
'meta',
'orgs',
'pull_requests',
'repos',
'say',
'scopes',
'search',
'users'
# Serving up the 'social' in Social Coding, the Activity APIs
# provide access to notifications, subscriptions, and timelines.
namespace :activity
namespace :emojis
namespace :gists
namespace :gitignore
alias :git_ignore :gitignore
# The Git Database API gives you access to read and write raw Git objects
# to your Git database on GitHub and to list and update your references
# (branch heads and tags).
namespace :git_data
alias :git :git_data
namespace :issues
namespace :markdown
namespace :meta
# An API for users to manage their own tokens. You can only access your own
# tokens, and only through Basic Authentication.
namespace :authorizations
alias :oauth :authorizations
alias :auth :authorizations
namespace :orgs
alias :organizations :orgs
namespace :pull_requests
alias :pulls :pull_requests
namespace :repos
alias :repositories :repos
namespace :say
alias :octocat :say
namespace :scopes
namespace :search
# Many of the resources on the users API provide a shortcut for getting
# information about the currently authenticated user.
namespace :users
end # Client
end # Github
github-api-0.14.2/lib/github_api/request/ 0000755 0001750 0001750 00000000000 12735456050 016605 5 ustar alee alee github-api-0.14.2/lib/github_api/request/verbs.rb 0000644 0001750 0001750 00000003062 12735456050 020254 0 ustar alee alee # encoding: utf-8
module Github
# A class responsible for dispatching http requests
class Request
# Defines HTTP verbs
module Verbs
# Make a head request
#
# @api public
def head_request(path, params = ParamsHash.empty)
Request.new(:head, path, self).call(current_options, params)
end
# Make a get request
#
# @api public
def get_request(path, params = ParamsHash.empty)
request = Request.new(:get, path, self).call(current_options, params)
request.auto_paginate
end
# Make a patch request
#
# @api public
def patch_request(path, params = ParamsHash.empty)
Request.new(:patch, path, self).call(current_options, params)
end
# Make a post request
#
# @api public
def post_request(path, params = ParamsHash.empty)
Request.new(:post, path, self).call(current_options, params)
end
# Make a put request
#
# @api public
def put_request(path, params = ParamsHash.empty)
Request.new(:put, path, self).call(current_options, params)
end
# Make a delete request
#
# @api public
def delete_request(path, params = ParamsHash.empty)
Request.new(:delete, path, self).call(current_options, params)
end
# Make a options request
#
# @api public
def options_request(path, params = ParamsHash.empty)
Request.new(:options, path, self).call(current_options, params)
end
end # Verbs
end # Request
end # Github
github-api-0.14.2/lib/github_api/request/oauth2.rb 0000644 0001750 0001750 00000001640 12735456050 020335 0 ustar alee alee # encoding: utf-8
require 'faraday'
module Github
class Request
class OAuth2 < Faraday::Middleware
include Github::Utils::Url
ACCESS_TOKEN = 'access_token'.freeze
AUTH_HEADER = 'Authorization'.freeze
dependency 'oauth2'
def call(env)
# Extract parameters from the query
params = { ACCESS_TOKEN => @token }.update query_params(env[:url])
if token = params[ACCESS_TOKEN] and !token.empty?
env[:url].query = build_query params
env[:request_headers].merge!(AUTH_HEADER => "token #{token}")
end
@app.call env
end
def initialize(app, *args)
super app
@app = app
@token = args.shift
end
def query_params(url)
if url.query.nil? or url.query.empty?
{}
else
parse_query url.query
end
end
end # OAuth2
end # Request
end # Github
github-api-0.14.2/lib/github_api/request/jsonize.rb 0000644 0001750 0001750 00000002524 12735456050 020616 0 ustar alee alee # encoding: utf-8
require 'faraday'
module Github
class Request::Jsonize < Faraday::Middleware
CONTENT_TYPE = 'Content-Type'.freeze
MIME_TYPE = 'application/json'.freeze
dependency 'multi_json'
def call(env)
if request_with_body?(env)
env[:request_headers][CONTENT_TYPE] ||= MIME_TYPE
env[:body] = encode_body env[:body] unless env[:body].respond_to?(:to_str)
elsif safe_to_modify?(env)
# Ensure valid body for put and post requests
if [:put, :patch, :post].include?(env[:method])
env[:body] = encode_body({})
end
end
@app.call env
end
def encode_body(value)
if MultiJson.respond_to?(:dump)
MultiJson.dump(value)
else
MultiJson.encode(value)
end
end
def request_with_body?(env)
type = request_type(env)
has_body?(env) and safe_to_modify?(env)
end
def safe_to_modify?(env)
type = request_type(env)
type.empty? or type == MIME_TYPE
end
# Don't encode bodies in string form
def has_body?(env)
body = env[:body] and !(body.respond_to?(:to_str) and body.empty?)
end
def request_type(env)
type = env[:request_headers][CONTENT_TYPE].to_s
type = type.split(';', 2).first if type.index(';')
type
end
end # Request::Jsonize
end # Github
github-api-0.14.2/lib/github_api/request/basic_auth.rb 0000644 0001750 0001750 00000001425 12735456050 021236 0 ustar alee alee # encoding: utf-8
require 'faraday'
require 'base64'
module Github
class Request
class BasicAuth < Faraday::Middleware
dependency 'base64'
# @api private
def initialize(app, *args)
@app = app
@auth = nil
options = args.extract_options!
if options.key?(:login) && !options[:login].nil?
credentials = "#{options[:login]}:#{options[:password]}"
@auth = Base64.encode64(credentials)
@auth.gsub!("\n", "")
end
end
# Update request headers
#
# @api private
def call(env)
if @auth
env[:request_headers].merge!('Authorization' => "Basic #{@auth}\"")
end
@app.call(env)
end
end # BasicAuth
end # Request
end # Github
github-api-0.14.2/lib/github_api/connection.rb 0000644 0001750 0001750 00000003764 12735456050 017613 0 ustar alee alee # encoding: utf-8
module Github
# Specifies Http connection options
module Connection
extend self
include Github::Constants
ALLOWED_OPTIONS = [
:headers,
:url,
:params,
:request,
:ssl
].freeze
# Default requets header information
#
# @return [Hash[String]]
#
# @api private
def default_headers
{
ACCEPT => 'application/vnd.github.v3+json,' \
'application/vnd.github.beta+json;q=0.5,' \
'application/json;q=0.1',
ACCEPT_CHARSET => 'utf-8'
}
end
# Create default connection options
#
# @return [Hash[Symbol]]
# the default options
#
# @api private
def default_options(options = {})
headers = default_headers.merge(options[:headers] || {})
headers.merge!({USER_AGENT => options[:user_agent]})
{
headers: headers,
ssl: options[:ssl],
url: options[:endpoint]
}
end
# Exposes middleware builder to facilitate custom stacks and easy
# addition of new extensions such as cache adapter.
#
# @api public
def stack(options = {})
@stack ||= begin
builder_class = if defined?(Faraday::RackBuilder)
Faraday::RackBuilder
else
Faraday::Builder
end
builder_class.new(&Github.default_middleware(options))
end
end
# Creates http connection
#
# Returns a Fraday::Connection object
def connection(api, options = {})
connection_options = default_options(options)
connection_options.merge!(builder: stack(options.merge!(api: api)))
if options[:connection_options]
connection_options.deep_merge!(options[:connection_options])
end
if ENV['DEBUG']
p "Connection options : \n"
pp connection_options
end
Faraday.new(connection_options)
end
end # Connection
end # Github
github-api-0.14.2/lib/github_api/ext/ 0000755 0001750 0001750 00000000000 12735456050 015715 5 ustar alee alee github-api-0.14.2/lib/github_api/ext/faraday.rb 0000644 0001750 0001750 00000001750 12735456050 017654 0 ustar alee alee # encoding: utf-8
module Faraday
module Utils
class ParamsHash
def params_encoder(encoder = nil)
if encoder
@encoder = encoder
else
@encoder
end
end
def to_query(encoder = nil)
Utils.build_nested_query(self, nil, params_encoder)
end
end
def build_nested_query(value, prefix = nil, encoder = nil)
case value
when Array
value.map { |v| build_nested_query(v, "#{prefix}%5B%5D", encoder) }.join("&")
when Hash
value.map { |k, v|
processed_value = encoder ? encoder.escape(k) : escape(k)
build_nested_query(v, prefix ? "#{prefix}%5B#{processed_value}%5D" : processed_value, encoder)
}.join("&")
when NilClass
prefix
else
raise ArgumentError, "value must be a Hash" if prefix.nil?
processed_value = encoder ? encoder.escape(value) : escape(value)
"#{prefix}=#{processed_value}"
end
end
end
end
github-api-0.14.2/lib/github_api/page_iterator.rb 0000644 0001750 0001750 00000006514 12735456050 020275 0 ustar alee alee # encoding: utf-8
require 'github_api/utils/url'
require 'uri'
module Github
# A class responsible for requesting resources through page links
#
# @api private
class PageIterator
include Github::Constants
include Github::Utils::Url
include Github::PagedRequest
# Setup attribute accesor for all the link types
ATTRIBUTES = [META_FIRST, META_NEXT, META_PREV, META_LAST]
DEFAULT_SHA = 'master'
ATTRIBUTES.each do |attr|
attr_accessor :"#{attr}_page_uri", :"#{attr}_page"
end
attr_reader :current_api
def initialize(links, current_api)
@links = links
@current_api = current_api
update_page_links(@links)
end
def next?
next_page == 0 || !next_page_uri.nil?
end
def count
parse_query(URI(last_page_uri).query)['page'] if last_page_uri
end
# Perform http get request for the first resource
#
def first
perform_request(first_page_uri) if first_page_uri
end
# Perform http get request for the next resource
#
def next
perform_request(next_page_uri) if next?
end
# Perform http get request for the previous resource
#
def prev
perform_request(prev_page_uri) if prev_page_uri
end
# Perform http get request for the last resource
#
def last
perform_request(last_page_uri) if last_page_uri
end
# Returns the result for a specific page.
#
def get_page(page_number)
# Find URI that we can work with, if we cannot get the first or the
# last page URI then there is only one page.
page_uri = first_page_uri || last_page_uri
return nil unless page_uri
perform_request(page_uri, page_number)
end
private
def perform_request(page_uri_path, page_number = nil)
page_uri = URI(page_uri_path)
params = parse_query(page_uri.query)
if page_number
params['page'] = page_number
elsif next_page < 1
sha = sha(params)
params['sha'] = sha if sha
else
params['page'] = parse_page_number(page_uri_path)
end
params['per_page'] = parse_per_page_number(page_uri_path)
response = page_request(page_uri.path, params)
update_page_links response.links
response
end
def sha(params)
return params['last_sha'] if params.keys.include?('last_sha')
return DEFAULT_SHA if params.keys.include?('sha')
end
def parse_per_page_number(uri) # :nodoc:
parse_page_params(uri, PARAM_PER_PAGE)
end
def parse_page_number(uri) # :nodoc:
parse_page_params(uri, PARAM_PAGE)
end
# Extracts query string parameter for given name
def parse_page_params(uri, attr) # :nodoc:
return -1 if uri.nil? || uri.empty?
parsed = nil
begin
parsed = URI.parse(uri)
rescue URI::Error
return -1
end
param = parse_query_for_param(parsed.query, attr)
return -1 if param.nil? || param.empty?
begin
return param.to_i
rescue ArgumentError
return -1
end
end
# Wholesale update of all link attributes
def update_page_links(links) # :nodoc:
ATTRIBUTES.each do |attr|
send(:"#{attr}_page_uri=", links.send(:"#{attr}"))
send(:"#{attr}_page=", parse_page_number(links.send(:"#{attr}")))
end
end
end # PageIterator
end # Github
github-api-0.14.2/lib/github_api/utils/ 0000755 0001750 0001750 00000000000 12735456050 016255 5 ustar alee alee github-api-0.14.2/lib/github_api/utils/url.rb 0000644 0001750 0001750 00000002655 12735456050 017414 0 ustar alee alee require 'cgi'
require 'addressable/uri'
module Github
module Utils
module Url
extend self
DEFAULT_QUERY_SEP = /[&;] */n
KEY_VALUE_SEP = '='.freeze
def escape_uri(s) Addressable::URI.escape(s.to_s) end
def escape(s) CGI.escape(s.to_s) end
def unescape(s) CGI.unescape(s.to_s) end
def normalize(s) Addressable::URI.parse(s.to_s).normalize.path end
def build_query(params)
params.map { |k, v|
if v.class == Array
build_query(v.map { |x| [k, x] })
else
v.nil? ? escape(k) : "#{escape(k)}=#{escape(v)}"
end
}.join("&")
end
def parse_query(query_string)
return '' if query_string.nil? || query_string.empty?
params = {}
query_string.split(DEFAULT_QUERY_SEP).each do |part|
k, v = part.split(KEY_VALUE_SEP, 2).map { |el| unescape(el) }
if cur = params[k]
if cur.class == Array
params[k] << v
else
params[k] = [cur, v]
end
else
params[k] = v
end
end
params
end
def parse_query_for_param(query_string, name)
parse_query(query_string).each do |key, val|
return val.first if (name == key) && val.is_a?(Array)
return val if (name == key)
end
return nil
end
end # Url
end # Utils
end # Github
github-api-0.14.2/lib/github_api/request.rb 0000644 0001750 0001750 00000004470 12735456050 017137 0 ustar alee alee # encoding: utf-8
require 'github_api/request/oauth2'
require 'github_api/request/basic_auth'
require 'github_api/request/jsonize'
require 'github_api/connection'
module Github
# A class responsible for dispatching http requests
class Request
include Connection
HTTP_METHODS = [:get, :head, :post, :put, :delete, :patch]
METHODS_WITH_BODIES = [:post, :put, :patch]
# Return http verb
#
# @return [Symbol]
attr_reader :action
# Return url
#
# @return [String]
attr_accessor :path
# Return api this request is associated with
#
# @return [Github::API]
attr_reader :api
# Create a new Request
#
# @return [Github::Request]
#
# @api public
def initialize(action, path, api)
@action = action
@path = path
@api = api
end
# Performs a request
#
# @param [Symbol] method - The Symbol the HTTP verb
# @param [String] path - String relative URL to access
# @param [ParamsHash] params - ParamsHash to configure the request API
#
# @return [Github::ResponseWrapper]
#
# @api private
def call(current_options, params)
unless HTTP_METHODS.include?(action)
raise ArgumentError, "unknown http method: #{method}"
end
puts "EXECUTED: #{action} - #{path} with PARAMS: #{params}" if ENV['DEBUG']
request_options = params.options
connection_options = current_options.merge(request_options)
conn = connection(api, connection_options)
self.path = Utils::Url.normalize(self.path)
if conn.path_prefix != '/' && self.path.index(conn.path_prefix) != 0
self.path = (conn.path_prefix + self.path).gsub(/\/(\/)*/, '/')
end
response = conn.send(action) do |request|
case action.to_sym
when *(HTTP_METHODS - METHODS_WITH_BODIES)
request.body = params.data if params.key?('data')
if params.key?('encoder')
request.params.params_encoder(params.encoder)
end
request.url(self.path, params.request_params)
when *METHODS_WITH_BODIES
request.url(self.path, connection_options[:query] || {})
request.body = params.data unless params.empty?
end
end
ResponseWrapper.new(response, api)
end
end # Request
end # Github
github-api-0.14.2/lib/github_api/rate_limit.rb 0000644 0001750 0001750 00000000715 12735456050 017576 0 ustar alee alee # encoding: utf-8
module Github
module RateLimit
def ratelimit(*args)
arguments(args)
get_request("/rate_limit", arguments.params).rate.limit
end
def ratelimit_remaining(*args)
arguments(args)
get_request("/rate_limit", arguments.params).rate.remaining
end
def ratelimit_reset(*args)
arguments(args)
get_request("/rate_limit", arguments.params).rate.reset
end
end # RateLimit
end # Github
github-api-0.14.2/lib/github_api/api/ 0000755 0001750 0001750 00000000000 12735456050 015666 5 ustar alee alee github-api-0.14.2/lib/github_api/api/arguments.rb 0000644 0001750 0001750 00000014353 12735456050 020226 0 ustar alee alee # encoding: utf-8
module Github
class API
# A class responsible for handilng request arguments
class Arguments
include Normalizer
include ParameterFilter
include Validations
AUTO_PAGINATION = 'auto_pagination'.freeze
# Parameters passed to request
attr_reader :params
# The remaining unparsed arguments
attr_reader :remaining
# The request api
attr_reader :api
# Initialize an Arguments
#
# @param [Hash] options
#
# @option options [Array[String]] :required
# arguments that must be present before request is fired
#
# @option options [Github::API] :api
# the reference to the current api
#
# @api public
def initialize(options = {}, &block)
normalize! options
@api = options.fetch('api')
@required = options.fetch('required', []).map(&:to_s)
@optional = options.fetch('optional', []).map(&:to_s)
@assigns = {}
yield_or_eval(&block)
end
# Specify required attribute(s)
#
# @api public
def require(*attrs, &block)
attrs_clone = attrs.clone
@required = Array(attrs_clone)
self
end
alias :required :require
# Specify optional attribute(s)
#
# @api public
def optional(*attrs, &block)
end
# Hash like access to request arguments
#
# @param [String, Symbol] property
# the property name
#
# @api public
def [](property)
@assigns[property.to_s]
end
def []=(property, value)
@assigns[property.to_s] = value
end
def method_missing(method_name, *args, &block)
if @assigns.key?(method_name.to_s)
self[method_name]
else
super
end
end
def respond_to_missing?(method_name, include_private = false)
@assigns.key?(method_name) || super
end
# Parse arguments to allow for flexible api calls
#
# Arguments can be part of parameters hash or be simple string arguments.
#
# @api public
def parse(*args, &block)
options = ParamsHash.new(args.extract_options!)
normalize! options
if args.size.zero? # Arguments are inside the parameters hash
parse_hash(options)
else
parse_array(*args)
end
@params = options
@remaining = args[@required.size..-1]
extract_pagination(options)
yield_or_eval(&block)
self
end
# Remove unknown keys from parameters hash.
#
# = Parameters
# :recursive - boolean that toggles whether nested filtering should be applied
#
def permit(keys, key=nil, options={})
filter! keys, (key.nil? ? params : params[key]), options if keys.any?
self
end
# Check if required keys are present inside parameters hash.
#
# @api public
def assert_required(*required)
assert_required_keys(required, params)
self
end
# Check if parameters match expected values.
#
# @api public
def assert_values(values, key=nil)
assert_valid_values values, (key.nil? ? params : params[key])
self
end
private
# Parse array arguments and assign in order to required properties
#
# @param [Array[Object]] args
#
# @raise ArgumentError
#
# @return [nil]
#
# @api public
def parse_array(*args)
assert_presence_of(*args)
@required.each_with_index do |req, indx|
@assigns[req] = args[indx]
end
check_requirement!(*args)
end
# Remove required arguments from parameters and
# validate their presence(if not nil or empty string).
#
# @param [Hash[String]] options
#
# @return [nil]
#
# @api private
def parse_hash(options)
options.each { |key, val| remove_required(options, key, val) }
hash = update_required_from_global
check_requirement!(*hash.keys)
end
# Remove required property from hash
#
# @param [Hash[String]] options
# the options to check
#
# @param [String] key
# the key to remove
#
# @param [String] val
# the value to assign
#
# @api private
def remove_required(options, key, val)
if @required.include?(key.to_s)
assert_presence_of(val)
options.delete(key)
@assigns[key.to_s] = val
end
end
# Update required property from globals if not present
#
# @return [Hash[String]]
#
# @api private
def update_required_from_global
@required.reduce({}) do |hash, property|
if @assigns.key?(property)
hash[property] = self[property]
elsif api_property?(property)
hash[property] = api.send(:"#{property}")
self[property] = hash[property]
end
hash
end
end
# Check if api has non-empty property
#
# @param [String] property
# the property to check
#
# @return [Boolean]
#
# @api private
def api_property?(property)
api.respond_to?(:"#{property}") && api.send(:"#{property}")
end
# Check if required arguments are present.
#
#
def check_requirement!(*args)
args_length = args.length
required_length = @required.length
if args_length < required_length
raise ArgumentError, "Wrong number of arguments " \
"(#{args_length} for #{required_length}). " \
"Expected `#{@required.join(', ')}` as required arguments, " \
"but got `#{args.join(", ")}`."
end
end
# Find auto_pagination parameter in options hash
#
def extract_pagination(options)
if (value = options.delete(AUTO_PAGINATION))
api.auto_pagination = value
end
end
# Evaluate a block
#
# @api privte
def yield_or_eval(&block)
return unless block
block.arity > 0 ? yield(self) : instance_eval(&block)
end
end # Arguments
end # Api
end # Github
github-api-0.14.2/lib/github_api/api/factory.rb 0000644 0001750 0001750 00000001466 12735456050 017671 0 ustar alee alee # encoding: utf-8
require 'github_api/core_ext/hash'
module Github
class API
class Factory
# Instantiates a new github api object
#
def self.new(klass, options={}, &block)
return create_instance(klass, options, &block) if klass
raise ArgumentError, 'must provide API class to be instantiated'
end
# Passes configuration options to instantiated class
#
def self.create_instance(klass, options, &block)
options.symbolize_keys!
convert_to_constant(klass.to_s).new options, &block
end
# Convert name to constant
#
def self.convert_to_constant(classes)
classes.split('::').inject(Github) do |constant, klass|
constant.const_get klass
end
end
end # Factory
end # Api
end # Github
github-api-0.14.2/lib/github_api/api/config/ 0000755 0001750 0001750 00000000000 12735456050 017133 5 ustar alee alee github-api-0.14.2/lib/github_api/api/config/property_set.rb 0000644 0001750 0001750 00000005527 12735456050 022230 0 ustar alee alee # encoding: utf-8
require 'set'
module Github
class API
class Config
# Class responsible for storing configuration properties
class PropertySet
include Enumerable
attr_reader :parent
attr_reader :properties
# Initialize an PropertySet
#
# @param [Object] parent
# @param [Set] properties
#
# @return [undefined]
#
# @api private
def initialize(parent = nil, properties = Set.new)
@parent = parent
@properties = properties
@map = {}
end
# Iterate over properties
#
# @yield [property]
#
# @yieldparam [Property] property
#
# @return [self]
#
# @api public
def each
return to_enum unless block_given?
@map.each { |name, property| yield property if name.is_a?(Symbol) }
self
end
# Adds property to the set
#
# @example
# properties_set << property
#
# @param [Property] property
#
# @return [self]
#
# @api public
def <<(property)
properties << property
update_map(property.name, property.default)
property.define_accessor_methods(self)
self
end
# Access property by name
#
# @api public
def [](name)
@map[name]
end
alias_method :fetch, :[]
# Set property value by name
#
# @api public
def []=(name, property)
update_map(name, property)
end
# Update map with index
#
# @api private
def update_map(name, property)
@map[name.to_sym] = @map[name.to_s.freeze] = property
end
# Convert properties to a hash of property names and
# corresponding values
#
# @api public
def to_hash
properties.each_with_object({}) do |property, props|
name = property.name
props[name] = self[name]
end
end
# Check if properties exist
#
# @api public
def empty?
@map.empty?
end
# @api private
def define_reader_method(property, method_name, visibility)
property_set = self
parent.send(:define_method, method_name) { property_set[property.name] }
parent.send(visibility, method_name)
end
# @api private
def define_writer_method(property, method_name, visibility)
property_set = self
parent.send(:define_method, method_name) do |value|
property_set[property.name]= value
end
parent.send(visibility, method_name)
end
end # PropertySet
end # Config
end # Api
end # Github
github-api-0.14.2/lib/github_api/api/config/property.rb 0000644 0001750 0001750 00000001341 12735456050 021343 0 ustar alee alee # encoding: utf-8
module Github
class API
class Config
# Property objects provide an interface for configuration options
class Property
attr_reader :name
attr_reader :default
attr_reader :required
def initialize(name, options)
@name = name
@default = options.fetch(:default, nil)
@required = options.fetch(:required, nil)
@options = options
end
# @api private
def define_accessor_methods(properties)
properties.define_reader_method(self, self.name, :public)
properties.define_writer_method(self, "#{self.name}=", :public)
end
end # Property
end # Config
end # Api
end # Github
github-api-0.14.2/lib/github_api/api/actions.rb 0000644 0001750 0001750 00000003064 12735456050 017656 0 ustar alee alee # encoding: utf-8
module Github
# Responsible for providing inspection of api methods
class API
# Returns all API public methods for a given class.
#
# @return [nil]
#
# @api public
def self.extend_with_actions(child_class)
return unless child_class.is_a?(Class)
return if child_class.name.nil? # Skip anonymous classes
child_class.class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
def self.actions
self.new.actions
end
def actions
api_methods_in(#{child_class}) + module_methods_in(#{child_class})
end
RUBY_EVAL
end
# Finds api methods in a class
#
# @param [Class] klass
# The klass to inspect for methods.
#
# @api private
def api_methods_in(klass)
methods = klass.send(:instance_methods, false) - [:actions]
methods.sort.each_with_object([]) do |method_name, accumulator|
unless method_name.to_s.include?('with') ||
method_name.to_s.include?('without')
accumulator << method_name
end
accumulator
end
end
# Finds methods included through class modules
#
# @param [Class] klass
# The klass to inspect for methods.
#
# @api private
def module_methods_in(klass)
klass.included_modules.each_with_object([]) do |mod, accumulator|
if mod.to_s =~ /#{klass}/
mod.instance_methods(false).each do |method|
accumulator << method
end
end
accumulator
end
end
end # API
end # Github
github-api-0.14.2/lib/github_api/api/config.rb 0000644 0001750 0001750 00000004646 12735456050 017472 0 ustar alee alee # encoding: utf-8
require 'github_api/api/config/property'
require 'github_api/api/config/property_set'
module Github
class API
# A base class for constructing api configuration
class Config
# Defines a property on an object's class or instance
#
# @example
# class Configuration < Api::Config
# property :adapter, default: :net_http
# property :user, required: true
# end
#
# @param [Symbol] name
# the name of a property
#
# @param [#to_hash] options
# the extra options
#
# @return [self]
#
# @api public
def self.property(name, options = {})
self.property_set << Property.new(name, options)
update_subclasses(name, options)
self
end
def self.update_subclasses(name, options)
if defined?(@subclasses) && @subclasses
@subclasses.each { |klass| klass.property(name, options) }
end
end
# Check if property is defined
#
# @param [Symbol] name
# the name to check
#
# @return [Boolean]
#
# @api public
def self.property?(name)
property_set.include?(name)
end
class << self
attr_reader :property_set
end
instance_variable_set("@property_set", PropertySet.new(self))
def self.inherited(descendant)
super
(@subclasses ||= Set.new) << descendant
descendant.instance_variable_set('@property_set',
PropertySet.new(descendant, self.property_set.properties.dup))
end
def initialize(&block)
super(&block)
end
def property_names
self.class.property_set.properties.map(&:name)
end
def self.property_names
property_set.properties.map(&:name)
end
# Fetach all the properties and their values
#
# @return [Hash[Symbol]]
#
# @api public
def fetch(value = nil)
if value
self.class.property_set[value]
else
self.class.property_set.to_hash
end
end
# Provide access to properties
#
# @example
# config.call do |config|
# config.adapter = :net_http
# end
#
# @return [self]
#
# @api private
def call(&block)
block.call(self) if block_given?
self
end
end # Config
end # Api
end # Github
github-api-0.14.2/lib/github_api/error/ 0000755 0001750 0001750 00000000000 12735456050 016246 5 ustar alee alee github-api-0.14.2/lib/github_api/error/not_found.rb 0000644 0001750 0001750 00000000410 12735456050 020561 0 ustar alee alee # encoding: utf-8
module Github #:nodoc
# Raised when Github returns the HTTP status code 404
module Error
class NotFound < ServiceError
http_status_code 404
def initialize(env)
super(env)
end
end
end # Error
end # Github
github-api-0.14.2/lib/github_api/error/unauthorized.rb 0000644 0001750 0001750 00000000446 12735456050 021320 0 ustar alee alee # encoding: utf-8
module Github #:nodoc
# Raised when Github returns the HTTP status code 401
module Error
class Unauthorized < ServiceError
http_status_code 401
def initialize(response)
super(response)
end
end # Unauthorized
end # Error
end # Github
github-api-0.14.2/lib/github_api/error/service_error.rb 0000644 0001750 0001750 00000002702 12735456050 021445 0 ustar alee alee # encoding: utf-8
require 'json'
module Github
# Raised when GitHub returns any of the HTTP status codes
module Error
class ServiceError < GithubError
attr_reader :http_headers, :body, :status
MIN_BODY_LENGTH = 2
def initialize(response)
@http_headers = response[:response_headers]
@body = parse_body(response[:body])
@status = response[:status]
super(create_message(response))
end
def create_message(response)
"#{response[:method].to_s.upcase} #{response[:url]}: #{@status} #{@body}"
end
def decode_body(body)
if body.respond_to?(:to_str) && body.length >= MIN_BODY_LENGTH
JSON.parse(body, symbolize_names: true)
else
body
end
end
def parse_body(body)
body = decode_body(body)
return '' if body.nil? || body.empty?
if body[:error]
body[:error]
elsif body[:errors]
error = Array(body[:errors]).first
error.is_a?(Hash) ? error[:message] : error
elsif body[:message]
body[:message]
else
''
end
end
def self.http_status_code(code)
define_method(:http_status_code) { code }
end
def self.errors
@errors ||= Hash[
descendants.map { |klass| [klass.new({}).http_status_code, klass] }
]
end
end # ServiceError
end # Error
end # Github
github-api-0.14.2/lib/github_api/error/internal_server_error.rb 0000644 0001750 0001750 00000000464 12735456050 023212 0 ustar alee alee # encoding: utf-8
module Github #:nodoc
# Raised when Github returns the HTTP status code 500
module Error
class InternalServerError < ServiceError
http_status_code 500
def initialize(response)
super(response)
end
end # InternalServerError
end # Error
end # Github
github-api-0.14.2/lib/github_api/error/client_error.rb 0000644 0001750 0001750 00000001112 12735456050 021255 0 ustar alee alee # encoding: utf-8
module Github #:nodoc
# Raised when Github returns the HTTP status code 404
module Error
class ClientError < GithubError
attr_reader :problem, :summary, :resolution
def initialize(message)
super(message)
end
def generate_message(attributes)
@problem = attributes[:problem]
@summary = attributes[:summary]
@resolution = attributes[:resolution]
"\nProblem:\n #{@problem}"+
"\nSummary:\n #{@summary}"+
"\nResolution:\n #{@resolution}"
end
end
end # Error
end # Github
github-api-0.14.2/lib/github_api/error/not_acceptable.rb 0000644 0001750 0001750 00000000450 12735456050 021535 0 ustar alee alee # encoding: utf-8
module Github #:nodoc
# Raised when GitHub returns the HTTP status code 406
module Error
class NotAcceptable < ServiceError
http_status_code 406
def initialize(response)
super(response)
end
end # NotAcceptable
end # Error
end # Github
github-api-0.14.2/lib/github_api/error/unknown_value.rb 0000644 0001750 0001750 00000001230 12735456050 021462 0 ustar alee alee # encoding: utf-8
module Github #:nodoc
# Raised when invalid options are passed to a request body
module Error
class UnknownValue < ClientError
def initialize(key, value, permitted)
super(
generate_message(
:problem => "Wrong value of '#{value}' for the parameter: #{key} provided for this request.",
:summary => "Github gem checks the request parameters passed to ensure that github api is not hit unnecessairly and fails fast.",
:resolution => "Permitted values are: #{permitted}, make sure these are the ones you are using"
)
)
end
end
end # Error
end # Github
github-api-0.14.2/lib/github_api/error/forbidden.rb 0000644 0001750 0001750 00000000423 12735456050 020526 0 ustar alee alee # encoding: utf-8
module Github #:nodoc
# Raised when Github returns the HTTP status code 403
module Error
class Forbidden < ServiceError
http_status_code 403
def initialize(response)
super(response)
end
end
end # Error
end # Github
github-api-0.14.2/lib/github_api/error/validations.rb 0000644 0001750 0001750 00000001155 12735456050 021112 0 ustar alee alee # encoding: utf-8
module Github #:nodoc
# Raised when passed parameters are missing or contain wrong values.
module Error
class Validations < ClientError
def initialize(errors)
super(
generate_message(
:problem => "Attempted to send request with nil arguments for #{errors.keys.join(', ')}.",
:summary => 'Each request expects certain number of required arguments.',
:resolution => 'Double check that the provided arguments are set to some value that is neither nil nor empty string.'
)
)
end
end
end # Error
end # Github
github-api-0.14.2/lib/github_api/error/unknown_media.rb 0000644 0001750 0001750 00000001130 12735456050 021424 0 ustar alee alee # encoding: utf-8
module Github #:nodoc
# Raised when invalid options are passed to a request body
module Error
class UnknownMedia < ClientError
def initialize(file)
super(
generate_message(
:problem => "Unknown content type for: '#{file}' provided for this request.",
:summary => "Github gem infers the content type of the resource by calling the mime-types gem type inference.",
:resolution => "Please install mime-types gem to infer the resource content type."
)
)
end
end
end # Error
end # Github
github-api-0.14.2/lib/github_api/error/bad_request.rb 0000644 0001750 0001750 00000000406 12735456050 021071 0 ustar alee alee # encoding: utf-8
module Github
module Error
# Raised when Github returns the HTTP status code 400
class BadRequest < ServiceError
http_status_code 400
def initialize(response)
super(response)
end
end
end
end # Github
github-api-0.14.2/lib/github_api/error/required_params.rb 0000644 0001750 0001750 00000001253 12735456050 021757 0 ustar alee alee # encoding: utf-8
module Github #:nodoc
# Raised when invalid options are passed to a request body
module Error
class RequiredParams < ClientError
def initialize(provided, required)
super(
generate_message(
:problem => "Missing required parameters: #{provided.keys.join(', ')} provided for this request.",
:summary => "Github gem checks the request parameters passed to ensure that github api is not hit unnecessairly and to fail fast.",
:resolution => "Required parameters are: #{required.join(', ')}, make sure these are the ones you are using"
)
)
end
end
end # Error
end # Github
github-api-0.14.2/lib/github_api/error/unprocessable_entity.rb 0000644 0001750 0001750 00000000435 12735456050 023036 0 ustar alee alee # encoding: utf-8
module Github #:nodoc
# Raised when Github returns the HTTP status code 422
module Error
class UnprocessableEntity < ServiceError
http_status_code 422
def initialize(response)
super(response)
end
end
end # Error
end # Github
github-api-0.14.2/lib/github_api/error/invalid_options.rb 0000644 0001750 0001750 00000001220 12735456050 021767 0 ustar alee alee # encoding: utf-8
module Github #:nodoc
# Raised when invalid options are passed to a request body
module Error
class InvalidOptions < ClientError
def initialize(invalid, valid)
super(
generate_message(
:problem => "Invalid option #{invalid.keys.join(', ')} provided for this request.",
:summary => "Github gem checks the request parameters passed to ensure that github api is not hit unnecessairly and to fail fast.",
:resolution => "Valid options are: #{valid.join(', ')}, make sure these are the ones you are using"
)
)
end
end
end # Error
end # Github
github-api-0.14.2/lib/github_api/error/service_unavailable.rb 0000644 0001750 0001750 00000000462 12735456050 022600 0 ustar alee alee # encoding: utf-8
module Github #:nodoc
# Raised when Github returns the HTTP status code 503
module Error
class ServiceUnavailable < ServiceError
http_status_code 503
def initialize(response)
super(response)
end
end # ServiceUnavailable
end # Error
end # Github
github-api-0.14.2/lib/github_api/params_hash.rb 0000644 0001750 0001750 00000004564 12735456050 017741 0 ustar alee alee # encoding: utf-8
require 'delegate'
require 'base64'
module Github
# Class responsible for holding request parameters
class ParamsHash < DelegateClass(Hash)
include Normalizer
include MimeType
REQUEST_PARAMS = [:accept, :media, :data, :raw, :content_type, :headers]
def initialize(hash)
super(normalize!(Hash[hash]))
end
# Create empty hash
#
# @api public
def self.empty
new({})
end
# Extract and parse media type param
#
# [.version].param[+json]
#
# @api public
def media
parse(delete('media'))
end
# Get accept header
#
# @api public
def accept
if key?('accept') then self['accept']
elsif key?('media') then media
else nil
end
end
# Extract request data from parameters
#
# @api public
def data
if key?('data') && !self['data'].nil?
self['data']
else
request_params
end
end
def encoder
if key?('encoder') && self['encoder']
self['encoder']
else
{}
end
end
# Configuration options from request
#
# @return [Hash]
#
# @api public
def options
opts = fetch('options', {})
headers = fetch('headers', {})
if value = accept
headers[:accept] = value
end
if self['content_type']
headers[:content_type] = self['content_type']
end
opts[:raw] = key?('raw') ? self['raw'] : false
opts[:headers] = headers unless headers.empty?
opts
end
# Update hash with default parameters for non existing keys
#
def merge_default(defaults)
if defaults && !defaults.empty?
defaults.each do |key, value|
self[key] = value unless self.key?(key)
end
end
self
end
# Base64 encode string removing newline characters
#
# @api public
def strict_encode64(key)
value = self[key]
encoded = if Base64.respond_to?(:strict_encode64)
Base64.strict_encode64(value)
else
[value].pack('m0')
end
self[key] = encoded.delete("\n\r")
end
# Filter out request params
#
# @api public
def request_params
to_hash.select do |key, value|
!REQUEST_PARAMS.include?(key.to_sym)
end
end
end # ParamsHash
end # Github
github-api-0.14.2/lib/github_api/authorization.rb 0000644 0001750 0001750 00000004145 12735456050 020346 0 ustar alee alee # encoding: utf-8
module Github
module Authorization
# Setup OAuth2 instance
def client
@client ||= ::OAuth2::Client.new(client_id, client_secret,
{
:site => current_options.fetch(:site) { Github.site },
:authorize_url => 'login/oauth/authorize',
:token_url => 'login/oauth/access_token',
:ssl => { :verify => false }
}
)
end
# Strategy token
def auth_code
_verify_client
client.auth_code
end
# Sends authorization request to GitHub.
# = Parameters
# * :redirect_uri - Optional string.
# * :scope - Optional string. Comma separated list of scopes.
# Available scopes:
# * (no scope) - public read-only access (includes public user profile info, public repo info, and gists).
# * user - DB read/write access to profile info only.
# * public_repo - DB read/write access, and Git read access to public repos.
# * repo - DB read/write access, and Git read access to public and private repos.
# * gist - write access to gists.
#
def authorize_url(params = {})
_verify_client
client.auth_code.authorize_url(params)
end
# Makes request to token endpoint and retrieves access token value
def get_token(authorization_code, params = {})
_verify_client
client.auth_code.get_token(authorization_code, params)
end
# Check whether authentication credentials are present
def authenticated?
basic_authed? || oauth_token?
end
# Check whether basic authentication credentials are present
def basic_authed?
basic_auth? || (login? && password?)
end
# Select authentication parameters
#
# @api public
def authentication
if basic_authed?
{ login: login, password: password }
else
{}
end
end
private
def _verify_client # :nodoc:
raise ArgumentError, 'Need to provide client_id and client_secret' unless client_id? && client_secret?
end
end # Authorization
end # Github
github-api-0.14.2/lib/github_api/page_links.rb 0000644 0001750 0001750 00000003146 12735456050 017562 0 ustar alee alee module Github
# Determines the links in the current response link header to be used
# to find the links to other pages of request responses. These will
# only be present if the result set size exceeds the per page limit.
#
# @api private
class PageLinks
include Github::Constants
DELIM_LINKS = ','.freeze # :nodoc:
# Hold the extracted values for URI from the Link header
# for the first, last, next and previous page.
attr_accessor :first, :last, :next, :prev
LINK_REGEX = /<([^>]+)>; rel=\"([^\"]+)\"/
# Parses links from executed request
#
# @param [Hash] response_headers
#
# @api private
def initialize(response_headers)
link_header = response_headers[HEADER_LINK]
if link_header && link_header =~ /(next|first|last|prev)/
extract_links(link_header)
else
# When on the first page
self.next = response_headers[HEADER_NEXT]
self.last = response_headers[HEADER_LAST]
end
end
private
def extract_links(link_header)
link_header.split(DELIM_LINKS).each do |link|
LINK_REGEX.match(link.strip) do |match|
url_part, meta_part = match[1], match[2]
next if !url_part || !meta_part
assign_url_part(meta_part, url_part)
end
end
end
def assign_url_part(meta_part, url_part)
case meta_part
when META_FIRST
self.first = url_part
when META_LAST
self.last = url_part
when META_NEXT
self.next = url_part
when META_PREV
self.prev = url_part
end
end
end # PageLinks
end # Github
github-api-0.14.2/lib/github_api/api.rb 0000644 0001750 0001750 00000023020 12735456050 016210 0 ustar alee alee # encoding: utf-8
require 'github_api/configuration'
require 'github_api/mime_type'
require 'github_api/rate_limit'
require 'github_api/core_ext/hash'
require 'github_api/core_ext/array'
require 'github_api/null_encoder'
require 'github_api/request/verbs'
require 'github_api/api/actions'
require 'github_api/api/factory'
require 'github_api/api/arguments'
module Github
# Core class responsible for api interface operations
class API
extend Github::ClassMethods
include Constants
include Authorization
include MimeType
include Request::Verbs
include RateLimit
attr_reader *Github.configuration.property_names
attr_accessor *Validations::VALID_API_KEYS
attr_accessor :current_options
# Callback to update current configuration options
class_eval do
Github.configuration.property_names.each do |key|
define_method "#{key}=" do |arg|
self.instance_variable_set("@#{key}", arg)
self.current_options.merge!({:"#{key}" => arg})
end
end
end
# Create new API
#
# @api public
def initialize(options={}, &block)
opts = Github.configuration.fetch.merge(options)
@current_options = opts
Github.configuration.property_names.each do |key|
send("#{key}=", opts[key])
end
if opts.key?(:login) && !opts[:login].nil?
@login, @password = opts[:login], opts[:password]
elsif opts.key?(:basic_auth) && !opts[:basic_auth].nil?
@login, @password = extract_basic_auth(opts[:basic_auth])
end
yield_or_eval(&block) if block_given?
end
# Call block with argument
#
# @api private
def yield_or_eval(&block)
return unless block
block.arity > 0 ? yield(self) : self.instance_eval(&block)
end
# Extract login and password from basic_auth parameter
#
# @api private
def extract_basic_auth(auth)
case auth
when String
auth.split(':', 2)
when Hash
[auth[:login], auth[:password]]
end
end
# List of before callbacks
#
# @api public
def self.before_callbacks
@before_callbacks ||= []
end
# List of after callbacks
#
# @api public
def self.after_callbacks
@after_callbacks ||= []
end
# Before request filter
#
# @api public
def self.before_request(callback, params = {})
before_callbacks << params.merge(callback: callback)
end
# After request filter
#
# @api public
def self.after_request(callback, params = {})
after_callbacks << params.merge(callback: callback)
end
class << self
attr_reader :root
alias_method :root?, :root
end
def self.root!
@root = true
end
def self.inherited(child_class)
before_callbacks.reverse_each { |callback|
child_class.before_callbacks.unshift(callback)
}
after_callbacks.reverse_each { |callback|
child_class.after_callbacks.unshift(callback)
}
extend_with_actions(child_class)
unless child_class.instance_variable_defined?(:@root)
child_class.instance_variable_set(:@root, false)
end
super
end
root!
def self.internal_methods
api = self
api = api.superclass until api.root?
api.public_instance_methods(true)
end
def self.extra_methods
['actions']
end
# Find all the api methods that should be considred by
# request callbacks.
#
# @return [Set]
#
# @api private
def self.request_methods
@request_methods ||= begin
methods = (public_instance_methods(true) -
internal_methods +
public_instance_methods(false)).uniq.map(&:to_s)
Set.new(methods - extra_methods)
end
end
def self.clear_request_methods!
@request_methods = nil
end
def self.method_added(method_name)
method_name = method_name.to_s.gsub(/_with(out)?_callback_.*$/, '')
# Only subclasses matter
return if self.root?
return if extra_methods.include?(method_name)
# Only public methods are of interest
return unless request_methods.include?(method_name)
# Do not redefine
return if (@__methods_added ||= []).include?(method_name)
class_name = self.name.to_s.split('::').last.downcase
with_method = "#{method_name}_with_callback_#{class_name}"
without_method = "#{method_name}_without_callback_#{class_name}"
return if public_method_defined?(with_method)
[method_name, with_method, without_method].each do |met|
@__methods_added << met
end
return if public_method_defined?(with_method)
define_method(with_method) do |*args, &block|
send(:execute, without_method, *args, &block)
end
alias_method without_method, method_name
alias_method method_name, with_method
clear_request_methods!
end
# Filter callbacks based on kind
#
# @param [Symbol] kind
# one of :before or :after
#
# @return [Array[Hash]]
#
# @api private
def filter_callbacks(kind, action_name)
matched_callbacks = self.class.send("#{kind}_callbacks").select do |callback|
callback[:only].nil? || callback[:only].include?(action_name)
end
end
# Run all callbacks associated with this action
#
# @apram [Symbol] action_name
#
# @api private
def run_callbacks(action_name, &block)
filter_callbacks(:before, action_name).each { |hook| send hook[:callback] }
yield if block_given?
filter_callbacks(:after, action_name).each { |hook| send hook[:callback] }
end
# Execute action
#
# @param [Symbol] action
#
# @api private
def execute(action, *args, &block)
action_name = action.to_s.gsub(/_with(out)?_callback_.*$/, '')
result = nil
run_callbacks(action_name) do
result = send(action, *args, &block)
end
result
end
# Responds to attribute query or attribute clear
#
# @api private
def method_missing(method_name, *args, &block) # :nodoc:
case method_name.to_s
when /^(.*)\?$/
return !!send($1.to_s)
when /^clear_(.*)$/
send("#{$1.to_s}=", nil)
else
super
end
end
# Acts as setter and getter for api requests arguments parsing.
#
# Returns Arguments instance.
#
def arguments(args=(not_set = true), options={}, &block)
if not_set
@arguments
else
@arguments = Arguments.new(options.merge!(api: self)).parse(*args, &block)
end
end
# Set a configuration option for a given namespace
#
# @param [String] option
# @param [Object] value
# @param [Boolean] ignore_setter
#
# @return [self]
#
# @api public
def set(option, value=(not_set=true), ignore_setter=false, &block)
raise ArgumentError, 'value not set' if block and !not_set
return self if !not_set and value.nil?
if not_set
set_options option
return self
end
if respond_to?("#{option}=") and not ignore_setter
return __send__("#{option}=", value)
end
define_accessors option, value
self
end
# Defines a namespace
#
# @param [Array[Symbol]] names
# the name for the scope
#
# @example
# namespace :scopes
#
# @return [self]
#
# @api public
def self.namespace(*names)
options = names.last.is_a?(Hash) ? names.pop : {}
names = names.map(&:to_sym)
name = names.pop
if public_method_defined?(name)
raise ArgumentError, "namespace '#{name}' is already defined"
end
class_name = extract_class_name(name, options)
define_method(name) do |*args, &block|
options = args.last.is_a?(Hash) ? args.pop : {}
API::Factory.new(class_name, current_options.merge(options), &block)
end
end
# Extracts class name from options
#
# @param [Hash] options
# @option options [String] :full_name
# the full name for the class
# @option options [Boolean] :root
# if the class is at the root or not
#
# @example
# extract_class_name(:stats, class_name: :statistics)
#
# @return [String]
#
# @api private
def self.extract_class_name(name, options)
converted = options.fetch(:full_name, name).to_s
converted = converted.split('_').map(&:capitalize).join
class_name = options.fetch(:root, false) ? '': "#{self.name}::"
class_name += converted
class_name
end
private
# Set multiple options
#
# @api private
def set_options(options)
unless options.respond_to?(:each)
raise ArgumentError, 'cannot iterate over value'
end
options.each { |key, value| set(key, value) }
end
# Define setters and getters
#
# @api private
def define_accessors(option, value)
setter = proc { |val| set option, val, true }
getter = proc { value }
define_singleton_method("#{option}=", setter) if setter
define_singleton_method(option, getter) if getter
end
# Dynamically define a method for setting request option
#
# @api private
def define_singleton_method(method_name, content=Proc.new)
(class << self; self; end).class_eval do
undef_method(method_name) if method_defined?(method_name)
if String === content
class_eval("def #{method_name}() #{content}; end")
else
define_method(method_name, &content)
end
end
end
end # API
end # Github
github-api-0.14.2/lib/github_api/validations.rb 0000644 0001750 0001750 00000000612 12735456050 017756 0 ustar alee alee # encoding: utf-8
module Github
module Validations
Github::require_all 'github_api/validations',
'presence',
'token',
'format',
'required'
include Presence
include Format
include Token
include Required
VALID_API_KEYS = [
'page',
'per_page',
'auto_pagination',
'jsonp_callback'
]
end # Validation
end # Github
github-api-0.14.2/lib/github_api/version.rb 0000644 0001750 0001750 00000000103 12735456050 017121 0 ustar alee alee # encoding: utf-8
module Github
VERSION = "0.14.2"
end # Github
github-api-0.14.2/lib/github_api/ssl_certs/ 0000755 0001750 0001750 00000000000 12735456050 017116 5 ustar alee alee github-api-0.14.2/lib/github_api/ssl_certs/cacerts.pem 0000644 0001750 0001750 00000407316 12735456050 021260 0 ustar alee alee # Issuer: CN=GTE CyberTrust Global Root O=GTE Corporation OU=GTE CyberTrust Solutions, Inc.
# Subject: CN=GTE CyberTrust Global Root O=GTE Corporation OU=GTE CyberTrust Solutions, Inc.
# Label: "GTE CyberTrust Global Root"
# Serial: 421
# MD5 Fingerprint: ca:3d:d3:68:f1:03:5c:d0:32:fa:b8:2b:59:e8:5a:db
# SHA1 Fingerprint: 97:81:79:50:d8:1c:96:70:cc:34:d8:09:cf:79:44:31:36:7e:f4:74
# SHA256 Fingerprint: a5:31:25:18:8d:21:10:aa:96:4b:02:c7:b7:c6:da:32:03:17:08:94:e5:fb:71:ff:fb:66:67:d5:e6:81:0a:36
-----BEGIN CERTIFICATE-----
MIICWjCCAcMCAgGlMA0GCSqGSIb3DQEBBAUAMHUxCzAJBgNVBAYTAlVTMRgwFgYD
VQQKEw9HVEUgQ29ycG9yYXRpb24xJzAlBgNVBAsTHkdURSBDeWJlclRydXN0IFNv
bHV0aW9ucywgSW5jLjEjMCEGA1UEAxMaR1RFIEN5YmVyVHJ1c3QgR2xvYmFsIFJv
b3QwHhcNOTgwODEzMDAyOTAwWhcNMTgwODEzMjM1OTAwWjB1MQswCQYDVQQGEwJV
UzEYMBYGA1UEChMPR1RFIENvcnBvcmF0aW9uMScwJQYDVQQLEx5HVEUgQ3liZXJU
cnVzdCBTb2x1dGlvbnMsIEluYy4xIzAhBgNVBAMTGkdURSBDeWJlclRydXN0IEds
b2JhbCBSb290MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCVD6C28FCc6HrH
iM3dFw4usJTQGz0O9pTAipTHBsiQl8i4ZBp6fmw8U+E3KHNgf7KXUwefU/ltWJTS
r41tiGeA5u2ylc9yMcqlHHK6XALnZELn+aks1joNrI1CqiQBOeacPwGFVw1Yh0X4
04Wqk2kmhXBIgD8SFcd5tB8FLztimQIDAQABMA0GCSqGSIb3DQEBBAUAA4GBAG3r
GwnpXtlR22ciYaQqPEh346B8pt5zohQDhT37qw4wxYMWM4ETCJ57NE7fQMh017l9
3PR2VX2bY1QY6fDq81yx2YtCHrnAlU66+tXifPVoYb+O7AWXX1uw16OFNMQkpw0P
lZPvy5TYnh+dXIVtx6quTx8itc2VrbqnzPmrC3p/
-----END CERTIFICATE-----
# Issuer: CN=Thawte Server CA O=Thawte Consulting cc OU=Certification Services Division
# Subject: CN=Thawte Server CA O=Thawte Consulting cc OU=Certification Services Division
# Label: "Thawte Server CA"
# Serial: 1
# MD5 Fingerprint: c5:70:c4:a2:ed:53:78:0c:c8:10:53:81:64:cb:d0:1d
# SHA1 Fingerprint: 23:e5:94:94:51:95:f2:41:48:03:b4:d5:64:d2:a3:a3:f5:d8:8b:8c
# SHA256 Fingerprint: b4:41:0b:73:e2:e6:ea:ca:47:fb:c4:2f:8f:a4:01:8a:f4:38:1d:c5:4c:fa:a8:44:50:46:1e:ed:09:45:4d:e9
-----BEGIN CERTIFICATE-----
MIIDEzCCAnygAwIBAgIBATANBgkqhkiG9w0BAQQFADCBxDELMAkGA1UEBhMCWkEx
FTATBgNVBAgTDFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMR0wGwYD
VQQKExRUaGF3dGUgQ29uc3VsdGluZyBjYzEoMCYGA1UECxMfQ2VydGlmaWNhdGlv
biBTZXJ2aWNlcyBEaXZpc2lvbjEZMBcGA1UEAxMQVGhhd3RlIFNlcnZlciBDQTEm
MCQGCSqGSIb3DQEJARYXc2VydmVyLWNlcnRzQHRoYXd0ZS5jb20wHhcNOTYwODAx
MDAwMDAwWhcNMjAxMjMxMjM1OTU5WjCBxDELMAkGA1UEBhMCWkExFTATBgNVBAgT
DFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMR0wGwYDVQQKExRUaGF3
dGUgQ29uc3VsdGluZyBjYzEoMCYGA1UECxMfQ2VydGlmaWNhdGlvbiBTZXJ2aWNl
cyBEaXZpc2lvbjEZMBcGA1UEAxMQVGhhd3RlIFNlcnZlciBDQTEmMCQGCSqGSIb3
DQEJARYXc2VydmVyLWNlcnRzQHRoYXd0ZS5jb20wgZ8wDQYJKoZIhvcNAQEBBQAD
gY0AMIGJAoGBANOkUG7I/1Zr5s9dtuoMaHVHoqrC2oQl/Kj0R1HahbUgdJSGHg91
yekIYfUGbTBuFRkC6VLAYttNmZ7iagxEOM3+vuNkCXDF/rFrKbYvScg71CcEJRCX
L+eQbcAoQpnXTEPew/UhbVSfXcNY4cDk2VuwuNy0e982OsK1ZiIS1ocNAgMBAAGj
EzARMA8GA1UdEwEB/wQFMAMBAf8wDQYJKoZIhvcNAQEEBQADgYEAB/pMaVz7lcxG
7oWDTSEwjsrZqG9JGubaUeNgcGyEYRGhGshIPllDfU+VPaGLtwtimHp1it2ITk6e
QNuozDJ0uW8NxuOzRAvZim+aKZuZGCg70eNAKJpaPNW15yAbi8qkq43pUdniTCxZ
qdq5snUb9kLy78fyGPmJvKP/iiMucEc=
-----END CERTIFICATE-----
# Issuer: CN=Thawte Premium Server CA O=Thawte Consulting cc OU=Certification Services Division
# Subject: CN=Thawte Premium Server CA O=Thawte Consulting cc OU=Certification Services Division
# Label: "Thawte Premium Server CA"
# Serial: 1
# MD5 Fingerprint: 06:9f:69:79:16:66:90:02:1b:8c:8c:a2:c3:07:6f:3a
# SHA1 Fingerprint: 62:7f:8d:78:27:65:63:99:d2:7d:7f:90:44:c9:fe:b3:f3:3e:fa:9a
# SHA256 Fingerprint: ab:70:36:36:5c:71:54:aa:29:c2:c2:9f:5d:41:91:16:3b:16:2a:22:25:01:13:57:d5:6d:07:ff:a7:bc:1f:72
-----BEGIN CERTIFICATE-----
MIIDJzCCApCgAwIBAgIBATANBgkqhkiG9w0BAQQFADCBzjELMAkGA1UEBhMCWkEx
FTATBgNVBAgTDFdlc3Rlcm4gQ2FwZTESMBAGA1UEBxMJQ2FwZSBUb3duMR0wGwYD
VQQKExRUaGF3dGUgQ29uc3VsdGluZyBjYzEoMCYGA1UECxMfQ2VydGlmaWNhdGlv
biBTZXJ2aWNlcyBEaXZpc2lvbjEhMB8GA1UEAxMYVGhhd3RlIFByZW1pdW0gU2Vy
dmVyIENBMSgwJgYJKoZIhvcNAQkBFhlwcmVtaXVtLXNlcnZlckB0aGF3dGUuY29t
MB4XDTk2MDgwMTAwMDAwMFoXDTIwMTIzMTIzNTk1OVowgc4xCzAJBgNVBAYTAlpB
MRUwEwYDVQQIEwxXZXN0ZXJuIENhcGUxEjAQBgNVBAcTCUNhcGUgVG93bjEdMBsG
A1UEChMUVGhhd3RlIENvbnN1bHRpbmcgY2MxKDAmBgNVBAsTH0NlcnRpZmljYXRp
b24gU2VydmljZXMgRGl2aXNpb24xITAfBgNVBAMTGFRoYXd0ZSBQcmVtaXVtIFNl
cnZlciBDQTEoMCYGCSqGSIb3DQEJARYZcHJlbWl1bS1zZXJ2ZXJAdGhhd3RlLmNv
bTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEA0jY2aovXwlue2oFBYo847kkE
VdbQ7xwblRZH7xhINTpS9CtqBo87L+pW46+GjZ4X9560ZXUCTe/LCaIhUdib0GfQ
ug2SBhRz1JPLlyoAnFxODLz6FVL88kRu2hFKbgifLy3j+ao6hnO2RlNYyIkFvYMR
uHM/qgeN9EJN50CdHDcCAwEAAaMTMBEwDwYDVR0TAQH/BAUwAwEB/zANBgkqhkiG
9w0BAQQFAAOBgQAmSCwWwlj66BZ0DKqqX1Q/8tfJeGBeXm43YyJ3Nn6yF8Q0ufUI
hfzJATj/Tb7yFkJD57taRvvBxhEf8UqwKEbJw8RCfbz6q1lu1bdRiBHjpIUZa4JM
pAwSremkrj/xw0llmozFyD4lt5SZu5IycQfwhl7tUCemDaYj+bvLpgcUQg==
-----END CERTIFICATE-----
# Issuer: O=Equifax OU=Equifax Secure Certificate Authority
# Subject: O=Equifax OU=Equifax Secure Certificate Authority
# Label: "Equifax Secure CA"
# Serial: 903804111
# MD5 Fingerprint: 67:cb:9d:c0:13:24:8a:82:9b:b2:17:1e:d1:1b:ec:d4
# SHA1 Fingerprint: d2:32:09:ad:23:d3:14:23:21:74:e4:0d:7f:9d:62:13:97:86:63:3a
# SHA256 Fingerprint: 08:29:7a:40:47:db:a2:36:80:c7:31:db:6e:31:76:53:ca:78:48:e1:be:bd:3a:0b:01:79:a7:07:f9:2c:f1:78
-----BEGIN CERTIFICATE-----
MIIDIDCCAomgAwIBAgIENd70zzANBgkqhkiG9w0BAQUFADBOMQswCQYDVQQGEwJV
UzEQMA4GA1UEChMHRXF1aWZheDEtMCsGA1UECxMkRXF1aWZheCBTZWN1cmUgQ2Vy
dGlmaWNhdGUgQXV0aG9yaXR5MB4XDTk4MDgyMjE2NDE1MVoXDTE4MDgyMjE2NDE1
MVowTjELMAkGA1UEBhMCVVMxEDAOBgNVBAoTB0VxdWlmYXgxLTArBgNVBAsTJEVx
dWlmYXggU2VjdXJlIENlcnRpZmljYXRlIEF1dGhvcml0eTCBnzANBgkqhkiG9w0B
AQEFAAOBjQAwgYkCgYEAwV2xWGcIYu6gmi0fCG2RFGiYCh7+2gRvE4RiIcPRfM6f
BeC4AfBONOziipUEZKzxa1NfBbPLZ4C/QgKO/t0BCezhABRP/PvwDN1Dulsr4R+A
cJkVV5MW8Q+XarfCaCMczE1ZMKxRHjuvK9buY0V7xdlfUNLjUA86iOe/FP3gx7kC
AwEAAaOCAQkwggEFMHAGA1UdHwRpMGcwZaBjoGGkXzBdMQswCQYDVQQGEwJVUzEQ
MA4GA1UEChMHRXF1aWZheDEtMCsGA1UECxMkRXF1aWZheCBTZWN1cmUgQ2VydGlm
aWNhdGUgQXV0aG9yaXR5MQ0wCwYDVQQDEwRDUkwxMBoGA1UdEAQTMBGBDzIwMTgw
ODIyMTY0MTUxWjALBgNVHQ8EBAMCAQYwHwYDVR0jBBgwFoAUSOZo+SvSspXXR9gj
IBBPM5iQn9QwHQYDVR0OBBYEFEjmaPkr0rKV10fYIyAQTzOYkJ/UMAwGA1UdEwQF
MAMBAf8wGgYJKoZIhvZ9B0EABA0wCxsFVjMuMGMDAgbAMA0GCSqGSIb3DQEBBQUA
A4GBAFjOKer89961zgK5F7WF0bnj4JXMJTENAKaSbn+2kmOeUJXRmm/kEd5jhW6Y
7qj/WsjTVbJmcVfewCHrPSqnI0kBBIZCe/zuf6IWUrVnZ9NA2zsmWLIodz2uFHdh
1voqZiegDfqnc1zqcPGUIWVEX/r87yloqaKHee9570+sB3c4
-----END CERTIFICATE-----
# Issuer: O=VeriSign, Inc. OU=Class 3 Public Primary Certification Authority
# Subject: O=VeriSign, Inc. OU=Class 3 Public Primary Certification Authority
# Label: "Verisign Class 3 Public Primary Certification Authority"
# Serial: 149843929435818692848040365716851702463
# MD5 Fingerprint: 10:fc:63:5d:f6:26:3e:0d:f3:25:be:5f:79:cd:67:67
# SHA1 Fingerprint: 74:2c:31:92:e6:07:e4:24:eb:45:49:54:2b:e1:bb:c5:3e:61:74:e2
# SHA256 Fingerprint: e7:68:56:34:ef:ac:f6:9a:ce:93:9a:6b:25:5b:7b:4f:ab:ef:42:93:5b:50:a2:65:ac:b5:cb:60:27:e4:4e:70
-----BEGIN CERTIFICATE-----
MIICPDCCAaUCEHC65B0Q2Sk0tjjKewPMur8wDQYJKoZIhvcNAQECBQAwXzELMAkG
A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFz
cyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTk2
MDEyOTAwMDAwMFoXDTI4MDgwMTIzNTk1OVowXzELMAkGA1UEBhMCVVMxFzAVBgNV
BAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFzcyAzIFB1YmxpYyBQcmlt
YXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGfMA0GCSqGSIb3DQEBAQUAA4GN
ADCBiQKBgQDJXFme8huKARS0EN8EQNvjV69qRUCPhAwL0TPZ2RHP7gJYHyX3KqhE
BarsAx94f56TuZoAqiN91qyFomNFx3InzPRMxnVx0jnvT0Lwdd8KkMaOIG+YD/is
I19wKTakyYbnsZogy1Olhec9vn2a/iRFM9x2Fe0PonFkTGUugWhFpwIDAQABMA0G
CSqGSIb3DQEBAgUAA4GBALtMEivPLCYATxQT3ab7/AoRhIzzKBxnki98tsX63/Do
lbwdj2wsqFHMc9ikwFPwTtYmwHYBV4GSXiHx0bH/59AhWM1pF+NEHJwZRDmJXNyc
AA9WjQKZ7aKQRUzkuxCkPfAyAw7xzvjoyVGM5mKf5p/AfbdynMk2OmufTqj/ZA1k
-----END CERTIFICATE-----
# Issuer: O=VeriSign, Inc. OU=Class 3 Public Primary Certification Authority - G2/(c) 1998 VeriSign, Inc. - For authorized use only/VeriSign Trust Network
# Subject: O=VeriSign, Inc. OU=Class 3 Public Primary Certification Authority - G2/(c) 1998 VeriSign, Inc. - For authorized use only/VeriSign Trust Network
# Label: "Verisign Class 3 Public Primary Certification Authority - G2"
# Serial: 167285380242319648451154478808036881606
# MD5 Fingerprint: a2:33:9b:4c:74:78:73:d4:6c:e7:c1:f3:8d:cb:5c:e9
# SHA1 Fingerprint: 85:37:1c:a6:e5:50:14:3d:ce:28:03:47:1b:de:3a:09:e8:f8:77:0f
# SHA256 Fingerprint: 83:ce:3c:12:29:68:8a:59:3d:48:5f:81:97:3c:0f:91:95:43:1e:da:37:cc:5e:36:43:0e:79:c7:a8:88:63:8b
-----BEGIN CERTIFICATE-----
MIIDAjCCAmsCEH3Z/gfPqB63EHln+6eJNMYwDQYJKoZIhvcNAQEFBQAwgcExCzAJ
BgNVBAYTAlVTMRcwFQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE8MDoGA1UECxMzQ2xh
c3MgMyBQdWJsaWMgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcy
MTowOAYDVQQLEzEoYykgMTk5OCBWZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3Jp
emVkIHVzZSBvbmx5MR8wHQYDVQQLExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMB4X
DTk4MDUxODAwMDAwMFoXDTI4MDgwMTIzNTk1OVowgcExCzAJBgNVBAYTAlVTMRcw
FQYDVQQKEw5WZXJpU2lnbiwgSW5jLjE8MDoGA1UECxMzQ2xhc3MgMyBQdWJsaWMg
UHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAtIEcyMTowOAYDVQQLEzEo
YykgMTk5OCBWZXJpU2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5
MR8wHQYDVQQLExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMIGfMA0GCSqGSIb3DQEB
AQUAA4GNADCBiQKBgQDMXtERXVxp0KvTuWpMmR9ZmDCOFoUgRm1HP9SFIIThbbP4
pO0M8RcPO/mn+SXXwc+EY/J8Y8+iR/LGWzOOZEAEaMGAuWQcRXfH2G71lSk8UOg0
13gfqLptQ5GVj0VXXn7F+8qkBOvqlzdUMG+7AUcyM83cV5tkaWH4mx0ciU9cZwID
AQABMA0GCSqGSIb3DQEBBQUAA4GBAFFNzb5cy5gZnBWyATl4Lk0PZ3BwmcYQWpSk
U01UbSuvDV1Ai2TT1+7eVmGSX6bEHRBhNtMsJzzoKQm5EWR0zLVznxxIqbxhAe7i
F6YM40AIOw7n60RzKprxaZLvcRTDOaxxp5EJb+RxBrO6WVcmeQD2+A2iMzAo1KpY
oJ2daZH9
-----END CERTIFICATE-----
# Issuer: CN=GlobalSign Root CA O=GlobalSign nv-sa OU=Root CA
# Subject: CN=GlobalSign Root CA O=GlobalSign nv-sa OU=Root CA
# Label: "GlobalSign Root CA"
# Serial: 4835703278459707669005204
# MD5 Fingerprint: 3e:45:52:15:09:51:92:e1:b7:5d:37:9f:b1:87:29:8a
# SHA1 Fingerprint: b1:bc:96:8b:d4:f4:9d:62:2a:a8:9a:81:f2:15:01:52:a4:1d:82:9c
# SHA256 Fingerprint: eb:d4:10:40:e4:bb:3e:c7:42:c9:e3:81:d3:1e:f2:a4:1a:48:b6:68:5c:96:e7:ce:f3:c1:df:6c:d4:33:1c:99
-----BEGIN CERTIFICATE-----
MIIDdTCCAl2gAwIBAgILBAAAAAABFUtaw5QwDQYJKoZIhvcNAQEFBQAwVzELMAkG
A1UEBhMCQkUxGTAXBgNVBAoTEEdsb2JhbFNpZ24gbnYtc2ExEDAOBgNVBAsTB1Jv
b3QgQ0ExGzAZBgNVBAMTEkdsb2JhbFNpZ24gUm9vdCBDQTAeFw05ODA5MDExMjAw
MDBaFw0yODAxMjgxMjAwMDBaMFcxCzAJBgNVBAYTAkJFMRkwFwYDVQQKExBHbG9i
YWxTaWduIG52LXNhMRAwDgYDVQQLEwdSb290IENBMRswGQYDVQQDExJHbG9iYWxT
aWduIFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDaDuaZ
jc6j40+Kfvvxi4Mla+pIH/EqsLmVEQS98GPR4mdmzxzdzxtIK+6NiY6arymAZavp
xy0Sy6scTHAHoT0KMM0VjU/43dSMUBUc71DuxC73/OlS8pF94G3VNTCOXkNz8kHp
1Wrjsok6Vjk4bwY8iGlbKk3Fp1S4bInMm/k8yuX9ifUSPJJ4ltbcdG6TRGHRjcdG
snUOhugZitVtbNV4FpWi6cgKOOvyJBNPc1STE4U6G7weNLWLBYy5d4ux2x8gkasJ
U26Qzns3dLlwR5EiUWMWea6xrkEmCMgZK9FGqkjWZCrXgzT/LCrBbBlDSgeF59N8
9iFo7+ryUp9/k5DPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8E
BTADAQH/MB0GA1UdDgQWBBRge2YaRQ2XyolQL30EzTSo//z9SzANBgkqhkiG9w0B
AQUFAAOCAQEA1nPnfE920I2/7LqivjTFKDK1fPxsnCwrvQmeU79rXqoRSLblCKOz
yj1hTdNGCbM+w6DjY1Ub8rrvrTnhQ7k4o+YviiY776BQVvnGCv04zcQLcFGUl5gE
38NflNUVyRRBnMRddWQVDf9VMOyGj/8N7yy5Y0b2qvzfvGn9LhJIZJrglfCm7ymP
AbEVtQwdpf5pLGkkeB6zpxxxYu7KyJesF12KwvhHhm4qxFYxldBniYUr+WymXUad
DKqC5JlR3XC321Y9YeRq4VzW9v493kHMB65jUr9TU/Qr6cf9tveCX4XSQRjbgbME
HMUfpIBvFSDJ3gyICh3WZlXi/EjJKSZp4A==
-----END CERTIFICATE-----
# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R2
# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R2
# Label: "GlobalSign Root CA - R2"
# Serial: 4835703278459682885658125
# MD5 Fingerprint: 94:14:77:7e:3e:5e:fd:8f:30:bd:41:b0:cf:e7:d0:30
# SHA1 Fingerprint: 75:e0:ab:b6:13:85:12:27:1c:04:f8:5f:dd:de:38:e4:b7:24:2e:fe
# SHA256 Fingerprint: ca:42:dd:41:74:5f:d0:b8:1e:b9:02:36:2c:f9:d8:bf:71:9d:a1:bd:1b:1e:fc:94:6f:5b:4c:99:f4:2c:1b:9e
-----BEGIN CERTIFICATE-----
MIIDujCCAqKgAwIBAgILBAAAAAABD4Ym5g0wDQYJKoZIhvcNAQEFBQAwTDEgMB4G
A1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjIxEzARBgNVBAoTCkdsb2JhbFNp
Z24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDYxMjE1MDgwMDAwWhcNMjExMjE1
MDgwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMjETMBEG
A1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZI
hvcNAQEBBQADggEPADCCAQoCggEBAKbPJA6+Lm8omUVCxKs+IVSbC9N/hHD6ErPL
v4dfxn+G07IwXNb9rfF73OX4YJYJkhD10FPe+3t+c4isUoh7SqbKSaZeqKeMWhG8
eoLrvozps6yWJQeXSpkqBy+0Hne/ig+1AnwblrjFuTosvNYSuetZfeLQBoZfXklq
tTleiDTsvHgMCJiEbKjNS7SgfQx5TfC4LcshytVsW33hoCmEofnTlEnLJGKRILzd
C9XZzPnqJworc5HGnRusyMvo4KD0L5CLTfuwNhv2GXqF4G3yYROIXJ/gkwpRl4pa
zq+r1feqCapgvdzZX99yqWATXgAByUr6P6TqBwMhAo6CygPCm48CAwEAAaOBnDCB
mTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm+IH
V2ccHsBqBt5ZtJot39wZhi4wNgYDVR0fBC8wLTAroCmgJ4YlaHR0cDovL2NybC5n
bG9iYWxzaWduLm5ldC9yb290LXIyLmNybDAfBgNVHSMEGDAWgBSb4gdXZxwewGoG
3lm0mi3f3BmGLjANBgkqhkiG9w0BAQUFAAOCAQEAmYFThxxol4aR7OBKuEQLq4Gs
J0/WwbgcQ3izDJr86iw8bmEbTUsp9Z8FHSbBuOmDAGJFtqkIk7mpM0sYmsL4h4hO
291xNBrBVNpGP+DTKqttVCL1OmLNIG+6KYnX3ZHu01yiPqFbQfXf5WRDLenVOavS
ot+3i9DAgBkcRcAtjOj4LaR0VknFBbVPFd5uRHg5h6h+u/N5GJG79G+dwfCMNYxd
AfvDbbnvRG15RjF+Cv6pgsH/76tuIMRQyV+dTZsXjAzlAcmgQWpzU/qlULRuJQ/7
TBj0/VLZjmmx6BEP3ojY+x1J96relc8geMJgEtslQIxq/H5COEBkEveegeGTLg==
-----END CERTIFICATE-----
# Issuer: CN=http://www.valicert.com/ O=ValiCert, Inc. OU=ValiCert Class 1 Policy Validation Authority
# Subject: CN=http://www.valicert.com/ O=ValiCert, Inc. OU=ValiCert Class 1 Policy Validation Authority
# Label: "ValiCert Class 1 VA"
# Serial: 1
# MD5 Fingerprint: 65:58:ab:15:ad:57:6c:1e:a8:a7:b5:69:ac:bf:ff:eb
# SHA1 Fingerprint: e5:df:74:3c:b6:01:c4:9b:98:43:dc:ab:8c:e8:6a:81:10:9f:e4:8e
# SHA256 Fingerprint: f4:c1:49:55:1a:30:13:a3:5b:c7:bf:fe:17:a7:f3:44:9b:c1:ab:5b:5a:0a:e7:4b:06:c2:3b:90:00:4c:01:04
-----BEGIN CERTIFICATE-----
MIIC5zCCAlACAQEwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0
IFZhbGlkYXRpb24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAz
BgNVBAsTLFZhbGlDZXJ0IENsYXNzIDEgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9y
aXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG
9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTk5MDYyNTIyMjM0OFoXDTE5MDYy
NTIyMjM0OFowgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRpb24gTmV0d29y
azEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENs
YXNzIDEgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRw
Oi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNl
cnQuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDYWYJ6ibiWuqYvaG9Y
LqdUHAZu9OqNSLwxlBfw8068srg1knaw0KWlAdcAAxIiGQj4/xEjm84H9b9pGib+
TunRf50sQB1ZaG6m+FiwnRqP0z/x3BkGgagO4DrdyFNFCQbmD3DD+kCmDuJWBQ8Y
TfwggtFzVXSNdnKgHZ0dwN0/cQIDAQABMA0GCSqGSIb3DQEBBQUAA4GBAFBoPUn0
LBwGlN+VYH+Wexf+T3GtZMjdd9LvWVXoP+iOBSoh8gfStadS/pyxtuJbdxdA6nLW
I8sogTLDAHkY7FkXicnGah5xyf23dKUlRWnFSKsZ4UWKJWsZ7uW7EvV/96aNUcPw
nXS3qT6gpf+2SQMT2iLM7XGCK5nPOrf1LXLI
-----END CERTIFICATE-----
# Issuer: CN=http://www.valicert.com/ O=ValiCert, Inc. OU=ValiCert Class 2 Policy Validation Authority
# Subject: CN=http://www.valicert.com/ O=ValiCert, Inc. OU=ValiCert Class 2 Policy Validation Authority
# Label: "ValiCert Class 2 VA"
# Serial: 1
# MD5 Fingerprint: a9:23:75:9b:ba:49:36:6e:31:c2:db:f2:e7:66:ba:87
# SHA1 Fingerprint: 31:7a:2a:d0:7f:2b:33:5e:f5:a1:c3:4e:4b:57:e8:b7:d8:f1:fc:a6
# SHA256 Fingerprint: 58:d0:17:27:9c:d4:dc:63:ab:dd:b1:96:a6:c9:90:6c:30:c4:e0:87:83:ea:e8:c1:60:99:54:d6:93:55:59:6b
-----BEGIN CERTIFICATE-----
MIIC5zCCAlACAQEwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0
IFZhbGlkYXRpb24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAz
BgNVBAsTLFZhbGlDZXJ0IENsYXNzIDIgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9y
aXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG
9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTk5MDYyNjAwMTk1NFoXDTE5MDYy
NjAwMTk1NFowgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRpb24gTmV0d29y
azEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENs
YXNzIDIgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRw
Oi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNl
cnQuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDOOnHK5avIWZJV16vY
dA757tn2VUdZZUcOBVXc65g2PFxTXdMwzzjsvUGJ7SVCCSRrCl6zfN1SLUzm1NZ9
WlmpZdRJEy0kTRxQb7XBhVQ7/nHk01xC+YDgkRoKWzk2Z/M/VXwbP7RfZHM047QS
v4dk+NoS/zcnwbNDu+97bi5p9wIDAQABMA0GCSqGSIb3DQEBBQUAA4GBADt/UG9v
UJSZSWI4OB9L+KXIPqeCgfYrx+jFzug6EILLGACOTb2oWH+heQC1u+mNr0HZDzTu
IYEZoDJJKPTEjlbVUjP9UNV+mWwD5MlM/Mtsq2azSiGM5bUMMj4QssxsodyamEwC
W/POuZ6lcg5Ktz885hZo+L7tdEy8W9ViH0Pd
-----END CERTIFICATE-----
# Issuer: CN=http://www.valicert.com/ O=ValiCert, Inc. OU=ValiCert Class 3 Policy Validation Authority
# Subject: CN=http://www.valicert.com/ O=ValiCert, Inc. OU=ValiCert Class 3 Policy Validation Authority
# Label: "RSA Root Certificate 1"
# Serial: 1
# MD5 Fingerprint: a2:6f:53:b7:ee:40:db:4a:68:e7:fa:18:d9:10:4b:72
# SHA1 Fingerprint: 69:bd:8c:f4:9c:d3:00:fb:59:2e:17:93:ca:55:6a:f3:ec:aa:35:fb
# SHA256 Fingerprint: bc:23:f9:8a:31:3c:b9:2d:e3:bb:fc:3a:5a:9f:44:61:ac:39:49:4c:4a:e1:5a:9e:9d:f1:31:e9:9b:73:01:9a
-----BEGIN CERTIFICATE-----
MIIC5zCCAlACAQEwDQYJKoZIhvcNAQEFBQAwgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0
IFZhbGlkYXRpb24gTmV0d29yazEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAz
BgNVBAsTLFZhbGlDZXJ0IENsYXNzIDMgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9y
aXR5MSEwHwYDVQQDExhodHRwOi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG
9w0BCQEWEWluZm9AdmFsaWNlcnQuY29tMB4XDTk5MDYyNjAwMjIzM1oXDTE5MDYy
NjAwMjIzM1owgbsxJDAiBgNVBAcTG1ZhbGlDZXJ0IFZhbGlkYXRpb24gTmV0d29y
azEXMBUGA1UEChMOVmFsaUNlcnQsIEluYy4xNTAzBgNVBAsTLFZhbGlDZXJ0IENs
YXNzIDMgUG9saWN5IFZhbGlkYXRpb24gQXV0aG9yaXR5MSEwHwYDVQQDExhodHRw
Oi8vd3d3LnZhbGljZXJ0LmNvbS8xIDAeBgkqhkiG9w0BCQEWEWluZm9AdmFsaWNl
cnQuY29tMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQDjmFGWHOjVsQaBalfD
cnWTq8+epvzzFlLWLU2fNUSoLgRNB0mKOCn1dzfnt6td3zZxFJmP3MKS8edgkpfs
2Ejcv8ECIMYkpChMMFp2bbFc893enhBxoYjHW5tBbcqwuI4V7q0zK89HBFx1cQqY
JJgpp0lZpd34t0NiYfPT4tBVPwIDAQABMA0GCSqGSIb3DQEBBQUAA4GBAFa7AliE
Zwgs3x/be0kz9dNnnfS0ChCzycUs4pJqcXgn8nCDQtM+z6lU9PHYkhaM0QTLS6vJ
n0WuPIqpsHEzXcjFV9+vqDWzf4mH6eglkrh/hXqu1rweN1gqZ8mRzyqBPu3GOd/A
PhmcGcwTTYJBtYze4D1gCCAPRX5ron+jjBXu
-----END CERTIFICATE-----
# Issuer: CN=VeriSign Class 3 Public Primary Certification Authority - G3 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 1999 VeriSign, Inc. - For authorized use only
# Subject: CN=VeriSign Class 3 Public Primary Certification Authority - G3 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 1999 VeriSign, Inc. - For authorized use only
# Label: "Verisign Class 3 Public Primary Certification Authority - G3"
# Serial: 206684696279472310254277870180966723415
# MD5 Fingerprint: cd:68:b6:a7:c7:c4:ce:75:e0:1d:4f:57:44:61:92:09
# SHA1 Fingerprint: 13:2d:0d:45:53:4b:69:97:cd:b2:d5:c3:39:e2:55:76:60:9b:5c:c6
# SHA256 Fingerprint: eb:04:cf:5e:b1:f3:9a:fa:76:2f:2b:b1:20:f2:96:cb:a5:20:c1:b9:7d:b1:58:95:65:b8:1c:b9:a1:7b:72:44
-----BEGIN CERTIFICATE-----
MIIEGjCCAwICEQCbfgZJoz5iudXukEhxKe9XMA0GCSqGSIb3DQEBBQUAMIHKMQsw
CQYDVQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZl
cmlTaWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWdu
LCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlT
aWduIENsYXNzIDMgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3Jp
dHkgLSBHMzAeFw05OTEwMDEwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMIHKMQswCQYD
VQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlT
aWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWduLCBJ
bmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlTaWdu
IENsYXNzIDMgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg
LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMu6nFL8eB8aHm8b
N3O9+MlrlBIwT/A2R/XQkQr1F8ilYcEWQE37imGQ5XYgwREGfassbqb1EUGO+i2t
KmFZpGcmTNDovFJbcCAEWNF6yaRpvIMXZK0Fi7zQWM6NjPXr8EJJC52XJ2cybuGu
kxUccLwgTS8Y3pKI6GyFVxEa6X7jJhFUokWWVYPKMIno3Nij7SqAP395ZVc+FSBm
CC+Vk7+qRy+oRpfwEuL+wgorUeZ25rdGt+INpsyow0xZVYnm6FNcHOqd8GIWC6fJ
Xwzw3sJ2zq/3avL6QaaiMxTJ5Xpj055iN9WFZZ4O5lMkdBteHRJTW8cs54NJOxWu
imi5V5cCAwEAATANBgkqhkiG9w0BAQUFAAOCAQEAERSWwauSCPc/L8my/uRan2Te
2yFPhpk0djZX3dAVL8WtfxUfN2JzPtTnX84XA9s1+ivbrmAJXx5fj267Cz3qWhMe
DGBvtcC1IyIuBwvLqXTLR7sdwdela8wv0kL9Sd2nic9TutoAWii/gt/4uhMdUIaC
/Y4wjylGsB49Ndo4YhYYSq3mtlFs3q9i6wHQHiT+eo8SGhJouPtmmRQURVyu565p
F4ErWjfJXir0xuKhXFSbplQAz/DxwceYMBo7Nhbbo27q/a2ywtrvAkcTisDxszGt
TxzhT5yvDwyd93gN2PQ1VoDat20Xj50egWTh/sVFuq1ruQp6Tk9LhO5L8X3dEQ==
-----END CERTIFICATE-----
# Issuer: CN=VeriSign Class 4 Public Primary Certification Authority - G3 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 1999 VeriSign, Inc. - For authorized use only
# Subject: CN=VeriSign Class 4 Public Primary Certification Authority - G3 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 1999 VeriSign, Inc. - For authorized use only
# Label: "Verisign Class 4 Public Primary Certification Authority - G3"
# Serial: 314531972711909413743075096039378935511
# MD5 Fingerprint: db:c8:f2:27:2e:b1:ea:6a:29:23:5d:fe:56:3e:33:df
# SHA1 Fingerprint: c8:ec:8c:87:92:69:cb:4b:ab:39:e9:8d:7e:57:67:f3:14:95:73:9d
# SHA256 Fingerprint: e3:89:36:0d:0f:db:ae:b3:d2:50:58:4b:47:30:31:4e:22:2f:39:c1:56:a0:20:14:4e:8d:96:05:61:79:15:06
-----BEGIN CERTIFICATE-----
MIIEGjCCAwICEQDsoKeLbnVqAc/EfMwvlF7XMA0GCSqGSIb3DQEBBQUAMIHKMQsw
CQYDVQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZl
cmlTaWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWdu
LCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlT
aWduIENsYXNzIDQgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3Jp
dHkgLSBHMzAeFw05OTEwMDEwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMIHKMQswCQYD
VQQGEwJVUzEXMBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlT
aWduIFRydXN0IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAxOTk5IFZlcmlTaWduLCBJ
bmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxRTBDBgNVBAMTPFZlcmlTaWdu
IENsYXNzIDQgUHVibGljIFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg
LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAK3LpRFpxlmr8Y+1
GQ9Wzsy1HyDkniYlS+BzZYlZ3tCD5PUPtbut8XzoIfzk6AzufEUiGXaStBO3IFsJ
+mGuqPKljYXCKtbeZjbSmwL0qJJgfJxptI8kHtCGUvYynEFYHiK9zUVilQhu0Gbd
U6LM8BDcVHOLBKFGMzNcF0C5nk3T875Vg+ixiY5afJqWIpA7iCXy0lOIAgwLePLm
NxdLMEYH5IBtptiWLugs+BGzOA1mppvqySNb247i8xOOGlktqgLw7KSHZtzBP/XY
ufTsgsbSPZUd5cBPhMnZo0QoBmrXRazwa2rvTl/4EYIeOGM0ZlDUPpNz+jDDZq3/
ky2X7wMCAwEAATANBgkqhkiG9w0BAQUFAAOCAQEAj/ola09b5KROJ1WrIhVZPMq1
CtRK26vdoV9TxaBXOcLORyu+OshWv8LZJxA6sQU8wHcxuzrTBXttmhwwjIDLk5Mq
g6sFUYICABFna/OIYUdfA5PVWw3g8dShMjWFsjrbsIKr0csKvE+MW8VLADsfKoKm
fjaF3H48ZwC15DtS4KjrXRX5xm3wrR0OhbepmnMUWluPQSjA1egtTaRezarZ7c7c
2NU8Qh0XwRJdRTjDOPP8hS6DRkiy1yBfkjaP53kPmF6Z6PDQpLv1U70qzlmwr25/
bLvSHgCwIe34QWKCudiyxLtGUPMxxY8BqHTr9Xgn2uf3ZkPznoM+IKrDNWCRzg==
-----END CERTIFICATE-----
# Issuer: CN=Entrust.net Secure Server Certification Authority O=Entrust.net OU=www.entrust.net/CPS incorp. by ref. (limits liab.)/(c) 1999 Entrust.net Limited
# Subject: CN=Entrust.net Secure Server Certification Authority O=Entrust.net OU=www.entrust.net/CPS incorp. by ref. (limits liab.)/(c) 1999 Entrust.net Limited
# Label: "Entrust.net Secure Server CA"
# Serial: 927650371
# MD5 Fingerprint: df:f2:80:73:cc:f1:e6:61:73:fc:f5:42:e9:c5:7c:ee
# SHA1 Fingerprint: 99:a6:9b:e6:1a:fe:88:6b:4d:2b:82:00:7c:b8:54:fc:31:7e:15:39
# SHA256 Fingerprint: 62:f2:40:27:8c:56:4c:4d:d8:bf:7d:9d:4f:6f:36:6e:a8:94:d2:2f:5f:34:d9:89:a9:83:ac:ec:2f:ff:ed:50
-----BEGIN CERTIFICATE-----
MIIE2DCCBEGgAwIBAgIEN0rSQzANBgkqhkiG9w0BAQUFADCBwzELMAkGA1UEBhMC
VVMxFDASBgNVBAoTC0VudHJ1c3QubmV0MTswOQYDVQQLEzJ3d3cuZW50cnVzdC5u
ZXQvQ1BTIGluY29ycC4gYnkgcmVmLiAobGltaXRzIGxpYWIuKTElMCMGA1UECxMc
KGMpIDE5OTkgRW50cnVzdC5uZXQgTGltaXRlZDE6MDgGA1UEAxMxRW50cnVzdC5u
ZXQgU2VjdXJlIFNlcnZlciBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw05OTA1
MjUxNjA5NDBaFw0xOTA1MjUxNjM5NDBaMIHDMQswCQYDVQQGEwJVUzEUMBIGA1UE
ChMLRW50cnVzdC5uZXQxOzA5BgNVBAsTMnd3dy5lbnRydXN0Lm5ldC9DUFMgaW5j
b3JwLiBieSByZWYuIChsaW1pdHMgbGlhYi4pMSUwIwYDVQQLExwoYykgMTk5OSBF
bnRydXN0Lm5ldCBMaW1pdGVkMTowOAYDVQQDEzFFbnRydXN0Lm5ldCBTZWN1cmUg
U2VydmVyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGdMA0GCSqGSIb3DQEBAQUA
A4GLADCBhwKBgQDNKIM0VBuJ8w+vN5Ex/68xYMmo6LIQaO2f55M28Qpku0f1BBc/
I0dNxScZgSYMVHINiC3ZH5oSn7yzcdOAGT9HZnuMNSjSuQrfJNqc1lB5gXpa0zf3
wkrYKZImZNHkmGw6AIr1NJtl+O3jEP/9uElY3KDegjlrgbEWGWG5VLbmQwIBA6OC
AdcwggHTMBEGCWCGSAGG+EIBAQQEAwIABzCCARkGA1UdHwSCARAwggEMMIHeoIHb
oIHYpIHVMIHSMQswCQYDVQQGEwJVUzEUMBIGA1UEChMLRW50cnVzdC5uZXQxOzA5
BgNVBAsTMnd3dy5lbnRydXN0Lm5ldC9DUFMgaW5jb3JwLiBieSByZWYuIChsaW1p
dHMgbGlhYi4pMSUwIwYDVQQLExwoYykgMTk5OSBFbnRydXN0Lm5ldCBMaW1pdGVk
MTowOAYDVQQDEzFFbnRydXN0Lm5ldCBTZWN1cmUgU2VydmVyIENlcnRpZmljYXRp
b24gQXV0aG9yaXR5MQ0wCwYDVQQDEwRDUkwxMCmgJ6AlhiNodHRwOi8vd3d3LmVu
dHJ1c3QubmV0L0NSTC9uZXQxLmNybDArBgNVHRAEJDAigA8xOTk5MDUyNTE2MDk0
MFqBDzIwMTkwNTI1MTYwOTQwWjALBgNVHQ8EBAMCAQYwHwYDVR0jBBgwFoAU8Bdi
E1U9s/8KAGv7UISX8+1i0BowHQYDVR0OBBYEFPAXYhNVPbP/CgBr+1CEl/PtYtAa
MAwGA1UdEwQFMAMBAf8wGQYJKoZIhvZ9B0EABAwwChsEVjQuMAMCBJAwDQYJKoZI
hvcNAQEFBQADgYEAkNwwAvpkdMKnCqV8IY00F6j7Rw7/JXyNEwr75Ji174z4xRAN
95K+8cPV1ZVqBLssziY2ZcgxxufuP+NXdYR6Ee9GTxj005i7qIcyunL2POI9n9cd
2cNgQ4xYDiKWL2KjLB+6rQXvqzJ4h6BUcxm1XAX5Uj5tLUUL9wqT6u0G+bI=
-----END CERTIFICATE-----
# Issuer: CN=Entrust.net Certification Authority (2048) O=Entrust.net OU=www.entrust.net/CPS_2048 incorp. by ref. (limits liab.)/(c) 1999 Entrust.net Limited
# Subject: CN=Entrust.net Certification Authority (2048) O=Entrust.net OU=www.entrust.net/CPS_2048 incorp. by ref. (limits liab.)/(c) 1999 Entrust.net Limited
# Label: "Entrust.net Premium 2048 Secure Server CA"
# Serial: 946059622
# MD5 Fingerprint: ba:21:ea:20:d6:dd:db:8f:c1:57:8b:40:ad:a1:fc:fc
# SHA1 Fingerprint: 80:1d:62:d0:7b:44:9d:5c:5c:03:5c:98:ea:61:fa:44:3c:2a:58:fe
# SHA256 Fingerprint: d1:c3:39:ea:27:84:eb:87:0f:93:4f:c5:63:4e:4a:a9:ad:55:05:01:64:01:f2:64:65:d3:7a:57:46:63:35:9f
-----BEGIN CERTIFICATE-----
MIIEXDCCA0SgAwIBAgIEOGO5ZjANBgkqhkiG9w0BAQUFADCBtDEUMBIGA1UEChML
RW50cnVzdC5uZXQxQDA+BgNVBAsUN3d3dy5lbnRydXN0Lm5ldC9DUFNfMjA0OCBp
bmNvcnAuIGJ5IHJlZi4gKGxpbWl0cyBsaWFiLikxJTAjBgNVBAsTHChjKSAxOTk5
IEVudHJ1c3QubmV0IExpbWl0ZWQxMzAxBgNVBAMTKkVudHJ1c3QubmV0IENlcnRp
ZmljYXRpb24gQXV0aG9yaXR5ICgyMDQ4KTAeFw05OTEyMjQxNzUwNTFaFw0xOTEy
MjQxODIwNTFaMIG0MRQwEgYDVQQKEwtFbnRydXN0Lm5ldDFAMD4GA1UECxQ3d3d3
LmVudHJ1c3QubmV0L0NQU18yMDQ4IGluY29ycC4gYnkgcmVmLiAobGltaXRzIGxp
YWIuKTElMCMGA1UECxMcKGMpIDE5OTkgRW50cnVzdC5uZXQgTGltaXRlZDEzMDEG
A1UEAxMqRW50cnVzdC5uZXQgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgKDIwNDgp
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEArU1LqRKGsuqjIAcVFmQq
K0vRvwtKTY7tgHalZ7d4QMBzQshowNtTK91euHaYNZOLGp18EzoOH1u3Hs/lJBQe
sYGpjX24zGtLA/ECDNyrpUAkAH90lKGdCCmziAv1h3edVc3kw37XamSrhRSGlVuX
MlBvPci6Zgzj/L24ScF2iUkZ/cCovYmjZy/Gn7xxGWC4LeksyZB2ZnuU4q941mVT
XTzWnLLPKQP5L6RQstRIzgUyVYr9smRMDuSYB3Xbf9+5CFVghTAp+XtIpGmG4zU/
HoZdenoVve8AjhUiVBcAkCaTvA5JaJG/+EfTnZVCwQ5N328mz8MYIWJmQ3DW1cAH
4QIDAQABo3QwcjARBglghkgBhvhCAQEEBAMCAAcwHwYDVR0jBBgwFoAUVeSB0RGA
vtiJuQijMfmhJAkWuXAwHQYDVR0OBBYEFFXkgdERgL7YibkIozH5oSQJFrlwMB0G
CSqGSIb2fQdBAAQQMA4bCFY1LjA6NC4wAwIEkDANBgkqhkiG9w0BAQUFAAOCAQEA
WUesIYSKF8mciVMeuoCFGsY8Tj6xnLZ8xpJdGGQC49MGCBFhfGPjK50xA3B20qMo
oPS7mmNz7W3lKtvtFKkrxjYR0CvrB4ul2p5cGZ1WEvVUKcgF7bISKo30Axv/55IQ
h7A6tcOdBTcSo8f0FbnVpDkWm1M6I5HxqIKiaohowXkCIryqptau37AUX7iH0N18
f3v/rxzP5tsHrV7bhZ3QKw0z2wTR5klAEyt2+z7pnIkPFc4YsIV4IU9rTw76NmfN
B/L/CNDi3tm/Kq+4h4YhPATKt5Rof8886ZjXOP/swNlQ8C5LWK5Gb9Auw2DaclVy
vUxFnmG6v4SBkgPR0ml8xQ==
-----END CERTIFICATE-----
# Issuer: CN=Baltimore CyberTrust Root O=Baltimore OU=CyberTrust
# Subject: CN=Baltimore CyberTrust Root O=Baltimore OU=CyberTrust
# Label: "Baltimore CyberTrust Root"
# Serial: 33554617
# MD5 Fingerprint: ac:b6:94:a5:9c:17:e0:d7:91:52:9b:b1:97:06:a6:e4
# SHA1 Fingerprint: d4:de:20:d0:5e:66:fc:53:fe:1a:50:88:2c:78:db:28:52:ca:e4:74
# SHA256 Fingerprint: 16:af:57:a9:f6:76:b0:ab:12:60:95:aa:5e:ba:de:f2:2a:b3:11:19:d6:44:ac:95:cd:4b:93:db:f3:f2:6a:eb
-----BEGIN CERTIFICATE-----
MIIDdzCCAl+gAwIBAgIEAgAAuTANBgkqhkiG9w0BAQUFADBaMQswCQYDVQQGEwJJ
RTESMBAGA1UEChMJQmFsdGltb3JlMRMwEQYDVQQLEwpDeWJlclRydXN0MSIwIAYD
VQQDExlCYWx0aW1vcmUgQ3liZXJUcnVzdCBSb290MB4XDTAwMDUxMjE4NDYwMFoX
DTI1MDUxMjIzNTkwMFowWjELMAkGA1UEBhMCSUUxEjAQBgNVBAoTCUJhbHRpbW9y
ZTETMBEGA1UECxMKQ3liZXJUcnVzdDEiMCAGA1UEAxMZQmFsdGltb3JlIEN5YmVy
VHJ1c3QgUm9vdDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKMEuyKr
mD1X6CZymrV51Cni4eiVgLGw41uOKymaZN+hXe2wCQVt2yguzmKiYv60iNoS6zjr
IZ3AQSsBUnuId9Mcj8e6uYi1agnnc+gRQKfRzMpijS3ljwumUNKoUMMo6vWrJYeK
mpYcqWe4PwzV9/lSEy/CG9VwcPCPwBLKBsua4dnKM3p31vjsufFoREJIE9LAwqSu
XmD+tqYF/LTdB1kC1FkYmGP1pWPgkAx9XbIGevOF6uvUA65ehD5f/xXtabz5OTZy
dc93Uk3zyZAsuT3lySNTPx8kmCFcB5kpvcY67Oduhjprl3RjM71oGDHweI12v/ye
jl0qhqdNkNwnGjkCAwEAAaNFMEMwHQYDVR0OBBYEFOWdWTCCR1jMrPoIVDaGezq1
BE3wMBIGA1UdEwEB/wQIMAYBAf8CAQMwDgYDVR0PAQH/BAQDAgEGMA0GCSqGSIb3
DQEBBQUAA4IBAQCFDF2O5G9RaEIFoN27TyclhAO992T9Ldcw46QQF+vaKSm2eT92
9hkTI7gQCvlYpNRhcL0EYWoSihfVCr3FvDB81ukMJY2GQE/szKN+OMY3EU/t3Wgx
jkzSswF07r51XgdIGn9w/xZchMB5hbgF/X++ZRGjD8ACtPhSNzkE1akxehi/oCr0
Epn3o0WC4zxe9Z2etciefC7IpJ5OCBRLbf1wbWsaY71k5h+3zvDyny67G7fyUIhz
ksLi4xaNmjICq44Y3ekQEe5+NauQrz4wlHrQMz2nZQ/1/I6eYs9HRCwBXbsdtTLS
R9I4LtD+gdwyah617jzV/OeBHRnDJELqYzmp
-----END CERTIFICATE-----
# Issuer: CN=Equifax Secure Global eBusiness CA-1 O=Equifax Secure Inc.
# Subject: CN=Equifax Secure Global eBusiness CA-1 O=Equifax Secure Inc.
# Label: "Equifax Secure Global eBusiness CA"
# Serial: 1
# MD5 Fingerprint: 8f:5d:77:06:27:c4:98:3c:5b:93:78:e7:d7:7d:9b:cc
# SHA1 Fingerprint: 7e:78:4a:10:1c:82:65:cc:2d:e1:f1:6d:47:b4:40:ca:d9:0a:19:45
# SHA256 Fingerprint: 5f:0b:62:ea:b5:e3:53:ea:65:21:65:16:58:fb:b6:53:59:f4:43:28:0a:4a:fb:d1:04:d7:7d:10:f9:f0:4c:07
-----BEGIN CERTIFICATE-----
MIICkDCCAfmgAwIBAgIBATANBgkqhkiG9w0BAQQFADBaMQswCQYDVQQGEwJVUzEc
MBoGA1UEChMTRXF1aWZheCBTZWN1cmUgSW5jLjEtMCsGA1UEAxMkRXF1aWZheCBT
ZWN1cmUgR2xvYmFsIGVCdXNpbmVzcyBDQS0xMB4XDTk5MDYyMTA0MDAwMFoXDTIw
MDYyMTA0MDAwMFowWjELMAkGA1UEBhMCVVMxHDAaBgNVBAoTE0VxdWlmYXggU2Vj
dXJlIEluYy4xLTArBgNVBAMTJEVxdWlmYXggU2VjdXJlIEdsb2JhbCBlQnVzaW5l
c3MgQ0EtMTCBnzANBgkqhkiG9w0BAQEFAAOBjQAwgYkCgYEAuucXkAJlsTRVPEnC
UdXfp9E3j9HngXNBUmCbnaEXJnitx7HoJpQytd4zjTov2/KaelpzmKNc6fuKcxtc
58O/gGzNqfTWK8D3+ZmqY6KxRwIP1ORROhI8bIpaVIRw28HFkM9yRcuoWcDNM50/
o5brhTMhHD4ePmBudpxnhcXIw2ECAwEAAaNmMGQwEQYJYIZIAYb4QgEBBAQDAgAH
MA8GA1UdEwEB/wQFMAMBAf8wHwYDVR0jBBgwFoAUvqigdHJQa0S3ySPY+6j/s1dr
aGwwHQYDVR0OBBYEFL6ooHRyUGtEt8kj2Puo/7NXa2hsMA0GCSqGSIb3DQEBBAUA
A4GBADDiAVGqx+pf2rnQZQ8w1j7aDRRJbpGTJxQx78T3LUX47Me/okENI7SS+RkA
Z70Br83gcfxaz2TE4JaY0KNA4gGK7ycH8WUBikQtBmV1UsCGECAhX2xrD2yuCRyv
8qIYNMR1pHMc8Y3c7635s3a0kr/clRAevsvIO1qEYBlWlKlV
-----END CERTIFICATE-----
# Issuer: CN=Equifax Secure eBusiness CA-1 O=Equifax Secure Inc.
# Subject: CN=Equifax Secure eBusiness CA-1 O=Equifax Secure Inc.
# Label: "Equifax Secure eBusiness CA 1"
# Serial: 4
# MD5 Fingerprint: 64:9c:ef:2e:44:fc:c6:8f:52:07:d0:51:73:8f:cb:3d
# SHA1 Fingerprint: da:40:18:8b:91:89:a3:ed:ee:ae:da:97:fe:2f:9d:f5:b7:d1:8a:41
# SHA256 Fingerprint: cf:56:ff:46:a4:a1:86:10:9d:d9:65:84:b5:ee:b5:8a:51:0c:42:75:b0:e5:f9:4f:40:bb:ae:86:5e:19:f6:73
-----BEGIN CERTIFICATE-----
MIICgjCCAeugAwIBAgIBBDANBgkqhkiG9w0BAQQFADBTMQswCQYDVQQGEwJVUzEc
MBoGA1UEChMTRXF1aWZheCBTZWN1cmUgSW5jLjEmMCQGA1UEAxMdRXF1aWZheCBT
ZWN1cmUgZUJ1c2luZXNzIENBLTEwHhcNOTkwNjIxMDQwMDAwWhcNMjAwNjIxMDQw
MDAwWjBTMQswCQYDVQQGEwJVUzEcMBoGA1UEChMTRXF1aWZheCBTZWN1cmUgSW5j
LjEmMCQGA1UEAxMdRXF1aWZheCBTZWN1cmUgZUJ1c2luZXNzIENBLTEwgZ8wDQYJ
KoZIhvcNAQEBBQADgY0AMIGJAoGBAM4vGbwXt3fek6lfWg0XTzQaDJj0ItlZ1MRo
RvC0NcWFAyDGr0WlIVFFQesWWDYyb+JQYmT5/VGcqiTZ9J2DKocKIdMSODRsjQBu
WqDZQu4aIZX5UkxVWsUPOE9G+m34LjXWHXzr4vCwdYDIqROsvojvOm6rXyo4YgKw
Env+j6YDAgMBAAGjZjBkMBEGCWCGSAGG+EIBAQQEAwIABzAPBgNVHRMBAf8EBTAD
AQH/MB8GA1UdIwQYMBaAFEp4MlIR21kWNl7fwRQ2QGpHfEyhMB0GA1UdDgQWBBRK
eDJSEdtZFjZe38EUNkBqR3xMoTANBgkqhkiG9w0BAQQFAAOBgQB1W6ibAxHm6VZM
zfmpTMANmvPMZWnmJXbMWbfWVMMdzZmsGd20hdXgPfxiIKeES1hl8eL5lSE/9dR+
WB5Hh1Q+WKG1tfgq73HnvMP2sUlG4tega+VWeponmHxGYhTnyfxuAxJ5gDgdSIKN
/Bf+KpYrtWKmpj29f5JZzVoqgrI3eQ==
-----END CERTIFICATE-----
# Issuer: O=Equifax Secure OU=Equifax Secure eBusiness CA-2
# Subject: O=Equifax Secure OU=Equifax Secure eBusiness CA-2
# Label: "Equifax Secure eBusiness CA 2"
# Serial: 930140085
# MD5 Fingerprint: aa:bf:bf:64:97:da:98:1d:6f:c6:08:3a:95:70:33:ca
# SHA1 Fingerprint: 39:4f:f6:85:0b:06:be:52:e5:18:56:cc:10:e1:80:e8:82:b3:85:cc
# SHA256 Fingerprint: 2f:27:4e:48:ab:a4:ac:7b:76:59:33:10:17:75:50:6d:c3:0e:e3:8e:f6:ac:d5:c0:49:32:cf:e0:41:23:42:20
-----BEGIN CERTIFICATE-----
MIIDIDCCAomgAwIBAgIEN3DPtTANBgkqhkiG9w0BAQUFADBOMQswCQYDVQQGEwJV
UzEXMBUGA1UEChMORXF1aWZheCBTZWN1cmUxJjAkBgNVBAsTHUVxdWlmYXggU2Vj
dXJlIGVCdXNpbmVzcyBDQS0yMB4XDTk5MDYyMzEyMTQ0NVoXDTE5MDYyMzEyMTQ0
NVowTjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDkVxdWlmYXggU2VjdXJlMSYwJAYD
VQQLEx1FcXVpZmF4IFNlY3VyZSBlQnVzaW5lc3MgQ0EtMjCBnzANBgkqhkiG9w0B
AQEFAAOBjQAwgYkCgYEA5Dk5kx5SBhsoNviyoynF7Y6yEb3+6+e0dMKP/wXn2Z0G
vxLIPw7y1tEkshHe0XMJitSxLJgJDR5QRrKDpkWNYmi7hRsgcDKqQM2mll/EcTc/
BPO3QSQ5BxoeLmFYoBIL5aXfxavqN3HMHMg3OrmXUqesxWoklE6ce8/AatbfIb0C
AwEAAaOCAQkwggEFMHAGA1UdHwRpMGcwZaBjoGGkXzBdMQswCQYDVQQGEwJVUzEX
MBUGA1UEChMORXF1aWZheCBTZWN1cmUxJjAkBgNVBAsTHUVxdWlmYXggU2VjdXJl
IGVCdXNpbmVzcyBDQS0yMQ0wCwYDVQQDEwRDUkwxMBoGA1UdEAQTMBGBDzIwMTkw
NjIzMTIxNDQ1WjALBgNVHQ8EBAMCAQYwHwYDVR0jBBgwFoAUUJ4L6q9euSBIplBq
y/3YIHqngnYwHQYDVR0OBBYEFFCeC+qvXrkgSKZQasv92CB6p4J2MAwGA1UdEwQF
MAMBAf8wGgYJKoZIhvZ9B0EABA0wCxsFVjMuMGMDAgbAMA0GCSqGSIb3DQEBBQUA
A4GBAAyGgq3oThr1jokn4jVYPSm0B482UJW/bsGe68SQsoWou7dC4A8HOd/7npCy
0cE+U58DRLB+S/Rv5Hwf5+Kx5Lia78O9zt4LMjTZ3ijtM2vE1Nc9ElirfQkty3D1
E4qUoSek1nDFbZS1yX2doNLGCEnZZpum0/QL3MUmV+GRMOrN
-----END CERTIFICATE-----
# Issuer: CN=AddTrust Class 1 CA Root O=AddTrust AB OU=AddTrust TTP Network
# Subject: CN=AddTrust Class 1 CA Root O=AddTrust AB OU=AddTrust TTP Network
# Label: "AddTrust Low-Value Services Root"
# Serial: 1
# MD5 Fingerprint: 1e:42:95:02:33:92:6b:b9:5f:c0:7f:da:d6:b2:4b:fc
# SHA1 Fingerprint: cc:ab:0e:a0:4c:23:01:d6:69:7b:dd:37:9f:cd:12:eb:24:e3:94:9d
# SHA256 Fingerprint: 8c:72:09:27:9a:c0:4e:27:5e:16:d0:7f:d3:b7:75:e8:01:54:b5:96:80:46:e3:1f:52:dd:25:76:63:24:e9:a7
-----BEGIN CERTIFICATE-----
MIIEGDCCAwCgAwIBAgIBATANBgkqhkiG9w0BAQUFADBlMQswCQYDVQQGEwJTRTEU
MBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3
b3JrMSEwHwYDVQQDExhBZGRUcnVzdCBDbGFzcyAxIENBIFJvb3QwHhcNMDAwNTMw
MTAzODMxWhcNMjAwNTMwMTAzODMxWjBlMQswCQYDVQQGEwJTRTEUMBIGA1UEChML
QWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3b3JrMSEwHwYD
VQQDExhBZGRUcnVzdCBDbGFzcyAxIENBIFJvb3QwggEiMA0GCSqGSIb3DQEBAQUA
A4IBDwAwggEKAoIBAQCWltQhSWDia+hBBwzexODcEyPNwTXH+9ZOEQpnXvUGW2ul
CDtbKRY654eyNAbFvAWlA3yCyykQruGIgb3WntP+LVbBFc7jJp0VLhD7Bo8wBN6n
tGO0/7Gcrjyvd7ZWxbWroulpOj0OM3kyP3CCkplhbY0wCI9xP6ZIVxn4JdxLZlyl
dI+Yrsj5wAYi56xz36Uu+1LcsRVlIPo1Zmne3yzxbrww2ywkEtvrNTVokMsAsJch
PXQhI2U0K7t4WaPW4XY5mqRJjox0r26kmqPZm9I4XJuiGMx1I4S+6+JNM3GOGvDC
+Mcdoq0Dlyz4zyXG9rgkMbFjXZJ/Y/AlyVMuH79NAgMBAAGjgdIwgc8wHQYDVR0O
BBYEFJWxtPCUtr3H2tERCSG+wa9J/RB7MAsGA1UdDwQEAwIBBjAPBgNVHRMBAf8E
BTADAQH/MIGPBgNVHSMEgYcwgYSAFJWxtPCUtr3H2tERCSG+wa9J/RB7oWmkZzBl
MQswCQYDVQQGEwJTRTEUMBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFk
ZFRydXN0IFRUUCBOZXR3b3JrMSEwHwYDVQQDExhBZGRUcnVzdCBDbGFzcyAxIENB
IFJvb3SCAQEwDQYJKoZIhvcNAQEFBQADggEBACxtZBsfzQ3duQH6lmM0MkhHma6X
7f1yFqZzR1r0693p9db7RcwpiURdv0Y5PejuvE1Uhh4dbOMXJ0PhiVYrqW9yTkkz
43J8KiOavD7/KCrto/8cI7pDVwlnTUtiBi34/2ydYB7YHEt9tTEv2dB8Xfjea4MY
eDdXL+gzB2ffHsdrKpV2ro9Xo/D0UrSpUwjP4E/TelOL/bscVjby/rK25Xa71SJl
pz/+0WatC7xrmYbvP33zGDLKe8bjq2RGlfgmadlVg3sslgf/WSxEo8bl6ancoWOA
WiFeIc9TVPC6b4nbqKqVz4vjccweGyBECMB6tkD9xOQ14R0WHNC8K47Wcdk=
-----END CERTIFICATE-----
# Issuer: CN=AddTrust External CA Root O=AddTrust AB OU=AddTrust External TTP Network
# Subject: CN=AddTrust External CA Root O=AddTrust AB OU=AddTrust External TTP Network
# Label: "AddTrust External Root"
# Serial: 1
# MD5 Fingerprint: 1d:35:54:04:85:78:b0:3f:42:42:4d:bf:20:73:0a:3f
# SHA1 Fingerprint: 02:fa:f3:e2:91:43:54:68:60:78:57:69:4d:f5:e4:5b:68:85:18:68
# SHA256 Fingerprint: 68:7f:a4:51:38:22:78:ff:f0:c8:b1:1f:8d:43:d5:76:67:1c:6e:b2:bc:ea:b4:13:fb:83:d9:65:d0:6d:2f:f2
-----BEGIN CERTIFICATE-----
MIIENjCCAx6gAwIBAgIBATANBgkqhkiG9w0BAQUFADBvMQswCQYDVQQGEwJTRTEU
MBIGA1UEChMLQWRkVHJ1c3QgQUIxJjAkBgNVBAsTHUFkZFRydXN0IEV4dGVybmFs
IFRUUCBOZXR3b3JrMSIwIAYDVQQDExlBZGRUcnVzdCBFeHRlcm5hbCBDQSBSb290
MB4XDTAwMDUzMDEwNDgzOFoXDTIwMDUzMDEwNDgzOFowbzELMAkGA1UEBhMCU0Ux
FDASBgNVBAoTC0FkZFRydXN0IEFCMSYwJAYDVQQLEx1BZGRUcnVzdCBFeHRlcm5h
bCBUVFAgTmV0d29yazEiMCAGA1UEAxMZQWRkVHJ1c3QgRXh0ZXJuYWwgQ0EgUm9v
dDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALf3GjPm8gAELTngTlvt
H7xsD821+iO2zt6bETOXpClMfZOfvUq8k+0DGuOPz+VtUFrWlymUWoCwSXrbLpX9
uMq/NzgtHj6RQa1wVsfwTz/oMp50ysiQVOnGXw94nZpAPA6sYapeFI+eh6FqUNzX
mk6vBbOmcZSccbNQYArHE504B4YCqOmoaSYYkKtMsE8jqzpPhNjfzp/haW+710LX
a0Tkx63ubUFfclpxCDezeWWkWaCUN/cALw3CknLa0Dhy2xSoRcRdKn23tNbE7qzN
E0S3ySvdQwAl+mG5aWpYIxG3pzOPVnVZ9c0p10a3CitlttNCbxWyuHv77+ldU9U0
WicCAwEAAaOB3DCB2TAdBgNVHQ4EFgQUrb2YejS0Jvf6xCZU7wO94CTLVBowCwYD
VR0PBAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wgZkGA1UdIwSBkTCBjoAUrb2YejS0
Jvf6xCZU7wO94CTLVBqhc6RxMG8xCzAJBgNVBAYTAlNFMRQwEgYDVQQKEwtBZGRU
cnVzdCBBQjEmMCQGA1UECxMdQWRkVHJ1c3QgRXh0ZXJuYWwgVFRQIE5ldHdvcmsx
IjAgBgNVBAMTGUFkZFRydXN0IEV4dGVybmFsIENBIFJvb3SCAQEwDQYJKoZIhvcN
AQEFBQADggEBALCb4IUlwtYj4g+WBpKdQZic2YR5gdkeWxQHIzZlj7DYd7usQWxH
YINRsPkyPef89iYTx4AWpb9a/IfPeHmJIZriTAcKhjW88t5RxNKWt9x+Tu5w/Rw5
6wwCURQtjr0W4MHfRnXnJK3s9EK0hZNwEGe6nQY1ShjTK3rMUUKhemPR5ruhxSvC
Nr4TDea9Y355e6cJDUCrat2PisP29owaQgVR1EX1n6diIWgVIEM8med8vSTYqZEX
c4g/VhsxOBi0cQ+azcgOno4uG+GMmIPLHzHxREzGBHNJdmAPx/i9F4BrLunMTA5a
mnkPIAou1Z5jJh5VkpTYghdae9C8x49OhgQ=
-----END CERTIFICATE-----
# Issuer: CN=AddTrust Public CA Root O=AddTrust AB OU=AddTrust TTP Network
# Subject: CN=AddTrust Public CA Root O=AddTrust AB OU=AddTrust TTP Network
# Label: "AddTrust Public Services Root"
# Serial: 1
# MD5 Fingerprint: c1:62:3e:23:c5:82:73:9c:03:59:4b:2b:e9:77:49:7f
# SHA1 Fingerprint: 2a:b6:28:48:5e:78:fb:f3:ad:9e:79:10:dd:6b:df:99:72:2c:96:e5
# SHA256 Fingerprint: 07:91:ca:07:49:b2:07:82:aa:d3:c7:d7:bd:0c:df:c9:48:58:35:84:3e:b2:d7:99:60:09:ce:43:ab:6c:69:27
-----BEGIN CERTIFICATE-----
MIIEFTCCAv2gAwIBAgIBATANBgkqhkiG9w0BAQUFADBkMQswCQYDVQQGEwJTRTEU
MBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3
b3JrMSAwHgYDVQQDExdBZGRUcnVzdCBQdWJsaWMgQ0EgUm9vdDAeFw0wMDA1MzAx
MDQxNTBaFw0yMDA1MzAxMDQxNTBaMGQxCzAJBgNVBAYTAlNFMRQwEgYDVQQKEwtB
ZGRUcnVzdCBBQjEdMBsGA1UECxMUQWRkVHJ1c3QgVFRQIE5ldHdvcmsxIDAeBgNV
BAMTF0FkZFRydXN0IFB1YmxpYyBDQSBSb290MIIBIjANBgkqhkiG9w0BAQEFAAOC
AQ8AMIIBCgKCAQEA6Rowj4OIFMEg2Dybjxt+A3S72mnTRqX4jsIMEZBRpS9mVEBV
6tsfSlbunyNu9DnLoblv8n75XYcmYZ4c+OLspoH4IcUkzBEMP9smcnrHAZcHF/nX
GCwwfQ56HmIexkvA/X1id9NEHif2P0tEs7c42TkfYNVRknMDtABp4/MUTu7R3AnP
dzRGULD4EfL+OHn3Bzn+UZKXC1sIXzSGAa2Il+tmzV7R/9x98oTaunet3IAIx6eH
1lWfl2royBFkuucZKT8Rs3iQhCBSWxHveNCD9tVIkNAwHM+A+WD+eeSI8t0A65RF
62WUaUC6wNW0uLp9BBGo6zEFlpROWCGOn9Bg/QIDAQABo4HRMIHOMB0GA1UdDgQW
BBSBPjfYkrAfd59ctKtzquf2NGAv+jALBgNVHQ8EBAMCAQYwDwYDVR0TAQH/BAUw
AwEB/zCBjgYDVR0jBIGGMIGDgBSBPjfYkrAfd59ctKtzquf2NGAv+qFopGYwZDEL
MAkGA1UEBhMCU0UxFDASBgNVBAoTC0FkZFRydXN0IEFCMR0wGwYDVQQLExRBZGRU
cnVzdCBUVFAgTmV0d29yazEgMB4GA1UEAxMXQWRkVHJ1c3QgUHVibGljIENBIFJv
b3SCAQEwDQYJKoZIhvcNAQEFBQADggEBAAP3FUr4JNojVhaTdt02KLmuG7jD8WS6
IBh4lSknVwW8fCr0uVFV2ocC3g8WFzH4qnkuCRO7r7IgGRLlk/lL+YPoRNWyQSW/
iHVv/xD8SlTQX/D67zZzfRs2RcYhbbQVuE7PnFylPVoAjgbjPGsye/Kf8Lb93/Ao
GEjwxrzQvzSAlsJKsW2Ox5BF3i9nrEUEo3rcVZLJR2bYGozH7ZxOmuASu7VqTITh
4SINhwBk/ox9Yjllpu9CtoAlEmEBqCQTcAARJl/6NVDFSMwGR+gn2HCNX2TmoUQm
XiLsks3/QppEIW1cxeMiHV9HEufOX1362KqxMy3ZdvJOOjMMK7MtkAY=
-----END CERTIFICATE-----
# Issuer: CN=AddTrust Qualified CA Root O=AddTrust AB OU=AddTrust TTP Network
# Subject: CN=AddTrust Qualified CA Root O=AddTrust AB OU=AddTrust TTP Network
# Label: "AddTrust Qualified Certificates Root"
# Serial: 1
# MD5 Fingerprint: 27:ec:39:47:cd:da:5a:af:e2:9a:01:65:21:a9:4c:bb
# SHA1 Fingerprint: 4d:23:78:ec:91:95:39:b5:00:7f:75:8f:03:3b:21:1e:c5:4d:8b:cf
# SHA256 Fingerprint: 80:95:21:08:05:db:4b:bc:35:5e:44:28:d8:fd:6e:c2:cd:e3:ab:5f:b9:7a:99:42:98:8e:b8:f4:dc:d0:60:16
-----BEGIN CERTIFICATE-----
MIIEHjCCAwagAwIBAgIBATANBgkqhkiG9w0BAQUFADBnMQswCQYDVQQGEwJTRTEU
MBIGA1UEChMLQWRkVHJ1c3QgQUIxHTAbBgNVBAsTFEFkZFRydXN0IFRUUCBOZXR3
b3JrMSMwIQYDVQQDExpBZGRUcnVzdCBRdWFsaWZpZWQgQ0EgUm9vdDAeFw0wMDA1
MzAxMDQ0NTBaFw0yMDA1MzAxMDQ0NTBaMGcxCzAJBgNVBAYTAlNFMRQwEgYDVQQK
EwtBZGRUcnVzdCBBQjEdMBsGA1UECxMUQWRkVHJ1c3QgVFRQIE5ldHdvcmsxIzAh
BgNVBAMTGkFkZFRydXN0IFF1YWxpZmllZCBDQSBSb290MIIBIjANBgkqhkiG9w0B
AQEFAAOCAQ8AMIIBCgKCAQEA5B6a/twJWoekn0e+EV+vhDTbYjx5eLfpMLXsDBwq
xBb/4Oxx64r1EW7tTw2R0hIYLUkVAcKkIhPHEWT/IhKauY5cLwjPcWqzZwFZ8V1G
87B4pfYOQnrjfxvM0PC3KP0q6p6zsLkEqv32x7SxuCqg+1jxGaBvcCV+PmlKfw8i
2O+tCBGaKZnhqkRFmhJePp1tUvznoD1oL/BLcHwTOK28FSXx1s6rosAx1i+f4P8U
WfyEk9mHfExUE+uf0S0R+Bg6Ot4l2ffTQO2kBhLEO+GRwVY18BTcZTYJbqukB8c1
0cIDMzZbdSZtQvESa0NvS3GU+jQd7RNuyoB/mC9suWXY6QIDAQABo4HUMIHRMB0G
A1UdDgQWBBQ5lYtii1zJ1IC6WA+XPxUIQ8yYpzALBgNVHQ8EBAMCAQYwDwYDVR0T
AQH/BAUwAwEB/zCBkQYDVR0jBIGJMIGGgBQ5lYtii1zJ1IC6WA+XPxUIQ8yYp6Fr
pGkwZzELMAkGA1UEBhMCU0UxFDASBgNVBAoTC0FkZFRydXN0IEFCMR0wGwYDVQQL
ExRBZGRUcnVzdCBUVFAgTmV0d29yazEjMCEGA1UEAxMaQWRkVHJ1c3QgUXVhbGlm
aWVkIENBIFJvb3SCAQEwDQYJKoZIhvcNAQEFBQADggEBABmrder4i2VhlRO6aQTv
hsoToMeqT2QbPxj2qC0sVY8FtzDqQmodwCVRLae/DLPt7wh/bDxGGuoYQ992zPlm
hpwsaPXpF/gxsxjE1kh9I0xowX67ARRvxdlu3rsEQmr49lx95dr6h+sNNVJn0J6X
dgWTP5XHAeZpVTh/EGGZyeNfpso+gmNIquIISD6q8rKFYqa0p9m9N5xotS1WfbC3
P6CxB9bpT9zeRXEwMn8bLgn5v1Kh7sKAPgZcLlVAwRv1cEWw3F369nJad9Jjzc9Y
iQBCYz95OdBEsIJuQRno3eDBiFrRHnGTHyQwdOUeqN48Jzd/g66ed8/wMLH/S5no
xqE=
-----END CERTIFICATE-----
# Issuer: CN=Entrust Root Certification Authority O=Entrust, Inc. OU=www.entrust.net/CPS is incorporated by reference/(c) 2006 Entrust, Inc.
# Subject: CN=Entrust Root Certification Authority O=Entrust, Inc. OU=www.entrust.net/CPS is incorporated by reference/(c) 2006 Entrust, Inc.
# Label: "Entrust Root Certification Authority"
# Serial: 1164660820
# MD5 Fingerprint: d6:a5:c3:ed:5d:dd:3e:00:c1:3d:87:92:1f:1d:3f:e4
# SHA1 Fingerprint: b3:1e:b1:b7:40:e3:6c:84:02:da:dc:37:d4:4d:f5:d4:67:49:52:f9
# SHA256 Fingerprint: 73:c1:76:43:4f:1b:c6:d5:ad:f4:5b:0e:76:e7:27:28:7c:8d:e5:76:16:c1:e6:e6:14:1a:2b:2c:bc:7d:8e:4c
-----BEGIN CERTIFICATE-----
MIIEkTCCA3mgAwIBAgIERWtQVDANBgkqhkiG9w0BAQUFADCBsDELMAkGA1UEBhMC
VVMxFjAUBgNVBAoTDUVudHJ1c3QsIEluYy4xOTA3BgNVBAsTMHd3dy5lbnRydXN0
Lm5ldC9DUFMgaXMgaW5jb3Jwb3JhdGVkIGJ5IHJlZmVyZW5jZTEfMB0GA1UECxMW
KGMpIDIwMDYgRW50cnVzdCwgSW5jLjEtMCsGA1UEAxMkRW50cnVzdCBSb290IENl
cnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA2MTEyNzIwMjM0MloXDTI2MTEyNzIw
NTM0MlowgbAxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1FbnRydXN0LCBJbmMuMTkw
NwYDVQQLEzB3d3cuZW50cnVzdC5uZXQvQ1BTIGlzIGluY29ycG9yYXRlZCBieSBy
ZWZlcmVuY2UxHzAdBgNVBAsTFihjKSAyMDA2IEVudHJ1c3QsIEluYy4xLTArBgNV
BAMTJEVudHJ1c3QgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASIwDQYJ
KoZIhvcNAQEBBQADggEPADCCAQoCggEBALaVtkNC+sZtKm9I35RMOVcF7sN5EUFo
Nu3s/poBj6E4KPz3EEZmLk0eGrEaTsbRwJWIsMn/MYszA9u3g3s+IIRe7bJWKKf4
4LlAcTfFy0cOlypowCKVYhXbR9n10Cv/gkvJrT7eTNuQgFA/CYqEAOwwCj0Yzfv9
KlmaI5UXLEWeH25DeW0MXJj+SKfFI0dcXv1u5x609mhF0YaDW6KKjbHjKYD+JXGI
rb68j6xSlkuqUY3kEzEZ6E5Nn9uss2rVvDlUccp6en+Q3X0dgNmBu1kmwhH+5pPi
94DkZfs0Nw4pgHBNrziGLp5/V6+eF67rHMsoIV+2HNjnogQi+dPa2MsCAwEAAaOB
sDCBrTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zArBgNVHRAEJDAi
gA8yMDA2MTEyNzIwMjM0MlqBDzIwMjYxMTI3MjA1MzQyWjAfBgNVHSMEGDAWgBRo
kORnpKZTgMeGZqTx90tD+4S9bTAdBgNVHQ4EFgQUaJDkZ6SmU4DHhmak8fdLQ/uE
vW0wHQYJKoZIhvZ9B0EABBAwDhsIVjcuMTo0LjADAgSQMA0GCSqGSIb3DQEBBQUA
A4IBAQCT1DCw1wMgKtD5Y+iRDAUgqV8ZyntyTtSx29CW+1RaGSwMCPeyvIWonX9t
O1KzKtvn1ISMY/YPyyYBkVBs9F8U4pN0wBOeMDpQ47RgxRzwIkSNcUesyBrJ6Zua
AGAT/3B+XxFNSRuzFVJ7yVTav52Vr2ua2J7p8eRDjeIRRDq/r72DQnNSi6q7pynP
9WQcCk3RvKqsnyrQ/39/2n3qse0wJcGE2jTSW3iDVuycNsMm4hH2Z0kdkquM++v/
eu6FSqdQgPCnXEqULl8FmTxSQeDNtGPPAUO6nIPcj2A781q0tHuu2guQOHXvgR1m
0vdXcDazv/wor3ElhVsT/h5/WrQ8
-----END CERTIFICATE-----
# Issuer: CN=GeoTrust Global CA O=GeoTrust Inc.
# Subject: CN=GeoTrust Global CA O=GeoTrust Inc.
# Label: "GeoTrust Global CA"
# Serial: 144470
# MD5 Fingerprint: f7:75:ab:29:fb:51:4e:b7:77:5e:ff:05:3c:99:8e:f5
# SHA1 Fingerprint: de:28:f4:a4:ff:e5:b9:2f:a3:c5:03:d1:a3:49:a7:f9:96:2a:82:12
# SHA256 Fingerprint: ff:85:6a:2d:25:1d:cd:88:d3:66:56:f4:50:12:67:98:cf:ab:aa:de:40:79:9c:72:2d:e4:d2:b5:db:36:a7:3a
-----BEGIN CERTIFICATE-----
MIIDVDCCAjygAwIBAgIDAjRWMA0GCSqGSIb3DQEBBQUAMEIxCzAJBgNVBAYTAlVT
MRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMRswGQYDVQQDExJHZW9UcnVzdCBHbG9i
YWwgQ0EwHhcNMDIwNTIxMDQwMDAwWhcNMjIwNTIxMDQwMDAwWjBCMQswCQYDVQQG
EwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEbMBkGA1UEAxMSR2VvVHJ1c3Qg
R2xvYmFsIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2swYYzD9
9BcjGlZ+W988bDjkcbd4kdS8odhM+KhDtgPpTSEHCIjaWC9mOSm9BXiLnTjoBbdq
fnGk5sRgprDvgOSJKA+eJdbtg/OtppHHmMlCGDUUna2YRpIuT8rxh0PBFpVXLVDv
iS2Aelet8u5fa9IAjbkU+BQVNdnARqN7csiRv8lVK83Qlz6cJmTM386DGXHKTubU
1XupGc1V3sjs0l44U+VcT4wt/lAjNvxm5suOpDkZALeVAjmRCw7+OC7RHQWa9k0+
bw8HHa8sHo9gOeL6NlMTOdReJivbPagUvTLrGAMoUgRx5aszPeE4uwc2hGKceeoW
MPRfwCvocWvk+QIDAQABo1MwUTAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTA
ephojYn7qwVkDBF9qn1luMrMTjAfBgNVHSMEGDAWgBTAephojYn7qwVkDBF9qn1l
uMrMTjANBgkqhkiG9w0BAQUFAAOCAQEANeMpauUvXVSOKVCUn5kaFOSPeCpilKIn
Z57QzxpeR+nBsqTP3UEaBU6bS+5Kb1VSsyShNwrrZHYqLizz/Tt1kL/6cdjHPTfS
tQWVYrmm3ok9Nns4d0iXrKYgjy6myQzCsplFAMfOEVEiIuCl6rYVSAlk6l5PdPcF
PseKUgzbFbS9bZvlxrFUaKnjaZC2mqUPuLk/IH2uSrW4nOQdtqvmlKXBx4Ot2/Un
hw4EbNX/3aBd7YdStysVAq45pmp06drE57xNNB6pXE0zX5IJL4hmXXeXxx12E6nV
5fEWCRE11azbJHFwLJhWC9kXtNHjUStedejV0NxPNO3CBWaAocvmMw==
-----END CERTIFICATE-----
# Issuer: CN=GeoTrust Global CA 2 O=GeoTrust Inc.
# Subject: CN=GeoTrust Global CA 2 O=GeoTrust Inc.
# Label: "GeoTrust Global CA 2"
# Serial: 1
# MD5 Fingerprint: 0e:40:a7:6c:de:03:5d:8f:d1:0f:e4:d1:8d:f9:6c:a9
# SHA1 Fingerprint: a9:e9:78:08:14:37:58:88:f2:05:19:b0:6d:2b:0d:2b:60:16:90:7d
# SHA256 Fingerprint: ca:2d:82:a0:86:77:07:2f:8a:b6:76:4f:f0:35:67:6c:fe:3e:5e:32:5e:01:21:72:df:3f:92:09:6d:b7:9b:85
-----BEGIN CERTIFICATE-----
MIIDZjCCAk6gAwIBAgIBATANBgkqhkiG9w0BAQUFADBEMQswCQYDVQQGEwJVUzEW
MBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEdMBsGA1UEAxMUR2VvVHJ1c3QgR2xvYmFs
IENBIDIwHhcNMDQwMzA0MDUwMDAwWhcNMTkwMzA0MDUwMDAwWjBEMQswCQYDVQQG
EwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEdMBsGA1UEAxMUR2VvVHJ1c3Qg
R2xvYmFsIENBIDIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDvPE1A
PRDfO1MA4Wf+lGAVPoWI8YkNkMgoI5kF6CsgncbzYEbYwbLVjDHZ3CB5JIG/NTL8
Y2nbsSpr7iFY8gjpeMtvy/wWUsiRxP89c96xPqfCfWbB9X5SJBri1WeR0IIQ13hL
TytCOb1kLUCgsBDTOEhGiKEMuzozKmKY+wCdE1l/bztyqu6mD4b5BWHqZ38MN5aL
5mkWRxHCJ1kDs6ZgwiFAVvqgx306E+PsV8ez1q6diYD3Aecs9pYrEw15LNnA5IZ7
S4wMcoKK+xfNAGw6EzywhIdLFnopsk/bHdQL82Y3vdj2V7teJHq4PIu5+pIaGoSe
2HSPqht/XvT+RSIhAgMBAAGjYzBhMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYE
FHE4NvICMVNHK266ZUapEBVYIAUJMB8GA1UdIwQYMBaAFHE4NvICMVNHK266ZUap
EBVYIAUJMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQUFAAOCAQEAA/e1K6td
EPx7srJerJsOflN4WT5CBP51o62sgU7XAotexC3IUnbHLB/8gTKY0UvGkpMzNTEv
/NgdRN3ggX+d6YvhZJFiCzkIjKx0nVnZellSlxG5FntvRdOW2TF9AjYPnDtuzywN
A0ZF66D0f0hExghAzN4bcLUprbqLOzRldRtxIR0sFAqwlpW41uryZfspuk/qkZN0
abby/+Ea0AzRdoXLiiW9l14sbxWZJue2Kf8i7MkCx1YAzUm5s2x7UwQa4qjJqhIF
I8LO57sEAszAR6LkxCkvW0VXiVHuPOtSCP8HNR6fNWpHSlaY0VqFH4z1Ir+rzoPz
4iIprn2DQKi6bA==
-----END CERTIFICATE-----
# Issuer: CN=GeoTrust Universal CA O=GeoTrust Inc.
# Subject: CN=GeoTrust Universal CA O=GeoTrust Inc.
# Label: "GeoTrust Universal CA"
# Serial: 1
# MD5 Fingerprint: 92:65:58:8b:a2:1a:31:72:73:68:5c:b4:a5:7a:07:48
# SHA1 Fingerprint: e6:21:f3:35:43:79:05:9a:4b:68:30:9d:8a:2f:74:22:15:87:ec:79
# SHA256 Fingerprint: a0:45:9b:9f:63:b2:25:59:f5:fa:5d:4c:6d:b3:f9:f7:2f:f1:93:42:03:35:78:f0:73:bf:1d:1b:46:cb:b9:12
-----BEGIN CERTIFICATE-----
MIIFaDCCA1CgAwIBAgIBATANBgkqhkiG9w0BAQUFADBFMQswCQYDVQQGEwJVUzEW
MBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEeMBwGA1UEAxMVR2VvVHJ1c3QgVW5pdmVy
c2FsIENBMB4XDTA0MDMwNDA1MDAwMFoXDTI5MDMwNDA1MDAwMFowRTELMAkGA1UE
BhMCVVMxFjAUBgNVBAoTDUdlb1RydXN0IEluYy4xHjAcBgNVBAMTFUdlb1RydXN0
IFVuaXZlcnNhbCBDQTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAKYV
VaCjxuAfjJ0hUNfBvitbtaSeodlyWL0AG0y/YckUHUWCq8YdgNY96xCcOq9tJPi8
cQGeBvV8Xx7BDlXKg5pZMK4ZyzBIle0iN430SppyZj6tlcDgFgDgEB8rMQ7XlFTT
QjOgNB0eRXbdT8oYN+yFFXoZCPzVx5zw8qkuEKmS5j1YPakWaDwvdSEYfyh3peFh
F7em6fgemdtzbvQKoiFs7tqqhZJmr/Z6a4LauiIINQ/PQvE1+mrufislzDoR5G2v
c7J2Ha3QsnhnGqQ5HFELZ1aD/ThdDc7d8Lsrlh/eezJS/R27tQahsiFepdaVaH/w
mZ7cRQg+59IJDTWU3YBOU5fXtQlEIGQWFwMCTFMNaN7VqnJNk22CDtucvc+081xd
VHppCZbW2xHBjXWotM85yM48vCR85mLK4b19p71XZQvk/iXttmkQ3CgaRr0BHdCX
teGYO8A3ZNY9lO4L4fUorgtWv3GLIylBjobFS1J72HGrH4oVpjuDWtdYAVHGTEHZ
f9hBZ3KiKN9gg6meyHv8U3NyWfWTehd2Ds735VzZC1U0oqpbtWpU5xPKV+yXbfRe
Bi9Fi1jUIxaS5BZuKGNZMN9QAZxjiRqf2xeUgnA3wySemkfWWspOqGmJch+RbNt+
nhutxx9z3SxPGWX9f5NAEC7S8O08ni4oPmkmM8V7AgMBAAGjYzBhMA8GA1UdEwEB
/wQFMAMBAf8wHQYDVR0OBBYEFNq7LqqwDLiIJlF0XG0D08DYj3rWMB8GA1UdIwQY
MBaAFNq7LqqwDLiIJlF0XG0D08DYj3rWMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG
9w0BAQUFAAOCAgEAMXjmx7XfuJRAyXHEqDXsRh3ChfMoWIawC/yOsjmPRFWrZIRc
aanQmjg8+uUfNeVE44B5lGiku8SfPeE0zTBGi1QrlaXv9z+ZhP015s8xxtxqv6fX
IwjhmF7DWgh2qaavdy+3YL1ERmrvl/9zlcGO6JP7/TG37FcREUWbMPEaiDnBTzyn
ANXH/KttgCJwpQzgXQQpAvvLoJHRfNbDflDVnVi+QTjruXU8FdmbyUqDWcDaU/0z
uzYYm4UPFd3uLax2k7nZAY1IEKj79TiG8dsKxr2EoyNB3tZ3b4XUhRxQ4K5RirqN
Pnbiucon8l+f725ZDQbYKxek0nxru18UGkiPGkzns0ccjkxFKyDuSN/n3QmOGKja
QI2SJhFTYXNd673nxE0pN2HrrDktZy4W1vUAg4WhzH92xH3kt0tm7wNFYGm2DFKW
koRepqO1pD4r2czYG0eq8kTaT/kD6PAUyz/zg97QwVTjt+gKN02LIFkDMBmhLMi9
ER/frslKxfMnZmaGrGiR/9nmUxwPi1xpZQomyB40w11Re9epnAahNt3ViZS82eQt
DF4JbAiXfKM9fJP/P6EUp8+1Xevb2xzEdt+Iub1FBZUbrvxGakyvSOPOrg/Sfuvm
bJxPgWp6ZKy7PtXny3YuxadIwVyQD8vIP/rmMuGNG2+k5o7Y+SlIis5z/iw=
-----END CERTIFICATE-----
# Issuer: CN=GeoTrust Universal CA 2 O=GeoTrust Inc.
# Subject: CN=GeoTrust Universal CA 2 O=GeoTrust Inc.
# Label: "GeoTrust Universal CA 2"
# Serial: 1
# MD5 Fingerprint: 34:fc:b8:d0:36:db:9e:14:b3:c2:f2:db:8f:e4:94:c7
# SHA1 Fingerprint: 37:9a:19:7b:41:85:45:35:0c:a6:03:69:f3:3c:2e:af:47:4f:20:79
# SHA256 Fingerprint: a0:23:4f:3b:c8:52:7c:a5:62:8e:ec:81:ad:5d:69:89:5d:a5:68:0d:c9:1d:1c:b8:47:7f:33:f8:78:b9:5b:0b
-----BEGIN CERTIFICATE-----
MIIFbDCCA1SgAwIBAgIBATANBgkqhkiG9w0BAQUFADBHMQswCQYDVQQGEwJVUzEW
MBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEgMB4GA1UEAxMXR2VvVHJ1c3QgVW5pdmVy
c2FsIENBIDIwHhcNMDQwMzA0MDUwMDAwWhcNMjkwMzA0MDUwMDAwWjBHMQswCQYD
VQQGEwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEgMB4GA1UEAxMXR2VvVHJ1
c3QgVW5pdmVyc2FsIENBIDIwggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoIC
AQCzVFLByT7y2dyxUxpZKeexw0Uo5dfR7cXFS6GqdHtXr0om/Nj1XqduGdt0DE81
WzILAePb63p3NeqqWuDW6KFXlPCQo3RWlEQwAx5cTiuFJnSCegx2oG9NzkEtoBUG
FF+3Qs17j1hhNNwqCPkuwwGmIkQcTAeC5lvO0Ep8BNMZcyfwqph/Lq9O64ceJHdq
XbboW0W63MOhBW9Wjo8QJqVJwy7XQYci4E+GymC16qFjwAGXEHm9ADwSbSsVsaxL
se4YuU6W3Nx2/zu+z18DwPw76L5GG//aQMJS9/7jOvdqdzXQ2o3rXhhqMcceujwb
KNZrVMaqW9eiLBsZzKIC9ptZvTdrhrVtgrrY6slWvKk2WP0+GfPtDCapkzj4T8Fd
IgbQl+rhrcZV4IErKIM6+vR7IVEAvlI4zs1meaj0gVbi0IMJR1FbUGrP20gaXT73
y/Zl92zxlfgCOzJWgjl6W70viRu/obTo/3+NjN8D8WBOWBFM66M/ECuDmgFz2ZRt
hAAnZqzwcEAJQpKtT5MNYQlRJNiS1QuUYbKHsu3/mjX/hVTK7URDrBs8FmtISgoc
QIgfksILAAX/8sgCSqSqqcyZlpwvWOB94b67B9xfBHJcMTTD7F8t4D1kkCLm0ey4
Lt1ZrtmhN79UNdxzMk+MBB4zsslG8dhcyFVQyWi9qLo2CQIDAQABo2MwYTAPBgNV
HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR281Xh+qQ2+/CfXGJx7Tz0RzgQKzAfBgNV
HSMEGDAWgBR281Xh+qQ2+/CfXGJx7Tz0RzgQKzAOBgNVHQ8BAf8EBAMCAYYwDQYJ
KoZIhvcNAQEFBQADggIBAGbBxiPz2eAubl/oz66wsCVNK/g7WJtAJDday6sWSf+z
dXkzoS9tcBc0kf5nfo/sm+VegqlVHy/c1FEHEv6sFj4sNcZj/NwQ6w2jqtB8zNHQ
L1EuxBRa3ugZ4T7GzKQp5y6EqgYweHZUcyiYWTjgAA1i00J9IZ+uPTqM1fp3DRgr
Fg5fNuH8KrUwJM/gYwx7WBr+mbpCErGR9Hxo4sjoryzqyX6uuyo9DRXcNJW2GHSo
ag/HtPQTxORb7QrSpJdMKu0vbBKJPfEncKpqA1Ihn0CoZ1Dy81of398j9tx4TuaY
T1U6U+Pv8vSfx3zYWK8pIpe44L2RLrB27FcRz+8pRPPphXpgY+RdM4kX2TGq2tbz
GDVyz4crL2MjhF2EjD9XoIj8mZEoJmmZ1I+XRL6O1UixpCgp8RW04eWe3fiPpm8m
1wk8OhwRDqZsN/etRIcsKMfYdIKz0G9KV7s1KSegi+ghp4dkNl3M2Basx7InQJJV
OCiNUW7dFGdTbHFcJoRNdVq2fmBWqU2t+5sel/MN2dKXVHfaPRK34B7vCAas+YWH
6aLcr34YEoP9VhdBLtUpgn2Z9DH2canPLAEnpQW5qrJITirvn5NSUZU8UnOOVkwX
QMAJKOSLakhT2+zNVVXxxvjpoixMptEmX36vWkzaH6byHCx+rgIW0lbQL1dTR+iS
-----END CERTIFICATE-----
# Issuer: CN=America Online Root Certification Authority 1 O=America Online Inc.
# Subject: CN=America Online Root Certification Authority 1 O=America Online Inc.
# Label: "America Online Root Certification Authority 1"
# Serial: 1
# MD5 Fingerprint: 14:f1:08:ad:9d:fa:64:e2:89:e7:1c:cf:a8:ad:7d:5e
# SHA1 Fingerprint: 39:21:c1:15:c1:5d:0e:ca:5c:cb:5b:c4:f0:7d:21:d8:05:0b:56:6a
# SHA256 Fingerprint: 77:40:73:12:c6:3a:15:3d:5b:c0:0b:4e:51:75:9c:df:da:c2:37:dc:2a:33:b6:79:46:e9:8e:9b:fa:68:0a:e3
-----BEGIN CERTIFICATE-----
MIIDpDCCAoygAwIBAgIBATANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJVUzEc
MBoGA1UEChMTQW1lcmljYSBPbmxpbmUgSW5jLjE2MDQGA1UEAxMtQW1lcmljYSBP
bmxpbmUgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAxMB4XDTAyMDUyODA2
MDAwMFoXDTM3MTExOTIwNDMwMFowYzELMAkGA1UEBhMCVVMxHDAaBgNVBAoTE0Ft
ZXJpY2EgT25saW5lIEluYy4xNjA0BgNVBAMTLUFtZXJpY2EgT25saW5lIFJvb3Qg
Q2VydGlmaWNhdGlvbiBBdXRob3JpdHkgMTCCASIwDQYJKoZIhvcNAQEBBQADggEP
ADCCAQoCggEBAKgv6KRpBgNHw+kqmP8ZonCaxlCyfqXfaE0bfA+2l2h9LaaLl+lk
hsmj76CGv2BlnEtUiMJIxUo5vxTjWVXlGbR0yLQFOVwWpeKVBeASrlmLojNoWBym
1BW32J/X3HGrfpq/m44zDyL9Hy7nBzbvYjnF3cu6JRQj3gzGPTzOggjmZj7aUTsW
OqMFf6Dch9Wc/HKpoH145LcxVR5lu9RhsCFg7RAycsWSJR74kEoYeEfffjA3PlAb
2xzTa5qGUwew76wGePiEmf4hjUyAtgyC9mZweRrTT6PP8c9GsEsPPt2IYriMqQko
O3rHl+Ee5fSfwMCuJKDIodkP1nsmgmkyPacCAwEAAaNjMGEwDwYDVR0TAQH/BAUw
AwEB/zAdBgNVHQ4EFgQUAK3Zo/Z59m50qX8zPYEX10zPM94wHwYDVR0jBBgwFoAU
AK3Zo/Z59m50qX8zPYEX10zPM94wDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEB
BQUAA4IBAQB8itEfGDeC4Liwo+1WlchiYZwFos3CYiZhzRAW18y0ZTTQEYqtqKkF
Zu90821fnZmv9ov761KyBZiibyrFVL0lvV+uyIbqRizBs73B6UlwGBaXCBOMIOAb
LjpHyx7kADCVW/RFo8AasAFOq73AI25jP4BKxQft3OJvx8Fi8eNy1gTIdGcL+oir
oQHIb/AUr9KZzVGTfu0uOMe9zkZQPXLjeSWdm4grECDdpbgyn43gKd8hdIaC2y+C
MMbHNYaz+ZZfRtsMRf3zUMNvxsNIrUam4SdHCh0Om7bCd39j8uB9Gr784N/Xx6ds
sPmuujz9dLQR6FgNgLzTqIA6me11zEZ7
-----END CERTIFICATE-----
# Issuer: CN=America Online Root Certification Authority 2 O=America Online Inc.
# Subject: CN=America Online Root Certification Authority 2 O=America Online Inc.
# Label: "America Online Root Certification Authority 2"
# Serial: 1
# MD5 Fingerprint: d6:ed:3c:ca:e2:66:0f:af:10:43:0d:77:9b:04:09:bf
# SHA1 Fingerprint: 85:b5:ff:67:9b:0c:79:96:1f:c8:6e:44:22:00:46:13:db:17:92:84
# SHA256 Fingerprint: 7d:3b:46:5a:60:14:e5:26:c0:af:fc:ee:21:27:d2:31:17:27:ad:81:1c:26:84:2d:00:6a:f3:73:06:cc:80:bd
-----BEGIN CERTIFICATE-----
MIIFpDCCA4ygAwIBAgIBATANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJVUzEc
MBoGA1UEChMTQW1lcmljYSBPbmxpbmUgSW5jLjE2MDQGA1UEAxMtQW1lcmljYSBP
bmxpbmUgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eSAyMB4XDTAyMDUyODA2
MDAwMFoXDTM3MDkyOTE0MDgwMFowYzELMAkGA1UEBhMCVVMxHDAaBgNVBAoTE0Ft
ZXJpY2EgT25saW5lIEluYy4xNjA0BgNVBAMTLUFtZXJpY2EgT25saW5lIFJvb3Qg
Q2VydGlmaWNhdGlvbiBBdXRob3JpdHkgMjCCAiIwDQYJKoZIhvcNAQEBBQADggIP
ADCCAgoCggIBAMxBRR3pPU0Q9oyxQcngXssNt79Hc9PwVU3dxgz6sWYFas14tNwC
206B89enfHG8dWOgXeMHDEjsJcQDIPT/DjsS/5uN4cbVG7RtIuOx238hZK+GvFci
KtZHgVdEglZTvYYUAQv8f3SkWq7xuhG1m1hagLQ3eAkzfDJHA1zEpYNI9FdWboE2
JxhP7JsowtS013wMPgwr38oE18aO6lhOqKSlGBxsRZijQdEt0sdtjRnxrXm3gT+9
BoInLRBYBbV4Bbkv2wxrkJB+FFk4u5QkE+XRnRTf04JNRvCAOVIyD+OEsnpD8l7e
Xz8d3eOyG6ChKiMDbi4BFYdcpnV1x5dhvt6G3NRI270qv0pV2uh9UPu0gBe4lL8B
PeraunzgWGcXuVjgiIZGZ2ydEEdYMtA1fHkqkKJaEBEjNa0vzORKW6fIJ/KD3l67
Xnfn6KVuY8INXWHQjNJsWiEOyiijzirplcdIz5ZvHZIlyMbGwcEMBawmxNJ10uEq
Z8A9W6Wa6897GqidFEXlD6CaZd4vKL3Ob5Rmg0gp2OpljK+T2WSfVVcmv2/LNzGZ
o2C7HK2JNDJiuEMhBnIMoVxtRsX6Kc8w3onccVvdtjc+31D1uAclJuW8tf48ArO3
+L5DwYcRlJ4jbBeKuIonDFRH8KmzwICMoCfrHRnjB453cMor9H124HhnAgMBAAGj
YzBhMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFE1FwWg4u3OpaaEg5+31IqEj
FNeeMB8GA1UdIwQYMBaAFE1FwWg4u3OpaaEg5+31IqEjFNeeMA4GA1UdDwEB/wQE
AwIBhjANBgkqhkiG9w0BAQUFAAOCAgEAZ2sGuV9FOypLM7PmG2tZTiLMubekJcmn
xPBUlgtk87FYT15R/LKXeydlwuXK5w0MJXti4/qftIe3RUavg6WXSIylvfEWK5t2
LHo1YGwRgJfMqZJS5ivmae2p+DYtLHe/YUjRYwu5W1LtGLBDQiKmsXeu3mnFzccc
obGlHBD7GL4acN3Bkku+KVqdPzW+5X1R+FXgJXUjhx5c3LqdsKyzadsXg8n33gy8
CNyRnqjQ1xU3c6U1uPx+xURABsPr+CKAXEfOAuMRn0T//ZoyzH1kUQ7rVyZ2OuMe
IjzCpjbdGe+n/BLzJsBZMYVMnNjP36TMzCmT/5RtdlwTCJfy7aULTd3oyWgOZtMA
DjMSW7yV5TKQqLPGbIOtd+6Lfn6xqavT4fG2wLHqiMDn05DpKJKUe2h7lyoKZy2F
AjgQ5ANh1NolNscIWC2hp1GvMApJ9aZphwctREZ2jirlmjvXGKL8nDgQzMY70rUX
Om/9riW99XJZZLF0KjhfGEzfz3EEWjbUvy+ZnOjZurGV5gJLIaFb1cFPj65pbVPb
AZO1XB4Y3WRayhgoPmMEEf0cjQAPuDffZ4qdZqkCapH/E8ovXYO8h5Ns3CRRFgQl
Zvqz2cK6Kb6aSDiCmfS/O0oxGfm/jiEzFMpPVF/7zvuPcX/9XhmgD0uRuMRUvAaw
RY8mkaKO/qk=
-----END CERTIFICATE-----
# Issuer: CN=AAA Certificate Services O=Comodo CA Limited
# Subject: CN=AAA Certificate Services O=Comodo CA Limited
# Label: "Comodo AAA Services root"
# Serial: 1
# MD5 Fingerprint: 49:79:04:b0:eb:87:19:ac:47:b0:bc:11:51:9b:74:d0
# SHA1 Fingerprint: d1:eb:23:a4:6d:17:d6:8f:d9:25:64:c2:f1:f1:60:17:64:d8:e3:49
# SHA256 Fingerprint: d7:a7:a0:fb:5d:7e:27:31:d7:71:e9:48:4e:bc:de:f7:1d:5f:0c:3e:0a:29:48:78:2b:c8:3e:e0:ea:69:9e:f4
-----BEGIN CERTIFICATE-----
MIIEMjCCAxqgAwIBAgIBATANBgkqhkiG9w0BAQUFADB7MQswCQYDVQQGEwJHQjEb
MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow
GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDEhMB8GA1UEAwwYQUFBIENlcnRpZmlj
YXRlIFNlcnZpY2VzMB4XDTA0MDEwMTAwMDAwMFoXDTI4MTIzMTIzNTk1OVowezEL
MAkGA1UEBhMCR0IxGzAZBgNVBAgMEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE
BwwHU2FsZm9yZDEaMBgGA1UECgwRQ29tb2RvIENBIExpbWl0ZWQxITAfBgNVBAMM
GEFBQSBDZXJ0aWZpY2F0ZSBTZXJ2aWNlczCCASIwDQYJKoZIhvcNAQEBBQADggEP
ADCCAQoCggEBAL5AnfRu4ep2hxxNRUSOvkbIgwadwSr+GB+O5AL686tdUIoWMQua
BtDFcCLNSS1UY8y2bmhGC1Pqy0wkwLxyTurxFa70VJoSCsN6sjNg4tqJVfMiWPPe
3M/vg4aijJRPn2jymJBGhCfHdr/jzDUsi14HZGWCwEiwqJH5YZ92IFCokcdmtet4
YgNW8IoaE+oxox6gmf049vYnMlhvB/VruPsUK6+3qszWY19zjNoFmag4qMsXeDZR
rOme9Hg6jc8P2ULimAyrL58OAd7vn5lJ8S3frHRNG5i1R8XlKdH5kBjHYpy+g8cm
ez6KJcfA3Z3mNWgQIJ2P2N7Sw4ScDV7oL8kCAwEAAaOBwDCBvTAdBgNVHQ4EFgQU
oBEKIz6W8Qfs4q8p74Klf9AwpLQwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQF
MAMBAf8wewYDVR0fBHQwcjA4oDagNIYyaHR0cDovL2NybC5jb21vZG9jYS5jb20v
QUFBQ2VydGlmaWNhdGVTZXJ2aWNlcy5jcmwwNqA0oDKGMGh0dHA6Ly9jcmwuY29t
b2RvLm5ldC9BQUFDZXJ0aWZpY2F0ZVNlcnZpY2VzLmNybDANBgkqhkiG9w0BAQUF
AAOCAQEACFb8AvCb6P+k+tZ7xkSAzk/ExfYAWMymtrwUSWgEdujm7l3sAg9g1o1Q
GE8mTgHj5rCl7r+8dFRBv/38ErjHT1r0iWAFf2C3BUrz9vHCv8S5dIa2LX1rzNLz
Rt0vxuBqw8M0Ayx9lt1awg6nCpnBBYurDC/zXDrPbDdVCYfeU0BsWO/8tqtlbgT2
G9w84FoVxp7Z8VlIMCFlA2zs6SFz7JsDoeA3raAVGI/6ugLOpyypEBMs1OUIJqsi
l2D4kF501KKaU73yqWjgom7C12yxow+ev+to51byrvLjKzg6CYG1a4XXvi3tPxq3
smPi9WIsgtRqAEFQ8TmDn5XpNpaYbg==
-----END CERTIFICATE-----
# Issuer: CN=Secure Certificate Services O=Comodo CA Limited
# Subject: CN=Secure Certificate Services O=Comodo CA Limited
# Label: "Comodo Secure Services root"
# Serial: 1
# MD5 Fingerprint: d3:d9:bd:ae:9f:ac:67:24:b3:c8:1b:52:e1:b9:a9:bd
# SHA1 Fingerprint: 4a:65:d5:f4:1d:ef:39:b8:b8:90:4a:4a:d3:64:81:33:cf:c7:a1:d1
# SHA256 Fingerprint: bd:81:ce:3b:4f:65:91:d1:1a:67:b5:fc:7a:47:fd:ef:25:52:1b:f9:aa:4e:18:b9:e3:df:2e:34:a7:80:3b:e8
-----BEGIN CERTIFICATE-----
MIIEPzCCAyegAwIBAgIBATANBgkqhkiG9w0BAQUFADB+MQswCQYDVQQGEwJHQjEb
MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow
GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDEkMCIGA1UEAwwbU2VjdXJlIENlcnRp
ZmljYXRlIFNlcnZpY2VzMB4XDTA0MDEwMTAwMDAwMFoXDTI4MTIzMTIzNTk1OVow
fjELMAkGA1UEBhMCR0IxGzAZBgNVBAgMEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G
A1UEBwwHU2FsZm9yZDEaMBgGA1UECgwRQ29tb2RvIENBIExpbWl0ZWQxJDAiBgNV
BAMMG1NlY3VyZSBDZXJ0aWZpY2F0ZSBTZXJ2aWNlczCCASIwDQYJKoZIhvcNAQEB
BQADggEPADCCAQoCggEBAMBxM4KK0HDrc4eCQNUd5MvJDkKQ+d40uaG6EfQlhfPM
cm3ye5drswfxdySRXyWP9nQ95IDC+DwN879A6vfIUtFyb+/Iq0G4bi4XKpVpDM3S
HpR7LZQdqnXXs5jLrLxkU0C8j6ysNstcrbvd4JQX7NFc0L/vpZXJkMWwrPsbQ996
CF23uPJAGysnnlDOXmWCiIxe004MeuoIkbY2qitC++rCoznl2yY4rYsK7hljxxwk
3wN42ubqwUcaCwtGCd0C/N7Lh1/XMGNooa7cMqG6vv5Eq2i2pRcV/b3Vp6ea5EQz
6YiO/O1R65NxTq0B50SOqy3LqP4BSUjwwN3HaNiS/j0CAwEAAaOBxzCBxDAdBgNV
HQ4EFgQUPNiTiMLAggnMAZkGkyDpnnAJY08wDgYDVR0PAQH/BAQDAgEGMA8GA1Ud
EwEB/wQFMAMBAf8wgYEGA1UdHwR6MHgwO6A5oDeGNWh0dHA6Ly9jcmwuY29tb2Rv
Y2EuY29tL1NlY3VyZUNlcnRpZmljYXRlU2VydmljZXMuY3JsMDmgN6A1hjNodHRw
Oi8vY3JsLmNvbW9kby5uZXQvU2VjdXJlQ2VydGlmaWNhdGVTZXJ2aWNlcy5jcmww
DQYJKoZIhvcNAQEFBQADggEBAIcBbSMdflsXfcFhMs+P5/OKlFlm4J4oqF7Tt/Q0
5qo5spcWxYJvMqTpjOev/e/C6LlLqqP05tqNZSH7uoDrJiiFGv45jN5bBAS0VPmj
Z55B+glSzAVIqMk/IQQezkhr/IXownuvf7fM+F86/TXGDe+X3EyrEeFryzHRbPtI
gKvcnDe4IRRLDXE97IMzbtFuMhbsmMcWi1mmNKsFVy2T96oTy9IT4rcuO81rUBcJ
aD61JlfutuC23bkpgHl9j6PwpCikFcSF9CfUa7/lXORlAnZUtOM3ZiTTGWHIUhDl
izeauan5Hb/qmZJhlv8BzaFfDbxxvA6sCx1HRR3B7Hzs/Sk=
-----END CERTIFICATE-----
# Issuer: CN=Trusted Certificate Services O=Comodo CA Limited
# Subject: CN=Trusted Certificate Services O=Comodo CA Limited
# Label: "Comodo Trusted Services root"
# Serial: 1
# MD5 Fingerprint: 91:1b:3f:6e:cd:9e:ab:ee:07:fe:1f:71:d2:b3:61:27
# SHA1 Fingerprint: e1:9f:e3:0e:8b:84:60:9e:80:9b:17:0d:72:a8:c5:ba:6e:14:09:bd
# SHA256 Fingerprint: 3f:06:e5:56:81:d4:96:f5:be:16:9e:b5:38:9f:9f:2b:8f:f6:1e:17:08:df:68:81:72:48:49:cd:5d:27:cb:69
-----BEGIN CERTIFICATE-----
MIIEQzCCAyugAwIBAgIBATANBgkqhkiG9w0BAQUFADB/MQswCQYDVQQGEwJHQjEb
MBkGA1UECAwSR3JlYXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHDAdTYWxmb3JkMRow
GAYDVQQKDBFDb21vZG8gQ0EgTGltaXRlZDElMCMGA1UEAwwcVHJ1c3RlZCBDZXJ0
aWZpY2F0ZSBTZXJ2aWNlczAeFw0wNDAxMDEwMDAwMDBaFw0yODEyMzEyMzU5NTla
MH8xCzAJBgNVBAYTAkdCMRswGQYDVQQIDBJHcmVhdGVyIE1hbmNoZXN0ZXIxEDAO
BgNVBAcMB1NhbGZvcmQxGjAYBgNVBAoMEUNvbW9kbyBDQSBMaW1pdGVkMSUwIwYD
VQQDDBxUcnVzdGVkIENlcnRpZmljYXRlIFNlcnZpY2VzMIIBIjANBgkqhkiG9w0B
AQEFAAOCAQ8AMIIBCgKCAQEA33FvNlhTWvI2VFeAxHQIIO0Yfyod5jWaHiWsnOWW
fnJSoBVC21ndZHoa0Lh73TkVvFVIxO06AOoxEbrycXQaZ7jPM8yoMa+j49d/vzMt
TGo87IvDktJTdyR0nAducPy9C1t2ul/y/9c3S0pgePfw+spwtOpZqqPOSC+pw7IL
fhdyFgymBwwbOM/JYrc/oJOlh0Hyt3BAd9i+FHzjqMB6juljatEPmsbS9Is6FARW
1O24zG71++IsWL1/T2sr92AkWCTOJu80kTrV44HQsvAEAtdbtz6SrGsSivnkBbA7
kUlcsutT6vifR4buv5XAwAaf0lteERv0xwQ1KdJVXOTt6wIDAQABo4HJMIHGMB0G
A1UdDgQWBBTFe1i97doladL3WRaoszLAeydb9DAOBgNVHQ8BAf8EBAMCAQYwDwYD
VR0TAQH/BAUwAwEB/zCBgwYDVR0fBHwwejA8oDqgOIY2aHR0cDovL2NybC5jb21v
ZG9jYS5jb20vVHJ1c3RlZENlcnRpZmljYXRlU2VydmljZXMuY3JsMDqgOKA2hjRo
dHRwOi8vY3JsLmNvbW9kby5uZXQvVHJ1c3RlZENlcnRpZmljYXRlU2VydmljZXMu
Y3JsMA0GCSqGSIb3DQEBBQUAA4IBAQDIk4E7ibSvuIQSTI3S8NtwuleGFTQQuS9/
HrCoiWChisJ3DFBKmwCL2Iv0QeLQg4pKHBQGsKNoBXAxMKdTmw7pSqBYaWcOrp32
pSxBvzwGa+RZzG0Q8ZZvH9/0BAKkn0U+yNj6NkZEUD+Cl5EfKNsYEYwq5GWDVxIS
jBc/lDb+XbDABHcTuPQV1T84zJQ6VdCsmPW6AF/ghhmBeC8owH7TzEIK9a5QoNE+
xqFx7D+gIIxmOom0jtTYsU0lR+4viMi14QVFwL4Ucd56/Y57fU0IlqUSc/Atyjcn
dBInTMu2l+nZrghtWjlA3QVHdWpaIbOjGM9O9y5Xt5hwXsjEeLBi
-----END CERTIFICATE-----
# Issuer: CN=UTN - DATACorp SGC O=The USERTRUST Network OU=http://www.usertrust.com
# Subject: CN=UTN - DATACorp SGC O=The USERTRUST Network OU=http://www.usertrust.com
# Label: "UTN DATACorp SGC Root CA"
# Serial: 91374294542884689855167577680241077609
# MD5 Fingerprint: b3:a5:3e:77:21:6d:ac:4a:c0:c9:fb:d5:41:3d:ca:06
# SHA1 Fingerprint: 58:11:9f:0e:12:82:87:ea:50:fd:d9:87:45:6f:4f:78:dc:fa:d6:d4
# SHA256 Fingerprint: 85:fb:2f:91:dd:12:27:5a:01:45:b6:36:53:4f:84:02:4a:d6:8b:69:b8:ee:88:68:4f:f7:11:37:58:05:b3:48
-----BEGIN CERTIFICATE-----
MIIEXjCCA0agAwIBAgIQRL4Mi1AAIbQR0ypoBqmtaTANBgkqhkiG9w0BAQUFADCB
kzELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2Ug
Q2l0eTEeMBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExho
dHRwOi8vd3d3LnVzZXJ0cnVzdC5jb20xGzAZBgNVBAMTElVUTiAtIERBVEFDb3Jw
IFNHQzAeFw05OTA2MjQxODU3MjFaFw0xOTA2MjQxOTA2MzBaMIGTMQswCQYDVQQG
EwJVUzELMAkGA1UECBMCVVQxFzAVBgNVBAcTDlNhbHQgTGFrZSBDaXR5MR4wHAYD
VQQKExVUaGUgVVNFUlRSVVNUIE5ldHdvcmsxITAfBgNVBAsTGGh0dHA6Ly93d3cu
dXNlcnRydXN0LmNvbTEbMBkGA1UEAxMSVVROIC0gREFUQUNvcnAgU0dDMIIBIjAN
BgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA3+5YEKIrblXEjr8uRgnn4AgPLit6
E5Qbvfa2gI5lBZMAHryv4g+OGQ0SR+ysraP6LnD43m77VkIVni5c7yPeIbkFdicZ
D0/Ww5y0vpQZY/KmEQrrU0icvvIpOxboGqBMpsn0GFlowHDyUwDAXlCCpVZvNvlK
4ESGoE1O1kduSUrLZ9emxAW5jh70/P/N5zbgnAVssjMiFdC04MwXwLLA9P4yPykq
lXvY8qdOD1R8oQ2AswkDwf9c3V6aPryuvEeKaq5xyh+xKrhfQgUL7EYw0XILyulW
bfXv33i+Ybqypa4ETLyorGkVl73v67SMvzX41MPRKA5cOp9wGDMgd8SirwIDAQAB
o4GrMIGoMAsGA1UdDwQEAwIBxjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRT
MtGzz3/64PGgXYVOktKeRR20TzA9BgNVHR8ENjA0MDKgMKAuhixodHRwOi8vY3Js
LnVzZXJ0cnVzdC5jb20vVVROLURBVEFDb3JwU0dDLmNybDAqBgNVHSUEIzAhBggr
BgEFBQcDAQYKKwYBBAGCNwoDAwYJYIZIAYb4QgQBMA0GCSqGSIb3DQEBBQUAA4IB
AQAnNZcAiosovcYzMB4p/OL31ZjUQLtgyr+rFywJNn9Q+kHcrpY6CiM+iVnJowft
Gzet/Hy+UUla3joKVAgWRcKZsYfNjGjgaQPpxE6YsjuMFrMOoAyYUJuTqXAJyCyj
j98C5OBxOvG0I3KgqgHf35g+FFCgMSa9KOlaMCZ1+XtgHI3zzVAmbQQnmt/VDUVH
KWss5nbZqSl9Mt3JNjy9rjXxEZ4du5A/EkdOjtd+D2JzHVImOBwYSf0wdJrE5SIv
2MCN7ZF6TACPcn9d2t0bi0Vr591pl6jFVkwPDPafepE39peC4N1xaf92P2BNPM/3
mfnGV/TJVTl4uix5yaaIK/QI
-----END CERTIFICATE-----
# Issuer: CN=UTN-USERFirst-Hardware O=The USERTRUST Network OU=http://www.usertrust.com
# Subject: CN=UTN-USERFirst-Hardware O=The USERTRUST Network OU=http://www.usertrust.com
# Label: "UTN USERFirst Hardware Root CA"
# Serial: 91374294542884704022267039221184531197
# MD5 Fingerprint: 4c:56:41:e5:0d:bb:2b:e8:ca:a3:ed:18:08:ad:43:39
# SHA1 Fingerprint: 04:83:ed:33:99:ac:36:08:05:87:22:ed:bc:5e:46:00:e3:be:f9:d7
# SHA256 Fingerprint: 6e:a5:47:41:d0:04:66:7e:ed:1b:48:16:63:4a:a3:a7:9e:6e:4b:96:95:0f:82:79:da:fc:8d:9b:d8:81:21:37
-----BEGIN CERTIFICATE-----
MIIEdDCCA1ygAwIBAgIQRL4Mi1AAJLQR0zYq/mUK/TANBgkqhkiG9w0BAQUFADCB
lzELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2Ug
Q2l0eTEeMBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExho
dHRwOi8vd3d3LnVzZXJ0cnVzdC5jb20xHzAdBgNVBAMTFlVUTi1VU0VSRmlyc3Qt
SGFyZHdhcmUwHhcNOTkwNzA5MTgxMDQyWhcNMTkwNzA5MTgxOTIyWjCBlzELMAkG
A1UEBhMCVVMxCzAJBgNVBAgTAlVUMRcwFQYDVQQHEw5TYWx0IExha2UgQ2l0eTEe
MBwGA1UEChMVVGhlIFVTRVJUUlVTVCBOZXR3b3JrMSEwHwYDVQQLExhodHRwOi8v
d3d3LnVzZXJ0cnVzdC5jb20xHzAdBgNVBAMTFlVUTi1VU0VSRmlyc3QtSGFyZHdh
cmUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCx98M4P7Sof885glFn
0G2f0v9Y8+efK+wNiVSZuTiZFvfgIXlIwrthdBKWHTxqctU8EGc6Oe0rE81m65UJ
M6Rsl7HoxuzBdXmcRl6Nq9Bq/bkqVRcQVLMZ8Jr28bFdtqdt++BxF2uiiPsA3/4a
MXcMmgF6sTLjKwEHOG7DpV4jvEWbe1DByTCP2+UretNb+zNAHqDVmBe8i4fDidNd
oI6yqqr2jmmIBsX6iSHzCJ1pLgkzmykNRg+MzEk0sGlRvfkGzWitZky8PqxhvQqI
DsjfPe58BEydCl5rkdbux+0ojatNh4lz0G6k0B4WixThdkQDf2Os5M1JnMWS9Ksy
oUhbAgMBAAGjgbkwgbYwCwYDVR0PBAQDAgHGMA8GA1UdEwEB/wQFMAMBAf8wHQYD
VR0OBBYEFKFyXyYbKJhDlV0HN9WFlp1L0sNFMEQGA1UdHwQ9MDswOaA3oDWGM2h0
dHA6Ly9jcmwudXNlcnRydXN0LmNvbS9VVE4tVVNFUkZpcnN0LUhhcmR3YXJlLmNy
bDAxBgNVHSUEKjAoBggrBgEFBQcDAQYIKwYBBQUHAwUGCCsGAQUFBwMGBggrBgEF
BQcDBzANBgkqhkiG9w0BAQUFAAOCAQEARxkP3nTGmZev/K0oXnWO6y1n7k57K9cM
//bey1WiCuFMVGWTYGufEpytXoMs61quwOQt9ABjHbjAbPLPSbtNk28Gpgoiskli
CE7/yMgUsogWXecB5BKV5UU0s4tpvc+0hY91UZ59Ojg6FEgSxvunOxqNDYJAB+gE
CJChicsZUN/KHAG8HQQZexB2lzvukJDKxA4fFm517zP4029bHpbj4HR3dHuKom4t
3XbWOTCC8KucUvIqx69JXn7HaOWCgchqJ/kniCrVWFCVH/A7HFe7fRQ5YiuayZSS
KqMiDP+JJn1fIytH1xUdqWqeUQ0qUZ6B+dQ7XnASfxAynB67nfhmqA==
-----END CERTIFICATE-----
# Issuer: CN=XRamp Global Certification Authority O=XRamp Security Services Inc OU=www.xrampsecurity.com
# Subject: CN=XRamp Global Certification Authority O=XRamp Security Services Inc OU=www.xrampsecurity.com
# Label: "XRamp Global CA Root"
# Serial: 107108908803651509692980124233745014957
# MD5 Fingerprint: a1:0b:44:b3:ca:10:d8:00:6e:9d:0f:d8:0f:92:0a:d1
# SHA1 Fingerprint: b8:01:86:d1:eb:9c:86:a5:41:04:cf:30:54:f3:4c:52:b7:e5:58:c6
# SHA256 Fingerprint: ce:cd:dc:90:50:99:d8:da:df:c5:b1:d2:09:b7:37:cb:e2:c1:8c:fb:2c:10:c0:ff:0b:cf:0d:32:86:fc:1a:a2
-----BEGIN CERTIFICATE-----
MIIEMDCCAxigAwIBAgIQUJRs7Bjq1ZxN1ZfvdY+grTANBgkqhkiG9w0BAQUFADCB
gjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3dy54cmFtcHNlY3VyaXR5LmNvbTEk
MCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2VydmljZXMgSW5jMS0wKwYDVQQDEyRY
UmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQxMTAxMTcx
NDA0WhcNMzUwMTAxMDUzNzE5WjCBgjELMAkGA1UEBhMCVVMxHjAcBgNVBAsTFXd3
dy54cmFtcHNlY3VyaXR5LmNvbTEkMCIGA1UEChMbWFJhbXAgU2VjdXJpdHkgU2Vy
dmljZXMgSW5jMS0wKwYDVQQDEyRYUmFtcCBHbG9iYWwgQ2VydGlmaWNhdGlvbiBB
dXRob3JpdHkwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCYJB69FbS6
38eMpSe2OAtp87ZOqCwuIR1cRN8hXX4jdP5efrRKt6atH67gBhbim1vZZ3RrXYCP
KZ2GG9mcDZhtdhAoWORlsH9KmHmf4MMxfoArtYzAQDsRhtDLooY2YKTVMIJt2W7Q
DxIEM5dfT2Fa8OT5kavnHTu86M/0ay00fOJIYRyO82FEzG+gSqmUsE3a56k0enI4
qEHMPJQRfevIpoy3hsvKMzvZPTeL+3o+hiznc9cKV6xkmxnr9A8ECIqsAxcZZPRa
JSKNNCyy9mgdEm3Tih4U2sSPpuIjhdV6Db1q4Ons7Be7QhtnqiXtRYMh/MHJfNVi
PvryxS3T/dRlAgMBAAGjgZ8wgZwwEwYJKwYBBAGCNxQCBAYeBABDAEEwCwYDVR0P
BAQDAgGGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFMZPoj0GY4QJnM5i5ASs
jVy16bYbMDYGA1UdHwQvMC0wK6ApoCeGJWh0dHA6Ly9jcmwueHJhbXBzZWN1cml0
eS5jb20vWEdDQS5jcmwwEAYJKwYBBAGCNxUBBAMCAQEwDQYJKoZIhvcNAQEFBQAD
ggEBAJEVOQMBG2f7Shz5CmBbodpNl2L5JFMn14JkTpAuw0kbK5rc/Kh4ZzXxHfAR
vbdI4xD2Dd8/0sm2qlWkSLoC295ZLhVbO50WfUfXN+pfTXYSNrsf16GBBEYgoyxt
qZ4Bfj8pzgCT3/3JknOJiWSe5yvkHJEs0rnOfc5vMZnT5r7SHpDwCRR5XCOrTdLa
IR9NmXmd4c8nnxCbHIgNsIpkQTG4DmyQJKSbXHGPurt+HBvbaoAPIbzp26a3QPSy
i6mx5O+aGtA9aZnuqCij4Tyz8LIRnM98QObd50N9otg6tamN8jSZxNQQ4Qb9CYQQ
O+7ETPTsJ3xCwnR8gooJybQDJbw=
-----END CERTIFICATE-----
# Issuer: O=The Go Daddy Group, Inc. OU=Go Daddy Class 2 Certification Authority
# Subject: O=The Go Daddy Group, Inc. OU=Go Daddy Class 2 Certification Authority
# Label: "Go Daddy Class 2 CA"
# Serial: 0
# MD5 Fingerprint: 91:de:06:25:ab:da:fd:32:17:0c:bb:25:17:2a:84:67
# SHA1 Fingerprint: 27:96:ba:e6:3f:18:01:e2:77:26:1b:a0:d7:77:70:02:8f:20:ee:e4
# SHA256 Fingerprint: c3:84:6b:f2:4b:9e:93:ca:64:27:4c:0e:c6:7c:1e:cc:5e:02:4f:fc:ac:d2:d7:40:19:35:0e:81:fe:54:6a:e4
-----BEGIN CERTIFICATE-----
MIIEADCCAuigAwIBAgIBADANBgkqhkiG9w0BAQUFADBjMQswCQYDVQQGEwJVUzEh
MB8GA1UEChMYVGhlIEdvIERhZGR5IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBE
YWRkeSBDbGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTA0MDYyOTE3
MDYyMFoXDTM0MDYyOTE3MDYyMFowYzELMAkGA1UEBhMCVVMxITAfBgNVBAoTGFRo
ZSBHbyBEYWRkeSBHcm91cCwgSW5jLjExMC8GA1UECxMoR28gRGFkZHkgQ2xhc3Mg
MiBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTCCASAwDQYJKoZIhvcNAQEBBQADggEN
ADCCAQgCggEBAN6d1+pXGEmhW+vXX0iG6r7d/+TvZxz0ZWizV3GgXne77ZtJ6XCA
PVYYYwhv2vLM0D9/AlQiVBDYsoHUwHU9S3/Hd8M+eKsaA7Ugay9qK7HFiH7Eux6w
wdhFJ2+qN1j3hybX2C32qRe3H3I2TqYXP2WYktsqbl2i/ojgC95/5Y0V4evLOtXi
EqITLdiOr18SPaAIBQi2XKVlOARFmR6jYGB0xUGlcmIbYsUfb18aQr4CUWWoriMY
avx4A6lNf4DD+qta/KFApMoZFv6yyO9ecw3ud72a9nmYvLEHZ6IVDd2gWMZEewo+
YihfukEHU1jPEX44dMX4/7VpkI+EdOqXG68CAQOjgcAwgb0wHQYDVR0OBBYEFNLE
sNKR1EwRcbNhyz2h/t2oatTjMIGNBgNVHSMEgYUwgYKAFNLEsNKR1EwRcbNhyz2h
/t2oatTjoWekZTBjMQswCQYDVQQGEwJVUzEhMB8GA1UEChMYVGhlIEdvIERhZGR5
IEdyb3VwLCBJbmMuMTEwLwYDVQQLEyhHbyBEYWRkeSBDbGFzcyAyIENlcnRpZmlj
YXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8wDQYJKoZIhvcNAQEFBQAD
ggEBADJL87LKPpH8EsahB4yOd6AzBhRckB4Y9wimPQoZ+YeAEW5p5JYXMP80kWNy
OO7MHAGjHZQopDH2esRU1/blMVgDoszOYtuURXO1v0XJJLXVggKtI3lpjbi2Tc7P
TMozI+gciKqdi0FuFskg5YmezTvacPd+mSYgFFQlq25zheabIZ0KbIIOqPjCDPoQ
HmyW74cNxA9hi63ugyuV+I6ShHI56yDqg+2DzZduCLzrTia2cyvk0/ZM/iZx4mER
dEr/VxqHD3VILs9RaRegAhJhldXRQLIQTO7ErBBDpqWeCtWVYpoNz4iCxTIM5Cuf
ReYNnyicsbkqWletNw+vHX/bvZ8=
-----END CERTIFICATE-----
# Issuer: O=Starfield Technologies, Inc. OU=Starfield Class 2 Certification Authority
# Subject: O=Starfield Technologies, Inc. OU=Starfield Class 2 Certification Authority
# Label: "Starfield Class 2 CA"
# Serial: 0
# MD5 Fingerprint: 32:4a:4b:bb:c8:63:69:9b:be:74:9a:c6:dd:1d:46:24
# SHA1 Fingerprint: ad:7e:1c:28:b0:64:ef:8f:60:03:40:20:14:c3:d0:e3:37:0e:b5:8a
# SHA256 Fingerprint: 14:65:fa:20:53:97:b8:76:fa:a6:f0:a9:95:8e:55:90:e4:0f:cc:7f:aa:4f:b7:c2:c8:67:75:21:fb:5f:b6:58
-----BEGIN CERTIFICATE-----
MIIEDzCCAvegAwIBAgIBADANBgkqhkiG9w0BAQUFADBoMQswCQYDVQQGEwJVUzEl
MCMGA1UEChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMp
U3RhcmZpZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDQw
NjI5MTczOTE2WhcNMzQwNjI5MTczOTE2WjBoMQswCQYDVQQGEwJVUzElMCMGA1UE
ChMcU3RhcmZpZWxkIFRlY2hub2xvZ2llcywgSW5jLjEyMDAGA1UECxMpU3RhcmZp
ZWxkIENsYXNzIDIgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwggEgMA0GCSqGSIb3
DQEBAQUAA4IBDQAwggEIAoIBAQC3Msj+6XGmBIWtDBFk385N78gDGIc/oav7PKaf
8MOh2tTYbitTkPskpD6E8J7oX+zlJ0T1KKY/e97gKvDIr1MvnsoFAZMej2YcOadN
+lq2cwQlZut3f+dZxkqZJRRU6ybH838Z1TBwj6+wRir/resp7defqgSHo9T5iaU0
X9tDkYI22WY8sbi5gv2cOj4QyDvvBmVmepsZGD3/cVE8MC5fvj13c7JdBmzDI1aa
K4UmkhynArPkPw2vCHmCuDY96pzTNbO8acr1zJ3o/WSNF4Azbl5KXZnJHoe0nRrA
1W4TNSNe35tfPe/W93bC6j67eA0cQmdrBNj41tpvi/JEoAGrAgEDo4HFMIHCMB0G
A1UdDgQWBBS/X7fRzt0fhvRbVazc1xDCDqmI5zCBkgYDVR0jBIGKMIGHgBS/X7fR
zt0fhvRbVazc1xDCDqmI56FspGowaDELMAkGA1UEBhMCVVMxJTAjBgNVBAoTHFN0
YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAsTKVN0YXJmaWVsZCBD
bGFzcyAyIENlcnRpZmljYXRpb24gQXV0aG9yaXR5ggEAMAwGA1UdEwQFMAMBAf8w
DQYJKoZIhvcNAQEFBQADggEBAAWdP4id0ckaVaGsafPzWdqbAYcaT1epoXkJKtv3
L7IezMdeatiDh6GX70k1PncGQVhiv45YuApnP+yz3SFmH8lU+nLMPUxA2IGvd56D
eruix/U0F47ZEUD0/CwqTRV/p2JdLiXTAAsgGh1o+Re49L2L7ShZ3U0WixeDyLJl
xy16paq8U4Zt3VekyvggQQto8PT7dL5WXXp59fkdheMtlb71cZBDzI0fmgAKhynp
VSJYACPq4xJDKVtHCN2MQWplBqjlIapBtJUhlbl90TSrE9atvNziPTnNvT51cKEY
WQPJIrSPnNVeKtelttQKbfi3QBFGmh95DmK/D5fs4C8fF5Q=
-----END CERTIFICATE-----
# Issuer: CN=StartCom Certification Authority O=StartCom Ltd. OU=Secure Digital Certificate Signing
# Subject: CN=StartCom Certification Authority O=StartCom Ltd. OU=Secure Digital Certificate Signing
# Label: "StartCom Certification Authority"
# Serial: 1
# MD5 Fingerprint: 22:4d:8f:8a:fc:f7:35:c2:bb:57:34:90:7b:8b:22:16
# SHA1 Fingerprint: 3e:2b:f7:f2:03:1b:96:f3:8c:e6:c4:d8:a8:5d:3e:2d:58:47:6a:0f
# SHA256 Fingerprint: c7:66:a9:be:f2:d4:07:1c:86:3a:31:aa:49:20:e8:13:b2:d1:98:60:8c:b7:b7:cf:e2:11:43:b8:36:df:09:ea
-----BEGIN CERTIFICATE-----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-----END CERTIFICATE-----
# Issuer: CN=DigiCert Assured ID Root CA O=DigiCert Inc OU=www.digicert.com
# Subject: CN=DigiCert Assured ID Root CA O=DigiCert Inc OU=www.digicert.com
# Label: "DigiCert Assured ID Root CA"
# Serial: 17154717934120587862167794914071425081
# MD5 Fingerprint: 87:ce:0b:7b:2a:0e:49:00:e1:58:71:9b:37:a8:93:72
# SHA1 Fingerprint: 05:63:b8:63:0d:62:d7:5a:bb:c8:ab:1e:4b:df:b5:a8:99:b2:4d:43
# SHA256 Fingerprint: 3e:90:99:b5:01:5e:8f:48:6c:00:bc:ea:9d:11:1e:e7:21:fa:ba:35:5a:89:bc:f1:df:69:56:1e:3d:c6:32:5c
-----BEGIN CERTIFICATE-----
MIIDtzCCAp+gAwIBAgIQDOfg5RfYRv6P5WD8G/AwOTANBgkqhkiG9w0BAQUFADBl
MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
d3cuZGlnaWNlcnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJv
b3QgQ0EwHhcNMDYxMTEwMDAwMDAwWhcNMzExMTEwMDAwMDAwWjBlMQswCQYDVQQG
EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNl
cnQuY29tMSQwIgYDVQQDExtEaWdpQ2VydCBBc3N1cmVkIElEIFJvb3QgQ0EwggEi
MA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCtDhXO5EOAXLGH87dg+XESpa7c
JpSIqvTO9SA5KFhgDPiA2qkVlTJhPLWxKISKityfCgyDF3qPkKyK53lTXDGEKvYP
mDI2dsze3Tyoou9q+yHyUmHfnyDXH+Kx2f4YZNISW1/5WBg1vEfNoTb5a3/UsDg+
wRvDjDPZ2C8Y/igPs6eD1sNuRMBhNZYW/lmci3Zt1/GiSw0r/wty2p5g0I6QNcZ4
VYcgoc/lbQrISXwxmDNsIumH0DJaoroTghHtORedmTpyoeb6pNnVFzF1roV9Iq4/
AUaG9ih5yLHa5FcXxH4cDrC0kqZWs72yl+2qp/C3xag/lRbQ/6GW6whfGHdPAgMB
AAGjYzBhMA4GA1UdDwEB/wQEAwIBhjAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQW
BBRF66Kv9JLLgjEtUYunpyGd823IDzAfBgNVHSMEGDAWgBRF66Kv9JLLgjEtUYun
pyGd823IDzANBgkqhkiG9w0BAQUFAAOCAQEAog683+Lt8ONyc3pklL/3cmbYMuRC
dWKuh+vy1dneVrOfzM4UKLkNl2BcEkxY5NM9g0lFWJc1aRqoR+pWxnmrEthngYTf
fwk8lOa4JiwgvT2zKIn3X/8i4peEH+ll74fg38FnSbNd67IJKusm7Xi+fT8r87cm
NW1fiQG2SVufAQWbqz0lwcy2f8Lxb4bG+mRo64EtlOtCt/qMHt1i8b5QZ7dsvfPx
H2sMNgcWfzd8qVttevESRmCD1ycEvkvOl77DZypoEd+A5wwzZr8TDRRu838fYxAe
+o0bJW1sj6W3YQGx0qMmoRBxna3iw/nDmVG3KwcIzi7mULKn+gpFL6Lw8g==
-----END CERTIFICATE-----
# Issuer: CN=DigiCert Global Root CA O=DigiCert Inc OU=www.digicert.com
# Subject: CN=DigiCert Global Root CA O=DigiCert Inc OU=www.digicert.com
# Label: "DigiCert Global Root CA"
# Serial: 10944719598952040374951832963794454346
# MD5 Fingerprint: 79:e4:a9:84:0d:7d:3a:96:d7:c0:4f:e2:43:4c:89:2e
# SHA1 Fingerprint: a8:98:5d:3a:65:e5:e5:c4:b2:d7:d6:6d:40:c6:dd:2f:b1:9c:54:36
# SHA256 Fingerprint: 43:48:a0:e9:44:4c:78:cb:26:5e:05:8d:5e:89:44:b4:d8:4f:96:62:bd:26:db:25:7f:89:34:a4:43:c7:01:61
-----BEGIN CERTIFICATE-----
MIIDrzCCApegAwIBAgIQCDvgVpBCRrGhdWrJWZHHSjANBgkqhkiG9w0BAQUFADBh
MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBD
QTAeFw0wNjExMTAwMDAwMDBaFw0zMTExMTAwMDAwMDBaMGExCzAJBgNVBAYTAlVT
MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j
b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IENBMIIBIjANBgkqhkiG
9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4jvhEXLeqKTTo1eqUKKPC3eQyaKl7hLOllsB
CSDMAZOnTjC3U/dDxGkAV53ijSLdhwZAAIEJzs4bg7/fzTtxRuLWZscFs3YnFo97
nh6Vfe63SKMI2tavegw5BmV/Sl0fvBf4q77uKNd0f3p4mVmFaG5cIzJLv07A6Fpt
43C/dxC//AH2hdmoRBBYMql1GNXRor5H4idq9Joz+EkIYIvUX7Q6hL+hqkpMfT7P
T19sdl6gSzeRntwi5m3OFBqOasv+zbMUZBfHWymeMr/y7vrTC0LUq7dBMtoM1O/4
gdW7jVg/tRvoSSiicNoxBN33shbyTApOB6jtSj1etX+jkMOvJwIDAQABo2MwYTAO
BgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA95QNVbR
TLtm8KPiGxvDl7I90VUwHwYDVR0jBBgwFoAUA95QNVbRTLtm8KPiGxvDl7I90VUw
DQYJKoZIhvcNAQEFBQADggEBAMucN6pIExIK+t1EnE9SsPTfrgT1eXkIoyQY/Esr
hMAtudXH/vTBH1jLuG2cenTnmCmrEbXjcKChzUyImZOMkXDiqw8cvpOp/2PV5Adg
06O/nVsJ8dWO41P0jmP6P6fbtGbfYmbW0W5BjfIttep3Sp+dWOIrWcBAI+0tKIJF
PnlUkiaY4IBIqDfv8NZ5YBberOgOzW6sRBc4L0na4UU+Krk2U886UAb3LujEV0ls
YSEY1QSteDwsOoBrp+uvFRTp2InBuThs4pFsiv9kuXclVzDAGySj4dzp30d8tbQk
CAUw7C29C79Fv1C5qfPrmAESrciIxpg0X40KPMbp1ZWVbd4=
-----END CERTIFICATE-----
# Issuer: CN=DigiCert High Assurance EV Root CA O=DigiCert Inc OU=www.digicert.com
# Subject: CN=DigiCert High Assurance EV Root CA O=DigiCert Inc OU=www.digicert.com
# Label: "DigiCert High Assurance EV Root CA"
# Serial: 3553400076410547919724730734378100087
# MD5 Fingerprint: d4:74:de:57:5c:39:b2:d3:9c:85:83:c5:c0:65:49:8a
# SHA1 Fingerprint: 5f:b7:ee:06:33:e2:59:db:ad:0c:4c:9a:e6:d3:8f:1a:61:c7:dc:25
# SHA256 Fingerprint: 74:31:e5:f4:c3:c1:ce:46:90:77:4f:0b:61:e0:54:40:88:3b:a9:a0:1e:d0:0b:a6:ab:d7:80:6e:d3:b1:18:cf
-----BEGIN CERTIFICATE-----
MIIDxTCCAq2gAwIBAgIQAqxcJmoLQJuPC3nyrkYldzANBgkqhkiG9w0BAQUFADBs
MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3
d3cuZGlnaWNlcnQuY29tMSswKQYDVQQDEyJEaWdpQ2VydCBIaWdoIEFzc3VyYW5j
ZSBFViBSb290IENBMB4XDTA2MTExMDAwMDAwMFoXDTMxMTExMDAwMDAwMFowbDEL
MAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZMBcGA1UECxMQd3d3
LmRpZ2ljZXJ0LmNvbTErMCkGA1UEAxMiRGlnaUNlcnQgSGlnaCBBc3N1cmFuY2Ug
RVYgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMbM5XPm
+9S75S0tMqbf5YE/yc0lSbZxKsPVlDRnogocsF9ppkCxxLeyj9CYpKlBWTrT3JTW
PNt0OKRKzE0lgvdKpVMSOO7zSW1xkX5jtqumX8OkhPhPYlG++MXs2ziS4wblCJEM
xChBVfvLWokVfnHoNb9Ncgk9vjo4UFt3MRuNs8ckRZqnrG0AFFoEt7oT61EKmEFB
Ik5lYYeBQVCmeVyJ3hlKV9Uu5l0cUyx+mM0aBhakaHPQNAQTXKFx01p8VdteZOE3
hzBWBOURtCmAEvF5OYiiAhF8J2a3iLd48soKqDirCmTCv2ZdlYTBoSUeh10aUAsg
EsxBu24LUTi4S8sCAwEAAaNjMGEwDgYDVR0PAQH/BAQDAgGGMA8GA1UdEwEB/wQF
MAMBAf8wHQYDVR0OBBYEFLE+w2kD+L9HAdSYJhoIAu9jZCvDMB8GA1UdIwQYMBaA
FLE+w2kD+L9HAdSYJhoIAu9jZCvDMA0GCSqGSIb3DQEBBQUAA4IBAQAcGgaX3Nec
nzyIZgYIVyHbIUf4KmeqvxgydkAQV8GK83rZEWWONfqe/EW1ntlMMUu4kehDLI6z
eM7b41N5cdblIZQB2lWHmiRk9opmzN6cN82oNLFpmyPInngiK3BD41VHMWEZ71jF
hS9OMPagMRYjyOfiZRYzy78aG6A9+MpeizGLYAiJLQwGXFK3xPkKmNEVX58Svnw2
Yzi9RKR/5CYrCsSXaQ3pjOLAEFe4yHYSkVXySGnYvCoCWw9E1CAx2/S6cCZdkGCe
vEsXCS+0yx5DaMkHJ8HSXPfqIbloEpw8nL+e/IBcm2PN7EeqJSdnoDfzAIJ9VNep
+OkuE6N36B9K
-----END CERTIFICATE-----
# Issuer: CN=GeoTrust Primary Certification Authority O=GeoTrust Inc.
# Subject: CN=GeoTrust Primary Certification Authority O=GeoTrust Inc.
# Label: "GeoTrust Primary Certification Authority"
# Serial: 32798226551256963324313806436981982369
# MD5 Fingerprint: 02:26:c3:01:5e:08:30:37:43:a9:d0:7d:cf:37:e6:bf
# SHA1 Fingerprint: 32:3c:11:8e:1b:f7:b8:b6:52:54:e2:e2:10:0d:d6:02:90:37:f0:96
# SHA256 Fingerprint: 37:d5:10:06:c5:12:ea:ab:62:64:21:f1:ec:8c:92:01:3f:c5:f8:2a:e9:8e:e5:33:eb:46:19:b8:de:b4:d0:6c
-----BEGIN CERTIFICATE-----
MIIDfDCCAmSgAwIBAgIQGKy1av1pthU6Y2yv2vrEoTANBgkqhkiG9w0BAQUFADBY
MQswCQYDVQQGEwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjExMC8GA1UEAxMo
R2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wNjEx
MjcwMDAwMDBaFw0zNjA3MTYyMzU5NTlaMFgxCzAJBgNVBAYTAlVTMRYwFAYDVQQK
Ew1HZW9UcnVzdCBJbmMuMTEwLwYDVQQDEyhHZW9UcnVzdCBQcmltYXJ5IENlcnRp
ZmljYXRpb24gQXV0aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
AQEAvrgVe//UfH1nrYNke8hCUy3f9oQIIGHWAVlqnEQRr+92/ZV+zmEwu3qDXwK9
AWbK7hWNb6EwnL2hhZ6UOvNWiAAxz9juapYC2e0DjPt1befquFUWBRaa9OBesYjA
ZIVcFU2Ix7e64HXprQU9nceJSOC7KMgD4TCTZF5SwFlwIjVXiIrxlQqD17wxcwE0
7e9GceBrAqg1cmuXm2bgyxx5X9gaBGgeRwLmnWDiNpcB3841kt++Z8dtd1k7j53W
kBWUvEI0EME5+bEnPn7WinXFsq+W06Lem+SYvn3h6YGttm/81w7a4DSwDRp35+MI
mO9Y+pyEtzavwt+s0vQQBnBxNQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4G
A1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQULNVQQZcVi/CPNmFbSvtr2ZnJM5IwDQYJ
KoZIhvcNAQEFBQADggEBAFpwfyzdtzRP9YZRqSa+S7iq8XEN3GHHoOo0Hnp3DwQ1
6CePbJC/kRYkRj5KTs4rFtULUh38H2eiAkUxT87z+gOneZ1TatnaYzr4gNfTmeGl
4b7UVXGYNTq+k+qurUKykG/g/CFNNWMziUnWm07Kx+dOCQD32sfvmWKZd7aVIl6K
oKv0uHiYyjgZmclynnjNS6yvGaBzEi38wkG6gZHaFloxt/m0cYASSJlyc1pZU8Fj
UjPtp8nSOQJw+uCxQmYpqptR7TBUIhRf2asdweSU8Pj1K/fqynhG1riR/aYNKxoU
AT6A8EKglQdebc3MS6RFjasS6LPeWuWgfOgPIh1a6Vk=
-----END CERTIFICATE-----
# Issuer: CN=thawte Primary Root CA O=thawte, Inc. OU=Certification Services Division/(c) 2006 thawte, Inc. - For authorized use only
# Subject: CN=thawte Primary Root CA O=thawte, Inc. OU=Certification Services Division/(c) 2006 thawte, Inc. - For authorized use only
# Label: "thawte Primary Root CA"
# Serial: 69529181992039203566298953787712940909
# MD5 Fingerprint: 8c:ca:dc:0b:22:ce:f5:be:72:ac:41:1a:11:a8:d8:12
# SHA1 Fingerprint: 91:c6:d6:ee:3e:8a:c8:63:84:e5:48:c2:99:29:5c:75:6c:81:7b:81
# SHA256 Fingerprint: 8d:72:2f:81:a9:c1:13:c0:79:1d:f1:36:a2:96:6d:b2:6c:95:0a:97:1d:b4:6b:41:99:f4:ea:54:b7:8b:fb:9f
-----BEGIN CERTIFICATE-----
MIIEIDCCAwigAwIBAgIQNE7VVyDV7exJ9C/ON9srbTANBgkqhkiG9w0BAQUFADCB
qTELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5jLjEoMCYGA1UECxMf
Q2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYGA1UECxMvKGMpIDIw
MDYgdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxHzAdBgNV
BAMTFnRoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EwHhcNMDYxMTE3MDAwMDAwWhcNMzYw
NzE2MjM1OTU5WjCBqTELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5j
LjEoMCYGA1UECxMfQ2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYG
A1UECxMvKGMpIDIwMDYgdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNl
IG9ubHkxHzAdBgNVBAMTFnRoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EwggEiMA0GCSqG
SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCsoPD7gFnUnMekz52hWXMJEEUMDSxuaPFs
W0hoSVk3/AszGcJ3f8wQLZU0HObrTQmnHNK4yZc2AreJ1CRfBsDMRJSUjQJib+ta
3RGNKJpchJAQeg29dGYvajig4tVUROsdB58Hum/u6f1OCyn1PoSgAfGcq/gcfomk
6KHYcWUNo1F77rzSImANuVud37r8UVsLr5iy6S7pBOhih94ryNdOwUxkHt3Ph1i6
Sk/KaAcdHJ1KxtUvkcx8cXIcxcBn6zL9yZJclNqFwJu/U30rCfSMnZEfl2pSy94J
NqR32HuHUETVPm4pafs5SSYeCaWAe0At6+gnhcn+Yf1+5nyXHdWdAgMBAAGjQjBA
MA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBR7W0XP
r87Lev0xkhpqtvNG61dIUDANBgkqhkiG9w0BAQUFAAOCAQEAeRHAS7ORtvzw6WfU
DW5FvlXok9LOAz/t2iWwHVfLHjp2oEzsUHboZHIMpKnxuIvW1oeEuzLlQRHAd9mz
YJ3rG9XRbkREqaYB7FViHXe4XI5ISXycO1cRrK1zN44veFyQaEfZYGDm/Ac9IiAX
xPcW6cTYcvnIc3zfFi8VqT79aie2oetaupgf1eNNZAqdE8hhuvU5HIe6uL17In/2
/qxAeeWsEG89jxt5dovEN7MhGITlNgDrYyCZuen+MwS7QcjBAvlEYyCegc5C09Y/
LHbTY5xZ3Y+m4Q6gLkH3LpVHz7z9M/P2C2F+fpErgUfCJzDupxBdN49cOSvkBPB7
jVaMaA==
-----END CERTIFICATE-----
# Issuer: CN=VeriSign Class 3 Public Primary Certification Authority - G5 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 2006 VeriSign, Inc. - For authorized use only
# Subject: CN=VeriSign Class 3 Public Primary Certification Authority - G5 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 2006 VeriSign, Inc. - For authorized use only
# Label: "VeriSign Class 3 Public Primary Certification Authority - G5"
# Serial: 33037644167568058970164719475676101450
# MD5 Fingerprint: cb:17:e4:31:67:3e:e2:09:fe:45:57:93:f3:0a:fa:1c
# SHA1 Fingerprint: 4e:b6:d5:78:49:9b:1c:cf:5f:58:1e:ad:56:be:3d:9b:67:44:a5:e5
# SHA256 Fingerprint: 9a:cf:ab:7e:43:c8:d8:80:d0:6b:26:2a:94:de:ee:e4:b4:65:99:89:c3:d0:ca:f1:9b:af:64:05:e4:1a:b7:df
-----BEGIN CERTIFICATE-----
MIIE0zCCA7ugAwIBAgIQGNrRniZ96LtKIVjNzGs7SjANBgkqhkiG9w0BAQUFADCB
yjELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL
ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNiBWZXJp
U2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxW
ZXJpU2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0
aG9yaXR5IC0gRzUwHhcNMDYxMTA4MDAwMDAwWhcNMzYwNzE2MjM1OTU5WjCByjEL
MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW
ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNiBWZXJpU2ln
biwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJp
U2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9y
aXR5IC0gRzUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCvJAgIKXo1
nmAMqudLO07cfLw8RRy7K+D+KQL5VwijZIUVJ/XxrcgxiV0i6CqqpkKzj/i5Vbex
t0uz/o9+B1fs70PbZmIVYc9gDaTY3vjgw2IIPVQT60nKWVSFJuUrjxuf6/WhkcIz
SdhDY2pSS9KP6HBRTdGJaXvHcPaz3BJ023tdS1bTlr8Vd6Gw9KIl8q8ckmcY5fQG
BO+QueQA5N06tRn/Arr0PO7gi+s3i+z016zy9vA9r911kTMZHRxAy3QkGSGT2RT+
rCpSx4/VBEnkjWNHiDxpg8v+R70rfk/Fla4OndTRQ8Bnc+MUCH7lP59zuDMKz10/
NIeWiu5T6CUVAgMBAAGjgbIwga8wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8E
BAMCAQYwbQYIKwYBBQUHAQwEYTBfoV2gWzBZMFcwVRYJaW1hZ2UvZ2lmMCEwHzAH
BgUrDgMCGgQUj+XTGoasjY5rw8+AatRIGCx7GS4wJRYjaHR0cDovL2xvZ28udmVy
aXNpZ24uY29tL3ZzbG9nby5naWYwHQYDVR0OBBYEFH/TZafC3ey78DAJ80M5+gKv
MzEzMA0GCSqGSIb3DQEBBQUAA4IBAQCTJEowX2LP2BqYLz3q3JktvXf2pXkiOOzE
p6B4Eq1iDkVwZMXnl2YtmAl+X6/WzChl8gGqCBpH3vn5fJJaCGkgDdk+bW48DW7Y
5gaRQBi5+MHt39tBquCWIMnNZBU4gcmU7qKEKQsTb47bDN0lAtukixlE0kF6BWlK
WE9gyn6CagsCqiUXObXbf+eEZSqVir2G3l6BFoMtEMze/aiCKm0oHw0LxOXnGiYZ
4fQRbxC1lfznQgUy286dUV4otp6F01vvpX1FQHKOtw5rDgb7MzVIcbidJ4vEZV8N
hnacRHr2lVz2XTIIM6RUthg/aFzyQkqFOFSDX9HoLPKsEdao7WNq
-----END CERTIFICATE-----
# Issuer: CN=COMODO Certification Authority O=COMODO CA Limited
# Subject: CN=COMODO Certification Authority O=COMODO CA Limited
# Label: "COMODO Certification Authority"
# Serial: 104350513648249232941998508985834464573
# MD5 Fingerprint: 5c:48:dc:f7:42:72:ec:56:94:6d:1c:cc:71:35:80:75
# SHA1 Fingerprint: 66:31:bf:9e:f7:4f:9e:b6:c9:d5:a6:0c:ba:6a:be:d1:f7:bd:ef:7b
# SHA256 Fingerprint: 0c:2c:d6:3d:f7:80:6f:a3:99:ed:e8:09:11:6b:57:5b:f8:79:89:f0:65:18:f9:80:8c:86:05:03:17:8b:af:66
-----BEGIN CERTIFICATE-----
MIIEHTCCAwWgAwIBAgIQToEtioJl4AsC7j41AkblPTANBgkqhkiG9w0BAQUFADCB
gTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4G
A1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxJzAlBgNV
BAMTHkNPTU9ETyBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAeFw0wNjEyMDEwMDAw
MDBaFw0yOTEyMzEyMzU5NTlaMIGBMQswCQYDVQQGEwJHQjEbMBkGA1UECBMSR3Jl
YXRlciBNYW5jaGVzdGVyMRAwDgYDVQQHEwdTYWxmb3JkMRowGAYDVQQKExFDT01P
RE8gQ0EgTGltaXRlZDEnMCUGA1UEAxMeQ09NT0RPIENlcnRpZmljYXRpb24gQXV0
aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0ECLi3LjkRv3
UcEbVASY06m/weaKXTuH+7uIzg3jLz8GlvCiKVCZrts7oVewdFFxze1CkU1B/qnI
2GqGd0S7WWaXUF601CxwRM/aN5VCaTwwxHGzUvAhTaHYujl8HJ6jJJ3ygxaYqhZ8
Q5sVW7euNJH+1GImGEaaP+vB+fGQV+useg2L23IwambV4EajcNxo2f8ESIl33rXp
+2dtQem8Ob0y2WIC8bGoPW43nOIv4tOiJovGuFVDiOEjPqXSJDlqR6sA1KGzqSX+
DT+nHbrTUcELpNqsOO9VUCQFZUaTNE8tja3G1CEZ0o7KBWFxB3NH5YoZEr0ETc5O
nKVIrLsm9wIDAQABo4GOMIGLMB0GA1UdDgQWBBQLWOWLxkwVN6RAqTCpIb5HNlpW
/zAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zBJBgNVHR8EQjBAMD6g
PKA6hjhodHRwOi8vY3JsLmNvbW9kb2NhLmNvbS9DT01PRE9DZXJ0aWZpY2F0aW9u
QXV0aG9yaXR5LmNybDANBgkqhkiG9w0BAQUFAAOCAQEAPpiem/Yb6dc5t3iuHXIY
SdOH5EOC6z/JqvWote9VfCFSZfnVDeFs9D6Mk3ORLgLETgdxb8CPOGEIqB6BCsAv
IC9Bi5HcSEW88cbeunZrM8gALTFGTO3nnc+IlP8zwFboJIYmuNg4ON8qa90SzMc/
RxdMosIGlgnW2/4/PEZB31jiVg88O8EckzXZOFKs7sjsLjBOlDW0JB9LeGna8gI4
zJVSk/BwJVmcIGfE7vmLV2H0knZ9P4SNVbfo5azV8fUZVqZa+5Acr5Pr5RzUZ5dd
BA6+C4OmF4O5MBKgxTMVBbkN+8cFduPYSo38NBejxiEovjBFMR7HeL5YYTisO+IB
ZQ==
-----END CERTIFICATE-----
# Issuer: CN=Network Solutions Certificate Authority O=Network Solutions L.L.C.
# Subject: CN=Network Solutions Certificate Authority O=Network Solutions L.L.C.
# Label: "Network Solutions Certificate Authority"
# Serial: 116697915152937497490437556386812487904
# MD5 Fingerprint: d3:f3:a6:16:c0:fa:6b:1d:59:b1:2d:96:4d:0e:11:2e
# SHA1 Fingerprint: 74:f8:a3:c3:ef:e7:b3:90:06:4b:83:90:3c:21:64:60:20:e5:df:ce
# SHA256 Fingerprint: 15:f0:ba:00:a3:ac:7a:f3:ac:88:4c:07:2b:10:11:a0:77:bd:77:c0:97:f4:01:64:b2:f8:59:8a:bd:83:86:0c
-----BEGIN CERTIFICATE-----
MIID5jCCAs6gAwIBAgIQV8szb8JcFuZHFhfjkDFo4DANBgkqhkiG9w0BAQUFADBi
MQswCQYDVQQGEwJVUzEhMB8GA1UEChMYTmV0d29yayBTb2x1dGlvbnMgTC5MLkMu
MTAwLgYDVQQDEydOZXR3b3JrIFNvbHV0aW9ucyBDZXJ0aWZpY2F0ZSBBdXRob3Jp
dHkwHhcNMDYxMjAxMDAwMDAwWhcNMjkxMjMxMjM1OTU5WjBiMQswCQYDVQQGEwJV
UzEhMB8GA1UEChMYTmV0d29yayBTb2x1dGlvbnMgTC5MLkMuMTAwLgYDVQQDEydO
ZXR3b3JrIFNvbHV0aW9ucyBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkwggEiMA0GCSqG
SIb3DQEBAQUAA4IBDwAwggEKAoIBAQDkvH6SMG3G2I4rC7xGzuAnlt7e+foS0zwz
c7MEL7xxjOWftiJgPl9dzgn/ggwbmlFQGiaJ3dVhXRncEg8tCqJDXRfQNJIg6nPP
OCwGJgl6cvf6UDL4wpPTaaIjzkGxzOTVHzbRijr4jGPiFFlp7Q3Tf2vouAPlT2rl
mGNpSAW+Lv8ztumXWWn4Zxmuk2GWRBXTcrA/vGp97Eh/jcOrqnErU2lBUzS1sLnF
BgrEsEX1QV1uiUV7PTsmjHTC5dLRfbIR1PtYMiKagMnc/Qzpf14Dl847ABSHJ3A4
qY5usyd2mFHgBeMhqxrVhSI8KbWaFsWAqPS7azCPL0YCorEMIuDTAgMBAAGjgZcw
gZQwHQYDVR0OBBYEFCEwyfsA106Y2oeqKtCnLrFAMadMMA4GA1UdDwEB/wQEAwIB
BjAPBgNVHRMBAf8EBTADAQH/MFIGA1UdHwRLMEkwR6BFoEOGQWh0dHA6Ly9jcmwu
bmV0c29sc3NsLmNvbS9OZXR3b3JrU29sdXRpb25zQ2VydGlmaWNhdGVBdXRob3Jp
dHkuY3JsMA0GCSqGSIb3DQEBBQUAA4IBAQC7rkvnt1frf6ott3NHhWrB5KUd5Oc8
6fRZZXe1eltajSU24HqXLjjAV2CDmAaDn7l2em5Q4LqILPxFzBiwmZVRDuwduIj/
h1AcgsLj4DKAv6ALR8jDMe+ZZzKATxcheQxpXN5eNK4CtSbqUN9/GGUsyfJj4akH
/nxxH2szJGoeBfcFaMBqEssuXmHLrijTfsK0ZpEmXzwuJF/LWA/rKOyvEZbz3Htv
wKeI8lN3s2Berq4o2jUsbzRF0ybh3uxbTydrFny9RAQYgrOJeRcQcT16ohZO9QHN
pGxlaKFJdlxDydi8NmdspZS11My5vWo1ViHe2MPr+8ukYEywVaCge1ey
-----END CERTIFICATE-----
# Issuer: CN=COMODO ECC Certification Authority O=COMODO CA Limited
# Subject: CN=COMODO ECC Certification Authority O=COMODO CA Limited
# Label: "COMODO ECC Certification Authority"
# Serial: 41578283867086692638256921589707938090
# MD5 Fingerprint: 7c:62:ff:74:9d:31:53:5e:68:4a:d5:78:aa:1e:bf:23
# SHA1 Fingerprint: 9f:74:4e:9f:2b:4d:ba:ec:0f:31:2c:50:b6:56:3b:8e:2d:93:c3:11
# SHA256 Fingerprint: 17:93:92:7a:06:14:54:97:89:ad:ce:2f:8f:34:f7:f0:b6:6d:0f:3a:e3:a3:b8:4d:21:ec:15:db:ba:4f:ad:c7
-----BEGIN CERTIFICATE-----
MIICiTCCAg+gAwIBAgIQH0evqmIAcFBUTAGem2OZKjAKBggqhkjOPQQDAzCBhTEL
MAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdyZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UE
BxMHU2FsZm9yZDEaMBgGA1UEChMRQ09NT0RPIENBIExpbWl0ZWQxKzApBgNVBAMT
IkNPTU9ETyBFQ0MgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkwHhcNMDgwMzA2MDAw
MDAwWhcNMzgwMTE4MjM1OTU5WjCBhTELMAkGA1UEBhMCR0IxGzAZBgNVBAgTEkdy
ZWF0ZXIgTWFuY2hlc3RlcjEQMA4GA1UEBxMHU2FsZm9yZDEaMBgGA1UEChMRQ09N
T0RPIENBIExpbWl0ZWQxKzApBgNVBAMTIkNPTU9ETyBFQ0MgQ2VydGlmaWNhdGlv
biBBdXRob3JpdHkwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQDR3svdcmCFYX7deSR
FtSrYpn1PlILBs5BAH+X4QokPB0BBO490o0JlwzgdeT6+3eKKvUDYEs2ixYjFq0J
cfRK9ChQtP6IHG4/bC8vCVlbpVsLM5niwz2J+Wos77LTBumjQjBAMB0GA1UdDgQW
BBR1cacZSBm8nZ3qQUfflMRId5nTeTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/
BAUwAwEB/zAKBggqhkjOPQQDAwNoADBlAjEA7wNbeqy3eApyt4jf/7VGFAkK+qDm
fQjGGoe9GKhzvSbKYAydzpmfz1wPMOG+FDHqAjAU9JM8SaczepBGR7NjfRObTrdv
GDeAU/7dIOA1mjbRxwG55tzd8/8dLDoWV9mSOdY=
-----END CERTIFICATE-----
# Issuer: CN=TC TrustCenter Class 2 CA II O=TC TrustCenter GmbH OU=TC TrustCenter Class 2 CA
# Subject: CN=TC TrustCenter Class 2 CA II O=TC TrustCenter GmbH OU=TC TrustCenter Class 2 CA
# Label: "TC TrustCenter Class 2 CA II"
# Serial: 941389028203453866782103406992443
# MD5 Fingerprint: ce:78:33:5c:59:78:01:6e:18:ea:b9:36:a0:b9:2e:23
# SHA1 Fingerprint: ae:50:83:ed:7c:f4:5c:bc:8f:61:c6:21:fe:68:5d:79:42:21:15:6e
# SHA256 Fingerprint: e6:b8:f8:76:64:85:f8:07:ae:7f:8d:ac:16:70:46:1f:07:c0:a1:3e:ef:3a:1f:f7:17:53:8d:7a:ba:d3:91:b4
-----BEGIN CERTIFICATE-----
MIIEqjCCA5KgAwIBAgIOLmoAAQACH9dSISwRXDswDQYJKoZIhvcNAQEFBQAwdjEL
MAkGA1UEBhMCREUxHDAaBgNVBAoTE1RDIFRydXN0Q2VudGVyIEdtYkgxIjAgBgNV
BAsTGVRDIFRydXN0Q2VudGVyIENsYXNzIDIgQ0ExJTAjBgNVBAMTHFRDIFRydXN0
Q2VudGVyIENsYXNzIDIgQ0EgSUkwHhcNMDYwMTEyMTQzODQzWhcNMjUxMjMxMjI1
OTU5WjB2MQswCQYDVQQGEwJERTEcMBoGA1UEChMTVEMgVHJ1c3RDZW50ZXIgR21i
SDEiMCAGA1UECxMZVEMgVHJ1c3RDZW50ZXIgQ2xhc3MgMiBDQTElMCMGA1UEAxMc
VEMgVHJ1c3RDZW50ZXIgQ2xhc3MgMiBDQSBJSTCCASIwDQYJKoZIhvcNAQEBBQAD
ggEPADCCAQoCggEBAKuAh5uO8MN8h9foJIIRszzdQ2Lu+MNF2ujhoF/RKrLqk2jf
tMjWQ+nEdVl//OEd+DFwIxuInie5e/060smp6RQvkL4DUsFJzfb95AhmC1eKokKg
uNV/aVyQMrKXDcpK3EY+AlWJU+MaWss2xgdW94zPEfRMuzBwBJWl9jmM/XOBCH2J
XjIeIqkiRUuwZi4wzJ9l/fzLganx4Duvo4bRierERXlQXa7pIXSSTYtZgo+U4+lK
8edJsBTj9WLL1XK9H7nSn6DNqPoByNkN39r8R52zyFTfSUrxIan+GE7uSNQZu+99
5OKdy1u2bv/jzVrndIIFuoAlOMvkaZ6vQaoahPUCAwEAAaOCATQwggEwMA8GA1Ud
EwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBTjq1RMgKHbVkO3
kUrL84J6E1wIqzCB7QYDVR0fBIHlMIHiMIHfoIHcoIHZhjVodHRwOi8vd3d3LnRy
dXN0Y2VudGVyLmRlL2NybC92Mi90Y19jbGFzc18yX2NhX0lJLmNybIaBn2xkYXA6
Ly93d3cudHJ1c3RjZW50ZXIuZGUvQ049VEMlMjBUcnVzdENlbnRlciUyMENsYXNz
JTIwMiUyMENBJTIwSUksTz1UQyUyMFRydXN0Q2VudGVyJTIwR21iSCxPVT1yb290
Y2VydHMsREM9dHJ1c3RjZW50ZXIsREM9ZGU/Y2VydGlmaWNhdGVSZXZvY2F0aW9u
TGlzdD9iYXNlPzANBgkqhkiG9w0BAQUFAAOCAQEAjNfffu4bgBCzg/XbEeprS6iS
GNn3Bzn1LL4GdXpoUxUc6krtXvwjshOg0wn/9vYua0Fxec3ibf2uWWuFHbhOIprt
ZjluS5TmVfwLG4t3wVMTZonZKNaL80VKY7f9ewthXbhtvsPcW3nS7Yblok2+XnR8
au0WOB9/WIFaGusyiC2y8zl3gK9etmF1KdsjTYjKUCjLhdLTEKJZbtOTVAB6okaV
hgWcqRmY5TFyDADiZ9lA4CQze28suVyrZZ0srHbqNZn1l7kPJOzHdiEoZa5X6AeI
dUpWoNIFOqTmjZKILPPy4cHGYdtBxceb9w4aUUXCYWvcZCcXjFq32nQozZfkvQ==
-----END CERTIFICATE-----
# Issuer: CN=TC TrustCenter Class 3 CA II O=TC TrustCenter GmbH OU=TC TrustCenter Class 3 CA
# Subject: CN=TC TrustCenter Class 3 CA II O=TC TrustCenter GmbH OU=TC TrustCenter Class 3 CA
# Label: "TC TrustCenter Class 3 CA II"
# Serial: 1506523511417715638772220530020799
# MD5 Fingerprint: 56:5f:aa:80:61:12:17:f6:67:21:e6:2b:6d:61:56:8e
# SHA1 Fingerprint: 80:25:ef:f4:6e:70:c8:d4:72:24:65:84:fe:40:3b:8a:8d:6a:db:f5
# SHA256 Fingerprint: 8d:a0:84:fc:f9:9c:e0:77:22:f8:9b:32:05:93:98:06:fa:5c:b8:11:e1:c8:13:f6:a1:08:c7:d3:36:b3:40:8e
-----BEGIN CERTIFICATE-----
MIIEqjCCA5KgAwIBAgIOSkcAAQAC5aBd1j8AUb8wDQYJKoZIhvcNAQEFBQAwdjEL
MAkGA1UEBhMCREUxHDAaBgNVBAoTE1RDIFRydXN0Q2VudGVyIEdtYkgxIjAgBgNV
BAsTGVRDIFRydXN0Q2VudGVyIENsYXNzIDMgQ0ExJTAjBgNVBAMTHFRDIFRydXN0
Q2VudGVyIENsYXNzIDMgQ0EgSUkwHhcNMDYwMTEyMTQ0MTU3WhcNMjUxMjMxMjI1
OTU5WjB2MQswCQYDVQQGEwJERTEcMBoGA1UEChMTVEMgVHJ1c3RDZW50ZXIgR21i
SDEiMCAGA1UECxMZVEMgVHJ1c3RDZW50ZXIgQ2xhc3MgMyBDQTElMCMGA1UEAxMc
VEMgVHJ1c3RDZW50ZXIgQ2xhc3MgMyBDQSBJSTCCASIwDQYJKoZIhvcNAQEBBQAD
ggEPADCCAQoCggEBALTgu1G7OVyLBMVMeRwjhjEQY0NVJz/GRcekPewJDRoeIMJW
Ht4bNwcwIi9v8Qbxq63WyKthoy9DxLCyLfzDlml7forkzMA5EpBCYMnMNWju2l+Q
Vl/NHE1bWEnrDgFPZPosPIlY2C8u4rBo6SI7dYnWRBpl8huXJh0obazovVkdKyT2
1oQDZogkAHhg8fir/gKya/si+zXmFtGt9i4S5Po1auUZuV3bOx4a+9P/FRQI2Alq
ukWdFHlgfa9Aigdzs5OW03Q0jTo3Kd5c7PXuLjHCINy+8U9/I1LZW+Jk2ZyqBwi1
Rb3R0DHBq1SfqdLDYmAD8bs5SpJKPQq5ncWg/jcCAwEAAaOCATQwggEwMA8GA1Ud
EwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBTUovyfs8PYA9NX
XAek0CSnwPIA1DCB7QYDVR0fBIHlMIHiMIHfoIHcoIHZhjVodHRwOi8vd3d3LnRy
dXN0Y2VudGVyLmRlL2NybC92Mi90Y19jbGFzc18zX2NhX0lJLmNybIaBn2xkYXA6
Ly93d3cudHJ1c3RjZW50ZXIuZGUvQ049VEMlMjBUcnVzdENlbnRlciUyMENsYXNz
JTIwMyUyMENBJTIwSUksTz1UQyUyMFRydXN0Q2VudGVyJTIwR21iSCxPVT1yb290
Y2VydHMsREM9dHJ1c3RjZW50ZXIsREM9ZGU/Y2VydGlmaWNhdGVSZXZvY2F0aW9u
TGlzdD9iYXNlPzANBgkqhkiG9w0BAQUFAAOCAQEANmDkcPcGIEPZIxpC8vijsrlN
irTzwppVMXzEO2eatN9NDoqTSheLG43KieHPOh6sHfGcMrSOWXaiQYUlN6AT0PV8
TtXqluJucsG7Kv5sbviRmEb8yRtXW+rIGjs/sFGYPAfaLFkB2otE6OF0/ado3VS6
g0bsyEa1+K+XwDsJHI/OcpY9M1ZwvJbL2NV9IJqDnxrcOfHFcqMRA/07QlIp2+gB
95tejNaNhk4Z+rwcvsUhpYeeeC422wlxo3I0+GzjBgnyXlal092Y+tTmBvTwtiBj
S+opvaqCZh77gaqnN60TGOaSw4HBM7uIHqHn4rS9MWwOUT1v+5ZWgOI2F9Hc5A==
-----END CERTIFICATE-----
# Issuer: CN=TC TrustCenter Universal CA I O=TC TrustCenter GmbH OU=TC TrustCenter Universal CA
# Subject: CN=TC TrustCenter Universal CA I O=TC TrustCenter GmbH OU=TC TrustCenter Universal CA
# Label: "TC TrustCenter Universal CA I"
# Serial: 601024842042189035295619584734726
# MD5 Fingerprint: 45:e1:a5:72:c5:a9:36:64:40:9e:f5:e4:58:84:67:8c
# SHA1 Fingerprint: 6b:2f:34:ad:89:58:be:62:fd:b0:6b:5c:ce:bb:9d:d9:4f:4e:39:f3
# SHA256 Fingerprint: eb:f3:c0:2a:87:89:b1:fb:7d:51:19:95:d6:63:b7:29:06:d9:13:ce:0d:5e:10:56:8a:8a:77:e2:58:61:67:e7
-----BEGIN CERTIFICATE-----
MIID3TCCAsWgAwIBAgIOHaIAAQAC7LdggHiNtgYwDQYJKoZIhvcNAQEFBQAweTEL
MAkGA1UEBhMCREUxHDAaBgNVBAoTE1RDIFRydXN0Q2VudGVyIEdtYkgxJDAiBgNV
BAsTG1RDIFRydXN0Q2VudGVyIFVuaXZlcnNhbCBDQTEmMCQGA1UEAxMdVEMgVHJ1
c3RDZW50ZXIgVW5pdmVyc2FsIENBIEkwHhcNMDYwMzIyMTU1NDI4WhcNMjUxMjMx
MjI1OTU5WjB5MQswCQYDVQQGEwJERTEcMBoGA1UEChMTVEMgVHJ1c3RDZW50ZXIg
R21iSDEkMCIGA1UECxMbVEMgVHJ1c3RDZW50ZXIgVW5pdmVyc2FsIENBMSYwJAYD
VQQDEx1UQyBUcnVzdENlbnRlciBVbml2ZXJzYWwgQ0EgSTCCASIwDQYJKoZIhvcN
AQEBBQADggEPADCCAQoCggEBAKR3I5ZEr5D0MacQ9CaHnPM42Q9e3s9B6DGtxnSR
JJZ4Hgmgm5qVSkr1YnwCqMqs+1oEdjneX/H5s7/zA1hV0qq34wQi0fiU2iIIAI3T
fCZdzHd55yx4Oagmcw6iXSVphU9VDprvxrlE4Vc93x9UIuVvZaozhDrzznq+VZeu
jRIPFDPiUHDDSYcTvFHe15gSWu86gzOSBnWLknwSaHtwag+1m7Z3W0hZneTvWq3z
wZ7U10VOylY0Ibw+F1tvdwxIAUMpsN0/lm7mlaoMwCC2/T42J5zjXM9OgdwZu5GQ
fezmlwQek8wiSdeXhrYTCjxDI3d+8NzmzSQfO4ObNDqDNOMCAwEAAaNjMGEwHwYD
VR0jBBgwFoAUkqR1LKSevoFE63n8isWVpesQdXMwDwYDVR0TAQH/BAUwAwEB/zAO
BgNVHQ8BAf8EBAMCAYYwHQYDVR0OBBYEFJKkdSyknr6BROt5/IrFlaXrEHVzMA0G
CSqGSIb3DQEBBQUAA4IBAQAo0uCG1eb4e/CX3CJrO5UUVg8RMKWaTzqwOuAGy2X1
7caXJ/4l8lfmXpWMPmRgFVp/Lw0BxbFg/UU1z/CyvwbZ71q+s2IhtNerNXxTPqYn
8aEt2hojnczd7Dwtnic0XQ/CNnm8yUpiLe1r2X1BQ3y2qsrtYbE3ghUJGooWMNjs
ydZHcnhLEEYUjl8Or+zHL6sQ17bxbuyGssLoDZJz3KL0Dzq/YSMQiZxIQG5wALPT
ujdEWBF6AmqI8Dc08BnprNRlc/ZpjGSUOnmFKbAWKwyCPwacx/0QK54PLLae4xW/
2TYcuiUaUj0a7CIMHOCkoj3w6DnPgcB77V0fb8XQC9eY
-----END CERTIFICATE-----
# Issuer: CN=Cybertrust Global Root O=Cybertrust, Inc
# Subject: CN=Cybertrust Global Root O=Cybertrust, Inc
# Label: "Cybertrust Global Root"
# Serial: 4835703278459682877484360
# MD5 Fingerprint: 72:e4:4a:87:e3:69:40:80:77:ea:bc:e3:f4:ff:f0:e1
# SHA1 Fingerprint: 5f:43:e5:b1:bf:f8:78:8c:ac:1c:c7:ca:4a:9a:c6:22:2b:cc:34:c6
# SHA256 Fingerprint: 96:0a:df:00:63:e9:63:56:75:0c:29:65:dd:0a:08:67:da:0b:9c:bd:6e:77:71:4a:ea:fb:23:49:ab:39:3d:a3
-----BEGIN CERTIFICATE-----
MIIDoTCCAomgAwIBAgILBAAAAAABD4WqLUgwDQYJKoZIhvcNAQEFBQAwOzEYMBYG
A1UEChMPQ3liZXJ0cnVzdCwgSW5jMR8wHQYDVQQDExZDeWJlcnRydXN0IEdsb2Jh
bCBSb290MB4XDTA2MTIxNTA4MDAwMFoXDTIxMTIxNTA4MDAwMFowOzEYMBYGA1UE
ChMPQ3liZXJ0cnVzdCwgSW5jMR8wHQYDVQQDExZDeWJlcnRydXN0IEdsb2JhbCBS
b290MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA+Mi8vRRQZhP/8NN5
7CPytxrHjoXxEnOmGaoQ25yiZXRadz5RfVb23CO21O1fWLE3TdVJDm71aofW0ozS
J8bi/zafmGWgE07GKmSb1ZASzxQG9Dvj1Ci+6A74q05IlG2OlTEQXO2iLb3VOm2y
HLtgwEZLAfVJrn5GitB0jaEMAs7u/OePuGtm839EAL9mJRQr3RAwHQeWP032a7iP
t3sMpTjr3kfb1V05/Iin89cqdPHoWqI7n1C6poxFNcJQZZXcY4Lv3b93TZxiyWNz
FtApD0mpSPCzqrdsxacwOUBdrsTiXSZT8M4cIwhhqJQZugRiQOwfOHB3EgZxpzAY
XSUnpQIDAQABo4GlMIGiMA4GA1UdDwEB/wQEAwIBBjAPBgNVHRMBAf8EBTADAQH/
MB0GA1UdDgQWBBS2CHsNesysIEyGVjJez6tuhS1wVzA/BgNVHR8EODA2MDSgMqAw
hi5odHRwOi8vd3d3Mi5wdWJsaWMtdHJ1c3QuY29tL2NybC9jdC9jdHJvb3QuY3Js
MB8GA1UdIwQYMBaAFLYIew16zKwgTIZWMl7Pq26FLXBXMA0GCSqGSIb3DQEBBQUA
A4IBAQBW7wojoFROlZfJ+InaRcHUowAl9B8Tq7ejhVhpwjCt2BWKLePJzYFa+HMj
Wqd8BfP9IjsO0QbE2zZMcwSO5bAi5MXzLqXZI+O4Tkogp24CJJ8iYGd7ix1yCcUx
XOl5n4BHPa2hCwcUPUf/A2kaDAtE52Mlp3+yybh2hO0j9n0Hq0V+09+zv+mKts2o
omcrUtW3ZfA5TGOgkXmTUg9U3YO7n9GPp1Nzw8v/MOx8BLjYRB+TX3EJIrduPuoc
A06dGiBh+4E37F78CkWr1+cXVdCg6mCbpvbjjFspwgZgFJ0tl0ypkxWdYcQBX0jW
WL1WMRJOEcgh4LMRkWXbtKaIOM5V
-----END CERTIFICATE-----
# Issuer: CN=GeoTrust Primary Certification Authority - G3 O=GeoTrust Inc. OU=(c) 2008 GeoTrust Inc. - For authorized use only
# Subject: CN=GeoTrust Primary Certification Authority - G3 O=GeoTrust Inc. OU=(c) 2008 GeoTrust Inc. - For authorized use only
# Label: "GeoTrust Primary Certification Authority - G3"
# Serial: 28809105769928564313984085209975885599
# MD5 Fingerprint: b5:e8:34:36:c9:10:44:58:48:70:6d:2e:83:d4:b8:05
# SHA1 Fingerprint: 03:9e:ed:b8:0b:e7:a0:3c:69:53:89:3b:20:d2:d9:32:3a:4c:2a:fd
# SHA256 Fingerprint: b4:78:b8:12:25:0d:f8:78:63:5c:2a:a7:ec:7d:15:5e:aa:62:5e:e8:29:16:e2:cd:29:43:61:88:6c:d1:fb:d4
-----BEGIN CERTIFICATE-----
MIID/jCCAuagAwIBAgIQFaxulBmyeUtB9iepwxgPHzANBgkqhkiG9w0BAQsFADCB
mDELMAkGA1UEBhMCVVMxFjAUBgNVBAoTDUdlb1RydXN0IEluYy4xOTA3BgNVBAsT
MChjKSAyMDA4IEdlb1RydXN0IEluYy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25s
eTE2MDQGA1UEAxMtR2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhv
cml0eSAtIEczMB4XDTA4MDQwMjAwMDAwMFoXDTM3MTIwMTIzNTk1OVowgZgxCzAJ
BgNVBAYTAlVTMRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMTkwNwYDVQQLEzAoYykg
MjAwOCBHZW9UcnVzdCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxNjA0
BgNVBAMTLUdlb1RydXN0IFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkg
LSBHMzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANziXmJYHTNXOTIz
+uvLh4yn1ErdBojqZI4xmKU4kB6Yzy5jK/BGvESyiaHAKAxJcCGVn2TAppMSAmUm
hsalifD614SgcK9PGpc/BkTVyetyEH3kMSj7HGHmKAdEc5IiaacDiGydY8hS2pgn
5whMcD60yRLBxWeDXTPzAxHsatBT4tG6NmCUgLthY2xbF37fQJQeqw3CIShwiP/W
JmxsYAQlTlV+fe+/lEjetx3dcI0FX4ilm/LC7urRQEFtYjgdVgbFA0dRIBn8exAL
DmKudlW/X3e+PkkBUz2YJQN2JFodtNuJ6nnltrM7P7pMKEF/BqxqjsHQ9gUdfeZC
huOl1UcCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYw
HQYDVR0OBBYEFMR5yo6hTgMdHNxr2zFblD4/MH8tMA0GCSqGSIb3DQEBCwUAA4IB
AQAtxRPPVoB7eni9n64smefv2t+UXglpp+duaIy9cr5HqQ6XErhK8WTTOd8lNNTB
zU6B8A8ExCSzNJbGpqow32hhc9f5joWJ7w5elShKKiePEI4ufIbEAp7aDHdlDkQN
kv39sxY2+hENHYwOB4lqKVb3cvTdFZx3NWZXqxNT2I7BQMXXExZacse3aQHEerGD
AWh9jUGhlBjBJVz88P6DAod8DQ3PLghcSkANPuyBYeYk28rgDi0Hsj5W3I31QYUH
SJsMC8tJP33st/3LjWeJGqvtux6jAAgIFyqCXDFdRootD4abdNlF+9RAsXqqaC2G
spki4cErx5z481+oghLrGREt
-----END CERTIFICATE-----
# Issuer: CN=thawte Primary Root CA - G2 O=thawte, Inc. OU=(c) 2007 thawte, Inc. - For authorized use only
# Subject: CN=thawte Primary Root CA - G2 O=thawte, Inc. OU=(c) 2007 thawte, Inc. - For authorized use only
# Label: "thawte Primary Root CA - G2"
# Serial: 71758320672825410020661621085256472406
# MD5 Fingerprint: 74:9d:ea:60:24:c4:fd:22:53:3e:cc:3a:72:d9:29:4f
# SHA1 Fingerprint: aa:db:bc:22:23:8f:c4:01:a1:27:bb:38:dd:f4:1d:db:08:9e:f0:12
# SHA256 Fingerprint: a4:31:0d:50:af:18:a6:44:71:90:37:2a:86:af:af:8b:95:1f:fb:43:1d:83:7f:1e:56:88:b4:59:71:ed:15:57
-----BEGIN CERTIFICATE-----
MIICiDCCAg2gAwIBAgIQNfwmXNmET8k9Jj1Xm67XVjAKBggqhkjOPQQDAzCBhDEL
MAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5jLjE4MDYGA1UECxMvKGMp
IDIwMDcgdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxJDAi
BgNVBAMTG3RoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EgLSBHMjAeFw0wNzExMDUwMDAw
MDBaFw0zODAxMTgyMzU5NTlaMIGEMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMdGhh
d3RlLCBJbmMuMTgwNgYDVQQLEy8oYykgMjAwNyB0aGF3dGUsIEluYy4gLSBGb3Ig
YXV0aG9yaXplZCB1c2Ugb25seTEkMCIGA1UEAxMbdGhhd3RlIFByaW1hcnkgUm9v
dCBDQSAtIEcyMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEotWcgnuVnfFSeIf+iha/
BebfowJPDQfGAFG6DAJSLSKkQjnE/o/qycG+1E3/n3qe4rF8mq2nhglzh9HnmuN6
papu+7qzcMBniKI11KOasf2twu8x+qi58/sIxpHR+ymVo0IwQDAPBgNVHRMBAf8E
BTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUmtgAMADna3+FGO6Lts6K
DPgR4bswCgYIKoZIzj0EAwMDaQAwZgIxAN344FdHW6fmCsO99YCKlzUNG4k8VIZ3
KMqh9HneteY4sPBlcIx/AlTCv//YoT7ZzwIxAMSNlPzcU9LcnXgWHxUzI1NS41ox
XZ3Krr0TKUQNJ1uo52icEvdYPy5yAlejj6EULg==
-----END CERTIFICATE-----
# Issuer: CN=thawte Primary Root CA - G3 O=thawte, Inc. OU=Certification Services Division/(c) 2008 thawte, Inc. - For authorized use only
# Subject: CN=thawte Primary Root CA - G3 O=thawte, Inc. OU=Certification Services Division/(c) 2008 thawte, Inc. - For authorized use only
# Label: "thawte Primary Root CA - G3"
# Serial: 127614157056681299805556476275995414779
# MD5 Fingerprint: fb:1b:5d:43:8a:94:cd:44:c6:76:f2:43:4b:47:e7:31
# SHA1 Fingerprint: f1:8b:53:8d:1b:e9:03:b6:a6:f0:56:43:5b:17:15:89:ca:f3:6b:f2
# SHA256 Fingerprint: 4b:03:f4:58:07:ad:70:f2:1b:fc:2c:ae:71:c9:fd:e4:60:4c:06:4c:f5:ff:b6:86:ba:e5:db:aa:d7:fd:d3:4c
-----BEGIN CERTIFICATE-----
MIIEKjCCAxKgAwIBAgIQYAGXt0an6rS0mtZLL/eQ+zANBgkqhkiG9w0BAQsFADCB
rjELMAkGA1UEBhMCVVMxFTATBgNVBAoTDHRoYXd0ZSwgSW5jLjEoMCYGA1UECxMf
Q2VydGlmaWNhdGlvbiBTZXJ2aWNlcyBEaXZpc2lvbjE4MDYGA1UECxMvKGMpIDIw
MDggdGhhd3RlLCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxJDAiBgNV
BAMTG3RoYXd0ZSBQcmltYXJ5IFJvb3QgQ0EgLSBHMzAeFw0wODA0MDIwMDAwMDBa
Fw0zNzEyMDEyMzU5NTlaMIGuMQswCQYDVQQGEwJVUzEVMBMGA1UEChMMdGhhd3Rl
LCBJbmMuMSgwJgYDVQQLEx9DZXJ0aWZpY2F0aW9uIFNlcnZpY2VzIERpdmlzaW9u
MTgwNgYDVQQLEy8oYykgMjAwOCB0aGF3dGUsIEluYy4gLSBGb3IgYXV0aG9yaXpl
ZCB1c2Ugb25seTEkMCIGA1UEAxMbdGhhd3RlIFByaW1hcnkgUm9vdCBDQSAtIEcz
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsr8nLPvb2FvdeHsbnndm
gcs+vHyu86YnmjSjaDFxODNi5PNxZnmxqWWjpYvVj2AtP0LMqmsywCPLLEHd5N/8
YZzic7IilRFDGF/Eth9XbAoFWCLINkw6fKXRz4aviKdEAhN0cXMKQlkC+BsUa0Lf
b1+6a4KinVvnSr0eAXLbS3ToO39/fR8EtCab4LRarEc9VbjXsCZSKAExQGbY2SS9
9irY7CFJXJv2eul/VTV+lmuNk5Mny5K76qxAwJ/C+IDPXfRa3M50hqY+bAtTyr2S
zhkGcuYMXDhpxwTWvGzOW/b3aJzcJRVIiKHpqfiYnODz1TEoYRFsZ5aNOZnLwkUk
OQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNV
HQ4EFgQUrWyqlGCc7eT/+j4KdCtjA/e2Wb8wDQYJKoZIhvcNAQELBQADggEBABpA
2JVlrAmSicY59BDlqQ5mU1143vokkbvnRFHfxhY0Cu9qRFHqKweKA3rD6z8KLFIW
oCtDuSWQP3CpMyVtRRooOyfPqsMpQhvfO0zAMzRbQYi/aytlryjvsvXDqmbOe1bu
t8jLZ8HJnBoYuMTDSQPxYA5QzUbF83d597YV4Djbxy8ooAw/dyZ02SUS2jHaGh7c
KUGRIjxpp7sC8rZcJwOJ9Abqm+RyguOhCcHpABnTPtRwa7pxpqpYrvS76Wy274fM
m7v/OeZWYdMKp8RcTGB7BXcmer/YB1IsYvdwY9k5vG8cwnncdimvzsUsZAReiDZu
MdRAGmI0Nj81Aa6sY6A=
-----END CERTIFICATE-----
# Issuer: CN=GeoTrust Primary Certification Authority - G2 O=GeoTrust Inc. OU=(c) 2007 GeoTrust Inc. - For authorized use only
# Subject: CN=GeoTrust Primary Certification Authority - G2 O=GeoTrust Inc. OU=(c) 2007 GeoTrust Inc. - For authorized use only
# Label: "GeoTrust Primary Certification Authority - G2"
# Serial: 80682863203381065782177908751794619243
# MD5 Fingerprint: 01:5e:d8:6b:bd:6f:3d:8e:a1:31:f8:12:e0:98:73:6a
# SHA1 Fingerprint: 8d:17:84:d5:37:f3:03:7d:ec:70:fe:57:8b:51:9a:99:e6:10:d7:b0
# SHA256 Fingerprint: 5e:db:7a:c4:3b:82:a0:6a:87:61:e8:d7:be:49:79:eb:f2:61:1f:7d:d7:9b:f9:1c:1c:6b:56:6a:21:9e:d7:66
-----BEGIN CERTIFICATE-----
MIICrjCCAjWgAwIBAgIQPLL0SAoA4v7rJDteYD7DazAKBggqhkjOPQQDAzCBmDEL
MAkGA1UEBhMCVVMxFjAUBgNVBAoTDUdlb1RydXN0IEluYy4xOTA3BgNVBAsTMChj
KSAyMDA3IEdlb1RydXN0IEluYy4gLSBGb3IgYXV0aG9yaXplZCB1c2Ugb25seTE2
MDQGA1UEAxMtR2VvVHJ1c3QgUHJpbWFyeSBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0
eSAtIEcyMB4XDTA3MTEwNTAwMDAwMFoXDTM4MDExODIzNTk1OVowgZgxCzAJBgNV
BAYTAlVTMRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMTkwNwYDVQQLEzAoYykgMjAw
NyBHZW9UcnVzdCBJbmMuIC0gRm9yIGF1dGhvcml6ZWQgdXNlIG9ubHkxNjA0BgNV
BAMTLUdlb1RydXN0IFByaW1hcnkgQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgLSBH
MjB2MBAGByqGSM49AgEGBSuBBAAiA2IABBWx6P0DFUPlrOuHNxFi79KDNlJ9RVcL
So17VDs6bl8VAsBQps8lL33KSLjHUGMcKiEIfJo22Av+0SbFWDEwKCXzXV2juLal
tJLtbCyf691DiaI8S0iRHVDsJt/WYC69IaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAO
BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFBVfNVdRVfslsq0DafwBo/q+EVXVMAoG
CCqGSM49BAMDA2cAMGQCMGSWWaboCd6LuvpaiIjwH5HTRqjySkwCY/tsXzjbLkGT
qQ7mndwxHLKgpxgceeHHNgIwOlavmnRs9vuD4DPTCF+hnMJbn0bWtsuRBmOiBucz
rD6ogRLQy7rQkgu2npaqBA+K
-----END CERTIFICATE-----
# Issuer: CN=VeriSign Universal Root Certification Authority O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 2008 VeriSign, Inc. - For authorized use only
# Subject: CN=VeriSign Universal Root Certification Authority O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 2008 VeriSign, Inc. - For authorized use only
# Label: "VeriSign Universal Root Certification Authority"
# Serial: 85209574734084581917763752644031726877
# MD5 Fingerprint: 8e:ad:b5:01:aa:4d:81:e4:8c:1d:d1:e1:14:00:95:19
# SHA1 Fingerprint: 36:79:ca:35:66:87:72:30:4d:30:a5:fb:87:3b:0f:a7:7b:b7:0d:54
# SHA256 Fingerprint: 23:99:56:11:27:a5:71:25:de:8c:ef:ea:61:0d:df:2f:a0:78:b5:c8:06:7f:4e:82:82:90:bf:b8:60:e8:4b:3c
-----BEGIN CERTIFICATE-----
MIIEuTCCA6GgAwIBAgIQQBrEZCGzEyEDDrvkEhrFHTANBgkqhkiG9w0BAQsFADCB
vTELMAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQL
ExZWZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwOCBWZXJp
U2lnbiwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MTgwNgYDVQQDEy9W
ZXJpU2lnbiBVbml2ZXJzYWwgUm9vdCBDZXJ0aWZpY2F0aW9uIEF1dGhvcml0eTAe
Fw0wODA0MDIwMDAwMDBaFw0zNzEyMDEyMzU5NTlaMIG9MQswCQYDVQQGEwJVUzEX
MBUGA1UEChMOVmVyaVNpZ24sIEluYy4xHzAdBgNVBAsTFlZlcmlTaWduIFRydXN0
IE5ldHdvcmsxOjA4BgNVBAsTMShjKSAyMDA4IFZlcmlTaWduLCBJbmMuIC0gRm9y
IGF1dGhvcml6ZWQgdXNlIG9ubHkxODA2BgNVBAMTL1ZlcmlTaWduIFVuaXZlcnNh
bCBSb290IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIIBIjANBgkqhkiG9w0BAQEF
AAOCAQ8AMIIBCgKCAQEAx2E3XrEBNNti1xWb/1hajCMj1mCOkdeQmIN65lgZOIzF
9uVkhbSicfvtvbnazU0AtMgtc6XHaXGVHzk8skQHnOgO+k1KxCHfKWGPMiJhgsWH
H26MfF8WIFFE0XBPV+rjHOPMee5Y2A7Cs0WTwCznmhcrewA3ekEzeOEz4vMQGn+H
LL729fdC4uW/h2KJXwBL38Xd5HVEMkE6HnFuacsLdUYI0crSK5XQz/u5QGtkjFdN
/BMReYTtXlT2NJ8IAfMQJQYXStrxHXpma5hgZqTZ79IugvHw7wnqRMkVauIDbjPT
rJ9VAMf2CGqUuV/c4DPxhGD5WycRtPwW8rtWaoAljQIDAQABo4GyMIGvMA8GA1Ud
EwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgEGMG0GCCsGAQUFBwEMBGEwX6FdoFsw
WTBXMFUWCWltYWdlL2dpZjAhMB8wBwYFKw4DAhoEFI/l0xqGrI2Oa8PPgGrUSBgs
exkuMCUWI2h0dHA6Ly9sb2dvLnZlcmlzaWduLmNvbS92c2xvZ28uZ2lmMB0GA1Ud
DgQWBBS2d/ppSEefUxLVwuoHMnYH0ZcHGTANBgkqhkiG9w0BAQsFAAOCAQEASvj4
sAPmLGd75JR3Y8xuTPl9Dg3cyLk1uXBPY/ok+myDjEedO2Pzmvl2MpWRsXe8rJq+
seQxIcaBlVZaDrHC1LGmWazxY8u4TB1ZkErvkBYoH1quEPuBUDgMbMzxPcP1Y+Oz
4yHJJDnp/RVmRvQbEdBNc6N9Rvk97ahfYtTxP/jgdFcrGJ2BtMQo2pSXpXDrrB2+
BxHw1dvd5Yzw1TKwg+ZX4o+/vqGqvz0dtdQ46tewXDpPaj+PwGZsY6rp2aQW9IHR
lRQOfc2VNNnSj3BzgXucfr2YYdhFh5iQxeuGMMY1v/D/w1WIg0vvBZIGcfK4mJO3
7M2CYfE45k+XmCpajQ==
-----END CERTIFICATE-----
# Issuer: CN=VeriSign Class 3 Public Primary Certification Authority - G4 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 2007 VeriSign, Inc. - For authorized use only
# Subject: CN=VeriSign Class 3 Public Primary Certification Authority - G4 O=VeriSign, Inc. OU=VeriSign Trust Network/(c) 2007 VeriSign, Inc. - For authorized use only
# Label: "VeriSign Class 3 Public Primary Certification Authority - G4"
# Serial: 63143484348153506665311985501458640051
# MD5 Fingerprint: 3a:52:e1:e7:fd:6f:3a:e3:6f:f3:6f:99:1b:f9:22:41
# SHA1 Fingerprint: 22:d5:d8:df:8f:02:31:d1:8d:f7:9d:b7:cf:8a:2d:64:c9:3f:6c:3a
# SHA256 Fingerprint: 69:dd:d7:ea:90:bb:57:c9:3e:13:5d:c8:5e:a6:fc:d5:48:0b:60:32:39:bd:c4:54:fc:75:8b:2a:26:cf:7f:79
-----BEGIN CERTIFICATE-----
MIIDhDCCAwqgAwIBAgIQL4D+I4wOIg9IZxIokYesszAKBggqhkjOPQQDAzCByjEL
MAkGA1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZW
ZXJpU2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNyBWZXJpU2ln
biwgSW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJp
U2lnbiBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9y
aXR5IC0gRzQwHhcNMDcxMTA1MDAwMDAwWhcNMzgwMTE4MjM1OTU5WjCByjELMAkG
A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMR8wHQYDVQQLExZWZXJp
U2lnbiBUcnVzdCBOZXR3b3JrMTowOAYDVQQLEzEoYykgMjAwNyBWZXJpU2lnbiwg
SW5jLiAtIEZvciBhdXRob3JpemVkIHVzZSBvbmx5MUUwQwYDVQQDEzxWZXJpU2ln
biBDbGFzcyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5
IC0gRzQwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAASnVnp8Utpkmw4tXNherJI9/gHm
GUo9FANL+mAnINmDiWn6VMaaGF5VKmTeBvaNSjutEDxlPZCIBIngMGGzrl0Bp3ve
fLK+ymVhAIau2o970ImtTR1ZmkGxvEeA3J5iw/mjgbIwga8wDwYDVR0TAQH/BAUw
AwEB/zAOBgNVHQ8BAf8EBAMCAQYwbQYIKwYBBQUHAQwEYTBfoV2gWzBZMFcwVRYJ
aW1hZ2UvZ2lmMCEwHzAHBgUrDgMCGgQUj+XTGoasjY5rw8+AatRIGCx7GS4wJRYj
aHR0cDovL2xvZ28udmVyaXNpZ24uY29tL3ZzbG9nby5naWYwHQYDVR0OBBYEFLMW
kf3upm7ktS5Jj4d4gYDs5bG1MAoGCCqGSM49BAMDA2gAMGUCMGYhDBgmYFo4e1ZC
4Kf8NoRRkSAsdk1DPcQdhCPQrNZ8NQbOzWm9kA3bbEhCHQ6qQgIxAJw9SDkjOVga
FRJZap7v1VmyHVIsmXHNxynfGyphe3HR3vPA5Q06Sqotp9iGKt0uEA==
-----END CERTIFICATE-----
# Issuer: O=VeriSign, Inc. OU=Class 3 Public Primary Certification Authority
# Subject: O=VeriSign, Inc. OU=Class 3 Public Primary Certification Authority
# Label: "Verisign Class 3 Public Primary Certification Authority"
# Serial: 80507572722862485515306429940691309246
# MD5 Fingerprint: ef:5a:f1:33:ef:f1:cd:bb:51:02:ee:12:14:4b:96:c4
# SHA1 Fingerprint: a1:db:63:93:91:6f:17:e4:18:55:09:40:04:15:c7:02:40:b0:ae:6b
# SHA256 Fingerprint: a4:b6:b3:99:6f:c2:f3:06:b3:fd:86:81:bd:63:41:3d:8c:50:09:cc:4f:a3:29:c2:cc:f0:e2:fa:1b:14:03:05
-----BEGIN CERTIFICATE-----
MIICPDCCAaUCEDyRMcsf9tAbDpq40ES/Er4wDQYJKoZIhvcNAQEFBQAwXzELMAkG
A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFz
cyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTk2
MDEyOTAwMDAwMFoXDTI4MDgwMjIzNTk1OVowXzELMAkGA1UEBhMCVVMxFzAVBgNV
BAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFzcyAzIFB1YmxpYyBQcmlt
YXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGfMA0GCSqGSIb3DQEBAQUAA4GN
ADCBiQKBgQDJXFme8huKARS0EN8EQNvjV69qRUCPhAwL0TPZ2RHP7gJYHyX3KqhE
BarsAx94f56TuZoAqiN91qyFomNFx3InzPRMxnVx0jnvT0Lwdd8KkMaOIG+YD/is
I19wKTakyYbnsZogy1Olhec9vn2a/iRFM9x2Fe0PonFkTGUugWhFpwIDAQABMA0G
CSqGSIb3DQEBBQUAA4GBABByUqkFFBkyCEHwxWsKzH4PIRnN5GfcX6kb5sroc50i
2JhucwNhkcV8sEVAbkSdjbCxlnRhLQ2pRdKkkirWmnWXbj9T/UWZYB2oK0z5XqcJ
2HUw19JlYD1n1khVdWk/kfVIC0dpImmClr7JyDiGSnoscxlIaU5rfGW/D/xwzoiQ
-----END CERTIFICATE-----
# Issuer: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R3
# Subject: CN=GlobalSign O=GlobalSign OU=GlobalSign Root CA - R3
# Label: "GlobalSign Root CA - R3"
# Serial: 4835703278459759426209954
# MD5 Fingerprint: c5:df:b8:49:ca:05:13:55:ee:2d:ba:1a:c3:3e:b0:28
# SHA1 Fingerprint: d6:9b:56:11:48:f0:1c:77:c5:45:78:c1:09:26:df:5b:85:69:76:ad
# SHA256 Fingerprint: cb:b5:22:d7:b7:f1:27:ad:6a:01:13:86:5b:df:1c:d4:10:2e:7d:07:59:af:63:5a:7c:f4:72:0d:c9:63:c5:3b
-----BEGIN CERTIFICATE-----
MIIDXzCCAkegAwIBAgILBAAAAAABIVhTCKIwDQYJKoZIhvcNAQELBQAwTDEgMB4G
A1UECxMXR2xvYmFsU2lnbiBSb290IENBIC0gUjMxEzARBgNVBAoTCkdsb2JhbFNp
Z24xEzARBgNVBAMTCkdsb2JhbFNpZ24wHhcNMDkwMzE4MTAwMDAwWhcNMjkwMzE4
MTAwMDAwWjBMMSAwHgYDVQQLExdHbG9iYWxTaWduIFJvb3QgQ0EgLSBSMzETMBEG
A1UEChMKR2xvYmFsU2lnbjETMBEGA1UEAxMKR2xvYmFsU2lnbjCCASIwDQYJKoZI
hvcNAQEBBQADggEPADCCAQoCggEBAMwldpB5BngiFvXAg7aEyiie/QV2EcWtiHL8
RgJDx7KKnQRfJMsuS+FggkbhUqsMgUdwbN1k0ev1LKMPgj0MK66X17YUhhB5uzsT
gHeMCOFJ0mpiLx9e+pZo34knlTifBtc+ycsmWQ1z3rDI6SYOgxXG71uL0gRgykmm
KPZpO/bLyCiR5Z2KYVc3rHQU3HTgOu5yLy6c+9C7v/U9AOEGM+iCK65TpjoWc4zd
QQ4gOsC0p6Hpsk+QLjJg6VfLuQSSaGjlOCZgdbKfd/+RFO+uIEn8rUAVSNECMWEZ
XriX7613t2Saer9fwRPvm2L7DWzgVGkWqQPabumDk3F2xmmFghcCAwEAAaNCMEAw
DgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFI/wS3+o
LkUkrk1Q+mOai97i3Ru8MA0GCSqGSIb3DQEBCwUAA4IBAQBLQNvAUKr+yAzv95ZU
RUm7lgAJQayzE4aGKAczymvmdLm6AC2upArT9fHxD4q/c2dKg8dEe3jgr25sbwMp
jjM5RcOO5LlXbKr8EpbsU8Yt5CRsuZRj+9xTaGdWPoO4zzUhw8lo/s7awlOqzJCK
6fBdRoyV3XpYKBovHd7NADdBj+1EbddTKJd+82cEHhXXipa0095MJ6RMG3NzdvQX
mcIfeg7jLQitChws/zyrVQ4PkX4268NXSb7hLi18YIvDQVETI53O9zJrlAGomecs
Mx86OyXShkDOOyyGeMlhLxS67ttVb9+E7gUJTb0o2HLO02JQZR7rkpeDMdmztcpH
WD9f
-----END CERTIFICATE-----
# Issuer: CN=TC TrustCenter Universal CA III O=TC TrustCenter GmbH OU=TC TrustCenter Universal CA
# Subject: CN=TC TrustCenter Universal CA III O=TC TrustCenter GmbH OU=TC TrustCenter Universal CA
# Label: "TC TrustCenter Universal CA III"
# Serial: 2010889993983507346460533407902964
# MD5 Fingerprint: 9f:dd:db:ab:ff:8e:ff:45:21:5f:f0:6c:9d:8f:fe:2b
# SHA1 Fingerprint: 96:56:cd:7b:57:96:98:95:d0:e1:41:46:68:06:fb:b8:c6:11:06:87
# SHA256 Fingerprint: 30:9b:4a:87:f6:ca:56:c9:31:69:aa:a9:9c:6d:98:88:54:d7:89:2b:d5:43:7e:2d:07:b2:9c:be:da:55:d3:5d
-----BEGIN CERTIFICATE-----
MIID4TCCAsmgAwIBAgIOYyUAAQACFI0zFQLkbPQwDQYJKoZIhvcNAQEFBQAwezEL
MAkGA1UEBhMCREUxHDAaBgNVBAoTE1RDIFRydXN0Q2VudGVyIEdtYkgxJDAiBgNV
BAsTG1RDIFRydXN0Q2VudGVyIFVuaXZlcnNhbCBDQTEoMCYGA1UEAxMfVEMgVHJ1
c3RDZW50ZXIgVW5pdmVyc2FsIENBIElJSTAeFw0wOTA5MDkwODE1MjdaFw0yOTEy
MzEyMzU5NTlaMHsxCzAJBgNVBAYTAkRFMRwwGgYDVQQKExNUQyBUcnVzdENlbnRl
ciBHbWJIMSQwIgYDVQQLExtUQyBUcnVzdENlbnRlciBVbml2ZXJzYWwgQ0ExKDAm
BgNVBAMTH1RDIFRydXN0Q2VudGVyIFVuaXZlcnNhbCBDQSBJSUkwggEiMA0GCSqG
SIb3DQEBAQUAA4IBDwAwggEKAoIBAQDC2pxisLlxErALyBpXsq6DFJmzNEubkKLF
5+cvAqBNLaT6hdqbJYUtQCggbergvbFIgyIpRJ9Og+41URNzdNW88jBmlFPAQDYv
DIRlzg9uwliT6CwLOunBjvvya8o84pxOjuT5fdMnnxvVZ3iHLX8LR7PH6MlIfK8v
zArZQe+f/prhsq75U7Xl6UafYOPfjdN/+5Z+s7Vy+EutCHnNaYlAJ/Uqwa1D7KRT
yGG299J5KmcYdkhtWyUB0SbFt1dpIxVbYYqt8Bst2a9c8SaQaanVDED1M4BDj5yj
dipFtK+/fz6HP3bFzSreIMUWWMv5G/UPyw0RUmS40nZid4PxWJ//AgMBAAGjYzBh
MB8GA1UdIwQYMBaAFFbn4VslQ4Dg9ozhcbyO5YAvxEjiMA8GA1UdEwEB/wQFMAMB
Af8wDgYDVR0PAQH/BAQDAgEGMB0GA1UdDgQWBBRW5+FbJUOA4PaM4XG8juWAL8RI
4jANBgkqhkiG9w0BAQUFAAOCAQEAg8ev6n9NCjw5sWi+e22JLumzCecYV42Fmhfz
dkJQEw/HkG8zrcVJYCtsSVgZ1OK+t7+rSbyUyKu+KGwWaODIl0YgoGhnYIg5IFHY
aAERzqf2EQf27OysGh+yZm5WZ2B6dF7AbZc2rrUNXWZzwCUyRdhKBgePxLcHsU0G
DeGl6/R1yrqc0L2z0zIkTO5+4nYES0lT2PLpVDP85XEfPRRclkvxOvIAu2y0+pZV
CIgJwcyRGSmwIC3/yzikQOEXvnlhgP8HA4ZMTnsGnxGGjYnuJ8Tb4rwZjgvDwxPH
LQNjO9Po5KIqwoIIlBZU8O8fJ5AluA0OKBtHd0e9HKgl8ZS0Zg==
-----END CERTIFICATE-----
# Issuer: CN=Go Daddy Root Certificate Authority - G2 O=GoDaddy.com, Inc.
# Subject: CN=Go Daddy Root Certificate Authority - G2 O=GoDaddy.com, Inc.
# Label: "Go Daddy Root Certificate Authority - G2"
# Serial: 0
# MD5 Fingerprint: 80:3a:bc:22:c1:e6:fb:8d:9b:3b:27:4a:32:1b:9a:01
# SHA1 Fingerprint: 47:be:ab:c9:22:ea:e8:0e:78:78:34:62:a7:9f:45:c2:54:fd:e6:8b
# SHA256 Fingerprint: 45:14:0b:32:47:eb:9c:c8:c5:b4:f0:d7:b5:30:91:f7:32:92:08:9e:6e:5a:63:e2:74:9d:d3:ac:a9:19:8e:da
-----BEGIN CERTIFICATE-----
MIIDxTCCAq2gAwIBAgIBADANBgkqhkiG9w0BAQsFADCBgzELMAkGA1UEBhMCVVMx
EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxGjAYBgNVBAoT
EUdvRGFkZHkuY29tLCBJbmMuMTEwLwYDVQQDEyhHbyBEYWRkeSBSb290IENlcnRp
ZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAwMFoXDTM3MTIzMTIz
NTk1OVowgYMxCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6b25hMRMwEQYDVQQH
EwpTY290dHNkYWxlMRowGAYDVQQKExFHb0RhZGR5LmNvbSwgSW5jLjExMC8GA1UE
AxMoR28gRGFkZHkgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIw
DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAL9xYgjx+lk09xvJGKP3gElY6SKD
E6bFIEMBO4Tx5oVJnyfq9oQbTqC023CYxzIBsQU+B07u9PpPL1kwIuerGVZr4oAH
/PMWdYA5UXvl+TW2dE6pjYIT5LY/qQOD+qK+ihVqf94Lw7YZFAXK6sOoBJQ7Rnwy
DfMAZiLIjWltNowRGLfTshxgtDj6AozO091GB94KPutdfMh8+7ArU6SSYmlRJQVh
GkSBjCypQ5Yj36w6gZoOKcUcqeldHraenjAKOc7xiID7S13MMuyFYkMlNAJWJwGR
tDtwKj9useiciAF9n9T521NtYJ2/LOdYq7hfRvzOxBsDPAnrSTFcaUaz4EcCAwEA
AaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYE
FDqahQcQZyi27/a9BUFuIMGU2g/eMA0GCSqGSIb3DQEBCwUAA4IBAQCZ21151fmX
WWcDYfF+OwYxdS2hII5PZYe096acvNjpL9DbWu7PdIxztDhC2gV7+AJ1uP2lsdeu
9tfeE8tTEH6KRtGX+rcuKxGrkLAngPnon1rpN5+r5N9ss4UXnT3ZJE95kTXWXwTr
gIOrmgIttRD02JDHBHNA7XIloKmf7J6raBKZV8aPEjoJpL1E/QYVN8Gb5DKj7Tjo
2GTzLH4U/ALqn83/B2gX2yKQOC16jdFU8WnjXzPKej17CuPKf1855eJ1usV2GDPO
LPAvTK33sefOT6jEm0pUBsV/fdUID+Ic/n4XuKxe9tQWskMJDE32p2u0mYRlynqI
4uJEvlz36hz1
-----END CERTIFICATE-----
# Issuer: CN=Starfield Root Certificate Authority - G2 O=Starfield Technologies, Inc.
# Subject: CN=Starfield Root Certificate Authority - G2 O=Starfield Technologies, Inc.
# Label: "Starfield Root Certificate Authority - G2"
# Serial: 0
# MD5 Fingerprint: d6:39:81:c6:52:7e:96:69:fc:fc:ca:66:ed:05:f2:96
# SHA1 Fingerprint: b5:1c:06:7c:ee:2b:0c:3d:f8:55:ab:2d:92:f4:fe:39:d4:e7:0f:0e
# SHA256 Fingerprint: 2c:e1:cb:0b:f9:d2:f9:e1:02:99:3f:be:21:51:52:c3:b2:dd:0c:ab:de:1c:68:e5:31:9b:83:91:54:db:b7:f5
-----BEGIN CERTIFICATE-----
MIID3TCCAsWgAwIBAgIBADANBgkqhkiG9w0BAQsFADCBjzELMAkGA1UEBhMCVVMx
EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT
HFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xMjAwBgNVBAMTKVN0YXJmaWVs
ZCBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5MDkwMTAwMDAw
MFoXDTM3MTIzMTIzNTk1OVowgY8xCzAJBgNVBAYTAlVTMRAwDgYDVQQIEwdBcml6
b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFyZmllbGQgVGVj
aG5vbG9naWVzLCBJbmMuMTIwMAYDVQQDEylTdGFyZmllbGQgUm9vdCBDZXJ0aWZp
Y2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoC
ggEBAL3twQP89o/8ArFvW59I2Z154qK3A2FWGMNHttfKPTUuiUP3oWmb3ooa/RMg
nLRJdzIpVv257IzdIvpy3Cdhl+72WoTsbhm5iSzchFvVdPtrX8WJpRBSiUZV9Lh1
HOZ/5FSuS/hVclcCGfgXcVnrHigHdMWdSL5stPSksPNkN3mSwOxGXn/hbVNMYq/N
Hwtjuzqd+/x5AJhhdM8mgkBj87JyahkNmcrUDnXMN/uLicFZ8WJ/X7NfZTD4p7dN
dloedl40wOiWVpmKs/B/pM293DIxfJHP4F8R+GuqSVzRmZTRouNjWwl2tVZi4Ut0
HZbUJtQIBFnQmA4O5t78w+wfkPECAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAO
BgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFHwMMh+n2TB/xH1oo2Kooc6rB1snMA0G
CSqGSIb3DQEBCwUAA4IBAQARWfolTwNvlJk7mh+ChTnUdgWUXuEok21iXQnCoKjU
sHU48TRqneSfioYmUeYs0cYtbpUgSpIB7LiKZ3sx4mcujJUDJi5DnUox9g61DLu3
4jd/IroAow57UvtruzvE03lRTs2Q9GcHGcg8RnoNAX3FWOdt5oUwF5okxBDgBPfg
8n/Uqgr/Qh037ZTlZFkSIHc40zI+OIF1lnP6aI+xy84fxez6nH7PfrHxBy22/L/K
pL/QlwVKvOoYKAKQvVR4CSFx09F9HdkWsKlhPdAKACL8x3vLCWRFCztAgfd9fDL1
mMpYjn0q7pBZc2T5NnReJaH1ZgUufzkVqSr7UIuOhWn0
-----END CERTIFICATE-----
# Issuer: CN=Starfield Services Root Certificate Authority - G2 O=Starfield Technologies, Inc.
# Subject: CN=Starfield Services Root Certificate Authority - G2 O=Starfield Technologies, Inc.
# Label: "Starfield Services Root Certificate Authority - G2"
# Serial: 0
# MD5 Fingerprint: 17:35:74:af:7b:61:1c:eb:f4:f9:3c:e2:ee:40:f9:a2
# SHA1 Fingerprint: 92:5a:8f:8d:2c:6d:04:e0:66:5f:59:6a:ff:22:d8:63:e8:25:6f:3f
# SHA256 Fingerprint: 56:8d:69:05:a2:c8:87:08:a4:b3:02:51:90:ed:cf:ed:b1:97:4a:60:6a:13:c6:e5:29:0f:cb:2a:e6:3e:da:b5
-----BEGIN CERTIFICATE-----
MIID7zCCAtegAwIBAgIBADANBgkqhkiG9w0BAQsFADCBmDELMAkGA1UEBhMCVVMx
EDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT
HFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xOzA5BgNVBAMTMlN0YXJmaWVs
ZCBTZXJ2aWNlcyBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5
MDkwMTAwMDAwMFoXDTM3MTIzMTIzNTk1OVowgZgxCzAJBgNVBAYTAlVTMRAwDgYD
VQQIEwdBcml6b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFy
ZmllbGQgVGVjaG5vbG9naWVzLCBJbmMuMTswOQYDVQQDEzJTdGFyZmllbGQgU2Vy
dmljZXMgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZI
hvcNAQEBBQADggEPADCCAQoCggEBANUMOsQq+U7i9b4Zl1+OiFOxHz/Lz58gE20p
OsgPfTz3a3Y4Y9k2YKibXlwAgLIvWX/2h/klQ4bnaRtSmpDhcePYLQ1Ob/bISdm2
8xpWriu2dBTrz/sm4xq6HZYuajtYlIlHVv8loJNwU4PahHQUw2eeBGg6345AWh1K
Ts9DkTvnVtYAcMtS7nt9rjrnvDH5RfbCYM8TWQIrgMw0R9+53pBlbQLPLJGmpufe
hRhJfGZOozptqbXuNC66DQO4M99H67FrjSXZm86B0UVGMpZwh94CDklDhbZsc7tk
6mFBrMnUVN+HL8cisibMn1lUaJ/8viovxFUcdUBgF4UCVTmLfwUCAwEAAaNCMEAw
DwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFJxfAN+q
AdcwKziIorhtSpzyEZGDMA0GCSqGSIb3DQEBCwUAA4IBAQBLNqaEd2ndOxmfZyMI
bw5hyf2E3F/YNoHN2BtBLZ9g3ccaaNnRbobhiCPPE95Dz+I0swSdHynVv/heyNXB
ve6SbzJ08pGCL72CQnqtKrcgfU28elUSwhXqvfdqlS5sdJ/PHLTyxQGjhdByPq1z
qwubdQxtRbeOlKyWN7Wg0I8VRw7j6IPdj/3vQQF3zCepYoUz8jcI73HPdwbeyBkd
iEDPfUYd/x7H4c7/I9vG+o1VTqkC50cRRj70/b17KSa7qWFiNyi2LSr2EIZkyXCn
0q23KXB56jzaYyWf/Wi3MOxw+3WKt21gZ7IeyLnp2KhvAotnDU0mV3HaIPzBSlCN
sSi6
-----END CERTIFICATE-----
# Issuer: CN=AffirmTrust Commercial O=AffirmTrust
# Subject: CN=AffirmTrust Commercial O=AffirmTrust
# Label: "AffirmTrust Commercial"
# Serial: 8608355977964138876
# MD5 Fingerprint: 82:92:ba:5b:ef:cd:8a:6f:a6:3d:55:f9:84:f6:d6:b7
# SHA1 Fingerprint: f9:b5:b6:32:45:5f:9c:be:ec:57:5f:80:dc:e9:6e:2c:c7:b2:78:b7
# SHA256 Fingerprint: 03:76:ab:1d:54:c5:f9:80:3c:e4:b2:e2:01:a0:ee:7e:ef:7b:57:b6:36:e8:a9:3c:9b:8d:48:60:c9:6f:5f:a7
-----BEGIN CERTIFICATE-----
MIIDTDCCAjSgAwIBAgIId3cGJyapsXwwDQYJKoZIhvcNAQELBQAwRDELMAkGA1UE
BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZpcm1UcnVz
dCBDb21tZXJjaWFsMB4XDTEwMDEyOTE0MDYwNloXDTMwMTIzMTE0MDYwNlowRDEL
MAkGA1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZp
cm1UcnVzdCBDb21tZXJjaWFsMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
AQEA9htPZwcroRX1BiLLHwGy43NFBkRJLLtJJRTWzsO3qyxPxkEylFf6EqdbDuKP
Hx6GGaeqtS25Xw2Kwq+FNXkyLbscYjfysVtKPcrNcV/pQr6U6Mje+SJIZMblq8Yr
ba0F8PrVC8+a5fBQpIs7R6UjW3p6+DM/uO+Zl+MgwdYoic+U+7lF7eNAFxHUdPAL
MeIrJmqbTFeurCA+ukV6BfO9m2kVrn1OIGPENXY6BwLJN/3HR+7o8XYdcxXyl6S1
yHp52UKqK39c/s4mT6NmgTWvRLpUHhwwMmWd5jyTXlBOeuM61G7MGvv50jeuJCqr
VwMiKA1JdX+3KNp1v47j3A55MQIDAQABo0IwQDAdBgNVHQ4EFgQUnZPGU4teyq8/
nx4P5ZmVvCT2lI8wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJ
KoZIhvcNAQELBQADggEBAFis9AQOzcAN/wr91LoWXym9e2iZWEnStB03TX8nfUYG
XUPGhi4+c7ImfU+TqbbEKpqrIZcUsd6M06uJFdhrJNTxFq7YpFzUf1GO7RgBsZNj
vbz4YYCanrHOQnDiqX0GJX0nof5v7LMeJNrjS1UaADs1tDvZ110w/YETifLCBivt
Z8SOyUOyXGsViQK8YvxO8rUzqrJv0wqiUOP2O+guRMLbZjipM1ZI8W0bM40NjD9g
N53Tym1+NH4Nn3J2ixufcv1SNUFFApYvHLKac0khsUlHRUe072o0EclNmsxZt9YC
nlpOZbWUrhvfKbAW8b8Angc6F2S1BLUjIZkKlTuXfO8=
-----END CERTIFICATE-----
# Issuer: CN=AffirmTrust Networking O=AffirmTrust
# Subject: CN=AffirmTrust Networking O=AffirmTrust
# Label: "AffirmTrust Networking"
# Serial: 8957382827206547757
# MD5 Fingerprint: 42:65:ca:be:01:9a:9a:4c:a9:8c:41:49:cd:c0:d5:7f
# SHA1 Fingerprint: 29:36:21:02:8b:20:ed:02:f5:66:c5:32:d1:d6:ed:90:9f:45:00:2f
# SHA256 Fingerprint: 0a:81:ec:5a:92:97:77:f1:45:90:4a:f3:8d:5d:50:9f:66:b5:e2:c5:8f:cd:b5:31:05:8b:0e:17:f3:f0:b4:1b
-----BEGIN CERTIFICATE-----
MIIDTDCCAjSgAwIBAgIIfE8EORzUmS0wDQYJKoZIhvcNAQEFBQAwRDELMAkGA1UE
BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZpcm1UcnVz
dCBOZXR3b3JraW5nMB4XDTEwMDEyOTE0MDgyNFoXDTMwMTIzMTE0MDgyNFowRDEL
MAkGA1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MR8wHQYDVQQDDBZBZmZp
cm1UcnVzdCBOZXR3b3JraW5nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKC
AQEAtITMMxcua5Rsa2FSoOujz3mUTOWUgJnLVWREZY9nZOIG41w3SfYvm4SEHi3y
YJ0wTsyEheIszx6e/jarM3c1RNg1lho9Nuh6DtjVR6FqaYvZ/Ls6rnla1fTWcbua
kCNrmreIdIcMHl+5ni36q1Mr3Lt2PpNMCAiMHqIjHNRqrSK6mQEubWXLviRmVSRL
QESxG9fhwoXA3hA/Pe24/PHxI1Pcv2WXb9n5QHGNfb2V1M6+oF4nI979ptAmDgAp
6zxG8D1gvz9Q0twmQVGeFDdCBKNwV6gbh+0t+nvujArjqWaJGctB+d1ENmHP4ndG
yH329JKBNv3bNPFyfvMMFr20FQIDAQABo0IwQDAdBgNVHQ4EFgQUBx/S55zawm6i
QLSwelAQUHTEyL0wDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwDQYJ
KoZIhvcNAQEFBQADggEBAIlXshZ6qML91tmbmzTCnLQyFE2npN/svqe++EPbkTfO
tDIuUFUaNU52Q3Eg75N3ThVwLofDwR1t3Mu1J9QsVtFSUzpE0nPIxBsFZVpikpzu
QY0x2+c06lkh1QF612S4ZDnNye2v7UsDSKegmQGA3GWjNq5lWUhPgkvIZfFXHeVZ
Lgo/bNjR9eUJtGxUAArgFU2HdW23WJZa3W3SAKD0m0i+wzekujbgfIeFlxoVot4u
olu9rxj5kFDNcFn4J2dHy8egBzp90SxdbBk6ZrV9/ZFvgrG+CJPbFEfxojfHRZ48
x3evZKiT3/Zpg4Jg8klCNO1aAFSFHBY2kgxc+qatv9s=
-----END CERTIFICATE-----
# Issuer: CN=AffirmTrust Premium O=AffirmTrust
# Subject: CN=AffirmTrust Premium O=AffirmTrust
# Label: "AffirmTrust Premium"
# Serial: 7893706540734352110
# MD5 Fingerprint: c4:5d:0e:48:b6:ac:28:30:4e:0a:bc:f9:38:16:87:57
# SHA1 Fingerprint: d8:a6:33:2c:e0:03:6f:b1:85:f6:63:4f:7d:6a:06:65:26:32:28:27
# SHA256 Fingerprint: 70:a7:3f:7f:37:6b:60:07:42:48:90:45:34:b1:14:82:d5:bf:0e:69:8e:cc:49:8d:f5:25:77:eb:f2:e9:3b:9a
-----BEGIN CERTIFICATE-----
MIIFRjCCAy6gAwIBAgIIbYwURrGmCu4wDQYJKoZIhvcNAQEMBQAwQTELMAkGA1UE
BhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MRwwGgYDVQQDDBNBZmZpcm1UcnVz
dCBQcmVtaXVtMB4XDTEwMDEyOTE0MTAzNloXDTQwMTIzMTE0MTAzNlowQTELMAkG
A1UEBhMCVVMxFDASBgNVBAoMC0FmZmlybVRydXN0MRwwGgYDVQQDDBNBZmZpcm1U
cnVzdCBQcmVtaXVtMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAxBLf
qV/+Qd3d9Z+K4/as4Tx4mrzY8H96oDMq3I0gW64tb+eT2TZwamjPjlGjhVtnBKAQ
JG9dKILBl1fYSCkTtuG+kU3fhQxTGJoeJKJPj/CihQvL9Cl/0qRY7iZNyaqoe5rZ
+jjeRFcV5fiMyNlI4g0WJx0eyIOFJbe6qlVBzAMiSy2RjYvmia9mx+n/K+k8rNrS
s8PhaJyJ+HoAVt70VZVs+7pk3WKL3wt3MutizCaam7uqYoNMtAZ6MMgpv+0GTZe5
HMQxK9VfvFMSF5yZVylmd2EhMQcuJUmdGPLu8ytxjLW6OQdJd/zvLpKQBY0tL3d7
70O/Nbua2Plzpyzy0FfuKE4mX4+QaAkvuPjcBukumj5Rp9EixAqnOEhss/n/fauG
V+O61oV4d7pD6kh/9ti+I20ev9E2bFhc8e6kGVQa9QPSdubhjL08s9NIS+LI+H+S
qHZGnEJlPqQewQcDWkYtuJfzt9WyVSHvutxMAJf7FJUnM7/oQ0dG0giZFmA7mn7S
5u046uwBHjxIVkkJx0w3AJ6IDsBz4W9m6XJHMD4Q5QsDyZpCAGzFlH5hxIrff4Ia
C1nEWTJ3s7xgaVY5/bQGeyzWZDbZvUjthB9+pSKPKrhC9IK31FOQeE4tGv2Bb0TX
OwF0lkLgAOIua+rF7nKsu7/+6qqo+Nz2snmKtmcCAwEAAaNCMEAwHQYDVR0OBBYE
FJ3AZ6YMItkm9UWrpmVSESfYRaxjMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/
BAQDAgEGMA0GCSqGSIb3DQEBDAUAA4ICAQCzV00QYk465KzquByvMiPIs0laUZx2
KI15qldGF9X1Uva3ROgIRL8YhNILgM3FEv0AVQVhh0HctSSePMTYyPtwni94loMg
Nt58D2kTiKV1NpgIpsbfrM7jWNa3Pt668+s0QNiigfV4Py/VpfzZotReBA4Xrf5B
8OWycvpEgjNC6C1Y91aMYj+6QrCcDFx+LmUmXFNPALJ4fqENmS2NuB2OosSw/WDQ
MKSOyARiqcTtNd56l+0OOF6SL5Nwpamcb6d9Ex1+xghIsV5n61EIJenmJWtSKZGc
0jlzCFfemQa0W50QBuHCAKi4HEoCChTQwUHK+4w1IX2COPKpVJEZNZOUbWo6xbLQ
u4mGk+ibyQ86p3q4ofB4Rvr8Ny/lioTz3/4E2aFooC8k4gmVBtWVyuEklut89pMF
u+1z6S3RdTnX5yTb2E5fQ4+e0BQ5v1VwSJlXMbSc7kqYA5YwH2AG7hsj/oFgIxpH
YoWlzBk0gG+zrBrjn/B7SK3VAdlntqlyk+otZrWyuOQ9PLLvTIzq6we/qzWaVYa8
GKa1qF60g2xraUDTn9zxw2lrueFtCfTxqlB2Cnp9ehehVZZCmTEJ3WARjQUwfuaO
RtGdFNrHF+QFlozEJLUbzxQHskD4o55BhrwE0GuWyCqANP2/7waj3VjFhT0+j/6e
KeC2uAloGRwYQw==
-----END CERTIFICATE-----
# Issuer: CN=AffirmTrust Premium ECC O=AffirmTrust
# Subject: CN=AffirmTrust Premium ECC O=AffirmTrust
# Label: "AffirmTrust Premium ECC"
# Serial: 8401224907861490260
# MD5 Fingerprint: 64:b0:09:55:cf:b1:d5:99:e2:be:13:ab:a6:5d:ea:4d
# SHA1 Fingerprint: b8:23:6b:00:2f:1d:16:86:53:01:55:6c:11:a4:37:ca:eb:ff:c3:bb
# SHA256 Fingerprint: bd:71:fd:f6:da:97:e4:cf:62:d1:64:7a:dd:25:81:b0:7d:79:ad:f8:39:7e:b4:ec:ba:9c:5e:84:88:82:14:23
-----BEGIN CERTIFICATE-----
MIIB/jCCAYWgAwIBAgIIdJclisc/elQwCgYIKoZIzj0EAwMwRTELMAkGA1UEBhMC
VVMxFDASBgNVBAoMC0FmZmlybVRydXN0MSAwHgYDVQQDDBdBZmZpcm1UcnVzdCBQ
cmVtaXVtIEVDQzAeFw0xMDAxMjkxNDIwMjRaFw00MDEyMzExNDIwMjRaMEUxCzAJ
BgNVBAYTAlVTMRQwEgYDVQQKDAtBZmZpcm1UcnVzdDEgMB4GA1UEAwwXQWZmaXJt
VHJ1c3QgUHJlbWl1bSBFQ0MwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQNMF4bFZ0D
0KF5Nbc6PJJ6yhUczWLznCZcBz3lVPqj1swS6vQUX+iOGasvLkjmrBhDeKzQN8O9
ss0s5kfiGuZjuD0uL3jET9v0D6RoTFVya5UdThhClXjMNzyR4ptlKymjQjBAMB0G
A1UdDgQWBBSaryl6wBE1NSZRMADDav5A1a7WPDAPBgNVHRMBAf8EBTADAQH/MA4G
A1UdDwEB/wQEAwIBBjAKBggqhkjOPQQDAwNnADBkAjAXCfOHiFBar8jAQr9HX/Vs
aobgxCd05DhT1wV/GzTjxi+zygk8N53X57hG8f2h4nECMEJZh0PUUd+60wkyWs6I
flc9nF9Ca/UHLbXwgpP5WW+uZPpY5Yse42O+tYHNbwKMeQ==
-----END CERTIFICATE-----
# Issuer: CN=StartCom Certification Authority O=StartCom Ltd. OU=Secure Digital Certificate Signing
# Subject: CN=StartCom Certification Authority O=StartCom Ltd. OU=Secure Digital Certificate Signing
# Label: "StartCom Certification Authority"
# Serial: 45
# MD5 Fingerprint: c9:3b:0d:84:41:fc:a4:76:79:23:08:57:de:10:19:16
# SHA1 Fingerprint: a3:f1:33:3f:e2:42:bf:cf:c5:d1:4e:8f:39:42:98:40:68:10:d1:a0
# SHA256 Fingerprint: e1:78:90:ee:09:a3:fb:f4:f4:8b:9c:41:4a:17:d6:37:b7:a5:06:47:e9:bc:75:23:22:72:7f:cc:17:42:a9:11
-----BEGIN CERTIFICATE-----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-----END CERTIFICATE-----
# Issuer: CN=StartCom Certification Authority G2 O=StartCom Ltd.
# Subject: CN=StartCom Certification Authority G2 O=StartCom Ltd.
# Label: "StartCom Certification Authority G2"
# Serial: 59
# MD5 Fingerprint: 78:4b:fb:9e:64:82:0a:d3:b8:4c:62:f3:64:f2:90:64
# SHA1 Fingerprint: 31:f1:fd:68:22:63:20:ee:c6:3b:3f:9d:ea:4a:3e:53:7c:7c:39:17
# SHA256 Fingerprint: c7:ba:65:67:de:93:a7:98:ae:1f:aa:79:1e:71:2d:37:8f:ae:1f:93:c4:39:7f:ea:44:1b:b7:cb:e6:fd:59:95
-----BEGIN CERTIFICATE-----
MIIFYzCCA0ugAwIBAgIBOzANBgkqhkiG9w0BAQsFADBTMQswCQYDVQQGEwJJTDEW
MBQGA1UEChMNU3RhcnRDb20gTHRkLjEsMCoGA1UEAxMjU3RhcnRDb20gQ2VydGlm
aWNhdGlvbiBBdXRob3JpdHkgRzIwHhcNMTAwMTAxMDEwMDAxWhcNMzkxMjMxMjM1
OTAxWjBTMQswCQYDVQQGEwJJTDEWMBQGA1UEChMNU3RhcnRDb20gTHRkLjEsMCoG
A1UEAxMjU3RhcnRDb20gQ2VydGlmaWNhdGlvbiBBdXRob3JpdHkgRzIwggIiMA0G
CSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQC2iTZbB7cgNr2Cu+EWIAOVeq8Oo1XJ
JZlKxdBWQYeQTSFgpBSHO839sj60ZwNq7eEPS8CRhXBF4EKe3ikj1AENoBB5uNsD
vfOpL9HG4A/LnooUCri99lZi8cVytjIl2bLzvWXFDSxu1ZJvGIsAQRSCb0AgJnoo
D/Uefyf3lLE3PbfHkffiAez9lInhzG7TNtYKGXmu1zSCZf98Qru23QumNK9LYP5/
Q0kGi4xDuFby2X8hQxfqp0iVAXV16iulQ5XqFYSdCI0mblWbq9zSOdIxHWDirMxW
RST1HFSr7obdljKF+ExP6JV2tgXdNiNnvP8V4so75qbsO+wmETRIjfaAKxojAuuK
HDp2KntWFhxyKrOq42ClAJ8Em+JvHhRYW6Vsi1g8w7pOOlz34ZYrPu8HvKTlXcxN
nw3h3Kq74W4a7I/htkxNeXJdFzULHdfBR9qWJODQcqhaX2YtENwvKhOuJv4KHBnM
0D4LnMgJLvlblnpHnOl68wVQdJVznjAJ85eCXuaPOQgeWeU1FEIT/wCc976qUM/i
UUjXuG+v+E5+M5iSFGI6dWPPe/regjupuznixL0sAA7IF6wT700ljtizkC+p2il9
Ha90OrInwMEePnWjFqmveiJdnxMaz6eg6+OGCtP95paV1yPIN93EfKo2rJgaErHg
TuixO/XWb/Ew1wIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MA4GA1UdDwEB/wQE
AwIBBjAdBgNVHQ4EFgQUS8W0QGutHLOlHGVuRjaJhwUMDrYwDQYJKoZIhvcNAQEL
BQADggIBAHNXPyzVlTJ+N9uWkusZXn5T50HsEbZH77Xe7XRcxfGOSeD8bpkTzZ+K
2s06Ctg6Wgk/XzTQLwPSZh0avZyQN8gMjgdalEVGKua+etqhqaRpEpKwfTbURIfX
UfEpY9Z1zRbkJ4kd+MIySP3bmdCPX1R0zKxnNBFi2QwKN4fRoxdIjtIXHfbX/dtl
6/2o1PXWT6RbdejF0mCy2wl+JYt7ulKSnj7oxXehPOBKc2thz4bcQ///If4jXSRK
9dNtD2IEBVeC2m6kMyV5Sy5UGYvMLD0w6dEG/+gyRr61M3Z3qAFdlsHB1b6uJcDJ
HgoJIIihDsnzb02CVAAgp9KP5DlUFy6NHrgbuxu9mk47EDTcnIhT76IxW1hPkWLI
wpqazRVdOKnWvvgTtZ8SafJQYqz7Fzf07rh1Z2AQ+4NQ+US1dZxAF7L+/XldblhY
XzD8AK6vM8EOTmy6p6ahfzLbOOCxchcKK5HsamMm7YnUeMx0HgX4a/6ManY5Ka5l
IxKVCCIcl85bBu4M4ru8H0ST9tg4RQUh7eStqxK2A6RCLi3ECToDZ2mEmuFZkIoo
hdVddLHRDiBYmxOlsGOm7XtH/UVVMKTumtTm4ofvmMkyghEpIrwACjFeLQ/Ajulr
so8uBtjRkcfGEvRM/TAXw8HaOFvjqermobp573PYtlNXLfbQ4ddI
-----END CERTIFICATE-----
github-api-0.14.2/lib/github_api/pagination.rb 0000644 0001750 0001750 00000007104 12735456050 017575 0 ustar alee alee # encoding: utf-8
module Github
# A module that decorates response with pagination helpers
module Pagination
include Github::Constants
# Return page links
def links
@links = Github::PageLinks.new(env[:response_headers])
end
# Retrive number of total pages base on current :per_page parameter
def count_pages
page_iterator.count.to_i
end
# Iterate over results set pages by automatically calling `next_page`
# until all pages are exhausted. Caution needs to be exercised when
# using this feature - 100 pages iteration will perform 100 API calls.
# By default this is off. You can set it on the client, individual API
# instances or just per given request.
#
def auto_paginate(auto=false)
if (current_api.auto_pagination? || auto) && self.body.is_a?(Array)
resources_bodies = []
each_page { |resource| resources_bodies += resource.body }
self.body = resources_bodies
end
self
end
# Iterator like each for response pages. If there are no pages to
# iterate over this method will return current page.
def each_page
yield self
while page_iterator.next?
yield next_page
end
end
# Retrives the result of the first page. Returns nil if there is
# no first page - either because you are already on the first page
# or there are no pages at all in the result.
def first_page
first_request = page_iterator.first
self.instance_eval { @env = first_request.env } if first_request
first_request
end
# Retrives the result of the next page. Returns nil if there is
# no next page or no pages at all.
def next_page
next_request = page_iterator.next
self.instance_eval { @env = next_request.env } if next_request
next_request
end
# Retrives the result of the previous page. Returns nil if there is
# no previous page or no pages at all.
def prev_page
prev_request = page_iterator.prev
self.instance_eval { @env = prev_request.env } if prev_request
prev_request
end
alias :previous_page :prev_page
# Retrives the result of the last page. Returns nil if there is
# no last page - either because you are already on the last page,
# there is only one page or there are no pages at all in the result.
def last_page
last_request = page_iterator.last
self.instance_eval { @env = last_request.env } if last_request
last_request
end
# Retrives a specific result for a page given page number.
# The page_number parameter is not validate, hitting a page
# that does not exist will return Github API error. Consequently, if
# there is only one page, this method returns nil
def page(page_number)
request = page_iterator.get_page(page_number)
self.instance_eval { @env = request.env } if request
request
end
# Returns true if there is another page in the result set,
# otherwise false
def has_next_page?
page_iterator.next?
end
# Handle pagination params when they are not passed directly
#
def self.per_page_as_param(per_page_config)
params = {}
if (per_page_config != Github::Configuration.property_set[:per_page])
params[:per_page] = per_page_config unless per_page_config.nil?
end
params
end
private
# Internally used page iterator
def page_iterator # :nodoc:
@page_iterator = Github::PageIterator.new(links, current_api)
end
end # Pagination
end # Github
github-api-0.14.2/lib/github_api/requestable.rb 0000644 0001750 0001750 00000003637 12735456050 017767 0 ustar alee alee # encoding: utf-8
module Github
# Defines HTTP verbs
module Request
METHODS = [:get, :post, :put, :delete, :patch]
METHODS_WITH_BODIES = [ :post, :put, :patch ]
def get_request(path, params={}, options={})
request(:get, path, params, options)
end
def patch_request(path, params={}, options={})
request(:patch, path, params, options)
end
def post_request(path, params={}, options={})
request(:post, path, params, options)
end
def put_request(path, params={}, options={})
request(:put, path, params, options)
end
def delete_request(path, params={}, options={})
request(:delete, path, params, options)
end
def request(method, path, params, options)
if !METHODS.include?(method)
raise ArgumentError, "unkown http method: #{method}"
end
# _extract_mime_type(params, options)
puts "EXECUTED: #{method} - #{path} with #{params} and #{options}" if ENV['DEBUG']
conn = connection(options)
path = (conn.path_prefix + path).gsub(/\/\//,'/') if conn.path_prefix != '/'
response = conn.send(method) do |request|
case method.to_sym
when *(METHODS - METHODS_WITH_BODIES)
request.body = params.delete('data') if params.has_key?('data')
request.url(path, params)
when *METHODS_WITH_BODIES
request.path = path
request.body = extract_data_from_params(params) unless params.empty?
end
end
response.body
end
private
def extract_data_from_params(params) # :nodoc:
return params['data'] if params.has_key?('data') and !params['data'].nil?
return params
end
def _extract_mime_type(params, options) # :nodoc:
options['resource'] = params['resource'] ? params.delete('resource') : ''
options['mime_type'] = params['resource'] ? params.delete('mime_type') : ''
end
end # Request
end # Github
github-api-0.14.2/lib/github_api/normalizer.rb 0000644 0001750 0001750 00000001064 12735456050 017625 0 ustar alee alee # encoding: utf-8
module Github
# Deals with normalazing client supplied parameter keys.
module Normalizer
# Turns any keys from nested hashes including nested arrays into strings
#
def normalize!(params)
case params
when Hash
params.keys.each do |k|
params[k.to_s] = params.delete(k)
normalize!(params[k.to_s])
end
when Array
params.map! do |el|
normalize!(el)
end
else
params.to_s
end
return params
end
end # Normalizer
end # Github
github-api-0.14.2/lib/github_api/resource.rb 0000644 0001750 0001750 00000000244 12735456050 017271 0 ustar alee alee
module Github
class Resource < API
def call(*args)
method = args.shift
template =
response = request(method, )
end
end
end
github-api-0.14.2/lib/github_api/response_wrapper.rb 0000644 0001750 0001750 00000006201 12735456050 021037 0 ustar alee alee # encoding: utf-8
module Github
# A class responsible for proxing to faraday response
class ResponseWrapper
extend Forwardable
include Pagination
include Enumerable
attr_reader :response
attr_reader :current_api
attr_reader :env
def_delegators :body, :empty?, :size, :include?, :length, :to_a, :first, :flatten, :include?, :keys, :[]
def initialize(response, current_api)
@response = response
@current_api = current_api
@env = response.env
end
# Overwrite methods to hash keys
#
['id', 'type', 'fork'].each do |method_name|
define_method(method_name) do
self.body.fetch(method_name.to_s)
end
end
# Request url
#
def url
response.env[:url].to_s
end
def body=(value)
@body = value
@env[:body] = value
end
# Response raw body
#
def body
@body ? @body : response.body
end
# Response status
#
def status
response.status
end
def success?
response.success?
end
def redirect?
status.to_i >= 300 && status.to_i < 400
end
def client_error?
status.to_i >= 400 && status.to_i < 500
end
def server_error?
status.to_i >= 500 && status.to_i < 600
end
# Return response headers
#
def headers
Github::Response::Header.new(env)
end
# Lookup an attribute from the body if hash, otherwise behave like array index.
# Convert any key to string before calling.
#
def [](key)
if self.body.is_a?(Array)
self.body[key]
else
self.body.send(:"#{key}")
end
end
# Return response body as string
#
def to_s
body.to_s
end
# Convert the ResponseWrapper into a Hash
#
def to_hash
body.to_hash
end
# Convert the ResponseWrapper into an Array
#
def to_ary
body.to_ary
end
# Iterate over each resource inside the body
#
def each
body_parts = self.body.respond_to?(:each) ? self.body : [self.body]
return body_parts.to_enum unless block_given?
body_parts.each { |part| yield(part) }
end
# Check if body has an attribute
#
def has_key?(key)
self.body.is_a?(Hash) && self.body.has_key?(key)
end
# Coerce any method calls for body attributes
#
def method_missing(method_name, *args, &block)
if self.has_key?(method_name.to_s)
self.[](method_name, &block)
else
super
end
end
# Check if method is defined on the body
#
def respond_to?(method_name, include_all = false)
if self.has_key?(method_name.to_s)
true
else
super
end
end
# Print only response body
#
def inspect
"#<#{self.class.name} @body=\"#{self.body}\">"
end
# Compare the wrapper with other wrapper for equality
#
def ==(other)
return false unless other.is_a?(self.class)
return false unless (other.respond_to?(:env) && other.respond_to?(:body))
self.env == other.env && self.body == other.body
end
alias eql? ==
end # ResponseWrapper
end # Github
github-api-0.14.2/lib/github_api/parameter_filter.rb 0000644 0001750 0001750 00000001577 12735456050 021001 0 ustar alee alee # -*- encoding: utf-8 -*-
module Github
# Allows you to specify parameters keys which will be preserved
# in parameters hash and its subhashes. Any keys from the nested
# hash that do not match will be removed.
module ParameterFilter
# Removes any keys from nested hashes that don't match predefiend keys
#
def filter!(keys, params, options={:recursive => true}) # :nodoc:
case params
when Hash, ParamsHash
params.keys.each do |k, v|
unless (keys.include?(k) or Github::Validations::VALID_API_KEYS.include?(k))
params.delete(k)
else
filter!(keys, params[k]) if options[:recursive]
end
end
when Array
params.map! do |el|
filter!(keys, el) if options[:recursive]
end
else
params
end
return params
end
end # Filter
end # Github
github-api-0.14.2/lib/github_api/response.rb 0000644 0001750 0001750 00000002110 12735456050 017272 0 ustar alee alee # encoding: utf-8
require 'faraday'
module Github
# Contains methods and attributes that act on the response returned from the
# request
class Response < Faraday::Response::Middleware
CONTENT_TYPE = 'Content-Type'.freeze
class << self
attr_accessor :parser
end
def self.define_parser(&block)
@parser = block
end
def initialize(app, options = {})
super(app)
@content_types = Array(options[:content_type])
end
def process_body(env)
env[:body] = parse(env[:body])
end
def parse_body?(env)
parse_response_type?(response_type(env)) and parse_response?(env)
end
def response_type(env)
type = env[:response_headers][CONTENT_TYPE].to_s
type = type.split(';', 2).first if type.index(';')
type
end
def parse_response_type?(type)
@content_types.empty? || @content_types.any? { |pattern|
pattern.is_a?(Regexp) ? type =~ pattern : type == pattern
}
end
def parse_response?(env)
env[:body].respond_to?(:to_str)
end
end # Response
end # Github
github-api-0.14.2/lib/github_api/response/ 0000755 0001750 0001750 00000000000 12735456050 016753 5 ustar alee alee github-api-0.14.2/lib/github_api/response/mashify.rb 0000644 0001750 0001750 00000000707 12735456050 020744 0 ustar alee alee # encoding: utf-8
require 'faraday'
module Github
class Response::Mashify < Response
dependency 'hashie/mash'
define_parser do |body|
::Hashie::Mash.new body
end
def parse(body)
case body
when Hash
self.class.parser.call body
when Array
body.map { |item| item.is_a?(Hash) ? self.class.parser.call(item) : item }
else
body
end
end
end # Response::Mashify
end # Github
github-api-0.14.2/lib/github_api/response/header.rb 0000644 0001750 0001750 00000003367 12735456050 020541 0 ustar alee alee # encoding: utf-8
module Github
class Response
# Represents http response header
class Header < Struct.new(:env)
include Github::Constants
SUCCESSFUL_STATUSES = 200..299
def loaded?
!!env
end
def oauth_scopes
loaded? ? env[:response_headers][OAUTH_SCOPES] : nil
end
def accepted_oauth_scopes
loaded? ? env[:response_headers][ACCEPTED_OAUTH_SCOPES] : nil
end
# Requests are limited to API v3 to 5000 per hour.
def ratelimit_limit
loaded? ? env[:response_headers][RATELIMIT_LIMIT] : nil
end
def ratelimit_remaining
loaded? ? env[:response_headers][RATELIMIT_REMAINING] : nil
end
# A unix timestamp describing when the ratelimit will
# be reset
def ratelimit_reset
loaded? ? env[:response_headers][RATELIMIT_RESET] : nil
end
def cache_control
loaded? ? env[:response_headers][CACHE_CONTROL] : nil
end
def content_type
loaded? ? env[:response_headers][CONTENT_TYPE] : nil
end
def content_length
loaded? ? env[:response_headers][CONTENT_LENGTH] : nil
end
def etag
loaded? ? env[:response_headers][ETAG] : nil
end
def date
loaded? ? env[:response_headers][DATE] : nil
end
def location
loaded? ? env[:response_headers][LOCATION] : nil
end
def server
loaded? ? env[:response_headers][SERVER] : nil
end
def status
loaded? ? env[:status] : nil
end
def success?
SUCCESSFUL_STATUSES.include? status
end
# Returns raw body
def body
loaded? ? env[:body] : nil
end
end # Header
end # Response
end # Github
github-api-0.14.2/lib/github_api/response/atom_parser.rb 0000644 0001750 0001750 00000000613 12735456050 021614 0 ustar alee alee # encoding: utf-8
require 'faraday'
module Github
class Response::AtomParser < Response
define_parser do |body|
require 'rss'
RSS::Parser.parse(body)
end
def initialize(app, options = {})
super(app, options.merge(content_type: /(\batom|\brss)/))
end
def on_complete(env)
if parse_body?(env)
process_body(env)
end
end
end
end
github-api-0.14.2/lib/github_api/response/raise_error.rb 0000644 0001750 0001750 00000000753 12735456050 021621 0 ustar alee alee # encoding: utf-8
require 'faraday'
require 'github_api/error'
module Github
class Response::RaiseError < Faraday::Response::Middleware
def on_complete(env)
status_code = env[:status].to_i
service_error = Github::Error::ServiceError
error_class = service_error.errors[status_code]
error_class = service_error if !error_class and (400...600) === status_code
raise error_class.new(env) if error_class
end
end # Response::RaiseError
end # Github
github-api-0.14.2/lib/github_api/response/xmlize.rb 0000644 0001750 0001750 00000000632 12735456050 020611 0 ustar alee alee # encoding: utf-8
require 'faraday'
module Github
class Response::Xmlize < Response
dependency 'nokogiri'
define_parser do |body|
::Nokogiri::XML body
end
def parse(body)
case body
when ''
nil
when 'true'
true
when 'false'
false
else
self.class.parser.call(body)
end
end
end # Response::Xmlize
end # Github
github-api-0.14.2/lib/github_api/response/jsonize.rb 0000644 0001750 0001750 00000000643 12735456050 020764 0 ustar alee alee # encoding: utf-8
require 'faraday'
require 'json'
module Github
class Response::Jsonize < Response
dependency 'json'
define_parser do |body|
JSON.parse(body)
end
def parse(body)
case body
when ''
nil
when 'true'
true
when 'false'
false
else
self.class.parser.call(body)
end
end
end # Response::Jsonize
end # Github
github-api-0.14.2/lib/github_api/core_ext/ 0000755 0001750 0001750 00000000000 12735456050 016725 5 ustar alee alee github-api-0.14.2/lib/github_api/core_ext/hash.rb 0000644 0001750 0001750 00000004174 12735456050 020203 0 ustar alee alee # encoding: utf-8
class Hash # :nodoc:
# Returns a new hash with keys removed
#
def except(*items)
self.dup.except!(*items)
end unless method_defined? :except
# Similar to except but modifies self
#
def except!(*keys)
keys.each { |key| delete(key) }
self
end unless method_defined? :except!
# Returns a new hash with all the keys converted to symbols
#
def symbolize_keys
inject({}) do |hash, (key, value)|
hash[(key.to_sym rescue key) || key] = value
hash
end
end unless method_defined? :symbolize_keys
# Similar to symbolize_keys but modifies self
#
def symbolize_keys!
hash = symbolize_keys
hash.each do |key, val|
hash[key] = case val
when Hash
val.symbolize_keys!
when Array
val.map do |item|
item.is_a?(Hash) ? item.symbolize_keys! : item
end
else
val
end
end
return hash
end unless method_defined? :symbolize_keys!
# Returns hash collapsed into a query string
#
def serialize
self.map { |key, val| [key, val].join("=") }.join("&")
end unless method_defined? :serialize
# Searches for all deeply nested keys
#
def deep_keys
keys = self.keys
keys.each do |key|
if self[key].is_a?(Hash)
keys << self[key].deep_keys.compact.flatten
next
end
end
keys.flatten
end unless method_defined? :deep_keys
# Returns true if the given key is present inside deeply nested hash
#
def deep_key?(key)
self.deep_keys.include? key
end unless method_defined? :deep_key?
# Recursively merges self with other hash and returns new hash.
#
def deep_merge(other, &block)
dup.deep_merge!(other, &block)
end unless method_defined? :deep_merge
# Similar as deep_merge but modifies self
#
def deep_merge!(other, &block)
other.each_pair do |key, val|
tval = self[key]
if tval.is_a?(Hash) && val.is_a?(Hash)
self[key] = tval.deep_merge(val)
else
self[key] = block && tval ? block.call(k, tval, val) : val
end
end
self
end unless method_defined? :deep_merge!
end # Hash
github-api-0.14.2/lib/github_api/core_ext/ordered_hash.rb 0000644 0001750 0001750 00000004032 12735456050 021700 0 ustar alee alee # encoding: utf-8
module Github
module CoreExt #:nodoc:
if RUBY_VERSION >= '1.9'
class OrderedHash < ::Hash; end
else
class OrderedHash < ::Hash
attr_accessor :order
class << self
def [](*args)
hsh = OrderedHash.new
if Hash == args[0]
hsh.replace args[0]
elsif (args.size % 2) != 0
pp args if ENV['DEBUG']
raise ArgumentError, "odd number of elements for Hash"
else
0.step(args.size - 1, 2) do |a|
b = a + 1
hsh[args[a]] = args[b]
end
end
hsh
end
end
def initialize(*args, &block)
super
@order = []
end
def []=(key, value)
@order.push key unless member?(key)
super key, value
end
def ==(hsh2)
return false if @order != hsh2.order
super hsh2
end
def clear
@order = []
super
end
def delete(key)
@order.delete key
super
end
def each_key
@order.each { |k| yield k }
self
end
def each_value
@order.each { |k| yield self[k] }
self
end
def each
@order.each { |k| yield k, self[k] }
self
end
alias :each_pair :each
def delete_if
@order.clone.each { |k| delete k if yield }
self
end
def values
ary = []
@order.each { |k| ary.push self[k] }
ary
end
def keys
@order
end
def replace(hsh2)
@order = hsh2.keys
super hsh2
end
def shift
key = @order.first
key ? [key, delete(key)] : super
end
def class
Hash
end
def __class__
OrderedHash
end
end # OrderedHash
end
end # CoreExt
end # Github
github-api-0.14.2/lib/github_api/core_ext/array.rb 0000644 0001750 0001750 00000001011 12735456050 020361 0 ustar alee alee # encoding: utf-8
class Array # :nodoc:
# Returns a new arrray with keys removed
#
def except(*keys)
self.dup.except!(*keys)
end unless method_defined? :except
# Similar to except but modifies self
#
def except!(*items)
copy = self.dup
copy.reject! { |item| items.include? item }
copy
end unless method_defined? :except!
# Selects a hash from the arguments list
#
def extract_options!
last.is_a?(::Hash) ? pop : {}
end unless method_defined? :extract_options!
end # Array
github-api-0.14.2/lib/github_api/error.rb 0000644 0001750 0001750 00000001616 12735456050 016577 0 ustar alee alee # encoding: utf-8
require 'descendants_tracker'
module Github
module Error
class GithubError < StandardError
extend DescendantsTracker
attr_reader :response_message, :response_headers
# Initialize a new Github error object.
#
def initialize(message=$!)
if message.respond_to?(:backtrace)
super(message.message)
@response_message = message
else
super(message.to_s)
end
end
def backtrace
@response_message ? @response_message.backtrace : super
end
end # GithubError
end # Error
end # Github
require 'github_api/error/service_error'
require 'github_api/error/client_error'
Dir[File.dirname(__FILE__) + '/error/*.rb'].sort.each do |path|
filename = File.basename(path)
next if ['service_error.rb', 'client_error.rb'].include?(filename)
require "github_api/error/#{filename}"
end
github-api-0.14.2/lib/github_api/constants.rb 0000644 0001750 0001750 00000002144 12735456050 017457 0 ustar alee alee module Github
module Constants
extend self
# Response headers
RATELIMIT_REMAINING = 'X-RateLimit-Remaining'.freeze
RATELIMIT_LIMIT = 'X-RateLimit-Limit'.freeze
RATELIMIT_RESET = 'X-RateLimit-Reset'.freeze
CONTENT_TYPE = 'Content-Type'.freeze
CONTENT_LENGTH = 'content-length'.freeze
CACHE_CONTROL = 'cache-control'.freeze
ETAG = 'ETag'.freeze
SERVER = 'Server'.freeze
DATE = 'Date'.freeze
LOCATION = 'Location'.freeze
USER_AGENT = 'User-Agent'.freeze
ACCEPT = 'Accept'.freeze
ACCEPT_CHARSET = 'Accept-Charset'.freeze
OAUTH_SCOPES = 'X-OAuth-Scopes'.freeze
ACCEPTED_OAUTH_SCOPES = 'X-Accepted-Oauth-Scopes'.freeze
# Link headers
HEADER_LINK = "Link".freeze
HEADER_NEXT = "X-Next".freeze
HEADER_LAST = "X-Last".freeze
META_REL = "rel".freeze
META_LAST = "last".freeze
META_NEXT = "next".freeze
META_FIRST = "first".freeze
META_PREV = "prev".freeze
PARAM_PAGE = "page".freeze
PARAM_PER_PAGE = "per_page".freeze
PARAM_START_PAGE = "start_page".freeze
end # Constants
end # Github
github-api-0.14.2/lib/github_api/client/ 0000755 0001750 0001750 00000000000 12735456050 016373 5 ustar alee alee github-api-0.14.2/lib/github_api/client/users.rb 0000644 0001750 0001750 00000005174 12735456050 020070 0 ustar alee alee # encoding: utf-8
module Github
class Client::Users < API
# Load all the modules after initializing Repos to avoid superclass mismatch
require_all 'github_api/client/users',
'emails',
'followers',
'keys'
VALID_USER_PARAMS_NAMES = %w[
name
email
blog
company
location
hireable
bio
].freeze
# Access to Users::Emails API
namespace :emails
# Access to Users::Followers API
namespace :followers
# Access to Users::Keys API
namespace :keys
# List all users.
#
# This provides a dump of every user, in the order that they signed up
# for GitHub.
#
# @param [Hash] params
# @option [Integer] :since
# The integer ID of the last User that you’ve seen.
#
# @example
# users = Github::Users.new
# users.list
#
# @api public
def list(*args)
arguments(args)
response = get_request("/users", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias :all :list
# Get a single unauthenticated user
#
# @example
# github = Github.new
# github.users.get user: 'user-name'
#
# Get the authenticated user
#
# @example
# github = Github.new oauth_token: '...'
# github.users.get
#
# @api public
def get(*args)
params = arguments(args).params
if user_name = params.delete('user')
get_request("/users/#{user_name}", params)
else
get_request("/user", params)
end
end
alias :find :get
# Update the authenticated user
#
# @param [Hash] params
# @option params [String] :name
# Optional string
# @option params [String] :email
# Optional string - publically visible email address
# @option params [String] :blog
# Optional string
# @option params [String] :company
# Optional string
# @option params [String] :location
# Optional string
# @option params [String] :hireable
# Optional boolean
# @option params [String] :bio
# Optional string
#
# @example
# github = Github.new oauth_token: '..'
# github.users.update
# name: "monalisa octocat",
# email: "octocat@github.com",
# blog: "https://github.com/blog",
# company: "GitHub",
# location: "San Francisco",
# hireable: true,
# bio: "There once..."
#
# @api public
def update(*args)
arguments(args) do
permit VALID_USER_PARAMS_NAMES
end
patch_request("/user", arguments.params)
end
end # Users
end # Github
github-api-0.14.2/lib/github_api/client/orgs/ 0000755 0001750 0001750 00000000000 12735456050 017345 5 ustar alee alee github-api-0.14.2/lib/github_api/client/orgs/memberships.rb 0000644 0001750 0001750 00000007735 12735456050 022224 0 ustar alee alee # encoding: utf-8
module Github
class Client::Orgs::Memberships < API
# List your organization memberships
#
# @see List your organization memberships
#
# @example
# github = Github.new
# github.orgs.memberships.list
#
# @api public
def list(*args)
arguments(args)
response = get_request('/user/memberships/orgs', arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias_method :all, :list
# Get organization membership
#
# In order to get a user's membership with an organization,
# the authenticated user must be an organization owner.
#
# @see https://developer.github.com/v3/orgs/members/#get-organization-membership
# @param [String] :org
# @param [String] :username
#
# @example
# github = Github.new oauth_toke: '...'
# github.orgs.memberships.get 'orgname', username: 'piotr'
#
# Get your organization membership
#
# @see https://developer.github.com/v3/orgs/members/#get-your-organization-membership
#
# @example
# github = Github.new oauth_token
# github.orgs.memberships.get 'orgname'
#
# @api public
def get(*args)
arguments(args, required: [:org_name])
params = arguments.params
if (username = params.delete('username'))
get_request("/orgs/#{arguments.org_name}/memberships/#{username}", params)
else
get_request("/user/memberships/orgs/#{arguments.org_name}", params)
end
end
alias_method :find, :get
# Add/update user's membership with organization
#
# In order to create or update a user's membership with an organization,
# the authenticated user must be an organization owner.
#
# @see https://developer.github.com/v3/orgs/members/#add-or-update-organization-membership
#
# @param [String] :org
# @param [String] :username
# @param [Hash] options
# @option options [String] :role
# Required. The role to give the user in the organization. Can be one of:
# * admin - The user will become an owner of the organization.
# * member - The user will become a non-owner member of the organization.
#
# @example
# github = Github.new oauth_token: '...'
# github.orgs.memberships.add 'org-name', 'member-name', role: 'role'
#
# @api public
def create(*args)
arguments(args, required: [:org_name, :username]) do
assert_required :role
end
put_request("/orgs/#{arguments.org_name}/memberships/#{arguments.username}",
arguments.params)
end
alias_method :update, :create
alias_method :add, :create
# Edit your organization membership
#
# @see https://developer.github.com/v3/orgs/members/#edit-your-organization-membership
# @param [String] :org
# @param [Hash] params
# @option params [String] :state
# Required. The state that the membership should be in.
# Only "active" will be accepted.
#
# @example
# github = Github.new oauth_token: '...'
# github.orgs.memberships.edit 'org-name', state: 'active'
#
# @api public
def edit(*args)
arguments(args, required: [:org_name]) do
assert_required :state
end
patch_request("/user/memberships/orgs/#{arguments.org_name}",
arguments.params)
end
# Remove organization membership
#
# @see https://developer.github.com/v3/orgs/members/#remove-organization-membership
# @param [String] :org
# @param [String] :username
#
# @example
# github = Github.new oauth_token: '...'
# github.orgs.memberships.remove 'orgname', 'username'
#
# @api public
def delete(*args)
arguments(args, required: [:org_name, :username])
delete_request("/orgs/#{arguments.org_name}/memberships/#{arguments.username}", arguments.params)
end
alias_method :remove, :delete
end # Client::Orgs::Memberships
end # Github
github-api-0.14.2/lib/github_api/client/orgs/teams.rb 0000644 0001750 0001750 00000031743 12735456050 021013 0 ustar alee alee # encoding: utf-8
module Github
# All actions against teams require at a minimum an authenticated user
# who is a member of the owner's team in the :org being managed.
# Api calls that require explicit permissions are noted.
class Client::Orgs::Teams < API
# List user teams
#
# List all of the teams across all of the organizations
# to which the authenticated user belongs. This method
# requires user or repo scope when authenticating via OAuth.
#
# @example
# github = Github.new oauth_token: '...'
# github.orgs.teams.list
#
# List teams
#
# @see https://developer.github.com/v3/orgs/teams/#list-teams
#
# @example
# github = Github.new oauth_token: '...'
# github.orgs.teams.list org: 'org-name'
#
# @api public
def list(*args)
params = arguments(args).params
if (org = params.delete('org'))
response = get_request("/orgs/#{org}/teams", params)
else
response = get_request('/user/teams', params)
end
return response unless block_given?
response.each { |el| yield el }
end
alias_method :all, :list
# Get a team
#
# @see https://developer.github.com/v3/orgs/teams/#get-team
#
# @example
# github = Github.new oauth_token: '...'
# github.orgs.teams.get 'team-id'
#
# @api public
def get(*args)
arguments(args, required: [:id])
get_request("/teams/#{arguments.id}", arguments.params)
end
alias_method :find, :get
# Create a team
#
# In order to create a team, the authenticated user must be an owner of :org
#
# @see https://developer.github.com/v3/orgs/teams/#create-team
#
# @param [Hash] params
# @option params [String] :name
# Required. The name of the team
# @option params [String] :description
# The description of the team.
# @option params [Array[String]] :repo_names
# The repositories to add the team to.
# @option params [String] :privacy
# The level of privacy this team should have. Can be one of:
# * secret - only visible to organization owners and
# members of this team.
# * closed - visible to all members of this organization.
# Default: secret
# @option params [String] :permission
# The permission to grant the team. Can be one of:
# * pull - team members can pull, but not push or
# administor this repositories.
# * push - team members can pull and push,
# but not administor this repositores.
# * admin - team members can pull, push and
# administor these repositories.
# Default: pull
#
# @example
# github = Github.new oauth_token: '...'
# github.orgs.teams.create 'org-name',
# name: "new team",
# permission: "push",
# repo_names: [
# "github/dotfiles"
# ]
#
# @api public
def create(*args)
arguments(args, required: [:org_name]) do
assert_required %w(name)
end
post_request("/orgs/#{arguments.org_name}/teams", arguments.params)
end
# Edit a team
#
# In order to edit a team, the authenticated user must be an owner
# of the org that the team is associated with.
#
# @see https://developer.github.com/v3/orgs/teams/#edit-team
#
# @param [Hash] params
# @option params [String] :name
# The repositories to add the team to.
# @option params [String] :description
# The description of the team.
# @option params [String] :privacy
# The level of privacy this team should have. Can be one of:
# * secret - only visible to organization owners and
# members of this team.
# * closed - visible to all members of this organization.
# Default: secret
# @option params [String] :permission
# The permission to grant the team. Can be one of:
# * pull - team members can pull, but not push or
# administor this repositories.
# * push - team members can pull and push,
# but not administor this repositores.
# * admin - team members can pull, push and
# administor these repositories.
# Default: pull
#
# @example
# github = Github.new oauth_token: '...'
# github.orgs.teams.edit 'team-id',
# name: "new team name",
# permission: "push"
#
# @api public
def edit(*args)
arguments(args, required: [:id]) do
assert_required %w(name)
end
patch_request("/teams/#{arguments.id}", arguments.params)
end
# Delete a team
#
# @see https://developer.github.com/v3/orgs/teams/#delete-team
#
# In order to delete a team, the authenticated user must be an owner
# of the org that the team is associated with
#
# @example
# github = Github.new oauth_token: '...'
# github.orgs.teams.delete 'team-id'
#
# @api public
def delete(*args)
arguments(args, required: [:id])
delete_request("/teams/#{arguments.id}", arguments.params)
end
alias_method :remove, :delete
# List team members
#
# In order to list members in a team, the authenticated user
# must be a member of the team.
#
# @see https://developer.github.com/v3/orgs/teams/#list-team-members
#
# @param [Integer] :team_id
#
# @example
# github = Github.new oauth_token: '...'
# github.orgs.teams.list_members 'team-id'
# github.orgs.teams.list_members 'team-id' { |member| ... }
#
# @api public
def list_members(*args)
arguments(args, required: [:team_id])
response = get_request("/teams/#{arguments.team_id}/members", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias_method :all_members, :list_members
# Check if a user is a member of a team
#
# @see https://developer.github.com/v3/orgs/teams/#get-team-member
#
# @param [Integer] :team_id
# @param [String] :username
#
# @example
# github = Github.new oauth_token: '...'
# github.orgs.teams.team_member? 'team-id', 'user-name'
#
# @api public
def team_member?(*args)
arguments(args, required: [:team_id, :user])
response = get_request("/teams/#{arguments.team_id}/members/#{arguments.user}", arguments.params)
response.status == 204
rescue Github::Error::NotFound
false
end
# Add a team member
#
# In order to add a user to a team, the authenticated user must
# have 'admin' permissions to the team or be an owner of the org
# that the team is associated with.
#
# @example
# github = Github.new oauth_token: '...'
# github.orgs.teams.add_member 'team-id', 'user-name'
#
# @api public
def add_member(*args)
arguments(args, required: [:id, :user])
put_request("/teams/#{arguments.id}/members/#{arguments.user}",
arguments.params)
end
alias_method :add_team_member, :add_member
# Remove a team member
#
# @see https://developer.github.com/v3/orgs/teams/#remove-team-member
#
# In order to remove a user from a team, the authenticated user must
# have 'admin' permissions to the team or be an owner of the org that
# the team is associated with.
# note: This does not delete the user, it just remove them from the team.
#
# @example
# github = Github.new oauth_token: '...'
# github.orgs.teams.remove_member 'team-id', 'user-name'
#
# @api public
def remove_member(*args)
arguments(args, required: [:id, :user])
delete_request("/teams/#{arguments.id}/members/#{arguments.user}",
arguments.params)
end
alias_method :remove_team_member, :remove_member
# Get team membership
#
# In order to get a user's membership with a team,
# the team must be visible to the authenticated user.
#
# @see https://developer.github.com/v3/orgs/teams/#get-team-membership
#
# @param [Integer] :team_id
# @param [String] :username
#
# @example
# github = Github.new oauth_token: '...'
# github.orgs.teams.team_membership 'team-id', 'username'
#
# @api public
def team_membership(*args)
arguments(args, required: [:team_id, :username])
get_request("/teams/#{arguments.team_id}/memberships/#{arguments.username}",
arguments.params)
end
# Add a team membership
#
# In order to add a user to a team, the authenticated user must
# have 'admin' permissions to the team or be an owner of the org
# that the team is associated with.
#
# @see https://developer.github.com/v3/orgs/teams/#add-team-membership
#
# @param [Integer] :team_id
# @param [String] :username
# @param [Hash] :params
# @option params [String] :role
# The role that this user should have in the team. Can be one of:
# * member - a normal member of the team.
# * maintainer - a team maintainer. Able to add/remove
# other team members, promote other team members to
# team maintainer, and edit the team's name and description.
# Default: member
#
# @example
# github = Github.new oauth_token: '...'
# github.orgs.teams.add_membership 'team-id', 'user-name'
#
# @api public
def add_membership(*args)
arguments(args, required: [:team_id, :user])
put_request("/teams/#{arguments.team_id}/memberships/#{arguments.user}",
arguments.params)
end
alias_method :add_team_membership, :add_membership
# Remove a team membership
#
# In order to remove a user from a team, the authenticated user must
# have 'admin' permissions to the team or be an owner of the org that
# the team is associated with.
# note: This does not delete the user, it just remove them from the team.
#
# @see https://developer.github.com/v3/orgs/teams/#remove-team-membership
#
# @example
# github = Github.new oauth_token: '...'
# github.orgs.teams.remove_membership 'team-id', 'user-name'
#
# @api public
def remove_membership(*args)
arguments(args, required: [:team_id, :user])
delete_request("/teams/#{arguments.team_id}/memberships/#{arguments.user}",
arguments.params)
end
alias_method :remove_team_membership, :remove_membership
# List team repositories
#
# @see https://developer.github.com/v3/orgs/teams/#list-team-repos
#
# @example
# github = Github.new oauth_token: '...'
# github.orgs.teams.list_repos 'team-id'
#
# @api public
def list_repos(*args)
arguments(args, required: [:id])
response = get_request("/teams/#{arguments.id}/repos", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias_method :repos, :list_repos
# Check if a repository belongs to a team
#
# @see https://developer.github.com/v3/orgs/teams/#get-team-repo
#
# @example
# github = Github.new oauth_token: '...'
# github.orgs.teams.team_repo? 'team-id', 'user-name', 'repo-name'
#
# @api public
def team_repo?(*args)
arguments(args, required: [:id, :user, :repo])
response = get_request("/teams/#{arguments.id}/repos/#{arguments.user}/#{arguments.repo}", arguments.params)
response.status == 204
rescue Github::Error::NotFound
false
end
alias_method :team_repository?, :team_repo?
# Add a team repository
#
# In order to add a repo to a team, the authenticated user must be
# an owner of the org that the team is associated with. Also, the repo
# must be owned by the organization, or a direct for of a repo owned
# by the organization.
#
# @see https://developer.github.com/v3/orgs/teams/#add-team-repo
#
# @example
# github = Github.new oauth_token: '...'
# github.orgs.teams.add_repo 'team-id', 'user-name', 'repo-name'
#
# @api public
def add_repo(*args)
arguments(args, required: [:id, :user, :repo])
put_request("/teams/#{arguments.id}/repos/#{arguments.user}/#{arguments.repo}", arguments.params)
end
alias_method :add_repository, :add_repo
# Remove a team repository
#
# In order to add a repo to a team, the authenticated user must be
# an owner of the org that the team is associated with.
# note: This does not delete the repo, it just removes it from the team.
#
# @see https://developer.github.com/v3/orgs/teams/#remove-team-repo
#
# @example
# github = Github.new oauth_token: '...'
# github.orgs.teams.remove_repo 'team-id', 'user-name', 'repo-name'
#
# @api public
def remove_repo(*args)
arguments(args, required: [:id, :user, :repo])
delete_request("/teams/#{arguments.id}/repos/#{arguments.user}/#{arguments.repo}", arguments.params)
end
alias_method :remove_repository, :remove_repo
end # Client::Orgs::Teams
end # Github
github-api-0.14.2/lib/github_api/client/orgs/members.rb 0000644 0001750 0001750 00000011254 12735456050 021327 0 ustar alee alee # encoding: utf-8
module Github
class Client::Orgs::Members < API
# List members
#
# List all users who are members of an organization. A member is a user
# that belongs to at least 1 team in the organization.
# If the authenticated user is also a member of this organization then
# both concealed and public members will be returned.
# Otherwise only public members are returned.
#
# @see https://developer.github.com/v3/orgs/members/#members-list
#
# @param [Hash] params
# @option params [String] :filter
# Filter members returned in the list. Can be one of:
# * 2fa_disabled: Members without two-factor authentication enabled.
# Available for owners of organizations with private repositories.
# * all: All members the authenticated user can see.
# Default: all
# @option params [String] :role
# Filter members returned by their role. Can be one of:
# * all: All members of the organization, regardless of role.
# * admin: Organization owners.
# * member: Non-owner organization members.
#
# @example
# github = Github.new
# github.orgs.members.list 'org-name'
# github.orgs.members.list 'org-name' { |memb| ... }
#
# List public members
#
# @see https://developer.github.com/v3/orgs/members/#public-members-list
#
# Members of an organization can choose to have their
# membership publicized or not.
#
# @example
# github = Github.new
# github.orgs.members.list 'org-name', public: true
# github.orgs.members.list 'org-name', public: true { |memb| ... }
#
# @api public
def list(*args)
params = arguments(args, required: [:org_name]).params
org_name = arguments.org_name
response = if params.delete('public')
get_request("/orgs/#{org_name}/public_members", params)
else
get_request("/orgs/#{org_name}/members", params)
end
return response unless block_given?
response.each { |el| yield el }
end
alias_method :all, :list
# Check if user is, publicly or privately, a member of an organization
#
# @example
# github = Github.new
# github.orgs.members.member? 'org-name', 'member-name'
#
# Check if a user is a public member of an organization
#
# @example
# github = Github.new
# github.orgs.members.member? 'org-name', 'member-name', public: true
#
# @api public
def member?(*args)
params = arguments(args, required: [:org_name, :user]).params
org_name = arguments.org_name
user = arguments.user
response = if params.delete('public')
get_request("/orgs/#{org_name}/public_members/#{user}", params)
else
get_request("/orgs/#{org_name}/members/#{user}", params)
end
response.status == 204
rescue Github::Error::NotFound
false
end
# Remove a member
#
# Removing a user from this list will remove them from all teams and
# they will no longer have any access to the organization's repositories.
#
# @see https://developer.github.com/v3/orgs/members/#remove-a-member
#
# @example
# github = Github.new
# github.orgs.members.remove 'org-name', 'member-name'
#
# @api public
def delete(*args)
arguments(args, required: [:org_name, :user])
delete_request("/orgs/#{arguments.org_name}/members/#{arguments.user}",
arguments.params)
end
alias_method :remove, :delete
# Publicize a user's membership
#
# @see https://developer.github.com/v3/orgs/members/#publicize-a-users-membership
#
# @example
# github = Github.new oauth_token: '...'
# github.orgs.members.publicize 'org-name', 'member-name'
#
# @api public
def publicize(*args)
arguments(args, required: [:org_name, :user])
put_request("/orgs/#{arguments.org_name}/public_members/#{arguments.user}", arguments.params)
end
alias_method :make_public, :publicize
alias_method :publicize_membership, :publicize
# Conceal a user's membership
#
# @see https://developer.github.com/v3/orgs/members/#conceal-a-users-membership
#
# @example
# github = Github.new oauth_token: '...'
# github.orgs.members.conceal 'org-name', 'member-name'
#
# @api public
def conceal(*args)
arguments(args, required: [:org_name, :user])
delete_request("/orgs/#{arguments.org_name}/public_members/#{arguments.user}", arguments.params)
end
alias_method :conceal_membership, :conceal
end # Client::Orgs::Members
end # Github
github-api-0.14.2/lib/github_api/client/orgs/hooks.rb 0000644 0001750 0001750 00000014164 12735456050 021023 0 ustar alee alee # encoding: utf-8
module Github
# The Organizations Hooks API manages the post-receive web and
# service hooks for an organization.
class Client::Orgs::Hooks < API
REQUIRED_PARAMS = %w( name config ).freeze # :nodoc:
# List organization hooks
#
# @see https://developer.github.com/v3/orgs/hooks/#list-hooks
#
# @example
# github = Github.new
# github.orgs.hooks.list 'org-name'
# github.orgs.hooks.list 'org-name' { |hook| ... }
#
# @api public
def list(*args)
arguments(args, required: [:org_name])
response = get_request("/orgs/#{arguments.org_name}/hooks", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias_method :all, :list
# Get a single hook
#
# @see https://developer.github.com/v3/orgs/hooks/#get-single-hook
#
# @example
# github = Github.new
# github.orgs.hooks.get 'org-name', 'hook-id'
#
# @api public
def get(*args)
arguments(args, required: [:org_name, :id])
get_request("/orgs/#{arguments.org_name}/hooks/#{arguments.id}",
arguments.params)
end
alias_method :find, :get
# Create a hook
#
# @see https://developer.github.com/v3/orgs/hooks/#create-a-hook
#
# @param [Hash] params
# @input params [String] :name
# Required. The name of the service that is being called.
# @input params [Hash] :config
# Required. Key/value pairs to provide settings for this hook.
# These settings vary between the services and are defined in
# the github-services repository. Booleans are stored internally
# as "1" for true, and "0" for false. Any JSON true/false values
# will be converted automatically.
# @input params [Array] :events
# Determines what events the hook is triggered for. Default: ["push"]
# @input params [Boolean] :active
# Determines whether the hook is actually triggered on pushes.
#
# To create a webhook, the following fields are required by the config:
#
# @input config [String] :url
# A required string defining the URL to which the payloads
# will be delivered.
# @input config [String] :content_type
# An optional string defining the media type used to serialize
# the payloads. Supported values include json and form.
# The default is form.
# @input config [String] :secret
# An optional string that’s passed with the HTTP requests as
# an X-Hub-Signature header. The value of this header is
# computed as the HMAC hex digest of the body,
# using the secret as the key.
# @input config [String] :insecure_ssl
# An optional string that determines whether the SSL certificate
# of the host for url will be verified when delivering payloads.
# Supported values include "0" (verification is performed) and
# "1" (verification is not performed). The default is "0".or instance, if the library doesn't get updated to permit a given parameter the api call won't work, however if we skip permission all together, the endpoint should always work provided the actual resource path doesn't change. I'm in the process of completely removing the permit functionality.
#
# @example
# github = Github.new
# github.orgs.hooks.create 'org-name',
# name: "web",
# active: true,
# config: {
# url: "http://something.com/webhook"
# }
# }
#
# @api public
def create(*args)
arguments(args, required: [:org_name]) do
assert_required REQUIRED_PARAMS
end
post_request("/orgs/#{arguments.org_name}/hooks", arguments.params)
end
# Edit a hook
#
# @see https://developer.github.com/v3/orgs/hooks/#edit-a-hook
#
# @param [Hash] params
# @input params [Hash] :config
# Required. Key/value pairs to provide settings for this hook.
# These settings vary between the services and are defined in
# the github-services repository. Booleans are stored internally
# as "1" for true, and "0" for false. Any JSON true/false values
# will be converted automatically.
# @input params [Array] :events
# Determines what events the hook is triggered for. Default: ["push"]
# @input params [Array] :add_events
# Determines a list of events to be added to the list of events
# that the Hook triggers for.
# @input params [Array] :remove_events
# Determines a list of events to be removed from the list of
# events that the Hook triggers for.
# @input params [Boolean] :active
# Determines whether the hook is actually triggered on pushes.
#
# @example
# github = Github.new
# github.orgs.hooks.edit 'org-name', 'hook-id',
# "name" => "campfire",
# "active" => true,
# "config" => {
# "subdomain" => "github",
# "room" => "Commits",
# "token" => "abc123"
# }
#
# @api public
def edit(*args)
arguments(args, required: [:org_name, :id]) do
assert_required REQUIRED_PARAMS
end
patch_request("/orgs/#{arguments.org_name}/hooks/#{arguments.id}",
arguments.params)
end
# Ping a hook
#
# This will trigger a ping event to be sent to the hook.
#
# @see https://developer.github.com/v3/orgs/hooks/#ping-a-hook
#
# @example
# github = Github.new
# github.orgs.hooks.ping 'org-name', 'hook-id'
#
# @api public
def ping(*args)
arguments(args, required: [:org_name, :id])
post_request("/orgs/#{arguments.org_name}/hooks/#{arguments.id}/pings",
arguments.params)
end
# Delete a hook
#
# @see https://developer.github.com/v3/orgs/hooks/#delete-a-hook
#
# @example
# github = Github.new
# github.orgs.hooks.delete 'org-name', 'hook-id'
#
# @api public
def delete(*args)
arguments(args, required: [:org_name, :id])
delete_request("/orgs/#{arguments.org_name}/hooks/#{arguments.id}",
arguments.params)
end
end # Client::Orgs::Hooks
end # Github
github-api-0.14.2/lib/github_api/client/emojis.rb 0000644 0001750 0001750 00000000450 12735456050 020205 0 ustar alee alee # encoding: utf-8
module Github
class Client::Emojis < API
# Lists all the emojis.
#
# @example
# Github.emojis.list
#
# @api public
def list(*args)
arguments(args)
get_request("/emojis", arguments.params)
end
end # Client::Emojis
end # Github
github-api-0.14.2/lib/github_api/client/gists.rb 0000644 0001750 0001750 00000016145 12735456050 020060 0 ustar alee alee # encoding: utf-8
module Github
class Client::Gists < API
require_all 'github_api/client/gists', 'comments'
# Access to Gists::Comments API
namespace :comments
# List a user's gists
#
# @see https://developer.github.com/v3/gists/#list-a-users-gists
#
# @example
# github = Github.new
# github.gists.list user: 'user-name'
#
# List the authenticated user’s gists or if called anonymously,
# this will returns all public gists
#
# @example
# github = Github.new oauth_token: '...'
# github.gists.list
#
# List all public gists
#
# @see https://developer.github.com/v3/gists/#list-all-public-gists
#
# github = Github.new
# github.gists.list :public
#
# @return [Hash]
#
# @api public
def list(*args)
params = arguments(args).params
response = if (user = params.delete('user'))
get_request("/users/#{user}/gists", params)
elsif args.map(&:to_s).include?('public')
get_request("/gists/public", params)
else
get_request("/gists", params)
end
return response unless block_given?
response.each { |el| yield el }
end
alias_method :all, :list
# List the authenticated user's starred gists
#
# @see https://developer.github.com/v3/gists/#list-starred-gists
#
# @example
# github = Github.new oauth_token: '...'
# github.gists.starred
#
# @return [Hash]
#
# @api public
def starred(*args)
arguments(args)
response = get_request("/gists/starred", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
# Get a single gist
#
# @see https://developer.github.com/v3/gists/#get-a-single-gist
#
# @example
# github = Github.new
# github.gists.get 'gist-id'
#
# Get a specific revision of gist
#
# @see https://developer.github.com/v3/gists/#get-a-specific-revision-of-a-gist
#
# @example
# github = Github.new
# github.gists.get 'gist-id', sha: '
#
# @return [Hash]
#
# @api public
def get(*args)
arguments(args, required: [:id])
if (sha = arguments.params.delete('sha'))
get_request("/gists/#{arguments.id}/#{sha}")
else
get_request("/gists/#{arguments.id}", arguments.params)
end
end
alias_method :find, :get
# Create a gist
#
# @see https://developer.github.com/v3/gists/#create-a-gist
#
# @param [Hash] params
# @option params [String] :description
# Optional string
# @option params [Boolean] :public
# Required boolean
# @option params [Hash] :files
# Required hash - Files that make up this gist.
# The key of which should be a required string filename and
# the value another required hash with parameters:
# @option files [String] :content
# Required string - File contents.
#
# @example
# github = Github.new
# github.gists.create
# description: 'the description for this gist',
# public: true,
# files: {
# 'file1.txt' => {
# content: 'String file contents'
# }
# }
#
# @return [Hash]
#
# @api public
def create(*args)
arguments(args)
post_request("/gists", arguments.params)
end
# Edit a gist
#
# @see https://developer.github.com/v3/gists/#edit-a-gist
#
# @param [Hash] params
# @option [String] :description
# Optional string
# @option [Hash] :files
# Optional hash - Files that make up this gist.
# The key of which should be a optional string filename and
# the value another optional hash with parameters:
# @option [String] :content
# Updated string - Update file contents.
# @option [String] :filename
# Optional string - New name for this file.
#
# @xample
# github = Github.new oauth_token: '...'
# github.gists.edit 'gist-id',
# description: 'the description for this gist',
# files: {
# 'file1.txt' => {
# content: 'Updated file contents'
# },
# 'old_name.txt' => {
# filename: 'new_name.txt',
# content: 'modified contents'
# },
# 'new_file.txt' => {
# content: 'a new file contents'
# },
# 'delete_the_file.txt' => nil
# }
#
# @return [Hash]
#
# @api public
def edit(*args)
arguments(args, required: [:id])
patch_request("/gists/#{arguments.id}", arguments.params)
end
# List gist commits
#
# @see https://developer.github.com/v3/gists/#list-gist-commits
#
# @example
# github = Github.new
# github.gists.commits 'gist-id'
#
# @api public
def commits(*args)
arguments(args, required: [:id])
response = get_request("/gists/#{arguments.id}/commits")
return response unless block_given?
response.each { |el| yield el }
end
# Star a gist
#
# @see https://developer.github.com/v3/gists/#star-a-gist
#
# @example
# github = Github.new
# github.gists.star 'gist-id'
#
# @api public
def star(*args)
arguments(args, required: [:id])
put_request("/gists/#{arguments.id}/star", arguments.params)
end
# Unstar a gist
#
# @see https://developer.github.com/v3/gists/#unstar-a-gist
#
# @xample
# github = Github.new
# github.gists.unstar 'gist-id'
#
# @api public
def unstar(*args)
arguments(args, required: [:id])
delete_request("/gists/#{arguments.id}/star", arguments.params)
end
# Check if a gist is starred
#
# @see https://developer.github.com/v3/gists/#check-if-a-gist-is-starred
#
# @example
# github = Github.new
# github.gists.starred? 'gist-id'
#
# @api public
def starred?(*args)
arguments(args, required: [:id])
get_request("/gists/#{arguments.id}/star", arguments.params)
true
rescue Github::Error::NotFound
false
end
# Fork a gist
#
# @example
# github = Github.new
# github.gists.fork 'gist-id'
#
# @api public
def fork(*args)
arguments(args, required: [:id])
post_request("/gists/#{arguments.id}/forks", arguments.params)
end
# List gist forks
#
# @see https://developer.github.com/v3/gists/#list-gist-forks
#
# @example
# github = Github.new
# github.gists.forks 'gist-id'
#
# @api public
def forks(*args)
arguments(args, required: [:id])
response = get_request("/gists/#{arguments.id}/forks")
return response unless block_given?
response.each { |el| yield el }
end
# Delete a gist
#
# @see https://developer.github.com/v3/gists/#delete-a-gist
#
# @example
# github = Github.new
# github.gists.delete 'gist-id'
#
# @api public
def delete(*args)
arguments(args, required: [:id])
delete_request("/gists/#{arguments.id}", arguments.params)
end
end # Gists
end # Github
github-api-0.14.2/lib/github_api/client/search/ 0000755 0001750 0001750 00000000000 12735456050 017640 5 ustar alee alee github-api-0.14.2/lib/github_api/client/search/legacy.rb 0000644 0001750 0001750 00000006321 12735456050 021433 0 ustar alee alee # encoding: utf-8
module Github
class Client::Search::Legacy < API
include Github::Utils::Url
# Search issues
#
# Find issues by state and keyword.
#
# @param [Hash] params
# @option params [String] :state
# Indicates the state of the issues to return. Can be either open or closed.
# @option params [String] :keyword
# The search term
#
# @example
# github = Github.new
# github.search.legacy.issues 'owner', 'repo-name', 'open','api'
# github.search.legacy.issues owner: 'owner', repo: 'repo-name', state: 'open', keyword: 'api'
#
# @api public
def issues(*args)
required = %w[ owner repo state keyword ]
arguments(args, required: required)
get_request("/legacy/issues/search/#{arguments.owner}/#{arguments.repo}/#{arguments.state}/#{escape_uri(arguments.keyword)}", arguments.params)
end
# Search repositories
#
# Find repositories by keyword.
#
# @param [Hash] params
# @option params [String] :keyword
# The search term
# @option params [String] :language
# Filter results by language
# @option params [String] :start_page
# The page number to fetch
# @option params [String] :sort
# The sort field. One of stars, forks, or updated.
# Default: results are sorted by best match.
# @option params [String] :order
# The sort field. if sort param is provided.
# Can be either asc or desc.
#
# @example
# github = Github.new
# github.search.legacy.repos 'api'
# github.search.legacy.repos keyword: 'api'
#
# @api public
def repos(*args)
arguments(args, required: [:keyword])
get_request("/legacy/repos/search/#{escape_uri(arguments.keyword)}", arguments.params)
end
alias :repositories :repos
# Search users
#
# Find users by keyword.
#
# @param [Hash] params
# @option params [String] :keyword
# The search term
# @option params [String] :start_page
# The page number to fetch
# @option params [String] :sort
# The sort field. One of stars, forks, or updated.
# Default: results are sorted by best match.
# @option params [String] :order
# The sort field. if sort param is provided.
# Can be either asc or desc.
#
# @example
# github = Github.new
# github.search.legacy.users 'user'
# github.search.legacy.users keyword: 'user'
#
# @api public
def users(*args)
arguments(args, required: [:keyword])
get_request("/legacy/user/search/#{escape_uri(arguments.keyword)}", arguments.params)
end
# Search email
#
# This API call is added for compatibility reasons only. There’s no
# guarantee that full email searches will always be available.
#
# @param [Hash] params
# @option params [String] :email
# The email address
#
# @example
# github = Github.new
# github.search.email 'email-address'
# github.search.email email: 'email-address'
#
# @api public
def email(*args)
arguments(args, required: [:email])
get_request("/legacy/user/email/#{arguments.email}", arguments.params)
end
end # Search::Legacy
end # Github
github-api-0.14.2/lib/github_api/client/authorizations/ 0000755 0001750 0001750 00000000000 12735456050 021456 5 ustar alee alee github-api-0.14.2/lib/github_api/client/authorizations/app.rb 0000644 0001750 0001750 00000006173 12735456050 022572 0 ustar alee alee # encoding: utf-8
module Github
class Client::Authorizations::App < Client::Authorizations
# Get-or-create an authorization for a specific app
#
# @see https://developer.github.com/v3/oauth_authorizations/#get-or-create-an-authorization-for-a-specific-app
#
# @param [Hash] params
# @option params [String] client_secret
# The 40 character OAuth app client secret associated with the client
# ID specified in the URL.
# @option params [Array] :scopes
# Optional array - A list of scopes that this authorization is in.
# @option params [String] :note
# Optional string - A note to remind you what the OAuth token is for.
# @option params [String] :note_url
# Optional string - A URL to remind you what the OAuth token is for.
#
# @example
# github = Github.new
# github.oauth.app.create 'client-id', client_secret: '...'
#
# @api public
def create(*args)
raise_authentication_error unless authenticated?
arguments(args, required: [:client_id])
if arguments.client_id
put_request("/authorizations/clients/#{arguments.client_id}", arguments.params)
else
raise raise_app_authentication_error
end
end
# Check if an access token is a valid authorization for an application
#
# @example
# github = Github.new basic_auth: "client_id:client_secret"
# github.oauth.app.check 'client_id', 'access-token'
#
# @api public
def check(*args)
raise_authentication_error unless authenticated?
params = arguments(args, required: [:client_id, :access_token]).params
if arguments.client_id
begin
get_request("/applications/#{arguments.client_id}/tokens/#{arguments.access_token}", params)
rescue Github::Error::NotFound => e
nil
end
else
raise raise_app_authentication_error
end
end
# Revoke all authorizations for an application
#
# @example
# github = Github.new basic_auth: "client_id:client_secret"
# github.oauth.app.delete 'client-id'
#
# Revoke an authorization for an application
#
# @example
# github = Github.new basic_auth: "client_id:client_secret"
# github.oauth.app.delete 'client-id', 'access-token'
#
# @api public
def delete(*args)
raise_authentication_error unless authenticated?
params = arguments(args, required: [:client_id]).params
if arguments.client_id
if access_token = (params.delete('access_token') || args[1])
delete_request("/applications/#{arguments.client_id}/tokens/#{access_token}", params)
else
# Revokes all tokens
delete_request("/applications/#{arguments.client_id}/tokens", params)
end
else
raise raise_app_authentication_error
end
end
alias :remove :delete
alias :revoke :delete
protected
def raise_app_authentication_error
raise ArgumentError, 'To create authorization for the app, ' +
'you need to provide client_id argument and client_secret parameter'
end
end # Client::Authorizations::App
end # Github
github-api-0.14.2/lib/github_api/client/git_data/ 0000755 0001750 0001750 00000000000 12735456050 020147 5 ustar alee alee github-api-0.14.2/lib/github_api/client/git_data/commits.rb 0000644 0001750 0001750 00000006105 12735456050 022151 0 ustar alee alee # encoding: utf-8
module Github
class Client::GitData::Commits < API
VALID_COMMIT_PARAM_NAMES = %w[
message
tree
parents
author
committer
name
email
date
].freeze
REQUIRED_COMMIT_PARAMS = %w[
message
tree
parents
].freeze
# Get a commit
#
# @example
# github = Github.new
# github.git_data.commits.get 'user-name', 'repo-name', 'sha'
#
# @example
# commits = Github::Commits.new user: 'user-name', repo: 'repo-name'
# commits.get sha: '...'
#
# @api public
def get(*args)
arguments(args, required: [:user, :repo, :sha])
params = arguments.params
get_request("/repos/#{arguments.user}/#{arguments.repo}/git/commits/#{arguments.sha}", params)
end
alias :find :get
# Create a commit
#
# @param [Hash] params
# @input params [String] :message
# The commit message
# @input params [String] :tree
# String of the SHA of the tree object this commit points to
# @input params [Array[String]] :parents
# Array of the SHAs of the commits that were the parents of this commit.
# If omitted or empty, the commit will be written as a root commit.
# For a single parent, an array of one SHA should be provided,
# for a merge commit, an array of more than one should be provided.
#
# Optional Parameters
#
# You can provide an additional commiter parameter, which is a hash
# containing information about the committer. Or, you can provide an author
# parameter, which is a hash containing information about the author.
#
# The committer section is optional and will be filled with the author
# data if omitted. If the author section is omitted, it will be filled
# in with the authenticated users information and the current date.
#
# Both the author and commiter parameters have the same keys:
#
# @input params [String] :name
# String of the name of the author (or commiter) of the commit
# @input params [String] :email
# String of the email of the author (or commiter) of the commit
# @input params [Timestamp] :date
# Indicates when this commit was authored (or committed).
# This is a timestamp in ISO 8601 format: YYYY-MM-DDTHH:MM:SSZ.
#
# @example
# github = Github.new
# github.git_data.commits.create 'user-name', 'repo-name',
# message: "my commit message",
# author: {
# name: "Scott Chacon",
# email: "schacon@gmail.com",
# date: "2008-07-09T16:13:30+12:00"
# },
# parents: [
# "7d1b31e74ee336d15cbd21741bc88a537ed063a0"
# ],
# tree: "827efc6d56897b048c772eb4087f854f46256132"]
#
# @api public
def create(*args)
arguments(args, required: [:user, :repo]) do
permit VALID_COMMIT_PARAM_NAMES
assert_required REQUIRED_COMMIT_PARAMS
end
post_request("/repos/#{arguments.user}/#{arguments.repo}/git/commits", arguments.params)
end
end # GitData::Commits
end # Github
github-api-0.14.2/lib/github_api/client/git_data/trees.rb 0000644 0001750 0001750 00000006414 12735456050 021623 0 ustar alee alee # encoding: utf-8
module Github
class Client::GitData::Trees < API
VALID_TREE_PARAM_NAMES = %w[
base_tree
tree
path
mode
type
sha
content
url
].freeze
VALID_TREE_PARAM_VALUES = {
'mode' => %w[ 100644 100755 040000 160000 120000 ],
'type' => %w[ blob tree commit ]
}
# Get a tree
#
# @example
# github = Github.new
# github.git_data.trees.get 'user-name', 'repo-name', 'sha'
# github.git_data.trees.get 'user-name', 'repo-name', 'sha' do |file|
# file.path
# end
#
# Get a tree recursively
#
# @example
# github = Github.new
# github.git_data.trees.get 'user-name', 'repo-name', 'sha', recursive: true
#
# @api public
def get(*args)
arguments(args, required: [:user, :repo, :sha])
user = arguments.user
repo = arguments.repo
sha = arguments.sha
params = arguments.params
response = if params['recursive']
params['recursive'] = 1
get_request("/repos/#{user}/#{repo}/git/trees/#{sha}", params)
else
get_request("/repos/#{user}/#{repo}/git/trees/#{sha.to_s}", params)
end
return response unless block_given?
response.tree.each { |el| yield el }
end
alias :find :get
# Create a tree
#
# The tree creation API will take nested entries as well.
# If both a tree and a nested path modifying that tree are specified,
# it will overwrite the contents of that tree with the new path contents
# and write a new tree out.
#
# @param [Hash] params
# @input params [String] :base_tree
# The SHA1 of the tree you want to update with new data
# @input params [Array[Hash]] :tree
# Required. Objects (of path, mode, type, and sha)
# specifying a tree structure
#
# The tree parameter takes the following keys:
# @input tree [String] :path
# The file referenced in the tree
# @input tree [String] :mode
# The file mode; one of 100644 for file (blob), 100755 for
# executable (blob), 040000 for subdirectory (tree), 160000 for
# submodule (commit), or 120000 for a blob that specifies
# the path of a symlink
# @input tree [String] :type
# Either blob, tree, or commit
# @input tree [String] :sha
# The SHA1 checksum ID of the object in the tree
# @input tree [String] :content
# The content you want this file to have - GitHub will write
# this blob out and use the SHA for this entry.
# Use either this or tree.sha
#
# @example
# github = Github.new
# github.git_data.trees.create 'user-name', 'repo-name',
# tree: [
# {
# path: "file.rb",
# mode: "100644",
# type: "blob",
# sha: "44b4fc6d56897b048c772eb4087f854f46256132"
# },
# ...
# ]
#
# @api public
def create(*args)
arguments(args, required: [:user, :repo]) do
assert_required %w[ tree ]
permit VALID_TREE_PARAM_NAMES, 'tree', { recursive: true }
assert_values VALID_TREE_PARAM_VALUES, 'tree'
end
post_request("/repos/#{arguments.user}/#{arguments.repo}/git/trees", arguments.params)
end
end # GitData::Trees
end # Github
github-api-0.14.2/lib/github_api/client/git_data/references.rb 0000644 0001750 0001750 00000010730 12735456050 022616 0 ustar alee alee # encoding: utf-8
module Github
class Client::GitData::References < API
VALID_REF_PARAM_NAMES = %w[ ref sha force ].freeze
REQUIRED_REF_PARAMS = %w[ ref sha ].freeze
VALID_REF_PARAM_VALUES = {
'ref' => %r{^refs\/\w+(\/\w+)*} # test fully qualified reference
}
# Get all references
#
# This will return an array of all the references on the system,
# including things like notes and stashes if they exist on the server.
# Anything in the namespace, not just heads and tags,
# though that would be the most common.
#
# @example
# github = Github.new
# github.git_data.references.list 'user-name', 'repo-name'
#
# @example
# github.git_data.references.list 'user-name', 'repo-name', ref:'tags'
#
# @api public
def list(*args)
arguments(args, required: [:user, :repo])
params = arguments.params
user = arguments.user
repo = arguments.repo
response = if (ref = params.delete('ref'))
validate_reference ref
get_request("/repos/#{user}/#{repo}/git/refs/#{ref}", params)
else
get_request("/repos/#{user}/#{repo}/git/refs", params)
end
return response unless block_given?
response.each { |el| yield el }
end
alias :all :list
# Get a reference
#
# The ref in the URL must be formatted as heads/branch,
# not just branch. For example, the call to get the data for a
# branch named sc/featureA would be formatted as heads/sc/featureA
#
# @example
# github = Github.new
# github.git_data.references.get 'user-name', 'repo-name', 'heads/branch'
#
# @api public
def get(*args)
arguments(args, required: [:user, :repo, :ref])
validate_reference arguments.ref
params = arguments.params
get_request("/repos/#{arguments.user}/#{arguments.repo}/git/refs/#{arguments.ref}", params)
end
alias :find :get
# Create a reference
#
# @param [Hash] params
# @input params [String] :ref
# The name of the fully qualified reference (ie: refs/heads/master).
# If it doesn’t start with ‘refs’ and have at least two slashes,
# it will be rejected.
# @input params [String] :sha
# The SHA1 value to set this reference to
#
# @example
# github = Github.new
# github.git_data.references.create 'user-name', 'repo-name',
# ref: "refs/heads/master",
# sha: "827efc6d56897b048c772eb4087f854f46256132"
#
# @api public
def create(*args)
arguments(args, required: [:user, :repo]) do
permit VALID_REF_PARAM_NAMES
assert_required REQUIRED_REF_PARAMS
end
params = arguments.params
validate_reference params['ref']
post_request("/repos/#{arguments.user}/#{arguments.repo}/git/refs", params)
end
# Update a reference
#
# @param [Hash] params
# @input params [String] :sha
# The SHA1 value to set this reference to
# @input params [Boolean] :force
# Indicates whether to force the update or to make sure the update
# is a fast-forward update. Leaving this out or setting it to false
# will make sure you’re not overwriting work. Default: false
#
# @example
# github = Github.new
# github.git_data.references.update 'user-name', 'repo-name', 'heads/master',
# sha: "827efc6d56897b048c772eb4087f854f46256132",
# force: true
#
# @api public
def update(*args)
arguments(args, required: [:user, :repo, :ref]) do
permit VALID_REF_PARAM_NAMES
assert_required %w[ sha ]
end
patch_request("/repos/#{arguments.user}/#{arguments.repo}/git/refs/#{arguments.ref}", arguments.params)
end
# Delete a reference
#
# @example
# github = Github.new
# github.git_data.references.delete 'user-name', 'repo-name',
# ref: "refs/heads/master"
#
# @api public
def delete(*args)
arguments(args, required: [:user, :repo, :ref])
params = arguments.params
delete_request("/repos/#{arguments.user}/#{arguments.repo}/git/refs/#{arguments.ref}", params)
end
alias :remove :delete
private
def validate_reference(ref)
refs = (ref =~ (/^(\/)?refs.*/) ? ref : "refs/#{ref}").gsub(/(\/)+/, '/')
refs.gsub!(/^\//, '')
unless VALID_REF_PARAM_VALUES['ref'] =~ refs
raise ArgumentError, "Provided 'reference' is invalid"
end
end
end # GitData::References
end # Github
github-api-0.14.2/lib/github_api/client/git_data/blobs.rb 0000644 0001750 0001750 00000002710 12735456050 021575 0 ustar alee alee # encoding: utf-8
module Github
# Since blobs can be any arbitrary binary data, the input and responses for
# the blob api takes an encoding parameter that can be either utf-8 or base64.
# If your data cannot be losslessly sent as a UTF-8 string, you can base64 encode it.
class Client::GitData::Blobs < API
VALID_BLOB_PARAM_NAMES = %w[ content encoding ].freeze
# Get a blob
#
# @example
# github = Github.new
# github.git_data.blobs.get 'user-name', 'repo-name', 'sha'
#
# @api public
def get(*args)
arguments(args, required: [:user, :repo, :sha])
get_request("/repos/#{arguments.user}/#{arguments.repo}/git/blobs/#{arguments.sha}", arguments.params)
end
alias :find :get
# Create a blob
#
# @param [Hash] params
# @input params [String] :content
# String of content.
# @input params [String] :encoding
# String containing encodingutf-8 or base64
#
# @examples
# github = Github.new
# github.git_data.blobs.create 'user-name', 'repo-name',
# content: "Content of the blob",
# encoding: "utf-8"
#
# @api public
def create(*args)
arguments(args, required: [:user, :repo]) do
permit VALID_BLOB_PARAM_NAMES
assert_required VALID_BLOB_PARAM_NAMES
end
post_request("/repos/#{arguments.user}/#{arguments.repo}/git/blobs", arguments.params)
end
end # GitData::Blobs
end # Github
github-api-0.14.2/lib/github_api/client/git_data/tags.rb 0000644 0001750 0001750 00000005342 12735456050 021436 0 ustar alee alee # encoding: utf-8
module Github
class Client::GitData::Tags < API
# This tags api only deals with tag objects -
# so only annotated tags, not lightweight tags.
VALID_TAG_PARAM_NAMES = %w[
tag
message
object
type
name
email
date
sha
url
tagger
].freeze
VALID_TAG_PARAM_VALUES = {
'type' => %w[ blob tree commit ]
}
# Get a tag
#
# @example
# github = Github.new
# github.git_data.tags.get 'user-name', 'repo-name', 'sha'
#
# @api public
def get(*args)
arguments(args, required: [:user, :repo, :sha])
params = arguments.params
get_request("/repos/#{arguments.user}/#{arguments.repo}/git/tags/#{arguments.sha}", params)
end
alias :find :get
# Create a tag object
#
# Note that creating a tag object does not create the reference that
# makes a tag in Git. If you want to create an annotated tag in Git,
# you have to do this call to create the tag object, and then create
# the refs/tags/[tag] reference. If you want to create a lightweight
# tag, you simply have to create the reference -
# this call would be unnecessary.
#
# @param [Hash] params
# @input params [String] :tag
# The tag
# @input params [String] :message
# The tag message
# @input params [String] :object
# The SHA of the git object this is tagging
# @input params [String] :type
# The type of the object we're tagging.
# Normally this is a commit but it can also be a tree or a blob
# @input params [Hash] :tagger
# A hash with information about the individual creating the tag.
#
# The tagger hash contains the following keys:
# @input tagger [String] :name
# The name of the author of the tag
# @input tagger [String] :email
# The email of the author of the tag
# @input tagger [String] :date
# When this object was tagged. This is a timestamp in ISO 8601
# format: YYYY-MM-DDTHH:MM:SSZ.
#
# @xample
# github = Github.new
# github.git_data.tags.create 'user-name', 'repo-name',
# tag: "v0.0.1",
# message: "initial version\n",
# type: "commit",
# object: "c3d0be41ecbe669545ee3e94d31ed9a4bc91ee3c",
# tagger: {
# name: "Scott Chacon",
# email: "schacon@gmail.com",
# date: "2011-06-17T14:53:3"
# }
#
# @api public
def create(*args)
arguments(args, required: [:user, :repo]) do
permit VALID_TAG_PARAM_NAMES
assert_values VALID_TAG_PARAM_VALUES
end
post_request("/repos/#{arguments.user}/#{arguments.repo}/git/tags", arguments.params)
end
end # GitData::Tags
end # Github
github-api-0.14.2/lib/github_api/client/markdown.rb 0000644 0001750 0001750 00000004024 12735456050 020542 0 ustar alee alee # encoding: utf-8
module Github
class Client::Markdown < API
# Render an arbritrary Markdown document
#
# = Parameters
# :text - Required string - The Markdown text to render
# :mode - Optional string - The rendering mode
# * markdown to render a document as plain Markdown, just
# like README files are rendered.
# * gfm to render a document as user-content, e.g. like user
# comments or issues are rendered. In GFM mode, hard line breaks are
# always taken into account, and issue and user mentions are
# linked accordingly.
# :context - Optional string - The repository context, only taken
# into account when rendering as gfm
#
# = Examples
# github = Github.new
# github.markdown.render
# "text": "Hello world github/linguist#1 **cool**, and #1!",
# "mode": "gfm",
# "context": "github/gollum"
#
def render(*args)
arguments(args) do
assert_required ['text']
end
params = arguments.params
params['raw'] = true
post_request("markdown", arguments.params)
end
# Render a Markdown document in raw mode
#
# = Input
# The raw API it not JSON-based. It takes a Markdown document as plaintext
# text/plain or text/x-markdown and renders it as plain
# Markdown without a repository context (just like a README.md file is
# rendered – this is the simplest way to preview a readme online)
#
# = Examples
# github = Github.new
# github.markdown.render_raw "Hello github/linguist#1 **cool**, and #1!",
# "accept": "text/plain",
#
def render_raw(*args)
params = arguments(args).params
mime_type, params['data'] = params['mime'], args.shift
params['raw'] = true
params['accept'] = params.fetch('accept') { 'text/plain' }
post_request("markdown/raw", params)
end
end # Markdown
end # Github
github-api-0.14.2/lib/github_api/client/git_data.rb 0000644 0001750 0001750 00000001004 12735456050 020467 0 ustar alee alee # encoding: utf-8
module Github
class Client::GitData < API
require_all 'github_api/client/git_data',
'blobs',
'commits',
'references',
'tags',
'trees'
# Access to GitData::Blobs API
namespace :blobs
# Access to GitData::Commits API
namespace :commits
# Access to GitData::References API
namespace :references
# Access to GitData::Tags API
namespace :tags
# Access to GitData::Tags API
namespace :trees
end # GitData
end # Github
github-api-0.14.2/lib/github_api/client/issues/ 0000755 0001750 0001750 00000000000 12735456050 017706 5 ustar alee alee github-api-0.14.2/lib/github_api/client/issues/events.rb 0000644 0001750 0001750 00000002505 12735456050 021541 0 ustar alee alee # encoding: utf-8
module Github
class Client::Issues::Events < API
# List events for an issue
#
# @example
# github = Github.new
# github.issues.events.list 'user-name', 'repo-name',
# issue_number: 'issue-number'
#
# List events for a repository
#
# @example
# github = Github.new
# github.issues.events.list 'user-name', 'repo-name'
#
# @api public
def list(*args)
arguments(args, required: [:user, :repo])
params = arguments.params
response = if (issue_number = params.delete('issue_number'))
get_request("/repos/#{arguments.user}/#{arguments.repo}/issues/#{issue_number}/events", params)
else
get_request("/repos/#{arguments.user}/#{arguments.repo}/issues/events", params)
end
return response unless block_given?
response.each { |el| yield el }
end
alias :all :list
# Get a single event
#
# @example
# github = Github.new
# github.issues.events.get 'user-name', 'repo-name', 'event-id'
#
# @api public
def get(*args)
arguments(args, :required => [:user, :repo, :id])
params = arguments.params
get_request("/repos/#{arguments.user}/#{arguments.repo}/issues/events/#{arguments.id}", params)
end
alias :find :get
end # Issues::Events
end # Github
github-api-0.14.2/lib/github_api/client/issues/assignees.rb 0000644 0001750 0001750 00000002362 12735456050 022217 0 ustar alee alee # encoding: utf-8
module Github
class Client::Issues::Assignees < API
# Lists all the available assignees (owner + collaborators)
# to which issues may be assigned.
#
# @example
# Github.issues.assignees.list 'owner', 'repo'
# Github.issues.assignees.list 'owner', 'repo' { |assignee| ... }
#
# @api public
def list(*args)
arguments(args, required: [:owner, :repo])
response = get_request("/repos/#{arguments.owner}/#{arguments.repo}/assignees", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias :all :list
# Check to see if a particular user is an assignee for a repository.
#
# @example
# Github.issues.assignees.check 'user', 'repo', 'assignee'
#
# @example
# github = Github.new user: 'user-name', repo: 'repo-name'
# github.issues.assignees.check 'assignee'
#
# @api public
def check(*args)
arguments(args, required: [:owner, :repo, :assignee])
params = arguments.params
get_request("/repos/#{arguments.owner}/#{arguments.repo}/assignees/#{arguments.assignee}",params)
true
rescue Github::Error::NotFound
false
end
end # Issues::Assignees
end # Github
github-api-0.14.2/lib/github_api/client/issues/comments.rb 0000644 0001750 0001750 00000010126 12735456050 022060 0 ustar alee alee # encoding: utf-8
module Github
class Client::Issues::Comments < API
VALID_ISSUE_COMMENT_PARAM_NAME = %w[
body
resource
mime_type
].freeze
# List comments on an issue
#
# @example
# github = Github.new
# github.issues.comments.all 'owner-name', 'repo-name', number: 'id'
# github.issues.comments.all 'owner-name', 'repo-name', number: 'id' {|com| .. }
# @example
# github.issues.comments.all owner: 'username', repo: 'repo-name', number: 'id'
#
# List comments in a repository
#
# @param [Hash] params
# @option params [String] :sort
# Optional string, created or updated
# @option params [String] :direction
# Optional string, asc or desc. Ignored with sort parameter.
# @option params [String] :since
# Optional string of a timestamp in ISO 8601 format: YYYY-MM-DDTHH:MM:SSZ
#
# @example
# github = Github.new
# github.issues.comments.all 'user-name', 'repo-name'
# github.issues.comments.all 'user-name', 'repo-name' {|com| .. }
#
# @api public
def list(*args)
arguments(args, required: [:user, :repo])
params = arguments.params
response = if (number = params.delete('number'))
get_request("/repos/#{arguments.user}/#{arguments.repo}/issues/#{number}/comments", params)
else
get_request("/repos/#{arguments.user}/#{arguments.repo}/issues/comments", params)
end
return response unless block_given?
response.each { |el| yield el }
end
alias :all :list
# Get a single comment
#
# @example
# github = Github.new
# github.issues.comments.find 'user-name', 'repo-name', 'id'
#
# @example
# github.issues.comments.find owner: 'user-name', repo: 'repo-name', id: 'id'
#
def get(*args)
arguments(args, required: [:user, :repo, :id])
params = arguments.params
get_request("/repos/#{arguments.user}/#{arguments.repo}/issues/comments/#{arguments.id}", params)
end
alias :find :get
# Create a comment
#
# @param [Hash] params
# @option [String] :body
# Required string
#
# @example
# github = Github.new
# github.issues.comments.create 'user-name', 'repo-name', 'number',
# body: 'a new comment'
#
# @example
# github.issues.comments.create
# user: 'owner-name',
# repo: 'repo-name',
# number: 'comment-number',
# body: 'a new comment body'
#
# @api public
def create(*args)
arguments(args, required: [:user, :repo, :number]) do
permit VALID_ISSUE_COMMENT_PARAM_NAME
assert_required %w[ body ]
end
params = arguments.params
post_request("/repos/#{arguments.user}/#{arguments.repo}/issues/#{arguments.number}/comments", params)
end
# Edit a comment
#
# @param [Hash] params
# @option params [String] :body
# Required string
#
# @example
# github = Github.new
# github.issues.comments.edit 'owner-name', 'repo-name', 'id',
# body: 'a new comment'
#
# @example
# github.issues.comments.edit
# user: 'owner-name',
# repo: 'repo-name',
# id: 'comment-id',
# body: 'a new comment body'
#
# @api public
def edit(*args)
arguments(args, required: [:user, :repo, :id]) do
permit VALID_ISSUE_COMMENT_PARAM_NAME
assert_required %w[ body ]
end
patch_request("/repos/#{arguments.user}/#{arguments.repo}/issues/comments/#{arguments.id}", arguments.params)
end
# Delete a comment
#
# = Examples
# github = Github.new
# github.issues.comments.delete 'owner-name', 'repo-name', 'comment-id'
#
# @example
# github.issues.comments.delete
# user: 'owner-name',
# repo: 'repo-name',
# id: 'comment-id',
#
# @api public
def delete(*args)
arguments(args, required: [:user, :repo, :id])
delete_request("/repos/#{arguments.user}/#{arguments.repo}/issues/comments/#{arguments.id}", arguments.params)
end
end # Issues::Comments
end # Github
github-api-0.14.2/lib/github_api/client/issues/labels.rb 0000644 0001750 0001750 00000013067 12735456050 021504 0 ustar alee alee # encoding: utf-8
module Github
class Client::Issues::Labels < API
VALID_LABEL_INPUTS = %w[ name color ].freeze
# List all labels for a repository
#
# @example
# github = Github.new user: 'user-name', repo: 'repo-name'
# github.issues.labels.list
# github.issues.labels.list { |label| ... }
#
# Get labels for every issue in a milestone
#
# @example
# github = Github.new
# github.issues.labels.list 'user-name', 'repo-name', milestone_id: 'milestone-id'
#
# List labels on an issue
#
# @example
# github = Github.new
# github.issues.labels.list 'user-name', 'repo-name', issue_id: 'issue-id'
#
# @api public
def list(*args)
arguments(args, required: [:user, :repo])
params = arguments.params
user = arguments.user
repo = arguments.repo
response = if (milestone_id = params.delete('milestone_id'))
get_request("/repos/#{user}/#{repo}/milestones/#{milestone_id}/labels", params)
elsif (issue_id = params.delete('issue_id'))
get_request("/repos/#{user}/#{repo}/issues/#{issue_id}/labels", params)
else
get_request("/repos/#{user}/#{repo}/labels", params)
end
return response unless block_given?
response.each { |el| yield el }
end
alias :all :list
# Get a single label
#
# @example
# github = Github.new
# github.issues.labels.find 'user-name', 'repo-name', 'label-name'
#
# @example
# github = Github.new user: 'user-name', repo: 'repo-name'
# github.issues.labels.get label_name: 'bug'
#
# @api public
def get(*args)
arguments(args, required: [:user, :repo, :label_name])
params = arguments.params
get_request("/repos/#{arguments.user}/#{arguments.repo}/labels/#{arguments.label_name}", params)
end
alias :find :get
# Create a label
#
# @param [Hash] params
# @option params [String] :name
# Required string
# @option params [String] :color
# Required string - 6 character hex code, without leading #
#
# @example
# github = Github.new user: 'user-name', repo: 'repo-name'
# github.issues.labels.create name: 'API', color: 'FFFFFF'
#
# @api public
def create(*args)
arguments(args, required: [:user, :repo]) do
permit VALID_LABEL_INPUTS
assert_required VALID_LABEL_INPUTS
end
post_request("/repos/#{arguments.user}/#{arguments.repo}/labels", arguments.params)
end
# Update a label
#
# @param [Hash] params
# @option params [String] :name
# Required string
# @option params [String] :color
# Required string - 6 character hex code, without leading #
#
# @example
# github = Github.new
# github.issues.labels.update 'user-name', 'repo-name', 'label-name',
# name: 'API', color: "FFFFFF"
#
# @api public
def update(*args)
arguments(args, required: [:user, :repo, :label_name]) do
permit VALID_LABEL_INPUTS
assert_required VALID_LABEL_INPUTS
end
patch_request("/repos/#{arguments.user}/#{arguments.repo}/labels/#{arguments.label_name}", arguments.params)
end
alias :edit :update
# Delete a label
#
# @examples
# github = Github.new
# github.issues.labels.delete 'user-name', 'repo-name', 'label-name'
#
# @api public
def delete(*args)
arguments(args, required: [:user, :repo, :label_name])
delete_request("/repos/#{arguments.user}/#{arguments.repo}/labels/#{arguments.label_name}", arguments.params)
end
# Add labels to an issue
#
# @example
# github = Github.new
# github.issues.labels.add 'user-name', 'repo-name', 'issue-number',
# 'label1', 'label2', ...
#
# @api public
def add(*args)
arguments(args, required: [:user, :repo, :number])
params = arguments.params
params['data'] = arguments.remaining unless arguments.remaining.empty?
post_request("/repos/#{arguments.user}/#{arguments.repo}/issues/#{arguments.number}/labels", params)
end
alias :<< :add
# Remove a label from an issue
#
# @example
# github = Github.new
# github.issues.labels.remove 'user-name', 'repo-name', 'issue-number',
# label_name: 'label-name'
#
# Remove all labels from an issue
#
# @example
# github = Github.new
# github.issues.labels.remove 'user-name', 'repo-name', 'issue-number'
#
# @api public
def remove(*args)
arguments(args, required: [:user, :repo, :number])
params = arguments.params
user = arguments.user
repo = arguments.repo
number = arguments.number
if (label_name = params.delete('label_name'))
delete_request("/repos/#{user}/#{repo}/issues/#{number}/labels/#{label_name}", params)
else
delete_request("/repos/#{user}/#{repo}/issues/#{number}/labels", params)
end
end
# Replace all labels for an issue
#
# Sending an empty array ([]) will remove all Labels from the Issue.
#
# @example
# github = Github.new
# github.issues.labels.replace 'user-name', 'repo-name', 'issue-number',
# 'label1', 'label2', ...
#
# @api public
def replace(*args)
arguments(args, required: [:user, :repo, :number])
params = arguments.params
params['data'] = arguments.remaining unless arguments.remaining.empty?
put_request("/repos/#{arguments.user}/#{arguments.repo}/issues/#{arguments.number}/labels", params)
end
end # Issues::Labels
end # Github
github-api-0.14.2/lib/github_api/client/issues/milestones.rb 0000644 0001750 0001750 00000010521 12735456050 022414 0 ustar alee alee # encoding: utf-8
module Github
class Client::Issues::Milestones < API
VALID_MILESTONE_OPTIONS = {
'state' => %w[ open closed all ],
'sort' => %w[ due_date completeness ],
'direction' => %w[ desc asc ]
}.freeze # :nodoc:
VALID_MILESTONE_INPUTS = %w[
title
state
description
due_on
].freeze # :nodoc:
# List milestones for a repository
#
# @param [Hash] params
# @option params [String] :state
# The state of the milestone. Either open, closed, or all. Default: open
# @option params [String] :sort
# What to sort results by. Either due_date or completeness.
# Default: due_date
# @option params [String] :direction
# The directoin of the sort. Either asc or desc. Default: desc
#
# @example
# github = Github.new user: 'user-name', repo: 'repo-name'
# github.issues.milestones.list
#
# @example
# github.issues.milestones.list state: 'open', sort: 'due_date',
# direction: 'asc'
#
# @api public
def list(*args)
arguments(args, required: [:user, :repo]) do
permit VALID_MILESTONE_OPTIONS.keys
assert_values VALID_MILESTONE_OPTIONS
end
response = get_request("/repos/#{arguments.user}/#{arguments.repo}/milestones", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias :all :list
# Get a single milestone
#
# @example
# github = Github.new
# github.issues.milestones.get 'user-name', 'repo-name', 'milestone-number'
#
# @example
# github.issues.milestones.get
# user: 'user-name',
# repo: 'repo-name',
# number: 'milestone-number'
#
# @api public
def get(*args)
arguments(args, required: [:user, :repo, :number])
get_request("/repos/#{arguments.user}/#{arguments.repo}/milestones/#{arguments.number}", arguments.params)
end
alias :find :get
# Create a milestone
#
# @param [Hash] params
# @option params [String] :title
# Required string. The title of the milestone
# @option params [String] :state
# The state of the milestone. Either open or closed. Default: open.
# @option params [String] :description
# A description of the milestone
# @option params [String] :due_on
# The milestone due date. This is a timestamp in ISO 8601 format:
# YYYY-MM-DDTHH:MM:SSZ.
#
# @example
# github = Github.new user: 'user-name', repo: 'repo-name'
# github.issues.milestones.create title: 'hello-world',
# state: "open or closed",
# description: "String",
# due_on: "Time"
#
# @api public
def create(*args)
arguments(args, required: [:user, :repo]) do
permit VALID_MILESTONE_INPUTS
assert_required %w[ title ]
end
post_request("/repos/#{arguments.user}/#{arguments.repo}/milestones", arguments.params)
end
# Update a milestone
#
# @param [Hash] params
# @option params [String] :title
# Required string. The title of the milestone
# @option params [String] :state
# The state of the milestone. Either open or closed. Default: open.
# @option params [String] :description
# A description of the milestone
# @option params [String] :due_on
# The milestone due date. This is a timestamp in ISO 8601 format:
# YYYY-MM-DDTHH:MM:SSZ.
#
# @example
# github = Github.new
# github.issues.milestones.update 'user-name', 'repo-name', 'number',
# :title => 'hello-world',
# :state => "open or closed",
# :description => "String",
# :due_on => "Time"
#
# @api public
def update(*args)
arguments(args, required: [:user, :repo, :number]) do
permit VALID_MILESTONE_INPUTS
end
patch_request("/repos/#{arguments.user}/#{arguments.repo}/milestones/#{arguments.number}", arguments.params)
end
# Delete a milestone
#
# @example
# github = Github.new
# github.issues.milestones.delete 'user-name', 'repo-name', 'number'
#
# @api public
def delete(*args)
arguments(args, required: [:user, :repo, :number])
delete_request("/repos/#{arguments.user}/#{arguments.repo}/milestones/#{arguments.number}", arguments.params)
end
end # Issues::Milestones
end # Github
github-api-0.14.2/lib/github_api/client/scopes.rb 0000644 0001750 0001750 00000002175 12735456050 020221 0 ustar alee alee # encoding: utf-8
module Github
class Client::Scopes < API
# Check what OAuth scopes you have.
#
# @see https://developer.github.com/v3/oauth/#scopes
#
# @example
# github = Github.new oauth_token: 'e72e16c7e42f292c6912e7710c838347ae17'
# github.scopes.all
#
# @example
# github = Github.new
# github.scopes.list 'e72e16c7e42f292c6912e7710c838347ae17'
#
# @example
# github = Github.new
# github.scopes.list token: 'e72e16c7e42f292c6912e7710c838347ae17'
#
# @api public
def list(*args)
arguments(args)
params = arguments.params
token = args.shift
if token.is_a?(Hash) && !params['token'].nil?
token = params.delete('token')
elsif token.nil?
token = oauth_token
end
if token.nil?
raise ArgumentError, 'Access token required'
end
headers = { 'Authorization' => "token #{token}" }
params['headers'] = headers
response = get_request("/user", params)
response.headers.oauth_scopes.split(',').map(&:strip)
end
alias all list
end # Client::Scopes
end # Github
github-api-0.14.2/lib/github_api/client/users/ 0000755 0001750 0001750 00000000000 12735456050 017534 5 ustar alee alee github-api-0.14.2/lib/github_api/client/users/followers.rb 0000644 0001750 0001750 00000006204 12735456050 022077 0 ustar alee alee # encoding: utf-8
module Github
class Client::Users::Followers < API
# List a user's followers
#
# @xample
# github = Github.new
# github.users.followers.list 'user-name'
# github.users.followers.list 'user-name' { |user| ... }
#
# List the authenticated user's followers
#
# @example
# github = Github.new oauth_token: '...'
# github.users.followers
# github.users.followers { |user| ... }
#
# @api public
def list(*args)
params = arguments(args).params
response = if user_name = arguments.remaining.first
get_request("/users/#{user_name}/followers", params)
else
get_request("/user/followers", params)
end
return response unless block_given?
response.each { |el| yield el }
end
alias :all :list
# List who a user is following
#
# @example
# github = Github.new
# github.users.followers.following 'user-name'
# github.users.followers.following 'user-name' { |user| ... }
#
# List who the authenicated user is following
#
# @example
# github = Github.new oauth_token: '...'
# github.users.followers.following
#
# @api public
def following(*args)
params = arguments(args).params
response = if user_name = arguments.remaining.first
get_request("/users/#{user_name}/following", params)
else
get_request("/user/following", params)
end
return response unless block_given?
response.each { |el| yield el }
end
# Check if you are following a user
#
# @example
# github = Github.new oauth_token: '...'
# github.users.followers.following? 'user-name'
# github.users.followers.following? username: 'user-name'
#
# Check if one user follows another
#
# @example
# github = Github.new oauth_token: '...'
# github.users.followers.following? username: 'user-name',
# target_user: 'target-user-name'
#
# @api public
def following?(*args)
arguments(args, required: [:username])
params = arguments.params
if target_user = params.delete('target_user')
get_request("/users/#{arguments.username}/following/#{target_user}", params)
else
get_request("/user/following/#{arguments.username}", params)
end
true
rescue Github::Error::NotFound
false
end
# Follow a user
#
# @example
# github = Github.new oauth_token: '...'
# github.users.followers.follow 'user-name'
# github.users.followers.follow username: 'user-name'
#
# @api public
def follow(*args)
arguments(args, required: [:username])
put_request("/user/following/#{arguments.username}", arguments.params)
end
# Unfollow a user
#
# @example
# github = Github.new oauth_token: '...'
# github.users.followers.unfollow 'user-name'
# github.users.followers.unfollow username: 'user-name'
#
def unfollow(*args)
arguments(args, required: [:username])
delete_request("/user/following/#{arguments.username}", arguments.params)
end
end # Users::Followers
end # Github
github-api-0.14.2/lib/github_api/client/users/keys.rb 0000644 0001750 0001750 00000005176 12735456050 021045 0 ustar alee alee # encoding: utf-8
module Github
class Client::Users::Keys < API
VALID_KEY_PARAM_NAMES = %w[ title key ].freeze
# List public keys for the authenticated user
#
# @example
# github = Github.new oauth_token: '...'
# github.users.keys.list
# github.users.keys.list { |key| ... }
#
# List public keys for the specified user
#
# @example
# github.users.keys.list user: 'user-name'
# github.users.keys.list user: 'user-name' { |key| ... }
#
# @return [Hash]
#
# @api public
def list(*args)
params = arguments(args).params
response = if (user = params.delete('user'))
get_request("/users/#{user}/keys", params)
else
get_request("/user/keys", params)
end
return response unless block_given?
response.each { |el| yield el }
end
alias :all :list
# Get a single pulic key for the authenticated user
#
# @example
# github = Github.new oauth_token: '...'
# github.users.keys.get 'key-id'
#
# @api public
def get(*args)
arguments(args, required: [:id])
get_request("/user/keys/#{arguments.id}", arguments.params)
end
alias :find :get
# Create a public key for the authenticated user
#
# @param [Hash] params
# @option [String] :title
# Required string
# @option [String] :key
# Required string. sha key
#
# @example
# github = Github.new oauth_token: '...'
# github.users.keys.create "title": "octocat@octomac", "key": "ssh-rsa AAA..."
#
# @api public
def create(*args)
arguments(args) do
permit VALID_KEY_PARAM_NAMES
end
post_request("/user/keys", arguments.params)
end
# Update a public key for the authenticated user
#
# @param [Hash] params
# @option [String] :title
# Required string
# @option [String] :key
# Required string. sha key
#
# @example
# github = Github.new oauth_token: '...'
# github.users.keys.update 'key-id', "title": "octocat@octomac",
# "key": "ssh-rsa AAA..."
#
# @api public
def update(*args)
arguments(args, required: [:id]) do
permit VALID_KEY_PARAM_NAMES
end
patch_request("/user/keys/#{arguments.id}", arguments.params)
end
# Delete a public key for the authenticated user
#
# @example
# github = Github.new oauth_token: '...'
# github.users.keys.delete 'key-id'
#
# @api public
def delete(*args)
arguments(args, required: [:id])
delete_request("/user/keys/#{arguments.id}", arguments.params)
end
end # Users::Keys
end # Github
github-api-0.14.2/lib/github_api/client/users/emails.rb 0000644 0001750 0001750 00000003231 12735456050 021332 0 ustar alee alee # encoding: utf-8
require 'cgi'
module Github
class Client::Users::Emails < API
# List email addresses for the authenticated user
#
# @example
# github = Github.new oauth_token: '...'
# github.users.emails.list
# github.users.emails.list { |email| ... }
#
# @return [Hash]
#
# @api public
def list(*args)
arguments(args)
response = get_request("/user/emails", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias :all :list
# Add email address(es) for the authenticated user
#
# @param [Array[String]] emails
# You can include a single email address or an array of addresses
#
# @example
# github = Github.new oauth_token: '...'
# github.users.emails.add "octocat@github.com", "support@github.com"
#
# @api public
def add(*args)
arguments(args)
params = arguments.params
params['data'] = arguments.remaining unless arguments.remaining.empty?
post_request("/user/emails", params)
end
alias :<< :add
# Delete email address(es) for the authenticated user
#
# @param [Array[String]] emails
# You can include a single email address or an array of addresses
#
# @example
# github = Github.new oauth_token: '...'
# github.users.emails.delete "octocat@github.com", "support@github.com"
#
# @api public
def delete(*args)
arguments(args)
params = arguments.params
params['data'] = arguments.remaining unless arguments.remaining.empty?
delete_request("/user/emails", params)
end
end # Users::Emails
end # Github
github-api-0.14.2/lib/github_api/client/activity.rb 0000644 0001750 0001750 00000001047 12735456050 020556 0 ustar alee alee # encoding: utf-8
module Github
class Client::Activity < API
require_all 'github_api/client/activity',
'events',
'notifications',
'feeds',
'starring',
'watching'
# Access to Activity::Events API
namespace :events
# Access to Activity::Notifications API
namespace :notifications
# Access to Activity::Feeds API
namespace :feeds
# Access to Activity::Starring API
namespace :starring
# Access to Activity::Watching API
namespace :watching
end # Activity
end # Github
github-api-0.14.2/lib/github_api/client/repos.rb 0000644 0001750 0001750 00000032773 12735456050 020064 0 ustar alee alee # encoding: utf-8
module Github
class Client::Repos < API
# Load all the modules after initializing Repos to avoid superclass mismatch
require_all 'github_api/client/repos',
'collaborators',
'comments',
'commits',
'contents',
'deployments',
'downloads',
'forks',
'hooks',
'keys',
'merging',
'pages',
'pub_sub_hubbub',
'releases',
'statistics',
'statuses'
DEFAULT_REPO_OPTIONS = {
"homepage" => "https://github.com",
"private" => false,
"has_issues" => true,
"has_wiki" => true,
"has_downloads" => true
}.freeze
REQUIRED_REPO_OPTIONS = %w[ name ]
VALID_REPO_OPTIONS = %w[
name
description
homepage
private
has_issues
has_wiki
has_downloads
team_id
auto_init
gitignore_template
default_branch
].freeze
VALID_REPO_TYPES = %w[ all public private member ].freeze
# Access to Repos::Collaborators API
namespace :collaborators
# Access to Repos::Comments API
namespace :comments
# Access to Repos::Commits API
namespace :commits
# Access to Repos::Contents API
namespace :contents
# Access to Repos::Deployments API
namespace :deployments
# Access to Repos::Downloads API
namespace :downloads
# Access to Repos::Forks API
namespace :forks
# Access to Repos::Hooks API
namespace :hooks
# Access to Repos::Keys API
namespace :keys
# Access to Repos::Merging API
namespace :merging
# Access to Repos::Pages API
namespace :pages
# Access to Repos::PubSubHubbub API
namespace :pubsubhubbub, full_name: :pub_sub_hubbub
# Access to Repos::Releases API
namespace :releases
# Access to Repos::Statistics API
namespace :stats, full_name: :statistics
# Access to Repos::Statuses API
namespace :statuses
# List repositories for the authenticated user
#
# @example
# github = Github.new oauth_token: '...'
# github.repos.list
# github.repos.list { |repo| ... }
#
# List all repositories
#
# This provides a dump of every repository,
# in the order that they were created.
#
# @param [Hash] params
# @option params [Integer] :since
# the integer ID of the last Repository that you've seen.
#
# @example
# github = Github.new
# github.repos.list :every
# github.repos.list :every { |repo| ... }
#
# List public repositories for the specified user.
#
# @example
# github = Github.new
# github.repos.list user: 'user-name'
# github.repos.list user: 'user-name', { |repo| ... }
#
# List repositories for the specified organisation.
#
# @example
# github = Github.new
# github.repos.list org: 'org-name'
# github.repos.list org: 'org-name', { |repo| ... }
#
# @api public
def list(*args)
arguments(args) do
permit %w[ user org type sort direction since ]
end
params = arguments.params
unless params.symbolize_keys[:per_page]
params.merge!(Pagination.per_page_as_param(current_options[:per_page]))
end
response = if (user_name = params.delete('user') || user)
get_request("/users/#{user_name}/repos", params)
elsif (org_name = params.delete('org') || org)
get_request("/orgs/#{org_name}/repos", params)
elsif args.map(&:to_s).include?('every')
get_request('/repositories', params)
else
# For authenticated user
get_request('/user/repos', params)
end
return response unless block_given?
response.each { |el| yield el }
end
alias :all :list
# Get a repository
#
# @example
# github = Github.new
# github.repos.get 'user-name', 'repo-name'
# github.repos.get user: 'user-name', repo: 'repo-name'
# github.repos(user: 'user-name', repo: 'repo-name').get
#
def get(*args)
arguments(args, required: [:user, :repo])
get_request("/repos/#{arguments.user}/#{arguments.repo}", arguments.params)
end
alias :find :get
# Create a new repository for the autheticated user.
#
# @param [Hash] params
# @option params [String] :name
# Required string
# @option params [String] :description
# Optional string
# @option params [String] :homepage
# Optional string
# @option params [Boolean] :private
# Optional boolean - true to create a private repository,
# false to create a public one.
# @option params [Boolean] :has_issues
# Optional boolean - true to enable issues for this repository,
# false to disable them
# @option params [Boolean] :has_wiki
# Optional boolean - true to enable the wiki for this repository,
# false to disable it. Default is true
# @option params [Boolean] :has_downloads
# Optional boolean - true to enable downloads for this repository
# @option params [String] :org
# Optional string - The organisation in which this
# repository will be created
# @option params [Numeric] :team_id
# Optional number - The id of the team that will be granted
# access to this repository. This is only valid when creating
# a repo in an organization
# @option params [Boolean] :auto_init
# Optional boolean - true to create an initial commit with
# empty README. Default is false.
# @option params [String] :gitignore_template
# Optional string - Desired language or platform .gitignore
# template to apply. Use the name of the template without
# the extension. For example, “Haskell” Ignored if
# auto_init parameter is not provided.
#
# @example
# github = Github.new
# github.repos.create "name": 'repo-name'
# "description": "This is your first repo",
# "homepage": "https://github.com",
# "private": false,
# "has_issues": true,
# "has_wiki": true,
# "has_downloads": true
#
# Create a new repository in this organisation. The authenticated user
# must be a member of this organisation
#
# @example
# github = Github.new oauth_token: '...'
# github.repos.create name: 'repo-name', org: 'organisation-name'
#
# @example
def create(*args)
arguments(args) do
permit VALID_REPO_OPTIONS + %w[ org ]
assert_required %w[ name ]
end
params = arguments.params
# Requires authenticated user
if (org = params.delete('org') || org)
post_request("/orgs/#{org}/repos", params.merge_default(DEFAULT_REPO_OPTIONS))
else
post_request('/user/repos', params.merge_default(DEFAULT_REPO_OPTIONS))
end
end
# Delete a repository
#
# Deleting a repository requires admin access.
# If OAuth is used, the delete_repo scope is required.
#
# @example
# github = Github.new oauth_token: '...'
# github.repos.delete 'user-name', 'repo-name'
#
# @api public
def delete(*args)
arguments(args, required: [:user, :repo])
delete_request("/repos/#{arguments.user}/#{arguments.repo}", arguments.params)
end
alias :remove :delete
# List contributors
#
# @param [Hash] params
# @option params [Boolean] :anon
# Optional flag. Set to 1 or true to include anonymous contributors.
#
# @examples
# github = Github.new
# github.repos.contributors 'user-name','repo-name'
# github.repos.contributors 'user-name','repo-name' { |cont| ... }
#
# @api public
def contributors(*args)
arguments(args, required: [:user, :repo]) do
permit %w[ anon ]
end
params = arguments.params
response = get_request("/repos/#{arguments.user}/#{arguments.repo}/contributors", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias :list_contributors :contributors
alias :contribs :contributors
# Edit a repository
#
# @param [Hash] params
# @option params [String] :name
# Required string
# @option params [String] :description
# Optional string
# @option params [String] :homepage
# Optional string
# @option params [Boolean] :private
# Optional boolean, true to make this a private repository, false to make it a public one
# @option params [Boolean] :has_issues
# Optional boolean - true to enable issues for this repository,
# false to disable them
# @option params [Boolean] :has_wiki
# Optional boolean - true to enable the wiki for this repository,
# false to disable it. Default is true
# @option params [Boolean] :has_downloads
# Optional boolean - true to enable downloads for this repository
# @option params [String] :default_branch
# Optional string - Update the default branch for this repository.
#
# @example
# github = Github.new
# github.repos.edit 'user-name', 'repo-name',
# name: 'hello-world',
# description: 'This is your first repo',
# homepage: "https://github.com",
# public: true, has_issues: true
#
def edit(*args)
arguments(args, required: [:user, :repo]) do
permit VALID_REPO_OPTIONS
assert_required %w[ name ]
end
patch_request("/repos/#{arguments.user}/#{arguments.repo}", arguments.params.merge_default(DEFAULT_REPO_OPTIONS))
end
# Delete a repository
#
# Deleting a repository requires admin access.
# If OAuth is used, the delete_repo scope is required.
#
# @example
# github = Github.new oauth_token: '...'
# github.repos.delete 'user-name', 'repo-name'
#
# @api public
def delete(*args)
arguments(args, required: [:user, :repo])
params = arguments.params
delete_request("/repos/#{arguments.user}/#{arguments.repo}", arguments.params)
end
alias :remove :delete
# List branches
#
# @example
# github = Github.new
# github.repos.branches 'user-name', 'repo-name'
# github.repos(user: 'user-name', repo: 'repo-name').branches
#
# @example
# repos = Github::Repos.new
# repos.branches 'user-name', 'repo-name'
#
# @api public
def branches(*args)
arguments(args, required: [:user, :repo])
response = get_request("/repos/#{arguments.user}/#{arguments.repo}/branches", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias :list_branches :branches
# Get branch
#
# @example
# github = Github.new
# github.repos.branch 'user-name', 'repo-name', 'branch-name'
# github.repos.branch user: 'user-name', repo: 'repo-name', branch: 'branch-name'
# github.repos(user: 'user-name', repo: 'repo-name', branch: 'branch-name').branch
# @api public
def branch(*args)
arguments(args, required: [:user, :repo, :branch])
get_request("/repos/#{arguments.user}/#{arguments.repo}/branches/#{arguments.branch}", arguments.params)
end
# List contributors
#
# @param [Hash] params
# @option params [Boolean] :anon
# Optional flag. Set to 1 or true to include anonymous contributors.
#
# @example
# github = Github.new
# github.repos.contributors 'user-name','repo-name'
# github.repos.contributors 'user-name','repo-name' { |cont| ... }
#
# @api public
def contributors(*args)
arguments(args, required: [:user, :repo]) do
permit ['anon']
end
response = get_request("/repos/#{arguments.user}/#{arguments.repo}/contributors", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias :list_contributors :contributors
alias :contribs :contributors
# List languages
#
# @examples
# github = Github.new
# github.repos.languages 'user-name', 'repo-name'
# github.repos.languages 'user-name', 'repo-name' { |lang| ... }
#
# @api public
def languages(*args)
arguments(args, required: [:user, :repo])
response = get_request("/repos/#{arguments.user}/#{arguments.repo}/languages", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias :list_languages :languages
# List tags
#
# @example
# github = Github.new
# github.repos.tags 'user-name', 'repo-name'
# github.repos.tags 'user-name', 'repo-name' { |tag| ... }
#
# @api public
def tags(*args)
arguments(args, required: [:user, :repo])
response = get_request("/repos/#{arguments.user}/#{arguments.repo}/tags", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias :list_tags :tags
alias :repo_tags :tags
alias :repository_tags :tags
# List teams
#
# @example
# github = Github.new
# github.repos.teams 'user-name', 'repo-name'
# github.repos.teams 'user-name', 'repo-name' { |team| ... }
#
# @example
# github.repos(user: 'user-name, repo: 'repo-name').teams
#
# @api public
def teams(*args)
arguments(args, required: [:user, :repo])
response = get_request("/repos/#{arguments.user}/#{arguments.repo}/teams", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias :list_teams :teams
alias :repo_teams :teams
alias :repository_teams :teams
end # Client::Repos
end # Github
github-api-0.14.2/lib/github_api/client/issues.rb 0000644 0001750 0001750 00000016473 12735456050 020246 0 ustar alee alee # encoding: utf-8
module Github
class Client::Issues < API
require_all 'github_api/client/issues',
'assignees',
'comments',
'events',
'labels',
'milestones'
VALID_ISSUE_PARAM_NAMES = %w[
assignee
body
creator
direction
filter
labels
milestone
mentioned
mime_type
org
resource
since
sort
state
title
].freeze
VALID_ISSUE_PARAM_VALUES = {
'filter' => %w[ assigned created mentioned subscribed all ],
'state' => %w[ open closed all ],
'sort' => %w[ created updated comments ],
'direction' => %w[ desc asc ],
'since' => %r{\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z}
}
# Access to Issues::Assignees API
namespace :assignees
# Access to Issues::Comments API
namespace :comments
# Access to Issues::Events API
namespace :events
# Access to Issues::Comments API
namespace :labels
# Access to Issues::Comments API
namespace :milestones
# List your issues
#
# List all issues across all the authenticated user’s visible repositories
# including owned repositories, member repositories,
# and organization repositories.
#
# @example
# github = Github.new oauth_token: '...'
# github.issues.list
#
# List all issues across owned and member repositories for the
# authenticated user.
#
# @example
# github = Github.new oauth_token: '...'
# github.issues.list :user
#
# List all issues for a given organization for the authenticated user.
#
# @example
# github = Github.new oauth_token: '...'
# github.issues.list org: 'org-name'
#
# List issues for a repository
#
# @example
# github = Github.new
# github.issues.list user: 'user-name', repo: 'repo-name'
#
# @param [Hash] params
# @option params [String] :filter
# * assigned Issues assigned to you (default)
# * created Issues created by you
# * mentioned Issues mentioning you
# * subscribed Issues you've subscribed to updates for
# * all All issues the user can see
# @option params [String] :milestone
# * Integer Milestone number
# * none for Issues with no Milestone.
# * * for Issues with any Milestone
# @option params [String] :state
# open, closed, default: open
# @option params [String] :labels
# String list of comma separated Label names. Example: bug,ui,@high
# @option params [String] :assignee
# * String User login
# * none for Issues with no assigned User.
# * * for Issues with any assigned User.
# @option params [String] :creator
# String User login
# @option params [String] :mentioned
# String User login
# @option params [String] :sort
# created, updated, comments, default: created
# @option params [String] :direction
# asc, desc, default: desc
# @option params [String] :since
# Optional string of a timestamp in ISO 8601 format: YYYY-MM-DDTHH:MM:SSZ
#
# @example
# github = Github.new oauth_token: '...'
# github.issues.list since: '2011-04-12T12:12:12Z',
# filter: 'created',
# state: 'open',
# labels: "bug,ui,bla",
# sort: 'comments',
# direction: 'asc'
#
# @api public
def list(*args)
params = arguments(args) do
assert_values VALID_ISSUE_PARAM_VALUES
end.params
response = if (org = params.delete('org'))
get_request("/orgs/#{org}/issues", params)
elsif (user_name = params.delete('user')) &&
(repo_name = params.delete('repo'))
list_repo user_name, repo_name
elsif args.include? :user
get_request("/user/issues", params)
else
get_request("/issues", params)
end
return response unless block_given?
response.each { |el| yield el }
end
alias :all :list
# List issues for a repository
#
# def list_repo(user_name, repo_name, params)
def list_repo(user, repo)
get_request("/repos/#{user}/#{repo}/issues", arguments.params)
end
private :list_repo
# Get a single issue
#
# @example
# github = Github.new
# github.issues.get 'user-name', 'repo-name', 'number'
#
def get(*args)
arguments(args, required: [:user, :repo, :number])
get_request("/repos/#{arguments.user}/#{arguments.repo}/issues/#{arguments.number}", arguments.params)
end
alias :find :get
# Create an issue
#
# @param [Hash] params
# @option params [String] :title
# Required string
# @option params [String] :body
# Optional string
# @option params [String] :assignee
# Optional string - Login for the user that this issue should be
# assigned to. Only users with push access can set the assignee for
# new issues. The assignee is silently dropped otherwise.
# @option params [Number] :milestone
# Optional number - Milestone to associate this issue with.
# Only users with push access can set the milestone for new issues.
# The milestone is silently dropped otherwise.
# @option params [Array[String]] :labels
# Optional array of strings - Labels to associate with this issue
# Only users with push access can set labels for new issues.
# Labels are silently dropped otherwise.
#
# @example
# github = Github.new user: 'user-name', repo: 'repo-name'
# github.issues.create
# title: "Found a bug",
# body: "I'm having a problem with this.",
# assignee: "octocat",
# milestone: 1,
# labels: [
# "Label1",
# "Label2"
# ]
#
def create(*args)
arguments(args, required: [:user, :repo]) do
permit VALID_ISSUE_PARAM_NAMES
assert_required %w[ title ]
end
post_request("/repos/#{arguments.user}/#{arguments.repo}/issues", arguments.params)
end
# Edit an issue
#
# @param [Hash] params
# @option params [String] :title
# Optional string
# @option params [String] :body
# Optional string
# @option params [String] :assignee
# Optional string - Login for the user that this issue should be assigned to.
# @option params [String] :state
# Optional string - State of the issue: open or closed
# @option params [Number] :milestone
# Optional number - Milestone to associate this issue with
# @option params [Array[String]] :labels
# Optional array of strings - Labels to associate with this issue.
# Pass one or more Labels to replace the set of Labels on this Issue.
# Send an empty array ([]) to clear all Labels from the Issue.
#
# @example
# github = Github.new
# github.issues.edit 'user-name', 'repo-name', 'number'
# title: "Found a bug",
# body: "I'm having a problem with this.",
# assignee: "octocat",
# milestone: 1,
# labels": [
# "Label1",
# "Label2"
# ]
#
# @api public
def edit(*args)
arguments(args, required: [:user, :repo, :number]) do
permit VALID_ISSUE_PARAM_NAMES
end
patch_request("/repos/#{arguments.user}/#{arguments.repo}/issues/#{arguments.number}", arguments.params)
end
end # Issues
end # Github
github-api-0.14.2/lib/github_api/client/gitignore.rb 0000644 0001750 0001750 00000002756 12735456050 020721 0 ustar alee alee # encoding: utf-8
module Github
# When you create a new GitHub repository via the API, you can specify a
# .gitignore template to apply to the repository upon creation.
class Client::Gitignore < API
# List all templates available to pass as an option
# when creating a repository.
#
# @see https://developer.github.com/v3/gitignore/#listing-available-templates
#
# @example
# github = Github.new
# github.gitignore.list
# github.gitignore.list { |template| ... }
#
# @api public
def list(*args)
arguments(args)
response = get_request("/gitignore/templates", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias :all :list
# Get a single template
#
# @see https://developer.github.com/v3/gitignore/#get-a-single-template
#
# @example
# github = Github.new
# github.gitignore.get "template-name"
#
# Use the raw media type to get the raw contents.
#
# @examples
# github = Github.new
# github.gitignore.get "template-name", accept: 'applicatin/vnd.github.raw'
#
# @api public
def get(*args)
arguments(args, required: [:name])
params = arguments.params
if (media = params.delete('accept'))
params['accept'] = media
params['raw'] = true
end
get_request("/gitignore/templates/#{arguments.name}", params)
end
alias :find :get
end # Client::Gitignore
end # Github
github-api-0.14.2/lib/github_api/client/authorizations.rb 0000644 0001750 0001750 00000010771 12735456050 022011 0 ustar alee alee # encoding: utf-8
module Github
# OAuth Authorizations API
class Client::Authorizations < API
require_all 'github_api/client/authorizations', 'app'
# Access to Authorizations::App API
namespace :app
# List authorizations
#
# @see https://developer.github.com/v3/oauth_authorizations/#list-your-authorizations
#
# @example
# github = Github.new basic_auth: 'login:password'
# github.auth.list
# github.auth.list { |auth| ... }
#
# @api public
def list(*args)
raise_authentication_error unless authenticated?
arguments(args)
response = get_request('/authorizations', arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias_method :all, :list
# Get a single authorization
#
# @see https://developer.github.com/v3/oauth_authorizations/#get-a-single-authorization
#
# @example
# github = Github.new basic_auth: 'login:password'
# github.oauth.get 'authorization-id'
#
# @return [ResponseWrapper]
#
# @api public
def get(*args)
raise_authentication_error unless authenticated?
arguments(args, required: [:id])
get_request("/authorizations/#{arguments.id}", arguments.params)
end
alias_method :find, :get
# Create a new authorization
#
# @see https://developer.github.com/v3/oauth_authorizations/#create-a-new-authorization
#
# @param [Hash] params
# @option params [Array[String]] :scopes
# A list of scopes that this authorization is in.
# @option params [String] :note
# Required. A note to remind you what the OAuth token is for.
# @option params [String] :note_url
# A URL to remind you what the OAuth token is for.
# @option params [String] :client_id
# The 20 character OAuth app client key for which to create the token.
# @option params [String] :client_secret
# The 40 character OAuth app client secret for which to create the token.
# @option params [String] :fingerprint
# A unique string to distinguish an authorization from others
# created for the same client ID and user.
#
# @example
# github = Github.new basic_auth: 'login:password'
# github.oauth.create scopes: ["public_repo"], note: 'amdmin script'
#
# @api public
def create(*args)
raise_authentication_error unless authenticated?
arguments(args) do
assert_required :note, :scopes
end
post_request('/authorizations', arguments.params)
end
# Update an existing authorization
#
# @see https://developer.github.com/v3/oauth_authorizations/#update-an-existing-authorization
#
# @param [Hash] inputs
# @option inputs [Array] :scopes
# Optional array - A list of scopes that this authorization is in.
# @option inputs [Array] :add_scopes
# Optional array - A list of scopes to add to this authorization.
# @option inputs [Array] :remove_scopes
# Optional array - A list of scopes to remove from this authorization.
# @option inputs [String] :note
# Optional string - A note to remind you what the OAuth token is for.
# @optoin inputs [String] :note_url
# Optional string - A URL to remind you what the OAuth token is for.
# @option params [String] :fingerprint
# A unique string to distinguish an authorization from others
# created for the same client ID and user.
#
# @example
# github = Github.new basic_auth: 'login:password'
# github.oauth.update "authorization-id", add_scopes: ["repo"]
#
# @api public
def update(*args)
raise_authentication_error unless authenticated?
arguments(args, required: [:id])
patch_request("/authorizations/#{arguments.id}", arguments.params)
end
alias_method :edit, :update
# Delete an authorization
#
# @see https://developer.github.com/v3/oauth_authorizations/#delete-an-authorization
#
# @example
# github = Github.new
# github.oauth.delete 'authorization-id'
#
# @api public
def delete(*args)
raise_authentication_error unless authenticated?
arguments(args, required: [:id])
delete_request("/authorizations/#{arguments.id}", arguments.params)
end
alias_method :remove, :delete
protected
def raise_authentication_error
raise ArgumentError, 'You can only access your own tokens' \
' via Basic Authentication'
end
end # Client::Authorizations
end # Github
github-api-0.14.2/lib/github_api/client/search.rb 0000644 0001750 0001750 00000007440 12735456050 020172 0 ustar alee alee # encoding: utf-8
module Github
# The Search API is optimized to help you find the specific item
# you're looking for (e.g., a specific user, a specific file
# in a repository, etc.).
class Client::Search < API
include Github::Utils::Url
require_all 'github_api/client/search', 'legacy'
# Access to Search::Legacy API
namespace :legacy
# Search issues
#
# Find issues by state and keyword.
# (This method returns up to 100 results per page.)
#
# @param [Hash] params
# @option params [String] :q
# The search terms. This can be any combination of the supported
# issue search parameters.
# @option params [String] :sort
# Optional sort field. One of comments, created, or updated.
# If not provided, results are sorted by best match.
# @option params [String] :order
# The sort order if sort parameter is provided.
# One of asc or desc. Default: desc
#
# @example
# github = Github.new
# github.search.issues 'query'
#
# @example
# github.search.issues q: 'query'
#
# @api public
def issues(*args)
params = arguments(args, required: [:q]).params
params['q'] ||= arguments.q
get_request('/search/issues' , params)
end
# Search repositories
#
# Find repositories via various criteria.
# (This method returns up to 100 results per page.)
#
# @param [Hash] params
# @option params [String] :q
# The search keywords, as well as any qualifiers.
# @option params [String] :sort
# The sort field. One of stars, forks, or updated.
# Default: results are sorted by best match.
# @option params [String] :order
# The sort order if sort parameter is provided.
# One of asc or desc. Default: desc
#
# @example
# github = Github.new
# github.search.repos 'query'
#
# @example
# github.search.repos q: 'query'
#
# @api public
def repos(*args)
params = arguments(args, required: [:q]).params
params['q'] ||= arguments.q
get_request('/search/repositories', arguments.params)
end
alias :repositories :repos
# Search users
#
# Find users by keyword.
#
# @param [Hash] params
# @option params [String] :q
# The search terms. This can be any combination of the supported
# issue search parameters.
# @option params [String] :sort
# Optional sort field. One of comments, created, or updated.
# If not provided, results are sorted by best match.
# @option params [String] :order
# The sort order if sort parameter is provided.
# One of asc or desc. Default: desc
#
# @example
# github = Github.new
# github.search.users q: 'wycats'
#
# @api public
def users(*args)
params = arguments(args, required: [:q]).params
params['q'] ||= arguments.q
get_request('/search/users', arguments.params)
end
# Find file contents via various criteria.
# (This method returns up to 100 results per page.)
#
# @param [Hash] params
# @option params [String] :q
# The search terms. This can be any combination of the supported
# issue search parameters.
# @option params [String] :sort
# Optional sort field. One of comments, created, or updated.
# If not provided, results are sorted by best match.
# @option params [String] :order
# The sort order if sort parameter is provided.
# One of asc or desc. Default: desc
#
# @example
# github = Github.new
# github.search.code q: 'wycats'
#
# @api public
def code(*args)
params = arguments(args, required: [:q]).params
params['q'] ||= arguments.q
get_request('/search/code', params)
end
end # Search
end # Github
github-api-0.14.2/lib/github_api/client/activity/ 0000755 0001750 0001750 00000000000 12735456050 020227 5 ustar alee alee github-api-0.14.2/lib/github_api/client/activity/starring.rb 0000644 0001750 0001750 00000007577 12735456050 022425 0 ustar alee alee # encoding: utf-8
module Github
# Repository Starring is a feature that lets users bookmark repositories.
# Stars are shown next to repositories to show an approximate level of interest.
# Stars have no effect on notifications or the activity feed.
class Client::Activity::Starring < API
# List stargazers
#
# @see https://developer.github.com/v3/activity/starring/#list-stargazers
#
# @example
# github = Github.new
# github.activity.starring.list user: 'user-name', repo: 'repo-name'
# github.activity.starring.list user: 'user-name', repo: 'repo-name' { |star| ... }
#
# @api public
def list(*args)
arguments(args, required: [:user, :repo])
response = get_request("/repos/#{arguments.user}/#{arguments.repo}/stargazers", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias_method :all, :list
# List repos being starred by a user
#
# @see https://developer.github.com/v3/activity/starring/#list-repositories-being-starred
#
# @param [Hash] params
# @option params [String] :sort
# One of created (when the repository was starred) or
# updated (when it was last pushed to).
# Default: created
# @option params [String] :direction
# One of asc (ascending) or desc (descending).
# Default: desc
#
# @example
# github = Github.new
# github.activity.starring.starred user: 'user-name'
#
# List repos being starred by the authenticated user
#
# @example
# github = Github.new oauth_token: '...'
# github.activity.starring.starred
#
# @api public
def starred(*args)
arguments(args)
params = arguments.params
response = if (user_name = params.delete('user'))
get_request("/users/#{user_name}/starred", params)
else
get_request('/user/starred', params)
end
return response unless block_given?
response.each { |el| yield el }
end
# Check if you are starring a repository
#
# @see https://developer.github.com/v3/activity/starring/#check-if-you-are-starring-a-repository
#
# @example
# github = Github.new
# github.activity.starring.starring? 'user-name', 'repo-name'
#
# @example
# github.activity.starring.starring? user: 'user-name', repo: 'repo-name'
#
# @return [Boolean]
# Returns true if this repo is starred by you, false otherwise.
#
# @api public
def starring?(*args)
arguments(args, required: [:user, :repo])
get_request("/user/starred/#{arguments.user}/#{arguments.repo}", arguments.params)
true
rescue Github::Error::NotFound
false
end
# Star a repository
#
# You need to be authenticated to star a repository
#
# @see https://developer.github.com/v3/activity/starring/#star-a-repository
#
# @example
# github = Github.new
# github.activity.starring.star 'user-name', 'repo-name'
#
# @example
# github.activity.starring.star user: 'user-name', repo: 'repo-name'
#
# @api public
def star(*args)
arguments(args, required: [:user, :repo])
put_request("/user/starred/#{arguments.user}/#{arguments.repo}", arguments.params)
end
# Unstar a repository
#
# You need to be authenticated to unstar a repository.
#
# @see https://developer.github.com/v3/activity/starring/#unstar-a-repository
#
# @example
# github = Github.new
# github.activity.starring.unstar 'user-name', 'repo-name'
#
# @example
# github.activit.starring.unstar user: 'user-name', repo: 'repo-name'
#
# @api public
def unstar(*args)
arguments(args, required: [:user, :repo])
delete_request("/user/starred/#{arguments.user}/#{arguments.repo}", arguments.params)
end
end # Client::Activity::Starring
end # Github
github-api-0.14.2/lib/github_api/client/activity/feeds.rb 0000644 0001750 0001750 00000002234 12735456050 021643 0 ustar alee alee # encoding: utf-8
module Github
class Client::Activity::Feeds < API
# List all the feeds available to the authenticated user.
#
# @see https://developer.github.com/v3/activity/feeds/#list-feeds
#
# @example
# github = Github.new
# github.activity.feeds.list
#
# @api public
def list(*args)
arguments(args)
response = get_request("/feeds", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias_method :all, :list
# Get all the items for a named timeline
#
# @see https://developer.github.com/v3/activity/feeds/#list-feeds
#
# @example
# github = Github.new
# github.activity.feeds.get "timeline"
#
# @param [String] name
# the name of the timeline resource
#
# @api public
def get(*args)
arguments(args, required: [:name])
name = arguments.name
response = list.body._links[name]
if response
params = arguments.params
params['accept'] = response.type
get_request(response.href, params)
end
end
alias_method :find, :get
end
end # Github
github-api-0.14.2/lib/github_api/client/activity/events.rb 0000644 0001750 0001750 00000020302 12735456050 022055 0 ustar alee alee # encoding: utf-8
module Github
class Client::Activity::Events < API
# List all public events
#
# @see https://developer.github.com/v3/activity/events/#list-public-events
#
# @example
# github = Github.new
# github.activity.events.public
# github.activity.events.public { |event| ... }
#
# @api public
def public(*args)
arguments(args)
response = get_request("/events", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias_method :public_events, :public
alias_method :list_public, :public
alias_method :list_public_events, :public
# List all repository events for a given user
#
# @example
# github = Github.new
# github.activity.events.repository 'user-name', 'repo-name'
# github.activity.events.repository 'user-name', 'repo-name' { |event| ... }
#
# @example
# github.activity.events.repository user: 'user-name', repo: 'repo-name'
# github.activity.events.repository user: 'user-name', repo: 'repo-name' {|event| ... }
#
# @api public
def repository(*args)
arguments(args, required: [:user, :repo])
response = get_request("/repos/#{arguments.user}/#{arguments.repo}/events", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias_method :repos, :repository
alias_method :repo_events, :repository
alias_method :repository_events, :repository
alias_method :list_repository_events, :repository
# List all issue events for a given repository
#
# @example
# github = Github.new
# github.activity.events.issue 'user-name', 'repo-name'
# github.activity.events.issue 'user-name', 'repo-name' { |event| ... }
#
# @example
# github.activity.events.issue user: 'user-name', repo: 'repo-name'
# github.activity.events.issue user: 'user-name', repo: 'repo-name' { |event| ... }
#
# @api public
def issue(*args)
arguments(args, required: [:user, :repo])
response = get_request("/repos/#{arguments.user}/#{arguments.repo}/issues/events", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias_method :issues, :issue
alias_method :issue_events, :issue
alias_method :list_issue_events, :issue
# List all public events for a network of repositories
#
# @see https://developer.github.com/v3/activity/events/#list-public-events-for-a-network-of-repositories
#
# @example
# github = Github.new
# github.activity.events.network 'user-name', 'repo-name'
# github.activity.events.network 'user-name', 'repo-name' { |event| ... }
#
# @example
# github.activity.events.network user: 'user-name', repo: 'repo-name'
# github.activity.events.network user: 'user-name', repo: 'repo-name' { |event| ... }
#
# @api public
def network(*args)
arguments(args, required: [:user, :repo])
response = get_request("/networks/#{arguments.user}/#{arguments.repo}/events", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias_method :repo_network, :network
alias_method :repository_network, :network
alias_method :list_repo_network_events, :network
alias_method :list_repository_network_events, :network
# List all public events for an organization
#
# @see https://developer.github.com/v3/activity/events/#list-public-events-for-an-organization
#
# @example
# github = Github.new
# github.activity.events.org 'org-name'
# github.activity.events.org 'org-name' { |event| ... }
#
# @example
# github.activity.events.org name: 'org-name'
# github.activity.events.org name: 'org-name' { |event| ... }
#
# @api public
def org(*args)
arguments(args, required: [:name])
response = get_request("/orgs/#{arguments.name}/events", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias_method :organization, :org
alias_method :list_orgs, :org
alias_method :list_org_events, :org
alias_method :list_organization_events, :org
# List all events that a user has received
#
# @see https://developer.github.com/v3/activity/events/#list-events-that-a-user-has-received
#
# These are events that you’ve received by watching repos
# and following users. If you are authenticated as the given user,
# you will see private events. Otherwise, you’ll only see public events.
#
# @example
# github = Github.new
# github.activity.events.received 'user-name'
# github.activity.events.received 'user-name' { |event| ... }
#
# List all public events that a user has received
#
# @see https://developer.github.com/v3/activity/events/#list-public-events-that-a-user-has-received
#
# @example
# github = Github.new
# github.activity.events.received 'user-name', public: true
# github.activity.events.received 'user-name', public: true { |event| ... }
#
# @api public
def received(*args)
arguments(args, required: [:user])
params = arguments.params
public_events = if params['public']
params.delete('public')
'/public'
end
response = get_request("/users/#{arguments.user}/received_events#{public_events}", params)
return response unless block_given?
response.each { |el| yield el }
end
alias_method :user_received, :received
alias_method :list_user_received, :received
# List all events that a user has performed
#
# @see https://developer.github.com/v3/activity/events/#list-events-performed-by-a-user
#
# If you are authenticated as the given user, you will see your private
# events. Otherwise, you’ll only see public events.
#
# @example
# github = Github.new
# github.activity.events.performed 'user-name'
# github.activity.events.performed 'user-name' { |event| ... }
#
# List all public events that a user has performed
#
# @see https://developer.github.com/v3/activity/events/#list-public-events-performed-by-a-user
#
# @example
# github = Github.new
# github.activity.events.performed 'user-name', public: true
# github.activity.events.performed 'user-name', public: true { |event| ... }
#
# @api public
def performed(*args)
arguments(args, required: [:user])
params = arguments.params
public_events = if params['public']
params.delete('public')
'/public'
end
response = get_request("/users/#{arguments.user}/events#{public_events}", params)
return response unless block_given?
response.each { |el| yield el }
end
alias_method :user_performed, :performed
alias_method :list_user_performed, :performed
# List all events for an organization
#
# @see https://developer.github.com/v3/activity/events/#list-events-for-an-organization
#
# This is the user's organization dashboard. You must be authenticated
# as the user to view this.
#
# @example
# github = Github.new
# github.activity.events.user_org 'user-name', 'org-name'
# github.activity.events.user_org 'user-name', 'org-name' { |event| ... }
#
# @example
# github.activity.events.user_org user: 'user-name', name: 'org-name'
# github.activity.events.user_org user: 'user-name', name: 'org-name' {|event| ...}
#
# @api public
def user_org(*args)
arguments(args, required: [:user, :name])
response = get_request("/users/#{arguments.user}/events/orgs/#{arguments.name}", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias_method :user_organization, :user_org
alias_method :list_user_org, :user_org
alias_method :list_user_org_events, :user_org
alias_method :list_user_organization_events, :user_org
end # Client::Activity::Events
end # Github
github-api-0.14.2/lib/github_api/client/activity/watching.rb 0000644 0001750 0001750 00000012531 12735456050 022362 0 ustar alee alee # encoding: utf-8
module Github
# Watching a Repository registers the user to receive notificactions on new
# discussions, as well as events in the user's activity feed.
class Client::Activity::Watching < API
# List repository watchers
#
# @see https://developer.github.com/v3/activity/watching/#list-watchers
#
# @example
# github = Github.new
# github.activity.watching.list user: 'user-name', repo: 'repo-name'
# github.activity.watching.list user: 'user-naem', repo: 'repo-name' { |watcher| ... }
#
# @api public
def list(*args)
arguments(args, required: [:user, :repo])
response = get_request("/repos/#{arguments.user}/#{arguments.repo}/subscribers", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias_method :all, :list
# List repos being watched by a user
#
# @see https://developer.github.com/v3/activity/watching/#list-repositories-being-watched
#
# @example
# github = Github.new
# github.activity.watching.watched user: 'user-name'
#
# List repos being watched by the authenticated user
#
# @example
# github = Github.new oauth_token: '...'
# github.activity.watching.watched
#
# @api public
def watched(*args)
arguments(args)
params = arguments.params
response = if (user_name = params.delete('user'))
get_request("/users/#{user_name}/subscriptions", params)
else
get_request('/user/subscriptions', params)
end
return response unless block_given?
response.each { |el| yield el }
end
# Check if you are subscribed to a repository
#
# @see https://developer.github.com/v3/activity/watching/#get-a-repository-subscription
#
# @example
# github = Github.new
# github.activity.watching.subscribed? 'user-name', 'repo-name'
#
# @example
# github.activity.watching.subscribed? user: 'user-name', repo: 'repo-name'
#
# @api public
def subscribed?(*args)
arguments(args, required: [:user, :repo])
get_request("/repos/#{arguments.user}/#{arguments.repo}/subscription", arguments.params)
true
rescue Github::Error::NotFound
false
end
# Create subscription to a repository
#
# @see https://developer.github.com/v3/activity/watching/#set-a-repository-subscription
#
# @param [Hash] params
# @option params [Boolean] :subscribed
# Determines if notifications should be received from this repository.
# @option params [Boolean] :ignored
# Determines if all notifications should be blocked from this repository.
#
# @example
# github = Github.new
# github.activity.watching.create 'user-name', 'repo-name'
#
# @example
# github.activity.watching.create user: 'user-name', repo: 'repo-name'
#
# @api public
def create(*args)
arguments(args, required: [:user, :repo])
put_request("/repos/#{arguments.user}/#{arguments.repo}/subscription", arguments.params)
end
alias_method :subscribe, :create
# Delete a repository subscription
#
# @see https://developer.github.com/v3/activity/watching/#delete-a-repository-subscription
#
# @example
# github = Github.new oauth_token: '...'
# github.activity.watching.delete 'user-name', 'repo-name'
#
# @example
# github.activity.watching.delete user: 'user-name', repo: 'repo-name'
#
# @api public
def delete(*args)
arguments(args, required: [:user, :repo])
delete_request("/repos/#{arguments.user}/#{arguments.repo}/subscription", arguments.params)
end
alias_method :unsubscribe, :delete
# Check if you are watching a repository
#
# @see https://developer.github.com/v3/activity/watching/#check-if-you-are-watching-a-repository-legacy
#
# @example
# github = Github.new
# github.activity.watching.watching? 'user-name', 'repo-name'
#
# @return [Boolean]
# Returns true if this repo is watched by you, false otherwise.
#
# @api public
def watching?(*args)
arguments(args, required: [:user, :repo])
get_request("/user/subscriptions/#{arguments.user}/#{arguments.repo}", arguments.params)
true
rescue Github::Error::NotFound
false
end
# Watch a repository
#
# You need to be authenticated to watch a repository
#
# @see https://developer.github.com/v3/activity/watching/#watch-a-repository-legacy
#
# @example
# github = Github.new
# github.activity.watching.watch 'user-name', 'repo-name'
#
# @api public
def watch(*args)
arguments(args, required: [:user, :repo])
put_request("/user/subscriptions/#{arguments.user}/#{arguments.repo}", arguments.params)
end
# Stop watching a repository
#
# You need to be authenticated to stop watching a repository.
#
# @see https://developer.github.com/v3/activity/watching/#stop-watching-a-repository-legacy
#
# @example
# github = Github.new
# github.activity.watching.unwatch 'user-name', 'repo-name'
#
# @api public
def unwatch(*args)
arguments(args, required: [:user, :repo])
delete_request("/user/subscriptions/#{arguments.user}/#{arguments.repo}", arguments.params)
end
end # Activity::Watching
end # Github
github-api-0.14.2/lib/github_api/client/activity/notifications.rb 0000644 0001750 0001750 00000013641 12735456050 023432 0 ustar alee alee # encoding: utf-8
module Github
class Client::Activity::Notifications < API
# List your notifications
#
# List all notifications for the current user, grouped by repository.
#
# @see https://developer.github.com/v3/activity/notifications/#list-your-notifications
#
# @param [Hash] params
# @option params [Boolean] :all
# If true, show notifications marked as read.
# Default: false
# @option params [Boolean] :participating
# If true, only shows notifications in which the user
# is directly participating or mentioned. Default: false
# @option params [String] :since
# Filters out any notifications updated before the given time.
# This is a timestamp in ISO 8601 format: YYYY-MM-DDTHH:MM:SSZ.
# Default: Time.now
#
# @example
# github = Github.new oauth_token: 'token'
# github.activity.notifications.list
#
# List your notifications in a repository
#
# @see https://developer.github.com/v3/activity/notifications/#list-your-notifications-in-a-repository
#
# @example
# github = Github.new
# github.activity.notifications.list user: 'user-name', repo: 'repo-name'
#
# @api public
def list(*args)
arguments(args)
params = arguments.params
response = if ( (user_name = params.delete('user')) &&
(repo_name = params.delete('repo')) )
get_request("/repos/#{user_name}/#{repo_name}/notifications", params)
else
get_request('/notifications', params)
end
return response unless block_given?
response.each { |el| yield el }
end
alias_method :all, :list
# View a single thread
#
# @see https://developer.github.com/v3/activity/notifications/#view-a-single-thread
#
# @example
# github = Github.new oauth_token: 'token'
# github.activity.notifications.get 'thread_id'
# github.activity.notifications.get 'thread_id' { |thread| ... }
#
# @api public
def get(*args)
arguments(args, required: [:thread_id])
response = get_request("/notifications/threads/#{arguments.thread_id}", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias_method :find, :get
# Mark as read
#
# Marking a notification as “read” removes it from the default view on GitHub.com.
#
# @see https://developer.github.com/v3/activity/notifications/#mark-as-read
#
# @param [Hash] params
# @option params [String] :last_read_at
# Describes the last point that notifications were checked.
# Anything updated since this time will not be updated.
# This is a timestamp in ISO 8601 format: YYYY-MM-DDTHH:MM:SSZ.
# Default: Time.now
#
# @example
# github = Github.new oauth_token: 'token'
# github.activity.notifications.mark
#
# Mark notifications as read in a repository
#
# @see https://developer.github.com/v3/activity/notifications/#mark-notifications-as-read-in-a-repository
#
# @example
# github.activity.notifications.mark user: 'user-name', repo: 'repo-name'
#
# Mark a thread as read
#
# @see https://developer.github.com/v3/activity/notifications/#mark-a-thread-as-read
#
# @example
# github.activity.notifications.mark id: 'thread-id'
#
# @api public
def mark(*args)
arguments(args)
params = arguments.params
if ( (user_name = params.delete('user')) &&
(repo_name = params.delete('repo')) )
put_request("/repos/#{user_name}/#{repo_name}/notifications", params)
elsif (thread_id = params.delete("id"))
patch_request("/notifications/threads/#{thread_id}", params)
else
put_request('/notifications', params)
end
end
# Check to see if the current user is subscribed to a thread.
#
# @see https://developer.github.com/v3/activity/notifications/#get-a-thread-subscription
#
# @example
# github = Github.new oauth_token: 'token'
# github.activity.notifications.subscribed? 'thread-id'
#
# @example
# github.activity.notifications.subscribed? id: 'thread-id'
#
# @api public
def subscribed?(*args)
arguments(args, required: [:thread_id])
get_request("/notifications/threads/#{arguments.thread_id}/subscription", arguments.params)
end
# Create a thread subscription
#
# This lets you subscribe to a thread, or ignore it. Subscribing to a thread
# is unnecessary if the user is already subscribed to the repository. Ignoring
# a thread will mute all future notifications (until you comment or get
# @mentioned).
#
# @see https://developer.github.com/v3/activity/notifications/#set-a-thread-subscription
#
# @param [Hash] params
# @option params [Boolean] :subscribed
# Determines if notifications should be received from this thread
# @option params [Boolean] :ignored
# Determines if all notifications should be blocked from this thread
#
# @example
# github = Github.new oauth_token: 'token'
# github.activity.notifications.create 'thread-id',
# subscribed: true
# ignored: false
#
# @api public
def create(*args)
arguments(args, required: [:thread_id])
put_request("/notifications/threads/#{arguments.thread_id}/subscription", arguments.params)
end
# Delete a thread subscription
#
# @see https://developer.github.com/v3/activity/notifications/#delete-a-thread-subscription
#
# @example
# github = Github.new oauth_token: 'token'
# github.activity.notifications.delete 'thread_id'
#
# @api public
def delete(*args)
arguments(args, required: [:thread_id])
delete_request("/notifications/threads/#{arguments.thread_id}/subscription", arguments.params)
end
alias_method :remove, :delete
end # Client::Activity::Notifications
end # Github
github-api-0.14.2/lib/github_api/client/pull_requests/ 0000755 0001750 0001750 00000000000 12735456050 021302 5 ustar alee alee github-api-0.14.2/lib/github_api/client/pull_requests/comments.rb 0000644 0001750 0001750 00000010707 12735456050 023461 0 ustar alee alee # encoding: utf-8
module Github
class Client::PullRequests::Comments < API
# List comments on a pull request
#
# @example
# github = Github.new
# github.pull_requests.comments.list 'user-name', 'repo-name', number: 'id'
#
# List comments in a repository
#
# By default, Review Comments are ordered by ascending ID.
#
# @param [Hash] params
# @input params [String] :sort
# Optional string. Can be either created or updated. Default: created
# @input params [String] :direction
# Optional string. Can be either asc or desc. Ignored without sort parameter
# @input params [String] :since
# Optional string of a timestamp in ISO 8601
# format: YYYY-MM-DDTHH:MM:SSZ
# @example
# github = Github.new
# github.pull_requests.comments.list 'user-name', 'repo-name'
# github.pull_requests.comments.list 'user-name', 'repo-name' { |comm| ... }
#
# @api public
def list(*args)
arguments(args, required: [:user, :repo])
params = arguments.params
user = arguments.user
repo = arguments.repo
response = if (number = params.delete('number'))
get_request("/repos/#{user}/#{repo}/pulls/#{number}/comments", params)
else
get_request("/repos/#{user}/#{repo}/pulls/comments", params)
end
return response unless block_given?
response.each { |el| yield el }
end
alias_method :all, :list
# Get a single comment for pull requests
#
# @example
# github = Github.new
# github.pull_requests.comments.get 'user-name', 'repo-name', 'number'
#
# @example
# github.pull_requests.comments.get
# user: 'user-name',
# repo: 'repo-name',
# number: 'comment-number
#
# @api public
def get(*args)
arguments(args, required: [:user, :repo, :number])
get_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/comments/#{arguments.number}", arguments.params)
end
alias_method :find, :get
# Create a pull request comment
#
# @param [Hash] params
# @option params [String] :body
# Required string. The text of the comment.
# @option params [String] :commit_id
# Required string - The SHA of the commit to comment on.
# @option params [String] :path
# Required string. The relative path of the file to comment on.
# @option params [Number] :position
# Required number. The line index in the diff to comment on.
#
# @example
# github = Github.new
# github.pull_requests.comments.create 'user-name', 'repo-name', 'number',
# body: "Nice change",
# commit_id: "6dcb09b5b57875f334f61aebed695e2e4193db5e",
# path: "file1.txt",
# position: 4
#
# Alternative Inputs
#
# Instead of passing commit_id, path, and position you can reply to
# an existing Pull Request Comment like this
# @option params [String] :body
# Required string. The text of the comment.
# @option params [Number] :in_reply_to
# Required number. The comment id to reply to.
#
# @example
# github = Github.new
# github.pull_requests.comments.create 'user-name','repo-name', 'number',
# body: "Nice change",
# in_reply_to: 4
#
# @api public
def create(*args)
arguments(args, required: [:user, :repo, :number])
post_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/#{arguments.number}/comments", arguments.params)
end
# Edit a pull request comment
#
# @param [Hash] params
# @option params [String] :body
# Required string. The text of the comment.
#
# @example
# github = Github.new
# github.pull_requests.comments.edit 'user-name', 'repo-name', 'number',
# body: "Nice change"
#
# @api public
def edit(*args)
arguments(args, required: [:user, :repo, :number])
patch_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/comments/#{arguments.number}", arguments.params)
end
# Delete a pull request comment
#
# @example
# github = Github.new
# github.pull_requests.comments.delete 'user-name', 'repo-name', 'number'
#
# @api public
def delete(*args)
arguments(args, required: [:user, :repo, :number])
delete_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/comments/#{arguments.number}", arguments.params)
end
end # PullRequests::Comments
end # Github
github-api-0.14.2/lib/github_api/client/say.rb 0000644 0001750 0001750 00000000757 12735456050 017525 0 ustar alee alee # encoding: utf-8
module Github
class Client::Say < API
# Generate ASCII octocat with speech bubble.
#
# @example
# Github::Client::Say.new.say "My custom string..."
#
# @example
# github = Github.new
# github.octocat.say "My custom string..."
#
def say(*args)
params = arguments(*args).params
params[:s] = args.shift unless args.empty?
params['raw'] = true
get_request('/octocat', params)
end
end # Say
end # Github
github-api-0.14.2/lib/github_api/client/repos/ 0000755 0001750 0001750 00000000000 12735456050 017523 5 ustar alee alee github-api-0.14.2/lib/github_api/client/repos/commits.rb 0000644 0001750 0001750 00000004653 12735456050 021533 0 ustar alee alee # encoding: utf-8
module Github
class Client::Repos::Commits < API
VALID_COMMITS_OPTIONS = %w[
sha
path
author
since
until
].freeze
# List commits on a repository
#
# @param [Hash] params
# @option params [String] :sha
# Sha or branch to start listing commits from.
# @option params [String] :path
# Only commits containing this file path will be returned.
# @option params [String] :author
# GitHub login, name or email by which to filter by commit author.
# @option params [String] :since
# Only commits after this date will be returned. This is a timestamp
# in ISO 8601 format: YYYY-MM-DDTHH:MM:SSZ.
# @option params [String] :until
# Only commits before this date will be returned. This is a timestamp
# in ISO 8601 format: YYYY-MM-DDTHH:MM:SSZ.
#
# @example
# github = Github.new
# github.repos.commits.list 'user-name', 'repo-name', sha: '...'
# github.repos.commits.list 'user-name', 'repo-name', sha: '...' { |commit| ... }
#
# @api public
def list(*args)
arguments(args, required: [:user, :repo]) do
permit VALID_COMMITS_OPTIONS
end
response = get_request("/repos/#{arguments.user}/#{arguments.repo}/commits", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias :all :list
# Gets a single commit
#
# @example
# github = Github.new
# github.repos.commits.get 'user-name', 'repo-name', '6dcb09b5b57875f334f61aebed6'
#
# @api public
def get(*args)
arguments(args, required: [:user, :repo, :sha])
get_request("/repos/#{arguments.user}/#{arguments.repo}/commits/#{arguments.sha}", arguments.params)
end
alias :find :get
# Compares two commits
#
# @note Both :base and :head can be either branch names in :repo or
# branch names in other repositories in the same network as :repo.
# For the latter case, use the format user:branch:
#
# @example
# github = Github.new
# github.repos.commits.compare 'user-name', 'repo-name', 'v0.4.8', 'master'
#
# @api public
def compare(*args)
arguments(args, required: [:user, :repo, :base, :head])
get_request("/repos/#{arguments.user}/#{arguments.repo}/compare/#{arguments.base}...#{arguments.head}", arguments.params)
end
end # Client::Repos::Commits
end # Github
github-api-0.14.2/lib/github_api/client/repos/merging.rb 0000644 0001750 0001750 00000002612 12735456050 021501 0 ustar alee alee # encoding: utf-8
module Github
# The Repo Merging API supports merging branches in a repository. This
# accomplishes essentially the same thing as merging one branch into another
# in a local repository and then pushing to GitHub.
class Client::Repos::Merging < API
VALID_MERGE_PARAM_NAMES = %w[
base
head
commit_message
].freeze # :nodoc:
REQUIRED_MERGE_PARAMS = %w[ base head ].freeze # :nodoc:
# Perform a merge
#
# @param [Hash] params
# @input params [String] :base
# Required. The name of the base branch that the head will be merged into.
# @input params [String] :head
# Required. The head to merge. This can be a branch name or a commit SHA1.
# @input params [String] :commit_message
# Commit message to use for the merge commit.
# If omitted, a default message will be used.
#
# @example
# github = Github.new
# github.repos.merging.merge 'user', 'repo',
# base: "master",
# head: "cool_feature",
# commit_message: "Shipped cool_feature!"
#
# @api public
def merge(*args)
arguments(args, required: [:user, :repo]) do
permit VALID_MERGE_PARAM_NAMES
assert_required REQUIRED_MERGE_PARAMS
end
post_request("/repos/#{arguments.user}/#{arguments.repo}/merges", arguments.params)
end
end # Client::Repos::Merging
end # Github
github-api-0.14.2/lib/github_api/client/repos/contents.rb 0000644 0001750 0001750 00000020176 12735456050 021713 0 ustar alee alee # encoding: utf-8
module Github
# These API methods let you retrieve the contents of files within a repository
# as Base64 encoded content.
class Client::Repos::Contents < API
REQUIRED_CONTENT_OPTIONS = %w[ path message content ]
# Get the README
#
# This method returns the preferred README for a repository.
#
# @param [Hash] params
# @option params [String] :ref
# The name of the commit/branch/tag.
# Default: the repository’s default branch (usually master)
#
# @example
# github = Github.new
# github.repos.contents.readme 'user-name', 'repo-name'
#
# @example
# content = Github::Client::Repos::Contents.new user: 'user-name', repo: 'repo-name'
# content.readme
#
# @api public
def readme(*args)
arguments(args, required: [:user, :repo])
get_request("/repos/#{arguments.user}/#{arguments.repo}/readme", arguments.params)
end
# Get contents
#
# This method returns the contents of any file or directory in a repository.
#
# @param [Hash] params
# @option params [String] :path
# The content path.
# @option params [String] :ref
# The name of the commit/branch/tag.
# Default: the repository’s default branch (usually master)
#
# @example
# github = Github.new
# github.repos.contents.get 'user-name', 'repo-name', 'path'
#
# @example
# github = Github.new user: 'user-name', repo: 'repo-name'
# github.repos.contents.get path: 'README.md'
#
# @api public
def get(*args)
arguments(args, required: [:user, :repo, :path])
get_request("/repos/#{arguments.user}/#{arguments.repo}/contents/#{arguments.path}", arguments.params)
end
alias :find :get
# Create a file
#
# This method creates a new file in a repository
#
# @param [Hash] params
# @option params [String] :path
# Requried string. The content path
# @option params [String]
# @option params [String] :message
# Requried string. The commit message.
# @option params [String] :content
# Requried string. The new file content, which will be Base64 encoded
# @option params [String] :branch
# The branch name. If not provided, uses the repository’s
# default branch (usually master)
#
# Optional Parameters
#
# The :author section is optional and is filled in with the
# :committer information if omitted. If the :committer
# information is omitted, the authenticated user’s information is used.
#
# You must provide values for both :name and :email, whether
# you choose to use :author or :committer. Otherwise, you’ll
# receive a 500 status code.
#
# Both the author and commiter parameters have the same keys:
#
# @option params [String] :name
# The name of the author (or commiter) of the commit
# @option params [String] :email
# The email of the author (or commiter) of the commit
#
# @example
# github = Github.new
# github.repos.contents.create 'user-name', 'repo-name', 'path',
# path: 'hello.rb',
# content: "puts 'hello ruby'",
# message: "my commit message"
#
# @api public
def create(*args)
arguments(args, required: [:user, :repo, :path]) do
assert_required REQUIRED_CONTENT_OPTIONS
end
params = arguments.params
params.strict_encode64('content')
put_request("/repos/#{arguments.user}/#{arguments.repo}/contents/#{arguments.path}", params)
end
# Update a file
#
# This method updates a file in a repository
#
# @param [Hash] params
# @option params [String] :path
# Requried string. The content path
# @option params [String]
# @option params [String] :message
# Requried string. The commit message.
# @option params [String] :content
# Requried string. The new file content, which will be Base64 encoded
# @option params [String] :sha
# Required string. The blob SHA of the file being replaced.
# @option params [String] :branch
# The branch name. If not provided, uses the repository’s
# default branch (usually master)
#
# Optional Parameters
#
# The :author section is optional and is filled in with the
# :committer information if omitted. If the :committer
# information is omitted, the authenticated user’s information is used.
#
# You must provide values for both :name and :email, whether
# you choose to use :author or :committer. Otherwise, you’ll
# receive a 500 status code.
#
# Both the author and commiter parameters have the same keys:
#
# @option params [String] :name
# The name of the author (or commiter) of the commit
# @option params [String] :email
# The email of the author (or commiter) of the commit
#
# @example
# github = Github.new
# github.repos.contents.update 'user-name', 'repo-name', 'path',
# path: 'hello.rb',
# content: "puts 'hello ruby again'",
# message: "my commit message",
# sha: "25b0bef9e404bd2e3233de26b7ef8cbd86d0e913"
#
# @api public
def update(*args)
create(*args)
end
# Delete a file
#
# This method deletes a file in a repository
#
# @param [Hash] params
# @option params [String] :path
# Requried string. The content path
# @option params [String]
# @option params [String] :message
# Requried string. The commit message.
# @option params [String] :sha
# Required string. The blob SHA of the file being replaced.
# @option params [String] :branch
# The branch name. If not provided, uses the repository’s
# default branch (usually master)
#
# Optional Parameters
#
# The :author section is optional and is filled in with the
# :committer information if omitted. If the :committer
# information is omitted, the authenticated user’s information is used.
#
# You must provide values for both :name and :email, whether
# you choose to use :author or :committer. Otherwise, you’ll
# receive a 500 status code.
#
# Both the author and commiter parameters have the same keys:
#
# @option params [String] :name
# The name of the author (or commiter) of the commit
# @option params [String] :email
# The email of the author (or commiter) of the commit
#
# @example
# github = Github.new
# github.repos.contents.delete 'user-name', 'repo-name', 'path',
# path: 'hello.rb',
# message: "delete hello.rb file",
# sha: "329688480d39049927147c162b9d2deaf885005f"
#
def delete(*args)
arguments(args, required: [:user, :repo, :path]) do
assert_required %w[ path message sha ]
end
delete_request("/repos/#{arguments.user}/#{arguments.repo}/contents/#{arguments.path}", arguments.params)
end
# Get archive link
#
# This method will return a 302 to a URL to download a tarball or zipball
# archive for a repository. Please make sure your HTTP framework is configured
# to follow redirects or you will need to use the Location header to make
# a second GET request.
#
# @note
# For private repositories, these links are temporary and expire quickly.
#
# @param [Hash] params
# @input params [String] :archive_format
# Required string. Either tarball or zipball. Default: tarball
# @input params [String] :ref
# Optional string. A valid Git reference.
# Default: the repository’s default branch (usually master)
#
# @example
# github = Github.new
# github.repos.contents.archive 'user-name', 'repo-name',
# archive_format: "tarball",
# ref: "master"
#
# @api public
def archive(*args)
arguments(args, required: [:user, :repo])
params = arguments.params
archive_format = params.delete('archive_format') || 'tarball'
ref = params.delete('ref') || 'master'
get_request("/repos/#{arguments.user}/#{arguments.repo}/#{archive_format}/#{ref}", params)
end
end # Client::Repos::Contents
end # Github
github-api-0.14.2/lib/github_api/client/repos/statuses.rb 0000644 0001750 0001750 00000005745 12735456050 021736 0 ustar alee alee # encoding: utf-8
module Github
# The Status API allows external services to mark commits with a success,
# failure, error, or pending state, which is then reflected in pull requests
# involving those commits.
class Client::Repos::Statuses < API
VALID_STATUS_PARAM_NAMES = %w[
state
target_url
description
context
].freeze # :nodoc:
REQUIRED_PARAMS = %w[ state ].freeze # :nodoc:
# List Statuses for a specific SHA
#
# @param [String] :ref
# Ref to fetch the status for. It can be a SHA, a branch name,
# or a tag name.
#
# @example
# github = Github.new
# github.repos.statuses.list 'user-name', 'repo-name', 'ref'
# github.repos.statuses.list 'user-name', 'repo-name', 'ref' { |status| ... }
#
# Get the combined Status for a specific Ref
#
# @example
# github = Github.new
# github.repos.statuses.list 'user', 'repo', 'ref', combined: true
#
# @api public
def list(*args)
arguments(args, required: [:user, :repo, :ref])
params = arguments.params
user, repo, ref = arguments.user, arguments.repo, arguments.ref
response = if params.delete('combined')
get_request("/repos/#{user}/#{repo}/commits/#{ref}/status", params)
else
get_request("/repos/#{user}/#{repo}/commits/#{ref}/statuses", params)
end
return response unless block_given?
response.each { |el| yield el }
end
alias :all :list
# Create a status
#
# @param [Hash] params
# @input params [String] :state
# Required. The state of the status. Can be one of pending,
# success, error, or failure.
# @input params [String] :target_url
# The target URL to associate with this status. This URL will
# be linked from the GitHub UI to allow users to easily see
# the ‘source’ of the Status.
#
# For example, if your Continuous Integration system is posting
# build status, you would want to provide the deep link for
# the build output for this specific SHA:
# http://ci.example.com/user/repo/build/sha.
# @input params [String] :description
# A short description of the status
# @input params [String] :context
# A string label to differentiate this status from the
# status of other systems. Default: "default"
#
# @example
# github = Github.new
# github.repos.statuses.create 'user-name', 'repo-name', 'sha',
# state: "success",
# target_url: "http://ci.example.com/johndoe/my-repo/builds/sha",
# description: "Successful build #3 from origin/master"
#
# @api public
def create(*args)
arguments(args, required: [:user, :repo, :sha]) do
permit VALID_STATUS_PARAM_NAMES, recursive: false
assert_required REQUIRED_PARAMS
end
post_request("/repos/#{arguments.user}/#{arguments.repo}/statuses/#{arguments.sha}", arguments.params)
end
end # Client::Repos::Statuses
end # Github
github-api-0.14.2/lib/github_api/client/repos/statistics.rb 0000644 0001750 0001750 00000005706 12735456050 022252 0 ustar alee alee # encoding: utf-8
module Github
# The Repository Statistics API allows you to fetch the data that GitHub uses
# for visualizing different types of repository activity.
class Client::Repos::Statistics < API
# Get contributors list with additions, deletions, and commit counts
#
# @example
# github = Github.new
# github.repos.stats.contributors user: '...', repo: '...'
# github.repos.stats.contributors user: '...', repo: '...' { |stat| ... }
#
# @api public
def contributors(*args)
arguments(args, required: [:user, :repo])
response = get_request("/repos/#{arguments.user}/#{arguments.repo}/stats/contributors", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
# Get the last year of commit activity data
#
# Returns the last year of commit activity grouped by week.
# The days array is a group of commits per day, starting on Sunday
#
# @example
# github = Github.new
# github.repos.stats.commit_activity user: '...', repo: '...'
# github.repos.stats.commit_activity user: '...', repo: '...' { |stat| ... }
#
# @api public
def commit_activity(*args)
arguments(args, required: [:user, :repo])
response = get_request("/repos/#{arguments.user}/#{arguments.repo}/stats/commit_activity", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
# Get the number of additions and deletions per week
#
# @example
# github = Github.new
# github.repos.stats.code_frequency user: '...', repo: '...'
# github.repos.stats.code_frequency user: '...', repo: '...' { |stat| ... }
#
# @api public
def code_frequency(*args)
arguments(args, required: [:user, :repo])
get_request("/repos/#{arguments.user}/#{arguments.repo}/stats/code_frequency", arguments.params)
end
# Get the weekly commit count for the repo owner and everyone else
#
# @example
# github = Github.new
# github.repos.stats.participation user: '...', repo: '...'
# github.repos.stats.participation user: '...', repo: '...' { |stat| ... }
#
# @api public
def participation(*args)
arguments(args, required: [:user, :repo])
get_request("/repos/#{arguments.user}/#{arguments.repo}/stats/participation", arguments.params)
end
# Get the number of commits per hour in each day
#
# @example
# github = Github.new
# github.repos.stats.punch_card user: '...', repo: '...'
# github.repos.stats.punch_card user: '...', repo: '...' { |stat| ... }
#
# @api public
def punch_card(*args)
arguments(args, required: [:user, :repo])
response = get_request("/repos/#{arguments.user}/#{arguments.repo}/stats/punch_card", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
end # Client::Repos::Statistics
end # Github
github-api-0.14.2/lib/github_api/client/repos/releases.rb 0000644 0001750 0001750 00000013773 12735456050 021666 0 ustar alee alee # encoding: utf-8
module Github
# The Releases API
class Client::Repos::Releases < API
require_all 'github_api/client/repos/releases', 'assets', 'tags'
# Access to Repos::Releases::Assets API
namespace :assets
# Access to Repos::Releases::Tags API
namespace :tags
# List releases for a repository
#
# Users with push access to the repository will receive all releases
# (i.e., published releases and draft releases). Users with pull access
# will receive published releases only.
#
# @see https://developer.github.com/v3/repos/releases/#list-releases-for-a-repository
#
# @example
# github = Github.new
# github.repos.releases.list 'owner', 'repo'
# github.repos.releases.list 'owner', 'repo' { |release| ... }
#
# @api public
def list(*args)
arguments(args, required: [:owner, :repo])
response = get_request("/repos/#{arguments.owner}/#{arguments.repo}/releases", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias_method :all, :list
# Get a single release
#
# @see https://developer.github.com/v3/repos/releases/#get-a-single-release
#
# @example
# github = Github.new
# github.repos.releases.get 'owner', 'repo', 'id'
#
# @api public
def get(*args)
arguments(args, required: [:owner, :repo, :id]).params
get_request("/repos/#{arguments.owner}/#{arguments.repo}/releases/#{arguments.id}" , arguments.params)
end
alias_method :find, :get
# Create a release
#
# Users with push access to the repository can create a release.
#
# @see https://developer.github.com/v3/repos/releases/#create-a-release
#
# @param [Hash] params
# @input params [String] :tag_name
# Required. The name of the tag.
# @input params [String] :target_commitish
# Specifies the commitish value that determines where the Git tag
# is created from. Can be any branch or commit SHA. Defaults to
# the repository's default branch (usually 'master').
# Unused if the Git tag already exists.
# @input params [String] :name
# The name of the release.
# @input params [String] :body
# Text describing the contents of the tag.
# @input params [Boolean] :draft
# true to create a draft (unpublished) release,
# false to create a published one. Default: false
# @input params [Boolean] :prerelease
# true to identify the release as a prerelease.
# false to identify the release as a full release. Default: false
#
# @example
# github = Github.new
# github.repos.releases.create 'owner', 'repo',
# tag_name: "v1.0.0",
# target_commitish: "master",
# name: "v1.0.0",
# body: "Description of the release",
# draft: false,
# prerelease: false
#
# @api public
def create(*args)
arguments(args, required: [:owner, :repo]) do
assert_required :tag_name
end
post_request("/repos/#{arguments.owner}/#{arguments.repo}/releases",
arguments.params)
end
# Edit a release
#
# Users with push access to the repository can edit a release.
#
# @see https://developer.github.com/v3/repos/releases/#edit-a-release
#
# @param [String] :owner
# @param [String] :repo
# @param [Integer] :id
# @param [Hash] params
# @input params [String] :tag_name
# Required. The name of the tag.
# @input params [String] :target_commitish
# Specifies the commitish value that determines where the Git tag
# is created from. Can be any branch or commit SHA. Defaults to
# the repository's default branch (usually 'master').
# Unused if the Git tag already exists.
# @input params [String] :name
# The name of the release.
# @input params [String] :body
# Text describing the contents of the tag.
# @input params [Boolean] :draft
# true to create a draft (unpublished) release,
# false to create a published one. Default: false
# @input params [Boolean] :prerelease
# true to identify the release as a prerelease.
# false to identify the release as a full release. Default: false
#
# @example
# github = Github.new
# github.repos.releases.edit 'owner', 'repo', 'id',
# tag_name: "v1.0.0",
# target_commitish: "master",
# name: "v1.0.0",
# body: "Description of the release",
# draft: false,
# prerelease: false
#
# @api public
def edit(*args)
arguments(args, required: [:owner, :repo, :id])
patch_request("/repos/#{arguments.owner}/#{arguments.repo}/releases/#{arguments.id}", arguments.params)
end
alias_method :update, :edit
# Delete a release
#
# Users with push access to the repository can delete a release.
#
# @see https://developer.github.com/v3/repos/releases/#delete-a-release
#
# @param [String] :owner
# @param [String] :repo
# @param [Integer] :id
#
# @example
# github = Github.new
# github.repos.releases.delete 'owner', 'repo', 'id'
#
# @api public
def delete(*args)
arguments(args, required: [:owner, :repo, :id]).params
delete_request("/repos/#{arguments.owner}/#{arguments.repo}/releases/#{arguments.id}", arguments.params)
end
# Get the latest release
#
# View the latest published full release for the repository.
# Draft releases and prereleases are not returned.
#
# @see https://developer.github.com/v3/repos/releases/#get-the-latest-release
#
# @param [String] :owner
# @param [String] :repo
#
# @example
# github = Github.new
# github.repos.releases.latest 'owner', 'repo'
#
# @api public
def latest(*args)
arguments(args, required: [:owner, :repo]).params
get_request("repos/#{arguments.owner}/#{arguments.repo}/releases/latest", arguments.params)
end
end # Client::Repos::Statuses
end # Github
github-api-0.14.2/lib/github_api/client/repos/keys.rb 0000644 0001750 0001750 00000005424 12735456050 021030 0 ustar alee alee # encoding: utf-8
module Github
class Client::Repos::Keys < API
# List deploy keys
#
# @see https://developer.github.com/v3/repos/keys/#list
#
# @param [String] :user
# @param [String :repo
#
# @example
# github = Github.new
# github.repos.keys.list 'user-name', 'repo-name'
# github.repos.keys.list 'user-name', 'repo-name' { |key| ... }
#
# @example
# keys = Github::Repos::Keys.new user: 'user-name', repo: 'repo-name'
# keys.list
#
# @api public
def list(*args)
arguments(args, required: [:user, :repo])
response = get_request("/repos/#{arguments.user}/#{arguments.repo}/keys",
arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias_method :all, :list
# Get a key
#
# @see https://developer.github.com/v3/repos/keys/#get
#
# @param [String] :user
# @param [String] :repo
# @param [Integer] :id
#
# @example
# github = Github.new
# github.repos.keys.get 'user-name', 'repo-name', 'key-id'
#
# @api public
def get(*args)
arguments(args, required: [:user, :repo, :id])
get_request("/repos/#{arguments.user}/#{arguments.repo}/keys/#{arguments.id}", arguments.params)
end
alias_method :find, :get
# Create a key
#
# @see https://developer.github.com/v3/repos/keys/#create
#
# @param [String] :user
# @param [String] :repo
# @param [Hash] params
# @option params [String] :title
# Required string.
# @option params [String] :key
# Required string.
# @option params [String] :read_only
# If true, the key will only be able to read repository contents.
# Otherwise, the key will be able to read and write.
#
# @example
# github = Github.new
# github.repos.keys.create 'user-name', 'repo-name',
# title: "octocat@octomac",
# key: "ssh-rsa AAA..."
#
# @api public
def create(*args)
arguments(args, required: [:user, :repo])
post_request("/repos/#{arguments.user}/#{arguments.repo}/keys",
arguments.params)
end
alias_method :add, :create
# Delete key
#
# @see https://developer.github.com/v3/repos/keys/#delete
#
# @param [String] :user
# @param [String] :repo
# @param [Integer] :id
#
# @example
# github = Github.new
# github.repos.keys.delete 'user-name', 'repo-name', 'key-id'
#
# @api public
def delete(*args)
arguments(args, required: [:user, :repo, :id])
delete_request("/repos/#{arguments.user}/#{arguments.repo}/keys/#{arguments.id}", arguments.params)
end
alias_method :remove, :delete
end # Client::Repos::Keys
end # Github
github-api-0.14.2/lib/github_api/client/repos/comments.rb 0000644 0001750 0001750 00000006663 12735456050 021710 0 ustar alee alee # encoding: utf-8
module Github
class Client::Repos::Comments < API
REQUIRED_COMMENT_OPTIONS = %w[ body ].freeze
VALID_COMMENT_OPTIONS = %w[
body
line
path
position
].freeze
# List commit comments for a repository
#
# @example
# github = Github.new
# github.repos.comments.list 'user-name', 'repo-name'
#
# @example
# github.repos.comments.list 'user-name', 'repo-name' { |com| ... }
#
# List comments for a single commit
#
# @example
# github.repos.comments.list 'user-name', 'repo-name',
# sha: '6dcb09b5b57875f334f61aebed695e2e4193db5e'
#
# @api public
def list(*args)
arguments(args, required: [:user, :repo])
params = arguments.params
user = arguments.user
repo = arguments.repo
response = if (sha = params.delete('sha'))
get_request("/repos/#{user}/#{repo}/commits/#{sha}/comments", params)
else
get_request("/repos/#{user}/#{repo}/comments", params)
end
return response unless block_given?
response.each { |el| yield el }
end
alias :all :list
# Gets a single commit comment
#
# @example
# github = Github.new
# github.repos.comments.get 'user-name', 'repo-name', 'id'
#
# @api public
def get(*args)
arguments(args, required: [:user, :repo, :id])
get_request("/repos/#{arguments.user}/#{arguments.repo}/comments/#{arguments.id}", arguments.params)
end
alias :find :get
# Creates a commit comment
#
# @param [Hash] params
# @option params [String] :body
# Required. The contents of the comment.
# @option params [String] :path
# Required. Relative path of the file to comment on.
# @option params [Number] :position
# Required number - Line index in the diff to comment on.
# @option params [Number] :line
# Required number - Line number in the file to comment on.
#
# @example
# github = Github.new
# github.repos.comments.create 'user-name', 'repo-name', 'sha-key',
# body: "Nice change",
# position: 4,
# line: 1,
# path: "file1.txt"
#
# @api public
def create(*args)
arguments(args, required: [:user, :repo, :sha]) do
permit VALID_COMMENT_OPTIONS
assert_required REQUIRED_COMMENT_OPTIONS
end
post_request("/repos/#{arguments.user}/#{arguments.repo}/commits/#{arguments.sha}/comments", arguments.params)
end
# Update a commit comment
#
# @param [Hash] params
# @option params [String] :body
# Required. The contents of the comment.
#
# @example
# github = Github.new
# github.repos.comments.update 'user-name', 'repo-name', 'id',
# body: "Nice change"
#
# @api public
def update(*args)
arguments(args, required: [:user, :repo, :id]) do
assert_required REQUIRED_COMMENT_OPTIONS
end
patch_request("/repos/#{arguments.user}/#{arguments.repo}/comments/#{arguments.id}", arguments.params)
end
# Deletes a commit comment
#
# @example
# github = Github.new
# github.repos.comments.delete 'user-name', 'repo-name', 'id'
#
# @api public
def delete(*args)
arguments(args, required: [:user, :repo, :id])
delete_request("/repos/#{arguments.user}/#{arguments.repo}/comments/#{arguments.id}", arguments.params)
end
end # Client::Repos::Comments
end # Github
github-api-0.14.2/lib/github_api/client/repos/collaborators.rb 0000644 0001750 0001750 00000004742 12735456050 022725 0 ustar alee alee # encoding: utf-8
module Github
class Client::Repos::Collaborators < API
# List collaborators
#
# When authenticating as an organization owner of an
# organization-owned repository, all organization owners are included
# in the list of collaborators. Otherwise, only users with access to the
# repository are returned in the collaborators list.
#
# @example
# github = Github.new
# github.repos.collaborators.list 'user-name', 'repo-name'
#
# @example
# github.repos.collaborators.list 'user-name', 'repo-name' { |cbr| .. }
#
# @return [Array]
#
# @api public
def list(*args)
arguments(args, required: [:user, :repo])
params = arguments.params
response = get_request("/repos/#{arguments.user}/#{arguments.repo}/collaborators", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias :all :list
# Add collaborator
#
# @example
# github = Github.new
# github.repos.collaborators.add 'user', 'repo', 'username'
#
# @example
# collaborators = Github::Repos::Collaborators.new
# collaborators.add 'user', 'repo', 'username'
#
# @api public
def add(*args)
arguments(args, required: [:user, :repo, :username])
put_request("/repos/#{arguments.user}/#{arguments.repo}/collaborators/#{arguments.username}", arguments.params)
end
alias :<< :add
# Checks if user is a collaborator for a given repository
#
# @example
# github = Github.new
# github.repos.collaborators.collaborator?('user', 'repo', 'username')
#
# @example
# github = Github.new user: 'user-name', repo: 'repo-name'
# github.collaborators.collaborator? username: 'collaborator'
#
# @api public
def collaborator?(*args)
arguments(args, required: [:user, :repo, :username])
get_request("/repos/#{arguments.user}/#{arguments.repo}/collaborators/#{arguments.username}", arguments.params)
true
rescue Github::Error::NotFound
false
end
# Removes collaborator
#
# @example
# github = Github.new
# github.repos.collaborators.remove 'user', 'repo', 'username'
#
# @api public
def remove(*args)
arguments(args, required: [:user, :repo, :username])
delete_request("/repos/#{arguments.user}/#{arguments.repo}/collaborators/#{arguments.username}", arguments.params)
end
end # Client::Repos::Collaborators
end # Github
github-api-0.14.2/lib/github_api/client/repos/pub_sub_hubbub.rb 0000644 0001750 0001750 00000010552 12735456050 023041 0 ustar alee alee # encoding: utf-8
module Github
class Client::Repos::PubSubHubbub < API
OPTIONS = {
:headers => {
CONTENT_TYPE => 'application/x-www-form-urlencoded'
}
}
# Subscribe to existing topic/event through pubsubhubbub
#
# @param [Hash] params
# @input params [String] :topic
# Required string. The URI of the GitHub repository to subscribe to.
# The path must be in the format of /:user/:repo/events/:event.
# @input params [String] :callback
# Required string - The URI to receive the updates to the topic.
#
# @example
# github = Github.new oauth_token: 'token'
# github.repos.pubsubhubbub.subscribe
# 'https://github.com/:user/:repo/events/push',
# 'github://Email?address=peter-murach@gmail.com',
# verify: 'sync',
# secret: '...'
#
# @api public
def subscribe(*args)
params = arguments(args, required: [:topic, :callback]).params
_merge_action!("subscribe", arguments.topic, arguments.callback, params)
params['options'] = OPTIONS
post_request("/hub", params)
end
# Unsubscribe from existing topic/event through pubsubhubbub
#
# @param [Hash] params
# @input params [String] :topic
# Required string. The URI of the GitHub repository to
# unsubscribe from. The path must be in the format of
# /:user/:repo/events/:event.
# @input params [String] :callback
# Required string. The URI to unsubscribe the topic from.
#
# @example
# github = Github.new oauth_token: 'token'
# github.repos.pubsubhubbub.unsubscribe
# 'https://github.com/:user/:repo/events/push',
# 'github://Email?address=peter-murach@gmail.com',
# verify: 'sync',
# secret: '...'
#
# @api public
def unsubscribe(*args)
params = arguments(args, required: [:topic, :callback]).params
_merge_action!("unsubscribe", arguments.topic, arguments.callback, params)
params['options'] = OPTIONS
post_request("/hub", params)
end
# Subscribe repository to service hook through pubsubhubbub
#
# @param [Hash] params
# @input params [String] :event
# Required hash key for the type of event. The default event is push.
#
# @example
# github = Github.new oauth_token: '...'
# github.repos.pubsubhubbub.subscribe_service 'user-name', 'repo-name',
# 'campfire',
# subdomain: 'github',
# room: 'Commits',
# token: 'abc123',
# event: 'watch'
#
# @api public
def subscribe_service(*args)
params = arguments(args, required: [:user, :repo, :service]).params
event = params.delete('event') || 'push'
topic = "#{site}/#{arguments.user}/#{arguments.repo}/events/#{event}"
callback = "github://#{arguments.service}?#{params.serialize}"
subscribe(topic, callback)
end
alias :subscribe_repository :subscribe_service
alias :subscribe_repo :subscribe_service
# Subscribe repository to service hook through pubsubhubbub
#
# @param [Hash] params
# @input params [String] :event
# Optional hash key for the type of event. The default event is push.
#
# @example
# github = Github.new oauth_token: '...'
# github.repos.pubsubhubbub.unsubscribe_service 'user-name', 'repo-name',
# 'campfire'
#
# @example
# github.repos.pubsubhubbub.unsubscribe_service
# user: 'user-name',
# repo: 'repo-name',
# service: 'service-name'
#
# @api public
def unsubscribe_service(*args)
params = arguments(args, required: [:user, :repo, :service]).params
event = params.delete('event') || 'push'
topic = "#{site}/#{arguments.user}/#{arguments.repo}/events/#{event}"
callback = "github://#{arguments.service}"
unsubscribe(topic, callback)
end
alias :unsubscribe_repository :unsubscribe_service
alias :unsubscribe_repo :unsubscribe_service
private
def _merge_action!(action, topic, callback, params) # :nodoc:
options = {
"hub.mode" => action.to_s,
"hub.topic" => topic.to_s,
"hub.callback" => callback,
"hub.verify" => params.delete('verify') || 'sync',
"hub.secret" => params.delete('secret') || ''
}
params.merge! options
end
end # Client::Repos::PubSubHubbub
end # Github
github-api-0.14.2/lib/github_api/client/repos/releases/ 0000755 0001750 0001750 00000000000 12735456050 021326 5 ustar alee alee github-api-0.14.2/lib/github_api/client/repos/releases/tags.rb 0000644 0001750 0001750 00000001227 12735456050 022613 0 ustar alee alee # encoding: utf-8
module Github
# The Releases API
class Client::Repos::Releases::Tags < API
# Get a published release with the specified tag.
#
# @see https://developer.github.com/v3/repos/releases/#get-a-release-by-tag-name
#
# @example
# github = Github.new
# github.repos.releases.tags.get 'owner', 'repo', 'tag'
#
# @api public
def get(*args)
arguments(args, required: [:owner, :repo, :tag]).params
get_request("/repos/#{arguments.owner}/#{arguments.repo}/releases/tags/#{arguments.tag}" , arguments.params)
end
alias_method :find, :get
end # Client::Repos::Releases::Tags
end # Github
github-api-0.14.2/lib/github_api/client/repos/releases/assets.rb 0000644 0001750 0001750 00000007550 12735456050 023164 0 ustar alee alee # encoding: utf-8
module Github
# The Release Assets API
class Client::Repos::Releases::Assets < API
VALID_ASSET_PARAM_NAMES = %w[
name
label
content_type
].freeze # :nodoc:
# List assets for a release
#
# @example
# github = Github.new
# github.repos.releases.assets.list 'owner', 'repo', 'id'
# github.repos.releases.assets.list 'owner', 'repo', 'id' { |asset| ... }
#
# @api public
def list(*args)
arguments(args, required: [:owner, :repo, :id]).params
response = get_request("/repos/#{arguments.owner}/#{arguments.repo}/releases/#{arguments.id}/assets", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias :all :list
# Get a single release asset
#
# @example
# github = Github.new
# github.repos.releases.assets.get 'owner', 'repo', 'id'
#
# @api public
def get(*args)
params = arguments(args, required: [:owner, :repo, :id]).params
get_request("/repos/#{arguments.owner}/#{arguments.repo}/releases/assets/#{arguments.id}" , arguments.params)
end
alias :find :get
# Upload a release asset
#
# @param [Hash] params
# @input params [String] :name
# Required string. The file name of the asset
# @input params [String] :content_type
# Required string. The content type of the asset.
# Example: “application/zip”.
#
# @example
# github = Github.new
# github.repos.releases.assets.upload 'owner', 'repo', 'id', 'file-path'
# name: "batman.jpg",
# content_type: "application/octet-stream"
#
# @api public
def upload(*args)
arguments(args, required: [:owner, :repo, :id, :filepath]) do
permit VALID_ASSET_PARAM_NAMES
end
params = arguments.params
unless type = params['content_type']
type = infer_media(arguments.filepath)
end
file = Faraday::UploadIO.new(arguments.filepath, type)
options = {
headers: { content_type: type },
endpoint: upload_endpoint,
query: {'name' => params['name']}
}
params['data'] = file.read
params['options'] = options
post_request("/repos/#{arguments.owner}/#{arguments.repo}/releases/#{arguments.id}/assets", params)
ensure
file.close if file
end
# Infer media type of the asset
#
def infer_media(filepath)
require 'mime/types'
types = MIME::Types.type_for(filepath)
types.empty? ? 'application/octet-stream' : types.first
rescue LoadError
raise Github::Error::UnknownMedia.new(filepath)
end
# Edit a release asset
#
# Users with push access to the repository can edit a release asset.
#
# @param [Hash] params
# @input params [String] :name
# Required. The file name of the asset.
# @input params [String] :label
# An alternate short description of the asset.
# Used in place of the filename.
#
# @example
# github = Github.new
# github.repos.releases.assets.edit 'owner', 'repo', 'id',
# name: "foo-1.0.0-osx.zip",
# label: "Mac binary"
#
# @api public
def edit(*args)
arguments(args, required: [:owner, :repo, :id]) do
permit VALID_ASSET_PARAM_NAMES
end
patch_request("/repos/#{arguments.owner}/#{arguments.repo}/releases/assets/#{arguments.id}", arguments.params)
end
alias :update :edit
# Delete a release asset
#
# @example
# github = Github.new
# github.repos.releases.assets.delete 'owner', 'repo', 'id'
#
# @api public
def delete(*args)
arguments(args, required: [:owner, :repo, :id])
delete_request("/repos/#{arguments.owner}/#{arguments.repo}/releases/assets/#{arguments.id}", arguments.params)
end
end # Client::Repos::Releases::Assets
end # Github
github-api-0.14.2/lib/github_api/client/repos/pages.rb 0000644 0001750 0001750 00000002665 12735456050 021160 0 ustar alee alee # encoding: utf-8
module Github
# The Pages API retrieves information about your GitHub Pages configuration,
# and the statuses of your builds. Information about the site and the builds
# can only be accessed by authenticated owners, even though the websites
# are public.
class Client::Repos::Pages < API
# List Pages builds
#
# @example
# github = Github.new
# github.repos.pages.list owner: 'owner-name', repo: 'repo-name'
#
# github = Github.new
# github.repos.pages.list :latest, owner: 'owner-name', repo: 'repo-name'
# @api public
def list(*args)
arguments(args, required: [:owner, :repo])
response = if args.map(&:to_s).include?('latest')
get_request("/repos/#{arguments.owner}/#{arguments.repo}/pages/builds/latest", arguments.params)
else
get_request("/repos/#{arguments.owner}/#{arguments.repo}/pages/builds", arguments.params)
end
return response unless block_given?
response.each { |el| yield el }
end
alias :all :list
# Get information about a Pages site
#
# @example
# github = Github.new
# github.repos.pages.get owner: 'owner-name', repo: 'repo-name'
#
# @api public
def get(*args)
arguments(args, required: [:owner, :repo])
get_request("/repos/#{arguments.owner}/#{arguments.repo}/pages", arguments.params)
end
alias :find :get
end # Client::Repos::Pages
end # Github
github-api-0.14.2/lib/github_api/client/repos/hooks.rb 0000644 0001750 0001750 00000015431 12735456050 021177 0 ustar alee alee # encoding: utf-8
module Github
# The Repository Hooks API manages the post-receive web and
# service hooks for a repository.
class Client::Repos::Hooks < API
VALID_HOOK_PARAM_NAMES = %w[
name
config
active
events
add_events
remove_events
].freeze # :nodoc:
# Active hooks can be configured to trigger for one or more events.
# The default event is push. The available events are:
VALID_HOOK_PARAM_VALUES = {
'events' => %w[
push
issues
issue_comment
commit_comment
pull_request
gollum
watch
download
fork
fork_apply
member
public
]
}.freeze # :nodoc:
REQUIRED_PARAMS = %w[ name config ].freeze # :nodoc:
# List repository hooks
#
# @example
# github = Github.new
# github.repos.hooks.list 'user-name', 'repo-name'
# github.repos.hooks.list 'user-name', 'repo-name' { |hook| ... }
#
# @api public
def list(*args)
arguments(args, required: [:user, :repo])
response = get_request("/repos/#{arguments.user}/#{arguments.repo}/hooks", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias :all :list
# Get a single hook
#
# @example
# github = Github.new
# github.repos.hooks.get 'user-name', 'repo-name', 'hook-id'
#
# @api public
def get(*args)
arguments(args, required: [:user, :repo, :id])
get_request("/repos/#{arguments.user}/#{arguments.repo}/hooks/#{arguments.id}", arguments.params)
end
alias :find :get
# Create a hook
#
# @param [Hash] params
# @input params [String] :name
# Required. The name of the service that is being called.
# @input params [Hash] :config
# Required. Key/value pairs to provide settings for this hook.
# These settings vary between the services and are defined in
# the github-services repository. Booleans are stored internally
# as “1” for true, and “0” for false. Any JSON true/false values
# will be converted automatically.
# @input params [Array] :events
# Determines what events the hook is triggered for. Default: ["push"]
# @input params [Boolean] :active
# Determines whether the hook is actually triggered on pushes.
#
# To create a webhook, the following fields are required by the config:
#
# @input config [String] :url
# A required string defining the URL to which the payloads
# will be delivered.
# @input config [String] :content_type
# An optional string defining the media type used to serialize
# the payloads. Supported values include json and form.
# The default is form.
# @input config [String] :secret
# An optional string that’s passed with the HTTP requests as
# an X-Hub-Signature header. The value of this header is
# computed as the HMAC hex digest of the body,
# using the secret as the key.
# @input config [String] :insecure_ssl
# An optional string that determines whether the SSL certificate
# of the host for url will be verified when delivering payloads.
# Supported values include "0" (verification is performed) and
# "1" (verification is not performed). The default is "0".
#
# @example
# github = Github.new
# github.repos.hooks.create 'user-name', 'repo-name',
# name: "web",
# active: true,
# config: {
# url: "http://something.com/webhook"
# }
# }
#
# @api public
def create(*args)
arguments(args, required: [:user, :repo]) do
permit VALID_HOOK_PARAM_NAMES, recursive: false
assert_required REQUIRED_PARAMS
end
post_request("/repos/#{arguments.user}/#{arguments.repo}/hooks", arguments.params)
end
# Edit a hook
#
# @param [Hash] params
# @input params [Hash] :config
# Required. Key/value pairs to provide settings for this hook.
# These settings vary between the services and are defined in
# the github-services repository. Booleans are stored internally
# as “1” for true, and “0” for false. Any JSON true/false values
# will be converted automatically.
# @input params [Array] :events
# Determines what events the hook is triggered for. Default: ["push"]
# @input params [Array] :add_events
# Determines a list of events to be added to the list of events
# that the Hook triggers for.
# @input params [Array] :remove_events
# Determines a list of events to be removed from the list of
# events that the Hook triggers for.
# @input params [Boolean] :active
# Determines whether the hook is actually triggered on pushes.
#
# @example
# github = Github.new
# github.repos.hooks.edit 'user-name', 'repo-name', 'hook-id',
# "name" => "campfire",
# "active" => true,
# "config" => {
# "subdomain" => "github",
# "room" => "Commits",
# "token" => "abc123"
# }
#
# @api public
def edit(*args)
arguments(args, required: [:user, :repo, :id]) do
permit VALID_HOOK_PARAM_NAMES, recursive: false
assert_required REQUIRED_PARAMS
end
patch_request("/repos/#{arguments.user}/#{arguments.repo}/hooks/#{arguments.id}", arguments.params)
end
# Test a hook
#
# This will trigger the hook with the latest push to the current
# repository if the hook is subscribed to push events. If the hook
# is not subscribed to push events, the server will respond with 204
# but no test POST will be generated.
#
# @example
# github = Github.new
# github.repos.hooks.test 'user-name', 'repo-name', 'hook-id'
#
# @api public
def test(*args)
arguments(args, required: [:user, :repo, :id])
post_request("/repos/#{arguments.user}/#{arguments.repo}/hooks/#{arguments.id}/tests", arguments.params)
end
# Ping a hook
#
# This will trigger a ping event to be sent to the hook.
#
# @example
# github = Github.new
# github.repos.hooks.ping 'user-name', 'repo-name', 'hook-id'
#
# @api public
def ping(*args)
arguments(args, required: [:user, :repo, :id])
post_request("/repos/#{arguments.user}/#{arguments.repo}/hooks/#{arguments.id}/pings", arguments.params)
end
# Delete a hook
#
# @example
# github = Github.new
# github.repos.hooks.delete 'user-name', 'repo-name', 'hook-id'
#
# @api public
def delete(*args)
arguments(args, required: [:user, :repo, :id])
delete_request("/repos/#{arguments.user}/#{arguments.repo}/hooks/#{arguments.id}", arguments.params)
end
end # Client::Repos::Hooks
end # Github
github-api-0.14.2/lib/github_api/client/repos/forks.rb 0000644 0001750 0001750 00000002462 12735456050 021200 0 ustar alee alee # encoding: utf-8
module Github
class Client::Repos::Forks < API
# List repository forks
#
# @param [Hash] params
# @input params [String] :sort
# The sort order. Can be either newest, oldest, or stargazers.
# Default: newest
#
# @example
# github = Github.new
# github.repos.forks.list 'user-name', 'repo-name'
# github.repos.forks.list 'user-name', 'repo-name' { |fork| ... }
#
# @api public
def list(*args)
arguments(args, required: [:user, :repo])
response = get_request("/repos/#{arguments.user}/#{arguments.repo}/forks", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias :all :list
# Create a fork for the authenticated user
#
# @param [Hash] params
# @input params [String] :organization
# The organization login. The repository will be forked into
# this organization.
#
# @example
# github = Github.new
# github.repos.forks.create 'user-name', 'repo-name',
# organization: "github"
#
# @api public
def create(*args)
arguments(args, required: [:user, :repo])
post_request("/repos/#{arguments.user}/#{arguments.repo}/forks", arguments.params)
end
end # Client::Repos::Forks
end # Github
github-api-0.14.2/lib/github_api/client/repos/downloads.rb 0000644 0001750 0001750 00000003075 12735456050 022047 0 ustar alee alee # encoding: utf-8
module Github
class Client::Repos::Downloads < API
REQUIRED_PARAMS = %w[ name size ].freeze
VALID_DOWNLOAD_PARAM_NAMES = %w[
name
size
description
content_type
].freeze
# List downloads for a repository
#
# @example
# github = Github.new
# github.repos.downloads.list 'user-name', 'repo-name'
# github.repos.downloads.list 'user-name', 'repo-name' { |downl| ... }
#
# @api public
def list(*args)
arguments(args, required: [:user, :repo])
response = get_request("/repos/#{arguments.user}/#{arguments.repo}/downloads", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias :all :list
# Get a single download
#
# @example
# github = Github.new
# github.repos.downloads.get 'user-name', 'repo-name', 'download-id'
#
# @api public
def get(*args)
arguments(args, required: [:user, :repo, :id])
get_request("/repos/#{arguments.user}/#{arguments.repo}/downloads/#{arguments.id}", arguments.params)
end
alias :find :get
# Delete download from a repository
#
# @example
# github = Github.new
# github.repos.downloads.delete 'user-name', 'repo-name', 'download-id'
#
# @api public
def delete(*args)
arguments(args, required: [:user, :repo, :id])
delete_request("/repos/#{arguments.user}/#{arguments.repo}/downloads/#{arguments.id}", arguments.params)
end
alias :remove :delete
end # Repos::Downloads
end # Github
github-api-0.14.2/lib/github_api/client/repos/deployments.rb 0000644 0001750 0001750 00000010730 12735456050 022414 0 ustar alee alee # encoding: utf-8
module Github
class Client::Repos::Deployments < API
VALID_DEPLOYMENTS_OPTIONS = %w[
ref
auto_merge
required_contexts
payload
environment
description
]
VALID_STATUS_OPTIONS = %w[
state
target_url
description
]
PREVIEW_MEDIA = 'application/vnd.github.cannonball-preview+json'.freeze # :nodoc:
# List deployments on a repository
#
# @xample
# github = Github.new
# github.repos.deployments.list 'user-name', 'repo-name'
# github.repos.deployments.list 'user-name', 'repo-name' { |deployment| ... }
#
# @api public
def list(*args)
arguments(args, required: [:user, :repo])
params = arguments.params
params['accept'] ||= PREVIEW_MEDIA
response = get_request("repos/#{arguments.user}/#{arguments.repo}/deployments", params)
return response unless block_given?
response.each { |el| yield el }
end
alias :all :list
# Create a deployment
#
# @param [Hash] params
# @option params [String] :ref
# Required string. The ref to deploy. This can be a branch, tag, or sha.
# @option params [Boolean] :auto_merge
# Optional boolean. Merge the default branch into the requested.
# @option params [Array] :required_contexts
# Optional array of status contexts verified against commit status checks.
# If this parameter is omitted from the parameters then all unique
# contexts will be verified before a deployment is created. To bypass
# checking entirely pass an empty array. Defaults to all unique contexts.
# @option params [String] :payload
# Optional JSON payload with extra information about the deployment.
# Default: ""
# @option params [String] :payload
# Optional String. Name for the target deployment environment (e.g.,
# production, staging, qa). Default: "production"
# @option params [String] :description
# Optional string. Optional short description.
#
# @example
# github = Github.new
# github.repos.deployments.create 'user-name', 'repo-name', ref: '...'
# github.repos.deployments.create
# 'user-name',
# 'repo-name',
# ref: '...',
# description: 'New deploy',
# force: true
#
# @api public
def create(*args)
arguments(args, required: [:user, :repo]) do
permit VALID_DEPLOYMENTS_OPTIONS
assert_required %w[ ref ]
end
params = arguments.params
params['accept'] ||= PREVIEW_MEDIA
post_request("repos/#{arguments.user}/#{arguments.repo}/deployments", arguments.params)
end
# List the statuses of a deployment.
#
# @param [Hash] params
# @option params [String] :id
# Required string. Id of the deployment being queried.
#
# @example
# github = Github.new
# github.repos.deployments.statuses 'user-name', 'repo-name', DEPLOYMENT_ID
# github.repos.deployments.statuses 'user-name', 'repo-name', DEPLOYMENT_ID { |status| ... }
#
# @api public
def statuses(*args)
arguments(args, required: [:user, :repo, :id])
params = arguments.params
params['accept'] ||= PREVIEW_MEDIA
statuses = get_request("repos/#{arguments.user}/#{arguments.repo}/deployments/#{arguments.id}/statuses", params)
return statuses unless block_given?
statuses.each { |status| yield status }
end
# Create a deployment status
#
# @param [Hash] params
# @option params [String] :id
# Required string. Id of the deployment being referenced.
# @option params [String] :state
# Required string. State of the deployment. Can be one of:
# pending, success, error, or failure.
# @option params [String] :target_url
# Optional string. The URL associated with the status.
# @option params [String] :description
# Optional string. A short description of the status.
#
# @example
# github = Github.new
# github.repos.deployments.create_status 'user-name', 'repo-name', DEPLOYMENT_ID, state: '...'
#
# @api public
def create_status(*args)
arguments(args, required: [:user, :repo, :id]) do
assert_required %w[ state ]
permit VALID_STATUS_OPTIONS
end
params = arguments.params
params['accept'] ||= PREVIEW_MEDIA
post_request("repos/#{arguments.user}/#{arguments.repo}/deployments/#{arguments.id}/statuses", params)
end
end # Client::Repos::Deployments
end # Github
github-api-0.14.2/lib/github_api/client/gists/ 0000755 0001750 0001750 00000000000 12735456050 017524 5 ustar alee alee github-api-0.14.2/lib/github_api/client/gists/comments.rb 0000644 0001750 0001750 00000005024 12735456050 021677 0 ustar alee alee # encoding: utf-8
module Github
class Client::Gists::Comments < API
# List comments on a gist
#
# @see https://developer.github.com/v3/gists/comments/#list-comments-on-a-gist
#
# @example
# github = Github.new
# github.gists.comments.list 'gist-id'
#
# @return [Hash]
#
# @api public
def list(*args)
arguments(args, required: [:gist_id])
response = get_request("/gists/#{arguments.gist_id}/comments",
arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias_method :all, :list
# Get a single comment
#
# @see https://developer.github.com/v3/gists/comments/#get-a-single-comment
#
# @example
# github = Github.new
# github.gists.comments.get 'gist-id', 'comment-id'
#
# @api public
def get(*args)
arguments(args, required: [:gist_id, :id])
get_request("/gists/#{arguments.gist_id}/comments/#{arguments.id}",
arguments.params)
end
alias_method :find, :get
# Create a comment
#
# @see https://developer.github.com/v3/gists/comments/#create-a-comment
#
# @param [Hash] params
# @option params [String] :body
# Required. The comment text.
#
# @example
# github = Github.new
# github.gists.comments.create 'gist-id'
#
# @api public
def create(*args)
arguments(args, required: [:gist_id])
post_request("/gists/#{arguments.gist_id}/comments", arguments.params)
end
# Edit a comment
#
# @see https://developer.github.com/v3/gists/comments/#edit-a-comment
#
# @param [Hash] params
# @option params [String] :body
# Required. The comment text.
#
# @example
# github = Github.new
# github.gists.comments.edit 'gist-id', 'comment-id'
#
# @api public
def edit(*args)
arguments(args, required: [:gist_id, :id])
patch_request("/gists/#{arguments.gist_id}/comments/#{arguments.id}",
arguments.params)
end
# Delete a comment
#
# @see https://developer.github.com/v3/gists/comments/#delete-a-comment
#
# @xample
# github = Github.new
# github.gists.comments.delete 'gist-id', 'comment-id'
#
# @api public
def delete(*args)
arguments(args, required: [:gist_id, :id])
delete_request("/gists/#{arguments.gist_id}/comments/#{arguments.id}",
arguments.params)
end
end # Gists::Comments
end # Github
github-api-0.14.2/lib/github_api/client/pull_requests.rb 0000644 0001750 0001750 00000013652 12735456050 021636 0 ustar alee alee # encoding: utf-8
module Github
class Client::PullRequests < API
require_all 'github_api/client/pull_requests', 'comments'
# Access to PullRequests::Comments API
namespace :comments
# List pull requests
#
# @example
# github = Github.new user: 'user-name', repo: 'repo-name'
# github.pull_requests.list
# github.pull_requests.list { |req| ... }
#
# @example
# pulls = Github::PullRequests.new
# pulls.pull_requests.list 'user-name', 'repo-name'
#
# @api public
def list(*args)
arguments(args, required: [:user, :repo])
response = get_request("/repos/#{arguments.user}/#{arguments.repo}/pulls",
arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
alias_method :all, :list
# Get a single pull request
#
# = Examples
# github = Github.new
# github.pull_requests.get 'user-name', 'repo-name', 'number'
#
# pulls = Github::PullRequests.new
# pulls.get 'user-name', 'repo-name', 'number'
#
def get(*args)
arguments(args, required: [:user, :repo, :number])
get_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/#{arguments.number}", arguments.params)
end
alias_method :find, :get
# Create a pull request
#
# @param [Hash] params
# @option params [String] :title
# Required string
# @option params [String] :body
# Optional string
# @option params [String] :base
# Required string - The branch you want your changes pulled into.
# @option params [String] :head
# Required string - The branch where your changes are implemented.
#
# @note: head and base can be either a sha or a branch name.
# Typically you would namespace head with a user like this: username:branch.
#
# Alternative Input
# You can also create a Pull Request from an existing Issue by passing
# an Issue number instead of title and body.
# @option params [Numeric] :issue
# Required number - Issue number in this repository to turn into a Pull Request.
#
# @example
# github = Github.new oauth_token: '...'
# github.pull_requests.create 'user-name', 'repo-name',
# title: "Amazing new feature",
# body: "Please pull this in!",
# head: "octocat:new-feature",
# base: "master"
#
# @example
# github.pull_requests.create 'user-name', 'repo-name',
# issue: "5",
# head: "octocat:new-feature",
# base: "master"
#
# @api public
def create(*args)
arguments(args, required: [:user, :repo])
post_request("/repos/#{arguments.user}/#{arguments.repo}/pulls",
arguments.params)
end
# Update a pull request
#
# @param [Hash] params
# @option params [String] :title
# Optional string
# @optoin params [String] :body
# Optional string
# @option params [String] :state
# Optional string - State of this Pull Request.
# Valid values are open and closed.
#
# @example
# github = Github.new oauth_token: '...'
# github.pull_requests.update 'user-name', 'repo-name', 'number'
# title: "Amazing new title",
# body: "Update body",
# state: "open"
#
# @api public
def update(*args)
arguments(args, required: [:user, :repo, :number])
patch_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/#{arguments.number}", arguments.params)
end
# List commits on a pull request
#
# @example
# github = Github.new
# github.pull_requests.commits 'user-name', 'repo-name', 'number'
#
# @api public
def commits(*args)
arguments(args, required: [:user, :repo, :number])
response = get_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/#{arguments.number}/commits", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
# List pull requests files
#
# @example
# github = Github.new
# github.pull_requests.files 'user-name', 'repo-name', 'number'
#
# @api public
def files(*args)
arguments(args, required: [:user, :repo, :number])
response = get_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/#{arguments.number}/files", arguments.params)
return response unless block_given?
response.each { |el| yield el }
end
# Check if pull request has been merged
#
# @example
# github = Github.new
# github.pull_requests.merged? 'user-name', 'repo-name', 'number'
#
# @api public
def merged?(*args)
arguments(args, required: [:user, :repo, :number])
get_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/#{arguments.number}/merge", arguments.params)
true
rescue Github::Error::NotFound
false
end
PREVIEW_MEDIA = 'application/vnd.github.polaris-preview+json'.freeze # :nodoc:
# Merge a pull request(Merge Button)
#
# @param [Hash] params
# @option params [String] :commit_title
# Optional string - The first line of the message that will be used for the merge commit
# @option params [String] :commit_message
# Optional string - The message that will be used for the merge commit
# @option params [String] :sha
# Optional string - The SHA that pull request head must match to allow merge
# @option params [Boolean] :squash
# Optional boolean - Commit a single commit to the head branch.
#
# @example
# github = Github.new
# github.pull_requests.merge 'user-name', 'repo-name', 'number'
#
# @api public
def merge(*args)
arguments(args, required: [:user, :repo, :number])
params = arguments.params
params['accept'] ||= PREVIEW_MEDIA
put_request("/repos/#{arguments.user}/#{arguments.repo}/pulls/#{arguments.number}/merge", params)
end
end # PullRequests
end # Github
github-api-0.14.2/lib/github_api/client/orgs.rb 0000644 0001750 0001750 00000006414 12735456050 017677 0 ustar alee alee # encoding: utf-8
module Github
# Organizations API
class Client::Orgs < API
require_all 'github_api/client/orgs',
'hooks',
'members',
'memberships',
'teams'
# Access to Client::Orgs::Hooks API
namespace :hooks
# Access to Client::Orgs::Members API
namespace :members
# Access to Client::Orgs::Memberships API
namespace :memberships
# Access to Client::Orgs::Teams API
namespace :teams
# List all organizations
#
# Lists all organizations, in the order that they were created on GitHub.
#
# @see https://developer.github.com/v3/orgs/#list-all-organizations
#
# @param [Hash] params
# @option params [String] :since
# The integer ID of the last Organization that you've seen.
#
# @example
# github = Github.new
# github.orgs.list :every
#
# List all public organizations for a user.
#
# @see https://developer.github.com/v3/orgs/#list-user-organizations
#
# @example
# github = Github.new
# github.orgs.list user: 'user-name'
#
# List public and private organizations for the authenticated user.
#
# @example
# github = Github.new oauth_token: '..'
# github.orgs.list
#
# @api public
def list(*args)
params = arguments(args).params
if (user_name = params.delete('user'))
response = get_request("/users/#{user_name}/orgs", params)
elsif args.map(&:to_s).include?('every')
response = get_request('/organizations', params)
else
# For the authenticated user
response = get_request('/user/orgs', params)
end
return response unless block_given?
response.each { |el| yield el }
end
alias_method :all, :list
# Get properties for a single organization
#
# @see https://developer.github.com/v3/orgs/#get-an-organization
#
# @example
# github = Github.new
# github.orgs.get 'github'
#
# @api public
def get(*args)
arguments(args, required: [:org_name])
get_request("/orgs/#{arguments.org_name}", arguments.params)
end
alias_method :find, :get
# Edit organization
#
# @see https://developer.github.com/v3/orgs/#edit-an-organization
#
# @param [Hash] params
# @option params [String] :billing_email
# Billing email address. This address is not publicized.
# @option params [String] :company
# The company name
# @option params [String] :email
# The publicly visible email address
# @option params [String] :location
# The location
# @option params [String] :name
# The shorthand name of the company.
# @option params [String] :description
# The description of the company.
#
# @example
# github = Github.new oauth_token: '...'
# github.orgs.edit 'github',
# billing_email: "support@github.com",
# blog: "https://github.com/blog",
# company: "GitHub",
# email: "support@github.com",
# location: "San Francisco",
# name: "github"
#
# @api public
def edit(*args)
arguments(args, required: [:org_name])
patch_request("/orgs/#{arguments.org_name}", arguments.params)
end
end # Orgs
end # Github
github-api-0.14.2/lib/github_api/client/meta.rb 0000644 0001750 0001750 00000000475 12735456050 017654 0 ustar alee alee # encoding: utf-8
module Github
class Client::Meta < API
# Get meta information about GitHub.com, the service.
#
# @example
# Github.meta.get
#
# @api public
def get(*args)
arguments(*args)
get_request("/meta", arguments.params)
end
end # Client::Meta
end # Github
github-api-0.14.2/lib/github_api/configuration.rb 0000644 0001750 0001750 00000003514 12735456050 020314 0 ustar alee alee # encoding: utf-8
require 'github_api/api/config'
module Github
# Stores the configuration
class Configuration < API::Config
# Other adapters are :typhoeus, :patron, :em_synchrony, :excon, :test
property :adapter, default: :net_http
# By default, don't traverse the page links
property :auto_pagination, default: false
# Basic authentication
property :basic_auth
# By default, don't set an application key
property :client_id
# By default, don't set an application secret
property :client_secret
# By default, don't set a user oauth access token
property :oauth_token
# The api endpoint used to connect to GitHub if none is set
property :endpoint, default: 'https://api.github.com'.freeze
# The web endpoint used to connect to GitHub if none is set
property :site, default: 'https://github.com'.freeze
# The web endpoint used to upload release assets to GitHub if none is set
property :upload_endpoint, default: 'https://uploads.github.com'.freeze
# The default SSL configuration
property :ssl, default: {
:ca_file => File.expand_path('../ssl_certs/cacerts.pem', __FILE__)
}
# By default the Accept header will make a request for JSON
property :mime_type
# The value sent in the http header for 'User-Agent' if none is set
property :user_agent, default: "Github API Ruby Gem #{Github::VERSION}".freeze
# By default uses the Faraday connection options if none is set
property :connection_options, default: {}
# Global repository name
property :repo
property :user
property :org
property :login
property :password
# By default display 30 resources
property :per_page, default: 30
# Add Faraday::RackBuilder to overwrite middleware
property :stack
end # Configuration
end # Github
github-api-0.14.2/lib/github_api/null_encoder.rb 0000644 0001750 0001750 00000000746 12735456050 020122 0 ustar alee alee # encoding: utf-8
require 'faraday'
module Github
# Skip encoding of the key nested parameters
module NullParamsEncoder
if defined?(Faraday::NestedParamsEncoder)
class << self
Faraday::NestedParamsEncoder.singleton_methods do |m|
define_method m, ::Faraday::NestedParamsEncoder.method(m).to_proc
end
end
end
def self.escape(s)
s.to_s
end
def self.unescape(s)
s.to_s
end
end # NullEncoder
end # Github
github-api-0.14.2/lib/github_api/paged_request.rb 0000644 0001750 0001750 00000002050 12735456050 020267 0 ustar alee alee # encoding: utf-8
module Github
# A module that adds http get request to response pagination
module PagedRequest
include Github::Constants
FIRST_PAGE = 1 # Default request page if none provided
PER_PAGE = 30 # Default number of items as specified by API
NOT_FOUND = -1 # Either page or per_page parameter not present
# Check if current api instance has default per_page param set,
# otherwise use global default.
#
def default_page_size
current_api.per_page ? current_api.per_page : PER_PAGE
end
def default_page
current_api.page ? current_api.page : FIRST_PAGE
end
# Perform http get request with pagination parameters
#
def page_request(path, params={})
if params[PARAM_PER_PAGE] == NOT_FOUND
params[PARAM_PER_PAGE] = default_page_size
end
if params[PARAM_PAGE] && params[PARAM_PAGE] == NOT_FOUND
params[PARAM_PAGE] = default_page
end
current_api.get_request(path, ParamsHash.new(params))
end
end # PagedRequest
end # Github
github-api-0.14.2/lib/github_api/mime_type.rb 0000644 0001750 0001750 00000001376 12735456050 017441 0 ustar alee alee # encoding: utf-8
module Github
module MimeType
MEDIA_LOOKUP = {
'json' => 'json',
'blob' => 'raw',
'raw' => 'raw+json',
'text' => 'text+json',
'html' => 'html+json',
'full' => 'full+json'
}
# Parse media type param
#
def parse(media)
version = 'v3'
media.sub!(/^[.]*|[.]*$/,"")
media = media.include?('+') ? media.split('+')[0] : media
version, media = media.split('.') if media.include?('.')
media_type = lookup_media(media)
"application/vnd.github.#{version}.#{media_type}"
end
def lookup_media(name)
MEDIA_LOOKUP.fetch(name) do
raise ArgumentError, "Provided Media Type #{name} is not valid"
end
end
end # MimeType
end # Github
github-api-0.14.2/lib/github_api.rb 0000644 0001750 0001750 00000005442 12735456050 015447 0 ustar alee alee # encoding: utf-8
require 'pp' if ENV['DEBUG']
require 'faraday'
require 'github_api/version'
require 'github_api/configuration'
require 'github_api/constants'
require 'github_api/utils/url'
require 'github_api/connection'
require 'github_api/deprecation'
require 'github_api/core_ext/ordered_hash'
require 'github_api/ext/faraday'
require 'github_api/middleware'
module Github
LIBNAME = 'github_api'
LIBDIR = File.expand_path("../#{LIBNAME}", __FILE__)
class << self
def included(base)
base.extend ClassMethods
end
# Alias for Github::Client.new
#
# @param [Hash] options
# the configuration options
#
# @return [Github::Client]
#
# @api public
def new(options = {}, &block)
Client.new(options, &block)
end
# Default middleware stack that uses default adapter as specified
# by configuration setup
#
# @return [Proc]
#
# @api private
def default_middleware(options = {})
Middleware.default(options)
end
# Delegate to Github::Client
#
# @api private
def method_missing(method_name, *args, &block)
if new.respond_to?(method_name)
new.send(method_name, *args, &block)
elsif configuration.respond_to?(method_name)
Github.configuration.send(method_name, *args, &block)
else
super
end
end
def respond_to?(method_name, include_private = false)
new.respond_to?(method_name, include_private) ||
configuration.respond_to?(method_name) ||
super(method_name, include_private)
end
end
module ClassMethods
# Requires internal libraries
#
# @param [String] prefix
# the relative path prefix
# @param [Array[String]] libs
# the array of libraries to require
#
# @return [self]
def require_all(prefix, *libs)
libs.each do |lib|
require "#{File.join(prefix, lib)}"
end
end
# The client configuration
#
# @return [Configuration]
#
# @api public
def configuration
@configuration ||= Configuration.new
end
alias_method :config, :configuration
# Configure options
#
# @example
# Github.configure do |c|
# c.some_option = true
# end
#
# @yield the configuration block
# @yieldparam configuration [Github::Configuration]
# the configuration instance
#
# @return [nil]
#
# @api public
def configure
yield configuration
end
end
extend ClassMethods
require_all LIBDIR,
'authorization',
'validations',
'normalizer',
'parameter_filter',
'api',
'client',
'pagination',
'request',
'response',
'response_wrapper',
'error',
'mime_type',
'page_links',
'paged_request',
'page_iterator',
'params_hash'
end # Github
github-api-0.14.2/LICENSE.txt 0000644 0001750 0001750 00000002040 12735456050 014053 0 ustar alee alee Copyright (c) 2011 Piotr Murach
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.
github-api-0.14.2/README.md 0000644 0001750 0001750 00000056050 12735456050 013521 0 ustar alee alee
# GithubAPI
[][gem]
[][travis]
[][codeclimate]
[][coverage]
[][inchpages]
[][gemnasium]
[gem]: http://badge.fury.io/rb/github_api
[travis]: http://travis-ci.org/piotrmurach/github
[codeclimate]: https://codeclimate.com/github/piotrmurach/github
[coverage]: https://coveralls.io/r/piotrmurach/github
[inchpages]: http://inch-ci.org/github/piotrmurach/github
[gemnasium]: https://gemnasium.com/piotrmurach/github
[Website](http://piotrmurach.github.io/github/) | [Wiki](https://github.com/piotrmurach/github/wiki) | [RDocs](http://rubydoc.info/github/piotrmurach/github/master/frames)
A Ruby client for the official GitHub API.
Supports all the API methods. It's built in a modular way. You can either instantiate the whole API wrapper Github.new or use parts of it i.e. Github::Client::Repos.new if working solely with repositories is your main concern. Intuitive query methods allow you easily call API endpoints.
## Features
* Intuitive GitHub API interface navigation.
* It's comprehensive. You can request all GitHub API resources.
* Modular design allows for working with parts of API.
* Fully customizable including advanced middleware stack construction.
* Supports OAuth2 authorization.
* Flexible argument parsing. You can write expressive and natural queries.
* Requests pagination with convenient DSL and automatic options.
* Easy error handling split for client and server type errors.
* Supports multithreaded environment.
* Custom media type specification through the 'media' parameter.
* Request results caching
* Fully tested with unit and feature tests hitting the live api.
## Installation
Install the gem by running
```ruby
gem install github_api
```
or put it in your Gemfile and run `bundle install`
```ruby
gem "github_api"
```
## Contents
* [1. Usage](#1-usage)
* [1.1 API Navigation](#11-api-navigation)
* [1.2 Modularity](#12-modularity)
* [1.3 Arguments](#13-arguments)
* [1.4 Response Querying](#14-response-querying)
* [1.4.1 Response Body](#141-response-body)
* [1.4.2 Response Headers](#142-response-headers)
* [1.4.3 Response Success](#143-response-success)
* [1.5 Request Headers](#15-request-headers)
* [1.5.1 Media Types](#151-media-types)
* [2. Configuration](#2-configuration)
* [2.1 Basic](#21-basic)
* [2.2 Advanced](#22-advanced)
* [2.3 SSL](#23-ssl)
* [2.4 Caching](#24-caching)
* [3. Authentication](#3-authentication)
* [3.1 Basic](#31-basic)
* [3.2 Authorizations API](#32-authorizations-api)
* [3.3 Scopes](#33-scopes)
* [3.4 Application OAuth](#34-application-oauth)
* [3.5 Two-Factor](#35-two-factor)
* [4. Pagination](#4-pagination)
* [4.1 Auto pagination](#41-auto-pagination)
* [5. Error Handling](#5-error-handling)
* [6. Examples](#6-examples)
* [6.1 Rails](#61-rails)
* [6.2 Manipulating Files](#62-manipulating-files)
* [7. Testing](#7-testing)
## 1 Usage
To start using the gem, you can either perform requests directly on `Github` namespace:
```ruby
Github.repos.list user: 'piotrmurach'
```
or create a new client instance like so
```ruby
github = Github.new
```
and then call api methods, for instance, to list a given user repositories do
```ruby
github.repos.list user: 'piotrmurach'
```
### 1.1 API Navigation
The **github_api** closely mirrors the [GitHub API](https://developer.github.com/v3/) hierarchy. For example, if you want to create a new file in a repository, look up the GitHub API spec. In there you will find contents sub category underneath the repository category. This would translate to the request:
```ruby
github = Github.new
github.repos.contents.create 'piotrmurach', 'finite_machine', 'hello.rb',
path: 'hello.rb',
content: "puts 'hello ruby'"
```
The whole library reflects the same api navigation. Therefore, if you need to list releases for a repository do:
```ruby
github.repos.releases.list 'piotrmurach', 'finite_machine'
```
or to list a user's followers:
```ruby
github.users.followers.list 'piotrmurach'
```
The code base has been extensively documented with examples of how to use each method. Please refer to the [documentation](http://rubydoc.info/github/piotrmurach/github/master/frames) under the `Github::Client` class name.
Alternatively, you can find out which methods are supported by an api by calling `actions` on a class or instance. For example, in order to find out available endpoints for `Github::Client::Repos::Contents` api call `actions` method:
```ruby
Github::Client::Repos::Contents.actions
=> [:archive, :create, :delete, :find, :get, :readme, :update]
```
### 1.2 Modularity
The code base is modular. This means that you can work specifically with a given part of GitHub API. If you want to only work with activity starring API do the following:
```ruby
starring = Github::Client::Activity::Starring.new oauth_token: token
starring.star 'piotrmurach', 'github'
```
Please refer to the [documentation](http://rubydoc.info/github/piotrmurach/github/master/frames) and look under `Github::Client` to see all available classes.
### 1.3 Arguments
The **github_api** library allows for flexible argument parsing.
Arguments can be passed directly inside the method called. The `required` arguments are passed in first, followed by optional parameters supplied as hash options:
```ruby
issues = Github::Client::Issues.new
issues.milestones.list 'piotrmurach', 'github', state: 'open'
```
In the previous example, the order of arguments is important. However, each method also allows you to specify `required` arguments using hash symbols and thus remove the need for ordering. Therefore, the same example could be rewritten like so:
```ruby
issues = Github::Client::Issues.new
issues.milestones.list user: 'piotrmurach', repo: 'github', state: 'open'
```
Furthermore, `required` arguments can be passed during instance creation:
```ruby
issues = Github::Client::Issues.new user: 'piotrmurach', repo: 'github'
issues.milestones.list state: 'open'
```
Similarly, the `required` arguments for the request can be passed inside the current scope such as:
```ruby
issues = Github::Client::Issues.new
issues.milestones(user: 'piotrmurach', repo: 'github').list state: 'open'
```
But why limit ourselves? You can mix and match arguments, for example:
```ruby
issues = Github::Client::Issues.new user: 'piotrmurach'
issues.milestones(repo: 'github').list
issues.milestones(repo: 'tty').list
```
You can also use a bit of syntactic sugar whereby "username/repository" can be passed as well:
```ruby
issues = Github::Client::Issues.new
issues.milestones('piotrmurach/github').list
issues.milestones.list 'piotrmurach/github'
```
Finally, use the `with` scope to clearly denote your requests
```ruby
issues = Github::Client::Issues.new
issues.milestones.with(user: 'piotrmurach', repo: 'github').list
```
Please consult the method [documentation](http://rubydoc.info/github/piotrmurach/github/master/frames) or [GitHub specification](https://developer.github.com/v3/) to see which arguments are required and what are the option parameters.
### 1.4 Response Querying
The response is of type `Github::ResponseWrapper` and allows traversing all the json response attributes like method calls. In addition, if the response returns more than one resource, these will be automatically yielded to the provided block one by one.
For example, when request is issued to list all the branches on a given repository, each branch will be yielded one by one:
```ruby
repos = Github::Client::Repos.new
repos.branches user: 'piotrmurach', repo: 'github' do |branch|
puts branch.name
end
```
#### 1.4.1 Response Body
The `ResponseWrapper` allows you to call json attributes directly as method calls. there is no magic here, all calls are delegated to the response body. Therefore, you can directly inspect request body by calling `body` method on the `ResponseWrapper` like so:
```ruby
response = repos.branches user: 'piotrmurach', repo: 'github'
response.body # => Array of branches
```
#### 1.4.2 Response Headers
Each response comes packaged with methods allowing for inspection of HTTP start line and headers. For example, to check for rate limits and status codes do:
```ruby
response = Github::Client::Repos.branches 'piotrmurach', 'github'
response.headers.ratelimit_limit # "5000"
response.headers.ratelimit_remaining # "4999"
response.headers.status # "200"
response.headers.content_type # "application/json; charset=utf-8"
response.headers.etag # "\"2c5dfc54b3fe498779ef3a9ada9a0af9\""
response.headers.cache_control # "public, max-age=60, s-maxage=60"
```
#### 1.4.3 Response Success
If you want to verify if the response was success, namely, that the `200` code was returned call the `success?` like so:
```ruby
response = Github::Client::Repos.branches 'piotrmurach', 'github'
response.success? # => true
```
### 1.5 Request Headers
It is possible to specify additional header information which will be added to the final request.
For example, to set `etag` and `X-Poll_Interval` headers, use the `:headers` hash key inside the `:options` hash like in the following:
```ruby
events = Github::Client::Activity::Events.new
events.public headers: {
'X-Poll-Interval': 60,
'ETag': "a18c3bded88eb5dbb5c849a489412bf3"
}
```
#### 1.5.1 Media Types
In order to set custom media types for a request use the accept header. By using the `:accept` key you can determine media type like in the example:
```ruby
issues = Github::Client::Issues.new
issues.get 'piotrmurach', 'github', 108, accept: 'application/vnd.github.raw'
```
## 2 Configuration
The **github_api** provides ability to specify global configuration options. These options will be available to all api calls.
### 2.1 Basic
The configuration options can be set by using the `configure` helper
```ruby
Github.configure do |c|
c.basic_auth = "login:password"
c.adapter = :typheous
c.user = 'piotrmurach'
c.repo = 'finite_machine'
end
```
Alternatively, you can configure the settings by passing a block to an instance like:
```ruby
Github.new do |c|
c.endpoint = 'https://github.company.com/api/v3'
c.site = 'https://github.company.com'
c.upload_endpoint = 'https://github.company.com/api/uploads'
end
```
or simply by passing hash of options to an instance like so
```ruby
github = Github.new basic_auth: 'login:password',
adapter: :typheous,
user: 'piotrmurach',
repo: 'finite_machine'
```
The following is the full list of available configuration options:
```ruby
adapter # Http client used for performing requests. Default :net_http
auto_pagination # Automatically traverse requests page links. Default false
basic_auth # Basic authentication in form login:password.
client_id # Oauth client id.
client_secret # Oauth client secret.
connection_options # Hash of connection options.
endpoint # Enterprise API endpoint. Default: 'https://api.github.com'
oauth_token # Oauth authorization token.
org # Global organization used in requests if none provided
per_page # Number of items per page. Max of 100. Default 30.
repo # Global repository used in requests in none provided
site # enterprise API web endpoint
ssl # SSL settings in hash form.
user # Global user used for requests if none provided
user_agent # Custom user agent name. Default 'Github API Ruby Gem'
```
### 2.2 Advanced
The **github_api** will use the default middleware stack which is exposed by calling `stack` on a client instance. However, this stack can be freely modified with methods such as `insert`, `insert_after`, `delete` and `swap`. For instance, to add your `CustomMiddleware` do:
```ruby
Github.configure do |c|
c.stack.insert_after Github::Response::Helpers, CustomMiddleware
end
```
Furthermore, you can build your entire custom stack and specify other connection options such as `adapter` by doing:
```ruby
Github.new do |c|
c.adapter :excon
c.stack do |builder|
builder.use Github::Response::Helpers
builder.use Github::Response::Jsonize
end
end
```
### 2.3 SSL
By default requests over SSL are set to OpenSSL::SSL::VERIFY_PEER. However, you can turn off peer verification by
```ruby
github = Github.new ssl: { verify: false }
```
If your client fails to find CA certs, you can pass other SSL options to specify exactly how the information is sourced
```ruby
ssl: {
client_cert: "/usr/local/www.example.com/client_cert.pem"
client_key: "/user/local/www.example.com/client_key.pem"
ca_file: "example.com.cert"
ca_path: "/etc/ssl/"
}
```
For instance, download CA root certificates from Mozilla [cacert](http://curl.haxx.se/ca/cacert.pem) and point ca_file at your certificate bundle location. This will allow the client to verify the github.com ssl certificate as authentic.
### 2.4 Caching
Caching is supported through the [`faraday-http-cache` gem](https://github.com/plataformatec/faraday-http-cache).
Add the gem to your Gemfile:
```ruby
gem 'faraday-http-cache'
```
You can now configure cache parameters as follows
```ruby
Github.configure do |config|
config.stack = proc do |builder|
builder.use Faraday::HttpCache, store: Rails.cache
end
end
```
More details on the available options can be found in the gem's own documentation: https://github.com/plataformatec/faraday-http-cache#faraday-http-cache
## 3 Authentication
### 3.1 Basic
To start making requests as authenticated user you can use your GitHub username and password like so
```ruby
Github.new basic_auth: 'login:password'
```
Though this method is convenient you should strongly consider using `OAuth` for improved security reasons.
### 3.2 Authorizations API
#### 3.2.1 For a User
To create an access token through the GitHub Authorizations API, you are required to pass your basic credentials and scopes you wish to have for the authentication token.
```ruby
github = Github.new basic_auth: 'login:password'
github.auth.create scopes: ['repo'], note: 'admin script'
```
You can add more than one scope from the `user`, `public_repo`, `repo`, `gist` or leave the scopes parameter out, in which case, the default read-only access will be assumed (includes public user profile info, public repo info, and gists).
#### 3.2.2 For an App
Furthermore, to create auth token for an application you need to pass `:app` argument together with `:client_id` and `:client_secret` parameters.
```ruby
github = Github.new basic_auth: 'login:password'
github.auth.app.create 'client-id', scopes: ['repo']
```
In order to revoke auth token(s) for an application you must use basic authentication with `client_id` as login and `client_secret` as password.
```ruby
github = Github.new basic_auth: "client_id:client_secret"
github.auth.app.delete 'client-id'
```
Revoke a specific app token.
```ruby
github.auth.app.delete 'client-id', 'access-token'
```
### 3.3 Scopes
You can check OAuth scopes you have by:
```ruby
github = Github.new oauth_token: 'token'
github.scopes.list # => ['repo']
```
or inidividually for a given user:
```ruby
github = Github.new
github.scopes.list 'token'
```
To list the scopes that the particular GitHub API action checks for do:
```ruby
repos = Github::Client::Repos.new
response = repos.list user: 'piotrmurach'
response.headers.accepted_oauth_scopes # => ['delete_repo', 'repo', 'public_repo']
```
To understand what each scope means refer to [documentation](http://developer.github.com/v3/oauth/#scopes)
### 3.4 Application OAuth
In order to authenticate your app through OAuth2 on GitHub you need to
* Visit https://github.com/settings/applications/new and register your app.
You will need to be logged in to initially register the application.
* Authorize your credentials https://github.com/login/oauth/authorize
You can use convenience methods to help you achieve this using **GithubAPI** gem:
```ruby
github = Github.new client_id: '...', client_secret: '...'
github.authorize_url redirect_uri: 'http://localhost', scope: 'repo'
# => "https://github.com/login/oauth/authorize?scope=repo&response_type=code&client_id='...'&redirect_uri=http%3A%2F%2Flocalhost"
```
After you get your authorization code, call to receive your access_token
```ruby
token = github.get_token( authorization_code )
```
Once you have your access token, configure your github instance following instructions under Configuration.
**Note**: If you are working locally (i.e. your app URL and callback URL are localhost), do not specify a ```:redirect_uri``` otherwise you will get a ```redirect_uri_mismatch``` error.
### 3.5 Two-Factor
In order to use [Two-Factor](https://help.github.com/articles/about-two-factor-authentication) authentication you need provide `X-GitHub-OTP: required; :2fa-type` header.
You can add headers during initialization:
```ruby
Github.new do |config|
config.basic_auth = "user:password"
config.connection_options = {headers: {"X-GitHub-OTP" => '2fa token'}}
end
```
or per request:
```ruby
github = Github.new basic_auth: 'login:password'
github.oauth.create scopes: ["public_repo"],
headers: {"X-GitHub-OTP" => "2fa token"}
```
## 4 Pagination
Any request that returns multiple items will be paginated to 30 items by default. You can specify custom `page` and `per_page` query parameters to alter default behavior. For instance:
```ruby
repos = Github::Client::Repos.new
response = repos.list user: 'wycats', per_page: 10, page: 5
```
Then you can query the pagination information included in the link header by:
```ruby
response.links.first # Shows the URL of the first page of results.
response.links.next # Shows the URL of the immediate next page of results.
response.links.prev # Shows the URL of the immediate previous page of results.
response.links.last # Shows the URL of the last page of results.
```
In order to iterate through the entire result set page by page, you can use convenience methods:
```ruby
response.each_page do |page|
page.each do |repo|
puts repo.name
end
end
```
or use `has_next_page?` and `next_page` helper methods like in the following:
```ruby
while response.has_next_page?
... process response ...
res.next_page
end
```
One can also navigate straight to the specific page by:
```ruby
res.count_pages # Number of pages
res.page 5 # Requests given page if it exists, nil otherwise
res.first_page # Get first page
res.next_page # Get next page
res.prev_page # Get previous page
res.last_page # Get last page
```
### 4.1 Auto pagination
You can retrieve all pages in one invocation by passing the `auto_pagination` option like so:
```ruby
github = Github.new auto_pagination: true
```
Depending at what stage you pass the `auto_pagination` it will affect all or only a single request. For example, in order to auto paginate all Repository API methods do:
```ruby
Github::Сlient::Repos.new auto_pagination: true
```
However, to only auto paginate results for a single request do:
```ruby
Github::Client::Repos.new.list user: '...', auto_pagination: true
```
## 5 Error Handling
The generic error class `Github::Error::GithubError` will handle both the client (`Github::Error::ClientError`) and service (`Github::Error::ServiceError`) side errors. For instance in your code you can catch errors like
```ruby
begin
# Do something with github_api gem
rescue Github::Error::GithubError => e
puts e.message
if e.is_a? Github::Error::ServiceError
# handle GitHub service errors such as 404
elsif e.is_a? Github::Error::ClientError
# handle client errors e.i. missing required parameter in request
end
end
```
## 6 Examples
### 6.1 Rails
A Rails controller that allows a user to authorize their GitHub account and then performs a request.
```ruby
class GithubController < ApplicationController
def authorize
address = github.authorize_url redirect_uri: 'http://...', scope: 'repo'
redirect_to address
end
def callback
authorization_code = params[:code]
access_token = github.get_token authorization_code
access_token.token # => returns token value
end
private
def github
@github ||= Github.new client_id: '...', client_secret: '...'
end
end
```
### 6.2 Manipulating Files
In order to be able to create/update/remove files you need to use Contents API like so:
```ruby
contents = Github::Client::Repos::Contents.new oauth_token: '...'
```
Having instantiated the contents, to create a file do:
```ruby
contents.create 'username', 'repo_name', 'full_path_to/file.ext',
path: 'full_path_to/file.ext',
message: 'Your commit message',
content: 'The contents of your file'
```
Content is all Base64 encoded to/from the API, and when you create a file it encodes it automatically for you.
To update a file, first you need to find the file so you can get the SHA you're updating off of:
```ruby
file = contents.find path: 'full_path_to/file.ext'
```
Then update the file just like you do with creating:
```ruby
contents.update 'username', 'repo_name', 'full_path_to/file.ext',
path: 'full_path_to/file.ext'
message: 'Your commit message',
content: 'The contents to be updated',
sha: file.sha
```
Finally to remove a file, find the file so you can get the SHA you're removing:
```ruby
file = contents.find path: 'full_path_to/file.ext'
```
Then delete the file like so:
```ruby
github.delete 'username', 'tome-of-knowledge', 'full_path_to/file.ext',
path: 'full_path_to/file.ext',
message: 'Your Commit Message',
sha: file.sha
```
## 7 Testing
The test suite is split into two groups, `live` and `mock`.
The `live` tests are the ones in `features` folder and they simply exercise the GitHub API by making live requests and then being cached with VCR in directory named `features\cassettes`. For details on how to get set up, please navigate to the `features` folder.
The `mock` tests are in the `spec` directory and their primary concern is to test the gem internals without the hindrance of external calls.
## Development
Questions or problems? Please post them on the [issue tracker](https://github.com/piotrmurach/github/issues). You can contribute changes by forking the project and submitting a pull request. You can ensure the tests are passing by running `bundle` and `rake`.
## Contributing
Bug reports and pull requests are welcome on GitHub at https://github.com/piotrmurach/github. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
## Copyright
Copyright (c) 2011-2016 Piotr Murach. See LICENSE.txt for further details.
github-api-0.14.2/metadata.yml 0000644 0001750 0001750 00000021044 12735456050 014540 0 ustar alee alee --- !ruby/object:Gem::Specification
name: github_api
version: !ruby/object:Gem::Version
version: 0.14.2
platform: ruby
authors:
- Piotr Murach
autorequire:
bindir: bin
cert_chain: []
date: 2016-06-28 00:00:00.000000000 Z
dependencies:
- !ruby/object:Gem::Dependency
name: addressable
requirement: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: 2.4.0
type: :runtime
prerelease: false
version_requirements: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: 2.4.0
- !ruby/object:Gem::Dependency
name: hashie
requirement: !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: '3.4'
type: :runtime
prerelease: false
version_requirements: !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: '3.4'
- !ruby/object:Gem::Dependency
name: faraday
requirement: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: '0.8'
- - "<"
- !ruby/object:Gem::Version
version: '0.10'
type: :runtime
prerelease: false
version_requirements: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: '0.8'
- - "<"
- !ruby/object:Gem::Version
version: '0.10'
- !ruby/object:Gem::Dependency
name: oauth2
requirement: !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: '0'
type: :runtime
prerelease: false
version_requirements: !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: '0'
- !ruby/object:Gem::Dependency
name: descendants_tracker
requirement: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: 0.0.4
type: :runtime
prerelease: false
version_requirements: !ruby/object:Gem::Requirement
requirements:
- - "~>"
- !ruby/object:Gem::Version
version: 0.0.4
- !ruby/object:Gem::Dependency
name: bundler
requirement: !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: '0'
type: :development
prerelease: false
version_requirements: !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: '0'
- !ruby/object:Gem::Dependency
name: rake
requirement: !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: '0'
type: :development
prerelease: false
version_requirements: !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: '0'
description: " Ruby client that supports all of the GitHub API methods. It's build
in a modular way, that is, you can either instantiate the whole api wrapper Github.new
or use parts of it e.i. Github::Client::Repos.new if working solely with repositories
is your main concern. Intuitive query methods allow you easily call API endpoints. "
email: ''
executables: []
extensions: []
extra_rdoc_files:
- LICENSE.txt
- README.md
files:
- LICENSE.txt
- README.md
- lib/github_api.rb
- lib/github_api/api.rb
- lib/github_api/api/actions.rb
- lib/github_api/api/arguments.rb
- lib/github_api/api/config.rb
- lib/github_api/api/config/property.rb
- lib/github_api/api/config/property_set.rb
- lib/github_api/api/factory.rb
- lib/github_api/authorization.rb
- lib/github_api/client.rb
- lib/github_api/client/activity.rb
- lib/github_api/client/activity/events.rb
- lib/github_api/client/activity/feeds.rb
- lib/github_api/client/activity/notifications.rb
- lib/github_api/client/activity/starring.rb
- lib/github_api/client/activity/watching.rb
- lib/github_api/client/authorizations.rb
- lib/github_api/client/authorizations/app.rb
- lib/github_api/client/emojis.rb
- lib/github_api/client/gists.rb
- lib/github_api/client/gists/comments.rb
- lib/github_api/client/git_data.rb
- lib/github_api/client/git_data/blobs.rb
- lib/github_api/client/git_data/commits.rb
- lib/github_api/client/git_data/references.rb
- lib/github_api/client/git_data/tags.rb
- lib/github_api/client/git_data/trees.rb
- lib/github_api/client/gitignore.rb
- lib/github_api/client/issues.rb
- lib/github_api/client/issues/assignees.rb
- lib/github_api/client/issues/comments.rb
- lib/github_api/client/issues/events.rb
- lib/github_api/client/issues/labels.rb
- lib/github_api/client/issues/milestones.rb
- lib/github_api/client/markdown.rb
- lib/github_api/client/meta.rb
- lib/github_api/client/orgs.rb
- lib/github_api/client/orgs/hooks.rb
- lib/github_api/client/orgs/members.rb
- lib/github_api/client/orgs/memberships.rb
- lib/github_api/client/orgs/teams.rb
- lib/github_api/client/pull_requests.rb
- lib/github_api/client/pull_requests/comments.rb
- lib/github_api/client/repos.rb
- lib/github_api/client/repos/collaborators.rb
- lib/github_api/client/repos/comments.rb
- lib/github_api/client/repos/commits.rb
- lib/github_api/client/repos/contents.rb
- lib/github_api/client/repos/deployments.rb
- lib/github_api/client/repos/downloads.rb
- lib/github_api/client/repos/forks.rb
- lib/github_api/client/repos/hooks.rb
- lib/github_api/client/repos/keys.rb
- lib/github_api/client/repos/merging.rb
- lib/github_api/client/repos/pages.rb
- lib/github_api/client/repos/pub_sub_hubbub.rb
- lib/github_api/client/repos/releases.rb
- lib/github_api/client/repos/releases/assets.rb
- lib/github_api/client/repos/releases/tags.rb
- lib/github_api/client/repos/statistics.rb
- lib/github_api/client/repos/statuses.rb
- lib/github_api/client/say.rb
- lib/github_api/client/scopes.rb
- lib/github_api/client/search.rb
- lib/github_api/client/search/legacy.rb
- lib/github_api/client/users.rb
- lib/github_api/client/users/emails.rb
- lib/github_api/client/users/followers.rb
- lib/github_api/client/users/keys.rb
- lib/github_api/configuration.rb
- lib/github_api/connection.rb
- lib/github_api/constants.rb
- lib/github_api/core_ext/array.rb
- lib/github_api/core_ext/hash.rb
- lib/github_api/core_ext/ordered_hash.rb
- lib/github_api/deprecation.rb
- lib/github_api/error.rb
- lib/github_api/error/bad_request.rb
- lib/github_api/error/client_error.rb
- lib/github_api/error/forbidden.rb
- lib/github_api/error/internal_server_error.rb
- lib/github_api/error/invalid_options.rb
- lib/github_api/error/not_acceptable.rb
- lib/github_api/error/not_found.rb
- lib/github_api/error/required_params.rb
- lib/github_api/error/service_error.rb
- lib/github_api/error/service_unavailable.rb
- lib/github_api/error/unauthorized.rb
- lib/github_api/error/unknown_media.rb
- lib/github_api/error/unknown_value.rb
- lib/github_api/error/unprocessable_entity.rb
- lib/github_api/error/validations.rb
- lib/github_api/ext/faraday.rb
- lib/github_api/middleware.rb
- lib/github_api/mime_type.rb
- lib/github_api/normalizer.rb
- lib/github_api/null_encoder.rb
- lib/github_api/page_iterator.rb
- lib/github_api/page_links.rb
- lib/github_api/paged_request.rb
- lib/github_api/pagination.rb
- lib/github_api/parameter_filter.rb
- lib/github_api/params_hash.rb
- lib/github_api/rate_limit.rb
- lib/github_api/request.rb
- lib/github_api/request/basic_auth.rb
- lib/github_api/request/jsonize.rb
- lib/github_api/request/oauth2.rb
- lib/github_api/request/verbs.rb
- lib/github_api/requestable.rb
- lib/github_api/resource.rb
- lib/github_api/response.rb
- lib/github_api/response/atom_parser.rb
- lib/github_api/response/header.rb
- lib/github_api/response/jsonize.rb
- lib/github_api/response/mashify.rb
- lib/github_api/response/raise_error.rb
- lib/github_api/response/xmlize.rb
- lib/github_api/response_wrapper.rb
- lib/github_api/ssl_certs/cacerts.pem
- lib/github_api/utils/url.rb
- lib/github_api/validations.rb
- lib/github_api/validations/format.rb
- lib/github_api/validations/presence.rb
- lib/github_api/validations/required.rb
- lib/github_api/validations/token.rb
- lib/github_api/version.rb
homepage: http://piotrmurach.github.io/github/
licenses:
- MIT
metadata: {}
post_install_message:
rdoc_options: []
require_paths:
- lib
required_ruby_version: !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: 1.9.2
required_rubygems_version: !ruby/object:Gem::Requirement
requirements:
- - ">="
- !ruby/object:Gem::Version
version: '0'
requirements: []
rubyforge_project:
rubygems_version: 2.5.1
signing_key:
specification_version: 4
summary: Ruby client for the official GitHub API
test_files: []
has_rdoc:
