validates_timeliness 2.3.2 → 3.0.0.beta

data/lib/validates_timeliness/locale/en.new.yml

@@ -1,18 +0,0 @@
-en:
-  activerecord:
-    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}"
-        between: "must be between %{earliest} and %{latest}"
-  validates_timeliness:
-    error_value_formats:
-      date: '%Y-%m-%d'
-      time: '%H:%M:%S'
-      datetime: '%Y-%m-%d %H:%M:%S'

data/lib/validates_timeliness/locale/en.old.yml

@@ -1,18 +0,0 @@
-en:
-  activerecord:
-    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}}"
-        between: "must be between {{earliest}} and {{latest}}"
-  validates_timeliness:
-    error_value_formats:
-      date: '%Y-%m-%d'
-      time: '%H:%M:%S'
-      datetime: '%Y-%m-%d %H:%M:%S'

data/lib/validates_timeliness/matcher.rb

@@ -1 +0,0 @@
-require 'validates_timeliness/spec/rails/matchers/validate_timeliness'

data/lib/validates_timeliness/spec/rails/matchers/validate_timeliness.rb

@@ -1,162 +0,0 @@
-module Spec
-  module Rails
-    module Matchers
-      class ValidateTimeliness
-
-        VALIDITY_TEST_VALUES = {
-          :date     => {:pass => '2000-01-01', :fail => '2000-01-32'},
-          :time     => {:pass => '12:00',      :fail => '25:00'},
-          :datetime => {:pass => '2000-01-01 00:00:00', :fail => '2000-01-32 00:00:00'}
-        }
-
-        OPTION_TEST_SETTINGS = {
-          :is_at        => { :method => :+, :modify_on => :invalid },
-          :before       => { :method => :-, :modify_on => :valid },
-          :after        => { :method => :+, :modify_on => :valid },
-          :on_or_before => { :method => :+, :modify_on => :invalid },
-          :on_or_after  => { :method => :-, :modify_on => :invalid }
-        }
-
-        def initialize(attribute, options)
-          @expected, @options = attribute, options
-          @validator = ValidatesTimeliness::Validator.new(options)
-        end
-
-        def matches?(record)
-          @record = record
-          @type = @options[:type]
-
-          valid = test_validity
-
-          valid = test_option(:is_at)        if valid && @options[:is_at]
-          valid = test_option(:before)       if valid && @options[:before]
-          valid = test_option(:after)        if valid && @options[:after]
-          valid = test_option(:on_or_before) if valid && @options[:on_or_before]
-          valid = test_option(:on_or_after)  if valid && @options[:on_or_after]
-          valid = test_between               if valid && @options[:between]
-
-          return valid
-        end
-
-        def failure_message
-          "expected model to validate #{@type} attribute #{@expected.inspect} with #{@last_failure}"
-        end
-
-        def negative_failure_message
-          "expected not to validate #{@type} attribute #{@expected.inspect}"
-        end
-
-        def description
-          "have validated #{@type} attribute #{@expected.inspect}"
-        end
-
-       private
-
-        def test_validity
-          invalid_value = VALIDITY_TEST_VALUES[@type][:fail]
-          valid_value   = parse_and_cast(VALIDITY_TEST_VALUES[@type][:pass])
-          error_matching(invalid_value, "invalid_#{@type}".to_sym) &&
-            no_error_matching(valid_value, "invalid_#{@type}".to_sym)
-        end
-
-        def test_option(option)
-          settings = OPTION_TEST_SETTINGS[option]
-          boundary = parse_and_cast(@options[option])
-
-          method = settings[:method]
-
-          valid_value, invalid_value = if settings[:modify_on] == :valid
-            [ boundary.send(method, 1), boundary ]
-          else
-            [ boundary, boundary.send(method, 1) ]
-          end
-
-          error_matching(invalid_value, option) &&
-            no_error_matching(valid_value, option)
-        end
-
-        def test_before
-          before = parse_and_cast(@options[:before])
-
-          error_matching(before - 1, :before) &&
-            no_error_matching(before, :before)
-        end
-
-        def test_between
-          between = parse_and_cast(@options[:between])
-
-          error_matching(between.first - 1, :between) &&
-            error_matching(between.last + 1, :between) &&
-            no_error_matching(between.first, :between) &&
-            no_error_matching(between.last, :between)
-        end
-
-        def parse_and_cast(value)
-          value = @validator.class.send(:evaluate_option_value, value, @type, @record)
-          @validator.class.send(:type_cast_value, value, @type)
-        end
-
-        def error_matching(value, option)
-          match = error_message_for(option)
-          @record.send("#{@expected}=", value)
-          @record.valid?
-          errors = @record.errors.on(@expected)
-          pass = [ errors ].flatten.any? {|error| /#{match}/ === error }
-          @last_failure = "error matching '#{match}' when value is #{format_value(value)}" unless pass
-          pass
-        end
-
-        def no_error_matching(value, option)
-          pass = !error_matching(value, option)
-          unless pass
-            error = error_message_for(option)
-            @last_failure = "no error matching '#{error}' when value is #{format_value(value)}"
-          end
-          pass
-        end
-
-        def error_message_for(message)
-          restriction = @validator.class.send(:evaluate_option_value, @validator.configuration[message], @type, @record)
-
-          if restriction
-            restriction = @validator.class.send(:type_cast_value, restriction, @type)
-            interpolate = @validator.send(:interpolation_values, message, restriction)
-          end
-
-          if defined?(I18n)
-            interpolate ||= {}
-            options = interpolate.merge(:default => @validator.send(:custom_error_messages)[message])
-            if defined?(ActiveRecord::Error)
-              ActiveRecord::Error.new(@record, @expected, message, options).message
-            else
-              @record.errors.generate_message(@expected, message, options)
-            end
-          else
-            interpolate ||= nil
-            @validator.error_messages[message] % interpolate
-          end
-        end
-
-        def format_value(value)
-          return value if value.is_a?(String)
-          value.strftime(@validator.class.error_value_formats[@type])
-        end
-      end
-
-      def validate_date(attribute, options={})
-        options[:type] = :date
-        ValidateTimeliness.new(attribute, options)
-      end
-
-      def validate_time(attribute, options={})
-        options[:type] = :time
-        ValidateTimeliness.new(attribute, options)
-      end
-
-      def validate_datetime(attribute, options={})
-        options[:type] = :datetime
-        ValidateTimeliness.new(attribute, options)
-      end
-    end
-  end
-end

data/lib/validates_timeliness/validation_methods.rb

@@ -1,46 +0,0 @@
-module ValidatesTimeliness
-  module ValidationMethods
-
-    def self.included(base)
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-
-      def validates_time(*attr_names)
-        configuration = attr_names.extract_options!
-        configuration[:type] = :time
-        validates_timeliness_of(attr_names, configuration)
-      end
-      
-      def validates_date(*attr_names)
-        configuration = attr_names.extract_options!
-        configuration[:type] = :date
-        validates_timeliness_of(attr_names, configuration)
-      end
-      
-      def validates_datetime(*attr_names)
-        configuration = attr_names.extract_options!
-        configuration[:type] = :datetime
-        validates_timeliness_of(attr_names, configuration)
-      end
-
-      private
-
-      def validates_timeliness_of(attr_names, configuration)
-        validator = ValidatesTimeliness::Validator.new(configuration.symbolize_keys)
-        
-        # bypass handling of allow_nil and allow_blank to validate raw value
-        configuration.delete(:allow_nil)
-        configuration.delete(:allow_blank)
-        validates_each(attr_names, configuration) do |record, attr_name, value|
-          validator.call(record, attr_name, value)
-        end
-      end
-
-    end
-
-  end
-end
-
-ActiveRecord::Base.send(:include, ValidatesTimeliness::ValidationMethods)

data/spec/action_view/instance_tag_spec.rb

@@ -1,194 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe 'ValidatesTimeliness::ActionView::InstanceTag' do
-  include ActionView::Helpers::DateHelper
-  include ActionController::Assertions::SelectorAssertions
-
-  before do
-    @person = Person.new
-  end
-
-  def params
-    @params ||= {}
-  end
-
-  describe "datetime_select" do
-    it "should use param values when attribute is nil" do
-      params["person"] = {
-        "birth_date_and_time(1i)" => 2009,
-        "birth_date_and_time(2i)" => 2,
-        "birth_date_and_time(3i)" => 29,
-        "birth_date_and_time(4i)" => 12,
-        "birth_date_and_time(5i)" => 13,
-        "birth_date_and_time(6i)" => 14,
-      }
-      @person.birth_date_and_time = nil
-      output = datetime_select(:person, :birth_date_and_time, :include_blank => true, :include_seconds => true)
-      output.should have_tag('select[id=person_birth_date_and_time_1i] option[selected=selected]', '2009')
-      output.should have_tag('select[id=person_birth_date_and_time_2i] option[selected=selected]', 'February')
-      output.should have_tag('select[id=person_birth_date_and_time_3i] option[selected=selected]', '29')
-      output.should have_tag('select[id=person_birth_date_and_time_4i] option[selected=selected]', '12')
-      output.should have_tag('select[id=person_birth_date_and_time_5i] option[selected=selected]', '13')
-      output.should have_tag('select[id=person_birth_date_and_time_6i] option[selected=selected]', '14')
-    end
-
-    it "should override object values and use params if present" do
-      params["person"] = {
-        "birth_date_and_time(1i)" => 2009,
-        "birth_date_and_time(2i)" => 2,
-        "birth_date_and_time(3i)" => 29,
-        "birth_date_and_time(4i)" => 13,
-        "birth_date_and_time(5i)" => 14,
-        "birth_date_and_time(6i)" => 15,
-      }
-      @person.birth_date_and_time = "2009-03-01 13:14:15"
-      output = datetime_select(:person, :birth_date_and_time, :include_blank => true, :include_seconds => true)
-      output.should have_tag('select[id=person_birth_date_and_time_1i] option[selected=selected]', '2009')
-      output.should have_tag('select[id=person_birth_date_and_time_2i] option[selected=selected]', 'February')
-      output.should have_tag('select[id=person_birth_date_and_time_3i] option[selected=selected]', '29')
-      output.should have_tag('select[id=person_birth_date_and_time_4i] option[selected=selected]', '13')
-      output.should have_tag('select[id=person_birth_date_and_time_5i] option[selected=selected]', '14')
-      output.should have_tag('select[id=person_birth_date_and_time_6i] option[selected=selected]', '15')
-    end
-
-    it "should select attribute values from object if no params" do
-      @person.birth_date_and_time = "2009-01-02 13:14:15"
-      output = datetime_select(:person, :birth_date_and_time, :include_blank => true, :include_seconds => true)
-      output.should have_tag('select[id=person_birth_date_and_time_1i] option[selected=selected]', '2009')
-      output.should have_tag('select[id=person_birth_date_and_time_2i] option[selected=selected]', 'January')
-      output.should have_tag('select[id=person_birth_date_and_time_3i] option[selected=selected]', '2')
-      output.should have_tag('select[id=person_birth_date_and_time_4i] option[selected=selected]', '13')
-      output.should have_tag('select[id=person_birth_date_and_time_5i] option[selected=selected]', '14')
-      output.should have_tag('select[id=person_birth_date_and_time_6i] option[selected=selected]', '15')
-    end
-
-    it "should select attribute values if params does not contain attribute params" do
-      @person.birth_date_and_time = "2009-01-02 13:14:15"
-      params["person"] = { }
-      output = datetime_select(:person, :birth_date_and_time, :include_blank => true, :include_seconds => true)
-      output.should have_tag('select[id=person_birth_date_and_time_1i] option[selected=selected]', '2009')
-      output.should have_tag('select[id=person_birth_date_and_time_2i] option[selected=selected]', 'January')
-      output.should have_tag('select[id=person_birth_date_and_time_3i] option[selected=selected]', '2')
-      output.should have_tag('select[id=person_birth_date_and_time_4i] option[selected=selected]', '13')
-      output.should have_tag('select[id=person_birth_date_and_time_5i] option[selected=selected]', '14')
-      output.should have_tag('select[id=person_birth_date_and_time_6i] option[selected=selected]', '15')
-    end
-
-    it "should not select values when attribute value is nil and has no param values" do
-      @person.birth_date_and_time = nil
-      output = datetime_select(:person, :birth_date_and_time, :include_blank => true, :include_seconds => true)
-      output.should_not have_tag('select[id=person_birth_date_and_time_1i] option[selected=selected]')
-      output.should_not have_tag('select[id=person_birth_date_and_time_2i] option[selected=selected]')
-      output.should_not have_tag('select[id=person_birth_date_and_time_3i] option[selected=selected]')
-      output.should_not have_tag('select[id=person_birth_date_and_time_4i] option[selected=selected]')
-      output.should_not have_tag('select[id=person_birth_date_and_time_5i] option[selected=selected]')
-      output.should_not have_tag('select[id=person_birth_date_and_time_6i] option[selected=selected]')
-    end
-  end
-
-  describe "date_select" do
-    it "should use param values when attribute is nil" do
-      params["person"] = {
-        "birth_date(1i)" => 2009,
-        "birth_date(2i)" => 2,
-        "birth_date(3i)" => 29,
-      }
-      @person.birth_date = nil
-      output = date_select(:person, :birth_date, :include_blank => true, :include_seconds => true)
-      output.should have_tag('select[id=person_birth_date_1i] option[selected=selected]', '2009')
-      output.should have_tag('select[id=person_birth_date_2i] option[selected=selected]', 'February')
-      output.should have_tag('select[id=person_birth_date_3i] option[selected=selected]', '29')
-    end
-
-    it "should override object values and use params if present" do
-      params["person"] = {
-        "birth_date(1i)" => 2009,
-        "birth_date(2i)" => 2,
-        "birth_date(3i)" => 29,
-      }
-      @person.birth_date = "2009-03-01"
-      output = date_select(:person, :birth_date, :include_blank => true, :include_seconds => true)
-      output.should have_tag('select[id=person_birth_date_1i] option[selected=selected]', '2009')
-      output.should have_tag('select[id=person_birth_date_2i] option[selected=selected]', 'February')
-      output.should have_tag('select[id=person_birth_date_3i] option[selected=selected]', '29')
-    end
-
-    it "should select attribute values from object if no params" do
-      @person.birth_date = "2009-01-02"
-      output = date_select(:person, :birth_date, :include_blank => true, :include_seconds => true)
-      output.should have_tag('select[id=person_birth_date_1i] option[selected=selected]', '2009')
-      output.should have_tag('select[id=person_birth_date_2i] option[selected=selected]', 'January')
-      output.should have_tag('select[id=person_birth_date_3i] option[selected=selected]', '2')
-    end
-
-    it "should select attribute values if params does not contain attribute params" do
-      @person.birth_date = "2009-01-02"
-      params["person"] = { }
-      output = date_select(:person, :birth_date, :include_blank => true, :include_seconds => true)
-      output.should have_tag('select[id=person_birth_date_1i] option[selected=selected]', '2009')
-      output.should have_tag('select[id=person_birth_date_2i] option[selected=selected]', 'January')
-      output.should have_tag('select[id=person_birth_date_3i] option[selected=selected]', '2')
-    end
-
-    it "should not select values when attribute value is nil and has no param values" do
-      @person.birth_date = nil
-      output = date_select(:person, :birth_date, :include_blank => true, :include_seconds => true)
-      output.should_not have_tag('select[id=person_birth_date_1i] option[selected=selected]')
-      output.should_not have_tag('select[id=person_birth_date_2i] option[selected=selected]')
-      output.should_not have_tag('select[id=person_birth_date_3i] option[selected=selected]')
-    end
-  end
-
-  describe "time_select" do
-    before :all do
-      Time.now = Time.mktime(2009,1,1)
-    end
-
-    it "should use param values when attribute is nil" do
-      params["person"] = {
-        "birth_time(1i)" => 2000,
-        "birth_time(2i)" => 1,
-        "birth_time(3i)" => 1,
-        "birth_time(4i)" => 12,
-        "birth_time(5i)" => 13,
-        "birth_time(6i)" => 14,
-      }
-      @person.birth_time = nil
-      output = time_select(:person, :birth_time, :include_blank => true, :include_seconds => true)
-      output.should have_tag('input[id=person_birth_time_1i][value=2000]')
-      output.should have_tag('input[id=person_birth_time_2i][value=1]')
-      output.should have_tag('input[id=person_birth_time_3i][value=1]')
-      output.should have_tag('select[id=person_birth_time_4i] option[selected=selected]', '12')
-      output.should have_tag('select[id=person_birth_time_5i] option[selected=selected]', '13')
-      output.should have_tag('select[id=person_birth_time_6i] option[selected=selected]', '14')
-    end
-
-    it "should select attribute values from object if no params" do
-      @person.birth_time = "13:14:15"
-      output = time_select(:person, :birth_time, :include_blank => true, :include_seconds => true)
-      output.should have_tag('input[id=person_birth_time_1i][value=2000]')
-      output.should have_tag('input[id=person_birth_time_2i][value=1]')
-      output.should have_tag('input[id=person_birth_time_3i][value=1]')
-      output.should have_tag('select[id=person_birth_time_4i] option[selected=selected]', '13')
-      output.should have_tag('select[id=person_birth_time_5i] option[selected=selected]', '14')
-      output.should have_tag('select[id=person_birth_time_6i] option[selected=selected]', '15')
-    end
-
-    it "should not select values when attribute value is nil and has no param values" do
-      @person.birth_time = nil
-      output = time_select(:person, :birth_time, :include_blank => true, :include_seconds => true)
-      output.should have_tag('input[id=person_birth_time_1i][value=""]')
-      # Annoyingly these may or not have value attribute depending on rails version.
-      # output.should have_tag('input[id=person_birth_time_2i][value=""]')
-      # output.should have_tag('input[id=person_birth_time_3i][value=""]')
-      output.should_not have_tag('select[id=person_birth_time_4i] option[selected=selected]')
-      output.should_not have_tag('select[id=person_birth_time_5i] option[selected=selected]')
-      output.should_not have_tag('select[id=person_birth_time_6i] option[selected=selected]')
-    end
-
-    after :all do
-      Time.now = nil
-    end
-  end
-
-end

data/spec/active_record/attribute_methods_spec.rb

@@ -1,157 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-
-describe ValidatesTimeliness::ActiveRecord::AttributeMethods do
-  before do
-    @person = Person.new
-  end
-
-  it "should define and call write method on first assign" do
-    Person.class_eval { @generated_methods = Set.new; @_defined_class_methods = nil }
-    Person.send(:undef_method, :birth_date=) if Person.instance_methods.include?('birth_date=')
-    person = Person.new
-    person.should_receive(:write_date_time_attribute)
-    person.birth_date = "2000-01-01"
-  end
-
-  it "should call write_date_time_attribute when time attribute assigned value" do
-    @person.should_receive(:write_date_time_attribute)
-    @person.birth_time = "12:00"
-  end
-
-  it "should call write_date_time_attribute when datetime attribute assigned value" do
-    @person.should_receive(:write_date_time_attribute)
-    @person.birth_date_and_time = "2000-01-01 12:00"
-  end
-
-  it "should call parser on write for datetime attribute" do
-    ValidatesTimeliness::Parser.should_receive(:parse).once
-    @person.birth_date_and_time = "2000-01-01 02:03:04"
-  end
-
-  it "should call parser on write for date attribute" do
-    ValidatesTimeliness::Parser.should_receive(:parse).once
-    @person.birth_date = "2000-01-01"
-  end
-
-  it "should call parser on write for time attribute" do
-    ValidatesTimeliness::Parser.should_receive(:parse).once
-    @person.birth_time = "12:00"
-  end
-
-  it "should return raw string value for attribute_before_type_cast when written as string" do
-    time_string = "2000-01-01 02:03:04"
-    @person.birth_date_and_time = time_string
-    @person.birth_date_and_time_before_type_cast.should == time_string
-  end
-
-  it "should return Time object for attribute_before_type_cast when written as Time" do
-    @person.birth_date_and_time = Time.mktime(2000, 1, 1, 2, 3, 4)
-    @person.birth_date_and_time_before_type_cast.should be_kind_of(Time)
-  end
-
-  it "should return Time object for datetime attribute read method when assigned Time object" do
-    @person.birth_date_and_time = Time.now
-    @person.birth_date_and_time.should be_kind_of(Time)
-  end
-
-  it "should return Time object for datetime attribute read method when assigned Date object" do
-    @person.birth_date_and_time = Date.today
-    @person.birth_date_and_time.should be_kind_of(Time)
-  end
-
-  it "should return Time object for datetime attribute read method when assigned string" do
-    @person.birth_date_and_time = "2000-01-01 02:03:04"
-    @person.birth_date_and_time.should be_kind_of(Time)
-  end
-
-  it "should return Date object for date attribute read method when assigned Date object" do
-    @person.birth_date = Date.today
-    @person.birth_date.should be_kind_of(Date)
-  end
-
-  it "should return Date object for date attribute read method when assigned string" do
-    @person.birth_date = '2000-01-01'
-    @person.birth_date.should be_kind_of(Date)
-  end
-
-  it "should return nil when time is invalid" do
-    @person.birth_date_and_time = "2000-01-32 02:03:04"
-    @person.birth_date_and_time.should be_nil
-  end
-
-  it "should not save invalid date value to database" do
-    time_string = "2000-01-32 02:03:04"
-    @person.birth_date_and_time = time_string
-    @person.save
-    @person.reload
-    @person.birth_date_and_time_before_type_cast.should be_nil
-  end
-
-  if RAILS_VER < '2.1'
-
-    it "should return time object from database in default timezone" do
-      ActiveRecord::Base.default_timezone = :utc
-      time_string = "2000-01-01 09:00:00"
-      @person.birth_date_and_time = time_string
-      @person.save
-      @person.reload
-      @person.birth_date_and_time.strftime('%Y-%m-%d %H:%M:%S %Z').should == time_string + ' UTC'
-    end
-
-  else
-
-    it "should return stored time string as Time with correct timezone" do
-      Time.zone = 'Melbourne'
-      time_string = "2000-06-01 02:03:04"
-      @person.birth_date_and_time = time_string
-      @person.birth_date_and_time.strftime('%Y-%m-%d %H:%M:%S %Z %z').should == time_string + ' EST +1000'
-    end
-
-    it "should return time object from database in correct timezone" do
-      Time.zone = 'Melbourne'
-      time_string = "2000-06-01 09:00:00"
-      @person.birth_date_and_time = time_string
-      @person.save
-      @person.reload
-      @person.birth_date_and_time.strftime('%Y-%m-%d %H:%M:%S %Z %z').should == time_string + ' EST +1000'
-    end
-
-  end
-
-  it "should return correct date value after new value assigned" do
-    today = Date.today
-    tomorrow = Date.today + 1.day
-    @person.birth_date = today
-    @person.birth_date.should == today
-    @person.birth_date = tomorrow
-    @person.birth_date.should == tomorrow
-  end
-
-  it "should update date attribute on existing object" do
-    today = Date.today
-    tomorrow = Date.today + 1.day
-    person = Person.create(:birth_date => today)
-    person.birth_date = tomorrow
-    person.save!
-    person.reload
-    person.birth_date.should == tomorrow
-  end
-
-  describe "attribute writer" do
-
-    it "should be able to be overridden in class" do
-      Person.class_eval { attr_accessor :birth_date }
-      person = Person.new
-      person.birth_date = 'overriden'
-      person.birth_date.should == 'overriden'
-    end
-
-    after do
-      Person.class_eval do
-        undef_method(:birth_date)
-        undef_method(:birth_date=)
-      end
-    end
-  end
-
-end