jike_captcha 0.0.2.beta

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9705fad0edd583fc5535d5ad82f53ee6069a1463
+  data.tar.gz: 2d7a401e51fb5910bd9ebb203ea98738bbb7ca89
+SHA512:
+  metadata.gz: 59709b2b11a2d627008cbc8a5e54a8eabac825b06d93d53309f3918207def2c8adba8551129a4d2acae1ee817d23015fe4a170a47522ff21e01053cc5caacfc4
+  data.tar.gz: 33edcccf1f2ecc97d5fe797c4959b29efbb4e9e57693b9f05d915ce8e07f2789e34b8202388827f4d211b89af2ac768539f26bb40f48f8d03629c7d964eb49fa

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+# source 'http://ruby.taobao.org'
+
+# Specify your gem's dependencies in jike_captcha.gemspec
+gemspec
+
+gem 'coveralls', require: false

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Xuhao
+
+MIT License
+
+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,170 @@
+# JikeCaptcha
+
+[![Build Status](https://travis-ci.org/Xuhao/jike_captcha.png?branch=master)](https://travis-ci.org/Xuhao/jike_captcha)
+[![Code Climate](https://codeclimate.com/github/Xuhao/jike_captcha.png)](https://codeclimate.com/github/Xuhao/jike_captcha)
+[![Coverage Status](https://coveralls.io/repos/Xuhao/jike_captcha/badge.png?branch=master)](https://coveralls.io/r/Xuhao/jike_captcha?branch=master)
+[![Gem Version](https://badge.fury.io/rb/jike_captcha.png)](http://badge.fury.io/rb/jike_captcha)
+
+Captcha form [Jike API][jike_api_site], It's very simple but it's light weight and very fast. No need generate captcha image locally, so you need not install any software for it, such as ImageMagick. It get captcha form a fast and stable service clusters. It's good choice for Captcha, try it!
+
+![Jike captcha screen shot](https://raw.github.com/Xuhao/jike_captcha/master/example/ScreenShot.png "Jike captcha screen shot")
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'jike_captcha'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install jike_captcha
+
+## Usage
+
+#### 1. Get your app_key
+
+Before use it, you need get you app_key form [Jike API site](http://open.jike.com/).
+
+Once get your app_key, you need tell JikeCaptcha what kind of app_key you got, there are two ways:
+
+One: create a file in config/initializers/jike_captcha.rb with below code:
+
+```ruby
+# config/initializers/jike_captcha.rb
+Jike::Captcha.app_key = "<your_app_key>"
+```
+
+Two: set app_key in config/application.rb:
+
+```ruby
+config.jike_app_key = '<your_app_key>'
+```
+
+#### 2. Put captcha tag in your form
+
+```erb
+<%= form_for :post do |f| %>
+  <%= captcha_tag %>
+  <%= f.submit %>
+<% end %>
+```
+
+##### captcha_tag
+
+The most useful helper is `captcha_tag`, it will render all the necessary tags.
+
+*args:*
+
+* `:wrapper_html`: options for wrapper tag
+  * `:tag`: control wrapper tag type
+* `:input_html`: options for captcha text filed tag
+* `:image_html`: options for captcha img tag
+  * `:src_type`: control image url type. if set to `:data_url`, will render img src as base64 encode
+  * `:update`: if set to true, captcha can be update be ajax, if set to a hash, value for `:text` key in that has will used for update link content.
+
+All the options at below are default value, except `args[:image_html][:src_type]`, its default value is nil.
+
+```ruby
+captcha_tag wrapper_html: {
+              tag: :div,
+              id: 'jike_captcha_wrapper',
+              class: 'jike_captcha_wrapper'
+            },
+            input_html: {
+              id: 'jike_captcha_input',
+              class: 'jike_captcha_input',
+              name: 'jike_captcha_value'
+            },
+            image_html: {
+              src_type: :data_url,
+              update: { text: 'change a new one' },
+              id: 'jike_captcha_image',
+              class: 'jike_captcha_image'
+            }
+```
+
+render:
+
+```html
+<div class="jike_captcha_wrapper" id="jike_captcha_wrapper">
+  <input class="jike_captcha_input" id="jike_captcha_input" name="jike_captcha_value" type="text" />
+  <img class="jike_captcha_image" data-src-type="data_url" id="jike_captcha_image" src="data:image/png;base64,iVBO......" style="cursor: pointer;" />
+  <input class="jike_captcha_id" id="jike_captcha_id" name="jike_captcha_id" type="hidden" value="..." />
+  <a href="javascript: void(0);" id="jike_captcha_update_link">change a new one</a>
+  <script type="text/javascript">
+    //<![CDATA[
+      $(function(){
+        $('body').on('click', 'img#jike_captcha_image, a#jike_captcha_update_link', function(event) {
+          var imageType, $captchaInput, $captchaImage, $captchaId;
+          $captchaInput = $('input#jike_captcha_input');
+          $captchaImage = $('img#jike_captcha_image');
+          $captchaId = $('input#jike_captcha_id');
+          imageType = $captchaImage.data('src-type');
+          $.getJSON('/jike_captcha/get_captcha.json', {image_type: imageType}, function(data) {
+            $captchaInput.val('');
+            $captchaImage.attr('src', decodeURIComponent(data.captcha_image));
+            $captchaId.val(data.captcha_id);
+          });
+        });
+      });
+    //]]>
+  </script>
+</div>
+```
+
+#### 3. Validate captcha in controller
+
+Submit captcha value form your form, then you can validate it in your controller use `captcha_valid?` method. It's very simple to do that.
+
+```ruby
+class UsersController < ApplicationController
+  def create
+    if captcha_valid? # Same as Jike::Captcha::Validation.captcha_valid?(params)
+      User.create(params[:user])
+    else
+      redirect_to :new, notice: 'Captcha is not correct!'
+    end
+  end
+end
+```
+
+As default, captcha value should submited by `params[:jike_captcha_value]`, another value is `params[:jike_captcha_id]`, it's generate by `captcha_tag` helper automatically.
+
+<b>Custom captcha value param in your form</b>
+
+You can use any param key to submit captcha value, as below:
+
+```erb
+<%= captcha_tag input_html: { name: 'my_captcha_value' } %>
+```
+
+The captcha value will submited by `params[:my_captcha_value]`. But you can't custom another value `params[:jike_captcha_id]`.
+
+then validate in your controller like this:
+
+```ruby
+class UsersController < ApplicationController
+  def create
+    if captcha_validate(params[:my_captcha_value])
+      User.create(params[:user])
+    else
+      redirect_to :new, notice: 'Captcha is not correct!'
+    end
+  end
+end
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+[jike_api_site]: http://open.jike.com/api/detailView?group_id=1

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/app/controllers/jike/captcha/get_captcha_controller.rb

@@ -0,0 +1,10 @@
+module Jike::Captcha
+  class GetCaptchaController < ::ActionController::Metal
+
+    def index
+      Jike::Captcha::Helpers.reset_captcha!
+      image = (params[:image_type] == 'data_url' ? Jike::Captcha::Helpers.captcha_image_data_url : Jike::Captcha::Helpers.captcha_image_url)
+      self.response_body = {captcha_image: image, captcha_id: Jike::Captcha::Helpers.captcha_id}.to_json
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,3 @@
+Rails.application.routes.draw do
+  get '/jike_captcha/get_captcha', to: Jike::Captcha::GetCaptchaController.action(:index)
+end

data/jike_captcha.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jike_captcha/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jike_captcha"
+  spec.version       = Jike::Captcha::VERSION
+  spec.authors       = ["Xuhao"]
+  spec.email         = ["xuhao@rubyfans.com"]
+  spec.description   = %q{Captcha form Jike API}
+  spec.summary       = %q{Captcha form Jike API}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'httparty'
+  spec.add_dependency 'activesupport'
+  spec.add_dependency 'actionpack'
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/jike_captcha.rb

@@ -0,0 +1,27 @@
+require "jike_captcha/version"
+require 'jike_captcha/engine' if Module.const_defined?('Rails')
+
+module Jike
+  module Captcha
+    CAPTCHA_ID_URL = 'http://api.jike.com/captcha/urls'
+    CAPTCHA_IMAGE_URL = 'http://api.jike.com/captcha/images'
+    CAPTCHA_VALIDATE_URL = 'http://api.jike.com/captcha/validation'
+
+    # There two way to set jike app key
+    # TODO: detail for those tow ways
+    def self.app_key
+      @app_key ||= begin
+        if Module.const_defined?('Rails')
+          Rails.application.config.jike_app_key if Rails.application.config.respond_to?(:jike_app_key)
+        end
+      end
+    end
+
+    def self.app_key=(app_key_string)
+      @app_key = app_key_string
+    end
+  end
+end
+
+require 'jike_captcha/helpers'
+require 'jike_captcha/validation'

data/lib/jike_captcha/engine.rb

@@ -0,0 +1,17 @@
+require "rails"
+
+module Jike
+  module Captcha
+    class Engine < Rails::Engine
+      initializer "Actionpack extensions" do
+        ActiveSupport.on_load :action_view do
+          ActionView::Base.send :include, Jike::Captcha::Helpers
+        end
+
+        ActiveSupport.on_load :action_controller do
+          ActionController::Metal.send :include, Jike::Captcha::Validation
+        end
+      end
+    end
+  end
+end

data/lib/jike_captcha/helpers.rb

@@ -0,0 +1,204 @@
+require 'httparty'
+require 'active_support/json/decoding'
+require 'active_support/core_ext/object/to_param'
+require 'active_support/core_ext/object/to_query'
+require 'active_support/concern'
+require 'active_support/core_ext/hash/keys'
+require 'active_support/core_ext/hash/deep_merge'
+require 'active_support/core_ext/string/output_safety'
+require 'active_support/core_ext/object/blank'
+require 'action_view'
+
+module Jike
+  module Captcha
+    module Helpers
+      class AppKeyMissingError < StandardError
+        def initialize
+          super 'Please set Jike app_key first! Check out jike_captcha document to see how to do that.'
+        end
+      end
+      # ActionView helpers and helper methods that can be called on Jike::Captcha::Helpers
+      #
+      # Example:
+      #   Jike::Captcha::Helpers.captcha_image_url
+      #   # => http://api.jike.com/captcha/images?app_key=<app_key>&captcha_id=<captcha_id>
+      #
+      #   <%= captcha_image_tag src_type: :data_url, id: :my_captcha_image %>
+      #   # => <img url="data_url" src="data:image/png;base64,iVBORw0..." id="my_captcha_image" class="jike_captcha_image">
+      #
+      #   <%= captcha_tag wrapper_html: {tag: :span, class: :captcha_field}, input_html: {class: :my_captcha_input}, image_html: {src_type: :data_url, id: :my_captcha_image} %>
+      #   # =>
+      #   # <span id="jike_captcha_wrapper" class="captcha_field">
+      #   #   <input id="jike_captcha_input" class="my_captcha_input" type="text" name="jike_captcha_value">
+      #   #   <img id="my_captcha_image" class="jike_captcha_image" src="data:image/png;base64,iVBORw0KG....">
+      #   #   <input id="jike_captcha_id" class="jike_captcha_id" type="hidden" value="b7c02131e7..." name="jike_captcha_id">
+      #   # </span>
+      include HTTParty, ActionView::Helpers::TagHelper, ActionView::Helpers::TextHelper, ActionView::Context
+      extend self
+
+      DEFAULT_WRAPPER_OPTIONS = { id: 'jike_captcha_wrapper', class: 'jike_captcha_wrapper' }
+      DEFAULT_IMAGE_OPTIONS = { id: 'jike_captcha_image', class: 'jike_captcha_image' }
+      DEFAULT_ID_OPTIONS = { id: 'jike_captcha_id', class: 'jike_captcha_id', name: 'jike_captcha_id' }
+      DEFAULT_INPUT_OPTIONS = { id: 'jike_captcha_input', class: 'jike_captcha_input', name: 'jike_captcha_value' }
+      DEFAULT_AJAX_LINK_OPTIONS = { id: 'jike_captcha_update_link', href: 'javascript: void(0);' }
+      AJAX_LINK_TEXT = 'change another one'
+
+      attr_accessor :captcha_image_url, :captcha_image_data, :captcha_image_data_url, :captcha_id, :captcha_image_base64
+
+      # Return captcha image url that redirect to jike server
+      #
+      # Example:
+      #   Jike::Captcha::Helpers.captcha_image_url
+      #   # => http://api.jike.com/captcha/images?app_key=<app_key>&captcha_id=<captcha_id>
+      def captcha_image_url
+        @captcha_image_url ||= api_url_for(CAPTCHA_IMAGE_URL, captcha_id: captcha_id)
+      end
+
+      # Return captcha image binary data, useful for some apps except Web application
+      #
+      # Example:
+      #   Jike::Captcha::Helpers.captcha_image_data
+      #   # => "\x89PNG\r\n\x1A\n\x00\x00\......"
+      def captcha_image_data
+        @captcha_image_data ||= get(captcha_image_url)
+      end
+
+      # Return data url for <code><img><code> tag
+      #
+      # Example:
+      #   Jike::Captcha::Helpers.captcha_image_data_url
+      #   # => "data:image/png;base64,iVBORw0KGgoAAA......""
+      def captcha_image_data_url
+        @captcha_image_data_url ||= "data:image/png;base64,#{captcha_image_base64}"
+      end
+
+      # Render captcha image and captcha_id hidden field
+      #
+      # Example:
+      #   <%= captcha_image_tag src_type: :data_url, id: :my_captcha_image %>
+      #   # => <img url="data_url" src="data:image/png;base64,iVBORw0..." id="my_captcha_image" class="jike_captcha_image">
+      def captcha_image_tag(options={})
+        image_options = get_image_options(options)
+        update_options_or_boolean = image_options.delete(:update)
+        set_pointer_cursor(image_options) if update_options_or_boolean.present?
+        output = ActiveSupport::SafeBuffer.new
+        output << tag(:img, image_options)
+        output << tag(:input, { type: :hidden, value: captcha_id }.update(DEFAULT_ID_OPTIONS))
+        if update_options_or_boolean.present?
+          output << ajax_link_tag(update_options_or_boolean)
+          output << js_for_ajax
+        end
+        output
+      end
+
+
+      def captcha_id # :nodoc:
+        @captcha_id ||= get_hash(captcha_id_url)['data']['captcha_id']
+      end
+
+      # Render captcha input text field, captcha image and captcha_id hidden field
+      #
+      # Example:
+      #   <%= captcha_tag wrapper_html: {tag: :span, class: :captcha_field}, input_html: {class: :my_captcha_input}, image_html: {src_type: :data_url, id: :my_captcha_image} %>
+      #   # =>
+      #   # <span id="jike_captcha_wrapper" class="captcha_field">
+      #   #   <input id="jike_captcha_input" class="my_captcha_input" type="text" name="jike_captcha_value">
+      #   #   <img id="my_captcha_image" class="jike_captcha_image" src="data:image/png;base64,iVBORw0KG....">
+      #   #   <input id="jike_captcha_id" class="jike_captcha_id" type="hidden" value="b7c02131e7..." name="jike_captcha_id">
+      #   # </span>
+      def captcha_tag(options = {})
+        options.symbolize_keys!
+        input_options = get_input_options(options)
+        wrapper_options = get_wrapper_options(options)
+
+        wrapper_tag = wrapper_options.delete(:tag) || :div
+        content_tag wrapper_tag, wrapper_options do
+          concat tag :input, { type: "text" }.update(input_options)
+          concat captcha_image_tag(options.delete(:image_html) || {})
+        end
+      end
+
+      def reset_captcha!
+        @captcha_image_url = nil
+        @captcha_image_data = nil
+        @captcha_image_data_url = nil
+        @captcha_id = nil
+        @captcha_image_base64 = nil
+      end
+
+      private
+
+        def captcha_image_base64
+          @captcha_image_base64 ||= Base64.encode64(captcha_image_data)
+        end
+
+        def captcha_id_url
+          api_url_for(CAPTCHA_ID_URL)
+        end
+
+        def api_url_for(base_url, params={})
+          params.merge!(app_key: Jike::Captcha.app_key)
+          "#{base_url}?#{params.to_param}"
+        end
+
+        def get(url)
+          raise AppKeyMissingError if Jike::Captcha.app_key.blank?
+          HTTParty.get(url).body
+        end
+
+        def get_hash(url)
+          ::ActiveSupport::JSON.decode(get(url))
+        end
+
+        def get_wrapper_options(options)
+          DEFAULT_WRAPPER_OPTIONS.merge(options.delete(:wrapper_html) || {})
+        end
+
+        def get_image_options(options)
+          image_src = options[:src_type].to_s == 'data_url' ? captcha_image_data_url : captcha_image_url
+          DEFAULT_IMAGE_OPTIONS.merge(src: image_src, data: { src_type: options.delete(:src_type) }).deep_merge(options)
+        end
+
+        def get_input_options(options)
+          DEFAULT_INPUT_OPTIONS.merge(options.delete(:input_html) || {})
+        end
+
+        def set_pointer_cursor(options)
+          options[:style] = "cursor: pointer;#{options[:style]}"
+        end
+
+        def ajax_link_tag(options_or_boolean)
+          if Hash === options_or_boolean
+            return '' if options_or_boolean.key?(:text) and options_or_boolean[:text].is_a?(FalseClass)
+            content_tag :a, options_or_boolean.delete(:text), options_or_boolean.merge( DEFAULT_AJAX_LINK_OPTIONS )
+          else
+            content_tag :a, AJAX_LINK_TEXT, DEFAULT_AJAX_LINK_OPTIONS
+          end
+        end
+
+        def js_for_ajax
+          js = <<-JAVASCRIPT
+            <script type="text/javascript">
+              //<![CDATA[
+                $(function(){
+                  $('body').on('click', 'img#jike_captcha_image, a#jike_captcha_update_link', function(event) {
+                    var imageType, $captchaInput, $captchaImage, $captchaId;
+                    $captchaInput = $('input#jike_captcha_input');
+                    $captchaImage = $('img#jike_captcha_image');
+                    $captchaId = $('input#jike_captcha_id');
+                    imageType = $captchaImage.data('src-type');
+                    $.getJSON('/jike_captcha/get_captcha.json', {image_type: imageType}, function(data) {
+                      $captchaInput.val('');
+                      $captchaImage.attr('src', decodeURIComponent(data.captcha_image));
+                      $captchaId.val(data.captcha_id);
+                    });
+                  });
+                });
+              //]]>
+            </script>
+          JAVASCRIPT
+          js.html_safe
+        end
+    end
+  end
+end

data/lib/jike_captcha/validation.rb

@@ -0,0 +1,55 @@
+require 'active_support/core_ext/object/blank'
+require 'active_support/concern'
+
+module Jike
+  module Captcha
+    module Validation
+      extend ActiveSupport::Concern
+      extend self
+
+      # Validate the request params
+      #
+      # Example:
+      #   class UsersController < ApplicationController
+      #     def create
+      #       if captcha_valid? # Same as Jike::Captcha::Validation.captcha_valid?(params)
+      #         User.create(params[:user])
+      #       else
+      #         redirect_to :new, notice: 'Captcha is not correct!'
+      #       end
+      #     end
+      #   end
+      def captcha_valid?(_params={})
+        request_params = self.respond_to?(:params) ? (_params.presence || params) : _params
+        captcha_validate(request_params[:jike_captcha_value], request_params[:jike_captcha_id])
+      end
+
+      # Validate the input value by a captcha_id
+      # It's usefull to custom the captcha_tag to pass the captcha value with different param
+      #
+      # Example:
+      #   class UsersController < ApplicationController
+      #     def create
+      #       if captcha_validate(params[:captcha_value])
+      #         User.create(params[:user])
+      #       else
+      #         redirect_to :new, notice: 'Captcha is not correct!'
+      #       end
+      #     end
+      #   end
+      def captcha_validate(input_value, captcha_id=nil)
+        captcha_id ||= self.respond_to?(:params) && params[:jike_captcha_id]
+        return false if input_value.blank? or captcha_id.blank?
+        response = Jike::Captcha::Helpers.send(:get_hash, validate_url(input_value, captcha_id))
+        !!response['data']
+      rescue
+        false
+      end
+
+      private
+        def validate_url(input_value, captcha_id)
+          Jike::Captcha::Helpers.send(:api_url_for, CAPTCHA_VALIDATE_URL, captcha_id: captcha_id, input: input_value)
+        end
+    end
+  end
+end

data/lib/jike_captcha/version.rb

@@ -0,0 +1,5 @@
+module Jike
+  module Captcha
+    VERSION = "0.0.2.beta"
+  end
+end

data/spec/helpers_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe Jike::Captcha::Helpers do
+  before(:each) { Jike::Captcha.app_key = 'ba02964ba79438ec' }
+  it 'should return captcha image url that redirect to jike server when call captcha_url method' do
+    image_url = Jike::Captcha::Helpers.captcha_image_url
+    image_url.should be_a(String)
+    image_url.include?(Jike::Captcha::CAPTCHA_IMAGE_URL).should be_true
+    image_url.include?("captcha_id=").should be_true
+  end
+
+  it 'should return a captcha id when call captcha_id method' do
+    captcha_id = Jike::Captcha::Helpers.captcha_id
+    captcha_id.should be_a(String)
+    captcha_id.size.should eq(32)
+    captcha_id.include?("captcha_id=").should be_false
+    Jike::Captcha.app_key = nil
+    Jike::Captcha::Helpers.reset_captcha!
+    expect { Jike::Captcha::Helpers.captcha_id }.to raise_error(Jike::Captcha::Helpers::AppKeyMissingError, "Please set Jike app_key first! Check out jike_captcha document to see how to do that.")
+  end
+
+  it 'should return binary data for captcha image when all captcha_image_data' do
+    image_data = Jike::Captcha::Helpers.captcha_image_data
+    image_data.encoding.name.should eq('ASCII-8BIT')
+    Jike::Captcha.app_key = nil
+    Jike::Captcha::Helpers.reset_captcha!
+    expect { Jike::Captcha::Helpers.captcha_image_data }.to raise_error(Jike::Captcha::Helpers::AppKeyMissingError, "Please set Jike app_key first! Check out jike_captcha document to see how to do that.")
+  end
+
+  it 'should return data url for captcha image when call captcha_image_data_url' do
+    Jike::Captcha::Helpers.captcha_image_data_url.should =~ /\Adata:image\/png;base64,+/
+  end
+
+  it 'should render captcha image and hidden input to value current captcha id when call captcha_image_tag' do
+    image_tag = Jike::Captcha::Helpers.captcha_image_tag(name: 'my_captcha_image')
+    image_tag.should =~ /\A<img+/
+    image_tag.should =~ /<input+/
+    image_tag.include?('class="jike_captcha_image"').should be_true
+    image_tag.include?('id="jike_captcha_image"').should be_true
+    image_tag.include?('class="jike_captcha_id"').should be_true
+    image_tag.include?('id="jike_captcha_id"').should be_true
+    image_tag.include?('name="my_captcha_image"').should be_true
+    Jike::Captcha::Helpers.captcha_image_tag(id: 'my_captcha_image').include?('id="my_captcha_image"').should be_true
+  end
+
+  it 'should render captcha input and captcha image when call captcha_tag method' do
+    captcha_tag = Jike::Captcha::Helpers.captcha_tag(wrapper_html: {tag: :div})
+    captcha_tag1 = Jike::Captcha::Helpers.captcha_tag(
+      wrapper_html: {tag: :span, class: 'my_captcha_wrapper'},
+      input_html: {id: 'my_captcha_input'},
+      image_html: {name: 'my_captcha_image', class: 'test_class'}
+    )
+    captcha_tag2 = Jike::Captcha::Helpers.captcha_tag(image_html: {update: { text: 'UPDATE IT', id: 'my_update_link_id'}})
+    captcha_tag3 = Jike::Captcha::Helpers.captcha_tag(image_html: {update: true})
+    captcha_tag.include?('class="jike_captcha_wrapper"').should be_true
+    captcha_tag.include?('id="jike_captcha_wrapper"').should be_true
+    captcha_tag.should =~ /\A<div+/
+    captcha_tag.should =~ /<img+/
+    captcha_tag.should =~ /<input+/
+    captcha_tag.include?('class="jike_captcha_image"').should be_true
+    captcha_tag.include?('id="jike_captcha_image"').should be_true
+    captcha_tag.include?('class="jike_captcha_id"').should be_true
+    captcha_tag.include?('id="jike_captcha_id"').should be_true
+    captcha_tag.include?('<script type="text/javascript">').should be_false
+
+    captcha_tag1.should =~ /\A<span+/
+    captcha_tag1.include?('class="test_class"').should be_true
+    captcha_tag1.include?('name="my_captcha_image"').should be_true
+    captcha_tag1.include?('class="my_captcha_wrapper"').should be_true
+    captcha_tag1.include?('id="my_captcha_input"').should be_true
+    captcha_tag1.include?('<script type="text/javascript">').should be_false
+
+    captcha_tag2.include?('style="cursor: pointer;"').should be_true
+    captcha_tag2.include?('<a href="javascript: void(0);" id="jike_captcha_update_link">UPDATE IT</a>').should be_true
+    captcha_tag2.include?('<script type="text/javascript">').should be_true
+    captcha_tag2.include?('id="jike_captcha_update_link">').should be_true
+
+    captcha_tag3.include?('style="cursor: pointer;"').should be_true
+    captcha_tag3.include?('<a href="javascript: void(0);" id="jike_captcha_update_link">change another one</a>').should be_true
+    captcha_tag3.include?('<script type="text/javascript">').should be_true
+  end
+
+  it 'should clean all cacha and reset all instance variables when call reset_captcha! method' do
+    helper = Jike::Captcha::Helpers
+    helper.captcha_id = 'captcha_id.sample'
+    helper.captcha_image_url = 'captcha_image_url.sample'
+    helper.captcha_image_data = 'captcha_image_data.sample'
+    helper.captcha_image_data_url = 'captcha_image_data_url.sample'
+    helper.captcha_image_base64 = 'captcha_image_base64.sample'
+
+    helper.reset_captcha!
+    helper.captcha_id.should_not eq('captcha_id.sample')
+    helper.captcha_image_url.should_not eq('captcha_image_url.sample')
+    helper.captcha_image_data.should_not eq('captcha_image_data.sample')
+    helper.captcha_image_data_url.should_not eq('captcha_image_data_url.sample')
+    helper.send(:captcha_image_base64).should_not eq('captcha_image_base64.sample')
+  end
+end

data/spec/jike_captcha_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Jike::Captcha do
+  it 'should have a version number' do
+    Jike::Captcha::VERSION.should_not be_nil
+  end
+
+  it 'should return app_key which defined in rails application configuration file.' do
+    Jike::Captcha.app_key = nil
+    stub_const('Rails', Module.new)
+    Rails.stub_chain('application.config.jike_app_key') { 'jike_app_key_test_sample' }
+    Jike::Captcha.app_key.should eq('jike_app_key_test_sample')
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'coveralls'
+Coveralls.wear!
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'jike_captcha'

data/spec/validation_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Jike::Captcha::Validation do
+  let(:params1) { { jike_captcha_value: 'captcha_value', jike_captcha_id: 'captcha_id' }}
+  let(:params2) { { jike_captcha_value: '', jike_captcha_id: nil }}
+  let(:params3) { { captcha_id: 'captcha_id' }}
+
+  it 'should validate captcha value in params when call captcha_valid?' do 
+    Jike::Captcha::Validation.captcha_valid?(params1).should be_false
+    Jike::Captcha::Validation.captcha_valid?(params2).should be_false
+    Jike::Captcha::Validation.captcha_valid?(params3).should be_false
+  end
+
+  it 'should check the given captcha value and id and return boolean' do
+    Jike::Captcha::Validation.captcha_validate(params1[:jike_captcha_value], params1[:jike_captcha_id]).class.should satisfy{|k| [TrueClass, FalseClass].include?(k)}
+    Jike::Captcha::Helpers.stub(:send).and_raise
+    Jike::Captcha::Validation.captcha_validate(params1[:jike_captcha_value], params1[:jike_captcha_id]).should be_false
+  end
+end

metadata

@@ -0,0 +1,152 @@
+--- !ruby/object:Gem::Specification
+name: jike_captcha
+version: !ruby/object:Gem::Version
+  version: 0.0.2.beta
+platform: ruby
+authors:
+- Xuhao
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  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: activesupport
+  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: actionpack
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: Captcha form Jike API
+email:
+- xuhao@rubyfans.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- app/controllers/jike/captcha/get_captcha_controller.rb
+- config/routes.rb
+- example/ScreenShot.png
+- jike_captcha.gemspec
+- lib/jike_captcha.rb
+- lib/jike_captcha/engine.rb
+- lib/jike_captcha/helpers.rb
+- lib/jike_captcha/validation.rb
+- lib/jike_captcha/version.rb
+- spec/helpers_spec.rb
+- spec/jike_captcha_spec.rb
+- spec/spec_helper.rb
+- spec/validation_spec.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.5
+signing_key: 
+specification_version: 4
+summary: Captcha form Jike API
+test_files:
+- spec/helpers_spec.rb
+- spec/jike_captcha_spec.rb
+- spec/spec_helper.rb
+- spec/validation_spec.rb