rdf-edtf 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ce99d4757012d81466654f14a746edf6b1af5094
+  data.tar.gz: 631e8d3b07ee24555c790af3106464e983a0c623
+SHA512:
+  metadata.gz: d9d9a547ae659cf53239a790e7cf7dbfacc457aa56e16dc0ad4a7cbe8ed82e6ace879946696f18d05768d45a32a35701b99a0baea11dd62eb70d829920566caa
+  data.tar.gz: 39f5ddb16660031cc928335b48c35e8642aab8d785ed7d95cc6cf219eb3ecaf5cdbc28e91f4e7f4a0a9f6bd91b1cf53ce145faf7b2c4ed45c7511565d6fde8a9

data/.gitignore

@@ -0,0 +1,3 @@
+#*#
+*~
+Gemfile.lock

data/CHANGELOG.md

@@ -0,0 +1,10 @@
+v0.1.0
+------
+
+- Initial release
+- Implements BNF grammar as a `Regexp` at `RDF::EDTF::Literal::GRAMMAR`
+- Supports EDTF level 0-2, with minor caveats:
+  - Datetimes without a zone offset will be parsed and reserialized as UTC with
+  `+00:00`. See: https://github.com/inukshuk/edtf-ruby/issues/14
+  - Sets will be reserialized with spaces in their separators. See:
+  https://github.com/inukshuk/edtf-ruby/issues/15

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,45 @@
+RDF::EDTF
+=========
+
+This is an `RDF::Literal` implementation around
+[Extended Date Time Format](http://www.loc.gov/standards/datetime/pre-submission.html).
+
+The underlying EDTF parser and implementation is provided by
+[`edtf-ruby`](https://github.com/inukshuk/edtf-ruby/). The parser supports all
+EDTF features, with caveats noted below.
+
+Usage
+-----
+
+```ruby
+require 'rdf/edtf'
+
+RDF::EDTF::Literal.new('1076?')
+# or
+RDF::Literal('1076?', datatype: RDF::EDTF::Literal::DATATYPE)
+```
+
+Known Issues
+------------
+
+  - Datetimes without a zone offset will be parsed and reserialized as UTC with
+    `+00:00`. See: https://github.com/inukshuk/edtf-ruby/issues/14
+  - Sets will be reserialized with spaces in their separators. See:
+    https://github.com/inukshuk/edtf-ruby/issues/15
+
+Contribution Guidelines
+-----------------------
+
+Please observe the following guidelines:
+
+  - Write tests for your contributions.
+  - Document methods you add using YARD annotations.
+  - Follow the included style guidelines (i.e. run `rubocop` before committing).
+  - Use well formed commit messages.
+
+Do note that in order for us to merge any non-trivial changes (as a rule of thumb, additions larger than about 15 lines of code), we need an explicit public domain dedication on record from you.
+
+License
+-------
+
+This is free and unencumbered public domain software. For more information, see http://unlicense.org/ or the accompanying {file:UNLICENSE} file.

data/UNLICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+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 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.
+
+For more information, please refer to <http://unlicense.org/>

data/lib/rdf/edtf.rb

@@ -0,0 +1,21 @@
+require 'rdf'
+
+module RDF
+  ##
+  # A module implementing Extended Date Time Format (EDTF) handling for
+  # {RDF::Literal}.
+  #
+  # @example requiring RDF::EDTF
+  #   require 'rdf/edtf'
+  #
+  # @example Initializing an EDTF literal with {RDF::Literal}
+  #    RDF::Literal('107x', datatype: RDF::EDTF::Literal::DATATYPE)
+  #
+  # @see RDF::Literal
+  # @see http://www.loc.gov/standards/datetime/pre-submission.html the EDTF
+  #    Specification
+  # @see http://id.loc.gov/datatypes/edtf.html
+  module EDTF
+    autoload :Literal, 'rdf/edtf/literal'
+  end
+end

data/lib/rdf/edtf/literal.rb

@@ -0,0 +1,159 @@
+require 'edtf'
+
+module RDF::EDTF
+  ##
+  # An EDTF Date literal
+  #
+  # @example Initializing an EDTF literal with {RDF::Literal}
+  #    RDF::Literal('107x', datatype: RDF::EDTF::Literal::DATATYPE)
+  #
+  class Literal < RDF::Literal
+    DATATYPE = RDF::URI('http://id.loc.gov/datatypes/edtf/EDTF')
+
+    YEAR = %r(-*[0-9]{4}).freeze
+    ONETHRU12 = %r((01|02|03|04|05|06|07|08|09|10|11|12)).freeze
+    ONETHRU13 = Regexp.union(ONETHRU12, /13/).freeze
+    ONETHRU23 = Regexp.union(ONETHRU13, %r((14|15|16|17|18|19|20|21|22|23)))
+                .freeze
+    ZEROTHRU23 =  Regexp.union(/00/, ONETHRU23).freeze
+    ONETHRU29 = Regexp.union(ONETHRU23, %r((24|25|26|27|28|29))).freeze
+    ONETHRU30 = Regexp.union(ONETHRU29, /30/).freeze
+    ONETHRU31 = Regexp.union(ONETHRU30, /31/).freeze
+
+    ONETHRU59 = Regexp.union(ONETHRU31,
+                             %r((32|33|34|35|36|37|38|39|40|41|42|43|44|45|46|47|48|49|50|51|52|53|54|55|56|57|58|59)))
+                .freeze
+    ZEROTHRU59 =  Regexp.union(/00/, ONETHRU59).freeze
+
+    POSITIVEDIGIT = %r((1|2|3|4|5|6|7|8|9)).freeze
+    DIGIT = Regexp.union(POSITIVEDIGIT, /0/).freeze
+
+    DAY = ONETHRU31
+    MONTH = ONETHRU12
+    MONTHDAY = %r(((01|03|05|07|08|10|12)-#{ONETHRU31})|((04|06|09|11)\-#{ONETHRU30})|(02\-#{ONETHRU29}))
+               .freeze
+    YEARMONTH = %r(#{YEAR}\-#{MONTH}).freeze
+    YEARMONTHDAY = %r(#{YEAR}\-#{MONTHDAY}).freeze
+    HOUR = ZEROTHRU23
+    MINUTE = ZEROTHRU59
+    SECOND = ZEROTHRU59
+
+    POSITIVEYEAR = %r((#{POSITIVEDIGIT}#{DIGIT}#{DIGIT}#{DIGIT})|(#{DIGIT}#{POSITIVEDIGIT}#{DIGIT}#{DIGIT})|(#{DIGIT}#{DIGIT}#{POSITIVEDIGIT}#{DIGIT})|(#{DIGIT}#{DIGIT}#{DIGIT}#{POSITIVEDIGIT})).freeze
+    NEGATIVEYEAR = %r(\-#{POSITIVEYEAR}).freeze
+    YYEAR = %r((#{POSITIVEYEAR}|#{NEGATIVEYEAR}|0000)).freeze
+    DATE = %r((#{YYEAR}|#{YEARMONTH}|#{YEARMONTHDAY})).freeze
+
+    BASETIME = %r((#{HOUR}\:#{MINUTE}\:#{SECOND}|(24\:00\:00))).freeze
+    # Zone offset is specified loosely, due to the issue documented here:
+    #   https://github.com/inukshuk/edtf-ruby/issues/14
+    # The correct specification is:
+    # ZONEOFFSET = %r(Z|((\+|\-))(#{ONETHRU13}((\:#{MINUTE})|$)|14\:00|00\:#{ONETHRU59})).freeze
+    ZONEOFFSET = %r(Z|((\+|\-))(#{ONETHRU13}((\:#{MINUTE})|$)|14\:00|00\:#{MINUTE})).freeze
+    TIME = %r(#{BASETIME}(#{ZONEOFFSET}|$)).freeze
+    DATEANDTIME = %r(#{DATE}T#{TIME}).freeze
+
+    L0INTERVAL = %r(#{DATE}\/#{DATE}).freeze
+
+    LEVEL0EXPRESSION = Regexp.union(/^#{DATE}$/, /^#{DATEANDTIME}/, /^#{L0INTERVAL}$/).freeze
+
+    UASYMBOL = %r((\?|\~|\?\~)).freeze
+    SEASONNUMBER = %r((21|22|23|24)).freeze
+    SEASON = %r(#{YYEAR}\-#{SEASONNUMBER}).freeze
+    DATEORSEASON = %r((#{DATE}|#{SEASON})).freeze
+
+    UNCERTAINORAPPROXDATE = %r(#{DATE}#{UASYMBOL}).freeze
+    YEARWITHONEORTWOUNSPECIFEDDIGITS = %r(#{DIGIT}#{DIGIT}(#{DIGIT}|u)u).freeze
+    MONTHUNSPECIFIED = %r(#{YEAR}\-uu).freeze
+    DAYUNSPECIFIED = %r(#{YEARMONTH}\-uu).freeze
+    DAYANDMONTHUNSPECIFIED = %r(#{YEAR}\-uu\-uu).freeze
+    UNSPECIFIED = Regexp.union(YEARWITHONEORTWOUNSPECIFEDDIGITS,
+                               MONTHUNSPECIFIED,
+                               DAYUNSPECIFIED,
+                               DAYANDMONTHUNSPECIFIED).freeze
+
+    L1START = %r((#{DATEORSEASON}(#{UASYMBOL})*)|unknown).freeze
+    L1END   = %r((#{L1START}|open)).freeze
+
+    L1INTERVAL = %r(#{L1START}\/#{L1END}).freeze
+
+    LONGYEARSIMPLE = %r(y\-?#{POSITIVEDIGIT}#{DIGIT}#{DIGIT}#{DIGIT}#{DIGIT}+).freeze
+
+    LEVEL1EXPRESSION = %r(^(#{UNCERTAINORAPPROXDATE}|#{UNSPECIFIED}|#{L1INTERVAL}|#{LONGYEARSIMPLE}|#{SEASON})$).freeze
+
+    IUABASE = %r((#{YEAR}#{UASYMBOL}\-#{MONTH}(\-\(#{DAY}\)#{UASYMBOL})?|#{YEAR}#{UASYMBOL}\-#{MONTHDAY}#{UASYMBOL}?|#{YEAR}#{UASYMBOL}?\-\(#{MONTH}\)#{UASYMBOL}(\-\(#{DAY}\)#{UASYMBOL})?|#{YEAR}#{UASYMBOL}?\-\(#{MONTH}\)#{UASYMBOL}(\-#{DAY})?|#{YEARMONTH}#{UASYMBOL}\-\(#{DAY}\)#{UASYMBOL}|#{YEARMONTH}#{UASYMBOL}\-#{DAY}|#{YEARMONTH}\-\(#{DAY}\)#{UASYMBOL}|#{YEAR}\-\(#{MONTHDAY}\)#{UASYMBOL}|#{SEASON}#{UASYMBOL})).freeze
+
+    INTERNALUNCERTAINORAPPROXIMATE = %r(#{IUABASE}|\(#{IUABASE}\)#{UASYMBOL}).freeze
+
+    POSITIVEDIGITORU = %r(#{POSITIVEDIGIT}|u).freeze
+    DIGITORU = %r(#{POSITIVEDIGITORU}|0).freeze
+    ONETHRU3 = %r(1|2|3).freeze
+
+    YEARWITHU = %r(u#{DIGITORU}#{DIGITORU}#{DIGITORU}|#{DIGITORU}u#{DIGITORU}#{DIGITORU}|#{DIGITORU}#{DIGITORU}u#{DIGITORU}|#{DIGITORU}#{DIGITORU}#{DIGITORU}u)
+    DAYWITHU = %r(#{ONETHRU31}|u#{DIGITORU}|#{ONETHRU3}u)
+    MONTHWITHU = %r(#{ONETHRU12}|0u|1u|(u#{DIGITORU})).freeze
+
+    # these allow days out of range for the month given (e.g. 2013-02-31)
+    # is this a bug in the EDTF BNF?
+    YEARMONTHWITHU = %r((#{YEAR}|#{YEARWITHU})\-#{MONTHWITHU}|#{YEARWITHU}\-#{MONTH}).freeze
+    MONTHDAYWITHU = %r((#{MONTH}|#{MONTHWITHU})\-#{DAYWITHU}|#{MONTHWITHU}\-#{DAY}).freeze
+    YEARMONTHDAYWITHU = %r((#{YEARWITHU}|#{YEAR})\-#{MONTHDAYWITHU}|#{YEARWITHU}\-#{MONTHDAY}).freeze
+
+    INTERNALUNSPECIFIED = Regexp.union(YEARWITHU, YEARMONTHWITHU, YEARMONTHDAYWITHU).freeze
+
+    DATEWITHINTERNALUNCERTAINTY = Regexp.union(INTERNALUNCERTAINORAPPROXIMATE, INTERNALUNSPECIFIED).freeze
+
+    EARLIER = %r(\.\.#{DATE}).freeze
+    LATER = %r(#{DATE}\.\.).freeze
+    CONSECUTIVES = %r(#{YEARMONTHDAY}\.\.#{YEARMONTHDAY}|#{YEARMONTH}\.\.#{YEARMONTH}|#{YEAR}\.\.#{YEAR}).freeze
+
+    LISTELEMENT = %r(#{DATE}|#{DATEWITHINTERNALUNCERTAINTY}|#{UNCERTAINORAPPROXDATE}|#{UNSPECIFIED}|#{CONSECUTIVES}).freeze
+    # list contents are specified here to allow spaces:
+    #  e.g. [1995, 1996, 1997]
+    # this is not allowed in the specification's grammar
+    # see: https://github.com/inukshuk/edtf-ruby/issues/15
+    LISTCONTENT = %r((#{EARLIER}(\,\s?#{LISTELEMENT})*|(#{EARLIER}\,\s?)?(#{LISTELEMENT}\,\s?)*#{LATER}|#{LISTELEMENT}(\,\s?#{LISTELEMENT})+|#{CONSECUTIVES})).freeze
+
+    CHOICELIST = %r(\[#{LISTCONTENT}\]).freeze
+    INCLUSIVELIST = %r(\{#{LISTCONTENT}\}).freeze
+
+    MASKEDPRECISION = %r(#{DIGIT}#{DIGIT}((#{DIGIT}x)|xx)).freeze
+
+    L2INTERVAL = %r((#{DATEORSEASON}\/#{DATEWITHINTERNALUNCERTAINTY})|(#{DATEWITHINTERNALUNCERTAINTY}\/#{DATEORSEASON})|(#{DATEWITHINTERNALUNCERTAINTY}\/#{DATEWITHINTERNALUNCERTAINTY})).freeze
+
+    POSITIVEINTEGER = %r(#{POSITIVEDIGIT}#{DIGIT}*).freeze
+    LONGYEARSCIENTIFIC = %r(y\-?#{POSITIVEINTEGER}e#{POSITIVEINTEGER}(p#{POSITIVEINTEGER})?).freeze
+
+    QUALIFYINGSTRING = %r(\S+).freeze
+    SEASONQUALIFIED = %r(#{SEASON}\^#{QUALIFYINGSTRING}).freeze
+
+    LEVEL2EXPRESSION = %r(^(#{INTERNALUNCERTAINORAPPROXIMATE}|#{INTERNALUNSPECIFIED}|#{CHOICELIST}|#{INCLUSIVELIST}|#{MASKEDPRECISION}|#{L2INTERVAL}|#{LONGYEARSCIENTIFIC}|#{SEASONQUALIFIED})$).freeze
+
+    ##
+    # Grammar is articulated according to the BNF in the EDTF 1.0 pre-submission
+    # specification, except where noted above.
+    #
+    # @todo investigate the allowance for out-of-range days (e.g. 2013-02-31) in
+    #   `INTERNALUNSPECIFIED`
+    # @todo follow up on zone offset `00:00`; disallow, if appropriate, once
+    #   {https://github.com/inukshuk/edtf-ruby/issues/14} is closed
+    # @todo disallow spaces in LISTCONTENT when
+    #   {https://github.com/inukshuk/edtf-ruby/issues/15} is closed
+    #
+    # @see http://www.loc.gov/standards/datetime/pre-submission.html#bnf
+    GRAMMAR = Regexp.union(LEVEL0EXPRESSION, LEVEL1EXPRESSION, LEVEL2EXPRESSION).freeze
+
+    ##
+    # Initializes an RDF::Literal with EDTF datatype.
+    #
+    # Casts lexical values with the correct datatype to EDTF, if they are
+    # parsable. Otherwise retains their original value as an `#invalid?`
+    # literal.
+    #
+    # @see RDF::Literal
+    def initialize(value, options = {})
+      value = EDTF.parse(value) || value
+      @string = value.edtf if value.respond_to? :edtf
+      super
+    end
+  end
+end

data/lib/rdf/edtf/version.rb

@@ -0,0 +1,5 @@
+module RDF
+  module EDTF
+    VERSION = '0.1.0'
+  end
+end

data/rdf-edtf.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path('../lib', __FILE__)
+require 'rdf/edtf/version'
+
+Gem::Specification.new do |s|
+  s.name        = "rdf-edtf"
+  s.version     = RDF::EDTF::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Tom Johnson']
+  s.homepage    = 'https://github.com/dpla/rdf-edtf'
+  s.email       = 'tom@dp.la'
+  s.summary     = %q{An `RDF::Literal` implementation around Extended Date Time Format.}
+  s.description = %q{Supports serializing and parsing EDTF (all levels) as typed literals in RDF.}
+  s.license     = 'UNLICENSE'
+  s.required_ruby_version     = '>= 2.0.0'
+
+  s.add_dependency('rdf', '~> 1.1')
+  s.add_dependency('edtf', '~>2.1.0')
+
+  s.add_development_dependency('pry')
+  s.add_development_dependency('rspec')
+  s.add_development_dependency('rdf-spec')
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {spec}/*`.split("\n")
+
+  s.extra_rdoc_files = ['UNLICENSE',
+                        'README.md']
+end

data/spec/edtf_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+
+describe RDF::EDTF::Literal do
+  it_behaves_like 'RDF::Literal with datatype',
+                  EDTF.parse!('1076'),
+                  'http://id.loc.gov/datatypes/edtf/EDTF'
+
+  let(:date) { EDTF.parse('1076') }
+  subject { described_class.new(EDTF.parse!('1076')) }
+
+  describe '#initialize' do
+    context 'with string' do
+      let(:date) { '199u' }
+
+      it 'casts object value to EDTF' do
+        expect(described_class.new(date).object).to eq EDTF.parse(date)
+      end
+
+      it 'sets lexical value' do
+        expect(described_class.new(date).value).to eq date
+      end
+
+      context 'as invalid edtf' do
+        let(:date) { 'not a valid edtf date' }
+
+        it 'retains original value as object' do
+          expect(described_class.new(date).object).to eq date
+        end
+
+        it 'gives #to_s as lexical value' do
+          expect(described_class.new(date).value).to eq date.to_s
+        end
+      end
+    end
+
+    it 'gives value if invalid edtf' do
+      date = '19!!'
+      expect(described_class.new(date).object).to eq date
+    end
+  end
+
+  describe '#<=>' do
+    it 'is less than succeding date' do
+      expect(subject).to be < described_class.new(date.succ)
+    end
+
+    it 'is greater than than previous date' do
+      expect(subject).to be > described_class.new(date.prev)
+    end
+
+    it 'is not equal to date of different precision' do
+      day_date = date.clone
+      day_date.precision = :day
+      expect(subject).not_to eq described_class.new(day_date)
+    end
+
+    it 'is not equal to date of different approximation' do
+      approx_date = date.clone
+      approx_date.approximate!
+      expect(subject).not_to eq described_class.new(approx_date)
+    end
+  end
+
+  describe '#value' do
+    it 'gives an edtf string representation' do
+      expect(subject.value).to eq date.edtf
+    end
+  end
+end
+
+describe RDF::Literal do
+  include_examples 'RDF::Literal lookup',
+                   { RDF::EDTF::Literal::DATATYPE => RDF::EDTF::Literal }
+
+  include_examples 'RDF::Literal canonicalization',
+                   RDF::EDTF::Literal::DATATYPE,
+                   {}
+
+  include_examples 'RDF::Literal validation',
+                   RDF::EDTF::Literal::DATATYPE,
+                   # valid value examples taken from:
+                   # http://www.loc.gov/standards/datetime/pre-submission.html
+                   ['2001-02-03',
+                    '2008-12',
+                    '2008',
+                    '-2008',
+                    '0000',
+                    '2001-02-03T09:30:01',
+                    '2004-01-01T10:10:10Z',
+                    '2004-01-01T10:10:10+05:00',
+                    '1964/2008',
+                    '2004-06/2006-08',
+                    '2004-02-01/2005-02-08',
+                    '2004-02-01/2005-02',
+                    '2004-02-01/2005',
+                    '2005/2006-02',
+                    '1984?',
+                    '2004-06?',
+                    '2004-06-11?',
+                    '1984~',
+                    '1984?~',
+                    '199u',
+                    '19uu',
+                    '1999-uu',
+                    '1999-01-uu',
+                    '1999-uu-uu',
+                    '2004-06-01/unknown',
+                    '2004-01-01/open',
+                    '1984~/2004-06',
+                    '1984/2004-06~',
+                    '1984?/2004?~',
+                    'y170000002',
+                    'y-170000002',
+                    '2001-21',
+                    '2001-22',
+                    '2001-23',
+                    '2001-24',
+                    '2004?-06-11',
+                    '2004-06~-11',
+                    '2004-(06)?-11',
+                    '2004-06-(11)~',
+                    '2004-(06)?~',
+                    '2004-(06-11)?',
+                    '2004?-06-(11)~',
+                    '(2004-(06)~)?',
+                    '2004?-(06)?~',
+                    # in addition to being unsupproed by EDTF.parse, these
+                    # appear to be disallowed by EDTF's BNF:
+                    # '(2004)?-06-04~', # unsupported; EDTF.parse returns nil
+                    # '(2011)-06-04~', # unsupported; EDTF.parse returns nil,
+                    '2011-(06-04)~',
+                    '2011-23~',
+                    '156u-12-25',
+                    '15uu-12-25',
+                    '15uu-12-uu',
+                    '1560-uu-25',
+                    '[1667,1668,1670..1672]',
+                    '[..1760-12-03]',
+                    '[1760-12..]',
+                    '[1760-01,1760-02,1760-12..]',
+                    '[1667,1760-12]',
+                    '{1667,1668,1670..1672}',
+                    '{1960,1961-12}',
+                    '196x',
+                    '19xx',
+                    '2004-06-(01)~/2004-06-(20)~',
+                    '2004-06-uu/2004-07-03',
+                    'y17e7',
+                    'y-17e7',
+                    'y17101e4p3', # unsupported; EDTF.parse returns nil
+                    '2001-21^southernHemisphere'],
+                   ['abc', '123', '1921-1', '100000', '1923-13', '192?',
+                    '1924a', '1234-22abc', '1xxx']
+
+  describe 'initializing with datatype' do
+    subject { RDF::Literal(date, datatype: RDF::EDTF::Literal::DATATYPE) }
+
+    context 'with edtf value' do
+      let(:date) { EDTF.parse!('1076') }
+
+      it 'sets date to object' do
+        expect(subject.object).to eql date
+      end
+    end
+
+    context 'with edtf value' do
+      let(:date) { '1076' }
+
+      it 'parses date to edtf' do
+        expect(subject.object).to eq EDTF.parse(date)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'rdf/edtf'
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.color = true
+  config.tty = true
+
+  # Uncomment the following line to get errors and backtrace for deprecation warnings
+  # config.raise_errors_for_deprecations!
+
+  # Use the specified formatter
+  config.formatter = :progress
+end

data/spec/support/shared_examples/literal.rb

@@ -0,0 +1,123 @@
+
+shared_examples 'RDF::Literal with datatype' do |value, datatype_uri|
+  subject { described_class.new(value) }
+
+  it 'has a DATATYPE' do
+    expect(described_class::DATATYPE).to be_a RDF::URI
+  end
+
+  it 'has a GRAMMAR' do
+    expect(described_class::GRAMMAR).to respond_to :=~
+  end
+
+  it { is_expected.to be_literal }
+  it { is_expected.to be_typed }
+  it { is_expected.not_to be_plain }
+  it { is_expected.not_to be_anonymous }
+
+  it 'has correct datatype' do
+    expect(subject.datatype).to eq datatype_uri
+  end
+
+  describe '#==' do
+    it { is_expected.to eq subject }
+    it { expect(subject.object).to eq value }
+    it { is_expected.not_to eq described_class.new('OTHER') }
+    it { is_expected.not_to eq nil }
+  end
+
+  describe '#humanize' do
+    it 'gives a string representation' do
+      expect(subject.humanize).to be_a String
+    end
+  end
+
+  describe '#to_s' do
+    it 'gives a string representation' do
+      expect(subject.to_s).to be_a String
+    end
+  end
+
+  describe '#object' do
+    it 'is the given value' do
+      expect(subject.humanize).to be_a String
+    end
+  end
+end
+
+shared_examples 'RDF::Literal lookup' do |uri_hash|
+  uri_hash.each do |uri, klass|
+    it "finds #{klass} for #{uri}" do
+      expect(RDF::Literal("0", :datatype => uri).class).to eq klass
+    end
+  end
+end
+
+shared_examples 'RDF::Literal canonicalization' do |datatype, pairs|
+  pairs.each do |value, str|
+
+    klass = RDF::Literal.datatyped_class(datatype.to_s)
+
+    it "does not normalize '#{value}' by default" do
+      expect(RDF::Literal.new(value,
+                              datatype: datatype ,
+                              canonicalize: false).to_s)
+        .to eq value
+    end
+
+    it "normalizes double '#{value}' to '#{str}'" do
+      expect(RDF::Literal.new(value,
+                              datatype: datatype,
+                              canonicalize: true).to_s)
+        .to eq str
+    end
+
+    it "humanizes double '#{value}' to '#{str}'" do
+      expect(RDF::Literal.new(value,
+                              datatype: datatype,
+                              canonicalize: false).humanize)
+        .to eq value
+    end
+
+    it "instantiates '#{value}' as #{klass}" do
+      expect(RDF::Literal.new(value,
+                              datatype: datatype,
+                              canonicalize: true))
+        .to be_a(klass)
+    end
+
+    it "causes normalized '#{value}' to be == '#{str}'" do
+      expect(RDF::Literal.new(value,
+                              datatype: datatype,
+                              canonicalize: true))
+        .to eq RDF::Literal.new(str, datatype: datatype, canonicalize: false)
+    end
+  end
+end
+
+shared_examples 'RDF::Literal validation' do |datatype,
+                                              valid_values,
+                                              invalid_values|
+
+  klass = RDF::Literal.datatyped_class(datatype.to_s)
+
+  valid_values.each do |value|
+    it "validates #{klass} '#{value}'" do
+      expect(RDF::Literal.new(value, datatype: datatype)).to be_valid
+    end
+
+    it "does not invalidate #{klass} '#{value}'" do
+      expect(RDF::Literal.new(value, datatype: datatype)).not_to be_invalid
+    end
+  end
+
+  invalid_values.each do |value|
+    it "invalidates #{klass} '#{value}'" do
+      expect(RDF::Literal.new(value, datatype: datatype)).to be_invalid
+    end
+
+    it "does not validate #{klass} '#{value}'" do
+      expect(RDF::Literal.new(value, datatype: datatype)).not_to be_valid
+    end
+  end
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: rdf-edtf
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tom Johnson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: edtf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdf-spec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Supports serializing and parsing EDTF (all levels) as typed literals
+  in RDF.
+email: tom@dp.la
+executables: []
+extensions: []
+extra_rdoc_files:
+- UNLICENSE
+- README.md
+files:
+- ".gitignore"
+- CHANGELOG.md
+- Gemfile
+- README.md
+- UNLICENSE
+- lib/rdf.rb
+- lib/rdf/edtf.rb
+- lib/rdf/edtf/literal.rb
+- lib/rdf/edtf/version.rb
+- rdf-edtf.gemspec
+- spec/edtf_spec.rb
+- spec/spec_helper.rb
+- spec/support/shared_examples/literal.rb
+homepage: https://github.com/dpla/rdf-edtf
+licenses:
+- UNLICENSE
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: An `RDF::Literal` implementation around Extended Date Time Format.
+test_files: []
+has_rdoc: