szilm-validates_timeliness 2.3.1

data/Rakefile

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rubygems/specification'
+require 'date'
+require 'spec/rake/spectask'
+require 'lib/validates_timeliness/version'
+
+GEM = "validates_timeliness"
+GEM_VERSION = ValidatesTimeliness::VERSION
+
+spec = Gem::Specification.new do |s|
+  s.name = GEM
+  s.version = GEM_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.rubyforge_project = "validatestime"
+  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.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}/**/*")
+end
+
+task :default => :spec
+
+desc "Run specs"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = %w(--color)
+end
+
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+desc "install the gem locally"
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{GEM}-#{GEM_VERSION}}
+end
+
+desc "create a gemspec file"
+task :make_spec do
+  File.open("#{GEM}.gemspec", "w") do |file|
+    file.puts spec.to_ruby
+  end
+end

data/TODO

@@ -0,0 +1,8 @@
+- valid formats could come from locale file
+- add replace_formats instead add_formats :before
+- array of values for all temporal options
+- use tz and zo value from time string?
+- filter valid formats rather than remove for hot swapping without recompilation
+- config generator
+- move all config into top namespace
+- remove action_view stuff

data/lib/validates_timeliness.rb

@@ -0,0 +1,49 @@
+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'
+
+module ValidatesTimeliness
+
+  mattr_accessor :default_timezone
+  self.default_timezone = :utc
+
+  mattr_accessor :use_time_zones
+  self.use_time_zones = false
+
+  LOCALE_PATH = File.expand_path(File.dirname(__FILE__) + '/validates_timeliness/locale/en.yml')
+
+  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
+  end
+end
+
+ValidatesTimeliness.setup_for_rails

data/lib/validates_timeliness/action_view/instance_tag.rb

@@ -0,0 +1,52 @@
+# TODO remove this from the plugin for v3.
+module ValidatesTimeliness
+
+  def self.enable_datetime_select_invalid_value_extension!
+    ::ActionView::Helpers::InstanceTag.send(:include, ValidatesTimeliness::ActionView::InstanceTag)
+  end
+
+  module ActionView
+
+    # 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.
+    #
+    module InstanceTag
+
+      def self.included(base)
+        selector_method = Rails::VERSION::STRING.to_f < 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)
+        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 = pairs.map do |(param, value)|
+          position = param.scan(/\(([0-9]*).*\)/).first.first
+          [position, value]
+        end.sort {|a,b| a[0] <=> b[0] }.map {|v| v[1] }
+
+        TimelinessDateTime.new(*values)
+      end
+
+    end
+
+  end
+end

data/lib/validates_timeliness/active_record/attribute_methods.rb

@@ -0,0 +1,77 @@
+module ValidatesTimeliness
+
+  def self.enable_active_record_datetime_parser!
+    ::ActiveRecord::Base.send(:include, ValidatesTimeliness::ActiveRecord::AttributeMethods)
+  end
+
+  module ActiveRecord
+
+    # Overrides write method for date, time and datetime columns
+    # to use plugin parser. Also adds mechanism to store value
+    # before type cast.
+    #
+    module AttributeMethods
+
+      def self.included(base)
+        base.extend ClassMethods
+        base.class_eval do
+          alias_method_chain :read_attribute_before_type_cast, :timeliness
+          class << self
+            alias_method_chain :define_attribute_methods, :timeliness
+          end
+        end
+      end
+
+      def write_date_time_attribute(attr_name, value, type, time_zone_aware)
+        @attributes_cache["_#{attr_name}_before_type_cast"] = value
+        value = ValidatesTimeliness::Parser.parse(value, type)
+
+        if value && type != :date
+          value = value.to_time unless Time === value
+          value = value.in_time_zone if time_zone_aware
+        end
+
+        write_attribute(attr_name.to_sym, value)
+      end
+
+      def read_attribute_before_type_cast_with_timeliness(attr_name)
+        cached_attr = "_#{attr_name}_before_type_cast"
+        return @attributes_cache[cached_attr] if @attributes_cache.has_key?(cached_attr)
+        read_attribute_before_type_cast_without_timeliness(attr_name)
+      end
+
+      module ClassMethods
+
+        def define_attribute_methods_with_timeliness
+          return if generated_methods?
+          timeliness_methods = []
+
+          columns_hash.each do |name, column|
+            if [:date, :time, :datetime].include?(column.type)
+              method_name = "#{name}="
+              next if instance_method_already_implemented?(method_name)
+
+              time_zone_aware = create_time_zone_conversion_attribute?(name, column) rescue false
+              define_method(method_name) do |value|
+                 write_date_time_attribute(name, value, column.type, time_zone_aware)
+              end
+              timeliness_methods << method_name
+            end
+          end
+
+          # Hack to get around instance_method_already_implemented? caching the
+          # methods in the ivar. It then appears to subsequent calls that the
+          # methods defined here, have not been and get defined again.
+          @_defined_class_methods = nil
+
+          define_attribute_methods_without_timeliness
+          # add generated methods which is a Set object hence no += method
+          timeliness_methods.each {|attr| generated_methods << attr }
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/validates_timeliness/active_record/multiparameter_attributes.rb

@@ -0,0 +1,69 @@
+module ValidatesTimeliness
+
+  def self.enable_multiparameter_attributes_extension!
+    ::ActiveRecord::Base.send(:include, ValidatesTimeliness::ActiveRecord::MultiparameterAttributes)
+  end
+
+  module ActiveRecord
+
+    class << self
+
+      def time_array_to_string(values, type)
+        values.collect! {|v| v.to_s }
+
+        case type
+        when :date
+          extract_date_from_multiparameter_attributes(values)
+        when :time
+          extract_time_from_multiparameter_attributes(values)
+        when :datetime
+          extract_date_from_multiparameter_attributes(values) + " " + extract_time_from_multiparameter_attributes(values)
+        end
+      end
+
+      def extract_date_from_multiparameter_attributes(values)
+        year = values[0].blank? ? nil : ValidatesTimeliness::Formats.unambiguous_year(values[0].rjust(2, "0"))
+        [year, *values.slice(1, 2).map { |s| s.blank? ? nil : s.rjust(2, "0") }].join("-")
+      end
+
+      def extract_time_from_multiparameter_attributes(values)
+        values[3..5].map { |s| s.blank? ? nil : s.rjust(2, "0") }.join(":")
+      end
+
+    end
+
+    module MultiparameterAttributes
+
+      def self.included(base)
+        base.alias_method_chain :execute_callstack_for_multiparameter_attributes, :timeliness
+      end
+
+      # Assign dates and times as formatted strings to force the use of the plugin parser
+      def execute_callstack_for_multiparameter_attributes_with_timeliness(callstack)
+        errors = []
+        callstack.each do |name, values|
+          column = column_for_attribute(name)
+          if column && [:date, :time, :datetime].include?(column.type)
+            begin
+              callstack.delete(name)
+              if values.empty? || values.all?(&:nil?)
+                send("#{name}=", nil)
+              else
+                value = ValidatesTimeliness::ActiveRecord.time_array_to_string(values, column.type)
+                send("#{name}=", value)
+              end
+            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
+        execute_callstack_for_multiparameter_attributes_without_timeliness(callstack)
+      end
+
+    end
+
+  end
+end

data/lib/validates_timeliness/formats.rb

@@ -0,0 +1,365 @@
+require 'date'
+
+module ValidatesTimeliness
+
+  # A date and time parsing library which allows you to add custom formats using
+  # simple predefined tokens. This makes it much easier to catalogue and customize
+  # the formats rather than dealing directly with regular expressions.
+  #
+  # Formats can be added or removed to customize the set of valid date or time
+  # string values.
+  #
+  class Formats
+    cattr_accessor :time_formats,
+                   :date_formats,
+                   :datetime_formats,
+                   :time_expressions,
+                   :date_expressions,
+                   :datetime_expressions,
+                   :format_tokens,
+                   :format_proc_args
+
+
+    # Set the threshold value for a two digit year to be considered last century
+    #
+    # Default: 30
+    #
+    #   Example:
+    #     year = '29' is considered 2029
+    #     year = '30' is considered 1930
+    #
+    cattr_accessor :ambiguous_year_threshold
+    self.ambiguous_year_threshold = 30
+
+    # Set the dummy date part for a time type value. Should be an array of 3 values
+    # being year, month and day in that order.
+    #
+    # Default: [ 2000, 1, 1 ] same as ActiveRecord
+    #
+    cattr_accessor :dummy_date_for_time_type
+    self.dummy_date_for_time_type = [ 2000, 1, 1 ]
+
+    # 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
+    #    yyyy = 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 h:nn_ampm',
+      '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:ssZ', # iso 8601 without zone offset
+      'yyyy-mm-ddThh:nn:sszo' # iso 8601 with zone offset
+    ]
+
+
+    # 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{4}|\d{2})', :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})', :offset ] },
+      { 'tz'   => [ /tz/,    '(?:[A-Z]{1,4})' ] },
+      { '_'    => [ /_/,     '\s?' ] }
+    ]
+
+    # Arguments which will be passed to the format proc if matched in the
+    # time string. The key must be 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)'],
+      :offset   => [7,   'z', 'offset_in_seconds(z)'],
+      :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 time array if matches a format, nil otherwise.
+      def parse(string, type, options={})
+        return string unless string.is_a?(String)
+        options.reverse_merge!(:strict => true)
+
+        sets = if options[:format]
+          options[:strict] = true
+          [ send("#{type}_expressions").assoc(options[:format]) ]
+        else
+          expression_set(type, string)
+        end
+
+        matches = nil
+        processor = sets.each do |format, regexp, proc|
+          full = /\A#{regexp}\Z/ if options[:strict]
+          full ||= case type
+          when :date     then /\A#{regexp}/
+          when :time     then /#{regexp}\Z/
+          when :datetime then /\A#{regexp}\Z/
+          end
+          break(proc) if matches = full.match(string.strip)
+        end
+        last = options[:include_offset] ? 8 : 7
+        if matches
+          values = processor.call(*matches[1..last])
+          values[0..2] = dummy_date_for_time_type if type == :time
+          return values
+        end
+      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
+
+      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)
+        if year.length <= 2
+          century = Time.now.year.to_s[0..1].to_i
+          century -= 1 if year.to_i >= ambiguous_year_threshold
+          year = "#{century}#{year.rjust(2,'0')}"
+        end
+        year.to_i
+      end
+
+      def month_index(month)
+        return month.to_i if month.to_i.nonzero?
+        abbr_month_names.index(month.capitalize) || month_names.index(month.capitalize)
+      end
+
+      def month_names
+        defined?(I18n) ? I18n.t('date.month_names') : Date::MONTHNAMES
+      end
+
+      def abbr_month_names
+        defined?(I18n) ? I18n.t('date.abbr_month_names') : Date::ABBR_MONTHNAMES
+      end
+
+      def microseconds(usec)
+        (".#{usec}".to_f * 1_000_000).to_i
+      end
+
+      def offset_in_seconds(offset)
+        sign = offset =~ /^-/ ? -1 : 1
+        parts = offset.scan(/\d\d/).map {|p| p.to_f }
+        parts[1] = parts[1].to_f / 60
+        (parts[0] + parts[1]) * sign * 3600
+      end
+
+    private
+
+      # Generate regular expression and processor from format string
+      def generate_format_expression(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
+        raise "The following format regular expression failed to compile: #{regexp}\n from format #{string_format}."
+      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.
+      #
+      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 = <<-EOL
+          lambda {|#{args.join(',')}|
+              md ||= nil
+              [#{arr.map {|i| i.nil? ? 'nil' : i }.join(',')}].map {|i| i.is_a?(Float) ? i : i.to_i }
+          }
+        EOL
+        eval proc_string
+      end
+
+      def compile_formats(formats)
+        formats.map { |format| [ format, *generate_format_expression(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
+
+    end
+  end
+end
+
+ValidatesTimeliness::Formats.compile_format_expressions