electr 0.0.2 → 0.0.3

data/lib/electr/repl/ast_printer.rb

@@ -0,0 +1,11 @@
+module Electr
+
+  # Prints the abstract syntax tree.
+  class ASTPrinter
+
+    def self.run(ast)
+      ast.display
+    end
+
+  end
+end

data/lib/electr/repl/ast_reader.rb

@@ -0,0 +1,17 @@
+module Electr
+
+  # Special reader for a REPL that display an AST instead of the
+  # computation.
+  class ASTReader < BaseReader
+
+    def initialize
+      super("E--ast> ")
+    end
+
+    def run
+      prompt
+      Compiler.compile_to_ast(STDIN.gets.chomp)
+    end
+
+  end
+end

data/lib/electr/repl/base_reader.rb

@@ -0,0 +1,23 @@
+module Electr
+
+  # Responsible of the terminal interface, that is printing the prompt
+  # and reading a line of code (I know, I know, there is an «and» in the
+  # description…).
+  class BaseReader
+
+    def initialize(prompt = "No prompt defined> ")
+      @prompt = prompt
+    end
+
+    def run
+      raise(NotImplementedError)
+    end
+
+    private
+
+    def prompt
+      print(@prompt)
+    end
+
+  end
+end

data/lib/electr/{evaluator.rb → repl/evaluator.rb}

@@ -1,5 +1,6 @@
 module Electr
 
+  # Evaluate (compute) a value.
   class Evaluator
 
     def initialize
@@ -9,7 +10,7 @@ module Electr
     def evaluate_pn(list)
       while item = list.pop
         case item.name
-        when "numeric" then @stack.push(item.value.to_f)
+        when "numeric" then @stack.push(item.to_f)
         when "constant" then @stack.push(constant(item.value))
         when "value" then do_value(item.value)
         when "operator" then operation(item.value)
@@ -37,6 +38,19 @@ module Electr
     end
 
     def operation(operand)
+      if operand == UNARY_MINUS_INTERNAL_SYMBOL
+        unary_minus
+      else
+        classic_operation(operand)
+      end
+    end
+
+    def unary_minus
+      a = @stack.pop
+      @stack.push(-a)
+    end
+
+    def classic_operation(operand)
       a = @stack.pop
       b = @stack.pop
       @stack.push(a.send(operand, b))

data/lib/electr/repl/nil_evaluator.rb

@@ -0,0 +1,11 @@
+module Electr
+
+  # An Evaluator that does nothing.
+  class NilEvaluator
+
+    def evaluate_pn(arg)
+      arg
+    end
+
+  end
+end

data/lib/electr/repl/printer.rb

@@ -0,0 +1,12 @@
+module Electr
+
+  # Prints the computation.
+  class Printer
+
+    def self.run(result)
+      truncated = result.truncate
+      puts result == truncated ? truncated : result.round(10)
+    end
+
+  end
+end

data/lib/electr/repl/reader.rb

@@ -0,0 +1,16 @@
+module Electr
+
+  # Normal reader for the REPL.
+  class Reader < BaseReader
+
+    def initialize
+      super("E> ")
+    end
+
+    def run
+      prompt
+      Compiler.compile_to_pn(STDIN.gets.chomp)
+    end
+
+  end
+end

data/lib/electr/repl/repl.rb

@@ -0,0 +1,28 @@
+module Electr
+
+  # The Read Eval Print Loop starting point.
+  class Repl
+
+    BANNER = "\nElectr version #{Electr::VERSION}\n" +
+             "A tiny language for electronic formulas\n\n" +
+             "Hit Ctrl+C to quit Electr\n\n"
+
+    def initialize(reader = Reader.new,
+                   evaluator = Evaluator.new,
+                   printer = Printer)
+      @reader = reader
+      @eval = evaluator
+      @printer = printer
+    end
+
+    def run
+      puts BANNER
+      run_once while true
+    end
+
+    def run_once
+      @printer.run(@eval.evaluate_pn(@reader.run))
+    end
+
+  end
+end

data/lib/electr/version.rb

@@ -1,3 +1,3 @@
 module Electr
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/spec/ast/ast_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+include Electr
+
+describe AST do
+
+  it 'has a name' do
+    node = AST.new('foobar')
+    expect(node.name).to eq 'foobar'
+  end
+
+  it 'has a default name' do
+    node = AST.new(nil)
+    expect(node.name).to eq 'AST'
+  end
+
+end

data/spec/compiler_spec.rb

@@ -16,26 +16,24 @@ describe Compiler do
     "sqrt(40 + 9)",
     "3 (2 + 1)",
     "2 sqrt(3)",
+    "2 pi 0.5uF sqrt(11K 22K)",
   ]
 
   specify "#compile_to_ast" do
     CODES_TO_COMPILE.each do |code|
-      compiler = Compiler.new
-      result = compiler.compile_to_ast(code)
+      result = Compiler.compile_to_ast(code)
       expect(result).to be_a AST
     end
   end
 
   specify do
-    compiler = Compiler.new
-    result = compiler.compile_to_ast("2 pi 0.5uF sqrt(11K 22K)")
+    result = Compiler.compile_to_ast("-pi 2")
     result.display
     expect(result).to be_a AST
   end
 
   specify "#compile_to_pn" do
-    compiler = Compiler.new
-    result = compiler.compile_to_pn("2 pi")
+    result = Compiler.compile_to_pn("2 pi")
     expect(result).to be_a Array
   end
 

data/spec/parser/base_rule_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+include Electr
+
+describe BaseRule do
+
+  it "is not implemented" do
+    expect {
+      BaseRule.new(nil, nil).apply
+    }.to raise_error(NotImplementedError)
+  end
+
+end

data/spec/{lexer_spec.rb → parser/lexer_spec.rb}

@@ -3,12 +3,15 @@ require 'spec_helper'
 include Electr
 
 describe Lexer do
-  before { @lexer = Lexer.new }
 
   TOKENS = [
     [ :numeric, "123" ],
     [ :numeric, "0.6" ],
+    [ :numeric, ".6" ],
     [ :operator, "+" ],
+    [ :operator, "-" ],
+    [ :operator, "/" ],
+    [ :operator, UNARY_MINUS_INTERNAL_SYMBOL ],
     [ :constant, "pi" ],
     [ :value, "11K" ],
     [ :value, "11kΩ" ],
@@ -20,7 +23,7 @@ describe Lexer do
 
   it "lexify" do
     TOKENS.each do |token|
-      lexeme = @lexer.lexify(token.last)
+      lexeme = Lexer.lexify(token.last)
       expect(lexeme.type).to eq token.first
       expect(lexeme.value).to eq token.last
     end

data/spec/parser/pn_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+include Electr
+
+describe Pn do
+
+  describe '#to_f' do
+
+    it { expect(Pn.new('1000', 'n').to_f).to eq 1000.0 }
+
+    it { expect(Pn.new('1_000', 'n').to_f).to eq 1000.0 }
+
+    it { expect(Pn.new('1,000', 'n').to_f).to eq 1000.0 }
+
+  end
+
+end

data/spec/{sya_spec.rb → parser/sya_spec.rb}

@@ -47,6 +47,17 @@ describe Sya do
     expect(sya.run).to eq [added, a, b]
   end
 
+  specify '2 -pi' do
+    a = LexicalUnit.numeric('2')
+    b = LexicalUnit.operator(UNARY_MINUS_INTERNAL_SYMBOL)
+    c = LexicalUnit.constant('pi')
+    added = LexicalUnit.operator('*')
+    sya = Sya.new([a, b, c])
+
+    # * 2 um pi
+    expect(sya.run).to eq [added, a, b, c]
+  end
+
   specify '2 11K' do
     a = LexicalUnit.numeric('2')
     b = LexicalUnit.constant('11K')
@@ -150,4 +161,28 @@ describe Sya do
     expect(sya.run).to eq [a, d, c, e]
   end
 
+  specify 'um pi' do
+    a = LexicalUnit.operator(UNARY_MINUS_INTERNAL_SYMBOL)
+    b = LexicalUnit.constant('pi')
+    sya = Sya.new([a, b])
+
+    # Note that the symbol used internally isn't `-`.
+    # - pi
+    expect(sya.run).to eq [a, b]
+  end
+
+  specify 'um sqrt(49) + 1' do
+    a = LexicalUnit.operator(UNARY_MINUS_INTERNAL_SYMBOL)
+    b = LexicalUnit.fname('sqrt')
+    c = LexicalUnit.open_parenthesis
+    d = LexicalUnit.numeric('49')
+    e = LexicalUnit.closed_parenthesis
+    f = LexicalUnit.operator('+')
+    g = LexicalUnit.numeric('1')
+    sya = Sya.new([a, b, c, d, e, f, g])
+
+    # + um sqrt 49 1
+    expect(sya.run).to eq [f, a, b, d, g]
+  end
+
 end

data/spec/{tokenizer_spec.rb → parser/tokenizer_spec.rb}

@@ -19,6 +19,33 @@ describe Tokenizer do
     end
   end
 
+  specify "21" do
+    tkr = Tokenizer.new("21")
+    expect(tkr.next_token).to eq "21"
+  end
+
+  specify "-21" do
+    tkr = Tokenizer.new("-21")
+    expect(tkr.next_token).to eq "-21"
+  end
+
+  specify "-.1" do
+    tkr = Tokenizer.new("-.1")
+    expect(tkr.next_token).to eq "-.1"
+  end
+
+  specify "- 21" do
+    tkr = Tokenizer.new("- 21")
+    expect(tkr.next_token).to eq "-"
+    expect(tkr.next_token).to eq "21"
+  end
+
+  specify "- .1" do
+    tkr = Tokenizer.new("- .1")
+    expect(tkr.next_token).to eq "-"
+    expect(tkr.next_token).to eq ".1"
+  end
+
   specify "21 300" do
     tkr = Tokenizer.new("21 300")
     expect(tkr.next_token).to eq "21"
@@ -31,6 +58,17 @@ describe Tokenizer do
     expect(tkr.next_token).to eq "0.6"
   end
 
+  specify ".6" do
+    tkr = Tokenizer.new(".6")
+    expect(tkr.next_token).to eq ".6"
+  end
+
+  specify "2 .6" do
+    tkr = Tokenizer.new("2 .6")
+    expect(tkr.next_token).to eq "2"
+    expect(tkr.next_token).to eq ".6"
+  end
+
   specify "2 0.6 3" do
     tkr = Tokenizer.new("2 0.6 3")
     expect(tkr.next_token).to eq "2"
@@ -45,12 +83,48 @@ describe Tokenizer do
     expect(tkr.next_token).to eq "3"
   end
 
+  specify "2 + -3" do
+    tkr = Tokenizer.new("2 + -3")
+    expect(tkr.next_token).to eq "2"
+    expect(tkr.next_token).to eq "+"
+    expect(tkr.next_token).to eq "-3"
+  end
+
   specify "2 pi" do
     tkr = Tokenizer.new("2 pi")
     expect(tkr.next_token).to eq "2"
     expect(tkr.next_token).to eq "pi"
   end
 
+  specify "pi" do
+    tkr = Tokenizer.new("pi")
+    expect(tkr.next_token).to eq "pi"
+  end
+
+  specify "-pi" do
+    tkr = Tokenizer.new("-pi")
+    expect(tkr.next_token).to eq UNARY_MINUS_INTERNAL_SYMBOL
+    expect(tkr.next_token).to eq "pi"
+  end
+
+  specify "2 -pi" do
+    tkr = Tokenizer.new("2 -pi")
+    expect(tkr.next_token).to eq "2"
+    expect(tkr.next_token).to eq UNARY_MINUS_INTERNAL_SYMBOL
+    expect(tkr.next_token).to eq "pi"
+  end
+
+  specify "-2V" do
+    tkr = Tokenizer.new("-2V")
+    expect(tkr.next_token).to eq "-2V"
+  end
+
+  specify "-sqrt(7)" do
+    tkr = Tokenizer.new("-sqrt(7)")
+    expect(tkr.next_token).to eq UNARY_MINUS_INTERNAL_SYMBOL
+    expect(tkr.next_token).to eq "sqrt"
+  end
+
   specify "11K 22k 33kΩ" do
     tkr = Tokenizer.new("11K 22k 33kΩ")
     expect(tkr.next_token).to eq "11K"
@@ -99,4 +173,19 @@ describe Tokenizer do
     expect(tkr.next_token).to eq ")"
   end
 
+  specify "-(2 3)" do
+    tkr = Tokenizer.new("-(2 3)")
+    expect(tkr.next_token).to eq UNARY_MINUS_INTERNAL_SYMBOL
+    expect(tkr.next_token).to eq "("
+    expect(tkr.next_token).to eq "2"
+    expect(tkr.next_token).to eq "3"
+    expect(tkr.next_token).to eq ")"
+  end
+
+  specify "22_000_000 11,000" do
+    tkr = Tokenizer.new("22_000_000 11,000")
+    expect(tkr.next_token).to eq "22_000_000"
+    expect(tkr.next_token).to eq "11,000"
+  end
+
 end