nogara-simple_captcha 0.1.1

data/README.rdoc

@@ -0,0 +1,211 @@
+=SimpleCaptcha
+
+SimpleCaptcha is the simplest and a robust captcha plugin. Its implementation requires 
+adding up a single line in views and in controllers/models.
+SimpleCaptcha is available to be used with Rails 3 or above and also it provides the 
+backward compatibility with previous versions of Rails.
+  
+==Features
+
+* Zero FileSystem usage(secret code moved to db-store and image storage removed).
+* Provides various image styles.
+* Provides three level of complexity of images.
+* Works absolutely fine in distributed environment(session and db based implementation works fine in distributed environment).
+* Implementation is as easy as just writing a single line in your view. "<%= show_simple_captcha %>" within the 'form' tags.
+* Flexible DOM and CSS handling(There is a separate view partial for rednering SimpleCaptcha DOM elements).
+* Automated removal of 1 hour old unmatched simple_captcha data.
+
+==Requirements
+
+* {Ruby}[http://ruby-lang.org/] >= 1.8.7
+* {Rails}[http://github.com/rails/rails] >= 3
+* ImageMagick should be installed on your machine to use this plugin.
+  visit http://www.imagemagick.org/script/index.php for more details.
+
+==Installation
+
+  gem 'simple_captcha', :git => 'git://github.com/galetahub/simple-captcha.git'
+
+==Setup
+
+After installation, follow these simple steps to setup the plugin. The setup will depend
+on the version of rails your application is using.
+
+  rails generate simple_captcha
+  
+  rake db:migrate
+
+==Usage
+
+===Controller Based
+
+Add the following line in the file "app/controllers/application.rb"
+    
+  ApplicationController < ActionController::Base
+    include SimpleCaptcha::ControllerHelpers
+  end
+
+In the view file within the form tags add this code
+    
+  <%= show_simple_captcha %>
+    
+and in the controller's action authenticate it as 
+    
+  if simple_captcha_valid?
+    do this
+  else
+    do that
+  end
+
+===Model Based
+
+In the view file within the form tags write this code
+
+  <%= show_simple_captcha(:object=>"user") %>
+
+and in the model class add this code
+
+  class User < ActiveRecord::Basse
+    apply_simple_captcha
+  end
+
+====FormBuilder helper
+
+  <%= form_for @user do |form| -%>
+    ...
+    <%= form.simple_captcha :label => "Enter numbers.." %>
+    ...
+  <% end -%>
+
+====Validating with captcha
+NOTE: @user.valid? will still work as it should, it will not validate the captcha code.
+
+  @user.valid_with_captcha?
+
+====Saving with captcha
+NOTE: @user.save will still work as it should, it will not validate the captcha code.
+
+  @user.save_with_captcha
+
+===Formtastic integration
+SimpleCaptcha detects if your use Formtastic and appends "SimpleCaptcha::CustomFormBuilder".
+
+  <%= form.input :captcha, :as => :simple_captcha %>
+
+==Options & Examples
+===View Options
+
+* *label* - provides the custom text b/w the image and the text field, the default is "type the code from the image"
+    
+* *object* - the name of the object of the model class, to implement the model based captcha.
+
+* *code_type* - return numeric only if set to 'numeric'
+
+===Global options
+
+* *image_style* - provides the specific image style for the captcha image.
+There are eight different styles available with the plugin as...
+  1) simply_blue
+  2) simply_red
+  3) simply_green
+  4) charcoal_grey
+  5) embosed_silver
+  6) all_black
+  7) distorted_black
+  8) almost_invisible
+Default style is 'simply_blue'.
+You can also specify 'random' to select the random image style.
+
+* *distortion* - handles the complexity of the image. The :distortion can be set to 'low', 'medium' or 'high'. Default is 'low'.
+  
+Create "rails_root/config/initializers/simple_captcha.rb"
+  
+  SimpleCaptcha.setup do |sc|
+    # default: 100x28
+    sc.image_size = '120x40'
+    
+    # default: 5
+    sc.length = 6
+    
+    # default: simply_blue
+    # possible values:
+    # 'embosed_silver',
+    # 'simply_red',
+    # 'simply_green',
+    # 'simply_blue',
+    # 'distorted_black',
+    # 'all_black',
+    # 'charcoal_grey',
+    # 'almost_invisible'
+    # 'random'
+    sc.image_style = 'simply_green'
+    
+    # default: low
+    # possible values: 'low', 'medium', 'high', 'random'
+    sc.distortion = 'medium'
+  end
+
+You can add your own style:
+
+  SimpleCaptcha.setup do |sc|
+    sc.image_style = 'mycaptha'
+    sc.add_image_style('mycaptha', [
+        "-background '#F4F7F8'", 
+        "-fill '#86818B'",
+        "-border 1",
+        "-bordercolor '#E0E2E3'"])
+  end
+      
+===How to change the CSS for SimpleCaptcha DOM elements?
+You can change the CSS of the SimpleCaptcha DOM elements as per your need in this file.
+  /app/views/simple_captcha/_simple_captcha.erb
+  
+===View's Examples
+====Controller Based Example
+
+  <%= show_simple_captcha %>
+
+  <%= show_simple_captcha(:label => "human authentication") %>     
+    
+====Model Based Example
+    
+  <%= show_simple_captcha(:object => 'user', :label => "human authentication") %>
+
+====Model Options
+
+* *message* - provides the custom message on failure of captcha authentication the default is "Secret Code did not match with the Image"
+
+* *add_to_base* - if set to true, appends the error message to the base.
+
+=====Model's Example
+    
+  class User < ActiveRecord::Base
+    apply_simple_captcha
+  end
+
+  class User < ActiveRecord::Base
+    apply_simple_captcha :message => "The secret Image and code were different", :add_to_base => true
+  end
+
+==I18n
+
+  simple_captcha:
+    message:
+      default: "Secret Code did not match with the Image"
+      user: "The secret Image and code were different"
+
+==Who's who?
+
+Enjoy the simplest captcha implementation.
+
+Author: Sur
+
+Blog: http://expressica.com
+
+Contact: sur.max@gmail.com
+
+Plugin Homepage: http://expressica.com/simple_captcha
+
+Plugin update for rails 3: http://github.com/galetahub
+
+Any feedback/comment/issue/donation is welcome!

data/Rakefile

@@ -0,0 +1,41 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the simple_captcha plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the simple_captcha plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'SimpleCaptcha'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "nogara-simple_captcha"
+    gemspec.version = '0.1.1'
+    gemspec.summary = "SimpleCaptcha is the simplest and a robust captcha plugin."
+    gemspec.description = "SimpleCaptcha is available to be used with Rails 3 or above and also it provides the backward compatibility with previous versions of Rails."
+    gemspec.email = "superp1987@gmail.com"
+    gemspec.homepage = "http://github.com/galetahub/simple-captcha"
+    gemspec.authors = ["Pavlo Galeta", "Igor Galeta"]
+    gemspec.files = FileList["[A-Z]*", "{lib}/**/*", "{app}/**/*", "{config}/**/*", "{test}/**/*"]
+    gemspec.rubyforge_project = "simple_captcha"
+  end
+  
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/app/controllers/simple_captcha_controller.rb

@@ -0,0 +1,17 @@
+class SimpleCaptchaController < ActionController::Metal
+  include ActionController::Streaming
+  include SimpleCaptcha::ImageHelpers
+
+  # GET /simple_captcha
+  def show
+    unless params[:id].blank?
+      send_file(
+        generate_simple_captcha_image(params[:id]),
+        :type => 'image/jpeg',
+        :disposition => 'inline',
+        :filename => 'simple_captcha.jpg')
+    else
+      self.response_body = [404, {"Content-Type" => "text/html"}, ["Not Found"]]
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,3 @@
+Rails.application.routes.draw do
+  match '/simple_captcha/:id', :to => 'simple_captcha#show', :as => :simple_captcha
+end

data/lib/generators/USAGE

@@ -0,0 +1,4 @@
+SimplaCaptcha
+=============
+# Generate migration and copy view partial
+  rails generate simple_captcha

data/lib/generators/simple_captcha_generator.rb

@@ -0,0 +1,21 @@
+require 'rails/generators'
+
+class SimpleCaptchaGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
+                          
+  def self.source_root
+    @source_root ||= File.expand_path(File.join(File.dirname(__FILE__), 'templates/'))
+  end
+
+  def self.next_migration_number(dirname)
+    Time.now.strftime("%Y%m%d%H%M%S")
+  end
+  
+  def create_partial
+    template "partial.erb", File.join('app/views', 'simple_captcha', "_simple_captcha.erb")
+  end
+  
+  def create_migration
+    migration_template "migration.rb", File.join('db/migrate', "create_simple_captcha_data.rb")
+  end
+end

data/lib/generators/templates/migration.rb

@@ -0,0 +1,15 @@
+class CreateSimpleCaptchaData < ActiveRecord::Migration
+  def self.up
+    create_table :simple_captcha_data do |t|
+      t.string :key, :limit => 40
+      t.string :value, :limit => 6
+      t.timestamps
+    end
+    
+    add_index :simple_captcha_data, :key, :name => "idx_key"
+  end
+
+  def self.down
+    drop_table :simple_captcha_data
+  end
+end

data/lib/generators/templates/partial.erb

@@ -0,0 +1,37 @@
+<style type="text/CSS">
+  .simple_captcha{border: 1px solid #ccc; padding: 5px !important;}
+  .simple_captcha,
+  .simple_captcha div{display: table;}
+  .simple_captcha .simple_captcha_field,
+  .simple_captcha .simple_captcha_image{
+    border: 1px solid #ccc;
+    margin: 0px 0px 2px 0px !important;
+    padding: 0px !important;
+  }
+  .simple_captcha .simple_captcha_image img{
+    margin: 0px !important;
+    padding: 0px !important;
+    width: 110px !important;
+  }
+  .simple_captcha .simple_captcha_label{font-size: 12px;}
+  .simple_captcha .simple_captcha_field input{
+    width: 150px !important;
+    font-size: 16px;
+    border: none;
+    background-color: #efefef;
+  }
+</style>
+
+<div class='simple_captcha'>
+  <div class='simple_captcha_image'>
+    <%%= simple_captcha_options[:image] %>
+  </div>
+  
+  <div class='simple_captcha_field'>
+    <%%= simple_captcha_options[:field] %>
+  </div>
+  
+  <div class='simple_captcha_label'>
+    <%%= simple_captcha_options[:label] %>
+  </div>
+</div>

data/lib/simple_captcha.rb

@@ -0,0 +1,47 @@
+# encoding: utf-8
+
+module SimpleCaptcha
+  autoload :Utils,             'simple_captcha/utils'
+  
+  autoload :ImageHelpers,      'simple_captcha/image'  
+  autoload :ViewHelper,        'simple_captcha/view'
+  autoload :ControllerHelpers, 'simple_captcha/controller'
+  autoload :ModelHelpers,      'simple_captcha/active_record'
+  
+  autoload :FormBuilder,       'simple_captcha/form_builder'
+  autoload :CustomFormBuilder, 'simple_captcha/formtastic'
+  
+  autoload :SimpleCaptchaData, 'simple_captcha/simple_captcha_data'
+  
+  mattr_accessor :image_size
+  @@image_size = "100x28"
+  
+  mattr_accessor :length
+  @@length = 5
+  
+  # 'embosed_silver',
+  # 'simply_red',
+  # 'simply_green',
+  # 'simply_blue',
+  # 'distorted_black',
+  # 'all_black',
+  # 'charcoal_grey',
+  # 'almost_invisible'
+  # 'random'
+  mattr_accessor :image_style
+  @@image_style = 'simply_blue'
+  
+  # 'low', 'medium', 'high', 'random'
+  mattr_accessor :distortion
+  @@distortion = 'low'
+  
+  def self.add_image_style(name, params = [])
+    SimpleCaptcha::ImageHelpers.image_styles.update(name.to_s => params)
+  end
+  
+  def self.setup
+    yield self
+  end
+end
+
+require 'simple_captcha/railtie'

data/lib/simple_captcha/active_record.rb

@@ -0,0 +1,72 @@
+module SimpleCaptcha #:nodoc
+  module ModelHelpers #:nodoc
+    def self.included(base)
+      base.extend(SingletonMethods)
+    end
+    
+    # To implement model based simple captcha use this method in the model as...
+    #
+    #  class User < ActiveRecord::Base
+    #
+    #    apply_simple_captcha :message => "my customized message"
+    #
+    #  end
+    #
+    # Customize the error message by using :message, the default message is "Captcha did not match". 
+    # As in the applications captcha is needed with a very few cases like signing up the new user, but
+    # not every time you need to authenticate the captcha with @user.save. So as to maintain simplicity
+    # here we have the explicit method to save the instace with captcha validation as...
+    #
+    # * to validate the instance
+    #  
+    #  @user.valid_with_captcha?  # whene captcha validation is required.
+    #
+    #  @user.valid?               # when captcha validation is not required.
+    #
+    # * to save the instance
+    #
+    #  @user.save_with_captcha   # whene captcha validation is required.
+    #
+    #  @user.save                # when captcha validation is not required.
+    module SingletonMethods
+      def apply_simple_captcha(options = {})
+        options = { :add_to_base => false }.merge(options)
+                  
+        write_inheritable_attribute :simple_captcha_options, options
+        class_inheritable_reader :simple_captcha_options
+        
+        unless self.is_a?(ClassMethods)
+          include InstanceMethods
+          extend ClassMethods
+          
+          attr_accessor :captcha, :captcha_key
+        end
+      end
+    end
+    
+    module ClassMethods
+    end
+    
+    module InstanceMethods
+    
+      def valid_with_captcha?
+        [valid?, is_captcha_valid?].all?
+      end
+      
+      def is_captcha_valid?
+        if captcha && captcha.upcase.delete(" ") == SimpleCaptcha::Utils::simple_captcha_value(captcha_key)
+          SimpleCaptcha::Utils::simple_captcha_passed!(captcha_key)
+          return true
+        else
+          message = simple_captcha_options[:message] || I18n.t(self.class.model_name.downcase, :scope => [:simple_captcha, :message], :default => :default)
+          simple_captcha_options[:add_to_base] ? errors.add_to_base(message) : errors.add(:captcha, message)
+          return false
+        end
+      end
+      
+      def save_with_captcha
+        valid_with_captcha? && save(:validate => false)
+      end
+    end
+  end
+end

data/lib/simple_captcha/controller.rb

@@ -0,0 +1,29 @@
+module SimpleCaptcha #:nodoc 
+  module ControllerHelpers #:nodoc
+    # This method is to validate the simple captcha in controller.
+    # It means when the captcha is controller based i.e. :object has not been passed to the method show_simple_captcha.
+    #
+    # *Example*
+    #
+    # If you want to save an object say @user only if the captcha is validated then do like this in action...
+    #
+    #  if simple_captcha_valid?
+    #   @user.save
+    #  else
+    #   flash[:notice] = "captcha did not match"
+    #   redirect_to :action => "myaction"
+    #  end
+    def simple_captcha_valid?
+      return true if Rails.env.test?
+      
+      if params[:captcha]
+        data = SimpleCaptcha::Utils::simple_captcha_value(session[:captcha])
+        result = data == params[:captcha].delete(" ").upcase
+        SimpleCaptcha::Utils::simple_captcha_passed!(session[:captcha]) if result
+        return result
+      else
+        return false
+      end
+    end
+  end
+end

data/lib/simple_captcha/form_builder.rb

@@ -0,0 +1,34 @@
+module SimpleCaptcha
+  module FormBuilder
+    def self.included(base)
+      base.send(:include, SimpleCaptcha::ViewHelper)
+      base.send(:include, SimpleCaptcha::FormBuilder::ClassMethods)
+      
+      base.delegate :render, :session, :to => :template
+    end
+    
+    module ClassMethods
+      # Example:
+		  # <% form_for :post, :url => posts_path do |form| %>
+		  #   ...
+		  #   <%= form.simple_captcha :label => "Enter numbers.." %>
+		  # <% end %>
+		  #
+		  def simple_captcha(options = {})
+      	options.update :object => @object_name
+      	show_simple_captcha(objectify_options(options))
+      end
+      
+      private
+        
+        def template
+          @template
+        end
+        
+        def simple_captcha_field(options={})
+          text_field(:captcha, :value => '', :autocomplete => 'off') +
+          hidden_field(:captcha_key, {:value => options[:field_value]})
+        end
+    end
+  end
+end

data/lib/simple_captcha/formtastic.rb

@@ -0,0 +1,11 @@
+module SimpleCaptcha
+  class CustomFormBuilder < Formtastic::SemanticFormBuilder
+
+    private
+
+    def simple_captcha_input(method, options)
+      options.update :object => sanitized_object_name
+      self.send(:show_simple_captcha, options)
+    end
+  end
+end

data/lib/simple_captcha/image.rb

@@ -0,0 +1,80 @@
+module SimpleCaptcha #:nodoc
+  module ImageHelpers #:nodoc
+  
+    mattr_accessor :image_styles
+    @@image_styles = {
+      'embosed_silver'  => ['-fill darkblue', '-shade 20x60', '-background white'],
+      'simply_red'      => ['-fill darkred', '-background white'],
+      'simply_green'    => ['-fill darkgreen', '-background white'],
+      'simply_blue'     => ['-fill darkblue', '-background white'],
+      'distorted_black' => ['-fill darkblue', '-edge 10', '-background white'],
+      'all_black'       => ['-fill darkblue', '-edge 2', '-background white'],
+      'charcoal_grey'   => ['-fill darkblue', '-charcoal 5', '-background white'],
+      'almost_invisible' => ['-fill red', '-solarize 50', '-background white']
+    }
+    
+    DISTORTIONS = ['low', 'medium', 'high']
+
+    class << self
+    
+      def image_params(key = 'simply_blue')
+        image_keys = @@image_styles.keys
+        
+        style = begin
+          if key == 'random'
+            image_keys[rand(image_keys.length)]
+          else
+            image_keys.include?(key) ? key : 'simply_blue'
+          end
+        end
+        
+        @@image_styles[style]
+      end
+      
+      def distortion(key='low')
+        key = 
+          key == 'random' ?
+          DISTORTIONS[rand(DISTORTIONS.length)] :
+          DISTORTIONS.include?(key) ? key : 'low'
+        case key.to_s
+          when 'low' then return [0 + rand(2), 80 + rand(20)]
+          when 'medium' then return [2 + rand(2), 50 + rand(20)]
+          when 'high' then return [4 + rand(2), 30 + rand(20)]
+        end
+      end
+    end
+
+    class Tempfile < ::Tempfile
+      # Replaces Tempfile's +make_tmpname+ with one that honors file extensions.
+      def make_tmpname(basename, n = 0)
+        extension = File.extname(basename)
+        sprintf("%s,%d,%d%s", File.basename(basename, extension), $$, n, extension)
+      end
+    end
+
+    private
+
+      def generate_simple_captcha_image(simple_captcha_key) #:nodoc        
+        amplitude, frequency = ImageHelpers.distortion(SimpleCaptcha.distortion)
+        text = Utils::simple_captcha_value(simple_captcha_key)
+        
+        params = ImageHelpers.image_params(SimpleCaptcha.image_style).dup
+        params << "-size #{SimpleCaptcha.image_size}"
+        params << "-wave #{amplitude}x#{frequency}"
+        params << "-gravity 'Center'"
+        params << "-pointsize 22"
+        params << "-implode 0.2"
+        
+        dst = Tempfile.new('simple_captcha.jpg')
+        dst.binmode
+        
+        params << "label:#{text} '#{File.expand_path(dst.path)}'"
+        
+        SimpleCaptcha::Utils::run("convert", params.join(' '))
+        
+        dst.close
+        
+        File.expand_path(dst.path)
+      end
+  end
+end

data/lib/simple_captcha/railtie.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+require 'rails'
+require 'simple_captcha'
+
+module SimpleCaptcha
+  class Railtie < ::Rails::Engine
+    config.before_initialize do
+      ActiveSupport.on_load :active_record do
+        ActiveRecord::Base.send(:include, SimpleCaptcha::ModelHelpers)
+      end
+    end
+    
+    config.after_initialize do
+      ActionView::Base.send(:include, SimpleCaptcha::ViewHelper)
+      ActionView::Helpers::FormBuilder.send(:include, SimpleCaptcha::FormBuilder)
+      
+      if Object.const_defined?("Formtastic")
+        Formtastic::SemanticFormHelper.builder = SimpleCaptcha::CustomFormBuilder
+      end
+    end
+  end
+end
+
+

data/lib/simple_captcha/simple_captcha_data.rb

@@ -0,0 +1,23 @@
+module SimpleCaptcha
+  class SimpleCaptchaData < ::ActiveRecord::Base
+    set_table_name "simple_captcha_data"
+    
+    attr_accessible :key, :value
+    
+    class << self
+      def get_data(key)
+        data = find_by_key(key) || new(:key => key)
+      end
+      
+      def remove_data(key)
+        delete_all(["#{connection.quote_column_name(:key)} = ?", key])
+        clear_old_data(1.hour.ago)
+      end
+      
+      def clear_old_data(time = 1.hour.ago)
+        return unless Time === time
+        delete_all(["#{connection.quote_column_name(:updated_at)} < ?", time])
+      end
+    end
+  end
+end

data/lib/simple_captcha/utils.rb

@@ -0,0 +1,32 @@
+require 'digest/sha1'
+
+module SimpleCaptcha #:nodoc
+  module Utils #:nodoc
+    # Execute command with params and return output if exit status equal expected_outcodes
+    def self.run(cmd, params = "", expected_outcodes = 0)
+      command = %Q[#{cmd} #{params}].gsub(/\s+/, " ")
+      command = "#{command} 2>&1"
+      
+      output = `#{command}`
+      
+      unless [expected_outcodes].flatten.include?($?.exitstatus)
+        raise ::StandardError, "Error while running #{cmd}: #{output}"
+      end
+      
+      output
+    end
+
+    def self.simple_captcha_value(key) #:nodoc
+      SimpleCaptchaData.get_data(key).value rescue nil
+    end
+
+    def self.simple_captcha_passed!(key) #:nodoc
+      SimpleCaptchaData.remove_data(key)
+    end
+    
+    def self.generate_key(*args)
+      args << Time.now.to_s
+      Digest::SHA1.hexdigest(args.join)
+    end
+  end
+end

data/lib/simple_captcha/view.rb

@@ -0,0 +1,110 @@
+module SimpleCaptcha #:nodoc
+  module ViewHelper #:nodoc
+
+    # Simple Captcha is a very simplified captcha.
+    #
+    # It can be used as a *Model* or a *Controller* based Captcha depending on what options
+    # we are passing to the method show_simple_captcha.
+    #
+    # *show_simple_captcha* method will return the image, the label and the text box.
+    # This method should be called from the view within your form as...
+    #
+    # <%= show_simple_captcha %>
+    #
+    # The available options to pass to this method are
+    # * label
+    # * object
+    #
+    # <b>Label:</b>
+    #
+    # default label is "type the text from the image", it can be modified by passing :label as
+    #
+    # <%= show_simple_captcha(:label => "new captcha label") %>.
+    #
+    # *Object*
+    #
+    # This option is needed to create a model based captcha.
+    # If this option is not provided, the captcha will be controller based and
+    # should be checked in controller's action just by calling the method simple_captcha_valid?
+    #
+    # To make a model based captcha give this option as...
+    #
+    # <%= show_simple_captcha(:object => "user") %>
+    # and also call the method apply_simple_captcha in the model
+    # this will consider "user" as the object of the model class.
+    #
+    # *Examples*
+    # * controller based
+    # <%= show_simple_captcha(:label => "Human Authentication: type the text from image above") %>
+    # * model based
+    # <%= show_simple_captcha(:object => "person", :label => "Human Authentication: type the text from image above") %>
+    #
+    # Find more detailed examples with sample images here on my blog http://EXPRESSICA.com
+    #
+    # All Feedbacks/CommentS/Issues/Queries are welcome.
+    def show_simple_captcha(options={})
+      key = simple_captcha_key(options[:object])
+      options[:field_value] = set_simple_captcha_data(key, options)
+      
+      defaults = {
+         :image => simple_captcha_image(key, options),
+         :label => options[:label] || I18n.t('simple_captcha.label'),
+         :field => simple_captcha_field(options)
+         }
+         
+      render :partial => 'simple_captcha/simple_captcha', :locals => { :simple_captcha_options => defaults }
+    end
+
+    private
+
+      def simple_captcha_image(simple_captcha_key, options = {})
+        defaults = {}
+        defaults[:time] = options[:time] || Time.now.to_i
+        
+        query = defaults.collect{ |key, value| "#{key}=#{value}" }.join('&')
+        url = "/simple_captcha/#{simple_captcha_key}?#{query}"
+        
+        "<img src='#{url}' alt='captcha' />".html_safe
+      end
+      
+      def simple_captcha_field(options={})
+        if options[:object]
+          text_field(options[:object], :captcha, :value => '', :autocomplete => 'off') +
+          hidden_field(options[:object], :captcha_key, {:value => options[:field_value]})
+        else
+          text_field_tag(:captcha, nil, :autocomplete => 'off')
+        end
+      end
+
+      def set_simple_captcha_data(key, options={})
+        code_type = options[:code_type]
+        
+        value = generate_simple_captcha_data(code_type)
+        data = SimpleCaptcha::SimpleCaptchaData.get_data(key)
+        data.value = value
+        data.save
+        key
+      end
+   
+      def generate_simple_captcha_data(code)
+        value = ''
+        
+        case code
+          when 'numeric' then 
+            SimpleCaptcha.length.times{value << (48 + rand(10)).chr}
+          else
+            SimpleCaptcha.length.times{value << (65 + rand(26)).chr}
+        end
+        
+        return value
+      end
+      
+      def simple_captcha_key(key_name = nil)
+        if key_name.nil?
+          session[:captcha] ||= SimpleCaptcha::Utils.generate_key(session[:id].to_s, 'captcha')
+        else
+          SimpleCaptcha::Utils.generate_key(session[:id].to_s, key_name)
+        end
+      end 
+  end
+end

data/test/simple_captcha_test.rb

@@ -0,0 +1,8 @@
+require 'test/unit'
+
+class SimpleCaptchaTest < Test::Unit::TestCase
+  # Replace this with your real tests.
+  def test_this_plugin
+    flunk
+  end
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification 
+name: nogara-simple_captcha
+version: !ruby/object:Gem::Version 
+  hash: 25
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Pavlo Galeta
+- Igor Galeta
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-11-18 00:00:00 -02:00
+default_executable: 
+dependencies: []
+
+description: SimpleCaptcha is available to be used with Rails 3 or above and also it provides the backward compatibility with previous versions of Rails.
+email: superp1987@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- app/controllers/simple_captcha_controller.rb
+- config/routes.rb
+- lib/generators/USAGE
+- lib/generators/simple_captcha_generator.rb
+- lib/generators/templates/migration.rb
+- lib/generators/templates/partial.erb
+- lib/simple_captcha.rb
+- lib/simple_captcha/active_record.rb
+- lib/simple_captcha/controller.rb
+- lib/simple_captcha/form_builder.rb
+- lib/simple_captcha/formtastic.rb
+- lib/simple_captcha/image.rb
+- lib/simple_captcha/railtie.rb
+- lib/simple_captcha/simple_captcha_data.rb
+- lib/simple_captcha/utils.rb
+- lib/simple_captcha/view.rb
+- test/simple_captcha_test.rb
+has_rdoc: true
+homepage: http://github.com/galetahub/simple-captcha
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: simple_captcha
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: SimpleCaptcha is the simplest and a robust captcha plugin.
+test_files: 
+- test/simple_captcha_test.rb