rdf-n3 3.1.1 → 3.1.2

data/lib/rdf/n3/algebra/time/minute.rb

@@ -0,0 +1,35 @@
+module RDF::N3::Algebra::Time
+  ##
+  # For a date-time, its time:minute is the minutes component.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-minutes-from-dateTime
+  class Minute < RDF::N3::Algebra::ResourceOperator
+    NAME = :timeMinute
+    URI = RDF::N3::Time.minute
+
+    ##
+    # The time:minute operator takes string or dateTime and extracts the minute component.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      case position
+      when :subject
+        return nil unless resource.literal?
+        resource = resource.as_datetime
+        RDF::Literal(resource.object.strftime("%M").to_i)
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+
+    ##
+    # There is no minute unless it was specified in the lexical form
+    def valid?(subject, object)
+      subject.value.match?(%r(^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}))
+    end
+  end
+end

data/lib/rdf/n3/algebra/time/month.rb

@@ -0,0 +1,35 @@
+module RDF::N3::Algebra::Time
+  ##
+  # For a date-time, its time:month is the two-digit month.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-month-from-dateTime
+  class Month < RDF::N3::Algebra::ResourceOperator
+    NAME = :timeMonth
+    URI = RDF::N3::Time.month
+
+    ##
+    # The time:month operator takes string or dateTime and extracts the month component.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      case position
+      when :subject
+        return nil unless resource.literal?
+        resource = resource.as_datetime
+        RDF::Literal(resource.object.strftime("%m").to_i)
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+
+    ##
+    # There is no month unless it was specified in the lexical form
+    def valid?(subject, object)
+      subject.value.match?(%r(^\d{4}-\d{2}))
+    end
+  end
+end

data/lib/rdf/n3/algebra/time/second.rb

@@ -0,0 +1,35 @@
+module RDF::N3::Algebra::Time
+  ##
+  # For a date-time, its time:second is the seconds component.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-seconds-from-dateTime
+  class Second < RDF::N3::Algebra::ResourceOperator
+    NAME = :timeSecond
+    URI = RDF::N3::Time.second
+
+    ##
+    # The time:second operator takes string or dateTime and extracts the seconds component.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      case position
+      when :subject
+        return nil unless resource.literal?
+        resource = resource.as_datetime
+        RDF::Literal(resource.object.strftime("%S").to_i)
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+
+    ##
+    # There is no second unless it was specified in the lexical form
+    def valid?(subject, object)
+      subject.value.match?(%r(^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}))
+    end
+  end
+end

data/lib/rdf/n3/algebra/time/timezone.rb

@@ -0,0 +1,36 @@
+module RDF::N3::Algebra::Time
+  ##
+  # For a date-time, its time:timeZone is the trailing timezone offset part, e.g.  "-05:00".
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-timezone-from-dateTime
+  class Timezone < RDF::N3::Algebra::ResourceOperator
+    NAME = :timeTimezone
+    URI = RDF::N3::Time.timeZone
+
+    ##
+    # The time:timeZone operator takes string or dateTime and extracts the timeZone component.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      case position
+      when :subject
+        return nil unless resource.literal?
+        resource = resource.as_datetime
+        RDF::Literal(resource.object.strftime("%Z"))
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+
+    ##
+    # There is no timezone unless it was specified in the lexical form and is not "Z"
+    def valid?(subject, object)
+      md = subject.value.match(%r(^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(Z|[\+-][\d-]+)))
+      md && md[1].to_s != 'Z'
+    end
+  end
+end

data/lib/rdf/n3/algebra/time/year.rb

@@ -0,0 +1,29 @@
+module RDF::N3::Algebra::Time
+  ##
+  # For a date-time, its time:year is  the year component.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-year-from-dateTime
+  class Year < RDF::N3::Algebra::ResourceOperator
+    NAME = :timeYear
+    URI = RDF::N3::Time.year
+
+    ##
+    # The time:year operator takes string or dateTime and extracts the year component.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      case position
+      when :subject
+        return nil unless resource.literal?
+        resource = resource.as_datetime
+        RDF::Literal(resource.object.strftime("%Y").to_i)
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+  end
+end

data/lib/rdf/n3/extensions.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require 'rdf'
+require 'rdf/n3/terminals'
 
 # Monkey-patch RDF::Enumerable to add `:existentials` and `:univerals` accessors
 module RDF
@@ -11,27 +12,21 @@ module RDF
     # Universal quantifiers defined on this enumerable
     # @return [Array<RDF::Query::Variable>]
     attr_accessor :universals
+  end
 
+  class List
     ##
-    # An enumerable contains another enumerable if every statement in other is a statement in self
+    # A list is variable if any of its members are variable?
     #
-    # @param [RDF::Enumerable] other
     # @return [Boolean]
-    def contain?(other)
-      other.all? {|statement| has_statement?(statement)}
-    end
-  end
-
-  class Statement
-    # Override variable?
     def variable?
-      to_a.any? {|term| !term.is_a?(RDF::Term) || term.variable?} || graph_name && graph_name.variable?
+      to_a.any?(&:variable?)
     end
 
     # Transform Statement into an SXP
     # @return [Array]
     def to_sxp_bin
-      [(variable? ? :pattern : :triple), subject, predicate, object, graph_name].compact
+      to_a.to_sxp_bin
     end
 
     ##
@@ -39,24 +34,188 @@ module RDF
     #
     # @return [String]
     def to_sxp
-      to_sxp_bin.to_sxp
+      to_a.to_sxp_bin.to_sxp
     end
   end
 
-  class Query::Solution
+  module Value
+    ##
+    # Returns `true` if `self` is a {RDF::N3::Algebra::Formula}.
+    #
+    # @return [Boolean]
+    def formula?
+      false
+    end
 
-    # Transform Statement into an SXP
-    # @return [Array]
-    def to_sxp_bin
-      [:solution] + bindings.map {|k, v| Query::Variable.new(k, v).to_sxp_bin}
+    # By default, returns itself. Can be used for terms such as blank nodes to be turned into non-disinguished variables.
+    #
+    # @param [RDF::Node] scope
+    # return [RDF::Query::Variable]
+    def to_ndvar(scope)
+      self
+    end
+  end
+
+  module Term
+    ##
+    # Is this the same term? Like `#eql?`, but no variable matching
+    def sameTerm?(other)
+      eql?(other)
     end
 
     ##
-    # Returns an S-Expression (SXP) representation
+    # Parse the value as a numeric literal, or return 0.
     #
-    # @return [String]
-    def to_sxp
-      to_sxp_bin.to_sxp
+    # @return [RDF::Literal::Numeric]
+    def as_number
+      RDF::Literal(0)
+    end
+
+    ##
+    # Parse the value as a dateTime literal, or return now.
+    #
+    # @return [RDF::Literal::DateTime]
+    def as_datetime
+      RDF::Literal::DateTime.new(DateTime.now)
+    end
+  end
+
+  class Literal
+    include RDF::N3::Terminals
+
+    ##
+    # Parse the value as a numeric literal, or return 0.
+    #
+    # @return [RDF::Literal::Numeric]
+    def as_number
+      return self if self.is_a?(RDF::Literal::Numeric)
+      case value
+      when DOUBLE  then RDF::Literal::Double.new(value)
+      when DECIMAL then RDF::Literal::Decimal.new(value)
+      when INTEGER then RDF::Literal::Integer.new(value)
+      else
+        RDF::Literal(0)
+      end
+    end
+
+    ##
+    # Parse the value as a dateTime literal, or return now.
+    #
+    # @return [RDF::Literal::DateTime]
+    def as_datetime
+      return self if is_a?(RDF::Literal::DateTime)
+      mvalue = value
+      mvalue = "#{mvalue}-01" if mvalue.match?(%r(^\d{4}$))
+      mvalue = "#{mvalue}-01" if mvalue.match?(%r(^\d{4}-\d{2}$))
+      RDF::Literal::DateTime.new(::DateTime.iso8601(mvalue), lexical: value)
+    rescue
+      RDF::Literal(0)
+    end
+  end
+
+  class Node
+    # Transform to a nondistinguished exisetntial variable in a formula scope
+    #
+    # @param [RDF::Node] scope
+    # return [RDF::Query::Variable]
+    def to_ndvar(scope)
+      label = "#{id}_#{scope ? scope.id : 'base'}_undext"
+      RDF::Query::Variable.new(label, existential: true, distinguished: false)
+    end
+  end
+
+  class Query
+    class Pattern
+      ##
+      # Overrides `#initialize!` to turn blank nodes into non-distinguished variables, if the `:ndvars` option is set.
+      alias_method :orig_initialize!, :initialize!
+      def initialize!
+        if @options[:ndvars]
+          @graph_name = @graph_name.to_ndvar(nil) if @graph_name
+          @subject = @subject.to_ndvar(@graph_name)
+          @predicate = @predicate.to_ndvar(@graph_name)
+          @object = @object.to_ndvar(@graph_name)
+        end
+        orig_initialize!
+      end
+
+      ##
+      # Checks pattern equality against a statement, considering nesting an lists.
+      #
+      # * A pattern which has a pattern as a subject or an object, matches
+      #   a statement having a statement as a subject or an object using {#eql?}.
+      #
+      # @param  [Statement] other
+      # @return [Boolean]
+      #
+      # @see RDF::URI#==
+      # @see RDF::Node#==
+      # @see RDF::Literal#==
+      # @see RDF::Query::Variable#==
+      def eql?(other)
+        return false unless other.is_a?(RDF::Statement) && (self.graph_name || false) == (other.graph_name || false)
+
+        [:subject, :predicate, :object].each do |part|
+          case o = self.send(part)
+          when RDF::Query::Pattern, RDF::List
+            return false unless o.eql?(other.send(part))
+          else
+            return false unless o == other.send(part)
+          end
+        end
+        true
+      end
+    end
+
+    class Solution
+      # Transform Statement into an SXP
+      # @return [Array]
+      def to_sxp_bin
+        [:solution] + bindings.map do |k, v|
+          existential = k.to_s.end_with?('ext')
+          k = k.to_s.sub(/_(?:und)?ext$/, '').to_sym
+          distinguished = !k.to_s.end_with?('undext')
+          Query::Variable.new(k, v, existential: existential, distinguished: distinguished).to_sxp_bin
+        end
+      end
+    end
+
+    class Variable
+      ##
+      # True if the other is the same variable
+      def sameTerm?(other)
+        other.is_a?(::RDF::Query::Variable) && name.eql?(other.name)
+      end
+
+      ##
+      # Parse the value as a numeric literal, or return 0.
+      #
+      # @return [RDF::Literal::Numeric]
+      def as_number
+        RDF::Literal(0)
+      end
+    end
+  end
+end
+
+module SPARQL
+  module Algebra
+    class Operator
+      ##
+      # Map of related formulae, indexed by graph name.
+      #
+      # @return [Hash{RDF::Resource => RDF::N3::Algebra::Formula}]
+      def formulae
+        @options.fetch(:formulae, {})
+      end
+
+      # Updates the operands for this operator.
+      #
+      # @param [Array] ary
+      # @return [Array]
+      def operands=(ary)
+        @operands = ary
+      end
     end
   end
 end

data/lib/rdf/n3/format.rb

@@ -27,5 +27,70 @@ module RDF::N3
     def self.symbols
       [:n3, :notation3]
     end
+
+    ##
+    # Hash of CLI commands appropriate for this format
+    # @return [Hash{Symbol => Hash}]
+    def self.cli_commands
+      {
+        reason: {
+          description: "Reason over formulae.",
+          help: "reason [--think] file\nPerform Notation-3 reasoning.",
+          parse: false,
+          # Only shows when input and output format set
+          filter: {format: :n3},  
+          repository: RDF::N3::Repository.new,
+          lambda: ->(argv, **options) do
+            repository = options[:repository]
+            result_repo = RDF::N3::Repository.new
+            RDF::CLI.parse(argv, format: :n3, list_terms: true, **options) do |reader|
+              reasoner = RDF::N3::Reasoner.new(reader, **options)
+              reasoner.reason!(**options)
+              if options[:conclusions]
+                result_repo << reasoner.conclusions
+              elsif options[:data]
+                result_repo << reasoner.data
+              else
+                result_repo << reasoner
+              end
+            end
+
+            # Replace input repository with results
+            repository.clear!
+            repository << result_repo
+          end,
+          options: [
+            RDF::CLI::Option.new(
+              symbol: :conclusions,
+              datatype: TrueClass,
+              control: :checkbox,
+              use: :optional,
+              on: ["--conclusions"],
+              description: "Exclude formulae and statements in the original dataset."),
+            RDF::CLI::Option.new(
+              symbol: :data,
+              datatype: TrueClass,
+              control: :checkbox,
+              use: :optional,
+              on: ["--data"],
+              description: "Only results from default graph, excluding formulae or variables."),
+            RDF::CLI::Option.new(
+              symbol: :strings,
+              datatype: TrueClass,
+              control: :checkbox,
+              use: :optional,
+              on: ["--strings"],
+              description: "Returns the concatenated strings from log:outputString."),
+            RDF::CLI::Option.new(
+              symbol: :think,
+              datatype: TrueClass,
+              control: :checkbox,
+              use: :optional,
+              on: ["--think"],
+              description: "Continuously execute until results stop growing."),
+          ]
+        },
+      }
+    end
   end
 end