green_light 0.0.2

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+**/**/.*.swp

data/Gemfile

@@ -0,0 +1,5 @@
+source 'http://rubygems.org'
+gem 'rails'
+gem "activerecord", :require => "active_record"
+gem 'rspec'
+gem 'supermodel'

data/README.rdoc

@@ -0,0 +1,52 @@
+= green_light
+
+Provides client side validation (with the help of the jquery validation plugin) while keeping validation in the model, where it belongs.
+
+
+== Installation
+
+Add green_light to your Gemfile and run the bundle install command.
+
+  gem 'green_light'
+  bundle install
+
+
+== Usage
+
+Run this generator to copy the required assets to your public folder:-
+
+  rails g green_light_assets
+
+Download jQuery and the {jQuery Validation Plugin}[http://bassistance.de/jquery-plugins/jquery-plugin-validation/] and include them in your layout header.
+
+Also, insert the following javascript include tag in your layout html header:-
+  
+  <%= javascript_include_tag 'jquery.validate_regex', 'green_light' %>
+
+Note, the green_light file specified above is generated dynamically, so it wont appear in your public javascripts folder.
+
+Add the <tt>green_light</tt> class to the forms that you wish to have client side validation:-
+
+  <%= form_for(@model, :html => { :class => 'green_light' }) do |f| %>
+
+And finally, add some validations to your models!
+
+
+== Currently Supports these validations
+  
+  validates_presence_of
+  validates_length_of
+  validates_format_of
+  validates_uniqueness_of
+  validates_numericality_of
+
+
+== Requirements
+
+  jQuery versions 1.3.2, 1.4.2, 1.4.4, 1.5.0, 1.5.1
+
+
+== Running the Tests
+
+  bundle install
+  bundle exec rspec spec

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/app/controllers/javascripts_controller.rb

@@ -0,0 +1,24 @@
+class JavascriptsController < ApplicationController
+  respond_to :js, :text
+
+  def green_light
+    @rules = GreenLight::Rules.generate(all_models)
+    respond_with(@rules)
+  end
+
+  def check_for_uniqueness
+    record = params[:model].constantize.where("#{params[:field]} = ?", params[params[:model].downcase.underscore][params[:field]])
+    if record.count > 0
+      render :text => "\"#{params[params[:model].downcase.underscore][params[:field]]} is already taken.\""
+    else
+      render :text => true
+    end
+  end
+
+  private
+    def all_models
+      tables = ActiveRecord::Base.connection.tables
+      tables.delete("schema_migrations")
+      tables.map { |table| table.camelize.singularize.constantize }
+    end
+end

data/app/views/javascripts/green_light.js.erb

@@ -0,0 +1,3 @@
+$().ready(function() {
+  $(".green_light").validate(<%= @rules.html_safe %>);
+});

data/config/routes.rb

@@ -0,0 +1,4 @@
+Rails.application.routes.draw do
+  match "/javascripts/green_light" => "javascripts#green_light"
+  match "/javascripts/check_for_uniqueness" => "javascripts#check_for_uniqueness"
+end

data/green_light.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "green_light/version"
+
+Gem::Specification.new do |s|
+  s.name        = "green_light"                                                                                                                                                                              
+  s.version     = GreenLight::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Phil McClure"]
+  s.email       = ["pmcclure@rumblelabs.com"]
+  s.homepage    = "http://www.rumblelabs.com"
+  s.summary     = %q{Simple client side validation that keeps validation in the models}
+  s.description = %q{Simple client side validation that keeps validation in the models}
+
+  s.rubyforge_project = "green_light"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/green_light.rb

@@ -0,0 +1,14 @@
+require 'active_support/all'
+require File.join(File.dirname(__FILE__), 'green_light/engine')
+
+module GreenLight
+  autoload :Rules,                          'green_light/rules'
+
+  module Validations
+    autoload :ValidatesFormatOf,            'green_light/validations/validates_format_of'
+    autoload :ValidatesLengthOf,            'green_light/validations/validates_length_of'
+    autoload :ValidatesNumericalityOf,      'green_light/validations/validates_numericality_of'
+    autoload :ValidatesPresenceOf,          'green_light/validations/validates_presence_of'
+    autoload :ValidatesUniquenessOf,        'green_light/validations/validates_uniqueness_of'
+  end
+end

data/lib/green_light/engine.rb

@@ -0,0 +1,4 @@
+module GreenLight #:nodoc:
+  class Engine < ::Rails::Engine #:nodoc:
+  end
+end

data/lib/green_light/rules.rb

@@ -0,0 +1,34 @@
+module GreenLight
+  class Rules
+    include Validations::ValidatesFormatOf
+    include Validations::ValidatesLengthOf
+    include Validations::ValidatesNumericalityOf
+    include Validations::ValidatesPresenceOf
+    include Validations::ValidatesUniquenessOf
+
+    def self.generate(models)
+      data, rules = {}, {}
+      models.each do |model| 
+        model._validators.each do |field_name, validations| 
+          rules["#{model.to_s.underscore.downcase}[#{field_name}]"] = parse_each_validation(model, field_name, validations)
+          data[:rules] = rules
+        end
+      end
+      data.merge!({:errorElement => "span"})
+      data.to_json
+    end
+
+    private
+      def self.parse_each_validation(model, field_name, validation_objs)
+        data, params = {}, {}
+        params[:model], params[:field_name] = model, field_name
+        validation_objs.each do |val_obj|
+          params[:val_obj] = val_obj
+          # Call each validation method
+          result = send(val_obj.class.name.split('::').last.underscore, params)
+          data.merge!(result) unless result.nil?
+        end
+        data
+      end
+  end
+end

data/lib/green_light/validations/validates_format_of.rb

@@ -0,0 +1,14 @@
+module GreenLight
+  module Validations
+    module ValidatesFormatOf
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def format_validator(params = {})
+          {:regex => "#{params[:val_obj].options[:with]}".gsub('?-mix:', '')}
+        end
+      end
+    end
+  end
+end
+

data/lib/green_light/validations/validates_length_of.rb

@@ -0,0 +1,16 @@
+module GreenLight
+  module Validations
+    module ValidatesLengthOf
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def length_validator(params = {})
+          min, max = {}, {}
+          min = {:minlength => params[:val_obj].options[:minimum]} if params[:val_obj].options[:minimum]
+          max = {:maxlength => params[:val_obj].options[:maximum]} if params[:val_obj].options[:maximum]
+          min.merge!(max)
+        end
+      end
+    end
+  end
+end

data/lib/green_light/validations/validates_numericality_of.rb

@@ -0,0 +1,14 @@
+module GreenLight
+  module Validations
+    module ValidatesNumericalityOf
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def numericality_validator(params = {})
+          {:regex => "^[0-9]*$"}
+        end
+      end
+    end
+  end
+end
+

data/lib/green_light/validations/validates_presence_of.rb

@@ -0,0 +1,14 @@
+module GreenLight
+  module Validations
+    module ValidatesPresenceOf
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def presence_validator(params = {})
+          {:required => true}
+        end
+      end
+    end
+  end
+end
+

data/lib/green_light/validations/validates_uniqueness_of.rb

@@ -0,0 +1,13 @@
+module GreenLight
+  module Validations
+    module ValidatesUniquenessOf
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def uniqueness_validator(params = {})
+          { :remote => "/javascripts/check_for_uniqueness?model=#{params[:model].to_s}&field=#{params[:field_name]}" }
+        end
+      end
+    end
+  end
+end

data/lib/green_light/version.rb

@@ -0,0 +1,3 @@
+module GreenLight
+  VERSION = "0.0.2"
+end

data/lib/rails/generators/green_light_assets/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Explain the generator
+
+Example:
+    rails generate green_light_assets
+
+    This will create:
+        what/will/it/create

data/lib/rails/generators/green_light_assets/green_light_assets_generator.rb

@@ -0,0 +1,23 @@
+require 'rails/generators'
+
+class GreenLightAssetsGenerator < Rails::Generators::Base
+  source_root File.expand_path('../templates', __FILE__)
+
+  def generate_assets
+    unless File.exists?("public/javascripts/jquery.validate_regex.js")
+      copy_file "jquery.validate_regex.js", "public/javascripts/jquery.validate_regex.js"
+    else
+      puts "public/javascripts/jquery.validate_regex.js already exists."
+    end
+    
+    puts "Nearly there!  Just download the jQuery Validate plugin (http://jquery.bassistance.de/validate/jquery-validation-1.8.0.zip)"
+    puts "and jQuery 1.3.2, 1.4.2, 1.4.4, 1.5.0, 1.5.1."
+    puts ""
+    puts "Include the above in your layout header."
+    puts ""
+    puts "Also, insert the following code in your layout header"
+    puts ""
+    puts "<%= javascript_include_tag 'jquery.validate_regex', 'green_light' %>"
+    puts ""
+  end
+end

data/lib/rails/generators/green_light_assets/templates/jquery.validate_regex.js

@@ -0,0 +1,9 @@
+$.validator.addMethod(
+  "regex",
+  function(value, element, regexp) {
+    var check = false;
+    var re = new RegExp(regexp);
+    return this.optional(element) || re.test(value);
+  },
+  "You have entered an invalid value for this field"
+);

data/spec/green_light_spec.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe GreenLight do
+  before(:all) do
+  end
+      
+  it "should return a valid json string when validating the format of a field" do
+    rules = GreenLight::Rules.generate([FormatOfModel])
+    rules.should == "{\"errorElement\":\"span\",\"rules\":{\"format_of_model[title]\":{\"regex\":\"(^[A-Za-z]$)\"}}}"
+  end
+
+  it "should return a json string when validating the presence of a field" do
+    rules = GreenLight::Rules.generate([PresenceOfModel])
+    rules.should == "{\"errorElement\":\"span\",\"rules\":{\"presence_of_model[title]\":{\"required\":true}}}"
+  end
+
+  it "should return a json string when validating the length of a field" do
+    rules = GreenLight::Rules.generate([LengthOfModel])
+    rules.should == "{\"errorElement\":\"span\",\"rules\":{\"length_of_model[title]\":{\"maxlength\":10,\"minlength\":5}}}"
+  end
+
+  it "should return a json string when validating the numericality of a field" do
+    rules = GreenLight::Rules.generate([NumericalityOfModel])
+    rules.should == "{\"errorElement\":\"span\",\"rules\":{\"numericality_of_model[age]\":{\"regex\":\"^[0-9]*$\"}}}"
+  end
+
+  it "should return a json string when validating the uniqueness of a field" do
+    rules = GreenLight::Rules.generate([UniquenessOfModel])
+    rules.should == "{\"errorElement\":\"span\",\"rules\":{\"uniqueness_of_model[title]\":{\"remote\":\"/javascripts/check_for_uniqueness?model=UniquenessOfModel&field=title\"}}}"
+  end
+end
+
+class FormatOfModel < SuperModel::Base
+  validates_format_of :title, :with => /^[A-Za-z]$/
+end
+
+class PresenceOfModel < SuperModel::Base
+  validates_presence_of :title
+end
+
+class LengthOfModel < SuperModel::Base
+  validates_length_of :title, :within => 5..10
+end
+
+class NumericalityOfModel < SuperModel::Base
+  validates_numericality_of :age
+end
+
+class UniquenessOfModel < SuperModel::Base
+  validates_uniqueness_of :title
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'rspec'
+require 'rails'
+require 'active_record'
+require 'supermodel'
+require File.dirname(__FILE__) + '/../lib/green_light'

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: green_light
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- Phil McClure
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-04 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Simple client side validation that keeps validation in the models
+email: 
+- pmcclure@rumblelabs.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- app/controllers/javascripts_controller.rb
+- app/views/javascripts/green_light.js.erb
+- config/routes.rb
+- green_light.gemspec
+- lib/green_light.rb
+- lib/green_light/engine.rb
+- lib/green_light/rules.rb
+- lib/green_light/validations/validates_format_of.rb
+- lib/green_light/validations/validates_length_of.rb
+- lib/green_light/validations/validates_numericality_of.rb
+- lib/green_light/validations/validates_presence_of.rb
+- lib/green_light/validations/validates_uniqueness_of.rb
+- lib/green_light/version.rb
+- lib/rails/generators/green_light_assets/USAGE
+- lib/rails/generators/green_light_assets/green_light_assets_generator.rb
+- lib/rails/generators/green_light_assets/templates/jquery.validate_regex.js
+- spec/green_light_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://www.rumblelabs.com
+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: green_light
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Simple client side validation that keeps validation in the models
+test_files: []
+