pluginaweek-smart_field_constraints 0.1.1

data/CHANGELOG.rdoc

@@ -0,0 +1,25 @@
+== master
+
+== 0.1.1 / 2009-03-15
+
+* Fix limits for integer columns being interpreted incorrectly [Michael Grosser]
+
+== 0.1.0 / 2008-12-14
+
+* Remove the PluginAWeek namespace
+* Update tests to use ActionView::TestCase
+
+== 0.0.2 / 2008-06-22
+
+* Remove log files from gems
+* Don't check length validation constraints if models were loaded prior to the plugin being loaded [Michael Grosser]
+* Refactor FormHelper extension to allow for others to easily extend the plugin for things like textarea lengths [Michael Grosser]
+* Add support for tracking validates_size_of validations
+
+== 0.0.1 / 2008-05-05
+
+* Initial public release
+* Add documentation
+* Remove maxlength attribute for textare tags since it's not valid html
+* Don't set the size based on the smart maxlength
+* Don't expect columns to exist for every attribute

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007-2009 Aaron Pfeifer
+
+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.rdoc

@@ -0,0 +1,92 @@
+= smart_field_constraints
+
++smart_field_constraints+ intelligently applies a maxlength attribute for text
+fields based on column constraints and validations.
+
+== Resources
+
+API
+
+* http://api.pluginaweek.org/smart_field_constraints
+
+Bugs
+
+* http://pluginaweek.lighthouseapp.com/projects/13287-smart_field_constraints
+
+Development
+
+* http://github.com/pluginaweek/smart_field_constraints
+
+Source
+
+* git://github.com/pluginaweek/smart_field_constraints.git
+
+== Description
+
+HTML input field restrictions within forms can often help with both validation
+and improving the user experience. Normally, adding the +maxlength+ configuration
+option for input fields is not DRY and duplicates data already available in the
+model or database. This plugin helps make this automatic.
+
++smart_field_constraints+ looks in two places for determining the maxlength value
+for an input field:
+* Model validates_length_of/validates_size_of validations
+* Database column definitions (limits specifically)
+
+Model validations will always take preference over database column definitions.
+
+== Usage
+
+There's nothing that you need to change to be able to use this plugin. It'll
+just start automatically adding the +maxlength+ values it finds based on the
+information described above (unless you define that option yourself).
+
+=== Example
+
+Model:
+  class User < ActiveRecord::Base
+    validates_length_of :login, :maximum => 12
+  end
+
+View:
+  text_field(:user, :login)
+
+HTML:
+  <input id="user_login" maxlength="12" name="user[login]" size="30" type="text" />
+
+=== Textarea maxlengths
+
+Since the +maxlength+ attribute is not W3C-compliant for textareas, it is not
+included in the types of fields that will be automatically assigned length
+constraints.  However, you can easily add this yourself by extending the plugin
+yourself.  For an example of this see smart_field_constraints_textarea[http://github.com/grosser/smart_field_constraints_textarea].
+
+== Caveats
+
+=== Plugin load order
+
+If you have plugins with models that are loaded *before* smart_field_constraints
+is loaded, then any length validations defined in those models will *not* be
+tracked and automatically used in form fields.  To fix this, you can adjust your
+application's plugin load order to ensure that smart_field_constraints is loaded
+first:
+
+config/environment.rb:
+  Rails::Initializer.run do |config|
+    ...
+    config.plugins = [:smart_field_constraints, :all]
+    ...
+  end
+
+== Testing
+
+Before you can run any tests, the following gem must be installed:
+* plugin_test_helper[http://github.com/pluginaweek/plugin_test_helper]
+
+To run against a specific version of Rails:
+
+  rake test RAILS_FRAMEWORK_ROOT=/path/to/rails
+
+== Dependencies
+
+* Rails 2.0 or later

data/Rakefile

@@ -0,0 +1,96 @@
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/gempackagetask'
+require 'rake/contrib/sshpublisher'
+
+spec = Gem::Specification.new do |s|
+  s.name              = 'smart_field_constraints'
+  s.version           = '0.1.1'
+  s.platform          = Gem::Platform::RUBY
+  s.summary           = 'Intelligently applies a maxlength attribute for text fields based on column constraints and validations'
+  s.description       = s.summary
+  
+  s.files             = FileList['{lib,test}/**/*'] + %w(CHANGELOG.rdoc init.rb LICENSE Rakefile README.rdoc) - FileList['test/app_root/{log,log/*,script,script/*}']
+  s.require_path      = 'lib'
+  s.has_rdoc          = true
+  s.test_files        = Dir['test/**/*_test.rb']
+  
+  s.author            = 'Aaron Pfeifer'
+  s.email             = 'aaron@pluginaweek.org'
+  s.homepage          = 'http://www.pluginaweek.org'
+  s.rubyforge_project = 'pluginaweek'
+end
+  
+desc 'Default: run all tests.'
+task :default => :test
+
+desc "Test the #{spec.name} plugin."
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.test_files = spec.test_files
+  t.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  namespace :test do
+    desc "Test the #{spec.name} plugin with Rcov."
+    Rcov::RcovTask.new(:rcov) do |t|
+      t.libs << 'lib'
+      t.test_files = spec.test_files
+      t.rcov_opts << '--exclude="^(?!lib/)"'
+      t.verbose = true
+    end
+  end
+rescue LoadError
+end
+
+desc "Generate documentation for the #{spec.name} plugin."
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = spec.name
+  rdoc.template = '../rdoc_template.rb'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc', 'CHANGELOG.rdoc', 'LICENSE', 'lib/**/*.rb')
+end
+
+desc 'Generate a gemspec file.'
+task :gemspec do
+  File.open("#{spec.name}.gemspec", 'w') do |f|
+    f.write spec.to_ruby
+  end
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+desc 'Publish the beta gem.'
+task :pgem => [:package] do
+  Rake::SshFilePublisher.new('aaron@pluginaweek.org', '/home/aaron/gems.pluginaweek.org/public/gems', 'pkg', "#{spec.name}-#{spec.version}.gem").upload
+end
+
+desc 'Publish the API documentation.'
+task :pdoc => [:rdoc] do
+  Rake::SshDirPublisher.new('aaron@pluginaweek.org', "/home/aaron/api.pluginaweek.org/public/#{spec.name}", 'rdoc').upload
+end
+
+desc 'Publish the API docs and gem'
+task :publish => [:pgem, :pdoc, :release]
+
+desc 'Publish the release files to RubyForge.'
+task :release => [:gem, :package] do
+  require 'rubyforge'
+  
+  ruby_forge = RubyForge.new.configure
+  ruby_forge.login
+  
+  %w(gem tgz zip).each do |ext|
+    file = "pkg/#{spec.name}-#{spec.version}.#{ext}"
+    puts "Releasing #{File.basename(file)}..."
+    
+    ruby_forge.add_release(spec.rubyforge_project, spec.name, spec.version, file)
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+require 'smart_field_constraints'

data/lib/smart_field_constraints.rb

@@ -0,0 +1,2 @@
+require 'smart_field_constraints/extensions/form_helper'
+require 'smart_field_constraints/extensions/validations'

data/lib/smart_field_constraints/extensions/form_helper.rb

@@ -0,0 +1,62 @@
+module SmartFieldConstraints
+  module Extensions #:nodoc:
+    # Automatically applies the maximum length for an input field if it can be
+    # determined
+    module InstanceTag
+      def self.included(base) #:nodoc:
+        base.class_eval do
+          alias_method_chain :to_input_field_tag, :smart_constraints
+        end
+      end
+      
+      # Apply constraints for the given field
+      def to_input_field_tag_with_smart_constraints(field_type, options = {})
+        # Only check password and text fields
+        add_max_length_constraints(options) if %w(password text).include?(field_type)
+        
+        to_input_field_tag_without_smart_constraints(field_type, options)
+      end
+      
+      private
+        def add_max_length_constraints(options)
+          options.stringify_keys!
+          return if options['maxlength'] || !object
+          
+          # Look for the attribute's maximum length from tracked validations or
+          # the column's definition
+          if max_length = validation_length || column_limit
+            # If the size isn't specified, use the caller's maxlength of the default value.
+            # This must be done here, otherwise it'll use the maxlength value that
+            # we apply here
+            options['size'] ||= options['maxlength'] || ActionView::Helpers::InstanceTag::DEFAULT_FIELD_OPTIONS['size']
+            options['maxlength'] = max_length
+          end
+        end
+        
+        # Finds the maximum length according to validations
+        def validation_length
+          if constraints = object.class.smart_length_constraints
+            constraints[method_name]
+          end
+        end
+        
+        # Finds the maximum length according to column limits
+        def column_limit
+          column = object.class.columns_hash[method_name]
+          
+          if column && limit = column.limit
+            if column.text?
+              limit
+            elsif column.number?
+              # Length is bound by the upper limit of the number + 1 (for negatives)
+              Math.log10(2 ** (limit * 8 - 1)).ceil + 1
+            end
+          end
+        end
+    end
+  end
+end
+
+ActionView::Helpers::InstanceTag.class_eval do
+  include SmartFieldConstraints::Extensions::InstanceTag
+end

data/lib/smart_field_constraints/extensions/validations.rb

@@ -0,0 +1,74 @@
+module SmartFieldConstraints
+  module Extensions #:nodoc:
+    # Tracks validations on the length of fields so that they can be used when
+    # generating form tags for those fields
+    module Validations
+      def self.included(base) #:nodoc:
+        base.class_eval do
+          extend SmartFieldConstraints::Extensions::Validations::ClassMethods
+        end
+      end
+      
+      module ClassMethods
+        def self.extended(base) #:nodoc:
+          base.class_eval do
+            class_inheritable_hash :smart_length_constraints
+            self.smart_length_constraints = {}
+          end
+          
+          class << base
+            alias_method_chain :validates_length_of, :smart_constraints
+            alias_method_chain :validates_size_of, :smart_constraints
+          end
+        end
+        
+        # Tracks what the maximum value is that's allowed for all of the
+        # attributes being validated
+        def validates_length_of_with_smart_constraints(*attrs)
+          track_length_constraints(attrs)
+          validates_length_of_without_smart_constraints(*attrs)
+        end
+        
+        # Tracks what the maximum value is that's allowed for all of the
+        # attributes being validated
+        def validates_size_of_with_smart_constraints(*attrs)
+          track_length_constraints(attrs)
+          validates_size_of_without_smart_constraints(*attrs)
+        end
+        
+        private
+          def track_length_constraints(attrs)
+            options = attrs.last
+            if options.is_a?(Hash)
+              # Extract the option restricting the length
+              options = options.symbolize_keys
+              range_options = ActiveRecord::Validations::ClassMethods::ALL_RANGE_OPTIONS & options.keys
+              option = range_options.first
+              option_value = options[range_options.first]
+              
+              # Find the max value from ranges or specific maximums
+              max_length = nil
+              case option
+              when :within, :in
+                max_length = option_value.end
+              when :maximum, :is
+                max_length = option_value
+              end
+              
+              if max_length
+                # Store the maximum value for each attribute so that it can be referenced later
+                attrs.each do |attr|
+                  self.smart_length_constraints ||= {}
+                  self.smart_length_constraints[attr.to_s] = max_length
+                end
+              end
+            end
+          end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  include SmartFieldConstraints::Extensions::Validations
+end

data/test/app_root/app/models/user.rb

@@ -0,0 +1,2 @@
+class User < ActiveRecord::Base
+end

data/test/app_root/config/environment.rb

@@ -0,0 +1,8 @@
+require 'config/boot'
+
+Rails::Initializer.run do |config|
+  config.plugins = %w(tags smart_field_constraints)
+  config.cache_classes = false
+  config.whiny_nils = true
+  config.action_controller.session = {:key => 'rails_session', :secret => 'd229e4d22437432705ab3985d4d246'}
+end

data/test/app_root/db/migrate/001_create_users.rb

@@ -0,0 +1,14 @@
+class CreateUsers < ActiveRecord::Migration
+  def self.up
+    create_table :users, :id => false do |t|
+      t.integer :id, :limit => 4, :null => false # For limit for testing purposes
+      t.string :login, :limit => 12
+      t.string :password, :limit => 16
+      t.text :biography
+    end
+  end
+  
+  def self.down
+    drop_table :users
+  end
+end

data/test/app_root/db/migrate/002_create_tags.rb

@@ -0,0 +1,11 @@
+class CreateTags < ActiveRecord::Migration
+  def self.up
+    create_table :tags do |t|
+      t.string :name, :limit => 100
+    end
+  end
+  
+  def self.down
+    drop_table :tags
+  end
+end

data/test/app_root/vendor/plugins/tags/init.rb

@@ -0,0 +1 @@
+require 'tag'

data/test/app_root/vendor/plugins/tags/lib/tag.rb

@@ -0,0 +1,3 @@
+class Tag < ActiveRecord::Base
+  validates_length_of :name, :maximum => 30
+end

data/test/helpers/form_helper_test.rb

@@ -0,0 +1,110 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class FormHelperWithoutConstraintsTest < ActionView::TestCase
+  tests ActionView::Helpers::FormHelper
+  
+  def setup
+    @user = User.new
+  end
+  
+  def test_should_not_add_maxlength_for_text_field
+    assert_equal '<input id="user_biography" name="user[biography]" size="30" type="text" />', text_field(:user, :biography)
+  end
+  
+  def test_should_not_add_maxlength_for_password_field
+    assert_equal '<input id="user_biography" name="user[biography]" size="30" type="password" />', password_field(:user, :biography)
+  end
+end
+
+class FormHelperWithValidationConstraintsTest < ActionView::TestCase
+  tests ActionView::Helpers::FormHelper
+  
+  def setup
+    User.validates_length_of :biography, :maximum => 120
+    User.validates_length_of :password, :maximum => 14
+    
+    @user = User.new
+  end
+  
+  def test_should_not_add_maxlength_for_text_area
+    assert_equal '<textarea cols="40" id="user_biography" name="user[biography]" rows="20"></textarea>', text_area(:user, :biography)
+  end
+  
+  def test_should_not_add_maxlength_for_hidden_field
+    assert_equal '<input id="user_password" name="user[password]" type="hidden" />', hidden_field(:user, :password)
+  end
+  
+  def test_should_add_maxlength_for_password_field
+    assert_equal '<input id="user_password" maxlength="14" name="user[password]" size="30" type="password" />', password_field(:user, :password)
+  end
+  
+  def test_should_add_maxlength_for_text_field
+    assert_equal '<input id="user_biography" maxlength="120" name="user[biography]" size="30" type="text" />', text_field(:user, :biography)
+  end
+  
+  def test_should_allow_maxlength_to_be_overridden
+    assert_equal '<input id="user_biography" maxlength="100" name="user[biography]" size="100" type="text" />', text_field(:user, :biography, :maxlength => 100)
+  end
+  
+  def teardown
+    User.class_eval do
+      ActiveRecord::Validations::VALIDATIONS.each do |validation|
+        instance_variable_set("@#{validation}_callbacks", nil)
+      end
+    end
+    
+    User.smart_length_constraints.clear
+  end
+end
+
+class FormHelperWithStringColumnConstraintsTest < ActionView::TestCase
+  tests ActionView::Helpers::FormHelper
+  
+  def setup
+    @user = User.new
+  end
+  
+  def test_should_not_add_maxlength_for_text_area
+    assert_equal '<textarea cols="40" id="user_login" name="user[login]" rows="20"></textarea>', text_area(:user, :login)
+  end
+  
+  def test_should_not_add_maxlength_for_hidden_field
+    assert_equal '<input id="user_password" name="user[password]" type="hidden" />', hidden_field(:user, :password)
+  end
+  
+  def test_should_add_maxlength_for_password_field
+    assert_equal '<input id="user_password" maxlength="16" name="user[password]" size="30" type="password" />', password_field(:user, :password)
+  end
+  
+  def test_should_add_maxlength_for_text_field
+    assert_equal '<input id="user_login" maxlength="12" name="user[login]" size="30" type="text" />', text_field(:user, :login)
+  end
+  
+  def test_should_allow_maxlength_to_be_overridden
+    assert_equal '<input id="user_login" maxlength="100" name="user[login]" size="100" type="text" />', text_field(:user, :login, :maxlength => 100)
+  end
+end
+
+class FormHelperWithNumberColumnConstraintsTest < ActionView::TestCase
+  tests ActionView::Helpers::FormHelper
+  
+  def setup
+    @user = User.new
+  end
+  
+  def test_should_add_maxlength
+    assert_equal '<input id="user_id" maxlength="11" name="user[id]" size="30" type="text" />', text_field(:user, :id)
+  end
+end
+
+class FormHelperForModelNotTrackedTest < ActionView::TestCase
+  tests ActionView::Helpers::FormHelper
+  
+  def setup
+    @tag = Tag.new
+  end
+  
+  def test_should_add_maxlength_based_on_column_constraints
+    assert_equal '<input id="tag_name" maxlength="100" name="tag[name]" size="30" type="text" />', text_field(:tag, :name)
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,7 @@
+# Load the plugin testing framework
+$:.unshift("#{File.dirname(__FILE__)}/../../plugin_test_helper/lib")
+require 'rubygems'
+require 'plugin_test_helper'
+
+# Run the migrations
+ActiveRecord::Migrator.migrate("#{Rails.root}/db/migrate")

data/test/unit/validations_test.rb

@@ -0,0 +1,61 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class ModelWithoutLengthValidationsTest < ActiveSupport::TestCase
+  def test_should_not_have_any_constraints
+    assert User.smart_length_constraints.empty?
+  end
+end
+
+class ModelWithLengthValidationsTest < ActiveSupport::TestCase
+  def test_should_not_track_constraint_for_minimum
+    User.validates_length_of :name, :minimum => 1
+    assert_nil User.smart_length_constraints['name']
+  end
+  
+  def test_should_track_constraint_for_within
+    User.validates_length_of :name, :within => 1..10
+    assert_equal 10, User.smart_length_constraints['name']
+  end
+  
+  def test_should_track_constraint_for_in
+    User.validates_length_of :name, :in => 1..10
+    assert_equal 10, User.smart_length_constraints['name']
+  end
+  
+  def test_should_track_constraint_for_maximum
+    User.validates_length_of :name, :maximum => 10
+    assert_equal 10, User.smart_length_constraints['name']
+  end
+  
+  def test_should_track_validation_for_is
+    User.validates_length_of :name, :is => 10
+    assert_equal 10, User.smart_length_constraints['name']
+  end
+  
+  def teardown
+    User.class_eval do
+      ActiveRecord::Validations::VALIDATIONS.each do |validation|
+        instance_variable_set("@#{validation}_callbacks", nil)
+      end
+    end
+    
+    User.smart_length_constraints.clear
+  end
+end
+
+class ModelWithSizeValidationsTest < ActiveSupport::TestCase
+  def test_should_track_constraints
+    User.validates_size_of :name, :maximum => 10
+    assert_equal 10, User.smart_length_constraints['name']
+  end
+  
+  def teardown
+    User.class_eval do
+      ActiveRecord::Validations::VALIDATIONS.each do |validation|
+        instance_variable_set("@#{validation}_callbacks", nil)
+      end
+    end
+    
+    User.smart_length_constraints.clear
+  end
+end

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification 
+name: pluginaweek-smart_field_constraints
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Aaron Pfeifer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-08 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Intelligently applies a maxlength attribute for text fields based on column constraints and validations
+email: aaron@pluginaweek.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/smart_field_constraints
+- lib/smart_field_constraints/extensions
+- lib/smart_field_constraints/extensions/validations.rb
+- lib/smart_field_constraints/extensions/form_helper.rb
+- lib/smart_field_constraints.rb
+- test/unit
+- test/unit/validations_test.rb
+- test/helpers
+- test/helpers/form_helper_test.rb
+- test/app_root
+- test/app_root/app
+- test/app_root/app/models
+- test/app_root/app/models/user.rb
+- test/app_root/vendor
+- test/app_root/vendor/plugins
+- test/app_root/vendor/plugins/tags
+- test/app_root/vendor/plugins/tags/lib
+- test/app_root/vendor/plugins/tags/lib/tag.rb
+- test/app_root/vendor/plugins/tags/init.rb
+- test/app_root/db
+- test/app_root/db/migrate
+- test/app_root/db/migrate/001_create_users.rb
+- test/app_root/db/migrate/002_create_tags.rb
+- test/app_root/config
+- test/app_root/config/environment.rb
+- test/test_helper.rb
+- CHANGELOG.rdoc
+- init.rb
+- LICENSE
+- Rakefile
+- README.rdoc
+has_rdoc: true
+homepage: http://www.pluginaweek.org
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: pluginaweek
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Intelligently applies a maxlength attribute for text fields based on column constraints and validations
+test_files: 
+- test/unit/validations_test.rb
+- test/helpers/form_helper_test.rb