sxp 1.1.0 → 1.2.2

data/lib/sxp/extensions.rb

@@ -1,6 +1,95 @@
+# -*- 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. Uses SPARQL-like escaping.
+  #
+  # @return [String]
+  def to_sxp(**options)
+    buffer = ""
+    each_char do |u|
+      buffer << case u.ord
+      when (0x00..0x07) then sprintf("\\u%04X", u.ord)
+      when (0x08)       then '\b'
+      when (0x09)       then '\t'
+      when (0x0A)       then '\n'
+      when (0x0C)       then '\f'
+      when (0x0D)       then '\r'
+      when (0x0E..0x1F) then sprintf("\\u%04X", u.ord)
+      when (0x22)       then '\"'
+      when (0x5C)       then '\\\\'
+      when (0x7F)       then sprintf("\\u%04X", u.ord)
+      else u.chr
+      end
+    end
+    '"' + buffer + '"'
+  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 +99,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 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
+        # Retain stated lexical form if possible
+        valid? ? to_s : object.to_sxp(**options)
+      else
+        text = value.to_sxp
+        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/basic.rb

@@ -35,7 +35,7 @@ module SXP; class Reader
     ##
     # @return [String]
     def read_string
-      buffer = String.new
+      buffer = ""
       skip_char # '"'
       until peek_char == ?" #"
         buffer <<
@@ -57,8 +57,8 @@ module SXP; class Reader
         when ?n  then ?\n
         when ?r  then ?\r
         when ?t  then ?\t
-        when ?u  then read_chars(4).to_i(16).chr
-        when ?U  then read_chars(8).to_i(16).chr
+        when ?u  then read_chars(4).to_i(16).chr(Encoding::UTF_8)
+        when ?U  then read_chars(8).to_i(16).chr(Encoding::UTF_8)
         when ?"  then char #"
         when ?\\ then char
         else char
@@ -69,7 +69,7 @@ module SXP; class Reader
     # @return [String]
     def read_literal
       grammar = self.class.const_get(:ATOM)
-      buffer = String.new
+      buffer = ""
       buffer << read_char while !eof? && peek_char.chr =~ grammar
       buffer
     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'     => " ",
@@ -70,7 +72,7 @@ module SXP; class Reader
     ##
     # @return [Symbol]
     def read_symbol(delimiter = nil)
-      buffer = String.new
+      buffer = ""
       skip_char # '|'
       until delimiter === peek_char
         buffer <<
@@ -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'     => " ",
@@ -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$/
@@ -83,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
@@ -129,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
@@ -173,7 +171,7 @@ module SXP; class Reader
     #
     # @return [RDF::URI]
     def read_rdf_uri
-      buffer = String.new
+      buffer = ""
       skip_char # '<'
       return :< if (char = peek_char).nil? || char.chr !~ ATOM # FIXME: nasty special case for the '< symbol
       return :<= if peek_char.chr.eql?(?=.chr) && read_char    # FIXME: nasty special case for the '<= symbol
@@ -184,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
@@ -211,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

data/lib/sxp.rb

@@ -1,23 +1,8 @@
 require 'rational'
 require 'stringio'
 
-if RUBY_VERSION < '1.8.7'
-  # @see http://rubygems.org/gems/backports
-  begin
-    require 'backports/1.8.7'
-  rescue LoadError
-    begin
-      require 'rubygems'
-      require 'backports/1.8.7'
-    rescue LoadError
-      abort "SXP.rb requires Ruby 1.8.7 or the Backports gem (hint: `gem install backports')."
-    end
-  end
-end
-
 require 'sxp/version'
 require 'sxp/extensions'
-require 'sxp/writer'
 
 module SXP
   autoload :Pair,      'sxp/pair'