loyal_simple_captcha 0.0.1

data/README.rdoc

@@ -0,0 +1,229 @@
+=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 "loyal-simple_captcha", :require => "simple_captcha"
+
+or
+
+  gem 'loyal-simple_captcha', :require => 'simple_captcha', :git => 'git://github.com/blogsoso/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::Base
+    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
+
+You can provide the path where image_magick is installed as well:
+
+  SimpleCaptcha.setup do |sc|
+    sc.image_magick_path = '/usr/bin' # you can check this from console by running: which convert
+  end
+
+You can provide the path where should be stored tmp files.
+It's usefull when you dont have acces to /tmp (default directory)
+
+  SimpleCaptcha.setup do |sc|
+    sc.tmp_path = '/tmp' # or somewhere in project eg. Rails.root.join('tmp/simple_captcha').to_s, make shure directory exists
+  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/blogsoso
+
+Any feedback/comment/issue/donation is welcome!

data/Rakefile

@@ -0,0 +1,22 @@
+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

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/active_record.rb

@@ -0,0 +1,75 @@
+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)
+                  
+        class_attribute :simple_captcha_options
+        self.simple_captcha_options = options
+        
+        unless self.is_a?(ClassMethods)
+          include InstanceMethods
+          extend ClassMethods
+          
+          attr_accessor :captcha, :captcha_key
+          attr_accessible :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?
+        return true if Rails.env.test?
+
+        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(: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(params[:captcha_key] || 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/engine.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+require 'rails'
+require 'simple_captcha'
+
+module SimpleCaptcha
+  class Engine < ::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")
+        if Formtastic.const_defined?("Helpers")
+          Formtastic::Helpers::FormHelper.builder = SimpleCaptcha::CustomFormBuilder
+        else
+          Formtastic::SemanticFormHelper.builder = SimpleCaptcha::CustomFormBuilder
+        end
+      end
+    end
+
+    config.app_middleware.use SimpleCaptcha::Middleware
+  end
+end
+
+

data/lib/simple_captcha/form_builder.rb

@@ -0,0 +1,41 @@
+module SimpleCaptcha
+  module FormBuilder
+    def self.included(base)
+      base.send(:include, SimpleCaptcha::ViewHelper)
+      base.send(:include, SimpleCaptcha::FormBuilder::ClassMethods)
+      base.send(:include, ActionView::Helpers)
+      base.send(:include, Sprockets::Helpers::RailsHelper)
+      base.send(:include, Sprockets::Helpers::IsolatedHelper)
+      
+      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={})
+          html = {:autocomplete => 'off', :required => 'required', :value => ''}
+          html.merge!(options[:input_html] || {})
+          html[:placeholder] = options[:placeholder] || I18n.t('simple_captcha.placeholder')
+          
+          text_field(:captcha, html) +
+          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::FormBuilder
+
+    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,86 @@
+require 'tempfile'
+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
+
+    if RUBY_VERSION < '1.9'
+      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
+    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 << "-gravity \"Center\""
+        params << "-pointsize 22"
+        params << "-implode 0.2"
+
+        dst = Tempfile.new(RUBY_VERSION < '1.9' ? 'simple_captcha.jpg' : ['simple_captcha', '.jpg'], SimpleCaptcha.tmp_path)
+        dst.binmode
+
+        #params << "label:#{text} '#{File.expand_path(dst.path)}'"
+        params << "label:#{text} \"#{File.expand_path(dst.path)}\""
+
+        SimpleCaptcha::Utils::run("convert", params.join(' '))
+
+        dst.close
+
+        File.expand_path(dst.path)
+        #dst
+      end
+  end
+end

data/lib/simple_captcha/middleware.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+module SimpleCaptcha
+  class Middleware
+    include SimpleCaptcha::ImageHelpers
+    
+    DEFAULT_SEND_FILE_OPTIONS = {
+      :type         => 'application/octet-stream'.freeze,
+      :disposition  => 'attachment'.freeze,
+    }.freeze
+    
+    def initialize(app, options={})
+      @app = app
+      self
+    end
+    
+    def call(env) # :nodoc:
+      if env["REQUEST_METHOD"] == "GET" && captcha_path?(env['PATH_INFO'])
+        make_image(env)
+      else
+        @app.call(env)
+      end
+    end
+    
+    protected
+      def make_image(env, headers = {}, status = 404)
+        request = Rack::Request.new(env)
+        code = request.params["code"]
+        body = []
+        
+        if !code.blank? && Utils::simple_captcha_value(code)
+          #status, headers, body = @app.call(env)
+          #status = 200
+          #body = generate_simple_captcha_image(code)
+          #headers['Content-Type'] = 'image/jpeg'
+          
+          return send_file(generate_simple_captcha_image(code), :type => 'image/jpeg', :disposition => 'inline', :filename =>  'simple_captcha.jpg')
+        end
+        
+        [status, headers, body]
+      end
+      
+      def captcha_path?(request_path)
+        request_path.include?('/simple_captcha')
+      end
+      
+      def send_file(path, options = {})
+        raise MissingFile, "Cannot read file #{path}" unless File.file?(path) and File.readable?(path)
+
+        options[:filename] ||= File.basename(path) unless options[:url_based_filename]
+
+        status = options[:status] || 200
+        headers = {"Content-Disposition" => "#{options[:disposition]}; filename='#{options[:filename]}'", "Content-Type" => options[:type], 'Content-Transfer-Encoding' => 'binary', 'Cache-Control' => 'private'}
+        response_body = File.open(path, "rb")
+        
+        [status, headers, response_body]
+      end
+  end
+end

data/lib/simple_captcha/simple_captcha_data.rb

@@ -0,0 +1,33 @@
+module SimpleCaptcha
+  class SimpleCaptchaData < ::ActiveRecord::Base
+    def self.rails3?
+      ::ActiveRecord::VERSION::MAJOR == 3
+    end
+
+    if rails3?
+      # Fixes deprecation warning in Rails 3.2:
+      # DEPRECATION WARNING: Calling set_table_name is deprecated. Please use `self.table_name = 'the_name'` instead.
+      self.table_name = "simple_captcha_data"
+    else
+      set_table_name "simple_captcha_data"
+    end
+    
+    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/simple_captcha_data_mongoid.rb

@@ -0,0 +1,25 @@
+module SimpleCaptcha
+  class SimpleCaptchaData
+    include Mongoid::Document
+    include Mongoid::Timestamps
+
+    field :key, type: String
+    field :value, type: String
+
+    class << self
+      def get_data(key)
+        data = where(:key => key).first || new(:key => key)
+      end
+      
+      def remove_data(key)
+        where(:key => key).delete_all
+        clear_old_data(1.hour.ago)
+      end
+      
+      def clear_old_data(time = 1.hour.ago)
+        return unless Time === time
+        where(:updated_at.lte => time).delete_all
+      end
+    end
+  end
+end

data/lib/simple_captcha/utils.rb

@@ -0,0 +1,36 @@
+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"
+
+      unless (image_magick_path = SimpleCaptcha.image_magick_path).blank?
+        command = File.join(image_magick_path, command)
+      end
+
+      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/version.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+module SimpleCaptcha
+  VERSION = "0.0.1".freeze
+end

data/lib/simple_captcha/view.rb

@@ -0,0 +1,115 @@
+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 = "#{ENV['RAILS_RELATIVE_URL_ROOT']}/simple_captcha?code=#{simple_captcha_key}&#{query}"
+        
+        tag('img', :src => url, :alt => 'captcha')
+      end
+      
+      def simple_captcha_field(options={})
+        html = {:autocomplete => 'off', :required => 'required'}
+        html.merge!(options[:input_html] || {})
+        html[:placeholder] = options[:placeholder] || I18n.t('simple_captcha.placeholder')
+          
+        if options[:object]
+          text_field(options[:object], :captcha, html.merge(:value => '')) +
+          hidden_field(options[:object], :captcha_key, {:value => options[:field_value]})
+        else
+          text_field_tag(:captcha, nil, html) +
+          hidden_field_tag(:captcha_key, options[:field_value])
+        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/lib/simple_captcha.rb

@@ -0,0 +1,62 @@
+# 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 :FormBuilder,       'simple_captcha/form_builder'
+  autoload :CustomFormBuilder, 'simple_captcha/formtastic'
+
+  if defined?(ActiveRecord)
+    autoload :ModelHelpers,      'simple_captcha/active_record'
+    autoload :SimpleCaptchaData, 'simple_captcha/simple_captcha_data'
+  else
+    autoload :SimpleCaptchaData,      'simple_captcha/simple_captcha_data_mongoid.rb'
+  end
+
+
+  autoload :Middleware,        'simple_captcha/middleware'
+
+  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'
+
+  # command path
+  mattr_accessor :image_magick_path
+  @@image_magick_path = ''
+
+  # tmp directory
+  mattr_accessor :tmp_path
+  @@tmp_path = nil
+
+  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/engine' if defined?(Rails)

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: loyal_simple_captcha
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Pavlo Galeta
+- Igor Galeta
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-26 00:00:00.000000000 Z
+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: galeta.igor@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.rdoc
+files:
+- lib/simple_captcha.rb
+- lib/simple_captcha/view.rb
+- lib/simple_captcha/simple_captcha_data.rb
+- lib/simple_captcha/simple_captcha_data_mongoid.rb
+- lib/simple_captcha/utils.rb
+- lib/simple_captcha/version.rb
+- lib/simple_captcha/form_builder.rb
+- lib/simple_captcha/engine.rb
+- lib/simple_captcha/active_record.rb
+- lib/simple_captcha/formtastic.rb
+- lib/simple_captcha/controller.rb
+- lib/simple_captcha/image.rb
+- lib/simple_captcha/middleware.rb
+- lib/generators/USAGE
+- lib/generators/simple_captcha_generator.rb
+- lib/generators/templates/partial.erb
+- lib/generators/templates/migration.rb
+- Rakefile
+- README.rdoc
+homepage: http://github.com/izzm/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
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: SimpleCaptcha is the simplest and a robust captcha plugin.
+test_files: []