micro-max-tool 0.0.1

data/httparty-0.24.2/examples/custom_parsers.rb

@@ -0,0 +1,68 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+require 'pp'
+
+class ParseAtom
+  include HTTParty
+
+  # Support Atom along with the default parsers: xml, json, etc.
+  class Parser::Atom < HTTParty::Parser
+    SupportedFormats.merge!({"application/atom+xml" => :atom})
+
+    protected
+
+    # perform atom parsing on body
+    def atom
+      body.to_atom
+    end
+  end
+
+  parser Parser::Atom
+end
+
+class OnlyParseAtom
+  include HTTParty
+
+  # Only support Atom
+  class Parser::OnlyAtom < HTTParty::Parser
+    SupportedFormats = { "application/atom+xml" => :atom }
+
+    protected
+
+    # perform atom parsing on body
+    def atom
+      body.to_atom
+    end
+  end
+
+  parser Parser::OnlyAtom
+end
+
+class SkipParsing
+  include HTTParty
+
+  # Parse the response body however you like
+  class Parser::Simple < HTTParty::Parser
+    def parse
+      body
+    end
+  end
+
+  parser Parser::Simple
+end
+
+class AdHocParsing
+  include HTTParty
+  parser(
+    proc do |body, format|
+      case format
+      when :json
+        body.to_json
+      when :xml
+        body.to_xml
+      else
+        body
+      end
+    end
+  )
+end

data/httparty-0.24.2/examples/delicious.rb

@@ -0,0 +1,37 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+require 'pp'
+config = YAML.load(File.read(File.join(ENV['HOME'], '.delicious')))
+
+class Delicious
+  include HTTParty
+  base_uri 'https://api.del.icio.us/v1'
+
+  def initialize(u, p)
+    @auth = { username: u, password: p }
+  end
+
+  # query params that filter the posts are:
+  #   tag (optional). Filter by this tag.
+  #   dt (optional). Filter by this date (CCYY-MM-DDThh:mm:ssZ).
+  #   url (optional). Filter by this url.
+  #   ie: posts(query: {tag: 'ruby'})
+  def posts(options = {})
+    options.merge!({ basic_auth: @auth })
+    self.class.get('/posts/get', options)
+  end
+
+  # query params that filter the posts are:
+  #   tag (optional). Filter by this tag.
+  #   count (optional). Number of items to retrieve (Default:15, Maximum:100).
+  def recent(options = {})
+    options.merge!({ basic_auth: @auth })
+    self.class.get('/posts/recent', options)
+  end
+end
+
+delicious = Delicious.new(config['username'], config['password'])
+pp delicious.posts(query: { tag: 'ruby' })
+pp delicious.recent
+
+delicious.recent['posts']['post'].each { |post| puts post['href'] }

data/httparty-0.24.2/examples/google.rb

@@ -0,0 +1,16 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+require 'pp'
+
+class Google
+  include HTTParty
+  format :html
+end
+
+# google.com redirects to www.google.com so this is live test for redirection
+pp Google.get('http://google.com')
+
+puts '', '*' * 70, ''
+
+# check that ssl is requesting right
+pp Google.get('https://www.google.com')

data/httparty-0.24.2/examples/headers_and_user_agents.rb

@@ -0,0 +1,10 @@
+# To send custom user agents to identify your application to a web service (or mask as a specific browser for testing), send "User-Agent" as a hash to headers as shown below.
+
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+require 'pp'
+
+response = HTTParty.get('http://example.com', {
+  headers: {"User-Agent" => "Httparty"},
+  debug_output: STDOUT, # To show that User-Agent is Httparty
+})

data/httparty-0.24.2/examples/idn.rb

@@ -0,0 +1,10 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+require 'pp'
+
+class Idn
+    include HTTParty
+    uri_adapter Addressable::URI
+end
+
+pp Idn.get("https://i❤️.ws/emojidomain/💎?format=json")

data/httparty-0.24.2/examples/logging.rb

@@ -0,0 +1,36 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+require 'logger'
+require 'pp'
+
+my_logger = Logger.new STDOUT
+
+my_logger.info "Logging can be used on the main HTTParty class. It logs redirects too."
+HTTParty.get "http://google.com", logger: my_logger
+
+my_logger.info '*' * 70
+
+my_logger.info "It can be used also on a custom class."
+
+class Google
+  include HTTParty
+  logger ::Logger.new STDOUT
+end
+
+Google.get "http://google.com"
+
+my_logger.info '*' * 70
+
+my_logger.info "The default formatter is :apache. The :curl formatter can also be used."
+my_logger.info "You can tell which method to call on the logger too. It is info by default."
+HTTParty.get "http://google.com", logger: my_logger, log_level: :debug, log_format: :curl
+
+my_logger.info '*' * 70
+
+my_logger.info "These configs are also available on custom classes."
+class Google
+  include HTTParty
+  logger ::Logger.new(STDOUT), :debug, :curl
+end
+
+Google.get "http://google.com"

data/httparty-0.24.2/examples/microsoft_graph.rb

@@ -0,0 +1,52 @@
+require 'httparty'
+
+class MicrosoftGraph
+  MS_BASE_URL = "https://login.microsoftonline.com".freeze
+  TOKEN_REQUEST_PATH = "oauth2/v2.0/token".freeze
+
+  def initialize(tenant_id)
+    @tenant_id = tenant_id
+  end
+
+  # Make a request to the Microsoft Graph API, for instance https://graph.microsoft.com/v1.0/users
+  def request(url)
+    return false unless (token = bearer_token)
+
+    response = HTTParty.get(
+      url,
+      headers: {
+        Authorization: "Bearer #{token}"
+      }
+    )
+
+    return false unless response.code == 200
+
+    return JSON.parse(response.body)
+  end
+
+  private
+
+  # A post to the Microsoft Graph to get a bearer token for the specified tenant.  In this example
+  # our Rails application has already been given permission to request these tokens by the admin of
+  # the specified tenant_id.
+  #
+  # See here for more information https://developer.microsoft.com/en-us/graph/docs/concepts/auth_v2_service
+  #
+  # This request also makes use of the multipart/form-data post body.
+  def bearer_token
+    response = HTTParty.post(
+      "#{MS_BASE_URL}/#{@tenant_id}/#{TOKEN_REQUEST_PATH}",
+      multipart: true,
+      body: {
+        client_id: Rails.application.credentials[Rails.env.to_sym][:microsoft_client_id],
+        client_secret: Rails.application.credentials[Rails.env.to_sym][:microsoft_client_secret],
+        scope: 'https://graph.microsoft.com/.default',
+        grant_type: 'client_credentials'
+      }
+    )
+
+    return false unless response.code == 200
+
+    JSON.parse(response.body)['access_token']
+  end
+end

data/httparty-0.24.2/examples/multipart.rb

@@ -0,0 +1,35 @@
+# If you are uploading file in params, multipart will used as content-type automatically
+
+HTTParty.post(
+  'http://localhost:3000/user',
+  body: {
+    name: 'Foo Bar',
+    email: 'example@email.com',
+    avatar: File.open('/full/path/to/avatar.jpg')
+  }
+)
+
+
+# However, you can force it yourself
+
+HTTParty.post(
+  'http://localhost:3000/user',
+  multipart: true,
+  body: {
+    name: 'Foo Bar',
+    email: 'example@email.com'
+  }
+)
+
+
+# For large file uploads, use stream_body: true to reduce memory usage.
+# Instead of loading the entire file into memory, HTTParty will stream it in chunks.
+# Note: Some servers may not handle streaming uploads correctly.
+
+HTTParty.post(
+  'http://localhost:3000/upload',
+  body: {
+    document: File.open('/full/path/to/large_file.zip')
+  },
+  stream_body: true
+)

data/httparty-0.24.2/examples/nokogiri_html_parser.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'nokogiri'
+
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+require 'pp'
+
+class HtmlParserIncluded < HTTParty::Parser
+  def html
+    Nokogiri::HTML(body)
+  end
+end
+
+class Page
+  include HTTParty
+  parser HtmlParserIncluded
+end
+
+pp Page.get('http://www.google.com')

data/httparty-0.24.2/examples/party_foul_mode.rb

@@ -0,0 +1,90 @@
+require 'httparty'
+
+class APIClient
+  include HTTParty
+  base_uri 'api.example.com'
+
+  def self.fetch_user(id)
+    begin
+      get("/users/#{id}", foul: true)
+    rescue HTTParty::NetworkError => e
+      handle_network_error(e)
+    rescue HTTParty::ResponseError => e
+      handle_api_error(e)
+    end
+  end
+
+  private
+
+  def self.handle_network_error(error)
+    case error.cause
+    when Errno::ECONNREFUSED
+      {
+        error: :server_down,
+        message: "The API server appears to be down",
+        details: error.message
+      }
+    when Net::OpenTimeout, Timeout::Error
+      {
+        error: :timeout,
+        message: "The request timed out",
+        details: error.message
+      }
+    when SocketError
+      {
+        error: :network_error,
+        message: "Could not connect to the API server",
+        details: error.message
+      }
+    when OpenSSL::SSL::SSLError
+      {
+        error: :ssl_error,
+        message: "SSL certificate verification failed",
+        details: error.message
+      }
+    else
+      {
+        error: :unknown_network_error,
+        message: "An unexpected network error occurred",
+        details: error.message
+      }
+    end
+  end
+
+  def self.handle_api_error(error)
+    {
+      error: :api_error,
+      message: "API returned error #{error.response.code}",
+      details: error.response.body
+    }
+  end
+end
+
+# Example usage:
+
+# 1. When server is down
+result = APIClient.fetch_user(123)
+puts "Server down example:"
+puts result.inspect
+puts
+
+# 2. When request times out
+result = APIClient.fetch_user(456)
+puts "Timeout example:"
+puts result.inspect
+puts
+
+# 3. When SSL error occurs
+result = APIClient.fetch_user(789)
+puts "SSL error example:"
+puts result.inspect
+puts
+
+# 4. Simple example without a wrapper class
+begin
+  HTTParty.get('https://api.example.com/users', foul: true)
+rescue HTTParty::Foul => e
+  puts "Direct usage example:"
+  puts "Error type: #{e.cause.class}"
+  puts "Error message: #{e.message}"
+end

data/httparty-0.24.2/examples/peer_cert.rb

@@ -0,0 +1,9 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+
+peer_cert = nil
+HTTParty.get("https://www.example.com") do |fragment|
+  peer_cert ||= fragment.connection.peer_cert
+end
+
+puts "The server's certificate expires #{peer_cert.not_after}"

data/httparty-0.24.2/examples/rescue_json.rb

@@ -0,0 +1,17 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+
+# Take note of the "; 1" at the end of the following line. It's required only if
+# running this in IRB, because IRB will try to inspect the variable named
+# "request", triggering the exception.
+request = HTTParty.get 'https://rubygems.org/api/v1/versions/doesnotexist.json' ; 1
+
+# Check an exception due to parsing the response
+# because HTTParty evaluate the response lazily
+begin
+  request.inspect
+  # This would also suffice by forcing the request to be parsed:
+  # request.parsed_response
+rescue => e
+  puts "Rescued #{e.inspect}"
+end

data/httparty-0.24.2/examples/rubyurl.rb

@@ -0,0 +1,14 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+require 'pp'
+
+class Rubyurl
+  include HTTParty
+  base_uri 'rubyurl.com'
+
+  def self.shorten(website_url)
+    post('/api/links.json', query: { link: { website_url: website_url } })
+  end
+end
+
+pp Rubyurl.shorten('http://istwitterdown.com/')

data/httparty-0.24.2/examples/stackexchange.rb

@@ -0,0 +1,24 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+require 'pp'
+
+class StackExchange
+  include HTTParty
+  base_uri 'api.stackexchange.com'
+
+  def initialize(service, page)
+    @options = { query: { site: service, page: page } }
+  end
+
+  def questions
+    self.class.get("/2.2/questions", @options)
+  end
+
+  def users
+    self.class.get("/2.2/users", @options)
+  end
+end
+
+stack_exchange = StackExchange.new("stackoverflow", 1)
+pp stack_exchange.questions
+pp stack_exchange.users

data/httparty-0.24.2/examples/stream_download.rb

@@ -0,0 +1,26 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+require 'pp'
+
+# download file linux-4.6.4.tar.xz without using the memory
+response = nil
+filename = "linux-4.6.4.tar.xz"
+url = "https://cdn.kernel.org/pub/linux/kernel/v4.x/#{filename}"
+
+File.open(filename, "w") do |file|
+  response = HTTParty.get(url, stream_body: true) do |fragment|
+    if [301, 302].include?(fragment.code)
+      print "skip writing for redirect"
+    elsif fragment.code == 200
+      print "."
+      file.write(fragment)
+    else
+      raise StandardError, "Non-success status code while streaming #{fragment.code}"
+    end
+  end
+end
+puts
+
+pp "Success: #{response.success?}"
+pp File.stat(filename).inspect
+File.unlink(filename)

data/httparty-0.24.2/examples/tripit_sign_in.rb

@@ -0,0 +1,44 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+
+class TripIt
+  include HTTParty
+  base_uri 'https://www.tripit.com'
+  debug_output
+
+  def initialize(email, password)
+    @email = email
+    get_response = self.class.get('/account/login')
+    get_response_cookie = parse_cookie(get_response.headers['Set-Cookie'])
+
+    post_response = self.class.post(
+      '/account/login',
+      body: {
+        login_email_address: email,
+        login_password: password
+      },
+      headers: {'Cookie' => get_response_cookie.to_cookie_string }
+    )
+
+    @cookie = parse_cookie(post_response.headers['Set-Cookie'])
+  end
+
+  def account_settings
+    self.class.get('/account/edit', headers: { 'Cookie' => @cookie.to_cookie_string })
+  end
+
+  def logged_in?
+    account_settings.include? "You're logged in as #{@email}"
+  end
+
+  private
+
+  def parse_cookie(resp)
+    cookie_hash = CookieHash.new
+    resp.get_fields('Set-Cookie').each { |c| cookie_hash.add_cookies(c) }
+    cookie_hash
+  end
+end
+
+tripit = TripIt.new('email', 'password')
+puts "Logged in: #{tripit.logged_in?}"

data/httparty-0.24.2/examples/twitter.rb

@@ -0,0 +1,31 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+require 'pp'
+config = YAML.load(File.read(File.join(ENV['HOME'], '.twitter')))
+
+class Twitter
+  include HTTParty
+  base_uri 'twitter.com'
+
+  def initialize(u, p)
+    @auth = {username: u, password: p}
+  end
+
+  # which can be :friends, :user or :public
+  # options[:query] can be things like since, since_id, count, etc.
+  def timeline(which = :friends, options = {})
+    options.merge!({ basic_auth: @auth })
+    self.class.get("/statuses/#{which}_timeline.json", options)
+  end
+
+  def post(text)
+    options = { query: { status: text }, basic_auth: @auth }
+    self.class.post('/statuses/update.json', options)
+  end
+end
+
+twitter = Twitter.new(config['email'], config['password'])
+pp twitter.timeline
+# pp twitter.timeline(:friends, query: {since_id: 868482746})
+# pp twitter.timeline(:friends, query: 'since_id=868482746')
+# pp twitter.post('this is a test of 0.2.0')

data/httparty-0.24.2/examples/whoismyrep.rb

@@ -0,0 +1,10 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+require 'pp'
+
+class Rep
+  include HTTParty
+end
+
+pp Rep.get('http://whoismyrepresentative.com/getall_mems.php?zip=46544')
+pp Rep.get('http://whoismyrepresentative.com/getall_mems.php', query: { zip: 46544 })

data/httparty-0.24.2/httparty.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+$LOAD_PATH.push File.expand_path("../lib", __FILE__)
+require "httparty/version"
+
+Gem::Specification.new do |s|
+  s.name        = "httparty"
+  s.version     = HTTParty::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.licenses    = ['MIT']
+  s.authors     = ["John Nunemaker", "Sandro Turriate"]
+  s.email       = ["nunemaker@gmail.com"]
+  s.homepage    = "https://github.com/jnunemaker/httparty"
+  s.summary     = 'Makes http fun! Also, makes consuming restful web services dead easy.'
+  s.description = 'Makes http fun! Also, makes consuming restful web services dead easy.'
+  s.metadata["changelog_uri"] = 'https://github.com/jnunemaker/httparty/releases'
+
+  s.required_ruby_version     = '>= 2.7.0'
+
+  s.add_dependency 'csv'
+  s.add_dependency 'multi_xml', ">= 0.5.2"
+  s.add_dependency 'mini_mime', ">= 1.0.0"
+
+  # If this line is removed, all hard partying will cease.
+  s.post_install_message = "When you HTTParty, you must party hard!"
+
+  all_files = `git ls-files`.split("\n")
+  test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+  s.files         = all_files - test_files
+  s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end