plyom_user 0.0.1 → 0.0.2

data/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/bin/httparty

@@ -0,0 +1,114 @@
+#!/usr/bin/env ruby
+
+require "optparse"
+require "pp"
+
+$:.unshift(File.join(File.dirname(__FILE__), "/../lib"))
+require "httparty"
+
+opts = {
+  :action => :get,
+  :headers => {},
+  :verbose => false
+}
+
+OptionParser.new do |o|
+  o.banner = "USAGE: #{$0} [options] [url]"
+
+  o.on("-f",
+       "--format [FORMAT]",
+       "Output format to use instead of pretty-print ruby: " +
+       "plain, json or xml") do |f|
+    opts[:output_format] = f.downcase.to_sym
+  end
+
+  o.on("-a",
+       "--action [ACTION]",
+       "HTTP action: get (default), post, put, delete, head, or options") do |a|
+    opts[:action] = a.downcase.to_sym
+  end
+
+  o.on("-d",
+       "--data [BODY]",
+       "Data to put in request body (prefix with '@' for file)") do |d|
+    if d =~ /^@/
+      opts[:body] = open(d[1..-1]).read
+    else
+      opts[:body] = d
+    end
+  end
+
+  o.on("-H", "--header [NAME:VALUE]", "Additional HTTP headers in NAME:VALUE form") do |h|
+    abort "Invalid header specification, should be Name:Value" unless h =~ /.+:.+/
+    name, value = h.split(':')
+    opts[:headers][name.strip] = value.strip
+  end
+
+  o.on("-v", "--verbose", "If set, print verbose output") do |v|
+    opts[:verbose] = true
+  end
+
+  o.on("-u", "--user [CREDS]", "Use basic authentication. Value should be user:password") do |u|
+    abort "Invalid credentials format. Must be user:password" unless u =~ /.*:.+/
+    user, password = u.split(':')
+    opts[:basic_auth] = { :username => user, :password => password }
+  end
+
+  o.on("-r", "--response-code", "Command fails if response code >= 400") do
+    opts[:response_code] = true
+  end
+
+  o.on("-h", "--help", "Show help documentation") do |h|
+    puts o
+    exit
+  end
+end.parse!
+
+
+if ARGV.empty?
+  STDERR.puts "You need to provide a URL"
+  STDERR.puts "USAGE: #{$0} [options] [url]"
+end
+
+def dump_headers(response)
+  resp_type = Net::HTTPResponse::CODE_TO_OBJ[response.code.to_s]
+  puts "#{response.code} #{resp_type.to_s.sub(/^Net::HTTP/, '')}"
+  response.headers.each do |n,v|
+    puts "#{n}: #{v}"
+  end
+  puts
+end
+
+if opts[:verbose]
+  puts "#{opts[:action].to_s.upcase} #{ARGV.first}"
+  opts[:headers].each do |n,v|
+    puts "#{n}: #{v}"
+  end
+  puts
+end
+
+response = HTTParty.send(opts[:action], ARGV.first, opts)
+if opts[:output_format].nil?
+  dump_headers(response) if opts[:verbose]
+  pp response
+else
+  print_format = opts[:output_format]
+  dump_headers(response) if opts[:verbose]
+
+  case opts[:output_format]
+    when :json
+      begin
+        require 'json'
+        puts JSON.pretty_generate(response.delegate)
+      rescue LoadError
+        puts YAML.dump(response.delegate)
+      end
+    when :xml
+      require 'rexml/document'
+      REXML::Document.new(response.body).write(STDOUT, 2)
+      puts
+    else
+      puts response
+  end
+end
+exit false if opts[:response_code] && response.code >= 400

data/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/cucumber.yml

@@ -0,0 +1 @@
+default: features --format progress

data/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/examples/aaws.rb

@@ -0,0 +1,32 @@
+require 'rubygems'
+require 'active_support'
+
+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'], '.aaws')))
+
+module AAWS
+  class Book
+    include HTTParty
+    base_uri 'http://ecs.amazonaws.com'
+    default_params :Service => 'AWSECommerceService', :Operation => 'ItemSearch', :SearchIndex => 'Books'
+    
+    def initialize(key)
+      self.class.default_params :AWSAccessKeyId => key
+    end
+    
+    def search(options={})
+      raise ArgumentError, 'You must search for something' if options[:query].blank?
+      
+      # amazon uses nasty camelized query params
+      options[:query] = options[:query].inject({}) { |h, q| h[q[0].to_s.camelize] = q[1]; h }
+      
+      # make a request and return the items (NOTE: this doesn't handle errors at this point)
+      self.class.get('/onca/xml', options)['ItemSearchResponse']['Items']
+    end
+  end
+end
+
+aaws = AAWS::Book.new(config[:access_key])
+pp aaws.search(:query => {:title => 'Ruby On Rails'})

data/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/examples/basic.rb

@@ -0,0 +1,32 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+require 'pp'
+
+# You can also use post, put, delete, head, options in the same fashion
+response = HTTParty.get('http://twitter.com/statuses/public_timeline.json')
+puts response.body, response.code, response.message, response.headers.inspect
+
+response.each do |item|
+  puts item['user']['screen_name']
+end
+
+# An example post to a minimal rails app in the development environment
+# Note that "skip_before_filter :verify_authenticity_token" must be set in the
+# "pears" controller for this example
+
+class Partay
+  include HTTParty
+  base_uri 'http://localhost:3000'
+end
+
+options = {
+  :body => {
+    :pear => { # your resource
+      :foo => '123', # your columns/data
+      :bar => 'second',
+      :baz => 'last thing'
+    }
+  }
+}
+
+pp Partay.post('/pears.xml', options)

data/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/examples/crack.rb

@@ -0,0 +1,19 @@
+require 'rubygems'
+require 'crack'
+
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+require 'pp'
+
+class Rep
+  include HTTParty
+
+  parser(
+    Proc.new do |body, format|
+      Crack::XML.parse(body)
+    end
+  )
+end
+
+pp Rep.get('http://whoismyrepresentative.com/whoismyrep.php?zip=46544')
+pp Rep.get('http://whoismyrepresentative.com/whoismyrep.php', :query => {:zip => 46544})

data/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/examples/custom_parsers.rb

@@ -0,0 +1,67 @@
+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.new do |body, format|
+      case format
+      when :json
+        body.to_json
+      when :xml
+        body.to_xml
+      else
+        body
+      end
+    end
+  )
+end

data/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/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/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/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/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/examples/headers_and_user_agents.rb

@@ -0,0 +1,6 @@
+# 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.
+
+require 'httparty'
+
+APPLICATION_NAME = "Httparty" 
+response = HTTParty.get('http://example.com', :headers => {"User-Agent" => APPLICATION_NAME})

data/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/examples/nokogiri_html_parser.rb

@@ -0,0 +1,22 @@
+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
+  SupportedFormats.merge!('text/html' => :html)
+
+  def html
+    Nokogiri::HTML(body)
+  end
+end
+
+class Page
+  include HTTParty
+  parser HtmlParserIncluded
+end
+
+pp Page.get('http://www.google.com')

data/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/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/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/examples/tripit_sign_in.rb

@@ -0,0 +1,33 @@
+dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+require File.join(dir, 'httparty')
+
+class TripIt
+  include HTTParty
+  base_uri 'http://www.tripit.com'
+  debug_output
+
+  def initialize(email, password)
+    @email = email
+    response = self.class.get('/account/login')
+    response = self.class.post(
+      '/account/login',
+      :body => {
+        :login_email_address => email,
+        :login_password => password
+      },
+      :headers => {'Cookie' => response.headers['Set-Cookie']}
+    )
+    @cookie = response.request.options[:headers]['Cookie']
+  end
+
+  def account_settings
+    self.class.get('/account/edit', :headers => {'Cookie' => @cookie})
+  end
+
+  def logged_in?
+    account_settings.include? "You're logged in as #{@email}"
+  end
+end
+
+tripit = TripIt.new('email', 'password')
+puts "Logged in: #{tripit.logged_in?}"

data/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/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/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/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/whoismyrep.php?zip=46544')
+pp Rep.get('http://whoismyrepresentative.com/whoismyrep.php', :query => {:zip => 46544})

data/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/features/basic_authentication.feature

@@ -0,0 +1,20 @@
+Feature:  Basic Authentication
+
+  As a developer
+  I want to be able to use a service that requires Basic Authentication
+  Because that is not an uncommon requirement
+
+  Scenario: Passing no credentials to a page requiring Basic Authentication
+    Given a restricted page at '/basic_auth.html'
+    When I call HTTParty#get with '/basic_auth.html'
+    Then it should return a response with a 401 response code
+
+  Scenario: Passing proper credentials to a page requiring Basic Authentication
+    Given a remote service that returns 'Authenticated Page'
+    And that service is accessed at the path '/basic_auth.html'
+    And that service is protected by Basic Authentication
+    And that service requires the username 'jcash' with the password 'maninblack'
+    When I call HTTParty#get with '/basic_auth.html' and a basic_auth hash:
+       | username | password   |
+       | jcash    | maninblack |
+    Then the return value should match 'Authenticated Page'

data/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/features/command_line.feature

@@ -0,0 +1,7 @@
+Feature: Command Line
+
+  As a developer
+  I want to be able to harness the power of HTTParty from the command line
+  Because that would make quick testing and debugging easy
+  And 'easy' is my middle name
+  And I'm kidding it's actually 'Danger'!

data/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/features/deals_with_http_error_codes.feature

@@ -0,0 +1,26 @@
+Feature: Deals with HTTP error codes
+
+  As a developer
+  I want to be informed of non-successful responses
+  Because sometimes thing explode
+  And I should probably know what happened
+
+  Scenario: A response of '404 - Not Found'
+    Given a remote service that returns a 404 status code
+    And that service is accessed at the path '/404_service.html'
+    When I call HTTParty#get with '/404_service.html'
+    Then it should return a response with a 404 response code
+
+  Scenario: A response of '500 - Internal Server Error'
+    Given a remote service that returns a 500 status code
+    And that service is accessed at the path '/500_service.html'
+    When I call HTTParty#get with '/500_service.html'
+    Then it should return a response with a 500 response code
+
+  Scenario: A non-successful response where I need the body
+    Given a remote service that returns a 400 status code
+    And the response from the service has a body of 'Bad response'
+    And that service is accessed at the path '/400_service.html'
+    When I call HTTParty#get with '/400_service.html'
+    Then it should return a response with a 400 response code
+    And the return value should match 'Bad response'

data/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/features/digest_authentication.feature

@@ -0,0 +1,20 @@
+Feature:  Digest Authentication
+
+  As a developer
+  I want to be able to use a service that requires Digest Authentication
+  Because that is not an uncommon requirement
+
+  Scenario: Passing no credentials to a page requiring Digest Authentication
+    Given a restricted page at '/digest_auth.html'
+    When I call HTTParty#get with '/digest_auth.html'
+    Then it should return a response with a 401 response code
+
+  Scenario: Passing proper credentials to a page requiring Digest Authentication
+    Given a remote service that returns 'Digest Authenticated Page'
+    And that service is accessed at the path '/digest_auth.html'
+    And that service is protected by Digest Authentication
+    And that service requires the username 'jcash' with the password 'maninblack'
+    When I call HTTParty#get with '/digest_auth.html' and a digest_auth hash:
+       | username | password   |
+       | jcash    | maninblack |
+    Then the return value should match 'Digest Authenticated Page'

data/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/features/handles_compressed_responses.feature

@@ -0,0 +1,19 @@
+Feature: Handles Compressed Responses
+
+  In order to save bandwidth
+  As a developer
+  I want to uncompress compressed responses
+
+  Scenario: Supports deflate encoding
+    Given a remote deflate service
+    And the response from the service has a body of '<h1>Some HTML</h1>'
+    And that service is accessed at the path '/deflate_service.html'
+    When I call HTTParty#get with '/deflate_service.html'
+    Then the return value should match '<h1>Some HTML</h1>'
+
+  Scenario: Supports gzip encoding
+    Given a remote gzip service
+    And the response from the service has a body of '<h1>Some HTML</h1>'
+    And that service is accessed at the path '/gzip_service.html'
+    When I call HTTParty#get with '/gzip_service.html'
+    Then the return value should match '<h1>Some HTML</h1>'

data/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/features/handles_multiple_formats.feature

@@ -0,0 +1,34 @@
+Feature: Handles Multiple Formats
+
+  As a developer
+  I want to be able to consume remote services of many different formats
+  And I want those formats to be automatically detected and handled
+  Because web services take many forms
+  And I don't want to have to do any extra work
+
+  Scenario: An HTML service
+    Given a remote service that returns '<h1>Some HTML</h1>'
+    And that service is accessed at the path '/html_service.html'
+    And the response from the service has a Content-Type of 'text/html'
+    When I call HTTParty#get with '/html_service.html'
+    Then it should return a String
+    And the return value should match '<h1>Some HTML</h1>'
+
+  Scenario: A JSON service
+    Given a remote service that returns '{ "jennings": "waylon", "cash": "johnny" }'
+    And that service is accessed at the path '/service.json'
+    And the response from the service has a Content-Type of 'application/json'
+    When I call HTTParty#get with '/service.json'
+    Then it should return a Hash equaling:
+       | key      | value  |
+       | jennings | waylon |
+       | cash     | johnny |
+
+  Scenario: An XML Service
+    Given a remote service that returns '<singer>waylon jennings</singer>'
+    And that service is accessed at the path '/service.xml'
+    And the response from the service has a Content-Type of 'text/xml'
+    When I call HTTParty#get with '/service.xml'
+    Then it should return a Hash equaling:
+       | key    | value           |
+       | singer | waylon jennings |

data/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/features/steps/env.rb

@@ -0,0 +1,22 @@
+require 'mongrel'
+require './lib/httparty'
+require 'spec/expectations'
+
+Before do
+  def new_port
+    server = TCPServer.new('0.0.0.0', nil)
+    port = server.addr[1]
+  ensure
+    server.close
+  end
+
+  port = ENV["HTTPARTY_PORT"] || new_port
+  @host_and_port = "0.0.0.0:#{port}"
+  @server = Mongrel::HttpServer.new("0.0.0.0", port)
+  @server.run
+  @request_options = {}
+end
+
+After do
+  @server.stop
+end

data/vendor/bundle/ruby/2.0.0/gems/httparty-0.11.0/features/steps/httparty_response_steps.rb

@@ -0,0 +1,40 @@
+# Not needed anymore in ruby 2.0, but needed to resolve constants
+# in nested namespaces. This is taken from rails :)
+def constantize(camel_cased_word)
+  names = camel_cased_word.split('::')
+  names.shift if names.empty? || names.first.empty?
+
+  constant = Object
+  names.each do |name|
+    constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+  end
+  constant
+end
+
+
+Then /it should return an? (\w+)$/ do |class_string|
+  @response_from_httparty.should be_an_instance_of(class_string.class)
+end
+
+Then /the return value should match '(.*)'/ do |expected_text|
+  @response_from_httparty.should eql(expected_text)
+end
+
+Then /it should return a Hash equaling:/ do |hash_table|
+  @response_from_httparty.should be_an_instance_of(Hash)
+  @response_from_httparty.keys.length.should eql(hash_table.rows.length)
+  hash_table.hashes.each do |pair|
+    key, value = pair["key"], pair["value"]
+    @response_from_httparty.keys.should include(key)
+    @response_from_httparty[key].should eql(value)
+  end
+end
+
+Then /it should return a response with a (\d+) response code/ do |code|
+  @response_from_httparty.code.should eql(code.to_i)
+end
+
+Then /it should raise (?:an|a) ([\w:]+) exception/ do |exception|
+  @exception_from_httparty.should_not be_nil
+  @exception_from_httparty.should be_a constantize(exception)
+end