rdf-n3 3.0.1 → 3.2.0

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/algebra.rb

@@ -0,0 +1,210 @@
+$:.unshift(File.expand_path("../..", __FILE__))
+require 'sparql/algebra'
+require 'sxp'
+
+module RDF::N3
+  # Based on the SPARQL Algebra, operators for executing a patch
+  #
+  # @author [Gregg Kellogg](http://greggkellogg.net/)
+  module Algebra
+    autoload :Builtin,                'rdf/n3/algebra/builtin'
+    autoload :Formula,                'rdf/n3/algebra/formula'
+    autoload :ListOperator,           'rdf/n3/algebra/list_operator'
+    autoload :NotImplemented,         'rdf/n3/algebra/not_implemented'
+    autoload :ResourceOperator,       'rdf/n3/algebra/resource_operator'
+
+    module List
+      def vocab; RDF::N3::List.to_uri; end
+      module_function :vocab
+      autoload :Append,               'rdf/n3/algebra/list/append'
+      autoload :First,                'rdf/n3/algebra/list/first'
+      autoload :In,                   'rdf/n3/algebra/list/in'
+      autoload :Iterate,              'rdf/n3/algebra/list/iterate'
+      autoload :Last,                 'rdf/n3/algebra/list/last'
+      autoload :Length,               'rdf/n3/algebra/list/length'
+      autoload :Member,               'rdf/n3/algebra/list/member'
+    end
+
+    module Log
+      def vocab; RDF::N3::Log.to_uri; end
+      module_function :vocab
+      autoload :Conclusion,           'rdf/n3/algebra/log/conclusion'
+      autoload :Conjunction,          'rdf/n3/algebra/log/conjunction'
+      autoload :Content,              'rdf/n3/algebra/log/content'
+      autoload :DtLit,                'rdf/n3/algebra/log/dtlit'
+      autoload :EqualTo,              'rdf/n3/algebra/log/equal_to'
+      autoload :Implies,              'rdf/n3/algebra/log/implies'
+      autoload :Includes,             'rdf/n3/algebra/log/includes'
+      autoload :LangLit,              'rdf/n3/algebra/log/langlit'
+      autoload :N3String,             'rdf/n3/algebra/log/n3_string'
+      autoload :NotEqualTo,           'rdf/n3/algebra/log/not_equal_to'
+      autoload :NotIncludes,          'rdf/n3/algebra/log/not_includes'
+      autoload :OutputString,         'rdf/n3/algebra/log/output_string'
+      autoload :ParsedAsN3,           'rdf/n3/algebra/log/parsed_as_n3'
+      autoload :Semantics,            'rdf/n3/algebra/log/semantics'
+    end
+
+    module Math
+      def vocab; RDF::N3::Math.to_uri; end
+      module_function :vocab
+      autoload :AbsoluteValue,        'rdf/n3/algebra/math/absolute_value'
+      autoload :ACos,                 'rdf/n3/algebra/math/acos'
+      autoload :ASin,                 'rdf/n3/algebra/math/asin'
+      autoload :ATan,                 'rdf/n3/algebra/math/atan'
+      autoload :ACosH,                'rdf/n3/algebra/math/acosh'
+      autoload :ASinH,                'rdf/n3/algebra/math/asinh'
+      autoload :ATanH,                'rdf/n3/algebra/math/atanh'
+      autoload :Ceiling,              'rdf/n3/algebra/math/ceiling'
+      autoload :Cos,                  'rdf/n3/algebra/math/cos'
+      autoload :CosH,                 'rdf/n3/algebra/math/cosh'
+      autoload :Difference,           'rdf/n3/algebra/math/difference'
+      autoload :EqualTo,              'rdf/n3/algebra/math/equal_to'
+      autoload :Exponentiation,       'rdf/n3/algebra/math/exponentiation'
+      autoload :Floor,                'rdf/n3/algebra/math/floor'
+      autoload :GreaterThan,          'rdf/n3/algebra/math/greater_than'
+      autoload :LessThan,             'rdf/n3/algebra/math/less_than'
+      autoload :Negation,             'rdf/n3/algebra/math/negation'
+      autoload :NotEqualTo,           'rdf/n3/algebra/math/not_equal_to'
+      autoload :NotGreaterThan,       'rdf/n3/algebra/math/not_greater_than'
+      autoload :NotLessThan,          'rdf/n3/algebra/math/not_less_than'
+      autoload :Product,              'rdf/n3/algebra/math/product'
+      autoload :Quotient,             'rdf/n3/algebra/math/quotient'
+      autoload :Remainder,            'rdf/n3/algebra/math/remainder'
+      autoload :Rounded,              'rdf/n3/algebra/math/rounded'
+      autoload :Sin,                  'rdf/n3/algebra/math/sin'
+      autoload :SinH,                 'rdf/n3/algebra/math/sinh'
+      autoload :Sum,                  'rdf/n3/algebra/math/sum'
+      autoload :Tan,                  'rdf/n3/algebra/math/tan'
+      autoload :TanH,                 'rdf/n3/algebra/math/tanh'
+    end
+
+    module Str
+      def vocab; RDF::N3::Str.to_uri; end
+      module_function :vocab
+      autoload :Concatenation,        'rdf/n3/algebra/str/concatenation'
+      autoload :Contains,             'rdf/n3/algebra/str/contains'
+      autoload :ContainsIgnoringCase, 'rdf/n3/algebra/str/contains_ignoring_case'
+      autoload :EndsWith,             'rdf/n3/algebra/str/ends_with'
+      autoload :EqualIgnoringCase,    'rdf/n3/algebra/str/equal_ignoring_case'
+      autoload :Format,               'rdf/n3/algebra/str/format'
+      autoload :GreaterThan,          'rdf/n3/algebra/str/greater_than'
+      autoload :LessThan,             'rdf/n3/algebra/str/less_than'
+      autoload :Matches,              'rdf/n3/algebra/str/matches'
+      autoload :NotEqualIgnoringCase, 'rdf/n3/algebra/str/not_equal_ignoring_case'
+      autoload :NotGreaterThan,       'rdf/n3/algebra/str/not_greater_than'
+      autoload :NotLessThan,          'rdf/n3/algebra/str/not_less_than'
+      autoload :NotMatches,           'rdf/n3/algebra/str/not_matches'
+      autoload :Replace,              'rdf/n3/algebra/str/replace'
+      autoload :Scrape,               'rdf/n3/algebra/str/scrape'
+      autoload :StartsWith,           'rdf/n3/algebra/str/starts_with'
+    end
+
+    module Time
+      def vocab; RDF::N3::Time.to_uri; end
+      module_function :vocab
+      autoload :DayOfWeek,            'rdf/n3/algebra/time/day_of_week'
+      autoload :Day,                  'rdf/n3/algebra/time/day'
+      autoload :GmTime,               'rdf/n3/algebra/time/gm_time'
+      autoload :Hour,                 'rdf/n3/algebra/time/hour'
+      autoload :InSeconds,            'rdf/n3/algebra/time/in_seconds'
+      autoload :LocalTime,            'rdf/n3/algebra/time/local_time'
+      autoload :Minute,               'rdf/n3/algebra/time/minute'
+      autoload :Month,                'rdf/n3/algebra/time/month'
+      autoload :Second,               'rdf/n3/algebra/time/second'
+      autoload :Timezone,             'rdf/n3/algebra/time/timezone'
+      autoload :Year,                 'rdf/n3/algebra/time/year'
+    end
+
+    def for(uri)
+      {
+        RDF::N3::List.append              => List.const_get(:Append),
+        RDF::N3::List.first               => List.const_get(:First),
+        RDF::N3::List.in                  => List.const_get(:In),
+        RDF::N3::List.iterate             => List.const_get(:Iterate),
+        RDF::N3::List.last                => List.const_get(:Last),
+        RDF::N3::List.length              => List.const_get(:Length),
+        RDF::N3::List.member              => List.const_get(:Member),
+
+        RDF::N3::Log.conclusion           => Log.const_get(:Conclusion),
+        RDF::N3::Log.conjunction          => Log.const_get(:Conjunction),
+        RDF::N3::Log.content              => Log.const_get(:Content),
+        RDF::N3::Log.dtlit                => Log.const_get(:DtLit),
+        RDF::N3::Log.equalTo              => Log.const_get(:EqualTo),
+        RDF::N3::Log.implies              => Log.const_get(:Implies),
+        RDF::N3::Log.includes             => Log.const_get(:Includes),
+        RDF::N3::Log.langlit              => Log.const_get(:LangLit),
+        RDF::N3::Log.n3String             => Log.const_get(:N3String),
+        RDF::N3::Log.notEqualTo           => Log.const_get(:NotEqualTo),
+        RDF::N3::Log.notIncludes          => Log.const_get(:NotIncludes),
+        RDF::N3::Log.outputString         => Log.const_get(:OutputString),
+        RDF::N3::Log.parsedAsN3           => Log.const_get(:ParsedAsN3),
+        RDF::N3::Log.semantics            => Log.const_get(:Semantics),
+        RDF::N3::Log.supports             => NotImplemented,
+
+        RDF::N3::Math.absoluteValue       => Math.const_get(:AbsoluteValue),
+        RDF::N3::Math.acos                => Math.const_get(:ACos),
+        RDF::N3::Math.asin                => Math.const_get(:ASin),
+        RDF::N3::Math.atan                => Math.const_get(:ATan),
+        RDF::N3::Math.acosh               => Math.const_get(:ACosH),
+        RDF::N3::Math.asinh               => Math.const_get(:ASinH),
+        RDF::N3::Math.atanh               => Math.const_get(:ATanH),
+        RDF::N3::Math.ceiling             => Math.const_get(:Ceiling),
+        RDF::N3::Math.ceiling             => Math.const_get(:Ceiling),
+        RDF::N3::Math.cos                 => Math.const_get(:Cos),
+        RDF::N3::Math.cosh                => Math.const_get(:CosH),
+        RDF::N3::Math.difference          => Math.const_get(:Difference),
+        RDF::N3::Math.equalTo             => Math.const_get(:EqualTo),
+        RDF::N3::Math.exponentiation      => Math.const_get(:Exponentiation),
+        RDF::N3::Math.floor               => Math.const_get(:Floor),
+        RDF::N3::Math.greaterThan         => Math.const_get(:GreaterThan),
+        RDF::N3::Math.lessThan            => Math.const_get(:LessThan),
+        RDF::N3::Math.negation            => Math.const_get(:Negation),
+        RDF::N3::Math.notEqualTo          => Math.const_get(:NotEqualTo),
+        RDF::N3::Math.notGreaterThan      => Math.const_get(:NotGreaterThan),
+        RDF::N3::Math.notLessThan         => Math.const_get(:NotLessThan),
+        RDF::N3::Math.product             => Math.const_get(:Product),
+        RDF::N3::Math.quotient            => Math.const_get(:Quotient),
+        RDF::N3::Math.remainder           => Math.const_get(:Remainder),
+        RDF::N3::Math.rounded             => Math.const_get(:Rounded),
+        RDF::N3::Math.sin                 => Math.const_get(:Sin),
+        RDF::N3::Math.sinh                => Math.const_get(:SinH),
+        RDF::N3::Math.tan                 => Math.const_get(:Tan),
+        RDF::N3::Math.tanh                => Math.const_get(:TanH),
+        RDF::N3::Math[:sum]               => Math.const_get(:Sum),
+
+        RDF::N3::Str.concatenation        => Str.const_get(:Concatenation),
+        RDF::N3::Str.contains             => Str.const_get(:Contains),
+        RDF::N3::Str.containsIgnoringCase => Str.const_get(:ContainsIgnoringCase),
+        RDF::N3::Str.containsRoughly      => NotImplemented,
+        RDF::N3::Str.endsWith             => Str.const_get(:EndsWith),
+        RDF::N3::Str.equalIgnoringCase    => Str.const_get(:EqualIgnoringCase),
+        RDF::N3::Str.format               => Str.const_get(:Format),
+        RDF::N3::Str.greaterThan          => Str.const_get(:GreaterThan),
+        RDF::N3::Str.lessThan             => Str.const_get(:LessThan),
+        RDF::N3::Str.matches              => Str.const_get(:Matches),
+        RDF::N3::Str.notEqualIgnoringCase => Str.const_get(:NotEqualIgnoringCase),
+        RDF::N3::Str.notGreaterThan       => Str.const_get(:NotGreaterThan),
+        RDF::N3::Str.notLessThan          => Str.const_get(:NotLessThan),
+        RDF::N3::Str.notMatches           => Str.const_get(:NotMatches),
+        RDF::N3::Str.replace              => Str.const_get(:Replace),
+        RDF::N3::Str.scrape               => Str.const_get(:Scrape),
+        RDF::N3::Str.startsWith           => Str.const_get(:StartsWith),
+
+        RDF::N3::Time.dayOfWeek           => Time.const_get(:DayOfWeek),
+        RDF::N3::Time.day                 => Time.const_get(:Day),
+        RDF::N3::Time.gmTime              => Time.const_get(:GmTime),
+        RDF::N3::Time.hour                => Time.const_get(:Hour),
+        RDF::N3::Time.inSeconds           => Time.const_get(:InSeconds),
+        RDF::N3::Time.localTime           => Time.const_get(:LocalTime),
+        RDF::N3::Time.minute              => Time.const_get(:Minute),
+        RDF::N3::Time.month               => Time.const_get(:Month),
+        RDF::N3::Time.second              => Time.const_get(:Second),
+        RDF::N3::Time.timeZone            => Time.const_get(:Timezone),
+        RDF::N3::Time.year                => Time.const_get(:Year),
+      }[uri]
+    end
+    module_function :for
+  end
+end
+
+

data/lib/rdf/n3/extensions.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+require 'rdf'
+require 'rdf/n3/terminals'
+
+# Monkey-patch RDF::Enumerable to add `:existentials` and `:univerals` accessors
+module RDF
+  module Enumerable
+    # Existential quantifiers defined on this enumerable
+    # @return [Array<RDF::Query::Variable>]
+    attr_accessor :existentials
+
+    # Universal quantifiers defined on this enumerable
+    # @return [Array<RDF::Query::Variable>]
+    attr_accessor :universals
+  end
+
+  class List
+    ##
+    # A list is variable if any of its members are variable?
+    #
+    # @return [Boolean]
+    def variable?
+      to_a.any?(&:variable?)
+    end
+
+    # Transform Statement into an SXP
+    # @return [Array]
+    def to_sxp_bin
+      to_a.to_sxp_bin
+    end
+
+    ##
+    # Returns an S-Expression (SXP) representation
+    #
+    # @return [String]
+    def to_sxp(**options)
+      to_a.to_sxp_bin.to_sxp(**options)
+    end
+  end
+
+  module Value
+    ##
+    # Returns `true` if `self` is a {RDF::N3::Algebra::Formula}.
+    #
+    # @return [Boolean]
+    def formula?
+      false
+    end
+
+    # 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
+
+    ##
+    # Parse the value as a numeric literal, or return 0.
+    #
+    # @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

@@ -15,7 +15,7 @@ module RDF::N3
   # @example Obtaining serialization format file extension mappings
   #     RDF::Format.file_extensions    #=> {n3: "text/n3"}
   #
-  # @see http://www.w3.org/TR/rdf-testcases/#ntriples
+  # @see https://www.w3.org/TR/rdf-testcases/#ntriples
   class Format < RDF::Format
     content_type     'text/n3',             extension: :n3, aliases: %w(text/rdf+n3;q=0.2 application/rdf+n3;q=0.2)
     content_encoding 'utf-8'
@@ -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