electr 0.0.2

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

@@ -0,0 +1,79 @@
+module Electr
+
+  class ExpressionRule < BaseRule
+
+    def apply!
+      while @units.size > 0
+        if first_unit_fname?
+          accept(:fname)
+          accept(:open_parenthesis, '(')
+          while @units.first && (not @units.first.closed_parenthesis?)
+            accept(@units.first.type)
+          end
+          accept(:closed_parenthesis, ')')
+        else
+          accept(@units.first.type)
+        end
+      end
+
+      sya = Sya.new(@series.dup)
+      @series = sya.run
+
+      if @series.first.numeric? || @series.first.constant? ||
+         @series.first.value? || @series.first.fname?
+        dig_series(@ast_node)
+      else
+        unit = @series.shift
+        node = OperatorAST.new(unit.value)
+        dig_series(node) while @series.size > 0
+        @ast_node.add_child(node)
+      end
+    end
+
+    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?
+    end
+
+    def first_unit_fname?
+      @units.first && @units.first.fname?
+    end
+
+    def dig_series(node)
+      while unit = @series.shift
+        if unit && unit.numeric? && node.size < 2
+          node.add_child(NumericAST.new(unit.value))
+        elsif unit && unit.constant? && node.size < 2
+          node.add_child(ConstantAST.new(unit.value))
+        elsif unit && unit.value? && node.size < 2
+          node.add_child(ValueAST.new(unit.value))
+        elsif unit && unit.fname? && node.size < 2
+          func      = FuncAST.new
+          func_name = FuncNameAST.new(unit.value)
+          func_args = FuncArgsAST.new
+          dig_series(func_args)
+          func.add_child(func_name)
+          func.add_child(func_args)
+          node.add_child(func)
+        elsif unit && unit.operator?
+          new_node = OperatorAST.new(unit.value)
+          dig_series(new_node)
+          node.add_child(new_node)
+        else
+          @series.unshift(unit)
+          break
+        end
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,21 @@
+module Electr
+
+  class RootRule < BaseRule
+
+    def apply!
+      root_node = RootAST.new
+      while more_units?
+        ExpressionRule.new(@units, root_node).apply!
+      end
+      @ast_node.add_child(root_node)
+    end
+
+    private
+
+    def more_units?
+      @units.size > 0
+    end
+
+  end
+end
+

data/lib/electr/parser/sya.rb

@@ -0,0 +1,105 @@
+module Electr
+
+  # Shunting Yard Algorithm.
+  #
+  # It produces prefix notation instead of the most common reverse
+  # 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},
+    }
+
+    # lexical_units - Array of LexicalUnit in the order they have been
+    #                 parsed (natural ordering).
+    def initialize(lexical_units)
+      @units = lexical_units
+      insert_multiplication
+      @output = []
+      @operator = []
+    end
+
+    # Run the Shunting Yard Algorithm.
+    #
+    # Returns Array of LexicalUnit ordered with prefix notation.
+    def run
+      while unit = @units.pop
+        if unit.number?
+          @output.push(unit)
+        elsif unit.fname?
+          @operator.push(unit)
+        elsif unit.type == :closed_parenthesis
+          @operator.push(unit)
+        elsif unit.type == :open_parenthesis
+          while @operator.last &&
+                @operator.last.type != :closed_parenthesis
+            @output.push(@operator.pop)
+          end
+          rparen = @operator.pop
+          if @operator.last && @operator.last.type == :fname
+            @output.push(@operator.pop)
+          end
+          # If the stack runs out without finding a right parenthesis,
+          # then there are mismatched parentheses.
+        elsif unit.operator?
+          while @operator.size > 0 &&
+                (@operator.last.operator? || @operator.last.fname?) &&
+                (precedence(unit) < precedence(@operator.last))
+            @output.push(@operator.pop)
+          end
+          @operator.push(unit)
+        end
+      end
+
+      @output.push(@operator.pop) while @operator.size > 0
+
+      @output.reverse
+    end
+
+    private
+
+    # Look up the precedence of an operator.
+    #
+    # operator - LexicalUnit operator.
+    #
+    # Returns the Fixnum precedence of `operator`.
+    def precedence(operator)
+      if operator.fname?
+        PRECEDENCE['()'][:val]
+      else
+        PRECEDENCE[operator.value][:val]
+      end
+    end
+
+    # Insert the multiplication operator (`*`) where it is needed inside
+    # the @units member. This is because in Electr the `*` is implicit.
+    #
+    # Examples
+    #
+    #   # @units before: 2 3
+    #   # @units after:  2 * 3
+    #
+    # Returns nothing.
+    def insert_multiplication
+      temp = []
+      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
+        end
+      end
+      @units = temp
+    end
+
+  end
+end

data/lib/electr/parser/syntaxer.rb

@@ -0,0 +1,21 @@
+module Electr
+
+  # A Syntaxer transform a list of lexical units into an AST.
+  class Syntaxer
+
+    # lexical_units - Array of LexicalUnits
+    def initialize(lexical_units)
+      @units = lexical_units
+      @ast = AST.new "ast"
+    end
+
+    # Public: Compile lexical units into an AST.
+    #
+    # Returns the AST.
+    def run
+      RootRule.new(@units, @ast).apply!
+      @ast
+    end
+
+  end
+end

data/lib/electr/parser/tokenizer.rb

@@ -0,0 +1,79 @@
+module Electr
+
+  class Tokenizer
+
+    ONE_CHAR_SYMBOLS = %w( + - / )
+
+    def initialize(string)
+      @index = 0
+      @token = ''
+      @look_ahead = ''
+      @codeline = string
+      forward_look_ahead
+    end
+
+    def has_more_token?
+      @index <= @codeline.size
+    end
+
+    def next_token
+      ret = produce_next_token
+      skip_white
+      @token = ''
+      ret
+    end
+
+    private
+
+    def forward_look_ahead
+      @look_ahead = @codeline[@index, 1]
+      @index += 1
+    end
+
+    def produce_next_token
+      if @look_ahead =~ /[0-9]/
+        get_number
+      elsif ONE_CHAR_SYMBOLS.include?(@look_ahead)
+        add_this_char
+      elsif @look_ahead == '('
+        add_this_char
+      elsif @look_ahead == ')'
+        add_this_char
+      else
+        get_word
+      end
+    end
+
+    def skip_white
+      forward_look_ahead while @look_ahead == ' '
+    end
+
+    def get_number
+      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
+    end
+
+    # Add current character to the current token and return it.
+    # Usefull shorthand for single character's tokens.
+    #
+    # Returns the String current token.
+    def add_this_char
+      add_look_ahead
+      @token
+    end
+
+  end
+end

data/lib/electr/repl.rb

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

data/lib/electr/rules.rb

@@ -0,0 +1,3 @@
+require "electr/parser/rules/base_rule"
+require "electr/parser/rules/root_rule"
+require "electr/parser/rules/expression_rule"

data/lib/electr/version.rb

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

data/spec/compiler_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+include Electr
+
+describe Compiler do
+
+  CODES_TO_COMPILE = [
+    "21 + 3",
+    "2",
+    "2 pi",
+    "2 11K",
+    "sqrt(49) + 1",
+    "sqrt(49)",
+    "1 + sqrt(49)",
+    "3 / (2 + 1)",
+    "sqrt(40 + 9)",
+    "3 (2 + 1)",
+    "2 sqrt(3)",
+  ]
+
+  specify "#compile_to_ast" do
+    CODES_TO_COMPILE.each do |code|
+      compiler = Compiler.new
+      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.display
+    expect(result).to be_a AST
+  end
+
+  specify "#compile_to_pn" do
+    compiler = Compiler.new
+    result = compiler.compile_to_pn("2 pi")
+    expect(result).to be_a Array
+  end
+
+end

data/spec/electr_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Electr do
+  it 'has a version number' do
+    expect(Electr::VERSION).not_to be nil
+  end
+end

data/spec/evaluator_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+include Electr
+
+describe Evaluator do
+
+  CODES_TO_EVAL = [
+    {code: "2", result: 2},
+    {code: "2 3", result: 6},
+    {code: "2 pi", result: 2 * Math::PI},
+    {code: "2 + 3", result: 5},
+    {code: "2 - 3", result: -1},
+    {code: "3 / 2", result: 1.5},
+    {code: "2 11k", result: 22_000},
+    {code: "sqrt(49)", result: 7},
+    {code: "3V / 25mA", result: 120},
+    {code: "110V / 2A", result: 55},
+    {code: "10mV 100R", result: 1},
+    {code: "10W 2", result: 20},
+    {code: "100mW 2", result: 0.2},
+  ]
+
+  specify "#evaluate_pn" do
+    CODES_TO_EVAL.each do |code|
+      compiler = Compiler.new
+      pns = compiler.compile_to_pn(code[:code])
+
+      evaluator = Evaluator.new
+      result = evaluator.evaluate_pn(pns)
+
+      expect(result).to eq code[:result]
+    end
+  end
+
+  specify do
+    compiler = Compiler.new
+    pns = compiler.compile_to_pn("1 - 1 + 4 - 1 - 1")
+    
+    evaluator = Evaluator.new
+    result = evaluator.evaluate_pn(pns)
+
+    expect(result).to eq 2
+  end
+
+
+
+end