lucio 0.0.7

data/.autotest

@@ -0,0 +1,3 @@
+Autotest.add_hook(:initialize) do |at|
+  at.add_exception %r{coverage}
+end

data/.document

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

data/.rspec

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

data/.rvmrc

@@ -0,0 +1,2 @@
+rvm use 1.9.2
+rvm gemset use lucio

data/CHANGELOG.md

@@ -0,0 +1 @@
+

data/Gemfile

@@ -0,0 +1,17 @@
+source "http://rubygems.org"
+
+gem 'polyglot'
+gem 'treetop'
+
+gem 'simplecov', '>= 0.4.0', :require => false, :group => :test
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development, :test do
+  gem 'rspec'
+  gem 'ZenTest'
+  gem 'diff-lcs'
+  gem "yard", "~> 0.6.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+end

data/Gemfile.lock

@@ -0,0 +1,41 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    ZenTest (4.5.0)
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    polyglot (0.3.1)
+    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)
+    treetop (1.4.9)
+      polyglot (>= 0.3.1)
+    yard (0.6.8)
+
+PLATFORMS
+  ruby
+  x86-mingw32
+
+DEPENDENCIES
+  ZenTest
+  bundler (~> 1.0.0)
+  diff-lcs
+  jeweler (~> 1.6.4)
+  polyglot
+  rspec
+  simplecov (>= 0.4.0)
+  treetop
+  yard (~> 0.6.0)

data/LICENSE.txt

@@ -0,0 +1,15 @@
+Open Source Initiative OSI - The MIT License (MIT):Licensing
+
+The MIT License (MIT)
+Copyright (c) 2011 P Balduino, R Lorca
+
+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.md

@@ -0,0 +1,67 @@
+# Lucio (en)
+
+## What?
+Lucio is **intended to be** a Lisp-like language developed in Ruby only for knowledge and fun. No profit intended.
+
+## Why?
+From Latin, Lucius means _Light_, because this development is enlightening my (poor) knowledge about programming languages, parsing and related subjects.
+
+Lucio is also the name of one of the most important teachers I had, and I found this as a kind of homage.
+
+The last, but not least, reason is to practice TDD, since I'm developing all the code using test-first.
+
+## When?
+Lucio is developed in my almost nonexistent spare time as a way to keep me learning and passionate with software development. 
+
+## Who?
+I'm just an ordinary software developer, passionate and curious. If you want to collaborate, fork this and start to code. Simple.
+
+## Small sample
+    (/ (* (+ 1 2) (+3 4)) 2)
+    => 10.5
+
+    (eql? (* (+ 1 2) 3) 9)
+    => true
+
+    (if (eql? 10.5 (/ (* (+ 1 2) (+3 4)) 2))
+      ("great"))
+    => "great"
+
+    (if (eql? 0 (/ (* (+ 1 2) (+3 4)) 2))
+      ("great")
+      ("ouch")
+    => "ouch"
+
+# Lucio (pt\_BR)
+
+## O que é?
+Lucio **tem a intenção de ser** um dialeto Lisp desenvolvido inicialmente em Ruby apenas por diversão e aprendizado, sem qualquer intenção de lucro financeiro.
+
+## Por que?
+Em Latim, Lucius significa _Luz_, ou _Iluminação_, porque esse projeto está iluminando meu (pobre) conhecimento sobre linguagens de programação, interpretadores e assuntos relacionados.
+
+Lucio é também o nome de um dos mais importantes professores que já tive, e encontrei nesse projeto uma forma de homenageá-lo.
+
+O último motivo, mas não menos importante, é poder praticar TDD, partindo do princípio que estou desenvolvendo **todo** o código utilizando essa metodologia.
+
+## Quando?
+Lucio está sendo desenvolvido em meu quase inexistente tempo livre como uma forma de me manter sempre aprendendo coisas novas e motivado a continuar desenvolvendo.
+
+## Quem?
+Sou apenas um rapaz latino-americano sem dinheiro no bolso nem amigos importantes, mas que realmente adora o que faz e muito curioso. Se você quiser participar e colaborar, crie um fork e comece a codificar. Simples assim.
+
+## Exemplos simples
+    (/ (* (+ 1 2) (+3 4)) 2)
+    => 10.5
+
+    (eql? (* (+ 1 2) 3) 9)
+    => true
+
+    (if (eql? 10.5 (/ (* (+ 1 2) (+3 4)) 2))
+      ("great"))
+    => "great"
+
+    (if (eql? 0 (/ (* (+ 1 2) (+3 4)) 2))
+      ("great")
+      ("ouch")
+    => "ouch"

data/Rakefile

@@ -0,0 +1,42 @@
+# 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 = "lucio"
+  gem.homepage = "https://github.com/pbalduino/lucio"
+  gem.license = "MIT"
+  gem.summary = %Q{Lucio is a LISP-like language created just for fun}
+  gem.description = %Q{Lucio is intended to be a Lisp-like language developed in Ruby only for knowledge and fun.}
+  gem.email = "pbalduino+github@gmail.com"
+  gem.authors = ["pbalduino"]
+  # 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 'yard'
+YARD::Rake::YardocTask.new

data/TODO.md

@@ -0,0 +1,32 @@
+# TODO
+
+## Introdução
+
+1. Toda a comunicação será feita através desse arquivo, das mensagens de commit e do código.
+
+1. Dúvidas, intenções e próximos passos serão incluidos aqui.
+
+1. Commits mal explicados ou sem uma mensagem clara e objetiva serão revertidos.
+
+1. ???
+
+1. Profit
+
+## Tarefas
+
+* Podemos fazer de duas formas: apagar as linhas de mensagens que foram resolvidas ou podemos simplesmente <strike>riscá-las</strike> e mantê-las por aqui, como uma forma rudimentar de histórico para quem não quiser/puder ver o versionamento do arquivo. O quê você prefere?
+
+* Escrever testes para casos especiais ou que ainda levantem dúvidas sobre o funcionamento do parser.
+
+* Finalizada uma versão funcional do parser, criar testes para resolver pequenas expressões matemáticas e fazer com que o Runner as execute.
+
+* Minha primeira idéia foi de usar a classe Lexicon como uma espécie de dicionário de funções e operadores, onde ficariam as funções existentes e as novas. O Runner vai executar a expressão correspondente ao operador utilizando valores simples da lista. Caso seja encontrada uma lista dentro da lista atual, ela será passada recursivamente ao Runner até que retorne um valor simples.
+
+* Exemplo:
+<pre>
+(eql? (+ 1 2) 3)
+|
++--> runner: eql? (lista) 3                            +-> eql? 3 3 -> true
+                      |                                    |
+                      +-----> runner + 1 2 --> returns 3 --+
+</pre>

data/VERSION

@@ -0,0 +1 @@
+0.0.7

data/bin/lucio

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+if ARGV.empty?
+  $LOAD_PATH << (File.expand_path(File.dirname(__FILE__)) + '/../bin')
+  require('repl')
+  Lucio::Repl.run
+else
+  puts 'meh'
+end

data/bin/repl.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+$LOAD_PATH << (File.expand_path(File.dirname(__FILE__)) + '/../lib')
+
+require 'rubygems'
+require 'lucio'
+
+QUIT = '.q'
+
+module Lucio
+  class Repl
+    def self.run
+exit = false
+
+puts <<lisp
+# lucio interactive console
+-------------------------
+# type a lucio expression and press ENTER
+# type .q and press ENTER to exit
+
+lisp
+while !exit
+  print 'lucio: '
+  command = (gets).chomp
+  exit = (command == QUIT)
+  unless exit
+    begin
+      print '=> '
+      p Lucio.eval(command)
+    rescue Exception => msg
+      puts "Error: #{msg}"
+    end
+    puts ''
+  end
+end
+
+puts '# bye!'
+    end
+  end
+end

data/lib/lucio/grammar.rb

@@ -0,0 +1,37 @@
+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/lexicon.rb

@@ -0,0 +1,25 @@
+require 'lucio/operators'
+
+module Lucio
+  class Lexicon
+    def initialize
+      fill_operator_list
+    end
+
+    def get(operator)
+      ret = @operator_list[operator]
+    end
+
+    private
+    def fill_operator_list
+      @operator_list = {}
+      @operator_list['+']     = Operator::Sum.new
+      @operator_list['*']     = Operator::Multiplication.new
+      @operator_list['/']     = Operator::Division.new
+      @operator_list['-']     = Operator::Subtraction.new
+      @operator_list['eql?']  = Operator::Equality.new
+      @operator_list['if']    = Operator::Conditional.new
+      @operator_list['let']   = Operator::Attribution.new
+    end
+  end
+end

data/lib/lucio/list.rb

@@ -0,0 +1,22 @@
+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/lucio.rb

@@ -0,0 +1,29 @@
+require 'lucio/runner'
+require 'lucio/lexicon'
+require 'lucio/list'
+require 'polyglot'
+require 'treetop'
+require 'lucio_syntax'
+
+module Lucio
+  def self.parse(str, debug = false)
+    parser = LucioParser.new
+    result = parser.parse str
+
+    puts "\n#{parser.failure_reason}" unless result || !debug
+
+    result
+  end
+
+  def self.eval(str)
+    parse(str).eval
+  end
+
+  def self.literal(str)
+    Lucio.eval(str).to_s
+  end
+
+  def self.behead(list)
+    [list[0], list.drop(1)]
+  end
+end

data/lib/lucio/operators/attribution.rb

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

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

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

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

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

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

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

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

@@ -0,0 +1,13 @@
+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/operators.rb

@@ -0,0 +1,9 @@
+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/runner.rb

@@ -0,0 +1,60 @@
+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.rb

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