lucio 0.0.7 → 0.0.8

data/lib/lucio/grammar.rb

@@ -1,37 +0,0 @@
-require 'lucio'
-
-module Lucio
-  class Grammar < Treetop::Runtime::SyntaxNode
-    def eval
-      Lucio::Runner.run make_tree(elements)
-    end
-
-    private
-      def make_tree(el)
-        x = make_list(el)
-        h = nil
-        h, x = Lucio.behead(x) if x[0] == '\''
-
-        Kernel::eval("Lucio::List.new(tree = #{x.inject('') {|x, y| x += "'#{y}',"}.strip.chop.gsub(/'\(',/, '[').gsub(/[,]?'\)'/, ']')}, evaluable = #{!h})")
-      end
-
-      def make_list(el, list = [])
-        el.each do |e|
-          methods = e.public_methods.reject{|i| i.to_s.chr != 'v'}.map{|i| i.to_s}.sort
-          if methods.include?('value')
-            list << e.value
-          else
-            unless e.empty? || e.text_value.strip.empty?
-              if e.nonterminal?
-                list = make_list(e.elements, list)
-              else
-                list << e.text_value
-              end
-            end
-          end
-        end
-        list
-      end
-  end
-end
-

data/lib/lucio/list.rb

@@ -1,22 +0,0 @@
-module Lucio
-  class List
-    attr :tree, :evaluable
-
-    def initialize(tree, evaluable = true)
-      @tree = tree
-      @evaluable = evaluable
-    end
-
-    def to_s
-      flat(tree)
-    end
-
-    private
-    def flat(list)
-      result = "#{'(' if list.empty?}#{list.inject('(') do |result, item|
-        result += "#{item} "
-      end.chop})"
-    end
-    
-  end
-end

data/lib/lucio/operators.rb

@@ -1,9 +0,0 @@
-require 'lucio/operators/operator'
-
-require 'lucio/operators/sum'
-require 'lucio/operators/multiplication'
-require 'lucio/operators/division'
-require 'lucio/operators/subtraction'
-require 'lucio/operators/equality'
-require 'lucio/operators/conditional'
-require 'lucio/operators/attribution'

data/lib/lucio/operators/attribution.rb

@@ -1,10 +0,0 @@
-require 'lucio/operators/macro'
-
-module Lucio
-  module Operator
-    class Attribution < Macro
-      def execute(lexicon, *items)
-      end
-    end
-  end
-end

data/lib/lucio/operators/conditional.rb

@@ -1,20 +0,0 @@
-require 'lucio/operators/macro'
-
-module Lucio
-  module Operator
-    class Conditional < Macro
-      def execute(lexicon, list)
-        tree = list.tree
-        condition = Lucio::Runner.run List.new(tree[0]), lexicon
-
-        if condition
-          Lucio::Runner.run List.new(tree[1]), lexicon
-        else
-          Lucio::Runner.run(List.new(tree[2]), lexicon) if tree.size > 2
-        end
-      end
-    end
-  end
-end
-
-

data/lib/lucio/operators/division.rb

@@ -1,16 +0,0 @@
-require 'lucio/operators/function'
-
-module Lucio
-  module Operator
-    class Division < Function
-      def execute(lexicon, *items)
-        if items.size == 0
-          0
-        else
-          items.inject {|result, item| result = result / item.to_f }
-        end
-      end
-    end
-  end
-end
-

data/lib/lucio/operators/equality.rb

@@ -1,11 +0,0 @@
-require 'lucio/operators/function'
-
-module Lucio
-  module Operator
-    class Equality < Function
-      def execute(lexicon, *items)
-        items[0] == items[1]
-      end
-    end
-  end
-end

data/lib/lucio/operators/macro.rb

@@ -1,15 +0,0 @@
-module Lucio
-  module Operator
-    class Macro
-      attr :type
-
-      def initialize
-        @type = :macro
-      end
-
-      def execute(*params)
-        raise "Operator not implemented"
-      end
-    end
-  end
-end

data/lib/lucio/operators/multiplication.rb

@@ -1,16 +0,0 @@
-require 'lucio/operators/function'
-
-module Lucio
-  module Operator
-    class Multiplication < Function
-      def execute(lexicon, *items)
-        if items.size == 0
-          0
-        else
-          items.inject(1) {|multiplication, item| multiplication *= item }
-        end
-      end
-    end
-  end
-end
-

data/lib/lucio/operators/operator.rb

@@ -1,29 +0,0 @@
-module Lucio
-  module Operator
-    class Operator
-      attr :type
-
-      def type
-        @type
-      end
-
-      def execute(*items)
-        raise "Incomplete operator"
-      end
-    end
-
-    class Function
-      def initialize
-        super.type = :function
-      end
-    end
-
-    class Macro
-      def initialize
-        super.type = :macro
-      end
-
-    end
-
-  end
-end

data/lib/lucio/operators/subtraction.rb

@@ -1,18 +0,0 @@
-require 'lucio/operators/function'
-
-module Lucio
-  module Operator
-    class Subtraction < Function
-      def execute(lexicon, *items)
-        p lexicon, items
-        if items.size == 0
-          0
-        else
-          head, tail = Lucio.behead(items)
-          tail.empty? ? (head * -1) : tail.inject(head) {|subtraction, item| subtraction -= item }
-        end
-      end
-    end
-  end
-end
-

data/lib/lucio/operators/sum.rb

@@ -1,13 +0,0 @@
-module Lucio
-  module Operator
-    class Sum < Function
-      def execute(lexicon, *items)
-        if items.size == 0
-          0
-        else
-          items.inject(0) {|sum, item| sum += item }
-        end
-      end
-    end
-  end
-end

data/lib/lucio/runner.rb

@@ -1,60 +0,0 @@
-module Lucio
-  class Runner
-    def self.run(obj_tree, lexicon = Lexicon.new)
-      tree = obj_tree.tree
-
-      if obj_tree.evaluable
-        case
-          when tree.empty?
-            nil
-          when tree.size == 1
-            item = tree[0]
-            instruction = lexicon.get item
-            if instruction
-              instruction.execute lexicon
-            else
-              begin
-                eval(item)
-              rescue Exception => e
-                raise "Invalid or unknown symbol: #{item}", e.backtrace
-              end
-            end
-          else
-            operator, list = Lucio.behead(tree)
-            start, tail = Lucio.behead(list)
-
-            instruction = lexicon.get operator
-
-            raise "Invalid or unknown operator: #{operator}" unless instruction
-
-            if instruction.type == :function
-              if(start.kind_of? Array)
-                first = run List.new(start), lexicon
-              else
-                first = eval start
-              end
-
-              if tail.empty?
-                instruction.execute(lexicon, first)
-              else
-                tail.inject(first) do |result, item| 
-                  if item.kind_of? Array
-                    i = run List.new(item), lexicon
-                  else
-                    i = eval item
-                  end
-
-                  instruction.execute(lexicon, result, i)
-                end
-              end
-
-            elsif instruction.type == :macro
-              instruction.execute lexicon, List.new(list)
-            end
-        end
-      else
-        obj_tree
-      end
-    end
-  end
-end

data/lib/lucio_syntax.treetop

@@ -1,92 +0,0 @@
-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/spec/all_the_fun_spec.rb

@@ -1,21 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,116 +0,0 @@
-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