electr 0.0.5 → 0.0.6

data/lib/electr/parser/token.rb

@@ -4,7 +4,8 @@ module Electr
     refine String do
 
       def numeric?
-        self =~ /[0-9.]\Z/
+        # I know it isn't the best regexp I can do…
+        self =~ /\A-?[0-9\.,_]+\z/
       end
 
       def operator?
@@ -17,7 +18,11 @@ module Electr
 
       def value?
         # The unit part is redondant with Tokenizer.
-        self =~ /[0-9.][A-Za-zΩ℧μ]{1,}\Z/
+        self =~ /[0-9.][A-Za-zΩ℧μ]{1,}\z/
+      end
+
+      def variable?
+        self =~ /\A[A-Z][0-9]+\z/
       end
 
     end

data/lib/electr/parser/tokenizer.rb

@@ -53,16 +53,22 @@ module Electr
     end
 
     def produce_next_token
+
       if begin_like_number?
         get_number
+
       elsif unary_minus?
         get_unary_minus
+
       elsif ONE_CHAR_OPERATORS.include?(@look_ahead)
         add_this_char
-      elsif @look_ahead == '('
-        add_this_char
-      elsif @look_ahead == ')'
+
+      elsif %w( \( \) = ).include?(@look_ahead)
         add_this_char
+
+      elsif variable?
+        get_variable
+
       else
         get_word
       end
@@ -84,6 +90,10 @@ module Electr
       @look_ahead == '-' && @codeline[@index] =~ /[a-z\(]/
     end
 
+    def variable?
+      @look_ahead =~ /[A-Z]/ && @codeline[@index] =~ /[0-9]/
+    end
+
     def get_unary_minus
       @look_ahead = UNARY_MINUS_INTERNAL_SYMBOL
       add_look_ahead
@@ -99,9 +109,15 @@ module Electr
       @token
     end
 
+    def get_variable
+      add_look_ahead
+      add_look_ahead while @look_ahead =~ /[0-9]/
+      @token
+    end
+
     def get_word
       add_look_ahead while @look_ahead =~ /[\w√]/
-      # At this step, an empty token signify that we have reached an
+      # At this point, an empty token means that we have reached an
       # illegal word.
       raise(SyntaxError, @codeline) if @token.empty?
       @token

data/lib/electr/repl.rb

@@ -7,3 +7,4 @@ require "electr/repl/ast_reader"
 require "electr/repl/printer"
 require "electr/repl/ast_printer"
 require "electr/repl/repl"
+require "electr/repl/electr_value"

data/lib/electr/repl/electr_value.rb

@@ -0,0 +1,78 @@
+module Electr
+
+  # ElectrValue is the container of an evaluation's result.
+  #
+  # The result of the evaluation step can be of three types:
+  #
+  # - number
+  # - error
+  # - hidden
+  #
+  # The type number is the most common one. It's, you know, just a number.
+  # It's the result of the evaluation of `2k 3`, which is the number 6000.
+  # An ElectrValue of type number is meant to be printed on the screen.
+  #
+  # If an evaluation raised an error, it produced an ElectrValue of type
+  # error. This ElectrValue holds the error message.
+  #
+  # The type hidden is just a special case of a number. It is produced as
+  # the result of the evaluation of an assignment. That is, `R1 = 100`
+  # produces an ElectrValue of type hidden. It holds the number 100 but is
+  # not likely to be printed on the screen, thus the type hidden.
+  #
+  # Creating a new ElectrValue is done using class constructors:
+  #
+  #   ElectrValue.number(100.0)
+  #   ElectrValue.hidden(200.0)
+  #   ElectrValue.error("Bad syntax error!")
+  #
+  # The class has dedicated method to check the various types:
+  #
+  #   val = ElectrValue.number(100.0)
+  #   val.number? #=> true
+  #   val.hidden? #=> false
+  #   val.error?  #=> false
+  class ElectrValue
+
+    def self.number(number)
+      new(number)
+    end
+
+    def self.error(message)
+      new(0, :error, message)
+    end
+
+    def self.hidden(number)
+      new(number, :hidden)
+    end
+
+    def initialize(number, type = :number, message = "")
+      @number = number
+      @type = type
+      @error = message
+    end
+    private_class_method :new
+
+    attr_reader :number, :type, :error
+
+    def number?
+      @type == :number
+    end
+
+    def error?
+      @type == :error
+    end
+
+    def hidden?
+      @type == :hidden
+    end
+
+    # Say it's equal only if all three fields are equals. This is enough
+    # for now and there is no needs to check equality type by type.
+    def ==(other)
+      return false unless other.is_a?(ElectrValue)
+      @number == other.number && @type == other.type && @error = other.error
+    end
+
+  end
+end

data/lib/electr/repl/evaluator.rb

@@ -5,24 +5,92 @@ module Electr
 
     def initialize
       @stack = []
+      @environment = {}
     end
 
+    # The environment is where we record the variable's names and
+    # values.
+    #
+    # Useful for testing purposes, for now there is no other needs to
+    # expose this variable.
+    attr_reader :environment
+
+    # Do the evaluation.This method must return something meaningful for
+    # the Printer object. So returning nil isn't an option here.
+    #
+    # list - A list of Pn item (Prefix notation).
+    #
+    # Returns the ElectrValue result of the evaluation.
+    #
+    # See also Printer and Pn.
     def evaluate_pn(list)
+
       while item = list.pop
+
         case item.name
-        when "numeric" then @stack.push(item.to_f)
+        when "numeric"  then @stack.push(item.to_f)
+        when "variable" then @stack.push(item.value)
         when "constant" then @stack.push(constant(item.value))
-        when "value" then do_value(item.value)
+        when "value"    then do_value(item.value)
         when "operator" then operation(item.value)
         when "funcname" then EvalFunction.eval(item.value, @stack)
         end
       end
 
-      @stack.pop
+      result = @stack.pop
+      if result.respond_to?(:hidden?)
+        result
+      else
+        ElectrValue.number(ensure_number(result))
+      end
+
+    rescue UnboundVariableError => e
+      @stack.clear
+      ElectrValue.error("Error: unbound variable #{e.message}")
+
+    rescue NilEvaluationError
+      @stack.clear
+      ElectrValue.error("Error: nil evaluation")
+
     end
 
     private
 
+    # In case we got the name of a variable, replace it by its value.
+    #
+    # wannabe_number - An object that can be coerced to a number. Either
+    #                  a Numeric number, the String name of a variable,
+    #                  or an ElectrValue.
+    #
+    # Returns a Numeric number.
+    def ensure_number(wannabe_number)
+
+      wannabe_number or raise(NilEvaluationError)
+
+      if wannabe_number.is_a?(String)
+        get_value_from_variable(wannabe_number)
+
+      elsif wannabe_number.respond_to?(:number)
+        wannabe_number.number
+
+      else
+        wannabe_number
+      end
+    end
+
+    # Get the value of a variable stored in the environment.
+    #
+    # name - The String name of the variable.
+    #
+    # Returns the Numeric value of the variable.
+    #
+    # Raises UnboundVariableError if the variable don't exist in the
+    # environment.
+    def get_value_from_variable(name)
+      variable = @environment[name]
+      variable ? variable.number : raise(UnboundVariableError, name)
+    end
+
     def constant(value)
       case value
       when "pi" then Math::PI
@@ -30,22 +98,34 @@ module Electr
     end
 
     def operation(operand)
-      if operand == UNARY_MINUS_INTERNAL_SYMBOL
-        unary_minus
+      case operand
+      when UNARY_MINUS_INTERNAL_SYMBOL then unary_minus
+      when "=" then assign
       else
         classic_operation(operand)
       end
     end
 
+    def assign
+      variable = @stack.pop
+      value = ensure_number(@stack.pop)
+      @environment[variable] = ElectrValue.number(value)
+      @stack.push(ElectrValue.hidden(value))
+    end
+
     def unary_minus
       a = @stack.pop
       @stack.push(-a)
     end
 
     def classic_operation(operand)
+
+      # Use the native ruby operand for exponentiation.
       operand = "**" if operand == '^'
-      a = @stack.pop
-      b = @stack.pop
+
+      a = ensure_number(@stack.pop)
+      b = ensure_number(@stack.pop)
+
       @stack.push(a.send(operand, b))
     end
 
@@ -54,15 +134,20 @@ module Electr
       # (ohm, volt, ampere, etc) and for the prefix ([m]illi, [k]ilo,
       # etc).
       val = str.to_f
+
       if %w( k K ).include?(str[-1]) || %w( kΩ ).include?(str[-2..-1])
         val *= 1_000
+
       elsif %w( mA mV mW ).include?(str[-2..-1])
         val *= 0.001
+
       elsif %w( u μ ).include?(str[-1]) || %w( μF uF ).include?(str[-2..-1])
         val *= 0.000_001
+
       elsif str[-1] == 'p' || str[-2..-1] == 'pF'
         val *= 0.000_000_001
       end
+
       @stack.push(val)
     end
 

data/lib/electr/repl/printer.rb

@@ -1,11 +1,34 @@
 module Electr
 
-  # Prints the computation.
+  # It knows how to print the result of an evaluation.
   class Printer
 
+    # result - The ElectrValue result of an evaluation.
     def self.run(result)
-      truncated = result.truncate
-      puts result == truncated ? truncated : result.round(10)
+      new(result).print
+    end
+
+    def initialize(result)
+      @result = result
+    end
+
+    def print
+      if @result.number?
+        print_number
+      elsif @result.error?
+        print_error
+      end
+      # If hidden, print nothing.
+    end
+
+    def print_number
+      number = @result.number
+      truncated = number.truncate
+      puts number == truncated ? truncated : number.round(10)
+    end
+
+    def print_error
+      puts @result.error
     end
 
   end

data/lib/electr/version.rb

@@ -1,4 +1,4 @@
 module Electr
-  VERSION = "0.0.5"
-  CODENAME = "Units"
+  VERSION = "0.0.6"
+  CODENAME = "Vacuist Variables"
 end

data/spec/compiler_spec.rb

@@ -17,6 +17,8 @@ describe Compiler do
     "3 (2 + 1)",
     "2 sqrt(3)",
     "2 pi 0.5uF sqrt(11K 22K)",
+    "1,234 + 1_234",
+    "C1 = 0.1",
   ]
 
   specify "#compile_to_ast" do
@@ -26,9 +28,38 @@ describe Compiler do
     end
   end
 
-  specify "#compile_to_pn" do
-    result = Compiler.compile_to_pn("2 pi")
-    expect(result).to be_a Array
+  describe "number" do
+
+    it "allows , and _" do
+      result = Compiler.compile_to_pn("1,234 + 1_234")
+      expect(result[2].name).to eq "operator"
+      expect(result[2].value).to eq "+"
+      expect(result[3].name).to eq "numeric"
+      expect(result[3].value).to eq "1,234"
+      expect(result[4].name).to eq "numeric"
+      expect(result[4].value).to eq "1_234"
+    end
+  end
+
+  describe "Prefix notation" do
+
+    specify "#compile_to_pn" do
+      result = Compiler.compile_to_pn("2 pi")
+      expect(result).to be_a Array
+    end
+
+    specify "assignment" do
+      result = Compiler.compile_to_pn("R1 = 100")
+      expect(result[0].name).to eq "ast"
+      expect(result[1].name).to eq "root"
+      expect(result[2].value).to eq "="
+      expect(result[2].name).to eq "operator"
+      expect(result[3].value).to eq "R1"
+      expect(result[3].name).to eq "variable"
+      expect(result[4].value).to eq "100"
+      expect(result[4].name).to eq "numeric"
+    end
+
   end
 
   describe "Bug in the AST with `sin(pi / 2) + 1`" do
@@ -66,4 +97,32 @@ describe Compiler do
 
   end
 
+  # The result is as expected if one specify the multiplication symbol:
+  #
+  #     R1 = 2
+  #     R2 = 5
+  #     R1 * R2
+  #     #=> 10
+  #
+  # The bug shows itself when one doesn't use *:
+  #
+  #     R1 = 2
+  #     R2 = 5
+  #     R1 R2
+  #     #=> 2
+  describe "Bug with multiplication and variables" do
+
+    specify do
+      result = Compiler.compile_to_pn("R1 R2")
+
+      expect(result[2].value).to eq "*"
+      expect(result[2].name).to eq "operator"
+      expect(result[3].value).to eq "R1"
+      expect(result[3].name).to eq "variable"
+      expect(result[4].value).to eq "R2"
+      expect(result[4].name).to eq "variable"
+    end
+
+  end
+
 end

data/spec/parser/lexer_spec.rb

@@ -8,6 +8,9 @@ describe Lexer do
     [ :numeric, "123" ],
     [ :numeric, "0.6" ],
     [ :numeric, ".6" ],
+    [ :numeric, "-.6" ],
+    [ :numeric, "-0.6" ],
+    [ :numeric, "-123" ],
     [ :operator, "+" ],
     [ :operator, "-" ],
     [ :operator, "/" ],
@@ -19,6 +22,8 @@ describe Lexer do
     [ :fname, "sqrt" ],
     [ :open_parenthesis, "(" ],
     [ :closed_parenthesis, ")" ],
+    [ :assign, "=" ],
+    [ :variable, "R1" ],
   ]
 
   it "lexify" do