sxp 0.0.4 → 0.0.5

data/VERSION

@@ -1 +1 @@
-0.0.4
+0.0.5

data/lib/sxp.rb

@@ -1,3 +1,20 @@
+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'
@@ -16,7 +33,7 @@ module SXP
   # @param  [Hash{Symbol => Object}] options
   # @return [Enumerable<Object>]
   def self.read_url(url, options = {})
-    require 'openuri'
+    require 'open-uri'
     open(url.to_s, 'rb', nil, options) { |io| read_all(io, options) }
   end
 
@@ -48,7 +65,7 @@ module SXP
   # @param  [Hash{Symbol => Object}] options
   # @return [Enumerable<Object>]
   def self.read_all(input, options = {})
-    Reader.new(input, options).read_all
+    Reader::Scheme.new(input, options).read_all
   end
 
   ##
@@ -58,7 +75,7 @@ module SXP
   # @param  [Hash{Symbol => Object}] options
   # @return [Object]
   def self.read(input, options = {})
-    Reader.new(input, options).read
+    Reader::Scheme.new(input, options).read
   end
 
   class << self

data/lib/sxp/reader.rb

@@ -2,34 +2,42 @@ module SXP
   ##
   # The base class for S-expression parsers.
   class Reader
-    include Enumerable
+    autoload :Basic,    'sxp/reader/basic'
+    autoload :Extended, 'sxp/reader/extended'
+    autoload :Scheme,   'sxp/reader/scheme'
 
     class Error < StandardError; end
     class EOF < Error; end
 
-    FLOAT           = /^[+-]?(\d*)?\.\d*$/
-    INTEGER_BASE_2  = /^[+-]?[01]+$/
-    INTEGER_BASE_8  = /^[+-]?[0-7]+$/
-    INTEGER_BASE_10 = /^[+-]?\d+$/
-    INTEGER_BASE_16 = /^[+-]?[\da-z]+$/i
-    RATIONAL        = /^([+-]?\d+)\/(\d+)$/
-    ATOM            = /^[^\s()\[\]]+/
+    include Enumerable
 
     # @return [Object]
     attr_reader :input
 
+    # @return [Hash{Symbol => Object}]
+    attr_reader :options
+
     ##
-    # @param  [Object] input
+    # @param  [IO, StringIO, String]   input
     # @param  [Hash{Symbol => Object}] options
-    def initialize(input, options = {})
+    def initialize(input, options = {}, &block)
+      @options = options.dup
+
       case
         when [:getc, :ungetc, :eof?].all? { |x| input.respond_to?(x) }
           @input = input
         when input.respond_to?(:to_str)
-          require 'stringio'
+          require 'stringio' unless defined?(StringIO)
           @input = StringIO.new(input.to_str)
         else
-          raise ArgumentError, "expected an IO or String input stream: #{input.inspect}"
+          raise ArgumentError, "expected an IO or String input stream, but got #{input.inspect}"
+      end
+
+      if block_given?
+        case block.arity
+          when 1 then block.call(self)
+          else self.instance_eval(&block)
+        end
       end
     end
 
@@ -38,7 +46,11 @@ module SXP
     # @yieldparam [Object] object
     # @return [Enumerator]
     def each(&block)
-      block.call(read) if block_given? # FIXME
+      #block_given? ? 
+      #  to_enum
+      #else
+      #  block.call(read)
+      #end
     end
 
     ##
@@ -61,9 +73,9 @@ module SXP
       case token
         when :eof
           throw :eof if options[:eof] == :throw
-          raise EOF, 'unexpected end of input'
+          raise EOF, "unexpected end of input"
         when :list
-          if value == ?( || value == ?[
+          if self.class.const_get(:LPARENS).include?(value)
             read_list
           else
             throw :eol if options[:eol] == :throw # end of list
@@ -75,19 +87,6 @@ module SXP
 
     alias_method :skip, :read
 
-    ##
-    # @return [Object]
-    def read_token
-      case peek_char
-        when nil    then :eof
-        when ?(, ?) then [:list, read_char]
-        when ?[, ?] then [:list, read_char]
-        when ?"     then [:atom, read_string]
-        when ?#     then [:atom, read_sharp]
-        else [:atom, read_atom]
-      end
-    end
-
     ##
     # @param [Array]
     def read_list
@@ -100,23 +99,19 @@ module SXP
 
     ##
     # @return [Object]
-    def read_sharp
-      skip_char # '#'
-      case char = read_char
-        when ?n  then nil
-        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
-        else raise Error, "invalid sharp-sign read syntax: ##{char.chr}"
+    def read_token
+      case peek_char
+        when nil    then :eof
+        else [:atom, read_atom]
       end
     end
 
+    ##
+    # @return [Object]
+    def read_sharp
+      raise NotImplementedError.new("#{self.class}#read_sharp")
+    end
+
     ##
     # @param  [Integer] base
     # @return [Integer]
@@ -131,66 +126,48 @@ module SXP
     ##
     # @return [Object]
     def read_atom
-      case buffer = read_literal
-        when '.'             then buffer.to_sym
-        when FLOAT           then buffer.to_f
-        when INTEGER_BASE_10 then buffer.to_i
-        when RATIONAL        then Rational($1.to_i, $2.to_i)
-        else buffer.to_sym
-      end
+      raise NotImplementedError.new("#{self.class}#read_atom")
     end
 
     ##
     # @return [String]
     def read_string
-      buffer = String.new
-      skip_char # '"'
-      until peek_char == ?"
-        buffer <<
-          case char = read_char
-            when ?\\ then read_character
-            else char
-          end
-      end
-      skip_char # '"'
-      buffer
+      raise NotImplementedError.new("#{self.class}#read_string")
     end
 
     ##
     # @return [String]
     def read_character
-      case char = read_char
-        when ?b then ?\b
-        when ?f then ?\f
-        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
-        else char
-      end
+      raise NotImplementedError.new("#{self.class}#read_character")
     end
 
     ##
     # @return [String]
     def read_literal
-      buffer = String.new
-      buffer << read_char while !eof? && peek_char.chr =~ ATOM
-      buffer
+      raise NotImplementedError.new("#{self.class}#read_literal")
     end
 
+  protected
+
     ##
     # @return [void]
     def skip_comments
       until eof?
         case (char = peek_char).chr
-          when /;/   then skip_line
           when /\s+/ then skip_char
           else break
         end
       end
     end
 
+    ##
+    # @return [void]
+    def skip_line
+      loop do
+        break if eof? || read_char.chr == $/
+      end
+    end
+
     ##
     # @param  [Integer] count
     # @return [String]
@@ -208,21 +185,13 @@ module SXP
       char
     end
 
-    ##
-    # @return [void]
-    def skip_line
-      loop do
-        break if eof? || read_char.chr == $/
-      end
-    end
-
     alias_method :skip_char, :read_char
 
     ##
     # @return [String]
     def peek_char
       char = @input.getc
-      @input.ungetc char unless char.nil?
+      @input.ungetc(char) unless char.nil?
       char
     end
 

data/lib/sxp/reader/basic.rb

@@ -0,0 +1,76 @@
+module SXP; class Reader
+  ##
+  # A basic S-expression parser.
+  class Basic < Reader
+    LPARENS  = [?(].freeze
+    RPARENS  = [?)].freeze
+    ATOM     = /^[^\s()]+/.freeze
+    RATIONAL = /^([+-]?\d+)\/(\d+)$/.freeze
+    DECIMAL  = /^[+-]?(\d*)?\.\d*$/.freeze
+    INTEGER  = /^[+-]?\d+$/.freeze
+
+    ##
+    # @return [Object]
+    def read_token
+      case peek_char
+        when ?(, ?) then [:list, read_char]
+        when ?"     then [:atom, read_string]
+        else super
+      end
+    end
+
+    ##
+    # @return [Object]
+    def read_atom
+      case buffer = read_literal
+        when '.'      then buffer.to_sym
+        when RATIONAL then Rational($1.to_i, $2.to_i)
+        when DECIMAL  then Float(buffer) # FIXME?
+        when INTEGER  then Integer(buffer)
+        else buffer.to_sym
+      end
+    end
+
+    ##
+    # @return [String]
+    def read_string
+      buffer = String.new
+      skip_char # '"'
+      until peek_char == ?"
+        buffer <<
+          case char = read_char
+            when ?\\ then read_character
+            else char
+          end
+      end
+      skip_char # '"'
+      buffer
+    end
+
+    ##
+    # @return [String]
+    def read_character
+      case char = read_char
+        when ?b  then ?\b
+        when ?f  then ?\f
+        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 ?"  then char
+        when ?\\ then char
+        else char
+      end
+    end
+
+    ##
+    # @return [String]
+    def read_literal
+      grammar = self.class.const_get(:ATOM)
+      buffer = String.new
+      buffer << read_char while !eof? && peek_char.chr =~ grammar
+      buffer
+    end
+  end # class Reader
+end; end # class SXP::Reader

data/lib/sxp/reader/extended.rb

@@ -0,0 +1,30 @@
+module SXP; class Reader
+  ##
+  # An extended S-expression parser.
+  class Extended < Basic
+    LPARENS  = [?(, ?[].freeze
+    RPARENS  = [?), ?]].freeze
+    ATOM     = /^[^\s()\[\]]+/.freeze
+
+    ##
+    # @return [Object]
+    def read_token
+      case peek_char
+        when ?[, ?] then [:list, read_char]
+        else super
+      end
+    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 Reader
+end; end # class SXP::Reader

data/lib/sxp/reader/scheme.rb

@@ -0,0 +1,52 @@
+module SXP; class Reader
+  ##
+  # A Scheme-like S-expression parser.
+  class Scheme < Extended
+    DECIMAL         = /^[+-]?(\d*)?\.\d*$/.freeze
+    INTEGER_BASE_2  = /^[+-]?[01]+$/.freeze
+    INTEGER_BASE_8  = /^[+-]?[0-7]+$/.freeze
+    INTEGER_BASE_10 = /^[+-]?\d+$/.freeze
+    INTEGER_BASE_16 = /^[+-]?[\da-z]+$/i.freeze
+    RATIONAL        = /^([+-]?\d+)\/(\d+)$/.freeze
+
+    ##
+    # @return [Object]
+    def read_token
+      case peek_char
+        when ?# then [:atom, read_sharp]
+        else super
+      end
+    end
+
+    ##
+    # @return [Object]
+    def read_atom
+      case buffer = read_literal
+        when '.'             then buffer.to_sym
+        when RATIONAL        then Rational($1.to_i, $2.to_i)
+        when DECIMAL         then Float(buffer)
+        when INTEGER_BASE_10 then Integer(buffer)
+        else buffer.to_sym
+      end
+    end
+
+    ##
+    # @return [Object]
+    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
+        else raise Error, "invalid sharp-sign read syntax: ##{char.chr}"
+      end
+    end
+  end # class Reader
+end; end # class SXP::Reader

data/lib/sxp/version.rb

@@ -2,11 +2,10 @@ module SXP
   module VERSION
     MAJOR = 0
     MINOR = 0
-    TINY  = 4
+    TINY  = 5
     EXTRA = nil
 
-    STRING = [MAJOR, MINOR, TINY].join('.')
-    STRING << ".#{EXTRA}" if EXTRA
+    STRING = [MAJOR, MINOR, TINY, EXTRA].compact.join('.')
 
     ##
     # @return [String]

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 4
-  version: 0.0.4
+  - 5
+  version: 0.0.5
 platform: ruby
 authors: 
 - Arto Bendiken
@@ -14,35 +14,35 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-05-25 00:00:00 +02:00
+date: 2010-06-23 00:00:00 +02:00
 default_executable: sxp2rdf
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: yard
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
         segments: 
-        - 1
-        - 3
         - 0
-        version: 1.3.0
+        - 5
+        - 8
+        version: 0.5.8
   type: :development
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: yard
+  name: rspec
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
         segments: 
+        - 1
+        - 3
         - 0
-        - 5
-        - 4
-        version: 0.5.4
+        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"
@@ -65,6 +65,9 @@ files:
 - lib/sxp/generator.rb
 - lib/sxp/list.rb
 - lib/sxp/pair.rb
+- lib/sxp/reader/basic.rb
+- lib/sxp/reader/extended.rb
+- lib/sxp/reader/scheme.rb
 - lib/sxp/reader.rb
 - lib/sxp/version.rb
 - lib/sxp/writer.rb
@@ -85,8 +88,8 @@ required_ruby_version: !ruby/object:Gem::Requirement
       segments: 
       - 1
       - 8
-      - 2
-      version: 1.8.2
+      - 1
+      version: 1.8.1
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="