sxp 1.0.0 → 1.2.0

data/lib/sxp/extensions.rb

@@ -1,6 +1,79 @@
+# -*- encoding: utf-8 -*-
+require 'bigdecimal'
+require 'matrix'
+require 'time'
+
+##
+# Extensions for Ruby's `Object` class.
+class Object
+  ##
+  # Returns the SXP representation of this object.
+  #
+  # @return [String]
+  def to_sxp(**options)
+    to_s.to_json
+  end
+end
+
+##
+# Extensions for Ruby's `NilClass` class.
+class NilClass
+  ##
+  # Returns the SXP representation of this object.
+  #
+  # @return [String]
+  def to_sxp(**options)
+    '#n'
+  end
+end
+
+##
+# Extensions for Ruby's `FalseClass` class.
+class FalseClass
+  ##
+  # Returns the SXP representation of this object.
+  #
+  # @return [String]
+  def to_sxp(**options)
+    '#f'
+  end
+end
+
+##
+# Extensions for Ruby's `TrueClass` class.
+class TrueClass
+  ##
+  # Returns the SXP representation of this object.
+  #
+  # @return [String]
+  def to_sxp(**options)
+    '#t'
+  end
+end
+
+##
+# Extensions for Ruby's `String` class.
+class String
+  ##
+  # Returns the SXP representation of this object.
+  #
+  # @return [String]
+  def to_sxp(**options)
+    inspect
+  end
+end
+
 ##
 # Extensions for Ruby's `Symbol` class.
 class Symbol
+  ##
+  # Returns the SXP representation of this object.
+  #
+  # @return [String]
+  def to_sxp(**options)
+    to_s
+  end
+
   ##
   # Returns `true` if this is a keyword symbol.
   #
@@ -10,17 +83,244 @@ class Symbol
   end
 end
 
-# Update RDF::URI if RDF is loaded
+##
+# Extensions for Ruby's `Integer` class.
+class Integer
+  ##
+  # Returns the SXP representation of this object.
+  #
+  # @return [String]
+  def to_sxp(**options)
+    to_s
+  end
+end
+
+##
+# Extensions for Ruby's `BigDecimal` class.
+class BigDecimal
+  ##
+  # Returns the SXP representation of this object.
+  #
+  # @return [String]
+  def to_sxp(**options)
+    to_f.to_s
+  end
+end
+
+##
+# Extensions for Ruby's `Float` class.
+class Float
+  ##
+  # Returns the SXP representation of this object.
+  #
+  # @return [String]
+  def to_sxp(**options)
+    case
+      when nan? then 'nan.0'
+      when infinite? then (infinite? > 0 ? '+inf.0' : '-inf.0')
+      else to_s
+    end
+  end
+end
+
+##
+# Extensions for Ruby's `Array` class.
+class Array
+  ##
+  # Returns the SXP representation of this object.
+  #
+  # @return [String]
+  def to_sxp()
+    '(' << map { |x| x.to_sxp(**options) }.join(' ') << ')'
+  end
+end
+
+##
+# Extensions for Ruby's `Vector` class.
+class Vector
+  ##
+  # Returns the SXP representation of this object.
+  #
+  # @return [String]
+  def to_sxp(**options)
+    '#(' << to_a.map { |x| x.to_sxp(**options) }.join(' ') << ')'
+  end
+end
+
+##
+# Extensions for Ruby's `Hash` class.
+class Hash
+  ##
+  # Returns the SXP representation of this object.
+  #
+  # @return [String]
+  def to_sxp(**options)
+    to_a.to_sxp(**options)
+  end
+end
+
+##
+# Extensions for Ruby's `Time` class.
+class Time
+  ##
+  # Returns the SXP representation of this object.
+  #
+  # @return [String]
+  def to_sxp(**options)
+    '#@' << (respond_to?(:xmlschema) ? xmlschema : to_i).to_s
+  end
+end
+
+##
+# Extensions for Ruby's `Regexp` class.
+class Regexp
+  ##
+  # Returns the SXP representation of this object.
+  #
+  # @return [String]
+  def to_sxp(**options)
+    '#' << inspect
+  end
+end
+
 begin
-  require 'rdf'
+  require 'rdf' # For SPARQL/RDF
 
   ##
-  # Extensions for RDF::URI
+  # Extensions for Ruby's `Array` class.
+  # These extensions depend on RDF being loaded
+  class Array
+    ##
+    # Returns the SXP representation of this object.
+    #
+    # If array is of the form `[:base, uri, ..]`, the base_uri is taken from the second value
+    #
+    # If array is of the form `[:prefix, [..], ..]`, prefixes are taken from the second value
+    #
+    # Prefixes always are terminated by a ':'
+    #
+    # @param [Hash{Symbol => RDF::URI}] prefixes(nil)
+    # @param [RDF::URI] base_uri(nil)
+    # @return [String]
+    def to_sxp(prefixes: nil, base_uri: nil, **options)
+      if self.first == :base && self.length == 3 && self[1].is_a?(RDF::URI)
+        base_uri = self[1]
+        '(' << (
+        self[0,2].map(&:to_sxp) <<
+          self.last.to_sxp(prefixes: prefixes, base_uri: base_uri, **options)
+        ).join(' ') << ')'
+      elsif self.first == :prefix && self.length == 3 && self[1].is_a?(Array)
+        prefixes = prefixes ? prefixes.dup : {}
+        self[1].each do |defn|
+          prefixes[defn.first.to_s.chomp(':').to_sym] = RDF::URI(defn.last) if
+            defn.is_a?(Array) && defn.length == 2
+        end
+        pfx_sxp = self[1].map {|(p,s)|["#{p.to_s.chomp(':')}:".to_sym, RDF::URI(s)]}.to_sxp
+        '(' << [
+          :prefix,
+          pfx_sxp,
+          self.last.to_sxp(prefixes: prefixes, base_uri: base_uri, **options)
+        ].join(' ') << ')'
+      else
+        '(' << map { |x| x.to_sxp(prefixes: prefixes, base_uri: base_uri, **options) }.join(' ') << ')'
+      end
+    end
+  end
+
   class RDF::URI
+    ##
+    # Returns the SXP representation of this a URI. Uses Lexical representation, if set, otherwise, any PName match, otherwise, the relativized version of the URI if a base_uri is given, otherwise just the URI.
+    #
+    # @param [Hash{Symbol => RDF::URI}] prefixes(nil)
+    # @param [RDF::URI] base_uri(nil)
+    # @return [String]
+    def to_sxp(prefixes: nil, base_uri: nil, **options)
+      return lexical if lexical
+      pn = pname(prefixes: prefixes || {})
+      return pn unless to_s == pn
+      md = self == base_uri ? '' : self.relativize(base_uri)
+      "<#{md}>"
+    end
+
     # Original lexical value of this URI to allow for round-trip serialization.
     def lexical=(value); @lexical = value; end
     def lexical; @lexical; end
   end
+
+  class RDF::Node
+    ##
+    # Returns the SXP representation of this object.
+    #
+    # @return [String]
+    def to_sxp(**options)
+      to_s
+    end
+  end
+
+  class RDF::Literal
+    ##
+    # Returns the SXP representation of a Literal.
+    #
+    # @return [String]
+    def to_sxp(**options)
+      case datatype
+      when RDF::XSD.boolean, RDF::XSD.integer, RDF::XSD.double, RDF::XSD.decimal, RDF::XSD.time
+        # Retain stated lexical form if possible
+        valid? ? to_s : object.to_sxp(**options)
+      else
+        text = value.dump
+        text << "@#{language}" if self.has_language?
+        text << "^^#{datatype.to_sxp(**options)}" if self.has_datatype?
+        text
+      end
+    end
+
+    class Double
+      ##
+      # Returns the SXP representation of this object.
+      #
+      # @return [String]
+      def to_sxp(**options)
+        case
+          when nan? then 'nan.0'
+          when infinite? then (infinite? > 0 ? '+inf.0' : '-inf.0')
+          else canonicalize.to_s.downcase
+        end
+      end
+    end
+  end
+
+  class RDF::Query
+    # Transform Query into an Array form of an SXP
+    #
+    # If Query is named, it's treated as a GroupGraphPattern, otherwise, a BGP
+    #
+    # @return [Array]
+    def to_sxp(**options)
+      res = [:bgp] + patterns
+      (named? ? [:graph, graph_name, res] : res).to_sxp(**options)
+    end
+  end
+
+  class RDF::Query::Pattern
+    # Transform Query Pattern into an SXP
+    #
+    # @return [String]
+    def to_sxp(**options)
+      [:triple, subject, predicate, object].to_sxp(**options)
+    end
+  end
+
+  class RDF::Query::Variable
+    ##
+    # Transform Query variable into an SXP.
+    #
+    # @return [String]
+    def to_sxp(**options)
+      prefix = distinguished? ? (existential? ? '$' : '?') : (existential? ? '$$' : '??')
+      unbound? ? "#{prefix}#{name}".to_sym.to_sxp : ["#{prefix}#{name}".to_sym, value].to_sxp
+    end
+  end
 rescue LoadError
-  # Ignore
+  # Ignore if RDF not loaded
 end

data/lib/sxp/generator.rb

@@ -16,18 +16,41 @@ module SXP
 
       ##
       # @param [Object] obj
-      def initialize(obj, indent)
+      # @param [Integer] indent
+      # @param [Hash{Symbol => RDF::URI}] prefixes (nil)
+      # @param [RDF::URI] base_uri (nil)
+      def initialize(obj, indent, prefixes: nil, base_uri: nil)
         @indent = indent
         @elements = []
+        @prefixes = prefixes
+        @base_uri = base_uri
         if obj.is_a?(Array)
-          obj.compact.each {|o| @elements << Block.new(o, indent + 1)}
+          # If this is a base or prefix element, update our representations
+          if obj.first == :base && obj.length == 3 && obj[1].is_a?(RDF::URI)
+            base_uri = obj[1]
+            @elements << Block.new(:base, indent + 1)
+            @elements << Block.new(obj[1], indent + 1)
+            @elements << Block.new(obj.last, indent + 1, prefixes: prefixes, base_uri: base_uri)
+          elsif obj.first == :prefix && obj.length == 3 && obj[1].is_a?(Array)
+            prefixes = prefixes ? prefixes.dup : {}
+            obj[1].each do |defn|
+              prefixes[defn.first.to_s.chomp(':').to_sym] = RDF::URI(defn.last) if defn.is_a?(Array) && defn.length == 2
+            end
+            @elements << Block.new(:prefix, indent + 1)
+            @elements << Block.new(obj[1], indent + 1)
+            @elements << Block.new(obj.last, indent + 1, prefixes: prefixes, base_uri: base_uri)
+          else          
+            obj.compact.each do |o|
+              @elements << Block.new(o, indent + 1, prefixes: prefixes, base_uri: base_uri)
+            end
+          end
         else
           @elements = obj
         end
       end
       
       ##
-      # Agregate length over each element accounting for spaces
+      # Aggregate length over each element accounting for spaces
       #
       # @return [Integer]
       #   If indent is not not nil, returns zero
@@ -35,7 +58,7 @@ module SXP
         if @elements.is_a?(Array)
           @elements.map(&:length).inject(:+).to_i + @elements.length - 1
         else
-          @elements.to_sxp.length
+          @elements.to_sxp(prefixes: @prefixes, base_uri: @base_uri).length
         end
       end
       
@@ -44,8 +67,8 @@ module SXP
       # This should only be called on a block when
       # no indentation is to be applied
       # @return [String]
-      def to_sxp
-        @elements.to_sxp
+      def to_sxp(prefixes: nil, base_uri: nil)
+        @elements.to_sxp(prefixes: prefixes || @prefixes, base_uri: base_uri || @base_uri)
       end
       
       ##
@@ -67,7 +90,7 @@ module SXP
           first, *elems = @elements
           unless first.sxp?
             # It's atomic, write out after paren
-            buffer += first.to_sxp + "\n"
+            buffer += first.to_sxp(prefixes: @prefixes, base_uri: @base_uri) + "\n"
           else
             buffer += "\n"
             elems.unshift(first)
@@ -77,7 +100,7 @@ module SXP
           end
           buffer += do_indent + ")\n"
         else
-          buffer += do_indent + @elements.to_sxp + "\n"
+          buffer += do_indent + @elements.to_sxp(prefixes: @prefixes, base_uri: @base_uri) + "\n"
         end
         buffer
       end

data/lib/sxp/pair.rb

@@ -27,7 +27,7 @@ module SXP
     # Returns `true` if the tail of this pair is not `nil` or another pair.
     #
     # @return [Boolean]
-    # @see    http://srfi.schemers.org/srfi-1/srfi-1.html#ImproperLists
+    # @see    https:/srfi.schemers.org/srfi-1/srfi-1.html#ImproperLists
     def dotted?
       !proper?
     end
@@ -36,7 +36,7 @@ module SXP
     # Returns `true` if the tail of this pair is `nil` or another pair.
     #
     # @return [Boolean]
-    # @see    http://srfi.schemers.org/srfi-1/srfi-1.html#ImproperLists
+    # @see    https:/srfi.schemers.org/srfi-1/srfi-1.html#ImproperLists
     def proper?
       tail.nil? || tail.is_a?(Pair)
     end

data/lib/sxp/reader/common_lisp.rb

@@ -1,9 +1,11 @@
 # -*- encoding: utf-8 -*-
+require 'matrix'
+
 module SXP; class Reader
   ##
   # A Common Lisp S-expressions parser.
   #
-  # @see http://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node14.html
+  # @see https:/www.cs.cmu.edu/Groups/AI/html/cltl/clm/node14.html
   class CommonLisp < Basic
     OPTIONS         = {nil: nil, t: true, quote: :quote, function: :function}
 
@@ -16,7 +18,7 @@ module SXP; class Reader
 
     # Escape characters, used in the form `#\Backspace`. Case is treated
     # insensitively
-    # @see http://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node22.html
+    # @see https:/www.cs.cmu.edu/Groups/AI/html/cltl/clm/node22.html
     CHARACTERS = {
       'newline'   => "\n",
       'space'     => " ",
@@ -37,8 +39,8 @@ module SXP; class Reader
     # @option options [Object]         :t        (true)
     # @option options [Object]         :quote    (:quote)
     # @option options [Object]         :function (:function)
-    def initialize(input, options = {}, &block)
-      super(input, OPTIONS.merge(options), &block)
+    def initialize(input, **options, &block)
+      super(input, **OPTIONS.merge(options), &block)
     end
 
     ##
@@ -88,7 +90,8 @@ module SXP; class Reader
     #
     # @return [Array]
     def read_vector
-      raise NotImplementedError, "#{self.class}#read_vector" # TODO
+      list = read_list(')')
+      Vector.[](*list)
     end
 
     ##
@@ -114,7 +117,7 @@ module SXP; class Reader
     # eroneously read characters back in the input stream
     #
     # @return [String]
-    # @see    http://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node22.html
+    # @see    https:/www.cs.cmu.edu/Groups/AI/html/cltl/clm/node22.html
     def read_character
       lit = read_literal
 

data/lib/sxp/reader/scheme.rb

@@ -3,7 +3,7 @@ module SXP; class Reader
   ##
   # A Scheme R4RS S-expressions parser.
   #
-  # @see http://people.csail.mit.edu/jaffer/r4rs_9.html#SEC65
+  # @see https:/people.csail.mit.edu/jaffer/r4rs_9.html#SEC65
   class Scheme < Extended
     DECIMAL         = /^[+-]?(\d*)?\.\d*$/
     INTEGER_BASE_2  = /^[+-]?[01]+$/
@@ -14,7 +14,7 @@ module SXP; class Reader
 
     # Escape characters, used in the form `#\newline`. Case is treated
     # insensitively
-    # @see http://people.csail.mit.edu/jaffer/r4rs_9.html#SEC65
+    # @see https:/people.csail.mit.edu/jaffer/r4rs_9.html#SEC65
     CHARACTERS = {
       'newline'   => "\n",
       'space'     => " ",
@@ -26,8 +26,8 @@ module SXP; class Reader
     # @param  [IO, StringIO, String]   input
     # @param  [Hash{Symbol => Object}] options
     # @option options [Symbol]         :version (:r4rs)
-    def initialize(input, options = {}, &block)
-      super(input, {version: :r4rs}.merge(options), &block)
+    def initialize(input, version: :r4rs, **options, &block)
+      super(input, version: version, **options, &block)
     end
 
     ##
@@ -64,8 +64,8 @@ module SXP; class Reader
         when ?d, ?D  then read_integer(10)
         when ?x, ?X  then read_integer(16)
         when ?\\     then read_character
-        when ?;      then skip; read
-        when ?!      then skip_line; read # shebang
+        when ?;      then skip # comment character
+        when ?!      then skip_line; skip # shebang
         else raise Error, "invalid sharp-sign read syntax: ##{char.chr}"
       end
     end
@@ -76,7 +76,7 @@ module SXP; class Reader
     # eroneously read characters back in the input stream
     #
     # @return [String]
-    # @see    http://people.csail.mit.edu/jaffer/r4rs_9.html#SEC65
+    # @see    https:/people.csail.mit.edu/jaffer/r4rs_9.html#SEC65
     def read_character
       lit = read_literal
 

data/lib/sxp/reader/sparql.rb

@@ -1,13 +1,13 @@
 # -*- encoding: utf-8 -*-
-require 'rdf' # @see http://rubygems.org/gems/rdf
+require 'rdf' # @see https:/rubygems.org/gems/rdf
 
 module SXP; class Reader
   ##
   # A SPARQL Syntax Expressions (SSE) parser.
   #
-  # Requires [RDF.rb](http://rdf.rubyforge.org/).
+  # Requires [RDF.rb](https:/rubygems.org/gems/rdf/).
   #
-  # @see http://openjena.org/wiki/SSE
+  # @see https:/openjena.org/wiki/SSE
   class SPARQL < Extended
     # Alias for rdf:type
     A         = /^a$/
@@ -29,7 +29,11 @@ module SXP; class Reader
     # Distinguished variable
     VAR_ID    = /^\?(.*)/
     # Non-distinguished variable
-    ND_VAR   = /^\?(:?\?([0-9]+)?|(\.[0-9]+))/
+    ND_VAR   = /^\?(?:[\?\.])(.*)/
+    # Distinguished existential variable
+    EVAR_ID    = /^\$(.*)/
+    # Non-distinguished existential variable
+    ND_EVAR   = /^\$(?:[\$\.])(.*)/
     # A QName, subject to expansion to URIs using {PREFIX}
     PNAME     = /([^:]*):(.*)/
     
@@ -67,7 +71,7 @@ module SXP; class Reader
     #
     # @param  [IO, StringIO, String]   input
     # @param  [Hash{Symbol => Object}] options
-    def initialize(input, options = {}, &block)
+    def initialize(input, **options, &block)
       super { @prefixes = {}; @bnodes = {}; @list_depth = 0 }
 
       if block_given?
@@ -79,12 +83,12 @@ module SXP; class Reader
     end
 
     ##
-    # Reads SSE Tokens, including {RDF::Literal}, {RDF::URI} and RDF::Node.
+    # Reads SSE Tokens, including `RDF::Literal`, `RDF::URI` and `RDF::Node`.
     #
     # Performs forward reference for prefix and base URI representations and saves in
     # {#base_uri} and {#prefixes} accessors.
     #
-    # Transforms tokens matching a {PNAME} pattern into {RDF::URI} instances if a match is
+    # Transforms tokens matching a {PNAME} pattern into `RDF::URI` instances if a match is
     # found with a previously identified {PREFIX}.
     # @return [Object]
     def read_token
@@ -125,8 +129,6 @@ module SXP; class Reader
             uri = RDF::URI(base.to_s + suffix)
             #STDERR.puts "read_tok lexical uri: #{uri.inspect}"
 
-            # Cause URI to be serialized as a lexical
-            uri.lexical = value
             [:atom, uri]
           else
             tok
@@ -158,7 +160,7 @@ module SXP; class Reader
           {datatype: read_token.last}
         else {}
       end
-      RDF::Literal(value, options)
+      RDF::Literal(value, **options)
     end
 
     ##
@@ -180,9 +182,7 @@ module SXP; class Reader
 
       # If we have a base URI, use that when constructing a new URI
       uri = if self.base_uri && RDF::URI(buffer).relative?
-        u = self.base_uri.join(buffer)
-        u.lexical = "<#{buffer}>" unless u.to_s == buffer  # So that it can be re-serialized properly
-        u
+        self.base_uri.join(buffer)
       else
         RDF::URI(buffer)
       end
@@ -207,7 +207,7 @@ module SXP; class Reader
     #
     # Atoms parsed including `base`, `prefix`, `true`, `false`, numeric, BNodes and variables.
     #
-    # Creates {RDF::Literal}, RDF::Node, or {RDF::Query::Variable} instances where appropriate.
+    # Creates `RDF::Literal`, `RDF::Node`, or `RDF::Query::Variable` instances where appropriate.
     #
     # @return [Object]
     def read_atom
@@ -223,8 +223,10 @@ module SXP; class Reader
         when INTEGER   then RDF::Literal::Integer.new(buffer)
         when BNODE_ID  then @bnodes[$1] ||= RDF::Node($1)
         when BNODE_NEW then RDF::Node.new
-        when ND_VAR   then variable($1, false)
-        when VAR_ID    then variable($1, true)
+        when ND_VAR    then variable($1, distinguished: false)
+        when VAR_ID    then variable($1, distinguished: true)
+        when ND_EVAR   then variable($1, existential: true, distinguished: false)
+        when EVAR_ID   then variable($1, existential: true, distinguished: true)
         else buffer.to_sym
       end
     end
@@ -251,20 +253,16 @@ module SXP; class Reader
     # is a disinguished or non-distinguished variable. Non-distinguished
     # variables are effectively the same as BNodes.
     # @return [RDF::Query::Variable]
-    def variable(id, distinguished = true)
+    def variable(id, distinguished: true, existential: false)
       id = nil if id.to_s.empty?
       
       if id
         @vars ||= {}
         @vars[id] ||= begin
-          v = RDF::Query::Variable.new(id)
-          v.distinguished = distinguished
-          v
+          RDF::Query::Variable.new(id, distinguished: distinguished, existential: existential)
         end
       else
-        v = RDF::Query::Variable.new
-        v.distinguished = distinguished
-        v
+        RDF::Query::Variable.new(distinguished: distinguished, existential: existential)
       end
     end
   end # SPARQL