lucio 0.0.7

data/lib/lucio_syntax.treetop

@@ -0,0 +1,92 @@
+require 'lucio/grammar'
+
+grammar Lucio
+
+  rule lucio
+    (whitespace / (quote? list))* <Grammar>
+  end
+
+  rule list
+    lparen (whitespace / operator)? (value)* rparen
+  end
+
+  rule value
+    list / string / number / boolean / operator / vector / whitespace
+  end
+
+  rule quote
+    '\''
+  end
+
+  rule rparen
+    ')'
+  end
+
+  rule lparen
+    '('
+  end
+
+  rule whitespace
+    [ \n\r\t,]+
+  end
+
+  rule vector
+    '[' (value)* ']'
+  end
+
+  rule operator
+    ((([a-zA-Z] ([-]? [a-zA-Z0-9])* [?]?) !('+' / '-' / '/' / '*')) / ('+' / '-' / '/' / '*')) {
+      def value
+        text_value
+      end
+    }
+  end
+
+  rule number
+    decimal / integer {
+      def value
+        f = text_value.to_f
+        i = text_value.to_i
+        (f - i == 0 ? i : f)
+      end
+    }
+  end
+
+  rule decimal
+    integer '.' [0-9]+ {
+      def value
+        text_value.to_f
+      end
+    }
+  end
+
+  rule integer
+    '-'? unsigned_integer
+  end
+
+  rule unsigned_integer
+    '0' / [1-9] [0-9]*
+  end
+
+  rule string
+    '"' [^"]* '"' {
+      def value
+        text_value
+      end
+    }
+  end
+#'
+  rule boolean
+    true / false
+  end
+
+  rule true
+    'true'
+  end
+
+  rule false
+    'false'
+  end
+
+end
+

data/lucio.gemspec

@@ -0,0 +1,104 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{lucio}
+  s.version = "0.0.7"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["pbalduino"]
+  s.date = %q{2011-07-15}
+  s.description = %q{Lucio is intended to be a Lisp-like language developed in Ruby only for knowledge and fun.}
+  s.email = %q{pbalduino+github@gmail.com}
+  s.executables = ["lucio", "repl.rb"]
+  s.extra_rdoc_files = [
+    "CHANGELOG.md",
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".autotest",
+    ".document",
+    ".rspec",
+    ".rvmrc",
+    "CHANGELOG.md",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "TODO.md",
+    "VERSION",
+    "bin/lucio",
+    "bin/repl.rb",
+    "lib/lucio.rb",
+    "lib/lucio/grammar.rb",
+    "lib/lucio/lexicon.rb",
+    "lib/lucio/list.rb",
+    "lib/lucio/lucio.rb",
+    "lib/lucio/operators.rb",
+    "lib/lucio/operators/attribution.rb",
+    "lib/lucio/operators/conditional.rb",
+    "lib/lucio/operators/division.rb",
+    "lib/lucio/operators/equality.rb",
+    "lib/lucio/operators/macro.rb",
+    "lib/lucio/operators/multiplication.rb",
+    "lib/lucio/operators/operator.rb",
+    "lib/lucio/operators/subtraction.rb",
+    "lib/lucio/operators/sum.rb",
+    "lib/lucio/runner.rb",
+    "lib/lucio_syntax.treetop",
+    "lucio.gemspec",
+    "spec/all_the_fun_spec.rb",
+    "spec/division_spec.rb",
+    "spec/eval_spec.rb",
+    "spec/lucio_spec.rb",
+    "spec/multiplication_spec.rb",
+    "spec/parser_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/subtraction_spec.rb",
+    "spec/sum_spec.rb",
+    "spec/variable_spec.rb"
+  ]
+  s.homepage = %q{https://github.com/pbalduino/lucio}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.5.2}
+  s.summary = %q{Lucio is a LISP-like language created just for fun}
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<polyglot>, [">= 0"])
+      s.add_runtime_dependency(%q<treetop>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+      s.add_development_dependency(%q<ZenTest>, [">= 0"])
+      s.add_development_dependency(%q<diff-lcs>, [">= 0"])
+      s.add_development_dependency(%q<yard>, ["~> 0.6.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.6.4"])
+    else
+      s.add_dependency(%q<polyglot>, [">= 0"])
+      s.add_dependency(%q<treetop>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 0"])
+      s.add_dependency(%q<ZenTest>, [">= 0"])
+      s.add_dependency(%q<diff-lcs>, [">= 0"])
+      s.add_dependency(%q<yard>, ["~> 0.6.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+    end
+  else
+    s.add_dependency(%q<polyglot>, [">= 0"])
+    s.add_dependency(%q<treetop>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 0"])
+    s.add_dependency(%q<ZenTest>, [">= 0"])
+    s.add_dependency(%q<diff-lcs>, [">= 0"])
+    s.add_dependency(%q<yard>, ["~> 0.6.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.6.4"])
+  end
+end
+

data/spec/all_the_fun_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+require 'lucio'
+
+describe "All the fun" do
+  it "should have all the fun" do
+    Lucio.literal("'(lisp programmers have all defun)").should == '(lisp programmers have all defun)'
+  end
+
+  it "should work too =P" do
+    Lucio.literal("'(a b c)").should == '(a b c)'
+  end
+
+  it "should work with numbers" do
+    Lucio.literal("'(1 2 3)").should == '(1 2 3)'
+  end
+
+  it "should work with mixed values too" do
+    Lucio.literal("'(a b c 1 2 3)").should == '(a b c 1 2 3)'
+  end
+
+end

data/spec/division_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'lucio'
+
+describe Lucio::Operator::Division do
+  it "an empty list should return zero" do
+    Lucio.eval('(/)').should == 0
+  end
+
+  it "a list with one item should return that item" do
+    Lucio.eval('(/ 1)').should == 1
+    Lucio.eval('(/ 2)').should == 2
+  end
+
+  it "a list with more than one item should eval all items" do
+    Lucio.eval('(/ 8 4)').should == 2
+    Lucio.eval('(/ 8 4 2)').should == 1
+  end
+
+end

data/spec/eval_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+require 'lucio'
+
+describe Lucio do
+
+  context 'empty list' do
+    it 'should return nil' do
+      Lucio.eval('()').should == nil
+      Lucio.eval('( )').should == nil
+      Lucio.eval('(  )').should == nil
+    end
+  end
+  
+  context 'sum operation' do
+    it 'should return a numeric value' do
+      Lucio.eval('(1)').should == 1
+      Lucio.eval('(+ 1 2)').should == 3
+      Lucio.eval('(+ 1 2 3 4 5 6)').should == 21
+      Lucio.eval('(+ 1 (+ 2 3))').should == 6
+
+      Lucio.eval('(+)').should == 0
+
+      lambda { Lucio.eval('(invalid)') }.should raise_error
+    end
+  end
+
+  context 'more than one type of operation' do
+    it 'should return a numeric value' do
+      Lucio.eval('(/ (* (+ 1 2) (+3 4)) 2)').should == 10.5
+      Lucio.eval('(- 10.5 (/ (* (+ 1 2) (+3 4)) 2))').should == 0
+    end
+  end
+
+  context 'builtin function' do
+    it 'compare two values using a function' do
+      Lucio.eval('(eql? (* (+ 1 2) 3) 9)').should be_true
+      Lucio.eval('(eql? (/ (* (+ 1 2) (+3 4)) 2) 10)').should be_false
+      Lucio.eval(<<lisp
+(eql? 
+  (/ 
+    (* 
+      (+ 1 2) 
+      (+3 4)) 
+    2) 
+  10)
+lisp
+).should be_false
+    end
+  end
+
+  context 'macro' do
+    it 'runs a simple if' do
+      Lucio.eval(<<lisp
+(if (eql? 1 1)
+  ("ok"))
+lisp
+).should == 'ok'
+    end
+
+    it 'a simple if without else returns nil when false' do
+      Lucio.eval('(if (eql? 1 2)("nope"))').should == nil
+    end
+
+    it 'runs a if with else' do
+      Lucio.eval(<<lisp
+(if (eql? 1 1)
+  ("ok")
+  ("nope"))
+lisp
+).should == 'ok'
+
+      Lucio.eval(<<lisp
+(if (eql? 2 1)
+  ("nope")
+  ("ok"))
+lisp
+).should == 'ok'
+    end
+
+    it 'runs a function before a macro' do
+      Lucio.eval(<<lisp
+(+ 1 2 3 (if (eql? (+ 1 1) 2) (4) (5)))
+lisp
+).should == 10
+
+      Lucio.eval(<<lisp
+(eql? (+ 1 2 3 (if (eql? (+ 1 1) 2) (4) (5))) 10)
+lisp
+).should be_true
+    end 
+
+    it 'runs a macro before a function ' do
+      code = <<lisp
+(if (eql? (+ 1 1) 2) (+ 1 2 3 4) (0))
+lisp
+      Lucio.eval(code).should == 10
+
+      Lucio.eval(<<lisp
+(if (eql? (+ 1 1) 2)
+  (eql? (+ 1 2 3 (4) (5)) 15) 
+  (false))
+lisp
+).should be_true
+    end 
+  end
+
+  context 'quoted list' do
+
+    it 'a quoted empty list should return an empty list' do
+      Lucio.literal("'()").should == '()'
+
+    end
+
+  end
+
+end

data/spec/lucio_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+require 'lucio'
+
+describe Lucio do
+  it "should return head and tail" do
+    h, t = Lucio.behead [1, 2, 3, 4, 5]
+    h.should == 1
+    t.should == [2, 3, 4, 5]
+  end
+
+  it "should return empty tail" do
+    h, t = Lucio.behead [1]
+    h.should == 1
+    t.should == []
+  end
+
+  it "should handle empty collections" do
+    h, t = Lucio.behead []
+    h.should == nil
+    t.should == [] 
+  end
+  
+  
+end
+

data/spec/multiplication_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'lucio'
+
+describe Lucio::Operator::Multiplication do
+  it "an empty list should return zero" do
+    Lucio.eval('(*)').should == 0
+  end
+
+  it "a list with one item should return that item" do
+    Lucio.eval('(* 1)').should == 1
+    Lucio.eval('(* 2)').should == 2
+  end
+
+  it "a list with more than one item should eval all items" do
+    Lucio.eval('(* 2 3)').should == 6
+    Lucio.eval('(* 2 3 4)').should == 24
+  end
+
+end

data/spec/parser_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+require 'lucio'
+ 
+describe Lucio do
+
+  context "list" do
+	  it "integer" do
+  	  Lucio.parse('(2)').should be
+	  end
+
+	  it "integers" do
+  	  Lucio.parse('(2)(3)').should be
+	  end
+
+	  it "decimal" do
+  	  Lucio.parse('(3.14)').should be
+	  end
+
+	  it "valid string" do
+  	  Lucio.parse('("this is a text")').should be
+	  end
+
+	  it "valid expression" do
+  	  Lucio.parse('(this is an expression)').should be
+	  end
+
+    it "boolean" do
+      Lucio.parse('(true)').should be
+  	  Lucio.parse('(true)').should be
+  	  Lucio.parse('(true)(false)').should be
+
+      Lucio.parse('true').should_not be
+  	  Lucio.parse('false').should_not be
+	  end
+
+    it 'space' do
+      Lucio.parse('()').should be
+      Lucio.parse('( )').should be
+      Lucio.parse('(  )').should be
+    end
+
+    it 'simple expression' do
+      Lucio.parse('(+ 1 2)').should be
+    end
+
+    it 'long expression' do
+      Lucio.parse('(+ 1 2 3 4)').should be
+    end
+
+    it 'long expression with commas' do
+      Lucio.parse('(+ 1, 2, 3, 4)').should be
+    end
+
+    it 'vector' do
+      Lucio.parse('([1 2 3 4 5 6])').should be
+    end
+
+    it 'vector with commas' do
+      Lucio.parse('([1, 2, 3, 4, 5, 6])').should be
+    end
+
+    it 'composed expression' do
+      Lucio.parse('(+ 1 (* 2 3))').should be
+    end
+
+    it 'composed long expression' do
+      Lucio.parse('(+ 1 2 3 (* 4 5 6))').should be
+    end
+
+    it 'and now we return to begin' do
+      Lucio.parse('(* (+ 1 2) 3)').should be
+
+      Lucio.parse('(/ (* (+ 1 2)(+ 3 4)) 2)').should be
+    end
+
+    it 'special caracters should work to improve the expressiveness' do
+      Lucio.parse('(eql? (* (+ 1 2) 3) 9)').should be
+
+      Lucio.parse('(eql?? (* (+ 1 2) 3) 9)').should_not be
+
+      Lucio.parse('(foo-bar (1 1 2 3 4 4))').should be
+      Lucio.parse('(foo-bar-meh (1 1 2 3 4 4))').should be
+
+      Lucio.parse('(foo--bar (1 1 2 3 4 4))').should be_nil
+      Lucio.parse('(foo--bar (1 1 2 3 4 4))').should_not be
+      Lucio.parse('(foo----- (1 1 2 3 4 4))').should_not be
+      Lucio.parse('(foo--bar-meh (1 1 2 3 4 4))').should_not be
+    end
+
+    it 'multiline' do
+      code = <<lisp
+(/
+  (*
+    (+ 1 2)
+    (+ 3 4))
+  2)
+lisp
+
+      Lucio.parse(code).should be
+    end
+
+  end
+
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require 'simplecov'
+
+SimpleCov.start # if ENV['COVERAGE']

data/spec/subtraction_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'lucio'
+
+describe Lucio::Operator::Subtraction do
+  it "an empty list should return zero" do
+    Lucio.eval('(-)').should == 0
+  end
+
+  it "a list with one item should return that item" do
+    Lucio.eval('(- 1)').should == -1
+    Lucio.eval('(- 2)').should == -2
+  end
+
+  it "a list with more than one item should eval all items" do
+    Lucio.eval('(- 2 1)').should == 1
+    Lucio.eval('(- 3 2 1)').should == 0
+  end
+
+end

data/spec/sum_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+require 'lucio'
+
+describe Lucio::Operator::Sum do
+  it "an empty list should return zero" do
+    Lucio.eval('(+)').should == 0
+  end
+
+  it "a list with one item should return that item" do
+    Lucio.eval('(+ 1)').should == 1
+    Lucio.eval('(+ 2)').should == 2
+  end
+
+  it "a list with more than one item should eval all items" do
+    Lucio.eval('(+ 1 2)').should == 3
+    Lucio.eval('(+ 1 2 3)').should == 6
+  end
+
+end

data/spec/variable_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'lucio'
+
+describe 'Var' do
+  it 'should store some value' do
+    code = <<lisp
+((let x 3)
+ (x))
+lisp
+
+    p Lucio.eval(code)
+  end
+end