validates_timeliness 1.0.0

data/lib/validates_timeliness.rb

@@ -0,0 +1,66 @@
+require 'validates_timeliness/formats'
+require 'validates_timeliness/validator'
+require 'validates_timeliness/validation_methods'
+require 'validates_timeliness/spec/rails/matchers/validate_timeliness' if ENV['RAILS_ENV'] == 'test'
+
+require 'validates_timeliness/active_record/attribute_methods'
+require 'validates_timeliness/active_record/multiparameter_attributes'
+require 'validates_timeliness/action_view/instance_tag'
+
+require 'validates_timeliness/core_ext/time'
+require 'validates_timeliness/core_ext/date'
+require 'validates_timeliness/core_ext/date_time'
+
+module ValidatesTimeliness
+  
+  mattr_accessor :default_timezone
+
+  self.default_timezone = :utc 
+
+  LOCALE_PATH = File.expand_path(File.dirname(__FILE__) + '/validates_timeliness/locale/en.yml')
+
+  class << self
+
+    def load_error_messages_with_i18n
+      I18n.load_path += [ LOCALE_PATH ]
+    end
+
+    def load_error_messages_without_i18n
+      messages = YAML::load(IO.read(LOCALE_PATH))
+      errors = messages['en']['activerecord']['errors']['messages'].inject({}) {|h,(k,v)| h[k.to_sym] = v.gsub(/\{\{\w*\}\}/, '%s');h }
+      ::ActiveRecord::Errors.default_error_messages.update(errors)
+    end
+    
+    def default_error_messages
+      if Rails::VERSION::STRING < '2.2'
+        ::ActiveRecord::Errors.default_error_messages
+      else
+        I18n.translate('activerecord.errors.messages')
+      end
+    end
+
+    def setup_for_rails_2_0
+      load_error_messages_without_i18n
+    end
+
+    def setup_for_rails_2_1
+      load_error_messages_without_i18n
+    end
+
+    def setup_for_rails_2_2
+      load_error_messages_with_i18n
+    end
+
+    def setup_for_rails
+      major, minor = Rails::VERSION::MAJOR, Rails::VERSION::MINOR
+      self.send("setup_for_rails_#{major}_#{minor}")
+      self.default_timezone = ::ActiveRecord::Base.default_timezone
+    rescue
+      raise "Rails version #{Rails::VERSION::STRING} not yet supported by validates_timeliness plugin"
+    end
+  end
+end
+
+ValidatesTimeliness.setup_for_rails
+
+ValidatesTimeliness::Formats.compile_format_expressions

data/lib/validates_timeliness/action_view/instance_tag.rb

@@ -0,0 +1,45 @@
+module ValidatesTimeliness
+  module ActionView
+
+    # Intercepts the date and time select helpers to allow the 
+    # attribute value before type cast to be used as in the select helpers.
+    # This means that an invalid date or time will be redisplayed rather than the
+    # type cast value which would be nil if invalid.
+    module InstanceTag    
+    
+      def self.included(base)
+        selector_method = Rails::VERSION::STRING < '2.2' ? :date_or_time_select : :datetime_selector
+        base.class_eval do
+          alias_method :datetime_selector_without_timeliness, selector_method
+          alias_method selector_method, :datetime_selector_with_timeliness
+        end
+        base.alias_method_chain :value, :timeliness
+      end
+      
+      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)
+        return value_without_timeliness(object) unless @timeliness_date_or_time_tag
+        
+        raw_value = value_before_type_cast(object)
+        
+        if raw_value.nil? || raw_value.acts_like?(:time) || raw_value.is_a?(Date)
+          return value_without_timeliness(object)
+        end
+        
+        time_array = ParseDate.parsedate(raw_value)
+        
+        TimelinessDateTime.new(*time_array[0..5])
+      end      
+       
+    end
+
+  end   
+end
+
+ActionView::Helpers::InstanceTag.send(:include, ValidatesTimeliness::ActionView::InstanceTag)

data/lib/validates_timeliness/active_record/attribute_methods.rb

@@ -0,0 +1,157 @@
+module ValidatesTimeliness
+  module ActiveRecord
+
+    # Rails 2.1 removed the ability to retrieve the raw value of a time or datetime
+    # attribute. The raw value is necessary to properly validate a string time or 
+    # datetime value instead of the internal Rails type casting which is very limited 
+    # and does not allow custom formats. These methods restore that ability while 
+    # respecting the automatic timezone handling.
+    #
+    # The automatic timezone handling sets the assigned attribute value to the current
+    # zone in Time.zone. To preserve this localised value and capture the raw value 
+    # we cache the localised value on write and store the raw value in the attributes
+    # hash for later retrieval and possibly validation. Any value from the database
+    # will not be in the attribute cache on first read so will be considered in default
+    # timezone and converted to local time. It is then stored back in the attributes
+    # hash and cached to avoid the need for any subsequent differentiation.
+    #
+    # The wholesale replacement of the Rails time type casting is not done to
+    # preserve the quickest conversion for timestamp columns and also any value
+    # which is never changed during the life of the record object.
+    module AttributeMethods
+
+      def self.included(base)
+        base.extend ClassMethods
+
+        if Rails::VERSION::STRING < '2.1'
+          base.class_eval do
+            class << self
+              def create_time_zone_conversion_attribute?(name, column)
+                false
+              end
+            end
+          end
+        end
+      end
+
+      # Adds check for cached date/time attributes which have been type cast already
+      # and value can be used from cache. This prevents the raw date/time value from
+      # being type cast using default Rails type casting when writing values
+      # to the database.
+      def read_attribute(attr_name)
+        attr_name = attr_name.to_s
+        if !(value = @attributes[attr_name]).nil?
+          if column = column_for_attribute(attr_name)
+            if unserializable_attribute?(attr_name, column)
+              unserialize_attribute(attr_name)
+            elsif [:date, :time, :datetime].include?(column.type) && @attributes_cache.has_key?(attr_name)
+              @attributes_cache[attr_name]
+            else
+              column.type_cast(value)
+            end
+          else
+            value
+          end
+        else
+          nil
+        end
+      end
+
+      # Writes attribute value by storing raw value in attributes hash,
+      # then convert it with parser and cache it.
+      #
+      # If Rails dirty attributes is enabled then the value is added to
+      # changed attributes if changed. Can't use the default dirty checking
+      # implementation as it chains the write_attribute method which deletes
+      # the attribute from the cache.
+      def write_date_time_attribute(attr_name, value)
+        column = column_for_attribute(attr_name)
+        old = read_attribute(attr_name) if defined?(::ActiveRecord::Dirty)
+        new = self.class.parse_date_time(value, column.type)
+
+        unless column.type == :date || new.nil?
+          new = new.to_time rescue new
+        end
+
+        if self.class.send(:create_time_zone_conversion_attribute?, attr_name, column)
+          new = new.in_time_zone rescue nil
+        end
+        @attributes_cache[attr_name] = new
+
+        if defined?(::ActiveRecord::Dirty) && !changed_attributes.include?(attr_name) && old != new
+          changed_attributes[attr_name] = (old.duplicable? ? old.clone : old)
+        end
+        @attributes[attr_name] = value
+      end
+
+      module ClassMethods
+
+        # Override AR method to define attribute reader and writer method for
+        # date, time and datetime attributes to use plugin parser.
+        def define_attribute_methods
+          return if generated_methods?
+          columns_hash.each do |name, column|
+            unless instance_method_already_implemented?(name)
+              if self.serialized_attributes[name]
+                define_read_method_for_serialized_attribute(name)
+              elsif create_time_zone_conversion_attribute?(name, column)
+                define_read_method_for_time_zone_conversion(name)
+              else
+                define_read_method(name.to_sym, name, column)
+              end
+            end
+
+            unless instance_method_already_implemented?("#{name}=")
+              if [:date, :time, :datetime].include?(column.type)
+                define_write_method_for_dates_and_times(name)
+              else
+                define_write_method(name.to_sym)
+              end
+            end
+
+            unless instance_method_already_implemented?("#{name}?")
+              define_question_method(name)
+            end
+          end
+        end
+
+        # Define write method for date, time and datetime columns
+        def define_write_method_for_dates_and_times(attr_name)
+          method_body = <<-EOV
+            def #{attr_name}=(value)
+               write_date_time_attribute('#{attr_name}', value)
+            end
+          EOV
+          evaluate_attribute_method attr_name, method_body, "#{attr_name}="
+        end
+
+        # Define time attribute reader. If reloading then check if cached,
+        # which means its in local time. If local, convert with parser as local
+        # timezone, otherwise use read_attribute method for quick default type
+        # cast of values from database using default timezone.
+        def define_read_method_for_time_zone_conversion(attr_name)
+          method_body = <<-EOV
+            def #{attr_name}(reload = false)
+              cached = @attributes_cache['#{attr_name}']
+              return cached if @attributes_cache.has_key?('#{attr_name}') && !reload
+              if @attributes_cache.has_key?('#{attr_name}')
+                time = read_attribute_before_type_cast('#{attr_name}')
+                time = self.class.parse_date_time(date, :datetime)
+              else
+                time = read_attribute('#{attr_name}')
+                @attributes['#{attr_name}'] = time.in_time_zone rescue nil
+              end
+              @attributes_cache['#{attr_name}'] = time.in_time_zone rescue nil
+            end
+          EOV
+          evaluate_attribute_method attr_name, method_body
+        end
+
+      end
+
+    end
+
+  end
+end
+
+ActiveRecord::Base.send(:include, ValidatesTimeliness::ActiveRecord::AttributeMethods)

data/lib/validates_timeliness/active_record/multiparameter_attributes.rb

@@ -0,0 +1,64 @@
+module ValidatesTimeliness
+  module ActiveRecord
+
+    module MultiparameterAttributes
+      
+      def self.included(base)
+        base.alias_method_chain :execute_callstack_for_multiparameter_attributes, :timeliness
+      end    
+    
+      # Overrides AR method to store multiparameter time and dates as string
+      # allowing validation later.
+      def execute_callstack_for_multiparameter_attributes_with_timeliness(callstack)
+        errors = []
+        callstack.each do |name, values|
+          klass = (self.class.reflect_on_aggregation(name.to_sym) || column_for_attribute(name)).klass
+          if values.empty?
+            send(name + "=", nil)
+          else
+            column = column_for_attribute(name)
+            begin
+              value = if [:date, :time, :datetime].include?(column.type)
+                time_array_to_string(values, column.type)  
+              else
+                klass.new(*values)
+              end
+              send(name + "=", value)
+            rescue => ex
+              errors << ::ActiveRecord::AttributeAssignmentError.new("error on assignment #{values.inspect} to #{name}", ex, name)
+            end
+          end
+        end
+        unless errors.empty?
+          raise ::ActiveRecord::MultiparameterAssignmentErrors.new(errors), "#{errors.size} error(s) on assignment of multiparameter attributes"
+        end
+      end
+      
+      def time_array_to_string(values, type)
+        values = values.map(&:to_s)
+                
+        case type
+          when :date
+            extract_date_from_multiparameter_attributes(values)
+          when :time
+            extract_time_from_multiparameter_attributes(values)
+          when :datetime
+            date_values, time_values = values.slice!(0, 3), values
+            extract_date_from_multiparameter_attributes(date_values) + " " + extract_time_from_multiparameter_attributes(time_values)
+        end
+      end   
+         
+      def extract_date_from_multiparameter_attributes(values)
+        [values[0], *values.slice(1, 2).map { |s| s.rjust(2, "0") }].join("-")
+      end
+      
+      def extract_time_from_multiparameter_attributes(values)
+        values.last(3).map { |s| s.rjust(2, "0") }.join(":")
+      end
+      
+    end
+
+  end
+end
+
+ActiveRecord::Base.send(:include, ValidatesTimeliness::ActiveRecord::MultiparameterAttributes)

data/lib/validates_timeliness/core_ext/date.rb

@@ -0,0 +1,13 @@
+module ValidatesTimeliness
+  module CoreExtensions
+    module Date
+    
+      def to_dummy_time
+        ::Time.send(ValidatesTimeliness.default_timezone, 2000, 1, 1, 0, 0, 0)
+      end
+
+    end
+  end
+end
+
+Date.send(:include, ValidatesTimeliness::CoreExtensions::Date)

data/lib/validates_timeliness/core_ext/date_time.rb

@@ -0,0 +1,13 @@
+module ValidatesTimeliness
+  module CoreExtensions
+    module DateTime
+
+      def to_dummy_time
+        ::Time.send(ValidatesTimeliness.default_timezone, 2000, 1, 1, hour, min, sec)
+      end
+
+    end
+  end
+end
+
+DateTime.send(:include, ValidatesTimeliness::CoreExtensions::DateTime)

data/lib/validates_timeliness/core_ext/time.rb

@@ -0,0 +1,13 @@
+module ValidatesTimeliness
+  module CoreExtensions
+    module Time 
+
+      def to_dummy_time
+        self.class.send(ValidatesTimeliness.default_timezone, 2000, 1, 1, hour, min, sec) 
+      end
+
+    end
+  end
+end
+
+Time.send(:include, ValidatesTimeliness::CoreExtensions::Time)

data/lib/validates_timeliness/formats.rb

@@ -0,0 +1,310 @@
+module ValidatesTimeliness
+  
+  # A date and time format regular expression generator. Allows you to 
+  # construct a date, time or datetime format using predefined tokens in 
+  # a string. This makes it much easier to catalogue and customize the formats
+  # rather than dealing directly with regular expressions. The formats are then
+  # compiled into regular expressions for use validating date or time strings. 
+  #
+  # Formats can be added or removed to customize the set of valid date or time
+  # string values.
+  #
+  class Formats
+    cattr_accessor :time_formats
+    cattr_accessor :date_formats
+    cattr_accessor :datetime_formats
+    
+    cattr_accessor :time_expressions
+    cattr_accessor :date_expressions
+    cattr_accessor :datetime_expressions
+    
+    cattr_accessor :format_tokens
+    cattr_accessor :format_proc_args
+    
+    # Format tokens:   
+    #       y = year
+    #       m = month
+    #       d = day
+    #       h = hour
+    #       n = minute
+    #       s = second
+    #       u = micro-seconds
+    #    ampm = meridian (am or pm) with or without dots (e.g. am, a.m, or a.m.)
+    #       _ = optional space
+    #      tz = Timezone abbreviation (e.g. UTC, GMT, PST, EST)
+    #      zo = Timezone offset (e.g. +10:00, -08:00, +1000)
+    #
+    #   All other characters are considered literal. You can embed regexp in the
+    #   format but no gurantees that it will remain intact. If you avoid the use
+    #   of any token characters and regexp dots or backslashes as special characters 
+    #   in the regexp, it may well work as expected. For special characters use 
+    #   POSIX character clsses for safety.
+    #
+    # Repeating tokens:        
+    #       x = 1 or 2 digits for unit (e.g. 'h' means an hour can be '9' or '09')
+    #      xx = 2 digits exactly for unit (e.g. 'hh' means an hour can only be '09')
+    #      
+    # Special Cases:
+    #      yy = 2 or 4 digit year
+    #   yyyyy = exactly 4 digit year
+    #     mmm = month long name (e.g. 'Jul' or 'July')
+    #     ddd = Day name of 3 to 9 letters (e.g. Wed or Wednesday)
+    #       u = microseconds matches 1 to 6 digits
+    #
+    #   Any other invalid combination of repeating tokens will be swallowed up 
+    #   by the next lowest length valid repeating token (e.g. yyy will be
+    #   replaced with yy)
+    
+    @@time_formats = [
+      'hh:nn:ss',
+      'hh-nn-ss',
+      'h:nn',
+      'h.nn',
+      'h nn',
+      'h-nn',
+      'h:nn_ampm',
+      'h.nn_ampm',
+      'h nn_ampm',
+      'h-nn_ampm',
+      'h_ampm'
+    ]
+    
+    @@date_formats = [
+      'yyyy-mm-dd',
+      'yyyy/mm/dd',
+      'yyyy.mm.dd',
+      'm/d/yy',
+      'd/m/yy',
+      'm\d\yy',
+      'd\m\yy',
+      'd-m-yy',
+      'd.m.yy',
+      'd mmm yy'
+    ]
+    
+    @@datetime_formats = [
+      'yyyy-mm-dd hh:nn:ss',
+      'yyyy-mm-dd h:nn',
+      'yyyy-mm-dd hh:nn:ss.u',
+      'm/d/yy h:nn:ss',
+      'm/d/yy h:nn_ampm',
+      'm/d/yy h:nn',
+      'd/m/yy hh:nn:ss',
+      'd/m/yy h:nn_ampm',
+      'd/m/yy h:nn',
+      'ddd, dd mmm yyyy hh:nn:ss (zo|tz)', # RFC 822
+      'ddd mmm d hh:nn:ss zo yyyy', # Ruby time string
+      'yyyy-mm-ddThh:nn:ss(?:Z|zo)' # iso 8601
+    ]
+    
+    
+    # All tokens available for format construction. The token array is made of 
+    # token regexp, validation regexp and key for format proc mapping if any.
+    # If the token needs no format proc arg then the validation regexp should
+    # not have a capturing group, as all captured groups are passed to the 
+    # format proc.
+    #
+    # The token regexp should only use a capture group if 'look-behind' anchor
+    # is required. The first capture group will be considered a literal and put
+    # into the validation regexp string as-is. This is a hack.
+    @@format_tokens = [
+      { 'd'    => [ /(\A|[^d])d{1}(?=[^d])/, '(\d{1,2})', :day ] }, #/
+      { 'ddd'  => [ /d{3,}/, '(\w{3,9})' ] },
+      { 'dd'   => [ /d{2,}/, '(\d{2})',   :day ] },
+      { 'mmm'  => [ /m{3,}/, '(\w{3,9})', :month ] },
+      { 'mm'   => [ /m{2}/,  '(\d{2})',   :month ] },
+      { 'm'    => [ /(\A|[^ap])m{1}/, '(\d{1,2})', :month ] },
+      { 'yyyy' => [ /y{4,}/, '(\d{4})',   :year ] },
+      { 'yy'   => [ /y{2,}/, '(\d{2}|\d{4})', :year ] },
+      { 'hh'   => [ /h{2,}/, '(\d{2})',   :hour ] },
+      { 'h'    => [ /h{1}/,  '(\d{1,2})', :hour ] },
+      { 'nn'   => [ /n{2,}/, '(\d{2})',   :min ]  },
+      { 'n'    => [ /n{1}/,  '(\d{1,2})', :min ] },
+      { 'ss'   => [ /s{2,}/, '(\d{2})',   :sec ] },
+      { 's'    => [ /s{1}/,  '(\d{1,2})', :sec ] },
+      { 'u'    => [ /u{1,}/, '(\d{1,6})', :usec ] },
+      { 'ampm' => [ /ampm/,  '((?:[aApP])\.?[mM]\.?)', :meridian ] },
+      { 'zo'   => [ /zo/,    '(?:[+-]\d{2}:?\d{2})'] },
+      { 'tz'   => [ /tz/,    '(?:[A-Z]{1,4})' ] }, 
+      { '_'    => [ /_/,     '\s?' ] }
+    ]
+    
+    # Arguments whichs will be passed to the format proc if matched in the 
+    # time string. The key must should the key from the format tokens. The array 
+    # consists of the arry position of the arg, the arg name, and the code to 
+    # place in the time array slot. The position can be nil which means the arg
+    # won't be placed in the array.
+    #
+    # The code can be used to manipulate the arg value if required, otherwise 
+    # should just be the arg name.
+    #
+    @@format_proc_args = {
+      :year     => [0, 'y', 'unambiguous_year(y)'],
+      :month    => [1, 'm', 'month_index(m)'],
+      :day      => [2, 'd', 'd'],
+      :hour     => [3, 'h', 'full_hour(h,md)'],
+      :min      => [4, 'n', 'n'],
+      :sec      => [5, 's', 's'],
+      :usec     => [6, 'u', 'microseconds(u)'],
+      :meridian => [nil, 'md', nil]
+    }
+    
+    class << self
+    
+      def compile_format_expressions
+        @@time_expressions     = compile_formats(@@time_formats)
+        @@date_expressions     = compile_formats(@@date_formats)
+        @@datetime_expressions = compile_formats(@@datetime_formats)
+      end
+      
+      # Loop through format expressions for type and call proc on matches. Allow
+      # pre or post match strings to exist if strict is false. Otherwise wrap
+      # regexp in start and end anchors.
+      # Returns 7 part time array.
+      def parse(string, type, strict=true)
+        return string unless string.is_a?(String)
+        
+        expressions = expression_set(type, string)
+        time_array = nil
+        expressions.each do |(regexp, processor)|
+          regexp = strict || type == :datetime ? /\A#{regexp}\Z/ : (type == :date ? /\A#{regexp}/ : /#{regexp}\Z/)
+          if matches = regexp.match(string.strip)
+            time_array = processor.call(*matches[1..7])
+            break
+          end
+        end
+        return time_array
+      end   
+      
+      # Delete formats of specified type. Error raised if format not found.
+      def remove_formats(type, *remove_formats)
+        remove_formats.each do |format|
+          unless self.send("#{type}_formats").delete(format)
+            raise "Format #{format} not found in #{type} formats"
+          end
+        end
+        compile_format_expressions
+      end
+      
+      # Adds new formats. Must specify format type and can specify a :before
+      # option to nominate which format the new formats should be inserted in 
+      # front on to take higher precedence. 
+      # Error is raised if format already exists or if :before format is not found.
+      def add_formats(type, *add_formats)
+        formats = self.send("#{type}_formats")
+        options = {}
+        options = add_formats.pop if add_formats.last.is_a?(Hash)
+        before = options[:before]
+        raise "Format for :before option #{format} was not found." if before && !formats.include?(before)
+        
+        add_formats.each do |format|
+          raise "Format #{format} is already included in #{type} formats" if formats.include?(format)
+
+          index = before ? formats.index(before) : -1
+          formats.insert(index, format)
+        end
+        compile_format_expressions
+      end
+      
+      
+      # Removes formats where the 1 or 2 digit month comes first, to eliminate
+      # formats which are ambiguous with the European style of day then month. 
+      # The mmm token is ignored as its not ambigous.
+      def remove_us_formats
+        us_format_regexp = /\Am{1,2}[^m]/
+        date_formats.reject! { |format| us_format_regexp =~ format }
+        datetime_formats.reject! { |format| us_format_regexp =~ format }
+        compile_format_expressions
+      end
+    
+    private
+      
+      # Compile formats into validation regexps and format procs    
+      def format_expression_generator(string_format)
+        regexp = string_format.dup      
+        order  = {}
+        regexp.gsub!(/([\.\\])/, '\\\\\1') # escapes dots and backslashes ]/
+        
+        format_tokens.each do |token|
+          token_name = token.keys.first
+          token_regexp, regexp_str, arg_key = *token.values.first
+          
+          # hack for lack of look-behinds. If has a capture group then is 
+          # considered an anchor to put straight back in the regexp string.
+          regexp.gsub!(token_regexp) {|m| "#{$1}" + regexp_str }
+          order[arg_key] = $~.begin(0) if $~ && !arg_key.nil?
+        end
+
+        return Regexp.new(regexp), format_proc(order)
+      rescue
+        puts "The following format regular expression failed to compile: #{regexp}\n from format #{string_format}."
+        raise
+      end
+      
+      # Generates a proc which when executed maps the regexp capture groups to a 
+      # proc argument based on order captured. A time array is built using the proc
+      # argument in the position indicated by the first element of the proc arg
+      # array.
+      #
+      # Examples:
+      #
+      #   'yyyy-mm-dd hh:nn'     => lambda {|y,m,d,h,n| md||=0; [unambiguous_year(y),month_index(m),d,full_hour(h,md),n,nil,nil].map {|i| i.to_i } }
+      #   'dd/mm/yyyy h:nn_ampm' => lambda {|d,m,y,h,n,md| md||=0; [unambiguous_year(y),month_index(m),d,full_hour(h,md),n,nil,nil].map {|i| i.to_i } }
+      #
+      def format_proc(order)
+        arg_map = format_proc_args
+        args = order.invert.sort.map {|p| arg_map[p[1]][1] }
+        arr = [nil] * 7
+        order.keys.each {|k| i = arg_map[k][0]; arr[i] = arg_map[k][2] unless i.nil? }
+        proc_string = "lambda {|#{args.join(',')}| md||=nil; [#{arr.map {|i| i.nil? ? 'nil' : i }.join(',')}].map {|i| i.to_i } }"
+        eval proc_string
+      end
+      
+      def compile_formats(formats)
+        formats.collect { |format| regexp, format_proc = format_expression_generator(format) }
+      end
+  
+      # Pick expression set and combine date and datetimes for 
+      # datetime attributes to allow date string as datetime
+      def expression_set(type, string)
+        case type
+          when :date
+            date_expressions
+          when :time
+            time_expressions
+          when :datetime
+            # gives a speed-up for date string as datetime attributes
+            if string.length < 11
+              date_expressions + datetime_expressions
+            else
+              datetime_expressions + date_expressions
+            end
+        end
+      end
+ 
+      def full_hour(hour, meridian)
+        hour = hour.to_i
+        return hour if meridian.nil?
+        if meridian.delete('.').downcase == 'am'
+          hour == 12 ? 0 : hour
+        else
+          hour == 12 ? hour : hour + 12
+        end
+      end
+      
+      def unambiguous_year(year, threshold=30)
+        year = "#{year.to_i < threshold ? '20' : '19'}#{year}" if year.length == 2
+        year.to_i
+      end
+      
+      def month_index(month)
+        return month.to_i if month.to_i.nonzero?
+        Date::ABBR_MONTHNAMES.index(month.capitalize) || Date::MONTHNAMES.index(month.capitalize)
+      end
+    
+      def microseconds(usec)
+        (".#{usec}".to_f * 1_000_000).to_i
+      end
+    end
+  end
+end