rack-picatcha 0.1.0

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 James Ayvaz
+
+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.md

@@ -0,0 +1,123 @@
+Dropin replacement for rack-recaptcha that uses picatcha verification.
+
+## How to Use
+
+### Configuration
+
+First, install the library with:
+    [sudo] gem install rack-picatcha
+
+You have to require 'rack-picatcha' in your gemfile.
+
+````ruby
+## Gemfile
+gem 'rack-picatcha', :require => 'rack/picatcha'
+````
+
+
+    Available options for `Rack::Picatcha` middleware are:
+
+    * :public_key -- your Picatcha API public key *(required)*
+    * :private_key -- your Picatcha API private key *(required)*
+    * :proxy_host -- the HTTP Proxy hostname *(optional)*
+    * :proxy_port -- the HTTP Proxy port *(optional)*
+    * :proxy_user -- the HTTP Proxy user *(optional, omit unless the proxy requires it)*
+    * :proxy_password -- the HTTP Proxy password *(optional, omit unless the proxy requires it)*
+
+Now configure your app to use the middleware. This might be different across each web framework.
+Only tested with Sinatra
+
+#### Sinatra
+
+````ruby
+## app.rb
+use Rack::Picatcha, :public_key => 'KEY', :private_key => 'SECRET'
+helpers Rack::Picatcha::Helpers
+````
+
+#### Padrino
+
+````ruby
+## app/app.rb
+use Rack::Picatcha, :public_key => 'KEY', :private_key => 'SECRET'
+helpers Rack::Picatcha::Helpers
+````
+
+
+#### Rails
+
+````ruby
+## application.rb:
+module YourRailsAppName
+  class Application < Rails::Application
+    ...
+    config.gem 'rack-picatcha', :lib => 'rack/picatcha'
+    config.middleware.use Rack::Picatcha, :public_key => 'KEY', :private_key => 'SECRET'
+  end
+end
+
+## application_helper.rb or whatever helper you want it in.
+module ApplicationHelper
+  include Rack::Picatcha::Helpers
+end
+
+## application_controller.rb or whatever controller you want it in.
+class ApplicationController < ActionController::Base
+  ...
+  include Rack::Picatcha::Helpers
+  ...
+end
+````
+
+### Helpers
+
+The `Rack::Picatcha::Helpers` module (for Sinatra, Rails, Padrino) adds these methods to your app:
+
+Return a picatcha form
+```ruby
+  picatcha_tag  :challenge, :public_key => PUBLIC_KEY
+```
+
+To test whether or not the verification passed, you can use:
+
+```ruby
+  picatcha_valid?
+```
+
+or
+ 
+```ruby
+  picatcha_valid? :picatcha => params[:picatcha], :private_key => "#{recaptcha_privatekey}"
+```
+
+The `picatcha_valid?` helper can also be overloaded during tests. You
+can set its response to either true or false by doing the following:
+
+```ruby
+ # Have picatcha_valid? return true
+ Rack::Picatcha.test_mode!
+
+ # Or have it return false
+ Rack::Picatcha.test_mode! :return => false
+```
+
+
+### Contributors
+
+James Ayvaz - [ayvazj](https://github.com/ayvazj)
+
+  * drop in replacement for rack-recaptcha
+
+#### 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) 2012 James Ayvaz. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,12 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.warning = true
+  test.verbose = true
+end
+
+task :default => [:test]

data/lib/rack/picatcha.rb

@@ -0,0 +1,146 @@
+require  File.expand_path '../picatcha/helpers', __FILE__
+require 'net/http'
+
+module Rack
+  class Picatcha
+    API_URL         = 'http://api.picatcha.com'
+    API_SECURE_URL  = 'https://api.picatcha.com'
+    VERIFY_URL      = 'http://api.picatcha.com/v'
+    CHALLENGE_FIELD = 'picatcha'
+
+    SKIP_VERIFY_ENV = ['test', 'cucumber']
+
+    class << self
+      attr_accessor :private_key, :public_key, :test_mode, :proxy_host, :proxy_port, :proxy_user, :proxy_password
+
+      def test_mode!(options = {})
+        value = options[:return]
+        self.test_mode = value.nil? ? true : options[:return]
+      end
+    end
+
+    # Initialize the Rack Middleware. Some of the available options are:
+    #   :public_key  -- your Picatcha API public key *(required)*
+    #   :private_key -- your Picatcha API private key *(required)*
+    #
+    def initialize(app,options = {})
+      @app = app
+      @paths = options[:paths] && [options[:paths]].flatten.compact
+      self.class.private_key = options[:private_key]
+      self.class.public_key = options[:public_key]
+      self.class.proxy_host = options[:proxy_host]
+      self.class.proxy_port = options[:proxy_port]
+      self.class.proxy_user = options[:proxy_user]
+      self.class.proxy_password = options[:proxy_password]
+    end
+
+    def call(env)
+#        LOGGER.debug "def call"
+      dup._call(env)
+    end
+
+    def _call(env)
+      request = Request.new(env)
+#      LOGGER.debug "def _call env=#{env} params=#{request.params}"
+      if request.params[CHALLENGE_FIELD]
+        value, msg = verify({
+          :request => request,
+          :ip => request.ip,
+          :challenge => request.params[CHALLENGE_FIELD]
+        })
+        env.merge!('picatcha.valid' => value == 'true', 'picatcha.msg' => msg)
+      end
+      @app.call(env)
+    end
+
+    def verify(options = {})
+      if !options.is_a? Hash
+        options = {:model => options}
+      end
+
+      model = options[:model]
+      request = options[:request]
+
+      return Rack::Picatcha.verify_picatcha({
+          :private_key => Rack::Picatcha.private_key,
+          :ipaddr => request.ip,
+          :proxy_host => self.class.proxy_host,
+          :proxy_port => self.class.proxy_port,
+          :proxy_user => self.class.proxy_user,
+          :proxy_password => self.class.proxy_password,
+          :picatcha => request.params["picatcha"]
+      })
+    end
+
+    def self.verify_picatcha(options = {})
+      if !options.is_a? Hash
+        options = {:model => options}
+      end
+
+      ipaddr = options[:ipaddr]
+      proxy_host = options[:proxy_host]
+      proxy_port = options[:proxy_port]
+      proxy_user = options[:proxy_user]
+      proxy_password = options[:proxy_password]
+
+      private_key = options[:private_key]
+      picatchadata = options[:picatcha]
+
+      data = {
+        "k" => private_key,
+        "ip" => ipaddr,
+        "ua"=> "Rack-Picatcha Ruby Gem",
+        "s" => picatchadata[:stages],  #the number of stages
+        "t" => picatchadata[:token],   #the challenge token
+        "r" => picatchadata[:r]        #the array of images
+      }
+       
+      payload = data.to_json
+#      LOGGER.debug "payload = #{payload}"
+
+      uri  = URI.parse(VERIFY_URL)
+      http = Net::HTTP.start(uri.host, uri.port)
+
+      if proxy_host && proxy_port
+        http = Net::HTTP.Proxy(proxy_host,
+                               proxy_port,
+                               proxy_user,
+                               proxy_password).start(uri.host, uri.port)
+      end
+
+      request           = Net::HTTP::Post.new(uri.path)
+      request.body      = payload
+      response          = http.request(request)
+
+      # debugging info
+#      LOGGER.debug "response.body = #{response.body}"
+          
+      if response.body !=nil
+        parsed_json = JSON(response.body)
+      else
+        return false, 'No reponse captured'
+      end
+          
+#      LOGGER.error "error? = #{parsed_json["e"]}"
+          
+      error = parsed_json["e"]
+          
+      # so far just a simple if.. else to check if the picatcha was 
+      # solved correctly. will revisit later and make it more
+      # verbose
+      if parsed_json["s"]==true
+        return true, ""
+      else
+        message = "Sorry, you incorrectly filled out Picatcha. Please try again."
+        message = I18n.translate(:'picatcha.errors.verification_failed', :default => message) if defined?(I18n)
+        return false, message
+      end
+    end
+  
+
+
+  
+    class PicatchaError < StandardError
+    end
+  end
+end

data/lib/rack/picatcha/helpers.rb

@@ -0,0 +1,90 @@
+require 'json'
+
+module Rack
+  class Picatcha
+    module Helpers
+
+      DEFAULT= {
+        :height => 300,
+        :width => 500,
+        :row => 3,
+        :cols => 5,
+        :format => '2',
+        :style => '#2a1f19',
+        :link => '1',
+        :img_size => '75',
+        :noise_level => '2',
+        :noise_type => '0',
+        :lang => 'en',
+        :lang_override => '0',
+        :ssl => false
+      }
+
+      # Helper method to output a picatcha form. Some of the available
+      # types you can have are:
+      #
+      # :challenge - Returns a javascript picatcha form
+      # :noscript  - Return a non-javascript picatcha form
+      # :ajax      - Return a ajax picatcha form
+      #
+      # You also have a few available options:
+      #
+      # For :challenge and :noscript
+      #  :public_key - Set the public key. Overrides the key set in Middleware option
+      def picatcha_tag(type= :noscript, options={})
+        # Default options
+        options = DEFAULT.merge(options)
+        options[:public_key] ||= Rack::Picatcha.public_key
+        path = options[:ssl] ? Rack::Picatcha::API_SECURE_URL : Rack::Picatcha::API_URL
+ 
+        raise PicatchaError, "No public key specified." unless options[:public_key].to_s != ''
+        error = options[:error] ||= (defined? flash ? flash[:picatcha_error] : "")
+        html  = ""
+        elm_id = "picatcha"
+  
+        html << <<-EOS
+            <script type="text/javascript" src="#{path}/static/client/jquery.min.js"></script>
+            <script type="text/javascript" src="#{path}/static/client/picatcha.js"></script>
+            <link href="#{path}/static/client/picatcha.css" rel="stylesheet" type="text/css">
+            <script>Picatcha.PUBLIC_KEY="#{options[:public_key]}";
+Picatcha.setCustomization({"format":"#{options[:format]}","color":"#{options[:style]}","link":"#{options[:link]}","image_size":"#{options[:img_size]}","lang":"#{options[:lang]}","langOverride":"#{options[:lang_override]}","noise_level":"#{options[:noise_level]}","noise_type":"#{options[:noise_type]}"});
+window.onload=function(){Picatcha.create("#{elm_id}", {});};</script>
+            <div id="#{elm_id}"></div>
+        EOS
+
+        if options[:display]
+          %{<script type="text/javascript">
+            var PicatchaOptions = #{options[:display].to_json};
+            </script>}.gsub(/^ +/, '')
+        else
+          ''
+        end + html
+      end
+
+      # Helper to return whether the picatcha was accepted.
+      def picatcha_valid?(options={})
+#        LOGGER.debug "def picatchs_valid? options=#{options}"
+        picatchadata = options[:picatcha] || ""
+        private_key = options[:private_key] || Rack::Picatcha.private_key
+        if picatchadata.to_s == "" then
+          test = Rack::Picatcha.test_mode
+          test.nil? ? request.env['picatcha.valid'] : test
+        else
+          retval, msg = Rack::Picatcha.verify_picatcha({
+            :private_key => private_key,
+            :ipaddr => request.ip,
+            :picatcha => picatchadata
+          })
+          return retval
+        end
+      end
+
+      private
+
+      def uri_parser
+        @uri_parser ||= URI.const_defined?(:Parser) ? URI::Parser.new : URI
+      end
+
+    end
+  end
+end

data/rack-picatcha.gemspec

@@ -0,0 +1,23 @@
+Gem::Specification.new do |s|
+  s.name = %q{rack-picatcha}
+  s.version = "0.1.0"
+  s.required_rubygems_version = ">=1.3.6"
+  s.authors = ["James Ayvaz"]
+  s.date = %q{2012-10-04}
+  s.description = %q{Rack middleware verification using Picatcha API.}
+  s.email = %q{james.ayvaz@gmail.com}
+  s.extra_rdoc_files = ["LICENSE", "README.md"]
+  s.files = %w{.gitignore LICENSE README.md Rakefile rack-picatcha.gemspec} + Dir.glob("{lib,test}/**/*")
+  s.homepage = %q{http://github.com/ayvazj/rack-picatcha}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Rack middleware for Picatcha}
+  s.test_files = Dir.glob("test/**/*")
+  s.add_runtime_dependency "json", ">= 0"
+  s.add_development_dependency "rake",      "~> 0.9.2"
+  s.add_development_dependency "riot",      "~> 0.12.3"
+  s.add_development_dependency "rack-test", "~> 0.5.7"
+  s.add_development_dependency "fakeweb",   "~> 1.3.0"
+  s.add_development_dependency "rr",        "~> 1.0.2"
+end

data/test/helpers_test.rb

@@ -0,0 +1,176 @@
+require File.expand_path '../teststrap', __FILE__
+
+class HelperTest
+  attr_accessor :request
+  include Rack::Picatcha::Helpers
+
+  def initialize
+    @request = HelperTest::Request.new
+  end
+
+  class Request
+    attr_accessor :env
+  end
+end
+
+
+# With "attr_accessor :request" HelperTest has "request" defined as a method
+# even when @request is set to nil
+#
+# defined?(request)
+# => method
+# request
+# => nil
+# self
+# => #<HelperTest:0x00000002125000 @request=nil>
+class HelperTestWithoutRequest
+  include Rack::Picatcha::Helpers
+end
+
+context "Rack::Picatcha::Helpers" do
+  helper(:helper_test) { HelperTest.new }
+
+  setup { Rack::Picatcha.public_key = '0'*40 }
+
+  context "picatcha_tag" do
+
+    context "ajax" do
+      context "with display" do
+        setup do
+          mock(helper_test.request.env).[]('picatcha.msg').returns(nil)
+          helper_test.picatcha_tag(:ajax,:display => {:theme => 'red'})
+        end
+
+        asserts_topic('has js').matches %r{picatcha_ajax.js}
+        asserts_topic('has div').matches %r{<div id="ajax_picatcha"></div>}
+        asserts_topic('has display').matches %r{PicatchaOptions}
+        asserts_topic('has theme').matches %r{"theme":"red"}
+      end
+
+      context "without display" do
+        setup do
+          mock(helper_test.request.env).[]('picatcha.msg').returns(nil)
+          helper_test.picatcha_tag(:ajax)
+        end
+
+        asserts_topic('has js').matches %r{picatcha_ajax.js}
+        asserts_topic('has div').matches %r{<div id="ajax_picatcha"></div>}
+        denies_topic('has display').matches %r{PicatchaOptions}
+        denies_topic('has theme').matches %r{"theme":"red"}
+      end
+    end
+
+    context "noscript" do
+      setup do
+        mock(helper_test.request.env).[]('picatcha.msg').returns(nil)
+        helper_test.picatcha_tag :noscript, :public_key => "hello_world_world", :language => :en
+      end
+
+      asserts_topic("iframe").matches %r{iframe}
+      asserts_topic("no script tag").matches %r{<noscript>}
+      asserts_topic("public key").matches %r{hello_world_world}
+      asserts_topic("has language").matches %r{hl=en}
+      denies_topic("has js").matches %r{picatcha_ajax.js}
+    end
+
+    context "challenge" do
+      setup do
+        mock(helper_test.request.env).[]('picatcha.msg').returns(nil)
+        helper_test.picatcha_tag(:challenge, :language => :en)
+      end
+
+      asserts_topic("has script tag").matches %r{script}
+      asserts_topic("has challenge js").matches %r{challenge}
+      denies_topic("has js").matches %r{picatcha_ajax.js}
+      denies_topic("has display").matches %r{PicatchaOptions}
+      asserts_topic("has public_key").matches %r{#{'0'*40}}
+      asserts_topic("has language").matches %r{hl=en}
+    end
+
+    context "server" do
+
+      asserts("using ssl url") do
+        mock(helper_test.request.env).[]('picatcha.msg').returns(nil)
+        helper_test.picatcha_tag(:challenge, :ssl => true)
+      end.matches %r{#{Rack::Picatcha::API_SECURE_URL}}
+
+      asserts("using non ssl url") do
+        mock(helper_test.request.env).[]('picatcha.msg').returns(nil)
+        helper_test.picatcha_tag(:ajax)
+      end.matches %r{#{Rack::Picatcha::API_URL}}
+    end
+
+  end
+
+  context "picatcha_tag_errors" do
+    context "challenge with error" do
+      setup do
+        mock(helper_test.request.env).[]('picatcha.msg').returns("Sample Error")
+        helper_test.picatcha_tag(:challenge)
+      end
+
+      asserts_topic("has script tag").matches %r{script}
+      asserts_topic("has challenge js").matches %r{challenge}
+      denies_topic("has js").matches %r{picatcha_ajax.js}
+      denies_topic("has display").matches %r{PicatchaOptions}
+      asserts_topic("has public_key").matches %r{#{'0'*40}}
+      asserts_topic("has previous error").matches %r{Sample%20Error}
+    end
+
+    context "noscript with error" do
+      setup do
+        mock(helper_test.request.env).[]('picatcha.msg').returns("Sample Error")
+        helper_test.picatcha_tag :noscript, :public_key => "hello_world_world"
+      end
+
+      asserts_topic("iframe").matches %r{iframe}
+      asserts_topic("no script tag").matches %r{<noscript>}
+      asserts_topic("public key").matches %r{hello_world_world}
+      denies_topic("has js").matches %r{picatcha_ajax.js}
+      asserts_topic("has previous error").matches %r{Sample%20Error}
+    end
+
+  end
+
+  context "picatcha_valid?" do
+
+    asserts "that it passes when picatcha.valid is true" do
+      Rack::Picatcha.test_mode = nil
+      mock(helper_test.request.env).[]('picatcha.valid').returns(true)
+      helper_test.picatcha_valid?
+    end
+
+    denies "that it passes when picatcha.valid is false" do
+      Rack::Picatcha.test_mode = nil
+      mock(helper_test.request.env).[]('picatcha.valid').returns(false)
+      helper_test.picatcha_valid?
+    end
+
+    asserts "that it passes when test mode set to pass" do
+      Rack::Picatcha.test_mode!
+      helper_test.picatcha_valid?
+    end
+
+    denies "that it passes when test mode set to fail" do
+      Rack::Picatcha.test_mode! :return => false
+      helper_test.picatcha_valid?
+    end
+
+  end
+end
+
+
+context Rack::Picatcha::Helpers do
+  helper(:helper_test) { HelperTestWithoutRequest.new }
+    context "request object not available.  Rack-picatcha shouldn't die" do
+      setup do
+        helper_test.picatcha_tag(:challenge)
+      end
+
+      asserts_topic("has script tag").matches %r{script}
+      asserts_topic("has challenge js").matches %r{challenge}
+      denies_topic("has js").matches %r{picatcha_ajax.js}
+      denies_topic("has display").matches %r{PicatchaOptions}
+      asserts_topic("has public_key").matches %r{#{'0'*40}}
+    end
+end

data/test/picatcha_test.rb

@@ -0,0 +1,58 @@
+require File.expand_path './teststrap'
+
+FakeWeb.allow_net_connect = false
+context "Rack::Picatcha" do
+
+  context "basic request" do
+    setup { get("/") ; last_response }
+
+    asserts(:status).equals 200
+    asserts(:body).equals "Hello world"
+  end
+
+  context "exposes" do
+    setup { Rack::Picatcha }
+
+    asserts(:private_key).equals PRIVATE_KEY
+    asserts(:public_key).equals PUBLIC_KEY
+  end
+
+  context "#test_mode!" do
+    setup { Rack::Picatcha }
+
+    asserts "that it sets @@test_mode to be true" do
+      topic.test_mode!
+      topic.test_mode
+    end
+
+    denies "that it sets @@test_mode to be true if option set to false" do
+      topic.test_mode! :return => false
+      topic.test_mode
+    end
+  end
+
+  context "login path" do
+
+    asserts "GET login" do
+      get '/login'
+      last_response.body
+    end.equals 'login'
+
+
+    asserts "POST login passes and" do
+      puts Rack::Picatcha::VERIFY_URL
+      FakeWeb.register_uri(:post, Rack::Picatcha::VERIFY_URL, :body => "true\nsuccess")
+      puts "HERE2"
+      post("/login", 'picatcha_challenge_field' => 'challenge', 'picatcha_response_field' => 'response')
+      puts "HERE3"
+      last_response.body
+    end.equals 'post login'
+
+    asserts "POST login fails and" do
+      FakeWeb.register_uri(:post, Rack::Picatcha::VERIFY_URL, :body => "false\nfailed")
+      post("/login", 'picatcha_challenge_field' => 'challenge', 'picatcha_response_field' => 'response')
+      last_response.body
+    end.equals 'post fail'
+  end
+
+end

data/test/teststrap.rb

@@ -0,0 +1,45 @@
+require 'rubygems'
+require 'rack/test'
+require 'rack/mock'
+require 'rack/utils'
+require 'rack/session/cookie'
+require 'rack/builder'
+require 'rr'
+require 'riot'
+require 'riot/rr'
+require 'fakeweb'
+require File.expand_path '../../lib/rack/picatcha', __FILE__
+
+PUBLIC_KEY = '0'*40
+PRIVATE_KEY = 'X'*40
+
+class Riot::Situation
+  include Rack::Test::Methods
+
+  def app
+    main_app = lambda { |env|
+      request = Rack::Request.new(env)
+      return_code, body_text =
+      case request.path
+      when '/' then [200,'Hello world']
+      when '/login'
+        if request.post?
+          env['picatcha.valid'] ? [200, 'post login'] : [200, 'post fail']
+        else
+          [200,'login']
+        end
+      else
+        [404,'Nothing here']
+      end
+      [return_code,{'Content-type' => 'text/plain'}, [body_text]]
+    }
+
+    builder = Rack::Builder.new
+    builder.use Rack::Picatcha, :private_key => PRIVATE_KEY, :public_key => PUBLIC_KEY
+    builder.run main_app
+    builder.to_app
+  end
+end
+
+class Riot::Context
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: rack-picatcha
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- James Ayvaz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+- !ruby/object:Gem::Dependency
+  name: riot
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.12.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.12.3
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.5.7
+- !ruby/object:Gem::Dependency
+  name: fakeweb
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: rr
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+description: Rack middleware verification using Picatcha API.
+email: james.ayvaz@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.md
+files:
+- .gitignore
+- LICENSE
+- README.md
+- Rakefile
+- rack-picatcha.gemspec
+- lib/rack/picatcha/helpers.rb
+- lib/rack/picatcha.rb
+- test/helpers_test.rb
+- test/picatcha_test.rb
+- test/teststrap.rb
+homepage: http://github.com/ayvazj/rack-picatcha
+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
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Rack middleware for Picatcha
+test_files:
+- test/helpers_test.rb
+- test/picatcha_test.rb
+- test/teststrap.rb