incomplete_date 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 60bcab9d810f4b939ecf3b9ff1e5df23f8b04482947110dedd527766df9d6fb3
+  data.tar.gz: 0a271f6433f699854bf2939ad1eb5d46cdbab7783430554185e1bedcf3090a31
+SHA512:
+  metadata.gz: a725a7381bb110165ce22e002e62c616a7d95155c5fdd14f7f5e7b44212e0909266081ae59b1b51c04337e7175c5aea67703b8360a1a259eddabbfd81a050f1b
+  data.tar.gz: 7e7fd53527085104b73e7dba177a32d9bf22f597c23e4095e7109c089b194435623f0ba3f27b1945e771cd4d11419ebe1b7b003163dae831b4ac512f7496173f

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Ernesto García
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,22 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the incomplete_date plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the incomplete_date plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'IncompleteDate'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/incomplete_date.rb

@@ -0,0 +1,296 @@
+require 'incomplete_date/date'
+require 'incomplete_date/active_record'
+require 'incomplete_date/form_builder'
+
+class IncompleteDate
+  attr_reader :day, :month, :year
+  attr_accessor :circa
+  alias mday day
+
+  def initialize(value)
+    @circa = false
+
+    case value
+    when Integer
+      @circa = (value < 0)
+      num = value.abs
+      num, @day = num.divmod(100)
+      @year, @month = num.divmod(100)
+    when Hash
+      @day, @month, @year = value[:day], value[:month], value[:year]
+      @circa = value.fetch(:circa, false)
+    when Date
+      @day, @month, @year = value.mday, value.month, value.year
+    when IncompleteDate
+      @day, @month, @year, @circa = value.day, value.month, value.year, value.circa
+    when nil #invaluable for existing databases!
+    	@day, @month, @year, @circa = 0, 0, 0, false
+    else
+      raise ArgumentError, "Invalid #{self.class.name} specification"
+    end
+
+    @day = nil if @day == 0
+    @month = nil if @month == 0
+    @year = nil if @year == 0
+  end
+
+  #--
+  # Core attributes handling
+  #++
+
+  #
+  # Returns +true+ if the given year is a leap year, +false+ otherwise.
+  #
+  def self.leap_year?(year)
+    raise ArgumentError, "year cannot be null or zero" if year.nil? or year.zero?
+    (year % 4 == 0) && (year % 100 != 0 || year % 400 == 0)
+  end
+
+  def self.max_month_days(month = nil, year = nil)
+    year ||= 2000 # Assume a leap year if year is not known
+    case month
+    when nil,1,3,5,7,8,10,12 then 31
+    when 4,6,9,11 then 30
+    when 2 then leap_year?(year) ? 29 : 28
+    else raise ArgumentError, "invalid month"
+    end
+  end
+
+  def valid_day?(day, month = nil, year = nil)
+    return true if day.nil? || day.zero?
+    max = IncompleteDate.max_month_days(month || self.month, year || self.year)
+    (1..max).include?(day)
+  end
+
+  def valid_month?(month)
+    return true if month.nil? || month.zero?
+    (1..12).include?(month) && valid_day?(self.day, month)
+  end
+
+  def valid_year?(year, month = nil, day = nil)
+    return true if year.nil? || year.zero?
+    day ||= self.day
+    month ||= self.month
+    !(!IncompleteDate.leap_year?(year) && (day == 29) && (month == 2))
+  end
+
+  def day=(value)
+    value = (value == 0) ? nil : value
+    raise ArgumentError, "invalid day" unless valid_day?(value)
+    @day = value
+  end
+
+  def month=(value)
+    value = (value == 0) ? nil : value
+    raise ArgumentError, "invalid month" unless valid_month?(value)
+    @month = value
+  end
+
+  def year=(value)
+    value = (value == 0) ? nil : value
+    raise ArgumentError, "invalid year" unless valid_year?(value)
+    @year = value
+  end
+
+  def circa?
+    @circa
+  end
+
+  VALID_DATE_PARTS = [:year, :month, :day, :circa]
+
+  def [](part_name)
+    raise ArgumentError, "Invalid date part #{part_name}" unless VALID_DATE_PARTS.include?(part_name)
+    self.send(part_name)
+  end
+
+  def []=(part_name, value)
+    raise ArgumentError, "Invalid date part #{part_name}" unless VALID_DATE_PARTS.include?(part_name)
+    self.send("#{part_name}=", value)
+  end
+
+  #--
+  # Testing completeness
+  #++
+
+  def incomplete?
+    @day.nil? || @month.nil? || @year.nil?
+  end
+
+  def complete?
+    !incomplete?
+  end
+
+  def exact?
+    complete? && !circa?
+  end
+
+  def empty?
+    @day.nil? && @month.nil? && @year.nil?
+  end
+
+  def has?(*parts)
+    parts.collect!(&:to_sym)
+    parts.inject(true) { |total,part| total && !self.send(part).nil? }
+  end
+
+  def has_day?
+    !@day.nil?
+  end
+
+  def has_month?
+    !@month.nil?
+  end
+
+  def has_year?
+    !@year.nil?
+  end
+
+  def defines_birthday?
+    has_day? && has_month?
+  end
+
+  def defined_parts
+    VALID_DATE_PARTS.reject { |part| (part == :circa) || self[part].nil? }
+  end
+
+  #++
+  # Relation to complete dates
+  #--
+
+  #
+  # Returns +true+ if the given date is included in the possible set of complete
+  # dates that match this incomplete date.
+  #
+  # For instance 2003-xx-xx includes 2003-12-24 (or any date within the year
+  # 2003) but it does not include 1999-12-14, for instance.
+  #
+  # The argument can be either a Date instance or an IncompleteDate instance.
+  #
+  def include?(date)
+    (self.year.nil? || (date.year == self.year)) &&
+    (self.month.nil? || (date.month == self.month)) &&
+    (self.day.nil? || (date.mday == self.mday))
+  end
+
+  #
+  # Returns the lowest possible date that matches this incomplete date.
+  #
+  # Only defined if this incomplete date has the year part defined. Otherwise it
+  # returns +nil+.
+  #
+  # see #highest
+  #
+  def lowest
+    return nil unless has_year?
+    Date.civil(self.year, self.month || 1, self.day || 1)
+  end
+  alias min lowest
+  alias first lowest
+
+  #
+  # Returns the highest possible date that matches this incomplete date.
+  #
+  # Only defined if this incomplete date has the year part defined. Otherwise it
+  # returns +nil+.
+  #
+  # see #lowest
+  #
+  def highest
+    return nil unless has_year?
+    max_month = self.month || 12
+    max_day = self.day || IncompleteDate.max_month_days(max_month, self.year)
+    Date.civil(self.year, max_month, max_day)
+  end
+  alias max highest
+  alias last highest
+
+  #--
+  # Conversions
+  #++
+
+  #
+  # Returns an incomplete date which only has the birthday parts (month and day)
+  # taken from this incomplete date. If the needed date parts are not defined,
+  # it returns +nil+.
+  #
+  def to_birthday
+    return nil unless defines_birthday?
+    IncompleteDate.new(:month => month, :day => day)
+  end
+
+  #
+  # Converts this incomplete date to a standard date value. Any missing date
+  # parts can be provided by the hash argument, or else are taken from today's
+  # date, or a reference date that be given as an optional argument with key
+  # +:ref+. In the case of the day missing and not explicitely provided, it
+  # defaults to 1, and not to the reference date.
+  #
+  def to_date(opts = {})
+    ref = opts.fetch(:ref, Date.today)
+    Date.civil(
+      (self.year || opts[:year] || ref.year).to_i,
+      (self.month || opts[:month] || ref.month).to_i,
+      (self.day || opts[:day] || 1).to_i)
+  end
+
+  def to_incomplete_date
+    self
+  end
+
+  #
+  # Converts this incomplete date to its equivalent integer representation
+  # suitable for the database layer.
+  #
+  # The two less significant digits in the decimal representation of the number
+  # are the day of the month. The next two less significant digits represent the
+  # month (numbered from 01 to 12) and the rest of the digits represent the
+  # year. In any case a value of zero means that that particular part of the
+  # date is not known. Finally, the sign of the number represents wether the
+  # date is considered to be uncertain (negative) or certain (positive).
+  #
+  # This representation relies on the fact there was no year 0 in the Gregorian
+  # or Julian calendars (see http://en.wikipedia.org/wiki/Year_zero).
+  #
+  # The integer value zero represents a date that is completely unknown, so it
+  # is somehow equivalent to +nil+ in terms of meaning, and it is questionable
+  # that we allow instances of this class with such a configuration.
+  #
+  def to_i
+    y,m,d = [year,month,day].collect(&:to_i) # converts +nil+ values to zero
+    (circa ? -1 : 1) * (d + m*100 + y*10000)
+  end
+
+  def to_s
+    dt = to_date
+    ord = has_day? ? dt.day.ordinalize : nil
+    result = case defined_parts
+      when [:year, :month, :day] then dt.strftime("%B #{ord}, %Y")
+      when [:year, :month] then dt.strftime("%B %Y")
+      when [:month, :day] then dt.strftime("%B #{ord}")
+      when [:year, :day] then dt.strftime("#{ord} of the month, %Y")
+      when [:year] then dt.strftime("%Y")
+      when [:month] then dt.strftime("%B")
+      when [:day] then "#{ord} of the month"
+      else return "unknown"
+    end
+    circa ? "c. #{result}" : result
+  end
+
+  #
+  # Returns the range of dates that are included or match with this incomplete
+  # date.
+  #
+  # Uses #lowest and #highest to determine the extremes of the range. Returns
+  # +nil+ if the year is not defined.
+  #
+  def to_range
+    has_year? ? (min..max) : nil
+  end
+
+  def to_hash
+    result = {}
+    VALID_DATE_PARTS.each { |part| result[part] = self.send(part) }
+    result
+  end
+
+end

data/lib/incomplete_date/active_record.rb

@@ -0,0 +1,55 @@
+class IncompleteDate
+  module IncompleteDateAttr
+    extend ActiveSupport::Concern
+    #
+    # Defines a new IncompleteDate virtual attribute with name +attr_name+
+    # corresponding to a real integer attribute named +raw_name+ that holds the
+    # raw date value in the database.
+    #
+    class_methods do
+
+      def incomplete_date_attr(attr_name, raw_name)
+        instance_var = "@#{attr_name}"
+
+        # getter
+        define_method "#{attr_name}" do
+          value = instance_variable_get(instance_var)
+          value ||= IncompleteDate.new(read_attribute(raw_name))
+          instance_variable_set(instance_var, value)
+          value
+        end
+
+        # setter
+        define_method "#{attr_name}=" do |value|
+          #begin
+            value = IncompleteDate.new(value)
+            instance_variable_set(instance_var, value)
+            write_attribute(raw_name, value.to_i)
+          #rescue ArgumentError
+          #  errors.add(raw_name)
+          #end
+        end
+      end
+
+      #
+      # Defines several virtual attributes at once for raw real attributes
+      #
+      def incomplete_date_attrs(*names)
+        options = names.extract_options!
+        prefix = options.fetch(:prefix, 'raw')
+        names.each do |name|
+          raw_name = "#{prefix}_#{name}"
+          incomplete_date_attr name, raw_name
+        end
+      end
+
+    end
+
+  end
+end
+
+class ApplicationRecord < ActiveRecord::Base
+  include IncompleteDate::IncompleteDateAttr
+
+  self.abstract_class = true
+end

data/lib/incomplete_date/date.rb

@@ -0,0 +1,22 @@
+class Date
+  def circa
+    false
+  end
+  alias circa? circa
+
+  def to_birthday
+    IncompleteDate.new(:month => month, :day => day)
+  end
+
+  def to_i
+    year*10000 + month*100 + day
+  end
+
+  def to_incomplete_date
+    IncompleteDate.new(self)
+  end
+
+  def matches?(incomplete_date)
+    incomplete_date.include?(self)
+  end
+end

data/lib/incomplete_date/form_builder.rb

@@ -0,0 +1,14 @@
+module ActionView::Helpers
+  class FormBuilder
+    def incomplete_date_select(method, options = {}, html_options = {})
+      date = @object.send(method) || (Date.today - 50.years)
+      date = date.to_incomplete_date
+      options.merge!(:prefix => @object_name, :include_blank => true)
+      # TODO: The +year+ and +circa+ tags don't have the standard +id+ according to its names.
+      @template.text_field_tag("#{@object_name}[#{method}][year]", date.year, :size => 5, :maxlength => 4) + ' ' +
+      @template.select_month(date, options.merge(:field_name => "#{method}][month")) + ' ' +
+      @template.select_day(date, options.merge(:field_name => "#{method}][day")) + ' ' +
+      @template.check_box_tag("#{@object_name}[#{method}][circa]", '1', date.circa) + ' circa'
+    end
+  end
+end

data/lib/incomplete_date/version.rb

@@ -0,0 +1,3 @@
+class IncompleteDate
+  VERSION = '0.1.2'
+end

data/lib/tasks/incomplete_date_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :incomplete_date do
+#   # Task goes here
+# end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: incomplete_date
+version: !ruby/object:Gem::Version
+  version: 0.1.2
+platform: ruby
+authors:
+- gnapse
+- ErCollao
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-05-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.6
+description: This plugin creates a Value Object class that controls the logic of incomplete
+  dates. It also creates a class method incomplete_date_attr to hook onto Active Record
+  objects, so some of the attributes are stored in the database as an integer instead
+  of a date
+email:
+- gnapse@gmail.com
+- daniel@collado-ruiz.es
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- Rakefile
+- lib/incomplete_date.rb
+- lib/incomplete_date/active_record.rb
+- lib/incomplete_date/date.rb
+- lib/incomplete_date/form_builder.rb
+- lib/incomplete_date/version.rb
+- lib/tasks/incomplete_date_tasks.rake
+homepage: https://github.com/gnapse/incomplete_date
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.1
+signing_key: 
+specification_version: 4
+summary: This plugin allows a Rails application to store and manage incomplete date
+  data, which is very common in historical archives, particularly in genealogy.
+test_files: []