rdf-n3 3.0.1 → 3.2.0

data/lib/rdf/n3/algebra/str/ends_with.rb

@@ -0,0 +1,33 @@
+module RDF::N3::Algebra::Str
+  # True iff the subject string ends with the object string.
+  class EndsWith < RDF::N3::Algebra::ResourceOperator
+    NAME = :strEndsWith
+    URI = RDF::N3::Str.endsWith
+
+    ##
+    # Resolves inputs as strings.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Literal]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      resource if resource.term?
+    end
+
+    # Both subject and object are inputs.
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+
+    ##
+    # @param  [RDF::Literal] left
+    #   a literal
+    # @param  [RDF::Literal] right
+    #   a literal
+    # @return [RDF::Literal::Boolean]
+    def apply(left, right)
+      RDF::Literal(left.to_s.end_with?(right.to_s))
+    end
+  end
+end

data/lib/rdf/n3/algebra/str/equal_ignoring_case.rb

@@ -0,0 +1,34 @@
+module RDF::N3::Algebra::Str
+  class EqualIgnoringCase < RDF::N3::Algebra::ResourceOperator
+    NAME = :strEqualIgnoringCase
+    URI = RDF::N3::Str.equalIgnoringCase
+
+    ##
+    # Resolves inputs as lower-case strings.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Literal]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      RDF::Literal(resource.to_s.downcase) if resource.term?
+    end
+
+    # Both subject and object are inputs.
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+
+    ##
+    # True iff the subject string is the same as object string ignoring differences between upper and lower case.
+    #
+    # @param  [RDF::Literal] left
+    #   a literal
+    # @param  [RDF::Literal] right
+    #   a literal
+    # @return [RDF::Literal::Boolean]
+    def apply(left, right)
+      RDF::Literal(left.to_s == right.to_s)
+    end
+  end
+end

data/lib/rdf/n3/algebra/str/format.rb

@@ -0,0 +1,17 @@
+module RDF::N3::Algebra::Str
+  # The subject is a list, whose first member is a format string, and whose remaining members are arguments to the format string. The formating string is in the style of python's % operator, very similar to C's sprintf(). The object is calculated from the subject.
+  class Format < RDF::N3::Algebra::ListOperator
+    include RDF::N3::Algebra::Builtin
+    NAME = :strFormat
+    URI = RDF::N3::Str.format
+
+    ##
+    # @param [RDF::N3::List] list
+    # @return [RDF::Term]
+    # @see RDF::N3::ListOperator#evaluate
+    def resolve(list)
+      format, *args = list.to_a.map(&:value)
+      str = RDF::Literal(format % args)
+    end
+  end
+end

data/lib/rdf/n3/algebra/str/greater_than.rb

@@ -0,0 +1,38 @@
+module RDF::N3::Algebra::Str
+  # True iff the string is greater than the object when ordered according to Unicode(tm) code order.
+  class GreaterThan < RDF::N3::Algebra::ResourceOperator
+    NAME = :strGreaterThan
+    URI = RDF::N3::Str.greaterThan
+
+    ##
+    # The string:greaterThan compares subject with object as strings.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      resource if resource.literal?
+    end
+
+    # Both subject and object are inputs.
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+
+    ##
+    # @param  [RDF::Literal] left
+    #   a literal
+    # @param  [RDF::Literal] right
+    #   a literal
+    # @return [RDF::Literal::Boolean]
+    def apply(left, right)
+      case
+      when !left.is_a?(RDF::Term) || !right.is_a?(RDF::Term) || !left.compatible?(right)
+        log_error(NAME) {"expected two RDF::Literal operands, but got #{left.inspect} and #{right.inspect}"}
+      when left > right then RDF::Literal::TRUE
+      else RDF::Literal::FALSE
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/str/less_than.rb

@@ -0,0 +1,33 @@
+module RDF::N3::Algebra::Str
+  # True iff the string is less than the object when ordered according to Unicode(tm) code order.
+  class LessThan < RDF::N3::Algebra::ResourceOperator
+    NAME = :strLessThan
+    URI = RDF::N3::Str.lessThan
+
+    ##
+    # Resolves inputs as strings.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Literal]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      resource if resource.term?
+    end
+
+    # Both subject and object are inputs.
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+
+    ##
+    # @param  [RDF::Literal] left
+    #   a literal
+    # @param  [RDF::Literal] right
+    #   a literal
+    # @return [RDF::Literal::Boolean]
+    def apply(left, right)
+      RDF::Literal(left.to_s < right.to_s)
+    end
+  end
+end

data/lib/rdf/n3/algebra/str/matches.rb

@@ -0,0 +1,37 @@
+module RDF::N3::Algebra::Str
+  # The subject is a string; the object is is a regular expression in the perl, python style.
+  # It is true iff the string matches the regexp.
+  class Matches < RDF::N3::Algebra::ResourceOperator
+    NAME = :strMatches
+    URI = RDF::N3::Str.matches
+
+    ##
+    # Resolves inputs as strings.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Literal]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      resource if resource.literal?
+    end
+
+    # Neither subect nor object are considered inputs, and must be resolved before evaluation.
+    def input_operand
+      RDF::N3::List.new
+    end
+
+    ##
+    # Tre if right, treated as a regular expression, matches left
+    #
+    # @param  [RDF::Literal] left
+    #   a simple literal
+    # @param  [RDF::Literal] right
+    #   a simple literal
+    # @return [RDF::Literal::Boolean] `true` or `false`
+    # @see https://www.w3.org/TR/xpath-functions/#regex-syntax
+    def apply(left, right)
+      RDF::Literal(Regexp.new(right.to_s).match?(left.to_s))
+    end
+  end
+end

data/lib/rdf/n3/algebra/str/not_equal_ignoring_case.rb

@@ -0,0 +1,17 @@
+module RDF::N3::Algebra::Str
+  # True iff the subject string is the NOT same as object string ignoring differences between upper and lower case.
+  class NotEqualIgnoringCase < EqualIgnoringCase
+    NAME = :strNotEqualIgnoringCase
+    URI = RDF::N3::Str.notEqualIgnoringCase
+
+    ##
+    # @param  [RDF::Literal] left
+    #   a literal
+    # @param  [RDF::Literal] right
+    #   a literal
+    # @return [RDF::Literal::Boolean]
+    def apply(left, right)
+      RDF::Literal(super != RDF::Literal::TRUE)
+    end
+  end
+end

data/lib/rdf/n3/algebra/str/not_greater_than.rb

@@ -0,0 +1,17 @@
+module RDF::N3::Algebra::Str
+  # True iff the string is NOT greater than the object when ordered according to Unicode(tm) code order.
+  class NotGreaterThan < GreaterThan
+    NAME = :strNotGreaterThan
+    URI = RDF::N3::Str.notGreaterThan
+
+    ##
+    # @param  [RDF::Literal] left
+    #   a literal
+    # @param  [RDF::Literal] right
+    #   a literal
+    # @return [RDF::Literal::Boolean]
+    def apply(left, right)
+      RDF::Literal(super != RDF::Literal::TRUE)
+    end
+  end
+end

data/lib/rdf/n3/algebra/str/not_less_than.rb

@@ -0,0 +1,17 @@
+module RDF::N3::Algebra::Str
+  # True iff the string is NOT less than the object when ordered according to Unicode(tm) code order.
+  class NotLessThan < LessThan
+    NAME = :strNotLessThan
+    URI = RDF::N3::Str.notLessThan
+
+    ##
+    # @param  [RDF::Literal] left
+    #   a literal
+    # @param  [RDF::Literal] right
+    #   a literal
+    # @return [RDF::Literal::Boolean]
+    def apply(left, right)
+      RDF::Literal(super != RDF::Literal::TRUE)
+    end
+  end
+end

data/lib/rdf/n3/algebra/str/not_matches.rb

@@ -0,0 +1,18 @@
+module RDF::N3::Algebra::Str
+  # The subject string; the object is a regular expression in the perl, python style. It is true iff the string does NOT match the regexp.
+  class NotMatches < Matches
+    NAME = :strNotMatches
+    URI = RDF::N3::Str.notMatches
+
+    ##
+    # @param  [RDF::Literal] text
+    #   a simple literal
+    # @param  [RDF::Literal] pattern
+    #   a simple literal
+    # @return [RDF::Literal::Boolean] `true` or `false`
+    # @see https://www.w3.org/TR/xpath-functions/#regex-syntax
+    def apply(text, pattern)
+      RDF::Literal(super != RDF::Literal::TRUE)
+    end
+  end
+end

data/lib/rdf/n3/algebra/str/replace.rb

@@ -0,0 +1,35 @@
+module RDF::N3::Algebra::Str
+  # A built-in for replacing characters or sub. takes a list of 3 strings; the first is the input data, the second the old and the third the new string. The object is calculated as the replaced string.
+  #
+  # @example
+  #     ("fofof bar", "of", "baz") string:replace "fbazbaz bar"
+  class Replace < RDF::N3::Algebra::ListOperator
+    include RDF::N3::Algebra::Builtin
+    NAME = :strReplace
+    URI = RDF::N3::Str.replace
+
+    ##
+    # @param [RDF::N3::List] list
+    # @return [RDF::Term]
+    # @see RDF::N3::ListOperator#evaluate
+    def resolve(list)
+      format, *args = list.to_a.map(&:value)
+      input, old_str, new_str = list.to_a
+      RDF::Literal(input.to_s.gsub(old_str.to_s, new_str.to_s))
+    end
+
+    ##
+    # Subclasses may override or supplement validate to perform validation on the list subject
+    #
+    # @param [RDF::N3::List] list
+    # @return [Boolean]
+    def validate(list)
+      if super && list.length == 3 && list.to_a.all?(&:literal?)
+        true
+      else
+        log_error(NAME) {"list must have exactly three entries: #{list.to_sxp}"}
+        false
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/str/scrape.rb

@@ -0,0 +1,35 @@
+module RDF::N3::Algebra::Str
+  # The subject is a list of two strings. The second string is a regular expression in the perl, python style. It must contain one group (a part in parentheses).  If the first string in the list matches the regular expression, then the object is calculated as being the part of the first string which matches the group.
+  #
+  # @example
+  #     ("abcdef" "ab(..)ef") string:scrape "cd"
+  class Scrape < RDF::N3::Algebra::ListOperator
+    include RDF::N3::Algebra::Builtin
+    NAME = :strScrape
+    URI = RDF::N3::Str.scrape
+
+    ##
+    # @param [RDF::N3::List] list
+    # @return [RDF::Term]
+    # @see RDF::N3::ListOperator#evaluate
+    def resolve(list)
+      input, regex = list.to_a
+      md = Regexp.new(regex.to_s).match(input.to_s)
+      RDF::Literal(md[1]) if md
+    end
+
+    ##
+    # Subclasses may override or supplement validate to perform validation on the list subject
+    #
+    # @param [RDF::N3::List] list
+    # @return [Boolean]
+    def validate(list)
+      if super && list.length == 2
+        true
+      else
+        log_error(NAME) {"list must have exactly two entries: #{list.to_sxp}"}
+        false
+      end
+    end
+  end
+end

data/lib/rdf/n3/algebra/str/starts_with.rb

@@ -0,0 +1,33 @@
+module RDF::N3::Algebra::Str
+  # True iff the subject string starts with the object string.
+  class StartsWith < RDF::N3::Algebra::ResourceOperator
+    NAME = :strStartsWith
+    URI = RDF::N3::Str.startsWith
+
+    ##
+    # Resolves inputs as strings.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Literal]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      resource if resource.term?
+    end
+
+    # Both subject and object are inputs.
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+
+    ##
+    # @param  [RDF::Literal] left
+    #   a literal
+    # @param  [RDF::Literal] right
+    #   a literal
+    # @return [RDF::Literal::Boolean]
+    def apply(left, right)
+      RDF::Literal(left.to_s.start_with?(right.to_s))
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module RDF::N3::Algebra::Time
+  ##
+  # For a date-time, its time:day is the day of the month.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-day-from-dateTime
+  class Day < RDF::N3::Algebra::ResourceOperator
+    NAME = :timeDay
+    URI = RDF::N3::Time.day
+
+    ##
+    # The time:day operator takes string or dateTime and extracts the day 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("%d").to_i)
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+
+    ##
+    # There is no day unless it was specified in the lexical form
+    def valid?(subject, object)
+      subject.value.match?(%r(^\d{4}-\d{2}-\d{2}))
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module RDF::N3::Algebra::Time
+  ##
+  # For a date-time, its time:dayOfWeek is the the day number within the week, Sunday being 0.
+  class DayOfWeek < RDF::N3::Algebra::ResourceOperator
+    NAME = :timeDayOfWeek
+    URI = RDF::N3::Time.dayOfWeek
+
+    ##
+    # The time:dayOfWeek operator takes string or dateTime and returns the 0-based day of the week.
+    #
+    # @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("%w").to_i)
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module RDF::N3::Algebra::Time
+  ##
+  # For a date-time format string, its time:gmtime is the result of formatting the Universal Time of processing in the format given. If the format string has zero length, then the ISOdate standard format is used. `[ is time:gmtime of ""]`  the therefore the current date time. It will end with "Z" as a timezone code.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-current-dateTime
+  class GmTime < RDF::N3::Algebra::ResourceOperator
+    NAME = :timeGmTime
+    URI = RDF::N3::Time.gmTime
+
+    ##
+    # The time:gmTime operator takes string or dateTime and returns current time formatted according to the subject.
+    #
+    # @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 = "%FT%T%:z" if resource.to_s.empty?
+        RDF::Literal(DateTime.now.new_offset(0).strftime(resource.to_s))
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module RDF::N3::Algebra::Time
+  ##
+  # For a date-time, its time:hour is the hour in the 24 hour clock.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-hours-from-dateTime
+  class Hour < RDF::N3::Algebra::ResourceOperator
+    NAME = :timeHour
+    URI = RDF::N3::Time.hour
+
+    ##
+    # The time:hour operator takes string or dateTime and extracts the hour 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("%H").to_i)
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+
+    ##
+    # There is no hour 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}))
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module RDF::N3::Algebra::Time
+  ##
+  # Iff the _subject_ is a `xsd:dateTime` and the _object_ is the integer number of seconds since the beginning of the era on a given system.  Don't assume a particular value, always test for it. The _object_ can be calculated as a function of the _subject_.
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-timezone-from-dateTime
+  class InSeconds < RDF::N3::Algebra::ResourceOperator
+    NAME = :timeInSeconds
+    URI = RDF::N3::Time.inSeconds
+
+    ##
+    # The time:inseconds operator takes may have either a bound subject or object.
+    #
+    # @param [RDF::Term] resource
+    # @param [:subject, :object] position
+    # @return [RDF::Term]
+    # @see RDF::N3::ResourceOperator#evaluate
+    def resolve(resource, position:)
+      case position
+      when :subject
+        case resource
+        when RDF::Query::Variable
+          resource
+        when RDF::Literal
+          resource = resource.as_datetime
+          # Subject evaluates to seconds from the epoc
+          RDF::Literal::Integer.new(resource.object.strftime("%s"))
+        else
+          nil
+        end
+      when :object
+        case resource
+        when RDF::Query::Variable
+          resource
+        when RDF::Literal
+          resource = resource.as_number
+          # Object evaluates to the DateTime representation of the seconds form the epoc
+          RDF::Literal(RDF::Literal::DateTime.new(::Time.at(resource).utc.to_datetime).to_s)
+        else
+          nil
+        end
+      end
+    end
+
+    # Either subject or object must be a bound resource
+    def valid?(subject, object)
+      return true if subject.literal? || object.literal?
+      log_error(NAME) {"subject or object are not literals: #{subject.inspect}, #{object.inspect}"}
+      false
+    end
+
+    ##
+    # Return both subject and object operands.
+    #
+    # @return [RDF::Term]
+    def input_operand
+      RDF::N3::List.new(values: operands)
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module RDF::N3::Algebra::Time
+  ##
+  # For a date-time format string, its time:localTime is the result of formatting the current time of processing and local timezone in the format given. If the format string has zero length, then the ISOdate standrad format is used.  [ is time:localTime of ""]  the therefore the current date time. It will end with a numeric timezone code or "Z" for UTC (GMT).
+  #
+  # @see https://www.w3.org/TR/xpath-functions/#func-current-dateTime
+  class LocalTime < RDF::N3::Algebra::ResourceOperator
+    NAME = :timeLocalTime
+    URI = RDF::N3::Time.localTime
+
+    ##
+    # The time:localTime operator takes string or dateTime and returns current time formatted according to the subject.
+    #
+    # @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 = "%FT%T%:z" if resource.to_s.empty?
+        RDF::Literal(DateTime.now.strftime(resource.to_s))
+      when :object
+        return nil unless resource.literal? || resource.variable?
+        resource
+      end
+    end
+  end
+end

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