sxp 0.0.5 → 0.0.6

data/README

@@ -1,38 +1,27 @@
-SXP.rb: SXP for Ruby
-====================
+SXP.rb: S-Expressions for Ruby
+==============================
 
-This is the Ruby reference implementation of the SXP data interchange
-format.
+This is a Ruby implementation of a universal [S-expression][] parser.
 
 * <http://sxp.rubyforge.org/>
 * <http://github.com/bendiken/sxp-ruby>
 
-### About SXP
-
-SXP is a data interchange format based on S-expressions, the simplest and
-most versatile known means of representing complex data structures such as
-lists, trees and graphs.
-
-* <http://sxp.cc/>
-* <http://en.wikipedia.org/wiki/S-expression>
-
 Features
 --------
 
-* Parses S-expressions in SXP format.
+* Parses S-expressions in universal, [Scheme][], [Common Lisp][], or
+  [SPARQL][] syntax.
 * Adds a `#to_sxp` method to Ruby objects.
+* Compatible with Ruby 1.8.7+, Ruby 1.9.x, and JRuby 1.4/1.5.
 
 Examples
 --------
 
     require 'sxp'
 
-### Parsing S-expressions
-
-    SXP.read "(+ 1 2)"
-    
-    => [:+, 1, 2]
+### Parsing S-expressions using universal syntax
 
+    SXP.read "(* 6 7)"  #=> [:*, 6, 7]
 
     SXP.read <<-EOF
       (define (fact n)
@@ -41,16 +30,43 @@ Examples
             (* n (fact (- n 1)))))
     EOF
     
-    => [:define, [:fact, :n],
-         [:if, [:"=", :n, 0],
-               1,
-               [:*, :n, [:fact, [:-, :n, 1]]]]]
+    #=> [:define, [:fact, :n],
+          [:if, [:"=", :n, 0],
+                1,
+                [:*, :n, [:fact, [:-, :n, 1]]]]]
+
+### Parsing S-expressions using Scheme syntax
+
+    SXP::Reader::Scheme.read %q((and #t #f))             #=> [:and, true, false]
+
+### Parsing S-expressions using Common Lisp syntax
+
+    SXP::Reader::CommonLisp.read %q((or t nil))          #=> [:or, true, nil]
+
+### Parsing S-expressions using SPARQL syntax
+
+    SXP::Reader::SPARQL.read %q((base <http://ar.to/>))  #=> [:base, RDF::URI('http://ar.to/')]
 
 Documentation
 -------------
 
 * <http://sxp.rubyforge.org/>
 
+Dependencies
+------------
+
+* [Ruby](http://ruby-lang.org/) (>= 1.8.7) or (>= 1.8.1 with [Backports][])
+* [RDF.rb](http://rubygems.org/gems/rdf) (>= 0.2.0), only needed for SPARQL
+  S-expressions
+
+Installation
+------------
+
+The recommended installation method is via [RubyGems](http://rubygems.org/).
+To install the latest official release of the SXP.rb gem, do:
+
+    % [sudo] gem install sxp
+
 Download
 --------
 
@@ -63,21 +79,13 @@ as follows:
 
     % wget http://github.com/bendiken/sxp-ruby/tarball/master
 
-Installation
-------------
-
-The recommended installation method is via RubyGems. To install the latest
-official release from Gemcutter, do:
-
-    % [sudo] gem install sxp
-
 Resources
 ---------
 
 * <http://sxp.rubyforge.org/>
 * <http://github.com/bendiken/sxp>
 * <http://github.com/bendiken/sxp-ruby>
-* <http://gemcutter.org/gems/sxp>
+* <http://rubygems.org/gems/sxp>
 * <http://rubyforge.org/projects/sxp/>
 * <http://raa.ruby-lang.org/project/sxp>
 
@@ -91,3 +99,9 @@ License
 
 SXP.rb is free and unencumbered public domain software. For more
 information, see <http://unlicense.org/> or the accompanying UNLICENSE file.
+
+[S-expression]: http://en.wikipedia.org/wiki/S-expression
+[Scheme]:       http://scheme.info/
+[Common Lisp]:  http://en.wikipedia.org/wiki/Common_Lisp
+[SPARQL]:       http://openjena.org/wiki/SSE
+[Backports]:    http://rubygems.org/gems/backports

data/VERSION

@@ -1 +1 @@
-0.0.5
+0.0.6

data/lib/sxp/reader/basic.rb

@@ -14,7 +14,7 @@ module SXP; class Reader
     def read_token
       case peek_char
         when ?(, ?) then [:list, read_char]
-        when ?"     then [:atom, read_string]
+        when ?"     then [:atom, read_string] #"
         else super
       end
     end
@@ -36,7 +36,7 @@ module SXP; class Reader
     def read_string
       buffer = String.new
       skip_char # '"'
-      until peek_char == ?"
+      until peek_char == ?" #"
         buffer <<
           case char = read_char
             when ?\\ then read_character
@@ -58,7 +58,7 @@ module SXP; class Reader
         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 ?"  then char
+        when ?"  then char #"
         when ?\\ then char
         else char
       end
@@ -72,5 +72,5 @@ module SXP; class Reader
       buffer << read_char while !eof? && peek_char.chr =~ grammar
       buffer
     end
-  end # class Reader
+  end # class Basic
 end; end # class SXP::Reader

data/lib/sxp/reader/common_lisp.rb

@@ -0,0 +1,127 @@
+module SXP; class Reader
+  ##
+  # A Common Lisp S-expressions parser.
+  #
+  # @see http://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node14.html
+  class CommonLisp < Basic
+    OPTIONS         = {:nil => nil, :t => true, :quote => :quote, :function => :function}
+
+    DECIMAL         = /^[+-]?(\d*)?\.\d*$/
+    INTEGER_BASE_2  = /^[+-]?[01]+$/
+    INTEGER_BASE_8  = /^[+-]?[0-7]+$/
+    INTEGER_BASE_10 = /^[+-]?\d+$/
+    INTEGER_BASE_16 = /^[+-]?[\da-z]+$/i
+    RATIONAL        = /^([+-]?\d+)\/(\d+)$/
+
+    # @see http://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node22.html
+    CHARACTERS = {
+      'newline'   => "\n",
+      'space'     => " ",
+      'backspace' => "\b",   # \010 BS
+      'tab'       => "\t",   # \011 HT
+      'linefeed'  => "\n",   # \012 LF
+      'page'      => "\f",   # \014 FF
+      'return'    => "\r",   # \015 CR
+      'rubout'    => "\x7F", # \177 DEL
+    }
+
+    ##
+    # Initializes the reader.
+    #
+    # @param  [IO, StringIO, String]   input
+    # @param  [Hash{Symbol => Object}] options
+    # @option options [Object]         :nil      (nil)
+    # @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)
+    end
+
+    ##
+    # @return [Object]
+    def read_token
+      case peek_char
+        when ?#  then [:atom, read_sharp]
+        when ?|  then [:atom, read_symbol(?|)]
+        when ?'  then [:atom, read_quote]
+        else super
+      end
+    end
+
+    ##
+    # @return [Object]
+    def read_sharp
+      skip_char # '#'
+      case char = read_char
+        when ?b, ?B  then read_integer(2)
+        when ?o, ?O  then read_integer(8)
+        when ?x, ?X  then read_integer(16)
+        when ?\\     then read_character
+        when ?(      then read_vector
+        when ?'      then read_function
+        else raise Error, "invalid sharp-sign read syntax: ##{char.chr}"
+      end
+    end
+
+    ##
+    # @return [Symbol]
+    def read_symbol(delimiter = nil)
+      buffer = String.new
+      skip_char # '|'
+      until delimiter === peek_char
+        buffer <<
+          case char = read_char
+            when ?\\ then read_character
+            else char
+          end
+      end
+      skip_char # '|'
+      buffer.to_sym
+    end
+
+    ##
+    # Reads `#(1 2 3)` forms.
+    #
+    # @return [Array]
+    def read_vector
+      raise NotImplementedError, "#{self.class}#read_vector" # TODO
+    end
+
+    ##
+    # Reads `'foobar` forms.
+    #
+    # @return [Array]
+    def read_quote
+      skip_char # "'"
+      [options[:quote] || :quote, read]
+    end
+
+    ##
+    # Reads `#'mapcar` forms.
+    #
+    # @return [Array]
+    def read_function
+      [options[:function] || :function, read]
+    end
+
+    ##
+    # @return [String]
+    # @see    http://www.cs.cmu.edu/Groups/AI/html/cltl/clm/node22.html
+    def read_character
+      super
+    end
+
+    ##
+    # @return [void]
+    def skip_comments
+      until eof?
+        case (char = peek_char).chr
+          when /\s+/ then skip_char
+          when /;/   then skip_line
+          else break
+        end
+      end
+    end
+  end # class CommonLisp
+end; end # class SXP::Reader

data/lib/sxp/reader/extended.rb

@@ -26,5 +26,5 @@ module SXP; class Reader
         end
       end
     end
-  end # class Reader
+  end # class Extended
 end; end # class SXP::Reader

data/lib/sxp/reader/scheme.rb

@@ -1,6 +1,8 @@
 module SXP; class Reader
   ##
-  # A Scheme-like S-expression parser.
+  # A Scheme R4RS S-expressions parser.
+  #
+  # @see http://people.csail.mit.edu/jaffer/r4rs_9.html#SEC65
   class Scheme < Extended
     DECIMAL         = /^[+-]?(\d*)?\.\d*$/.freeze
     INTEGER_BASE_2  = /^[+-]?[01]+$/.freeze
@@ -9,6 +11,16 @@ module SXP; class Reader
     INTEGER_BASE_16 = /^[+-]?[\da-z]+$/i.freeze
     RATIONAL        = /^([+-]?\d+)\/(\d+)$/.freeze
 
+    ##
+    # Initializes the 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)
+    end
+
     ##
     # @return [Object]
     def read_token
@@ -35,18 +47,18 @@ module SXP; class Reader
     def read_sharp
       skip_char # '#'
       case char = read_char
-        when ?n  then nil    # not in Scheme
-        when ?f  then false
-        when ?t  then true
-        when ?b  then read_integer(2)
-        when ?o  then read_integer(8)
-        when ?d  then read_integer(10)
-        when ?x  then read_integer(16)
-        when ?\\ then read_character
-        when ?;  then skip; read
-        when ?!  then skip_line; read # shebang
+        when ?n, ?N  then nil    # not in Scheme per se
+        when ?f, ?F  then false
+        when ?t, ?T  then true
+        when ?b, ?B  then read_integer(2)
+        when ?o, ?O  then read_integer(8)
+        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
         else raise Error, "invalid sharp-sign read syntax: ##{char.chr}"
       end
     end
-  end # class Reader
+  end # class Scheme
 end; end # class SXP::Reader

data/lib/sxp/reader/sparql.rb

@@ -0,0 +1,80 @@
+require 'rdf' # @see http://rubygems.org/gems/rdf
+
+module SXP; class Reader
+  ##
+  # A SPARQL Syntax Expressions (SSE) parser.
+  #
+  # Requires [RDF.rb](http://rdf.rubyforge.org/).
+  #
+  # @see http://openjena.org/wiki/SSE
+  class SPARQL < Extended
+    BNODE_ID  = /^_:([A-Za-z][A-Za-z0-9]*)/.freeze # FIXME
+    BNODE_NEW = /^_:$/.freeze
+    VARIABLE = /^\?([A-Za-z][A-Za-z0-9]*)/.freeze # FIXME
+    URIREF   = /^<([^>]+)>/.freeze
+
+    ##
+    # @return [Object]
+    def read_token
+      case peek_char
+        when ?" then [:atom, read_rdf_literal] # "
+        when ?< then [:atom, read_rdf_uri]
+        else super
+      end
+    end
+
+    ##
+    # @return [RDF::Literal]
+    def read_rdf_literal
+      value   = read_string
+      options = case peek_char
+        when ?@
+          skip_char # '@'
+          {:language => read_atom}
+        when ?^
+          2.times { skip_char } # '^^'
+          {:datatype => read_rdf_uri} # TODO: support prefixed names
+        else {}
+      end
+      RDF::Literal.new(value, options)
+    end
+
+    ##
+    # @return [RDF::URI]
+    def read_rdf_uri
+      buffer = String.new
+      skip_char # '<'
+      until peek_char == ?>
+        buffer << read_char # TODO: unescaping
+      end
+      skip_char # '>'
+      RDF::URI.new(buffer)
+    end
+
+    ##
+    # @return [Object]
+    def read_atom
+      case buffer = read_literal
+        when '.'       then buffer.to_sym
+        when INTEGER   then RDF::Literal.new(Integer(buffer))
+        when BNODE_ID  then RDF::Node.new($1)
+        when BNODE_NEW then RDF::Node.new
+        when VARIABLE  then RDF::Query::Variable.new($1)
+        else buffer.to_sym
+      end
+    end
+
+    ##
+    # @return [void]
+    def skip_comments
+      until eof?
+        case (char = peek_char).chr
+          when /\s+/ then skip_char
+          when /;/   then skip_line
+          when /#/   then skip_line
+          else break
+        end
+      end
+    end
+  end # class SPARQL
+end; end # class SXP::Reader

data/lib/sxp/reader.rb

@@ -2,22 +2,73 @@ module SXP
   ##
   # The base class for S-expression parsers.
   class Reader
-    autoload :Basic,    'sxp/reader/basic'
-    autoload :Extended, 'sxp/reader/extended'
-    autoload :Scheme,   'sxp/reader/scheme'
+    autoload :Basic,      'sxp/reader/basic'
+    autoload :Extended,   'sxp/reader/extended'
+    autoload :Scheme,     'sxp/reader/scheme'
+    autoload :CommonLisp, 'sxp/reader/common_lisp'
+    autoload :SPARQL,     'sxp/reader/sparql'
 
     class Error < StandardError; end
     class EOF < Error; end
 
     include Enumerable
 
-    # @return [Object]
-    attr_reader :input
+    ##
+    # Reads all S-expressions from a given input URL using the HTTP or FTP
+    # protocols.
+    #
+    # @param  [String, #to_s]          url
+    # @param  [Hash{Symbol => Object}] options
+    # @return [Enumerable<Object>]
+    def self.read_url(url, options = {})
+      require 'open-uri'
+      open(url.to_s, 'rb', nil, options) { |io| read_all(io, options) }
+    end
 
-    # @return [Hash{Symbol => Object}]
-    attr_reader :options
+    ##
+    # Reads all S-expressions from the given input files.
+    #
+    # @param  [Enumerable<String>]     filenames
+    # @param  [Hash{Symbol => Object}] options
+    # @return [Enumerable<Object>]
+    def self.read_files(*filenames)
+      options = filenames.last.is_a?(Hash) ? filenames.pop : {}
+      filenames.map { |filename| read_file(filename, options) }.inject { |sxps, sxp| sxps + sxp }
+    end
+
+    ##
+    # Reads all S-expressions from a given input file.
+    #
+    # @param  [String, #to_s]          filename
+    # @param  [Hash{Symbol => Object}] options
+    # @return [Enumerable<Object>]
+    def self.read_file(filename, options = {})
+      File.open(filename.to_s, 'rb') { |io| read_all(io, options) }
+    end
+
+    ##
+    # Reads all S-expressions from the given input stream.
+    #
+    # @param  [IO, StringIO, String]   input
+    # @param  [Hash{Symbol => Object}] options
+    # @return [Enumerable<Object>]
+    def self.read_all(input, options = {})
+      self.new(input, options).read_all
+    end
 
     ##
+    # Reads one S-expression from the given input stream.
+    #
+    # @param  [IO, StringIO, String]   input
+    # @param  [Hash{Symbol => Object}] options
+    # @return [Object]
+    def self.read(input, options = {})
+      self.new(input, options).read
+    end
+
+    ##
+    # Initializes the reader.
+    #
     # @param  [IO, StringIO, String]   input
     # @param  [Hash{Symbol => Object}] options
     def initialize(input, options = {}, &block)
@@ -28,7 +79,8 @@ module SXP
           @input = input
         when input.respond_to?(:to_str)
           require 'stringio' unless defined?(StringIO)
-          @input = StringIO.new(input.to_str)
+          # NOTE: StringIO#ungetc mutates the string, so we use #dup to take a copy.
+          @input = StringIO.new(input.to_str.dup)
         else
           raise ArgumentError, "expected an IO or String input stream, but got #{input.inspect}"
       end
@@ -41,16 +93,22 @@ module SXP
       end
     end
 
+    # @return [Object]
+    attr_reader :input
+
+    # @return [Hash]
+    attr_reader :options
+
     ##
     # @yield  [object]
     # @yieldparam [Object] object
     # @return [Enumerator]
     def each(&block)
-      #block_given? ? 
-      #  to_enum
-      #else
-      #  block.call(read)
-      #end
+      unless block_given?
+        to_enum
+      else
+        read_all.each(&block) # TODO: lazy reading
+      end
     end
 
     ##

data/lib/sxp/version.rb

@@ -2,7 +2,7 @@ module SXP
   module VERSION
     MAJOR = 0
     MINOR = 0
-    TINY  = 5
+    TINY  = 6
     EXTRA = nil
 
     STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.')

data/lib/sxp.rb

@@ -26,15 +26,14 @@ module SXP
   autoload :Reader,    'sxp/reader'
 
   ##
-  # Reads all S-expressions from a given input URI using the HTTP or FTP
+  # Reads all S-expressions from a given input URL using the HTTP or FTP
   # protocols.
   #
   # @param  [String, #to_s]          url
   # @param  [Hash{Symbol => Object}] options
   # @return [Enumerable<Object>]
   def self.read_url(url, options = {})
-    require 'open-uri'
-    open(url.to_s, 'rb', nil, options) { |io| read_all(io, options) }
+    Reader::Scheme.read_url(url, options)
   end
 
   ##
@@ -44,8 +43,7 @@ module SXP
   # @param  [Hash{Symbol => Object}] options
   # @return [Enumerable<Object>]
   def self.read_files(*filenames)
-    options = filenames.last.is_a?(Hash) ? filenames.pop : {}
-    filenames.map { |filename| read_file(filename, options) }.inject { |sxps, sxp| sxps + sxp }
+    Reader::Scheme.read_files(*filenames)
   end
 
   ##
@@ -55,7 +53,7 @@ module SXP
   # @param  [Hash{Symbol => Object}] options
   # @return [Enumerable<Object>]
   def self.read_file(filename, options = {})
-    File.open(filename.to_s, 'rb') { |io| read_all(io, options) }
+    Reader::Scheme.read_file(filename, options)
   end
 
   ##
@@ -65,7 +63,7 @@ module SXP
   # @param  [Hash{Symbol => Object}] options
   # @return [Enumerable<Object>]
   def self.read_all(input, options = {})
-    Reader::Scheme.new(input, options).read_all
+    Reader::Scheme.read_all(input, options)
   end
 
   ##
@@ -75,7 +73,7 @@ module SXP
   # @param  [Hash{Symbol => Object}] options
   # @return [Object]
   def self.read(input, options = {})
-    Reader::Scheme.new(input, options).read
+    Reader::Scheme.read(input, options)
   end
 
   class << self

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 5
-  version: 0.0.5
+  - 6
+  version: 0.0.6
 platform: ruby
 authors: 
 - Arto Bendiken
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-23 00:00:00 +02:00
+date: 2010-08-25 00:00:00 +02:00
 default_executable: sxp2rdf
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -45,7 +45,7 @@ dependencies:
         version: 1.3.0
   type: :development
   version_requirements: *id002
-description: "    SXP is a data interchange format based on S-expressions, the simplest and\n    most versatile known means of representing complex data structures such as\n    lists, trees and graphs.\n"
+description: A pure-Ruby implementation of a universal S-expression parser.
 email: arto.bendiken@gmail.com
 executables: 
 - sxp2rdf
@@ -66,8 +66,10 @@ files:
 - lib/sxp/list.rb
 - lib/sxp/pair.rb
 - lib/sxp/reader/basic.rb
+- lib/sxp/reader/common_lisp.rb
 - lib/sxp/reader/extended.rb
 - lib/sxp/reader/scheme.rb
+- lib/sxp/reader/sparql.rb
 - lib/sxp/reader.rb
 - lib/sxp/version.rb
 - lib/sxp/writer.rb
@@ -103,6 +105,6 @@ rubyforge_project: sxp
 rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: A pure-Ruby implementation of the SXP data interchange format.
+summary: A pure-Ruby implementation of a universal S-expression parser.
 test_files: []