simple_oauth 0.1.0

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Steve Richert
+
+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.

data/README.rdoc

@@ -0,0 +1,17 @@
+= simple_oauth
+
+Simply builds and verifies OAuth headers
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Steve Richert. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,55 @@
+require './lib/simple_oauth'
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = 'simple_oauth'
+    gem.version = SimpleOAuth::Version::STRING
+    gem.summary = 'Simply builds and verifies OAuth headers'
+    gem.description = 'Simply builds and verifies OAuth headers'
+    gem.email = 'steve.richert@gmail.com'
+    gem.homepage = 'http://github.com/laserlemon/simple_oauth'
+    gem.authors = ['Steve Richert']
+    gem.add_development_dependency 'mocha'
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts 'Jeweler is not available. Install it with: gem install jeweler'
+end
+
+Rake::TestTask.new do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |rcov|
+    rcov.libs << 'lib' << 'test'
+    rcov.pattern = 'test/**/*_test.rb'
+    rcov.verbose = true
+    rcov.rcov_opts << '--exclude "gems/*"'
+  end
+rescue LoadError
+  task :rcov do
+    abort 'RCov is not available. Install it with: gem install rcov'
+  end
+end
+
+Rake::RDocTask.new do |rdoc|
+  version = SimpleOAuth::Version::STRING
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "simple_oauth #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/init.rb

@@ -0,0 +1 @@
+require File.expand_path('../lib/simple_oauth', __FILE__)

data/lib/simple_oauth.rb

@@ -0,0 +1,117 @@
+require 'base64'
+require 'cgi'
+require 'openssl'
+require 'uri'
+
+module SimpleOAuth
+  module Version
+    MAJOR = 0
+    MINOR = 1
+    PATCH = 0
+    STRING = [MAJOR, MINOR, PATCH].join('.')
+  end
+
+  class Header
+    ATTRIBUTE_KEYS = [:consumer_key, :nonce, :signature_method, :timestamp, :token, :version]
+
+    def self.default_options
+      {
+        :nonce => OpenSSL::Random.random_bytes(16).unpack('H*')[0],
+        :signature_method => 'HMAC-SHA1',
+        :timestamp => Time.now.to_i.to_s,
+        :version => '1.0'
+      }
+    end
+
+    def self.encode(value)
+      URI.encode(value.to_s, /[^\w\-\.\~]/)
+    end
+
+    def self.decode(value)
+      URI.decode(value.to_s)
+    end
+
+    def self.parse(header)
+      header.to_s.sub(/^OAuth\s/, '').split(', ').inject({}) do |attributes, pair|
+        match = pair.match(/^(\w+)\=\"([^\"]*)\"$/)
+        attributes.merge(match[1].sub(/^oauth_/, '').to_sym => decode(match[2]))
+      end
+    end
+
+    attr_reader :method, :params, :options
+
+    def initialize(method, url, params, oauth = {})
+      @method = method.to_s.upcase
+      @uri = URI.parse(url).tap do |uri|
+        uri.scheme = uri.scheme.downcase
+        uri.normalize!
+        uri.fragment = nil
+      end
+      @params = params
+      @options = oauth.is_a?(Hash) ? self.class.default_options.merge(oauth) : self.class.parse(oauth)
+    end
+
+    def url
+      @uri.dup.tap{|u| u.query = nil }.to_s
+    end
+
+    def to_s
+      "OAuth #{normalized_attributes}"
+    end
+
+    def valid?(secrets = {})
+      original_options = options.dup
+      options.merge!(secrets)
+      valid = options[:signature] == signature
+      options.replace(original_options)
+      valid
+    end
+
+    private
+      def normalized_attributes
+        signed_attributes.sort_by(&:to_s).map{|k,v| %(#{k}="#{self.class.encode(v)}") }.join(', ')
+      end
+
+      def signed_attributes
+        attributes.merge(:oauth_signature => signature)
+      end
+
+      def attributes
+        ATTRIBUTE_KEYS.inject({}){|a,k| options.key?(k) ? a.merge(:"oauth_#{k}" => options[k]) : a }
+      end
+
+      def signature
+        send(options[:signature_method].downcase.tr('-', '_') + '_signature')
+      end
+
+      def hmac_sha1_signature
+        Base64.encode64(OpenSSL::HMAC.digest(OpenSSL::Digest::Digest.new('sha1'), secret, signature_base)).chomp
+      end
+
+      def rsa_sha1_signature
+        Base64.encode64(OpenSSL::HMAC.digest(OpenSSL::Digest::Digest.new('sha1'), options[:private_key].to_s, signature_base)).chomp
+      end
+
+      def secret
+        options.values_at(:consumer_secret, :token_secret).map{|v| self.class.encode(v) }.join('&')
+      end
+
+      alias_method :plaintext_signature, :secret
+
+      def signature_base
+        [method, url, normalized_params].map{|v| self.class.encode(v) }.join('&')
+      end
+
+      def normalized_params
+        signature_params.sort_by(&:to_s).map{|p| p.map{|v| self.class.encode(v) }.join('=') }.join('&')
+      end
+
+      def signature_params
+        attributes.to_a + params.to_a + url_params
+      end
+
+      def url_params
+        CGI.parse(@uri.query || '').inject([]){|p,(k,vs)| p + vs.map{|v| [k, v] } }
+      end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,4 @@
+require 'test/unit'
+require 'simple_oauth'
+require 'rubygems'
+require 'mocha'

data/test/simple_oauth_test.rb

@@ -0,0 +1,260 @@
+require 'helper'
+
+class SimpleOAuthTest < Test::Unit::TestCase
+  def test_initialize
+    header = SimpleOAuth::Header.new(:get, 'HTTPS://api.TWITTER.com:443/1/statuses/friendships.json#anchor', {})
+
+    # HTTP method should be an uppercase string.
+    #
+    # See: http://oauth.net/core/1.0/#rfc.section.9.1.3
+    assert_equal 'GET', header.method
+
+    # Request URL should downcase the scheme and authority parts as well as
+    # remove the query and fragment parts.
+    #
+    # See: http://oauth.net/core/1.0/#rfc.section.9.1.2
+    assert_equal 'https://api.twitter.com/1/statuses/friendships.json', header.url
+  end
+
+  def test_default_options
+    # Default header options should change with each call due to generation of
+    # a unique "timestamp" and "nonce" value combination.
+    default_options = SimpleOAuth::Header.default_options
+    assert_not_equal default_options, SimpleOAuth::Header.default_options
+
+    SimpleOAuth::Header.stubs(:default_options).returns(default_options)
+    header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friendships.json', {})
+
+    # Given no options argument, header options defer to the default options.
+    assert_equal default_options, header.options
+
+    # Default options should include a signature method and the OAuth version.
+    assert_equal 'HMAC-SHA1', default_options[:signature_method]
+    assert_equal '1.0', default_options[:version]
+  end
+
+  def test_attributes
+    attribute_options = SimpleOAuth::Header::ATTRIBUTE_KEYS.inject({}){|o,a| o.merge(a => a.to_s.upcase) }
+    options = attribute_options.merge(:other => 'OTHER')
+    header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friendships.json', {}, options)
+    attributes = header.send(:attributes)
+
+    # OAuth header attributes are all to begin with the "oauth_" prefix.
+    assert attributes.all?{|k,v| k.to_s =~ /^oauth_/ }
+
+    # Custom options not included in the list of valid attribute keys should
+    # not be included in the header attributes.
+    assert !attributes.key?(:oauth_other)
+
+    # Valid attribute option values should be preserved.
+    assert_equal attribute_options.size, attributes.size
+    assert attributes.all?{|k,v| k.to_s == "oauth_#{v.downcase}" }
+  end
+
+  def test_encode
+    # Non-word characters should be URL encoded...
+    [' ', '!', '@', '#', '$', '%', '^', '&'].each do |character|
+      encoded = SimpleOAuth::Header.encode(character)
+      assert_not_equal character, encoded
+      assert_equal URI.encode(character, /.*/), encoded
+    end
+
+    # ...except for the "-", "." and "~" characters.
+    ['-', '.', '~'].each do |character|
+      assert_equal character, SimpleOAuth::Header.encode(character)
+    end
+  end
+
+  def test_url_params
+    # A URL with no query parameters should produce empty +url_params+
+    header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friendships.json', {})
+    assert_equal [], header.send(:url_params)
+
+    # A URL with query parameters should return a hash having array values
+    # containing the given query parameters.
+    header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friendships.json?test=TEST', {})
+    url_params = header.send(:url_params)
+    assert_kind_of Array, url_params
+    assert_equal [['test', 'TEST']], url_params
+
+    # If a query parameter is repeated, the values should be sorted.
+    header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friendships.json?test=1&test=2', {})
+    assert_equal [['test', '1'], ['test', '2']], header.send(:url_params)
+  end
+
+  def test_signature_params
+    header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friendships.json', {})
+    header.stubs(:attributes).returns(:attribute => 'ATTRIBUTE')
+    header.stubs(:params).returns('param' => 'PARAM')
+    header.stubs(:url_params).returns([['url_param', '1'], ['url_param', '2']])
+
+    # Should combine OAuth header attributes, body parameters and URL
+    # parameters into an array of key value pairs.
+    signature_params = header.send(:signature_params)
+    assert_kind_of Array, signature_params
+    assert_equal [:attribute, 'param', 'url_param', 'url_param'], signature_params.map(&:first)
+    assert_equal ['ATTRIBUTE', 'PARAM', '1', '2'], signature_params.map(&:last)
+  end
+
+  def test_normalized_params
+    header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friendships.json', {})
+    header.stubs(:signature_params).returns([['A', '4'], ['B', '3'], ['B', '2'], ['C', '1'], ['D[]', '0 ']])
+
+    # The +normalized_params+ string should join key=value pairs with
+    # ampersands.
+    signature_params = header.send(:signature_params)
+    normalized_params = header.send(:normalized_params)
+    parts = normalized_params.split('&')
+    pairs = parts.map{|p| p.split('=') }
+    assert_kind_of String, normalized_params
+    assert_equal signature_params.size, parts.size
+    assert pairs.all?{|p| p.size == 2 }
+
+    # The signature parameters should be sorted and the keys/values URL encoded
+    # first.
+    assert_equal signature_params.sort_by(&:to_s), pairs.map{|k,v| [URI.decode(k), URI.decode(v)] }
+  end
+
+  def test_signature_base
+    header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friendships.json', {})
+    header.stubs(:method).returns('METHOD')
+    header.stubs(:url).returns('URL')
+    header.stubs(:normalized_params).returns('NORMALIZED_PARAMS')
+
+    # Should combine HTTP method, URL and normalized parameters string using
+    # ampersands.
+    assert_equal 'METHOD&URL&NORMALIZED_PARAMS', header.send(:signature_base)
+
+    header.stubs(:method).returns('ME#HOD')
+    header.stubs(:url).returns('U#L')
+    header.stubs(:normalized_params).returns('NORMAL#ZED_PARAMS')
+
+    # Each of the three combined values should be URL encoded.
+    assert_equal 'ME%23HOD&U%23L&NORMAL%23ZED_PARAMS', header.send(:signature_base)
+  end
+
+  def test_secret
+    header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friendships.json', {})
+    header.stubs(:options).returns(:consumer_secret => 'CONSUMER_SECRET', :token_secret => 'TOKEN_SECRET')
+
+    # Should combine the consumer and token secrets with an ampersand.
+    assert_equal 'CONSUMER_SECRET&TOKEN_SECRET', header.send(:secret)
+
+    header.stubs(:options).returns(:consumer_secret => 'CONSUM#R_SECRET', :token_secret => 'TOKEN_S#CRET')
+
+    # Should URL encode each secret value before combination.
+    assert_equal 'CONSUM%23R_SECRET&TOKEN_S%23CRET', header.send(:secret)
+  end
+
+  def test_hmac_sha1_signature
+    # Reproduce an actual successful call to the Twitter API using the
+    # HMAC-SHA1 signature method, GETting a list of friends.
+    options = {
+      :consumer_key => '8karQBlMg6gFOwcf8kcoYw',
+      :consumer_secret => '3d0vcHyUiiqADpWxolW8nlDIpSWMlyK7YNgc5Qna2M',
+      :nonce => '547fed103e122eecf84c080843eedfe6',
+      #:signature_method => 'HMAC-SHA1',
+      :timestamp => '1286830180',
+      :token => '201425800-Sv4sTcgoffmHGkTCue0JnURT8vrm4DiFAkeFNDkh',
+      :token_secret => 'T5qa1tF57tfDzKmpM89DHsNuhgOY4NT6DlNLsTFcuQ'
+    }
+    successful = 'OAuth oauth_consumer_key="8karQBlMg6gFOwcf8kcoYw", oauth_nonce="547fed103e122eecf84c080843eedfe6", oauth_signature="i9CT6ahDRAlfGX3hKYf78QzXsaw%3D", oauth_signature_method="HMAC-SHA1", oauth_timestamp="1286830180", oauth_token="201425800-Sv4sTcgoffmHGkTCue0JnURT8vrm4DiFAkeFNDkh", oauth_version="1.0"'
+    header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friends.json', {}, options)
+    assert_equal successful, header.to_s
+
+    # Reproduce a successful Twitter call, POSTing a new status.
+    options.merge!(
+      :nonce => 'b40a3e0f18590ecdcc0e273f7d7c82f8',
+      :timestamp => '1286830181'
+    )
+    successful = 'OAuth oauth_consumer_key="8karQBlMg6gFOwcf8kcoYw", oauth_nonce="b40a3e0f18590ecdcc0e273f7d7c82f8", oauth_signature="mPqSFKejrWWk3ZT9bTQjhO5b2xI%3D", oauth_signature_method="HMAC-SHA1", oauth_timestamp="1286830181", oauth_token="201425800-Sv4sTcgoffmHGkTCue0JnURT8vrm4DiFAkeFNDkh", oauth_version="1.0"'
+    header = SimpleOAuth::Header.new(:post, 'https://api.twitter.com/1/statuses/update.json', {:status => 'hi, again'}, options)
+    assert_equal successful, header.to_s
+  end
+
+  def test_signature
+    header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friends.json', {}, :signature_method => 'HMAC-SHA1')
+    header.expects(:hmac_sha1_signature).once.returns('HMAC_SHA1_SIGNATURE')
+    assert_equal 'HMAC_SHA1_SIGNATURE', header.send(:signature)
+
+    header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friends.json', {}, :signature_method => 'RSA-SHA1', :private_key => 'PRIVATE_KEY')
+    header.expects(:rsa_sha1_signature).once.returns('RSA_SHA1_SIGNATURE')
+    assert_equal 'RSA_SHA1_SIGNATURE', header.send(:signature)
+
+    header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friends.json', {}, :signature_method => 'PLAINTEXT')
+    header.expects(:plaintext_signature).once.returns('PLAINTEXT_SIGNATURE')
+    assert_equal 'PLAINTEXT_SIGNATURE', header.send(:signature)
+  end
+
+  def test_signed_attributes
+    header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friends.json', {})
+    assert header.send(:signed_attributes).keys.include?(:oauth_signature)
+  end
+
+  def test_normalized_attributes
+    header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friends.json', {})
+    header.stubs(:signed_attributes).returns(:d => 1, :c => 2, :b => 3, :a => 4)
+
+    # Should return the OAuth header attributes, sorted by name, with quoted
+    # values and comma-separated.
+    assert_equal 'a="4", b="3", c="2", d="1"', header.send(:normalized_attributes)
+
+    # Values should also be URL encoded.
+    header.stubs(:signed_attributes).returns(1 => '!', 2 => '@', 3 => '#', 4 => '$')
+    assert_equal '1="%21", 2="%40", 3="%23", 4="%24"', header.send(:normalized_attributes)
+  end
+
+  def test_to_s
+    header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friends.json', {})
+    assert_equal "OAuth #{header.send(:normalized_attributes)}", header.to_s
+  end
+
+  def test_parse
+    header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friends.json', {})
+    parsed_options = SimpleOAuth::Header.parse(header)
+
+    # Parsed options should be a Hash.
+    assert_kind_of Hash, parsed_options
+
+    # Parsed options should equal the options used to build the header, along
+    # with the additional signature.
+    assert_equal header.options, parsed_options.reject{|k,v| k == :signature }
+  end
+
+  def test_valid
+    # With no consumer or token secrets, built headers should be valid when
+    # parsed without secrets, regardless of signature method.
+    ['HMAC-SHA1', 'RSA-SHA1', 'PLAINTEXT'].each do |signature_method|
+      header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friends.json', {}, :signature_method => signature_method)
+      parsed_header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friends.json', {}, header)
+      assert_equal signature_method, parsed_header.options[:signature_method]
+      assert parsed_header.valid?
+    end
+
+    # When given consumer and token secrets, those secrets must be passed into
+    # the parsed header validation in order for the validity check to pass.
+    secrets = {:consumer_secret => 'CONSUMER_SECRET', :token_secret => 'TOKEN_SECRET'}
+    header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friends.json', {}, secrets)
+    parsed_header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friends.json', {}, header)
+    assert !parsed_header.valid?
+    assert parsed_header.valid?(secrets)
+
+    # Using the RSA-SHA1 signature method, a private key should be included
+    # with the options. When parsing the header on the server side, the
+    # the private key must be included in order for the header to validate.
+    secrets = {:private_key => 'PRIVATE_KEY'}
+    header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friends.json', {}, secrets.merge(:signature_method => 'RSA-SHA1'))
+    parsed_header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friends.json', {}, header)
+    assert !parsed_header.valid?
+    assert parsed_header.valid?(secrets)
+
+    # Like the default HMAC-RSA1 signature method, the PLAINTEXT method
+    # requires use of both a consumer secret and a token secret. A parsed
+    # header will not validate without these secret values.
+    secrets = {:consumer_secret => 'CONSUMER_SECRET', :token_secret => 'TOKEN_SECRET'}
+    header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friends.json', {}, secrets.merge(:signature_method => 'PLAINTEXT'))
+    parsed_header = SimpleOAuth::Header.new(:get, 'https://api.twitter.com/1/statuses/friends.json', {}, header)
+    assert !parsed_header.valid?
+    assert parsed_header.valid?(secrets)
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification 
+name: simple_oauth
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Steve Richert
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-11 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: Simply builds and verifies OAuth headers
+email: steve.richert@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- init.rb
+- lib/simple_oauth.rb
+- test/helper.rb
+- test/simple_oauth_test.rb
+has_rdoc: true
+homepage: http://github.com/laserlemon/simple_oauth
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Simply builds and verifies OAuth headers
+test_files: 
+- test/helper.rb
+- test/simple_oauth_test.rb