cultural_dates 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: fed7386233bac77b2728f75eb1368b8a2c6ee29c
+  data.tar.gz: 4001fe2cedd271f848de78fc629677d8703ff79b
+SHA512:
+  metadata.gz: 9706a8615ea4c54a54377ef1f31016cb529ba633423e8a6ba8cbe3aeac8d5fced68c4fff1a88eaa4930a47477a324e48f87f890b5cf3c5198c49c836f2d6ef88
+  data.tar.gz: ada2411bdc35b4efe20a9bf2a1fc2070074e4b745cb86e8da5d84a2f59375e20c4ea0db42ea1a070ae48c5240c1f9627495961f32dd657533de34378abfa6bde

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+TODO.md
+test.rb

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cultural_dates.gemspec
+gemspec
+

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Carnegie Museum of Art
+
+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/README.md

@@ -0,0 +1,86 @@
+# Cultural Dates
+
+Have you ever wished that there was an easy way for computers to make sense of the complications around the vague, imprecise dates cultural historians use?  Perhaps you've gone looking for concepts like [Allen Interval algebra](https://en.wikipedia.org/wiki/Allen%27s_interval_algebra), [XML Schema dates](https://www.w3.org/TR/xmlschema-2/) or [CIDOC-CRM](http://www.cidoc-crm.org), but you've backed away from the edge of that abyss, shaking your head and hoping your sanity remains intact.
+
+`cultural_dates` is a library written from the *other side*, providing sensible defaults and formats for humans and comprehensive schemas and abstractions for computers.  At its core, it's a parser that takes human-readable expressions like "Sometime after the 1880s until at least October 1920" and converts it into concrete dates in various forms, while still trying to maintain the underlying precision and expression.  It also goes the other way, taking the underlying data model and humanizing it into strings that have meaning for humans.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'cultural_dates'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cultural_dates
+
+## Usage
+
+```ruby
+require "cultural_dates"
+
+string = "January 2001"
+date = CulturalDates::CulturalDate.new(string)
+
+puts "String:         #{string}"
+puts "as EDTF:        #{date.to_edtf}"   # <-- 2001-01-uu
+puts "as a Ruby Date: #{date.value}"     # <-- 2001-01-01
+puts "as a String:    #{date.to_s}"      # <-- January 2001
+puts "Earliest Bound: #{date.earliest}"  # <-- 2001-01-01
+puts "Latest Bound:   #{date.latest}"    # <-- 2001-01-31
+
+puts "\n-------------------------------------------------------------------\n\n"
+
+interval_string ="sometime between 1650 and January 2001 until October 15, 2006"
+interval = CulturalDates::CulturalInterval.new(interval_string)
+
+puts "Interval to Parse:"
+puts "      #{interval_string}"
+
+puts "\n Four-point dates as strings:"
+puts "      Begin of the Begin: #{interval.botb}"  # <-- 1650
+puts "      End of the Begin:   #{interval.eotb}"  # <-- January 2001
+puts "      Begin of the End:   #{interval.bote}"  # <-- October 15, 2006
+puts "      End of the End:     #{interval.eote}"  # <-- October 15, 2006
+
+puts "\n and as EDTF:"
+puts "      Begin of the Begin: #{interval.botb.to_edtf}"  # <-- 1650-uu-uu
+puts "      End of the Begin:   #{interval.eotb.to_edtf}"  # <-- 2001-01-uu
+puts "      Begin of the End:   #{interval.bote.to_edtf}"  # <-- 2006-10-15
+puts "      End of the End:     #{interval.eote.to_edtf}"  # <-- 2006-10-15
+
+puts "\nas EDTF Intervals"
+puts "      Beginning: #{interval.begin_interval}"    # <-- 1650-01-01/2001-01-31
+puts "      Ending:    #{interval.end_interval}"      # <-- 2006-10-15/2006-10-15
+puts "      Possible:  #{interval.possible_interval}" # <-- 1650-01-01/2006-10-15
+puts "      Definite:  #{interval.definite_interval}" # <-- 2001-01-31/2006-10-15
+
+puts "\nas Bounds"
+puts "      Earliest Bound:        #{interval.earliest}"          # <-- 1650-01-01
+puts "      Latest Bound:          #{interval.latest}"            # <-- 2006-10-15
+puts "      Earliest Def. Bound:   #{interval.earliest_definite}" # <-- 2001-01-31
+puts "      Latest Definite Bound: #{interval.latest_definite}"   # <-- 2006-10-15
+
+puts "\nBack to String:"
+puts "      #{interval.to_s}" # <-- sometime between 1650 and January 2001 until October 15, 2006
+```
+
+## Implementation Details
+
+Under the hood, it wraps the wonderful [edtf-ruby](https://github.com/inukshuk/edtf-ruby) gem and uses a useful subset of EDTF as a data model.  It uses [parslet](http://kschiess.github.io/parslet/) to handle the string parsing, and the [ruby-rdf](https://github.com/ruby-rdf) suite of tools to generate RDF.
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/arttracks/cultural_dates.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/cultural_dates.gemspec

@@ -0,0 +1,40 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cultural_dates/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cultural_dates"
+  spec.version       = CulturalDates::VERSION
+  spec.authors       = ["David Newbury"]
+  spec.email         = ["david.newbury@gmail.com"]
+  spec.summary       = %q{Parse and validate dates and intervals for cultural heritage applications.}
+  spec.homepage      = "http://www.museumprovenance.org"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against " \
+      "public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'edtf', "~> 3.0.2"
+  spec.add_runtime_dependency 'parslet', "~> 1.7"
+  spec.add_runtime_dependency 'activesupport', '~> 4.2'
+  spec.add_runtime_dependency 'linkeddata'
+
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "m", '~> 1.5.0'
+end

data/lib/cultural_dates.rb

@@ -0,0 +1,11 @@
+require "cultural_dates/version"
+require "cultural_dates/cultural_date"
+require "cultural_dates/cultural_interval"
+require "cultural_dates/date_parser"
+require "cultural_dates/date_string_parser"
+require "cultural_dates/date_transform"
+require 'parslet'
+require 'parslet/convenience'
+
+module CulturalDates
+end

data/lib/cultural_dates/cultural_date.rb

@@ -0,0 +1,156 @@
+module CulturalDates
+
+  class CulturalDate
+    include Comparable
+
+    attr_reader :value
+
+    class << self
+      def parse(val)
+        return CulturalDate.new(val)
+      end
+
+      def edtf(edtf_date)
+        val = CulturalDate.new
+        date = Date.edtf(edtf_date) || EDTF::Unknown.new
+        val.instance_variable_set(:@value, date)
+        val
+      end
+    end
+
+    def values
+      @value.values
+    end
+
+    def <=>(other)
+      case other
+      when CulturalDates::CulturalDate
+        @value <=> other.value
+      when ::Date
+        @value <=> other
+      else
+        @value <=> other
+      end
+    end
+
+    def inspect
+      @value.inspect
+    end
+
+    def initialize(val="")
+      if val
+        begin
+          parse_result = DateParser.new.parse(val)
+          transformed_result = DateTransform.new.apply(parse_result)
+          if transformed_result
+            @value = Date.edtf(transformed_result)
+          end
+        rescue Parslet::ParseFailed => e
+          # puts e
+          @value = nil
+        end
+      else
+        @value = nil
+      end
+    end
+
+    def known?
+      return false if @value.instance_of?(EDTF::Unknown) || @value.nil?
+      true
+    end
+
+    def unknown?
+      return !self.known?
+    end
+
+    def earliest
+      return nil if @value.nil?
+      return @value if @value.instance_of? EDTF::Unknown
+      new_d = EDTF.parse(@value.to_s)
+      if new_d.year < 0
+        if @value.unspecified.year[2]
+          new_d = new_d.advance(:years =>-99)
+        end
+      end
+      new_d
+    end
+
+    def latest
+      return nil if @value.nil?
+      return @value if @value.instance_of? EDTF::Unknown
+      new_d = @value.clone
+      if new_d.unspecified.year[2] 
+        new_d = new_d.advance(:years =>99) if new_d.year >=0
+
+        new_d.year_precision!
+      elsif new_d.unspecified.year[3]
+        new_d = new_d.advance(:years =>9) if new_d.year >=0
+        new_d.year_precision!
+      elsif new_d.unspecified? :day
+       new_d.month_precision!
+       if new_d.unspecified? :month
+         new_d.year_precision!
+       end
+      end
+      new_d = new_d.succ
+      new_d.day_precision!
+      new_d - 1
+    end
+
+    def to_edtf
+      return nil if @value.nil?
+      return @value.edtf
+    end
+
+    def to_s
+     date = @value
+     return nil unless date.is_a? Date
+     str = ""
+     if !date.unspecified? :day
+       str = date.strftime("%B %-d, ")
+       if date.year >=0
+         year_str = date.year.to_s
+         year_str += " CE" if date.year < 1000
+       else
+         year_str = "#{-date.year} BCE"
+       end
+       str += year_str
+
+     elsif !date.unspecified? :month
+       str = date.strftime("%B ")
+       if date.year >=1
+         year_str = date.year.to_s
+         year_str += " CE" if date.year < 1000
+       elsif year == 0
+         year_str = "1 BCE"
+       else
+         year_str = "#{-year} BCE"
+       end
+       str += year_str
+
+     elsif !date.unspecified? :year
+       if date.year >=1
+         str = date.year.to_s
+         str += " CE" if date.year < 1000
+       else
+         str = "#{-date.year+1} BCE"
+       end
+      elsif !date.unspecified.year[2]
+        str = "the #{date.year}s"
+      else
+        bce = false
+        year = (date.year/100+1)
+        if year <= 0
+          year = -(year-2)
+          bce = true
+        end  
+        str = "the #{year.ordinalize} century"
+        str += " CE" if year >= 1 && year < 10 && !bce
+        str += " BCE" if bce
+        str
+      end
+      str += "?" unless date.certain?
+      str
+    end
+  end
+end

data/lib/cultural_dates/cultural_interval.rb

@@ -0,0 +1,164 @@
+module CulturalDates
+
+  class CulturalInterval
+    include Comparable
+ 
+
+    class << self
+      def parse(val, debug=false)
+        return CulturalInterval.new(val, debug)
+      end
+    end
+
+    def initialize(val="", debug=false)
+      if val
+        begin
+          parse_result = DateStringParser.new.parse_with_debug(val, reporter: Parslet::ErrorReporter::Deepest.new)
+          puts "parse_result: #{parse_result.inspect}" if debug
+          transformed_result = DateTransform.new.apply(parse_result)
+          puts "transformed_result: #{transformed_result.inspect}" if debug
+          if transformed_result
+            @value = transformed_result
+          end
+        rescue Parslet::ParseFailed => e
+          @value = nil
+        end
+      else
+        @value = nil
+      end
+      # puts "@value: #{@value}"
+    end
+
+    def botb
+      @botb ||= CulturalDate.edtf @value[:botb]
+    end
+
+    def bote
+      @bote ||= CulturalDate.edtf @value[:bote]
+    end
+
+    def eotb
+      @eotb ||= CulturalDate.edtf @value[:eotb]
+    end
+
+    def eote
+      @eote ||= CulturalDate.edtf @value[:eote]
+    end
+
+ 
+    def earliest
+      return nil if botb.unknown?
+      botb.earliest
+   end
+
+    def latest
+      return nil if eote.unknown?
+      eote.latest
+   end
+
+    def earliest_definite
+      return nil if eotb.unknown? && bote.unknown?
+      return latest_definite if eotb.unknown?
+      return eotb.earliest if eotb == bote
+      eotb.latest
+   end
+
+    def latest_definite
+      return nil if bote.unknown? && eotb.unknown?
+      return earliest_definite if bote.unknown?
+      return bote.latest if eotb == bote
+      bote.earliest
+   end
+
+    def begin_interval
+      from = earliest || :unknown
+      to = earliest_definite || :unknown
+      EDTF::Interval.new(from, to)
+    end
+    alias :beginning_interval :begin_interval
+    alias :beginning :begin_interval
+
+
+    def end_interval
+      from = latest_definite || :unknown
+      to = latest || :unknown
+      EDTF::Interval.new(from, to)
+    end
+    alias :ending_interval :end_interval
+    alias :ending :end_interval
+
+    def possible_interval
+      from = earliest || :unknown
+      to = latest || :unknown
+      EDTF::Interval.new(from, to)
+    end
+    
+
+
+    def definite_interval
+      from = earliest_definite || :unknown
+      to = latest_definite || :unknown
+      EDTF::Interval.new(from, to)
+    end
+    
+
+    def to_edtf 
+      possible_interval.edtf
+    end
+    
+    def to_definite_edtf 
+      definite_interval.edtf
+    end
+
+    # Generate a textual representation of the timeframe of the period.
+    # @return [String]
+    def to_s
+
+      # Handle special "throughout" case
+      if (eotb.known? && bote.known?) && !(botb.known? || eote.known?) && eotb == bote
+        return "throughout #{eotb}"
+      end
+
+      # Handle special "throughout, until" case
+      if (eotb.known? && bote.known? && eote.known?) && !botb.known? && eotb == bote
+        return "throughout #{eotb} until no later than #{eote}"
+      end
+
+      # Handle special "on" case
+      if (botb.known? && eotb.known? && bote.known? && eote.known?) && 
+         (botb == eotb && bote == eote && botb == eote) &&
+         botb.earliest == botb.latest
+         return "on #{botb}"
+      end
+
+      first_string = ""
+      if botb.known? && eotb.known?
+        if botb == eotb
+          first_string = botb
+        else
+          first_string = "sometime between #{botb} and #{eotb}"
+        end
+      elsif botb.known?
+        first_string = "after #{botb}"
+      elsif eotb.known?
+        first_string = "by #{eotb}"
+      end
+
+      second_string = nil
+      if bote.known? && eote.known?
+        if bote == eote
+          second_string = bote
+        else
+          second_string = "sometime between #{bote} and #{eote}"
+        end
+      elsif bote.known?
+        second_string = "at least #{bote}"
+      elsif eote.known?
+        second_string = "no later than #{eote}"
+      end
+
+      [first_string,second_string].compact.join(" until ").strip
+
+    end
+  end
+end

data/lib/cultural_dates/date_parser.rb

@@ -0,0 +1,44 @@
+require 'parslet'
+
+require_relative "date_word_helpers"
+
+module CulturalDates
+
+  #
+  # * :era
+  # * :century
+  # * :decade
+  # * :year
+  # * :month
+  # * :day
+  # * :timezone
+  #
+  class DateParser  < Parslet::Parser
+    include DateWordHelpers
+    include Parslet
+
+    
+    rule(:century) { (the.maybe >> century_number >> century_word) >> era.maybe >> certainty}
+    rule(:decade)  { (the.maybe >> decade_year) >> era.maybe >> certainty}
+    rule(:year)    { year_year >> era.maybe >> certainty}
+    rule(:month)   { month_name  >> year_year >> era.maybe >> certainty}
+    rule(:day)     { month_name >> day_number >> (comma | space) >> year_year >> era.maybe >> certainty}
+    rule(:euroday) { day_number >> space >> month_name >> year_year >> era.maybe >> certainty}
+    rule(:numdate) { month_number >> str("/") >> day_number >> str("/") >> year_year >> era.maybe >> certainty }
+    rule(:isodate) { year_year >> str("-") >> month_number >> str("-") >> day_number >> timezone.maybe >> era.maybe >> certainty }
+
+    rule(:date) {
+       (century | 
+        decade  |
+        day     |
+        year    |
+        month   |
+        euroday |
+        numdate |
+        isodate).as(:date)
+    }
+
+    root(:date)
+
+  end
+end

data/lib/cultural_dates/date_string_parser.rb

@@ -0,0 +1,50 @@
+require 'parslet'
+
+require_relative "date_parser"
+
+module CulturalDates
+  class DateStringParser < Parslet::Parser
+    include DateWordHelpers
+
+    date = DateParser.new
+
+
+    # KEYWORDS   
+    rule(:sometime)             { str("sometime") >> space}   
+    rule(:no_date)              { (str("no date").as(:nodate) | str("").as(:nodate))}
+    rule(:begin_end_separator)  { space.maybe >> str("until")      >> space }
+    rule(:after)                { sometime.maybe >> str("after")   >> space }
+    rule(:by)                   { str("by")                        >> space }
+    rule(:at_least)             { str("at least")                  >> space }
+    rule(:before)               { str("no later than")             >> space }
+    rule(:between)              { sometime.maybe >> str("between") >> space }
+    rule(:in_kw)                { str("throughout")                >> space }
+    rule(:on_kw)                { str("on")                        >> space }
+    rule(:and_kw)               { space? >> str("and")             >> space?}
+
+    # CLAUSES
+    rule(:begin_date)    { after    >> date.as(:botb) | 
+                           by       >> date.as(:eotb) }
+    rule(:end_date)      { at_least >> date.as(:bote) | 
+                           before   >> date.as(:eote) }
+    rule(:in_date)       { in_kw    >> date.as(:in) }
+    rule(:on_date)       { on_kw    >> date.as(:on) }
+    rule(:between_begin) { between  >> date.as(:botb) >> and_kw >> date.as(:eotb)}
+    rule(:between_end)   { between  >> date.as(:bote) >> and_kw >> date.as(:eote)}
+   
+    rule (:start_clause) {(in_date | between_begin | begin_date | date.as(:begin))}
+    rule (:end_clause)   {(between_end | end_date | date.as(:end))}
+   
+    # SENTENCE GRAMMARS
+    rule(:one_date)  {
+                       start_clause >> begin_end_separator >> end_clause |
+                       start_clause >> begin_end_separator.absent? |
+                       begin_end_separator >> end_clause
+                     }
+    
+
+    rule(:date_string) { one_date | on_date | no_date }
+    root(:date_string)
+
+  end
+end

data/lib/cultural_dates/date_transform.rb

@@ -0,0 +1,177 @@
+require "edtf"
+require 'active_support/core_ext/integer/inflections'
+
+
+module CulturalDates
+  class DateTransform < Parslet::Transform
+
+    rule(:certainty_value => simple(:x)) { x != "?"}
+ 
+    rule(begin: subtree(:x)) {{botb: x, eotb: x}}
+    rule(begin: subtree(:x), bote: subtree(:y)) {{botb: x, eotb: x, bote: y}}
+    rule(begin: subtree(:x), eote: subtree(:z)) {{botb: x, eotb: x, eote: z}}
+    rule(begin: subtree(:x), bote: subtree(:y), eote: subtree(:z)) {{botb: x, eotb: x, bote: y, eote: z}}
+
+    rule(end: subtree(:x)) { {bote: x, eote: x}}
+    rule(end: subtree(:x), botb: subtree(:y)) { {bote: x, eote: x, botb: y}}
+    rule(end: subtree(:x), eotb: subtree(:z)) { {bote: x, eote: x, eotb: z}}
+    rule(end: subtree(:x), botb: subtree(:y), eotb: subtree(:z)) { {bote: x, eote: x, botb: y,  eotb: z}}
+
+
+    rule(:in => subtree(:x)) { {eotb: x, bote: x}}
+    rule(:in => subtree(:x), eote: subtree(:y)) { {eotb: x, bote: x, eote: y}}
+
+    # This should never happen.
+    # rule(:in => subtree(:x), botb: subtree(:y)) { {eotb: x, bote: x, botb: y}}
+
+    # TODO: This should check for day precision, but currently does not.
+    rule(:on => subtree(:x)) { {eotb: x, bote: x, botb: x, eote: x}}
+    rule(:nodate => simple(:x)) {nil}
+
+    rule(:date => subtree(:x)) do |dictionary|
+      obj = regularize(dictionary[:x])
+      date = to_edtf_date(obj)
+      date.edtf
+    end
+
+  class << self
+
+     def to_edtf_date(d)
+      
+      if d[:day]
+        date = Date.new(d[:year],d[:month],d[:day])
+        date.day_precision!
+      elsif(d[:month])
+        date = Date.new(d[:year],d[:month])
+        date.unspecified! :day
+      elsif(d[:year])
+        if (d[:era] == "BCE")
+          date = Date.new(d[:year]+1)
+        else
+          date = Date.new(d[:year])
+        end
+        date.unspecified! :month
+        date.unspecified! :day
+      elsif(d[:decade])
+        date = Date.new(d[:decade])
+        date.unspecified.year[3]= true 
+        date.unspecified! :month
+        date.unspecified! :day
+      elsif(d[:century])
+        c = d[:century] * 100
+        c -=99 if (d[:era] == "BCE")
+        date = Date.new(c)         
+        date.unspecified.year[3]= true 
+        date.unspecified.year[2]= true
+        date.unspecified! :month
+        date.unspecified! :day 
+      end  
+      date.uncertain! unless  d[:certainty]      
+      date
+     end
+
+
+    def regularize(date_obj)
+      date_obj = regularize_era(date_obj)
+      date_obj = regularize_century(date_obj)
+      date_obj = regularize_decade(date_obj)
+      date_obj = regularize_year(date_obj)
+      date_obj = regularize_month(date_obj)
+      date_obj = regularize_day(date_obj)
+      date_obj
+    end
+
+
+      private
+
+      def regularize_era(date_obj)
+        if date_obj[:era].to_s[0] && date_obj[:era].to_s[0].downcase == "b" 
+          date_obj[:era] = "BCE"
+        else
+          date_obj[:era] = "CE"
+        end
+        date_obj
+      end
+
+      def regularize_century(date_obj)
+        return date_obj if date_obj[:century].is_a? Integer
+        if date_obj[:century]
+          date_obj[:century] = date_obj[:century].to_i - 1
+          if date_obj[:era] == "BCE" 
+            date_obj[:century] = -date_obj[:century]
+          end
+        else
+          date_obj[:century] = nil
+        end
+        date_obj
+      end
+
+      def regularize_decade(date_obj)
+        return date_obj if date_obj[:decade].is_a? Integer
+
+        if date_obj[:decade]
+          date_obj[:decade] = date_obj[:decade].to_i
+          if date_obj[:era] == "BCE" 
+            date_obj[:decade] = -date_obj[:decade]
+          end
+        else
+          date_obj[:decade] = nil
+        end
+        date_obj
+      end
+
+      def regularize_year(date_obj)
+        return date_obj if date_obj[:year].is_a? Integer
+
+        if date_obj[:year]
+          date_obj[:year] = date_obj[:year].to_i
+          if date_obj[:era] == "BCE" 
+            date_obj[:year] = -date_obj[:year]
+          end
+        else
+          date_obj[:year] = nil
+        end
+        date_obj
+      end
+
+      def regularize_day(date_obj)
+        return date_obj if date_obj[:day].is_a? Integer
+        if date_obj[:day]
+          date_obj[:day] = date_obj[:day].to_i
+        else
+          date_obj[:day] = nil
+        end
+        date_obj
+      end
+
+      def regularize_month(date_obj)
+        return date_obj if date_obj[:month].is_a? Integer
+
+        if date_obj[:month]
+          month = date_obj[:month].to_i
+          if month == 0
+            month = case date_obj[:month].to_s[0...3].downcase
+              when "jan" then 1
+              when "feb" then 2 
+              when "mar" then 3
+              when "apr" then 4
+              when "may" then 5
+              when "jun" then 6
+              when "jul" then 7
+              when "aug" then 8
+              when "sep" then 9
+              when "oct" then 10
+              when "nov" then 11
+              when "dec" then 12             
+            end
+          end
+          date_obj[:month] = month
+        else
+          date_obj[:month] = nil
+        end
+
+        return date_obj 
+      end
+    end
+  end
+end

data/lib/cultural_dates/date_word_helpers.rb

@@ -0,0 +1,34 @@
+require "parslet"
+
+module CulturalDates
+  module DateWordHelpers 
+    include Parslet
+
+    rule(:space)          { match('\s').repeat(1) }
+    rule(:space?)         { space.maybe }
+    rule(:comma)          { str(",") >> space }
+    rule(:period)         { str(".") >> space }
+    rule(:certainty)      { (str("?") | str("")).as(:certainty_value).as(:certainty)}
+
+    rule(:ordinal_suffix) { str("th") | str("st") | str("nd") | str("rd")}
+    rule(:era)            { (str("CE") | str("ce") | str("BCE") | str("bce") | str("AD")  | str("ad") | str("BC") | str('bc') | str("")).as(:era)}
+    rule(:the)            { match['tT'] >> str("he") >> space}
+    rule(:century_word)   { match['cC'] >> str("entury")  >> space?}
+    rule(:century_number) { match['0-9'].repeat(1,2).as(:century) >> ordinal_suffix.maybe >> space}
+    rule(:decade_year)    { (match["0-9"].repeat(1,3) >> str("0")).as(:decade) >> str("s") >> space?}
+    rule(:year_year)      { (match["0-9"].repeat(1,4).as(:year)  >> space?)}
+    
+    rule(:month_names_tc) {str("January") | str("February") | str("March") | str("April") | str("May") | str("June") | str("July") | str("August") | str("September") | str("October") | str("November") | str("December") }
+    rule(:month_names_lc) {str("january") | str("february") | str("march") | str("april") | str("may") | str("june") | str("july") | str("august") | str("september") | str("october") | str("november") | str("december") }
+    rule(:month_abb_tc)   {str("Jan") | str("Feb") | str("Mar") | str("Apr") | str("Jun") | str("Jul") | str("Aug") | str("Sept")| str("Sep") | str("Oct") | str("Nov") | str("Dec") }
+    rule(:month_abb_lc)   {str("jan") | str("feb") | str("mar") | str("apr") | str("jun") | str("jul") | str("aug") | str("sept")| str("sep") | str("oct") | str("nov") | str("dec") }
+    rule(:month_spelling) {str("febuary")}
+    rule(:month_name)     {(month_names_tc| month_names_lc | month_abb_tc | month_abb_lc | month_spelling).as(:month) >> (period | comma | space | str("., "))}
+
+    rule(:day_number)     { match['0-9'].repeat(1,2).as(:day) >> ordinal_suffix.maybe}
+    rule(:month_number)   { (match['0-1'].maybe >> match["0-9"]).as(:month)}
+
+    rule(:timezone)       {str("Z").as(:timezone) | (match["-+"] >> match["01"] >> match["0-9"] >> str(":") >> match["0-9"].repeat(2,2)).as(:timezone)}
+    
+  end
+end

data/lib/cultural_dates/version.rb

@@ -0,0 +1,3 @@
+module CulturalDates
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,172 @@
+--- !ruby/object:Gem::Specification
+name: cultural_dates
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- David Newbury
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-01-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: edtf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.0.2
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: linkeddata
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.13'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: m
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.5.0
+description: 
+email:
+- david.newbury@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- cultural_dates.gemspec
+- lib/cultural_dates.rb
+- lib/cultural_dates/cultural_date.rb
+- lib/cultural_dates/cultural_interval.rb
+- lib/cultural_dates/date_parser.rb
+- lib/cultural_dates/date_string_parser.rb
+- lib/cultural_dates/date_transform.rb
+- lib/cultural_dates/date_word_helpers.rb
+- lib/cultural_dates/version.rb
+homepage: http://www.museumprovenance.org
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+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: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Parse and validate dates and intervals for cultural heritage applications.
+test_files: []
+has_rdoc: