solis 0.103.0 → 0.104.0

data/lib/solis/query/run.rb

@@ -207,6 +207,9 @@ class Solis::Query::Runner
       ISO8601::TimeInterval.parse(literal.value).to_s
     when "http://www.w3.org/1999/02/22-rdf-syntax-ns#JSON"
       JSON.parse(literal.value) rescue literal.value
+    when /datatypes\/edtf/, /edtf$/i
+      # Return EDTF string representation
+      literal.value.to_s
     else
       # Handle language-tagged strings
       if literal.respond_to?(:language) && literal.language

data/lib/solis/rdf_edtf_literal.rb

@@ -0,0 +1,143 @@
+require 'rdf'
+require 'edtf'
+
+module RDF
+  class Literal
+    ##
+    # Extended Date/Time Format (EDTF) literal for RDF 3.x
+    #
+    # This class provides RDF literal support for EDTF dates, implementing
+    # the Library of Congress Extended Date/Time Format specification.
+    #
+    # @see https://www.loc.gov/standards/datetime/
+    # @see https://github.com/inukshuk/edtf-ruby
+    class EDTF < Literal
+      DATATYPE = RDF::URI('http://id.loc.gov/datatypes/edtf')
+
+      # Grammar pattern for EDTF validation
+      # Supports Level 0, 1, and 2 expressions
+      # This is a simplified pattern - the edtf gem handles full validation
+      GRAMMAR = /^[\d\-\/\?\~\.\[\]\{\}XuU\^%\,\+\:\s]+$/
+
+      ##
+      # @param  [Object] value
+      # @param  [Hash{Symbol => Object}] options
+      # @option options [String] :lexical (nil)
+      def initialize(value, datatype: nil, lexical: nil, **options)
+        @edtf_value = parse_edtf(value)
+
+        # Use EDTF string representation as the lexical form
+        lexical_value = @edtf_value.respond_to?(:edtf) ? @edtf_value.edtf : value.to_s
+
+        super(lexical_value, datatype: DATATYPE, lexical: lexical, **options)
+      end
+
+      ##
+      # Returns the EDTF object value
+      #
+      # @return [EDTF::Date, EDTF::Interval, EDTF::Season, EDTF::Set, etc.]
+      def object
+        @edtf_value
+      end
+
+      alias_method :to_edtf, :object
+
+      ##
+      # Validates the EDTF literal
+      #
+      # @return [Boolean]
+      def valid?
+        return false if @edtf_value.nil?
+        # EDTF values are valid if they were successfully parsed
+        true
+      rescue
+        false
+      end
+
+      ##
+      # Returns the canonical string representation
+      #
+      # @return [String]
+      def canonicalize
+        return self if @edtf_value.nil?
+        self.class.new(@edtf_value.edtf)
+      end
+
+      ##
+      # Converts to a human-readable string
+      #
+      # @return [String]
+      def humanize
+        return to_s unless @edtf_value.respond_to?(:humanize)
+        @edtf_value.humanize
+      rescue
+        to_s
+      end
+
+      ##
+      # Returns true if this is an uncertain date
+      #
+      # @return [Boolean]
+      def uncertain?
+        @edtf_value.respond_to?(:uncertain?) && @edtf_value.uncertain?
+      end
+
+      ##
+      # Returns true if this is an approximate date
+      #
+      # @return [Boolean]
+      def approximate?
+        @edtf_value.respond_to?(:approximate?) && @edtf_value.approximate?
+      end
+
+      ##
+      # Returns true if this is an interval
+      #
+      # @return [Boolean]
+      def interval?
+        @edtf_value.is_a?(::EDTF::Interval)
+      end
+
+      ##
+      # Returns true if this is a season
+      #
+      # @return [Boolean]
+      def season?
+        @edtf_value.is_a?(::EDTF::Season)
+      end
+
+      ##
+      # Returns true if this is a set
+      #
+      # @return [Boolean]
+      def set?
+        @edtf_value.is_a?(::EDTF::Set)
+      end
+
+      private
+
+      ##
+      # Parses input value to EDTF object
+      #
+      # @param  [Object] value
+      # @return [EDTF::Date, EDTF::Interval, EDTF::Season, EDTF::Set, etc.]
+      def parse_edtf(value)
+        case value
+        when ::EDTF::Interval, ::EDTF::Season, ::EDTF::Set, ::EDTF::Epoch
+          value
+        when ::Date, ::DateTime, ::Time
+          # For Ruby Date/DateTime/Time, try to parse as EDTF
+          ::Date.edtf(value.to_s) || value
+        when String
+          # Parse EDTF string
+          ::Date.edtf(value) || ::EDTF.parse(value)
+        else
+          ::EDTF.parse(value.to_s)
+        end
+      rescue StandardError => e
+        Solis::LOGGER.warn("Failed to parse EDTF value '#{value}': #{e.message}") if defined?(Solis::LOGGER)
+        nil
+      end
+    end
+  end
+end

data/lib/solis/shape/data_types.rb

@@ -277,4 +277,91 @@ Graphiti::Types[:array_of_temporal_coverages] = {
   write: Dry::Types["strict.array"].of(Graphiti::Types[:temporal_coverage][:write]),
   kind: "array",
   description: "contains a list of temporal coverage"
+}
+
+uri_definition = Dry::Types['strict.string']
+read_uri_type = uri_definition.constructor do |i|
+  if i.is_a?(RDF::URI)
+    i.to_s
+  elsif i.is_a?(String)
+    i
+  else
+    i.to_s
+  end
+rescue StandardError => e
+  Solis::LOGGER.error(e.message)
+  raise Solis::Error::InvalidDatatypeError, e.message
+end
+
+write_uri_type = uri_definition.constructor do |i|
+  i.to_s
+rescue StandardError => e
+  Solis::LOGGER.error(e.message)
+  raise Solis::Error::InvalidDatatypeError, e.message
+end
+
+Graphiti::Types[:anyuri] = {
+  canonical_name: :anyuri,
+  params: read_uri_type,
+  read: read_uri_type,
+  write: write_uri_type,
+  kind: "scalar",
+  description: "contains a URI"
+}
+
+Graphiti::Types[:array_of_anyuris] = {
+  canonical_name: :anyuri,
+  params: Dry::Types["strict.array"].of(Graphiti::Types[:anyuri][:params]),
+  read: Dry::Types["strict.array"].of(Graphiti::Types[:anyuri][:read]),
+  write: Dry::Types["strict.array"].of(Graphiti::Types[:anyuri][:write]),
+  kind: "array",
+  description: "contains a list of URIs"
+}
+
+edtf_definition = Dry::Types['strict.string']
+read_edtf_type = edtf_definition.constructor do |i|
+  if i.respond_to?(:edtf)
+    # EDTF object - convert to string representation
+    i.edtf
+  elsif i.is_a?(RDF::Literal::EDTF)
+    # RDF EDTF Literal - get the lexical value
+    i.value
+  elsif i.is_a?(String)
+    # Validate and return as-is
+    parsed = Date.edtf(i)
+    parsed ? parsed.edtf : i
+  else
+    i.to_s
+  end
+rescue StandardError => e
+  Solis::LOGGER.error("EDTF read error: #{e.message}")
+  raise Solis::Error::InvalidDatatypeError, e.message
+end
+
+write_edtf_type = edtf_definition.constructor do |i|
+  # Validate by parsing
+  parsed = Date.edtf(i.to_s)
+  raise "Invalid EDTF format" unless parsed && parsed.valid?
+  parsed.edtf
+rescue StandardError => e
+  Solis::LOGGER.error("EDTF write error: #{e.message}")
+  raise Solis::Error::InvalidDatatypeError, "Invalid EDTF format: #{e.message}"
+end
+
+Graphiti::Types[:edtf] = {
+  canonical_name: :edtf,
+  params: read_edtf_type,
+  read: read_edtf_type,
+  write: write_edtf_type,
+  kind: "scalar",
+  description: "Extended Date/Time Format (EDTF) - supports uncertain, approximate, and interval dates"
+}
+
+Graphiti::Types[:array_of_edtfs] = {
+  canonical_name: :edtf,
+  params: Dry::Types["strict.array"].of(Graphiti::Types[:edtf][:params]),
+  read: Dry::Types["strict.array"].of(Graphiti::Types[:edtf][:read]),
+  write: Dry::Types["strict.array"].of(Graphiti::Types[:edtf][:write]),
+  kind: "array",
+  description: "contains a list of EDTF dates"
 }

data/lib/solis/shape/reader/sheet.rb

@@ -511,6 +511,8 @@ hide empty members
                   { "type" => "string", "format" => "date-time" }
                 when /anyURI$/
                   { "type" => "string", "format" => "uri" }
+                when /datatypes\/edtf/, /edtf$/i
+                  { "type" => "string", "format" => "edtf" }
                 else
                   { "type" => "string" }
                 end

data/lib/solis/shape.rb

@@ -24,7 +24,7 @@ module Solis
           if datatype =~ /^http:\/\/www.w3.org\/2001\/XMLSchema#/
             case datatype
             when /^http:\/\/www.w3.org\/2001\/XMLSchema#anyURI/
-              :string
+              :anyuri
             when /http:\/\/www.w3.org\/2001\/XMLSchema#duration/
               :duration
             when /http:\/\/www.w3.org\/2001\/XMLSchema#integer/
@@ -72,6 +72,9 @@ module Solis
             # normalize ex."https://data.q.odis.be/person#Name" to Name
             #node.value.split('/').last.gsub(/Shape$/, '').split('#').last.to_sym
             #node.value.split('/').last.gsub(/Shape$/, '').gsub('#','').camelize.to_sym
+          elsif datatype =~ /datatypes\/edtf/ || datatype =~ /edtf$/i
+            # Library of Congress EDTF datatype
+            :edtf
           elsif datatype =~ /^http:\/\/www.w3.org\/1999\/02\/22-rdf-syntax-ns/
             case datatype
             when /http:\/\/www.w3.org\/1999\/02\/22-rdf-syntax-ns#langString/

data/lib/solis/version.rb

@@ -1,3 +1,3 @@
 module Solis
-  VERSION = "0.103.0"
+  VERSION = "0.104.0"
 end

data/lib/solis.rb

@@ -6,6 +6,7 @@ require 'logger'
 require "solis/version"
 require 'solis/config_file'
 require "solis/error"
+require 'solis/rdf_edtf_literal'
 require 'solis/graph'
 require 'solis/shape'
 

data/solis.gemspec

@@ -43,7 +43,7 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency 'csv', '~> 3.2'
   spec.add_runtime_dependency 'mutex_m', '~> 0.1'
   spec.add_runtime_dependency 'ostruct', '~> 0.5'
-  #  spec.add_runtime_dependency 'rdf-edtf', '~> 1.1.2'
+  spec.add_runtime_dependency 'edtf', '~> 3.0'
 
   spec.add_development_dependency 'rake', '~> 13.0'
   spec.add_development_dependency  'minitest', '~> 5.19'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solis
 version: !ruby/object:Gem::Version
-  version: 0.103.0
+  version: 0.104.0
 platform: ruby
 authors:
 - Mehmet Celik
@@ -233,6 +233,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: edtf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -296,10 +310,12 @@ files:
 - lib/solis/model.rb
 - lib/solis/model.rb.ok
 - lib/solis/options.rb
+- lib/solis/overlay_fs.rb
 - lib/solis/query.rb
 - lib/solis/query/construct.rb
 - lib/solis/query/filter.rb
 - lib/solis/query/run.rb
+- lib/solis/rdf_edtf_literal.rb
 - lib/solis/resource.rb
 - lib/solis/shape.rb
 - lib/solis/shape/data_types.rb