sxp 0.0.1

data/AUTHORS

@@ -0,0 +1 @@
+* Arto Bendiken <arto.bendiken@gmail.com> (Lead developer)

data/README

@@ -0,0 +1,93 @@
+SXP.rb: SXP for Ruby
+====================
+
+This is the Ruby reference implementation of the SXP data interchange
+format.
+
+* <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.
+* Adds a `#to_sxp` method to Ruby objects.
+
+Examples
+--------
+
+    require 'sxp'
+
+### Parsing S-expressions
+
+    SXP.read "(+ 1 2)"
+    
+    => [:+, 1, 2]
+
+
+    SXP.read <<-EOF
+      (define (fact n)
+        (if (= n 0)
+            1
+            (* n (fact (- n 1)))))
+    EOF
+    
+    => [:define, [:fact, :n],
+         [:if, [:"=", :n, 0],
+               1,
+               [:*, :n, [:fact, [:-, :n, 1]]]]]
+
+Documentation
+-------------
+
+* <http://sxp.rubyforge.org/>
+
+Download
+--------
+
+To get a local working copy of the development repository, do:
+
+    % git clone git://github.com/bendiken/sxp-ruby.git
+
+Alternatively, you can download the latest development version as a tarball
+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://rubyforge.org/projects/sxp/>
+* <http://raa.ruby-lang.org/project/sxp>
+
+Author
+------
+
+* [Arto Bendiken](mailto:arto.bendiken@gmail.com) - <http://ar.to/>
+
+License
+-------
+
+SXP.rb is free and unencumbered public domain software. For more
+information, see <http://unlicense.org/> or the accompanying UNLICENSE file.

data/Rakefile

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), 'lib')))
+require 'rubygems'
+begin
+  require 'rakefile' # http://github.com/bendiken/rakefile
+rescue LoadError => e
+end
+require 'sxp'

data/UNLICENSE

@@ -0,0 +1,24 @@
+This is free and unencumbered software released into the public domain.
+
+Anyone is free to copy, modify, publish, use, compile, sell, or
+distribute this software, either in source code form or as a compiled
+binary, for any purpose, commercial or non-commercial, and by any
+means.
+
+In jurisdictions that recognize copyright laws, the author or authors
+of this software dedicate any and all copyright interest in the
+software to the public domain. We make this dedication for the benefit
+of the public at large and to the detriment of our heirs and
+successors. We intend this dedication to be an overt act of
+relinquishment in perpetuity of all present and future rights to this
+software under copyright law.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
+For more information, please refer to <http://unlicense.org/>

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/bin/sxp2json

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby -rubygems
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+require 'sxp'
+
+abort "Usage: #{File.basename($0)} input.sxp > output.json" if ARGV.empty?

data/bin/sxp2rdf

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby -rubygems
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+require 'sxp'
+
+abort "Usage: #{File.basename($0)} input.sxp > output.rdf" if ARGV.empty?

data/bin/sxp2xml

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby -rubygems
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+require 'sxp'
+
+abort "Usage: #{File.basename($0)} input.sxp > output.xml" if ARGV.empty?

data/bin/sxp2yaml

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby -rubygems
+$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib')))
+require 'sxp'
+
+abort "Usage: #{File.basename($0)} input.sxp > output.yaml" if ARGV.empty?

data/lib/sxp/extensions.rb

@@ -0,0 +1,7 @@
+class Symbol
+  ##
+  # Returns +true+ if this is a keyword symbol.
+  def keyword?
+    to_s[-1] == ?:
+  end
+end

data/lib/sxp/generator.rb

@@ -0,0 +1,62 @@
+module SXP
+  class Generator
+    def self.string(*sxps)
+      require 'stringio' unless defined?(StringIO)
+      write(StringIO.new, *sxps).instance_variable_get('@buffer').string
+    end
+
+    def self.print(*sxps)
+      write($stdout, *sxps)
+    end
+
+    def self.write(out, *sxps)
+      generator = self.new(out)
+      sxps.each do |sxp|
+        generator.send((op = sxp.shift).to_sym, *sxp)
+      end
+      generator
+    end
+
+    def initialize(buffer)
+      @output = [@buffer = buffer]
+      @indent = 0
+    end
+
+    protected
+
+      def emit(text, options = {})
+        if out = @output.last
+          out.print(' ' * (indent * 2)) if options[:indent]
+          out.print(text)
+        end
+      end
+
+      def captured(&block)
+        require 'stringio' unless defined?(StringIO)
+        begin
+          @output.push(buffer = StringIO.new)
+          block.call
+        ensure
+          @output.pop
+        end
+        buffer.string
+      end
+
+      def indented(&block)
+        begin
+          increase_indent!
+          block.call
+        ensure
+          decrease_indent!
+        end
+      end
+
+      def increase_indent!()
+        @indent += 1
+      end
+
+      def decrease_indent!()
+        @indent -= 1
+      end
+  end
+end

data/lib/sxp/list.rb

@@ -0,0 +1,327 @@
+require 'sxp/pair'
+
+module SXP
+  class List < Pair
+    include Enumerable
+
+    def self.[](*elements)
+      self.new(elements)
+    end
+
+    def initialize(elements = [], &block)
+      @pair = nil
+      unshift(*elements) unless elements.empty?
+      block.call(self) if block_given?
+    end
+
+    def inspect
+      "(" << map { |value| value.inspect }.join(' ') << ")"
+    end
+
+    def head() first end
+    def tail() rest end
+
+    def rest
+      empty? ? false : @pair.tail
+    end
+
+    # Array interface
+
+    def &(other)
+      self.class.new(self.to_a & other.to_a)
+    end
+
+    def |(other)
+      self.class.new(self.to_a | other.to_a)
+    end
+
+    def *(times)
+      result = (self.to_a * times)
+      result.is_a?(Array) ? self.class.new(result) : result
+    end
+
+    def +(other)
+      self.class.new(self.to_a + other.to_a)
+    end
+
+    def -(other)
+      self.class.new(self.to_a - other.to_a)
+    end
+
+    def <<(object)
+      push(object)
+      self
+    end
+
+    def <=>(other)
+      to_a <=> other.to_a
+    end
+
+    def ==(other)
+      case other
+        when List
+          self.length == other.length && to_a == other.to_a
+        when other.respond_to?(:to_list)
+          other.to_list == self
+        else
+          false
+      end
+    end
+
+    def [](*args)
+      result = to_a[*args]
+      result.is_a?(Array) ? self.class.new(result) : result # FIXME
+    end
+
+    def []=(*args)
+      raise NotImplementedError # TODO
+    end
+
+    def assoc(object)
+      raise NotImplementedError # TODO
+    end
+
+    def at(index)
+      to_a.at(index)
+    end
+
+    def clear
+      @pair = nil
+      self
+    end
+
+    def collect!(&block)
+      raise NotImplementedError # TODO
+    end
+
+    def compact
+      self.class.new(to_a.compact)
+    end
+
+    def compact!
+      raise NotImplementedError # TODO
+    end
+
+    def concat(other)
+      raise NotImplementedError # TODO
+    end
+
+    def delete(object, &block)
+      raise NotImplementedError # TODO
+    end
+
+    def delete_at(index)
+      raise NotImplementedError # TODO
+    end
+
+    def delete_if(&block)
+      raise NotImplementedError # TODO
+    end
+
+    def each(&block)
+      pair = @pair
+      while pair != nil
+        block.call(pair.head)
+        pair = pair.tail
+      end
+      self
+    end
+
+    def each_index(&block)
+      index = 0
+      each do
+        block.call(index)
+        index += 1
+      end
+      self
+    end
+
+    def empty?
+      @pair.nil?
+    end
+
+    def eql?(other)
+      case other
+        when self then true
+        when List
+          self.length == other.length && to_a.eql?(other.to_a)
+      end
+    end
+
+    def fetch(*args, &block)
+      to_a.fetch(*args, &block)
+    end
+
+    def fill(*args, &block)
+      raise NotImplementedError # TODO
+    end
+
+    def first(count = nil)
+      case
+        when count.nil?
+          @pair.head unless empty?
+        when count == 1
+          empty? ? [] : [first]
+        when count > 1
+          empty? ? [] : to_a.first(count)
+      end
+    end
+
+    def flatten
+      raise NotImplementedError # TODO
+    end
+
+    def flatten!
+      raise NotImplementedError # TODO
+    end
+
+    def include?(object)
+      to_a.include?(object)
+    end
+
+    def index(object)
+      to_a.index(object)
+    end
+
+    def insert(index, *objects)
+      raise NotImplementedError # TODO
+    end
+
+    def join(separator = $,)
+      to_a.join(separator)
+    end
+
+    def last(count = nil)
+      case
+        when count.nil?
+          to_a.last
+        else
+          to_a.last(count)
+      end
+    end
+
+    def length
+      @length ||= to_a.length
+    end
+
+    def map!(&block)
+      collect!(&block)
+    end
+
+    def nitems
+      to_a.nitems
+    end
+
+    def pack(template)
+      to_a.pack(template)
+    end
+
+    def pop
+      raise NotImplementedError # TODO
+    end
+
+    def push(*objects)
+      raise NotImplementedError # TODO
+    end
+
+    def rassoc(key)
+      raise NotImplementedError # TODO
+    end
+
+    def reject!(&block)
+      raise NotImplementedError # TODO
+    end
+
+    def replace(other_list)
+      case other_list
+        when Pair
+          @pair = other_list
+        when List
+          @pair = other_list.to_pair
+        when Array
+          @pair = nil
+          unshift(*other_list)
+        else
+          # TODO
+      end
+      self
+    end
+
+    def reverse
+      self.class.new(to_a.reverse)
+    end
+
+    def reverse!
+      raise NotImplementedError # TODO
+    end
+
+    def reverse_each(&block)
+      to_a.reverse_each(&block)
+      self
+    end
+
+    def rindex(object)
+      to_a.rindex(object)
+    end
+
+    def shift
+      raise NotImplementedError # TODO
+    end
+
+    def size
+      length
+    end
+
+    def slice(*args)
+      self[*args]
+    end
+
+    def slice!(*args)
+      raise NotImplementedError # TODO
+    end
+
+    def sort(&block)
+      (array = to_a).sort!(&block)
+      self.class.new(array)
+    end
+
+    def sort!
+      raise NotImplementedError # TODO
+    end
+
+    def to_list
+      self
+    end
+
+    def to_pair
+      @pair
+    end
+
+    def to_s
+      join
+    end
+
+    def transpose
+      self.class.new(to_a.transpose)
+    end
+
+    def uniq
+      self.class.new(to_a.uniq)
+    end
+
+    def uniq!
+      raise NotImplementedError # TODO
+    end
+
+    def unshift(*objects)
+      objects.reverse_each do |object|
+        @pair = Pair.new(object, @pair)
+      end
+      self
+    end
+
+    def values_at(*selector)
+      self.class.new(to_a.values_at(*selector))
+    end
+  end
+end

data/lib/sxp/pair.rb

@@ -0,0 +1,39 @@
+module SXP
+  class Pair
+    attr_accessor :head
+    attr_accessor :tail
+
+    def initialize(head = nil, tail = nil)
+      @head, @tail = head, tail
+    end
+
+    def inspect
+      case
+        when tail.nil?
+          "(#{head.inspect})"
+        else
+          "(#{head.inspect} . #{tail.inspect})"
+      end
+    end
+
+    def empty?
+      head.nil? && tail.nil?
+    end
+
+    ##
+    # @see http://srfi.schemers.org/srfi-1/srfi-1.html#ImproperLists
+    def dotted?
+      !proper?
+    end
+
+    ##
+    # @see http://srfi.schemers.org/srfi-1/srfi-1.html#ImproperLists
+    def proper?
+      tail.nil? || tail.is_a?(Pair)
+    end
+
+    def to_a
+      [head, tail]
+    end
+  end
+end

data/lib/sxp/reader.rb

@@ -0,0 +1,210 @@
+module SXP
+
+  # Reads one S-expression from the given input stream.
+  def self.read(input)
+    Reader.new(input).read
+  end
+
+  # Reads all S-expressions from the given input stream.
+  def self.read_all(input)
+    Reader.new(input).read_all
+  end
+
+  # Reads all S-expressions from the given input files.
+  def self.read_files(*filenames)
+    filenames.map { |filename| read_file(filename) }.inject { |sxps, sxp| sxps + sxp }
+  end
+
+  # Reads all S-expressions from a given input file.
+  def self.read_file(filename)
+    File.open(filename, 'rb') { |io| read_all(io) }
+  end
+
+  # Reads all S-expressions from a given input URI using the HTTP or FTP protocols.
+  def self.read_uri(uri, options = {})
+    require 'openuri'
+    open(uri, 'rb', nil, options) { |io| read_all(io) }
+  end
+
+  class << self
+    alias_method :parse,       :read
+    alias_method :parse_all,   :read_all
+    alias_method :parse_files, :read_files
+    alias_method :parse_file,  :read_file
+    alias_method :parse_uri,   :read_uri
+  end
+
+  class Reader
+    include Enumerable
+
+    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()]+/
+
+    attr_reader :input
+
+    def initialize(input)
+      case
+        when [:getc, :ungetc, :eof?].all? { |x| input.respond_to?(x) }
+          @input = input
+        when input.respond_to?(:to_str)
+          require 'stringio'
+          @input = StringIO.new(input.to_str)
+        else
+          raise ArgumentError, "expected an IO or String input stream: #{input.inspect}"
+      end
+    end
+
+    def each(&block)
+      block.call(read)
+    end
+
+    def read_all(options = {})
+      list = []
+      catch (:eof) { list << read(:eof => :throw, *options) until eof? }
+      list
+    end
+
+    def read(options = {})
+      token, value = read_token
+      case token
+        when :eof
+          throw :eof if options[:eof] == :throw
+          raise EOF, 'unexpected end of input'
+        when :list
+          if value == ?(
+            read_list
+          else
+            throw :eol if options[:eol] == :throw
+            raise Error, 'unexpected list terminator: ?)'
+          end
+        else value
+      end
+    end
+
+    alias skip read
+
+    def read_token
+      skip_comments
+      case peek_char
+        when nil then :eof
+        when ?(, ?) then [:list, read_char]
+        when ?# then [:atom, read_sharp]
+        when ?" then [:atom, read_string]
+        else [:atom, read_atom]
+      end
+    end
+
+    def read_list
+      list = []
+      catch (:eol) { list << read(:eol => :throw) while true }
+      list
+    end
+
+    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
+        else raise Error, "invalid sharp-sign read syntax: ##{char.chr}"
+      end
+    end
+
+    def read_integer(base = 10)
+      case buffer = read_literal
+        when self.class.const_get(:"INTEGER_BASE_#{base}")
+          buffer.to_i(base)
+        else raise Error, "illegal base-#{base} number syntax: #{buffer}"
+      end
+    end
+
+    def read_atom
+      case buffer = read_literal
+        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
+    end
+
+    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
+
+    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
+    end
+
+    def read_literal
+      buffer = String.new
+      buffer << read_char while !eof? && peek_char.chr =~ ATOM
+      buffer
+    end
+
+    def skip_comments
+      until eof?
+        case (char = peek_char).chr
+          when /;/ then loop { break if eof? || read_char.chr == $/ }
+          when /\s+/ then skip_char
+          else break
+        end
+      end
+    end
+
+    def read_chars(count = 1)
+      buffer = ''
+      count.times { buffer << read_char.chr }
+      buffer
+    end
+
+    def read_char
+      char = @input.getc
+      raise EOF, 'unexpected end of input' if char.nil?
+      char
+    end
+
+    alias skip_char read_char
+
+    def peek_char
+      char = @input.getc
+      @input.ungetc char unless char.nil?
+      char
+    end
+
+    def eof?() @input.eof? end
+  end
+
+end

data/lib/sxp/version.rb

@@ -0,0 +1,14 @@
+module SXP
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 0
+    TINY  = 1
+    EXTRA = nil
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+    STRING << "-#{EXTRA}" if EXTRA
+
+    def self.to_s()   STRING end
+    def self.to_str() STRING end
+  end
+end

data/lib/sxp/writer.rb

@@ -0,0 +1,57 @@
+class Object
+  def to_sxp
+    to_s.to_json
+  end
+end
+
+class NilClass
+  def to_sxp; '#n'; end
+end
+
+class FalseClass
+  def to_sxp; '#f'; end
+end
+
+class TrueClass
+  def to_sxp; '#t'; end
+end
+
+class String
+  def to_sxp; inspect; end
+end
+
+class Symbol
+  def to_sxp; to_s; end
+end
+
+class Integer
+  def to_sxp; to_s; end
+end
+
+class Float
+  def to_sxp
+    case
+      when nan? then 'nan.'
+      when infinite? then (infinite? > 0 ? '+inf.' : '-inf.')
+      else to_s
+    end
+  end
+end
+
+class Array
+  def to_sxp
+    '(' << map { |x| x.to_sxp }.join(' ') << ')'
+  end
+end
+
+class Time
+  def to_sxp
+    '#@' << (respond_to?(:xmlschema) ? xmlschema : to_i).to_s
+  end
+end
+
+class Regexp
+  def to_sxp
+    '#' << inspect
+  end
+end

data/lib/sxp.rb

@@ -0,0 +1,7 @@
+require 'sxp/version'
+require 'sxp/extensions'
+require 'sxp/pair'
+require 'sxp/list'
+require 'sxp/reader'
+require 'sxp/writer'
+require 'sxp/generator'

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: sxp
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Arto Bendiken
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-21 00:00:00 +01:00
+default_executable: sxp2json
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.9
+    version: 
+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"
+email: arto.bendiken@gmail.com
+executables: 
+- sxp2json
+- sxp2rdf
+- sxp2xml
+- sxp2yaml
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- AUTHORS
+- README
+- Rakefile
+- UNLICENSE
+- VERSION
+- lib/sxp/extensions.rb
+- lib/sxp/generator.rb
+- lib/sxp/list.rb
+- lib/sxp/pair.rb
+- lib/sxp/reader.rb
+- lib/sxp/version.rb
+- lib/sxp/writer.rb
+- lib/sxp.rb
+has_rdoc: false
+homepage: http://sxp.rubyforge.org/
+licenses: 
+- Public Domain
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.2
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: sxp
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A pure-Ruby implementation of the SXP data interchange format.
+test_files: []
+