validates_timeliness 2.3.2 → 3.0.0.beta

data/Rakefile

@@ -1,52 +1,66 @@
 require 'rubygems'
+require 'rake/rdoctask'
 require 'rake/gempackagetask'
 require 'rubygems/specification'
-require 'date'
-require 'spec/rake/spectask'
+require 'rspec/core/rake_task'
 require 'lib/validates_timeliness/version'
 
-GEM = "validates_timeliness"
+GEM_NAME = "validates_timeliness"
 GEM_VERSION = ValidatesTimeliness::VERSION
 
 spec = Gem::Specification.new do |s|
-  s.name = GEM
+  s.name = GEM_NAME
   s.version = GEM_VERSION
   s.platform = Gem::Platform::RUBY
-  s.rubyforge_project = "validatestime"
+  s.rubyforge_project = "validates_timeliness"
   s.has_rdoc = true
-  s.extra_rdoc_files = ["README.rdoc", "LICENSE", "TODO", "CHANGELOG"]
-  s.summary = "Date and time validation plugin for Rails 2.x which allows custom formats"
+  s.extra_rdoc_files = ["README.rdoc", "LICENSE", "CHANGELOG"]
+  s.summary = %q{Date and time validation plugin for Rails which allows custom formats}
   s.description = s.summary
   s.author = "Adam Meehan"
   s.email = "adam.meehan@gmail.com"
   s.homepage = "http://github.com/adzap/validates_timeliness"
 
   s.require_path = 'lib'
-  s.autorequire = GEM
-  s.files = %w(LICENSE README.rdoc Rakefile TODO CHANGELOG) + Dir.glob("{lib,spec}/**/*")
+  s.autorequire = GEM_NAME
+  s.files = %w(validates_timeliness.gemspec LICENSE CHANGELOG README.rdoc Rakefile) + Dir.glob("{lib,spec}/**/*")
 end
 
+desc 'Default: run specs.'
 task :default => :spec
 
 desc "Run specs"
-Spec::Rake::SpecTask.new do |t|
-  t.spec_files = FileList['spec/**/*_spec.rb']
-  t.spec_opts = %w(--color)
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
 end
 
+desc "Generate code coverage"
+RSpec::Core::RakeTask.new(:coverage) do |t|
+  t.rcov = true
+  t.rcov_opts = ['--exclude', 'spec']
+end
+
+desc 'Generate documentation for plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ValidatesTimeliness'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
 
 Rake::GemPackageTask.new(spec) do |pkg|
   pkg.gem_spec = spec
 end
 
-desc "install the gem locally"
+desc "Install the gem locally"
 task :install => [:package] do
-  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION}}
+  sh %{gem install pkg/#{GEM_NAME}-#{GEM_VERSION}}
 end
 
-desc "create a gemspec file"
+desc "Create a gemspec file"
 task :make_spec do
-  File.open("#{GEM}.gemspec", "w") do |file|
+  File.open("#{GEM_NAME}.gemspec", "w") do |file|
     file.puts spec.to_ruby
   end
 end

data/lib/generators/validates_timeliness/install_generator.rb

@@ -0,0 +1,17 @@
+module ValidatesTimeliness
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      desc "Copy ValidatesTimeliness default files"
+      source_root File.expand_path('../templates', __FILE__)
+      class_option :template_engine
+
+      def copy_initializers
+        copy_file 'validates_timeliness.rb', 'config/initializers/validates_timeliness.rb'
+      end
+
+      def copy_locale_file
+        copy_file 'en.yml', 'config/locales/validates_timeliness.en.yml'
+      end
+    end
+  end
+end

data/lib/generators/validates_timeliness/templates/en.yml

@@ -0,0 +1,16 @@
+en:
+  errors:
+    messages:
+      invalid_date: "is not a valid date"
+      invalid_time: "is not a valid time"
+      invalid_datetime: "is not a valid datetime"
+      is_at: "must be at %{restriction}"
+      before: "must be before %{restriction}"
+      on_or_before: "must be on or before %{restriction}"
+      after: "must be after %{restriction}"
+      on_or_after: "must be on or after %{restriction}"
+  validates_timeliness:
+    error_value_formats:
+      date: '%Y-%m-%d'
+      time: '%H:%M:%S'
+      datetime: '%Y-%m-%d %H:%M:%S'

data/lib/generators/validates_timeliness/templates/validates_timeliness.rb

@@ -0,0 +1,22 @@
+ValidatesTimeliness.setup do |config|
+  # Add plugin to supported ORMs (only :active_record for now)
+  # config.extend_orms = [ :active_record ]
+  #
+  # Set the dummy date part for a time type values.
+  # config.dummy_date_for_time_type = [ 2000, 1, 1 ]
+  #
+  # Ignore errors when restriction options are evaluated
+  # config.ignore_restriction_errors = false
+  #
+  # Re-display invalid values in date/time selects
+  # config.enable_date_time_select_extension!
+  #
+  # Handle multiparameter date/time values strictly
+  # config.enable_multiparameter_extension!
+  #
+  # Shorthand date and time symbols for restrictions
+  # config.restriction_shorthand_symbols.update(
+  #   :now   => lambda { Time.now },
+  #   :today => lambda { Date.today }
+  # )
+end

data/lib/validates_timeliness.rb

@@ -1,59 +1,53 @@
-require 'validates_timeliness/formats'
-require 'validates_timeliness/parser'
-require 'validates_timeliness/validator'
-require 'validates_timeliness/validation_methods'
-require 'validates_timeliness/active_record/attribute_methods'
-require 'validates_timeliness/active_record/multiparameter_attributes'
-require 'validates_timeliness/action_view/instance_tag'
-begin
-  i18n_path = $:.grep(/active_support\/vendor\/i18n-/)
-  if i18n_path.empty?
-    require 'i18n/version'
-  else
-    require i18n_path[0] + '/version'
-  end
-rescue LoadError
-end if defined?(I18n)
+require 'date'
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/string/conversions'
+require 'active_support/core_ext/date/acts_like'
+require 'active_support/core_ext/date/conversions'
+require 'active_support/core_ext/time/acts_like'
+require 'active_support/core_ext/time/conversions'
+require 'active_support/core_ext/date_time/acts_like'
+require 'active_support/core_ext/date_time/conversions'
 
 module ValidatesTimeliness
+  autoload :VERSION, 'validates_timeliness/version'
+
+  # Add plugin to supported ORMs (only :active_record for now)
+  mattr_accessor :extend_orms
+  @@extend_orms = [ defined?(ActiveRecord) && :active_record ].compact
 
+  # User the plugin date/time parser which is stricter and extendable
+  mattr_accessor :use_plugin_parser
+  @@use_plugin_parser = false
+
+  # Default timezone
   mattr_accessor :default_timezone
-  self.default_timezone = :utc
-
-  mattr_accessor :use_time_zones
-  self.use_time_zones = false
-
-  I18N_LATEST = defined?(I18n::VERSION) && I18n::VERSION >= '0.4.0'
-  locale_file = I18N_LATEST ? 'en.new.yml' : 'en.old.yml'
-  LOCALE_PATH = File.expand_path(File.join(File.dirname(__FILE__),'validates_timeliness','locale',locale_file))
-
-  class << self
-
-    def enable_datetime_select_extension!
-      enable_datetime_select_invalid_value_extension!
-      enable_multiparameter_attributes_extension!
-    end
-
-    def load_error_messages
-      defaults = YAML::load(IO.read(LOCALE_PATH))['en']
-      ValidatesTimeliness::Validator.error_value_formats = defaults['validates_timeliness']['error_value_formats'].symbolize_keys
-
-      if defined?(I18n)
-        I18n.load_path.unshift(LOCALE_PATH)
-        I18n.reload!
-      else
-        errors = defaults['activerecord']['errors']['messages'].inject({}) {|h,(k,v)| h[k.to_sym] = v.gsub(/\{\{\w*\}\}/, '%s');h }
-        ::ActiveRecord::Errors.default_error_messages.update(errors)
-      end
-    end
-
-    def setup_for_rails
-      self.default_timezone = ::ActiveRecord::Base.default_timezone
-      self.use_time_zones = ::ActiveRecord::Base.time_zone_aware_attributes rescue false
-      self.enable_active_record_datetime_parser!
-      load_error_messages
-    end
+  @@default_timezone = defined?(ActiveRecord) ? ActiveRecord::Base.default_timezone : :utc
+
+  # Set the dummy date part for a time type values.
+  mattr_accessor :dummy_date_for_time_type
+  @@dummy_date_for_time_type = [ 2000, 1, 1 ]
+
+  # Ignore errors when restriction options are evaluated
+  mattr_accessor :ignore_restriction_errors
+  @@ignore_restriction_errors = defined?(Rails) ? !Rails.env.test? : false
+
+  # Shorthand time and date symbols for restrictions
+  mattr_accessor :restriction_shorthand_symbols
+  @@restriction_shorthand_symbols = {
+    :now   => lambda { Time.now },
+    :today => lambda { Date.today }
+  }
+
+  # Setup method for plugin configuration
+  def self.setup
+    yield self
+    extend_orms.each {|orm| require "validates_timeliness/orms/#{orm}" }
   end
 end
 
-ValidatesTimeliness.setup_for_rails
+require 'validates_timeliness/parser'
+require 'validates_timeliness/conversion'
+require 'validates_timeliness/validator'
+require 'validates_timeliness/helper_methods'
+require 'validates_timeliness/attribute_methods'
+require 'validates_timeliness/extensions'

data/lib/validates_timeliness/attribute_methods.rb

@@ -0,0 +1,51 @@
+module ValidatesTimeliness
+  module AttributeMethods
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def define_timeliness_methods(before_type_cast=false)
+        timeliness_validated_attributes.each do |attr_name, type|
+          define_timeliness_write_method(attr_name, type, timeliness_attribute_timezone_aware?(attr_name))
+          define_timeliness_before_type_cast_method(attr_name) if before_type_cast
+        end
+      end
+
+      protected
+
+      def define_timeliness_write_method(attr_name, type, timezone_aware)
+        method_body, line = <<-EOV, __LINE__ + 1
+          def #{attr_name}=(value)
+            @attributes_cache ||= {}
+            @attributes_cache["_#{attr_name}_before_type_cast"] = value
+            super
+          end
+        EOV
+        class_eval(method_body, __FILE__, line)
+      end
+
+      def define_timeliness_before_type_cast_method(attr_name)
+        method_body, line = <<-EOV, __LINE__ + 1
+          def #{attr_name}_before_type_cast
+            _timeliness_raw_value_for('#{attr_name}')
+          end
+        EOV
+        class_eval(method_body, __FILE__, line)
+      end
+
+      def timeliness_attribute_timezone_aware?(attr_name)
+        false
+      end
+
+    end
+
+    module InstanceMethods
+
+      def _timeliness_raw_value_for(attr_name)
+        @attributes_cache && @attributes_cache["_#{attr_name}_before_type_cast"]
+      end
+
+    end
+
+  end
+end

data/lib/validates_timeliness/conversion.rb

@@ -0,0 +1,69 @@
+module ValidatesTimeliness
+  module Conversion
+
+    def type_cast_value(value, type)
+      return nil if value.nil?
+
+      value = value.in_time_zone if value.acts_like?(:time) && @timezone_aware
+      value = case type
+      when :time
+        dummy_time(value)
+      when :date
+        value.to_date
+      when :datetime
+        value.to_time
+      end
+      if options[:ignore_usec] && value.is_a?(Time)
+        ValidatesTimeliness::Parser.make_time(Array(value).reverse[4..9], @timezone_aware)
+      else
+        value
+      end
+    end
+
+    def dummy_time(value)
+      time = if value.acts_like?(:time)
+        value = value.in_time_zone if @timezone_aware
+        [value.hour, value.min, value.sec]
+      else
+        [0,0,0]
+      end
+      values = ValidatesTimeliness.dummy_date_for_time_type + time
+      ValidatesTimeliness::Parser.make_time(values, @timezone_aware)
+    end
+
+    def evaluate_option_value(value, record)
+      case value
+      when Time, Date
+        value
+      when String
+        parse(value)
+      when Symbol
+        if !record.respond_to?(value) && restriction_shorthand?(value)
+          ValidatesTimeliness.restriction_shorthand_symbols[value].call
+        else
+          evaluate_option_value(record.send(value), record)
+        end
+      when Proc
+        result = value.arity > 0 ? value.call(record) : value.call
+        evaluate_option_value(result, record)
+      else
+        value
+      end
+    end
+
+    def restriction_shorthand?(symbol)
+      ValidatesTimeliness.restriction_shorthand_symbols.keys.include?(symbol)
+    end
+
+    def parse(value)
+      if ValidatesTimeliness.use_plugin_parser
+        ValidatesTimeliness::Parser.parse(value, @type, :timezone_aware => @timezone_aware, :format => options[:format], :strict => false)
+      else
+        @timezone_aware ? Time.zone.parse(value) : value.to_time(ValidatesTimeliness.default_timezone)
+      end
+    rescue ArgumentError, TypeError
+      nil
+    end
+
+  end
+end

data/lib/validates_timeliness/extensions.rb

@@ -0,0 +1,14 @@
+module ValidatesTimeliness
+  module Extensions
+    autoload :DateTimeSelect,        'validates_timeliness/extensions/date_time_select'
+    autoload :MultiparameterHandler, 'validates_timeliness/extensions/multiparameter_handler'
+  end
+
+  def self.enable_date_time_select_extension!
+    ::ActionView::Helpers::InstanceTag.send(:include, ValidatesTimeliness::Extensions::DateTimeSelect)
+  end
+
+  def self.enable_multiparameter_extension!
+    ::ActiveRecord::Base.send(:include, ValidatesTimeliness::Extensions::MultiparameterHandler)
+  end
+end

data/lib/validates_timeliness/extensions/date_time_select.rb

@@ -0,0 +1,45 @@
+module ValidatesTimeliness
+  module Extensions
+    module DateTimeSelect
+      extend ActiveSupport::Concern
+
+      # Intercepts the date and time select helpers to reuse the values from the
+      # the params rather than the parsed value. This allows invalid date/time
+      # values to be redisplayed instead of blanks to aid correction by the user.
+      # Its a minor usability improvement which is rarely an issue for the user.
+
+      included do
+        alias_method_chain :datetime_selector, :timeliness
+        alias_method_chain :value, :timeliness
+      end
+
+      module InstanceMethods
+
+        TimelinessDateTime = Struct.new(:year, :month, :day, :hour, :min, :sec)
+
+        def datetime_selector_with_timeliness(*args)
+          @timeliness_date_or_time_tag = true
+          datetime_selector_without_timeliness(*args)
+        end
+
+        def value_with_timeliness(object)
+          unless @timeliness_date_or_time_tag && @template_object.params[@object_name]
+            return value_without_timeliness(object)
+          end
+
+          pairs = @template_object.params[@object_name].select {|k,v| k =~ /^#{@method_name}\(/ }
+          return value_without_timeliness(object) if pairs.empty?
+
+          values = [nil] * 6
+          pairs.map do |(param, value)|
+            position = param.scan(/\(([0-9]*).*\)/).first.first
+            values[position.to_i-1] = value
+          end
+
+          TimelinessDateTime.new(*values)
+        end
+      end
+
+    end
+  end
+end

data/lib/validates_timeliness/extensions/multiparameter_handler.rb

@@ -0,0 +1,31 @@
+module ValidatesTimeliness
+  module Extensions
+    module MultiparameterHandler
+      extend ActiveSupport::Concern
+
+      included do
+        alias_method_chain :instantiate_time_object, :timeliness
+      end
+
+      private
+
+      # Stricter handling of date and time values from multiparameter 
+      # assignment from the date/time select view helpers
+      #
+      def instantiate_time_object_with_timeliness(name, values)
+        unless Date.valid_civil?(*values[0..2])
+          value =  [values[0], *values[1..2].map {|s| s.to_s.rjust(2,"0")} ].join("-")
+          value += ' ' + values[3..5].map {|s| s.to_s.rjust(2, "0") }.join(":") unless values[3..5].empty?
+          return value
+        end
+
+        if self.class.send(:create_time_zone_conversion_attribute?, name, column_for_attribute(name))
+          Time.zone.local(*values)
+        else
+          Time.time_with_datetime_fallback(self.class.default_timezone, *values)
+        end
+      end
+
+    end
+  end
+end