electr 0.0.2 → 0.0.3

data/lib/electr/parser/lexical_unit.rb

@@ -1,11 +1,14 @@
 module Electr
 
+  # Holds some data about a lexica unit (lexeme) of the language.
   class LexicalUnit
 
     private_class_method :new
 
     attr_reader :type, :value
 
+    # Create a new LexicalUnit.
+    #
     # type  - Symbol
     # value - String
     def initialize(type, value)
@@ -35,6 +38,10 @@ module Electr
       @type == :operator
     end
 
+    def unary_minus?
+      operator? && @value == UNARY_MINUS_INTERNAL_SYMBOL
+    end
+
     def constant?
       @type == :constant
     end
@@ -47,10 +54,6 @@ module Electr
       @type == :fname
     end
 
-    def fcall?
-      @type == :fcall
-    end
-
     def number?
       numeric? || constant? || value?
     end

data/lib/electr/parser/rules/base_rule.rb

@@ -1,9 +1,11 @@
 module Electr
 
+  # Base class for the rules. «Just» follow the grammar's rules to
+  # produce the AST.
   class BaseRule
 
     # Initialize a new rule. The units and ast_node objects
-    # given in arguments will be modified by #apply!.
+    # given in arguments will be modified by #apply.
     #
     # units    - Array of LexicalUnits.
     # ast_node - An AST object, for adding children, etc.
@@ -14,9 +16,9 @@ module Electr
     end
 
     # Public: Apply the rule to the list of lexical units, creating
-    # and/or modifying the ast node. #apply! modify the units and
+    # and/or modifying the ast node. #apply modify the units and
     # ast_node objects given to #initialize.
-    def apply!
+    def apply
       raise NotImplementedError
     end
 
@@ -45,16 +47,6 @@ module Electr
       end
     end
 
-    # A shortcut method to #accept. Usefull when we have several calls
-    # to #accept. Calls #accept for each of the symbol in args.
-    #
-    # args - A series of Symbol.
-    #
-    # Returns nothing.
-    def accept_all(*args)
-      args.each {|arg| accept(arg) }
-    end
-
   end
 end
 

data/lib/electr/parser/rules/expression_rule.rb

@@ -1,8 +1,12 @@
 module Electr
 
+  # Rules an Electr expression.
+  #
+  # TODO For now almost everything is an expression in Electr, so this
+  # is a somewhat complicated class. It should be refactored a lot.
   class ExpressionRule < BaseRule
 
-    def apply!
+    def apply
       while @units.size > 0
         if first_unit_fname?
           accept(:fname)
@@ -19,8 +23,7 @@ module Electr
       sya = Sya.new(@series.dup)
       @series = sya.run
 
-      if @series.first.numeric? || @series.first.constant? ||
-         @series.first.value? || @series.first.fname?
+      if number?
         dig_series(@ast_node)
       else
         unit = @series.shift
@@ -32,16 +35,9 @@ module Electr
 
     private
 
-    def first_unit_number?
-      @units.first && @units.first.number?
-    end
-
-    def first_unit_numeric?
-      @units.first && @units.first.numeric?
-    end
-
-    def first_unit_operator?
-      @units.first && @units.first.operator?
+    def number?
+      first = @series.first
+      first.numeric? || first.constant? || first.value? || first.fname?
     end
 
     def first_unit_fname?
@@ -50,13 +46,13 @@ module Electr
 
     def dig_series(node)
       while unit = @series.shift
-        if unit && unit.numeric? && node.size < 2
+        if unit && unit.numeric? && there_is_room?(node)
           node.add_child(NumericAST.new(unit.value))
-        elsif unit && unit.constant? && node.size < 2
+        elsif unit && unit.constant? && there_is_room?(node)
           node.add_child(ConstantAST.new(unit.value))
-        elsif unit && unit.value? && node.size < 2
+        elsif unit && unit.value? && there_is_room?(node)
           node.add_child(ValueAST.new(unit.value))
-        elsif unit && unit.fname? && node.size < 2
+        elsif unit && unit.fname? && there_is_room?(node)
           func      = FuncAST.new
           func_name = FuncNameAST.new(unit.value)
           func_args = FuncArgsAST.new
@@ -75,5 +71,10 @@ module Electr
       end
     end
 
+    def there_is_room?(node)
+      (node.value == UNARY_MINUS_INTERNAL_SYMBOL && node.size < 1) ||
+      (node.value != UNARY_MINUS_INTERNAL_SYMBOL && node.size < 2)
+    end
+
   end
 end

data/lib/electr/parser/rules/root_rule.rb

@@ -1,11 +1,14 @@
 module Electr
 
+  # Starting point for the rules.
+  #
+  # TODO Is this really needed?
   class RootRule < BaseRule
 
-    def apply!
+    def apply
       root_node = RootAST.new
       while more_units?
-        ExpressionRule.new(@units, root_node).apply!
+        ExpressionRule.new(@units, root_node).apply
       end
       @ast_node.add_child(root_node)
     end

data/lib/electr/parser/sya.rb

@@ -6,18 +6,10 @@ module Electr
   # polish notation to ease producing the AST.
   class Sya
 
-    PRECEDENCE = {
-      '()' => {assoc: 'L', val: 99},
-      ')'  => {assoc: 'L', val: 99},
-      '('  => {assoc: 'L', val: 99},
-      '*'  => {assoc: 'L', val: 10},
-      '/'  => {assoc: 'L', val: 10},
-      '-'  => {assoc: 'L', val:  1},
-      '+'  => {assoc: 'L', val:  1},
-    }
-
+    # Creates a new Sya.
+    #
     # lexical_units - Array of LexicalUnit in the order they have been
-    #                 parsed (natural ordering).
+    #                 parsed (natural/infix ordering).
     def initialize(lexical_units)
       @units = lexical_units
       insert_multiplication
@@ -25,7 +17,7 @@ module Electr
       @operator = []
     end
 
-    # Run the Shunting Yard Algorithm.
+    # Public: Run the Shunting Yard Algorithm.
     #
     # Returns Array of LexicalUnit ordered with prefix notation.
     def run
@@ -87,18 +79,27 @@ module Electr
     #
     # Returns nothing.
     def insert_multiplication
-      temp = []
+      new_units = []
       while unit = @units.shift
-        temp << unit
-        if @units.first
-          if (@units.first.number? && unit.number?) ||
-             (@units.first.open_parenthesis? && unit.number?) ||
-             (@units.first.fname? && unit.number?)
-            temp << LexicalUnit.operator('*')
-          end
+        new_units << unit
+        if maybe_insertion_needed?(unit)
+          new_units << LexicalUnit.operator('*') if insertion_needed?
         end
       end
-      @units = temp
+      @units = new_units
+    end
+
+    def maybe_insertion_needed?(unit)
+      unit_ahead && unit.number?
+    end
+
+    def insertion_needed?
+      unit_ahead.number? || unit_ahead.open_parenthesis? ||
+      unit_ahead.fname? || unit_ahead.unary_minus?
+    end
+
+    def unit_ahead
+      @units.first
     end
 
   end

data/lib/electr/parser/syntaxer.rb

@@ -1,6 +1,9 @@
 module Electr
 
   # A Syntaxer transform a list of lexical units into an AST.
+  #
+  # There isn't a monolithic class that does this work. There is
+  # actually some rule's classes to make the AST.
   class Syntaxer
 
     # lexical_units - Array of LexicalUnits
@@ -13,7 +16,7 @@ module Electr
     #
     # Returns the AST.
     def run
-      RootRule.new(@units, @ast).apply!
+      RootRule.new(@units, @ast).apply
       @ast
     end
 

data/lib/electr/parser/token.rb

@@ -0,0 +1,26 @@
+module Electr
+  module Token
+
+    refine String do
+
+      def numeric?
+        self =~ /[0-9.]\Z/
+      end
+
+      def operator?
+        ['+', '-', '/', UNARY_MINUS_INTERNAL_SYMBOL].include?(self)
+      end
+
+      def constant?
+        %w( pi ).include?(self)
+      end
+
+      def value?
+        # The unit part is redondant with Tokenizer.
+        self =~ /[0-9.][kKRuFpΩμAmWV]{1,}\Z/
+      end
+
+    end
+
+  end
+end

data/lib/electr/parser/tokenizer.rb

@@ -1,9 +1,22 @@
 module Electr
 
+  # The tokenizer is the first step of the parser. It explodes a code in
+  # its constituants (token), ie # `sqrt(3+2)` becomes the following
+  # list of tokens:
+  #
+  # - `sqrt`
+  # - `(`
+  # - `3`
+  # - `+`
+  # - `2`
+  # - `)`
   class Tokenizer
 
     ONE_CHAR_SYMBOLS = %w( + - / )
 
+    # Create a new Tokenizer for a specific code.
+    #
+    # string - The String code to tokenize.
     def initialize(string)
       @index = 0
       @token = ''
@@ -12,10 +25,16 @@ module Electr
       forward_look_ahead
     end
 
+    # Public: Check if the tokenizer is able to give another token.
+    #
+    # Returns Boolean true if there is another waiting token.
     def has_more_token?
       @index <= @codeline.size
     end
 
+    # Public: Get the next token.
+    #
+    # Returns a String token.
     def next_token
       ret = produce_next_token
       skip_white
@@ -30,9 +49,16 @@ module Electr
       @index += 1
     end
 
+    def add_look_ahead
+      @token << @look_ahead
+      forward_look_ahead
+    end
+
     def produce_next_token
-      if @look_ahead =~ /[0-9]/
+      if begin_like_number?
         get_number
+      elsif unary_minus?
+        get_unary_minus
       elsif ONE_CHAR_SYMBOLS.include?(@look_ahead)
         add_this_char
       elsif @look_ahead == '('
@@ -48,19 +74,33 @@ module Electr
       forward_look_ahead while @look_ahead == ' '
     end
 
+    def begin_like_number?
+      @look_ahead =~ /[0-9.]/ ||
+      (@look_ahead == '-' && @codeline[@index] =~ /[0-9.]/)
+    end
+
+    def unary_minus?
+      # We are able to recognize the unary minus operator only when it
+      # is followed by a name (constant or function) or an open
+      # parenthesis.
+      @look_ahead == '-' && @codeline[@index] =~ /[a-z\(]/
+    end
+
+    def get_unary_minus
+      @look_ahead = UNARY_MINUS_INTERNAL_SYMBOL
+      add_look_ahead
+      @token
+    end
+
     def get_number
-      add_look_ahead while @look_ahead =~ /[0-9.]/
+      add_look_ahead if @look_ahead == '-'
+      add_look_ahead while @look_ahead =~ /[0-9._,]/
       if @token[-1] != '.'
         add_look_ahead while @look_ahead =~ /[kKRuFpΩμAmWV]/
       end
       @token
     end
 
-    def add_look_ahead
-      @token << @look_ahead
-      forward_look_ahead
-    end
-
     def get_word
       add_look_ahead while @look_ahead =~ /\w/
       @token

data/lib/electr/repl.rb

@@ -1,56 +1,8 @@
-module Electr
-
-  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(options)
-      @options = options
-      puts BANNER
-    end
-
-    def run
-      if @options[:ast]
-        print_ast(read_ast) while true
-      else
-        _print(_eval(_read)) while true
-      end
-    end
-
-    private
-
-    def _read
-      print("E> ")
-      line = STDIN.gets.chomp
-      compiler = Compiler.new
-      compiler.compile_to_pn(line)
-    end
-
-    def read_ast
-      print("E--ast> ")
-      line = STDIN.gets.chomp
-      compiler = Compiler.new
-      compiler.compile_to_ast(line)
-    end
-
-    def _eval(pns)
-      evaluator = Evaluator.new
-      evaluator.evaluate_pn(pns)
-    end
-
-    def _print(result)
-      if result == result.truncate
-        puts result.truncate
-      else
-        puts result.round(10)
-      end
-    end
-
-    def print_ast(ast)
-      ast.display
-    end
-
-  end
-end
+require "electr/repl/evaluator"
+require "electr/repl/nil_evaluator"
+require "electr/repl/base_reader"
+require "electr/repl/reader"
+require "electr/repl/ast_reader"
+require "electr/repl/printer"
+require "electr/repl/ast_printer"
+require "electr/repl/repl"