sparse 0.0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+group :development, :test do
+  gem "rspec", "~> 2.6.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+  gem "simplecov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,30 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.9.2)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    simplecov (0.4.2)
+      simplecov-html (~> 0.4.4)
+    simplecov-html (0.4.5)
+
+PLATFORMS
+  x86-mingw32
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.6.4)
+  rspec (~> 2.6.0)
+  simplecov

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Plinio Balduino
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+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 OR COPYRIGHT HOLDERS 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.

data/README.rdoc

@@ -0,0 +1,19 @@
+= sparse
+
+Description goes here.
+
+== Contributing to sparse
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Plinio Balduino. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,49 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "sparse"
+  gem.homepage = "http://github.com/pbalduino/sparse"
+  gem.license = "MIT"
+  gem.summary = %Q{Fast and light S-Expression parser}
+  gem.description = %Q{Fast and light S-Expression parser}
+  gem.email = "pbalduino+github@gmail.com"
+  gem.authors = ["Plinio Balduino"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "sparse #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

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

data/lib/sparse/sparse.rb

@@ -0,0 +1,116 @@
+require 'strscan'
+
+class Sparse
+  def parse(text)
+    @scanner = StringScanner.new(text)
+    @line = 1
+    @column = 1
+
+    result = []
+    until @scanner.eos?
+      case
+        when open_parenthesis
+          result << strip
+        when quote
+          result << :quote
+          unless open_parenthesis
+            blowup 'Expected list'
+          end
+          @scanner.unscan
+        when whitespace || comment
+          #do nothing
+        else
+          blowup
+      end
+
+      # puts "parse rest: ->#{@scanner.rest.bytes.to_a.map{|b| b < 32 ? b : b.chr}}"
+    end
+
+    result
+
+  end
+
+  private
+  def format_text(text)
+    text.size < 10 ? text : "#{text[0..7]}..."
+  end
+
+  def blowup(message = "Unexpected token #{format(@scanner.rest)}")
+    raise SyntaxError.new "#{message} in position #{@scanner.pos + 1}, line #{@line}, column #{@scanner.pos - @column + 1}"
+  end
+
+  def strip
+    current = []
+    until close_parenthesis
+      start_rest = @scanner.rest
+      whitespace
+
+      case
+        when whitespace
+          # nothing, as usual
+        when open_parenthesis
+          current << strip
+        when quote
+          current << :quote
+          unless open_parenthesis || symbol || number # || string
+            p @scanner.rest
+            blowup 'Expected a list, symbol or number'
+          end
+          @scanner.unscan
+        when symbol
+          sym = @scanner.matched
+          current << (sym == '- ' ? '-' : sym).to_sym
+        when number
+          current << eval(@scanner.matched)
+      end
+
+#      puts "strip rest: #{@scanner.rest.bytes.to_a.map{|b| b < 32 ? b : b.chr}}"
+
+      if start_rest == @scanner.rest
+        p @scanner.rest
+        blowup 'Unbalanced brackets'
+
+      end
+
+    end
+
+    current
+  end
+
+  # singular: parenthesis
+  # plural  : parentheses 
+  def open_parenthesis
+    @scanner.scan(/[(]/)
+  end
+
+  def close_parenthesis
+    @scanner.scan(/[)]/)
+  end
+
+  def whitespace
+    ret = @scanner.scan(/[ \t\n\r]/)
+    if ret == "\n"
+      @line += 1
+      @column = @scanner.pos
+    end
+
+    ret
+  end
+
+  def quote
+    @scanner.scan(/[']/)
+  end
+
+  def symbol
+    @scanner.scan(/([-][^0-9]|[+*\/]|[a-zA-Z\$][a-zA-Z0-9\-\$]*)/)
+  end
+
+  def number
+    @scanner.scan(/[-]?[0-9]+([.][0-9]+)?/)
+  end
+
+  def comment
+    @scanner.scan(/^;.*$/)
+  end
+
+end

data/lib/sparse.rb

@@ -0,0 +1 @@
+require 'sparse/sparse'

data/spec/complete_code_spec.rb

@@ -0,0 +1,150 @@
+require 'spec_helper'
+
+describe Sparse do
+  context "Complete source code" do
+    before :each do
+      @parser = Sparse.new
+    end
+
+    # http://www.csc.villanova.edu/~dmatusze/resources/lisp/lisp-example.html
+    it "copied from villanova" do
+      code = <<lisp
+; Try to apply each rule in turn to the expression.  SIMPLIFY picks
+; up the rules and gives them, along with the expression, to SIMPLIFY-2.
+; SIMPLIFY-2 picks off one rule and applies it by calling APPLY-RULE,
+; then recurs with the remaining rules. APPLY-RULE breaks the rule up
+; into pattern and replacement parts and gives these, along with the
+; expression, to SUBSTITUTE.
+
+(defun simplify (expression)
+    (simplify-2 (rules) expression)  )
+
+(defun simplify-2 (rules expression)
+    (cond
+    ((null rules)  expression)
+    (T  (simplify-2 (cdr rules) (apply-rule (car rules) expression)))  )  )
+
+(defun apply-rule (rule expression)
+    (substitute (car rule) (cadr rule) expression)  )
+
+
+; Try to match the pattern to the expression.  If it matches, replace
+; the part matched with the replacement, and return the result.
+; If the pattern doesn't apply, the result is the original expression.
+; Example: (substitute '(1 + $) '($ + 1) '(A + 1 + B + C)) returns
+;(A + B + 1 + C)
+
+(defun substitute (pattern replacement expression)
+    (cond
+    ((null expression)  ())
+    ((occurs-at-front pattern expression)
+        (substitute-at-front pattern replacement expression) )
+    (T (cons (car expression) 
+             (substitute pattern replacement (cdr expression)) ))  )  )
+
+
+; Test whether the pattern occurs at the very front of the expression.
+; This function uses MATCHES to test individual components of the pattern.
+; Example: (occurs-at-front '($ + 0) '(A + 0 + B)) returns T
+
+(defun occurs-at-front (pattern expression)
+    (cond
+    ((null pattern)  T)
+    ((null expression)  nil)
+    ((matches (car pattern) (car expression))
+        (occurs-at-front (cdr pattern) (cdr expression)) )
+    (T  nil)  )  )
+
+
+; Test whether the first component of the pattern matches the
+; first component of the expression.  A match occurs if:
+;    1. The pattern component is '$
+;    2. They are identical atoms
+
+(defun matches (pattern-part expression-part)
+    (cond
+    ((eq pattern-part '$)  T)
+    (T  (eq pattern-part expression-part))  )  )
+
+
+; This function should be called only when we know that the pattern
+; matches the front of the expression.
+; If the pattern contains a $, find and return the corresponding
+; component (atom or list) of the expression.  If the pattern
+; does not contain a $, return NIL.
+; (Note: this means you can't replace $ with NIL, but for this
+;  example, using arithmetic expressions, you shouldn't ever want to.)
+; Example: (get-$-match '(0 + $) '(0 + A + B))  returns  A
+
+(defun get-$-match (pattern expression)
+    (cond
+    ((null expression)  nil)
+    ((eq (car pattern) '$)  (car expression))
+    (T  (get-$-match (cdr pattern) (cdr expression)))  )  )
+
+
+; In the replacement, substitute the value we found for the $ for
+; the $ itself.  If $-value is NIL, that means the pattern did not
+; contain a $, and the replacement shouldn't have one, either.
+; Example: (substitute-in-replacement 'A '($ + 0)) returns (A + 0).
+
+(defun substitute-in-replacement ($-value replacement)
+    (cond
+    ((null $-value)  replacement)
+    ((null replacement)  ())
+    ((eq (car replacement) '$)  (cons $-value (cdr replacement)))
+    (T  (cons (car replacement)
+              (substitute-in-replacement $-value (cdr replacement)) ))  )  )
+    
+
+; This function is called when we know the pattern matches the very
+; first part of the expression.  If the pattern contains a $, that
+; could match anything, and the thing it matches should be put in
+; place of the $ the replacement.  If the pattern does not contain
+; a $, then the replacement can be used as is.
+; Example: (substitute-at-front '(0 * $) '(0) '(0 * A + B)) returns (0 + B).
+
+(defun substitute-at-front (pattern replacement expression)
+    (final-replace
+        pattern
+        (substitute-in-replacement (get-$-match pattern expression) replacement)
+        expression )  )
+
+
+; This function is called when (1) the pattern has been matched at the
+; very front of the expression, and (2) the replacement has been suitably
+; modified.  We step through and discard one component of the expression
+; for every component of the pattern, then append the replacement to
+; whatever is left of the expression.
+; Example: (substitute-at-front '($ + 0) '($) '(A + 0 + B)) returns (A + B)
+
+(defun final-replace (pattern replacement expression)
+    (cond
+    ((null pattern)  (append replacement expression))
+    (T  (final-replace (cdr pattern) replacement (cdr expression)))  )  )
+
+
+; Define the rules
+
+(defun rules ()
+    '( (($ + 0)  ($))
+       ((0 + $)  ($))
+       ((1 * $)  ($))
+       ((0 * $)  (0))
+       (($ * 0)  (0))
+       ((1 + 1)  (2))
+       (($ * 2 * 2)  (4 * $)) )  )
+
+(+ 1 1)(+ 1.1 1)(+ -1 -1)(+ -1 -1.1)
+(* 1 1)(* 1.1 1)(* -1 -1)(* -1 -1.1)
+(- 1 1)(- 1.1 1)(- -1 -1)(- -1 -1.1)
+(/ 1 1)(/ 1.1 1)(/ -1 -1)(/ -1 -1.1)
+
+lisp
+      @parser.parse code
+    end
+
+    # http://www.lispworks.com/documentation/lcl50/ug/ug-22.html#HEADING22-0
+
+  end
+end

data/spec/empty_lists_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Sparse do
+  context "An empty list" do
+    before :each do
+      @parser = Sparse.new
+    end
+
+    it 'should work with an empty string' do
+      @parser.parse('').should be_empty
+    end
+
+    it 'could start with a parenthesis' do
+      @parser.parse('()').should == [[]]
+    end
+
+    it 'could start with a parenthesis and contains a space' do
+      @parser.parse('( )').should == [[]]
+    end
+
+    it 'could start with tab and contains space' do
+      @parser.parse("\t( )").should == [[]]
+    end
+
+    it 'could start with space and contains space' do
+      @parser.parse(" ( )").should == [[]]
+    end
+
+    it 'could start with linebreak and contains space' do
+      @parser.parse(<<lisp
+
+( )
+
+lisp
+      ).should == [[]]
+    end
+
+  end
+
+end

data/spec/invalid_syntax_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Sparse do
+  context 'Is an invalid syntax when it' do
+    before :each do
+      @parser = Sparse.new
+    end
+
+    it 'starts with a number' do
+      lambda {@parser.parse '9'}.should raise_error SyntaxError
+    end
+
+    it 'starts with two quotes' do
+      lambda {@parser.parse "''()"}.should raise_error SyntaxError
+    end
+
+    it 'has only a quote' do
+      lambda {@parser.parse "'"}.should raise_error SyntaxError
+    end
+
+    it 'has one open bracket and zero close brackets' do
+      lambda {@parser.parse "("}.should raise_error SyntaxError
+    end
+
+    it 'only close brackets' do
+      lambda {@parser.parse ')'}.should raise_error SyntaxError
+    end
+
+    it 'has unbalanced number of open and close brackets' do
+      lambda {@parser.parse '(()'}.should raise_error SyntaxError
+    end
+
+  end
+end

data/spec/nested_lists_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Sparse do
+  context 'Special use of lists' do
+    before :each do
+      @parser = Sparse.new
+    end
+
+    it 'like nested lists should just work' do
+      @parser.parse('(())').should == [[[]]]
+    end
+
+    it 'like sister lists should just work too' do
+      @parser.parse('()()').should == [[], []]
+    end
+
+    it 'like nested sister lists should just work also' do
+      @parser.parse('(()())').should == [[[], []]]
+    end
+
+  end
+end

data/spec/quote_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Sparse do
+  context 'Quotes' do
+    before :each do
+      @parser = Sparse.new
+    end
+
+    it 'should be before a first level list' do
+      @parser.parse("'()").should == [:quote, []]      
+    end
+
+    it 'should be before a first level list, in any position' do
+      @parser.parse("()'()").should == [[], :quote, []]      
+    end
+
+    it 'should be before a nested list' do
+      @parser.parse("('())").should == [[:quote, []]]
+    end
+
+    it 'should be before symbols' do
+      @parser.parse("('a 'b 'c)").should == [[:quote, :a, :quote, :b, :quote, :c]]
+    end
+
+    it 'should be before symbols with more than one character' do
+      @parser.parse("('abc 'def 'ghi)").should == [[:quote, :abc, :quote, :def, :quote, :ghi]]
+    end
+
+    it 'should be before numbers' do
+      @parser.parse("('1 '2 '3)").should == [[:quote, 1, :quote, 2, :quote, 3]]
+    end
+
+    it 'should be before negative numbers' do
+      @parser.parse("('-1 '-2 '-3)").should == [[:quote, -1, :quote, -2, :quote, -3]]
+    end
+
+    it 'should be before positive and negative decimal numbers' do
+      @parser.parse("('-1.1 '2.2 '3.14159)").should == [[:quote, -1.1, :quote, 2.2, :quote, 3.14159]]
+    end
+
+    it 'should be before nested lists' do
+      @parser.parse("(1 2 '(foo))").should == [[1, 2, :quote, [:foo]]]
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'sparse'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: sparse
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Plinio Balduino
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-07-16 00:00:00.000000000 -03:00
+default_executable: 
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &11380380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *11380380
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &11379948 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *11379948
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &11379612 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *11379612
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: &11379216 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *11379216
+description: Fast and light S-Expression parser
+email: pbalduino+github@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/sparse.rb
+- lib/sparse/sparse.rb
+- spec/complete_code_spec.rb
+- spec/empty_lists_spec.rb
+- spec/invalid_syntax_spec.rb
+- spec/nested_lists_spec.rb
+- spec/quote_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/pbalduino/sparse
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -540899953
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Fast and light S-Expression parser
+test_files: []