ndr_support 3.1.1

data/lib/ndr_support/date_and_time_extensions.rb

@@ -0,0 +1,103 @@
+require 'yaml'
+
+require 'ndr_support/concerns/working_days'
+[Time, Date, DateTime].each { |klass| klass.send(:include, WorkingDays) }
+
+class Date
+  # Note: default date format is specified in config/environment.rb
+  def to_verbose
+    strftime('%d %B %Y')
+  end # our long format
+
+  # to_iso output must be SQL safe for security reasons
+  def to_iso
+    strftime('%Y-%m-%d')
+  end # ISO date format
+
+  def to_ours
+    to_s
+  end
+
+  def to_YYYYMMDD # convert dates into format 'YYYYMMDD' - used in tracing
+    self.year.to_s + self.month.to_s.rjust(2, '0') + self.day.to_s.rjust(2, '0')
+  end
+end
+
+#-------------------------------------------------------------------------------
+
+class Time
+  def to_ours
+    strftime('%d.%m.%Y %H:%M')
+  end # Show times in our format
+
+  # to_iso output must be SQL safe for security reasons
+  def to_iso
+    strftime('%Y-%m-%dT%H:%M:%S')
+  end
+end
+
+#-------------------------------------------------------------------------------
+
+module NdrSupport
+  class << self
+    # Within the NDR, we change default date formatting, as below.
+    # This can cause problems with YAML emitted by syck, so we have to
+    # patch Date#to_yaml too.
+    def apply_era_date_formats!
+      update_date_formats!
+      update_time_formats!
+
+      attempt_date_patch!
+    end
+
+    def attempt_date_patch!
+      # There are potential load order issues with this patch,
+      # as it needs to be applied once syck has loaded.
+      fail('Date#to_yaml must exist to be patched!') unless Date.respond_to?(:to_yaml)
+      apply_date_patch!
+    end
+
+    private
+
+    def apply_date_patch!
+      # With YAML's crazy engine switching, it seems we
+      # can't rely including a module to define this method:
+      Date.module_eval do
+        def to_yaml(opts = {})
+          ::YAML.quick_emit(object_id, opts) do |out|
+            out.scalar('tag:yaml.org,2002:timestamp', to_s(:yaml), :plain)
+          end
+        end
+      end
+    end
+
+    # Override default date and time formats:
+    def update_date_formats!
+      Date::DATE_FORMATS.update(
+        :db      => '%Y-%m-%d %H:%M:%S',
+        :ui      => '%d.%m.%Y',
+        :yaml    => '%Y-%m-%d', # For Dates
+        :default => '%d.%m.%Y'
+      )
+    end
+
+    # Rails 2 loads Oracle dates (with timestamps) as DateTime or Time values
+    # (before or after 1970) whereas Rails 1.2 treated them as Date objects.
+    # Therefore we have a formatting challenge, which we overcome by hiding
+    # the time if it's exactly midnight
+    def update_time_formats!
+      Time::DATE_FORMATS.update(
+        :db      => '%Y-%m-%d %H:%M:%S',
+        :ui      => '%d.%m.%Y %H:%M',
+        :yaml    => '%Y-%m-%d %H:%M:%S %:z', # For DateTimes
+        :default => lambda do |time|
+          non_zero_time = time.hour != 0 || time.min != 0 || time.sec != 0
+          time.strftime(non_zero_time ? '%d.%m.%Y %H:%M' : '%d.%m.%Y')
+        end
+      )
+    end
+  end
+end
+
+# Maintain API:
+NdrSupport.attempt_date_patch!

data/lib/ndr_support/daterange.rb

@@ -0,0 +1,196 @@
+require 'active_support/time'
+require 'ndr_support/fixnum/julian_date_conversions'
+
+# Our "vague date" class, which can represent a single date or a date range.
+class Daterange
+  attr_reader :date1, :date2, :source
+
+  OKYEARS = 1880..2020
+
+  def self.extract(dates_string)
+    dates_string.to_s.split(',').map { |str| new(str) }
+  end
+
+  def self.merge(dates_string)
+    ranges = extract(dates_string)
+    new(ranges.map(&:date1).compact.min, ranges.map(&:date2).compact.max)
+  end
+
+  def initialize(x1 = nil, x2 = nil)
+    x1 = x1.to_datetime if x1.is_a?(Date) || x1.is_a?(Time)
+    x2 = x2.to_datetime if x2.is_a?(Date) || x2.is_a?(Time)
+
+    if x1.is_a?(DateTime) && x2.is_a?(DateTime)
+      @date1 = [x1, x2].min
+      @date2 = [x1, x2].max
+      @source = nil
+    elsif x1.is_a?(Daterange) && x2.nil?  # Patient model line 645
+      @date1 = x1.date1
+      @date2 = x1.date2
+      @source = x1.source
+    elsif x1.is_a?(DateTime) && x2.nil?
+      @date1 = x1
+      @date2 = x1
+      @source = nil
+    elsif x1.is_a?(String) && x2.nil?
+      self.source = (x1)
+    else
+      @date1 = nil
+      @date2 = nil
+      @source = nil
+    end
+    self.freeze
+  end
+
+  # If we have a valid date range, return a string representation of it
+  # TODO: possibly add support for to_s(format) e.g. to_s(:short)
+  def to_s
+    return '' unless @date1 && @date2
+    if @date1 == @date2 # single date
+      tidy_string_if_midnight(@date1)
+    elsif tidy_string_if_midnight(@date1) == tidy_string_if_midnight(@date2.at_beginning_of_year) &&
+          tidy_string_if_midnight(@date2) == tidy_string_if_midnight(@date1.at_end_of_year.at_beginning_of_day) # whole year
+      @date1.strftime('%Y')
+    elsif tidy_string_if_midnight(@date1) == tidy_string_if_midnight(@date2.at_beginning_of_month) &&
+          tidy_string_if_midnight(@date2) == tidy_string_if_midnight(@date1.at_end_of_month.at_beginning_of_day) # whole month
+      @date1.strftime('%m.%Y')
+    else # range
+      tidy_string_if_midnight(@date1) + ' to ' + tidy_string_if_midnight(@date2)
+    end
+  end
+
+  # used in Address model
+  # to_iso output must be SQL safe for security reasons
+  def to_iso
+    date1.is_a?(DateTime) ? date1.to_iso : ''
+  end
+
+  # A long string representation of the date or range
+  def verbose
+    return 'Bad date(s)' unless @date1 && @date2
+    if @date1 == @date2 # single date
+      @date1.to_verbose
+    else # range
+      'The period ' + @date1.to_verbose + ' to ' + @date2.to_verbose +
+        ' inclusive (' + (@date2 - @date1 + 1).to_s + ' days)'
+    end
+  end
+
+  def date1=(d)
+    if @source
+      @source += ' [d1 modified]'
+    else
+      @source = '[d1 modified]'
+    end
+    @date1 = d
+  end
+
+  def date2=(d)
+    if @source
+      @source += ' [d2 modified]'
+    else
+      @source = '[d2 modified]'
+    end
+    @date2 = d
+  end
+
+  def <=>(other)
+    self.date1 <=> other.date1
+  end
+
+  def ==(other)
+    self.date1 == other.date1 && self.date2 == other.date2
+  end
+
+  def intersects?(other)
+    !(self.empty? || other.empty?) && self.date1 <= other.date2 && self.date2 >= other.date1
+  end
+
+  def empty?
+    # An unspecified date will be empty. A valid or invalid date will not.
+    @date1.nil? && @source.blank?
+  end
+
+  def exact?
+    @date1 == @date2
+  end
+
+  private
+
+  def tidy_string_if_midnight(datetime)
+    if datetime.hour == 0 && datetime.min == 0 && datetime.sec == 0
+      # it's midnight
+      datetime.to_date.to_s(:ui)
+    else
+      return datetime.to_time.to_s(:ui)
+    end
+  end
+
+  # Update our attribute values using a string representation of the date(s).
+  # +s+ consists of one or more dates separated with spaces.
+  # Each date can be in various formats, e.g. d/m/yyyy, ddmmyyyy, yyyy-mm-dd.
+  # Each date can omit days or months, e.g. yyyy, dd/yyyy, yyyy-mm
+  def source=(s)
+    @source = s
+    ss = s.upcase.sub(/TO/, ' ') # accept default _to_s format
+    if ss =~ /[^0-9\-\/\. ]/ # only allow digits, hyphen, slash, dot, space
+      @date1 = @date2 = nil
+    else
+      da = [] # temporary array of arrays of dates
+      ss.split(' ').each do |vaguedate|
+        da << str_to_date_array(vaguedate)
+      end
+      da.flatten!
+      if da.include?(nil)
+        @date1 = @date2 =  nil
+      else
+        da.sort!
+        @date1, @date2 = da.first, da.last
+      end
+    end
+  end
+
+  # Take a string representation of a single date (which may be incomplete,
+  # e.g year only or year/month only) and return an array of two dates,
+  # being the earliest and latest that fit the partial date.
+  def str_to_date_array(ds)
+    parts = date_string_parts(ds)
+    return if parts.nil? || OKYEARS.exclude?(parts[0])
+
+    case parts.length
+    when 1 # just a year
+      j1 = Date.new(parts[0], 1, 1).jd
+      j2 = Date.new(parts[0], 12, 31).jd
+    when 2 # year and month
+      j1 = Date.new(parts[0], parts[1], 1).jd
+      j2 = Date.new(parts[0], parts[1], -1).jd
+    when 3 # full date
+      j1 = j2 = Date.new(parts[0], parts[1], parts[2]).jd
+    end
+
+    [j1.jd_to_datetime, j2.jd_to_datetime]
+  rescue
+    nil
+  end
+
+  # Take a string representation of a single date (which may be incomplete,
+  # e.g year only or year/month only) and return an array of 1..3 integers
+  # representing the year, month and day
+  def date_string_parts(ds)
+    if ds =~ /([\/\.\-])/ # find a slash or dot or hyphen
+      delimiter = $1
+      result = ds.split(delimiter)
+    elsif ds.length == 8 # ddmmyyyy
+      result = [ds[0..1], ds[2..3], ds[4..7]]
+    elsif ds.length == 6 # mmyyyy
+      result = [ds[0..1], ds[2..5]]
+    elsif ds.length == 4 # yyyy
+      result = [ds]
+    else
+      result = []
+    end
+    return nil unless (1..3) === result.length
+    result.reverse! unless delimiter == '-' # change to YMD if not ISO format
+    result.collect(&:to_i)
+  end
+end

data/lib/ndr_support/fixnum/calculations.rb

@@ -0,0 +1,15 @@
+class Fixnum
+  # Gets binomial coefficients:
+  #
+  #   4.choose(2) #=> 6
+  #
+  def choose(k)
+    fail(ArgumentError, "cannot choose #{k} from #{self}") unless (0..self) === k
+    self.factorial / (k.factorial * (self - k).factorial)
+  end
+
+  def factorial
+    fail("cannot calculate #{self}.factorial") unless self >= 0 # limited implementation
+    self.zero? ? 1 : (1..self).inject { |product, i| product * i }
+  end
+end

data/lib/ndr_support/fixnum/julian_date_conversions.rb

@@ -0,0 +1,14 @@
+require 'ndr_support/ourdate'
+
+# Extend Fixnum for use in our Daterange class
+class Fixnum
+  # Julian date number to Ruby Date
+  def jd_to_date
+    Date.jd(self)
+  end
+
+  def jd_to_datetime
+    date = jd_to_date
+    Ourdate.build_datetime(date.year, date.month, date.day)
+  end
+end

data/lib/ndr_support/hash.rb

@@ -0,0 +1,52 @@
+class Hash
+  # Special intersection method allowing us to intersect a hash with
+  # an array of keys. Matches string and symbol keys (like stringify_keys)
+  #
+  # For example
+  # {:a => 1, :b => :two, 'c' => '3'} & [:a, :c]
+  # => {:a => 1, 'c' => '3'}
+  def &(*keys)
+    h = {}
+    each { |k, v| h[k] = v if keys.flatten.map(&:to_s).include?(k.to_s) }
+    h
+  end
+
+  # This method allows us to walk the path of nested hashes to reference a value
+  #
+  # For example,
+  # my_hash = { 'one' => '1', 'two' => { 'twopointone' => '2.1', 'twopointtwo' => '2.2' } }
+  # my_hash['one']                 becomes  my_hash.value_by_path('one')
+  # my_hash['two']['twopointone']  becomes  my_hash.value_by_path('two', 'twopointone')
+  #
+  def value_by_path(first_key, *descendant_keys)
+    result = self[first_key]
+    descendant_keys.each do |key|
+      result = result[key]
+    end
+    result
+  end
+
+  # This method merges this hash with another, but also merges the :rawtext
+  # (rather than replacing the current hashes rawtext with the second).
+  # Additionally it can raise a RuntimeError to prevent the second hash
+  # overwriting the value for a key from the first.
+  def rawtext_merge(hash2, prevent_overwrite = true)
+    hash1_rawtext = self[:rawtext] || {}
+    hash2_rawtext = hash2[:rawtext] || {}
+
+    if prevent_overwrite
+      non_unique_rawtext_keys = hash1_rawtext.keys & hash2_rawtext.keys
+      unless non_unique_rawtext_keys.empty?
+        fail("Non-unique rawtext keys: #{non_unique_rawtext_keys.inspect}")
+      end
+      non_unique_non_rawtext_keys = (keys & hash2.keys) - [:rawtext]
+      unless non_unique_non_rawtext_keys.empty?
+        fail("Non-unique non-rawtext keys: #{non_unique_non_rawtext_keys.inspect}")
+      end
+    end
+
+    merge(hash2).merge(
+      :rawtext => hash1_rawtext.merge(hash2_rawtext)
+    )
+  end
+end

data/lib/ndr_support/integer.rb

@@ -0,0 +1,12 @@
+class Integer
+  # Rounds up to _p_ digits. For graphs. Josh Pencheon 22/08/2007
+  def round_up_to(p)
+    return nil if p > self.to_s.length || p < 0
+    p = p.to_i
+    s = self.to_s.split('')
+    d = s[0..(p - 1)]
+    d[p - 1] = s[p - 1].to_i + 1
+    s[p..-1].each_with_index { |_v, i| d[i + p] = '0' }
+    d.join.to_i
+  end
+end

data/lib/ndr_support/nil.rb

@@ -0,0 +1,38 @@
+# Extend Nilclass to avoid nil.xxx errors when empty data returned from database
+class NilClass
+  def to_date
+    nil
+  end
+
+  def titleize
+    nil
+  end
+
+  def surnameize
+    nil
+  end
+
+  def postcodeize(*)
+    nil
+  end
+
+  def upcase
+    nil
+  end
+
+  def clean(*)
+    nil
+  end
+
+  def squash
+    nil
+  end
+
+  def gsub(*)
+    ''
+  end
+
+  def strip
+    nil
+  end
+end

data/lib/ndr_support/ourdate.rb

@@ -0,0 +1,97 @@
+require 'active_record'
+require 'active_support/time'
+require 'ndr_support/date_and_time_extensions'
+require 'ndr_support/daterange'
+
+# Convert a string into a single date
+# (helped by String.thedate)
+class Ourdate
+  attr_reader :thedate
+
+  # We need a daylight saving time safe was of defining the date today.
+  def self.today
+    current_time = Time.now
+    #--
+    # TODO: Use Ourdate.build_datetime everywhere below:
+    #++
+    if ActiveRecord::Base.default_timezone == :local
+      build_datetime(current_time.year, current_time.month, current_time.day)
+    else
+      #--
+      # Only supports fake GMT time -- needs improvement
+      # Maybe use Time.zone.local or Time.local_time(year, month, day)
+      #++
+      Time.gm(current_time.year, current_time.month, current_time.day, 0, 0, 0, 0).to_datetime
+    end
+  end
+
+  # Construct a daylight saving time safe datetime, with arguments
+  #--
+  # FIXME: Note that the arguments should be numbers, not strings -- it works
+  # with strings arguments only after the 1970 epoch; before, it returns nil.
+  #++
+  def self.build_datetime(year, month = 1, day = 1, hour = 0, min = 0, sec = 0, usec = 0)
+    if ActiveRecord::Base.default_timezone == :local
+      # Time.local_time(year, month, day, hour, min, sec, usec).to_datetime
+      # Behave like oracle_adapter.rb
+      seconds = sec + Rational(usec, 10**6)
+      time_array = [year, month, day, hour, min, seconds]
+      begin
+        #--
+        # TODO: Fails unit tests unless we .to_datetime here
+        #       but the risk is we lose the usec component unnecesssarily.
+        #       Investigate removing .to_datetime below.
+        #++
+        Time.send(ActiveRecord::Base.default_timezone, *time_array).to_datetime
+      rescue
+        zone_offset = ActiveRecord::Base.default_timezone == :local ? DateTime.now.offset : 0
+        # Append zero calendar reform start to account for dates skipped by calendar reform
+        DateTime.new(*time_array[0..5] << zone_offset << 0) rescue nil
+      end
+    else
+      # Only supports fake GMT time -- needs improvement
+      # Maybe use Time.zone.local or Time.local_time(year, month, day)
+      Time.utc(year, month, day, hour, min, sec, usec).to_datetime
+    end
+  end
+
+  def initialize(x = nil)
+    if x.is_a?(Date)
+      @thedate = x
+    elsif x.is_a?(Time)
+      @thedate = x.to_datetime
+    elsif x.is_a?(String)
+      self.source = x
+    else
+      @thedate = nil
+    end
+  end
+
+  def to_s
+    @thedate ? @thedate.to_date.to_s(:ui) : ''
+  end
+
+  def empty?
+    # An unspecified date will be empty. A valid or invalid date will not.
+    @thedate.nil? && @source.blank?
+  end
+
+  def source=(s)
+    dr = Daterange.new(s)
+    if dr.date1 == dr.date2
+      @thedate = dr.date1
+    else
+      @thedate = nil
+    end
+  end
+
+  # Compute date difference in years (e.g. patient age), as an integer
+  # For a positive result, the later date should be the first argument.
+  # Leap days are treated as for age calculations.
+  def self.date_difference_in_years(date2, date1)
+    (date2.strftime('%Y%m%d').sub(/0229$/, '0228').to_i -
+     date1.strftime('%Y%m%d').sub(/0229$/, '0228').to_i) / 10_000
+  end
+
+  private :source=
+end