electr 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 129c7c8560ec169ade1a934c574de8a045e3dbc0
-  data.tar.gz: c04ece5fd979bad30c69e5d67b64899b841ac72e
+  metadata.gz: 6be27b7b5efaeb5cb477f1bda270e4d1b95d4fec
+  data.tar.gz: 086e216808aa9e6709ee47ff5a648a3d175779f7
 SHA512:
-  metadata.gz: faee90b0d4a72a8bf8c74c9530c697062e7edde33c6c96b0135d56aa93bda5573e1d78647279b7104622300bab369900f1ffd5d2d2be0b30915af20bc5430b6e
-  data.tar.gz: c04497b5911bb940656a495eaab0232be5394b456baf27c4f1a209a3aa2e86f27630e986b59b2499ba3c417a0bf557305c1f04fbe698a1795f6dc3a6e23fd23f
+  metadata.gz: 9d206038f0b0f77a76fc388c1f152416f623af280a766cb93f67fdf547e200c4ad3d135f6b2db4a2c4ce2e560eb55ef43bd3dde0bc14cf83c534bc3b352c272c
+  data.tar.gz: 3877f48e19951b1b2cb78b4fa0b3ef9197b16229246e63a18e1aefa575b054cade8fd5497815beb237204c5624e58a00a39fcf417d1725743b3747f0eff4adc4

data/.coco.yml

@@ -0,0 +1,4 @@
+:excludes:
+- lib/electr/version.rb
+- lib/electr/option.rb
+:always_run: false

data/.gitignore

@@ -13,3 +13,4 @@
 *.a
 mkmf.log
 TODO
+tags

data/CHANGELOG.md

@@ -3,6 +3,14 @@ All notable changes to this project will be documented in this file.
 This project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased] - unreleased
+### Added
+- Quit gracefuly with Ctrl-C
+- 10,000 and 10_000 are the same as 10000
+- Electr supports negative numbers
+- Coco, a code coverage tool as a developer dependency
+- Enable Travis Continuous Integration tool
+### Modified
+- One can write floating point number without a leading zero (ie `.678`).
 
 ## [0.0.2] - 2015-09-04
 ### Added

data/README.md

@@ -1,5 +1,4 @@
-Electr
-======
+# Electr [![Gem Version](https://badge.fury.io/rb/electr.png)](http://badge.fury.io/rb/electr)
 
 Interactive language for electronic formulas.
 
@@ -117,16 +116,16 @@ Electr is at a very early stage and it miss a lot of (basic) things!
 You can expect that the following features will be implemented in the
 next couple of days/weeks:
 
-[ ] Negative numbers
-[ ] `*` for the multiplication if one want to
-[ ] √ for an alternative to square root
-[ ] Floating point number without a leading zero (ie `.678`)
-[ ] More buitin functions (sin, cos, tan, etc)
-[ ] Exponent
-[ ] Shortcuts for function's names (ie sq and sqr for sqrt)
-[ ] Readline lib in the REPL for a better user experience
-[ ] 10_000 or 10,000 will be the same as 10000
-[ ] All units and prefix used in electronic
+- [x] Negative numbers
+- [x] Floating point number without a leading zero (ie `.678`)
+- [x] 10_000 or 10,000 will be the same as 10000
+- [ ] `*` for the multiplication if one want to
+- [ ] √ for an alternative to square root
+- [ ] More builtin functions (sin, cos, tan, etc)
+- [ ] Exponent
+- [ ] Shortcuts for function's names (ie sq and sqr for sqrt)
+- [ ] Readline lib in the REPL for a better user experience
+- [ ] All units and prefix used in electronic
 
 ## What's next?
 
@@ -177,7 +176,7 @@ Why not having custom functions?
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/electr/fork )
+1. Fork it ( https://github.com/lkdjiin/electr/fork )
 2. **PLEASE Create your feature branch** (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/bin/electr

@@ -2,18 +2,18 @@
 
 require 'electr'
 
+trap("INT") { puts "\nBye."; exit }
+
 opt = Electr::Option.new
 
 if opt[:expression]
   if opt[:ast]
-    compiler = Electr::Compiler.new
-    ast = compiler.compile_to_ast(opt[:expression])
+    ast = Electr::Compiler.compile_to_ast(opt[:expression])
     ast.display
   else
     # FIXME Should be under lib/ to be tested and there is a lot of
     # common code with Repl.
-    compiler = Electr::Compiler.new
-    temp = compiler.compile_to_pn(opt[:expression])
+    temp = Electr::Compiler.compile_to_pn(opt[:expression])
     evaluator = Electr::Evaluator.new
     temp = evaluator.evaluate_pn(temp)
     if temp == temp.truncate
@@ -23,5 +23,10 @@ if opt[:expression]
     end
   end
 else
-  Electr::Repl.new(opt).run
+  if opt[:ast]
+    Electr::Repl.new(Electr::ASTReader.new, Electr::NilEvaluator.new,
+                     Electr::ASTPrinter).run
+  else
+    Electr::Repl.new.run
+  end
 end

data/documentation/developer.md

@@ -0,0 +1,21 @@
+The parsing process
+===================
+
+The aim of the parsing process it to transform a source code into an AST.
+
+AST: [Abstract Syntax Tree][AST]
+
+SYA: [Shunting Yard Algorithm][SYA]
+
+PN: [Prefix Notation][PN]
+
+This is the stages of the parser:
+
+1. Tokenizer
+2. Lexer
+3. Syntaxer
+4. AST (using SYA for formulas)
+
+[AST]: https://en.wikipedia.org/wiki/Abstract_syntax_tree
+[SYA]: https://en.wikipedia.org/wiki/Shunting-yard_algorithm
+[PN]: https://en.wikipedia.org/wiki/Polish_notation

data/documentation/grammar.md

@@ -0,0 +1,34 @@
+# Grammar of Electr in EBNF
+
+    expression = [`(`], number {[op] expression}, [`)`];
+
+    number     = numeric | value | constant | f-call;
+
+    numeric    = integer | float;
+
+    integer    = ? integer ?;
+
+    float      = ? floating point number ?;
+
+    value      = ? integer or floating point directly followed by a unit ?;
+
+    constant   = `pi`;
+
+    (* function call *)
+    f-call     = f-name, `(`, expression, `)`;
+
+    (* function name *)
+    f-name     = ? regexp: [a-z]{1,} ?;
+
+    (* operators *)
+    op         = `-` | `+` |  `/`;
+
+## Precisions
+
+### Negative numbers
+
+`-123` is a negative number.<br/>
+`- 123` is not.
+
+This is because the multiplication is implicit, ie `2 - 3` equals `-1` and
+`2 -3` equals `-6`.

data/documentation/precedence.md

@@ -0,0 +1,8 @@
+Precedence Table
+================
+
+Operator  | Description                 | Associativity
+:-------: | -------------               | --------------
+()        | Function call               | Left
+* /       | Multiplication and division | Left
++ -       | Addition and substraction   | Left

data/electr.gemspec

@@ -22,4 +22,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec"
+  spec.add_development_dependency "coco"
 end

data/lib/electr.rb

@@ -5,16 +5,27 @@ require "electr/exceptions"
 require "electr/parser"
 require "electr/compiler"
 require "electr/ast"
-require "electr/rules"
-require "electr/evaluator"
 require "electr/repl"
 require "electr/option"
 
 module Electr
 
+  UNARY_MINUS_INTERNAL_SYMBOL = '€'
+
   # f - function
   SYMBOL_TABLE = {
     'sqrt' => 'f',
   }
 
+  PRECEDENCE = {
+    '()' => {assoc: 'L', val: 99},
+    ')'  => {assoc: 'L', val: 99},
+    '('  => {assoc: 'L', val: 99},
+    UNARY_MINUS_INTERNAL_SYMBOL => {assoc: 'R', val: 80},
+    '*'  => {assoc: 'L', val: 10},
+    '/'  => {assoc: 'L', val: 10},
+    '-'  => {assoc: 'L', val:  1},
+    '+'  => {assoc: 'L', val:  1},
+  }
+
 end

data/lib/electr/ast/ast.rb

@@ -1,5 +1,6 @@
 module Electr
 
+  # Base class for the abstract syntax tree.
   class AST
 
     def initialize(name)
@@ -12,6 +13,8 @@ module Electr
       @value = nil
     end
 
+    attr_reader :value, :name
+
     # Public: Add a child node to the end of the children's list.
     #
     # child - An AST node to add to the list of children.
@@ -32,12 +35,8 @@ module Electr
     end
 
     def display(indent = 0)
-      print " " * indent + @name
-      if leaf?
-        print " ::= #@value"
-      else
-        print " (#@value)" if @value
-      end
+      print name_for_display(indent)
+      print value_for_display
       puts
       @children.each {|child| child.display(indent + 2) }
     end
@@ -46,8 +45,23 @@ module Electr
       [* Pn.new(@value, @name)] + @children.map {|child| child.to_pn }.flatten
     end
 
+    private
+
+    def name_for_display(indent)
+      " " * indent + @name
+    end
+
+    def value_for_display
+      if leaf?
+        " ::= #@value"
+      else
+        " (#@value)" if @value
+      end
+    end
+
   end
 
+  # Element of a prefix notation.
   # TODO Pn is not a good name!
   class Pn
 
@@ -57,6 +71,10 @@ module Electr
     end
 
     attr_reader :value, :name
+
+    def to_f
+      value.tr(',', '_').to_f
+    end
   end
 
 end

data/lib/electr/ast/constant_ast.rb

@@ -1,5 +1,6 @@
 module Electr
 
+  # A constant node in the AST, ie the number pi.
   class ConstantAST < AST
 
     def initialize(value)

data/lib/electr/ast/func_args_ast.rb

@@ -1,5 +1,6 @@
 module Electr
 
+  # A node in the AST to hold arguments of a function.
   class FuncArgsAST < AST
 
     def initialize

data/lib/electr/ast/func_ast.rb

@@ -1,5 +1,6 @@
 module Electr
 
+  # A node in the AST to represent a function.
   class FuncAST < AST
 
     def initialize

data/lib/electr/ast/func_name_ast.rb

@@ -1,5 +1,7 @@
 module Electr
 
+  # A node in the AST to represent the name of a function, ie sqrt, sin
+  # or cos.
   class FuncNameAST < AST
 
     def initialize(value)

data/lib/electr/ast/numeric_ast.rb

@@ -1,5 +1,6 @@
 module Electr
 
+  # A node in the AST to represent a numeric, ie 234 or 17.89
   class NumericAST < AST
 
     def initialize(value)

data/lib/electr/ast/operator_ast.rb

@@ -1,5 +1,6 @@
 module Electr
 
+  # A node in the AST to hold an operator, ie +, -, etc.
   class OperatorAST < AST
 
     def initialize(value)

data/lib/electr/ast/root_ast.rb

@@ -1,5 +1,6 @@
 module Electr
 
+  # The root node of the AST.
   class RootAST < AST
 
     def initialize

data/lib/electr/ast/value_ast.rb

@@ -1,5 +1,6 @@
 module Electr
 
+  # A node in the AST to hold a value, ie 10mA or 3V.
   class ValueAST < AST
 
     def initialize(value)

data/lib/electr/compiler.rb

@@ -1,22 +1,26 @@
 module Electr
 
+  # The toolchain that takes a code at input and outputs it in another
+  # structure.
+  #
+  # The compiler could outputs the code either as an AST or as a list of
+  # element in the prefix notation.
   class Compiler
 
-    def compile_to_ast(code)
+    def self.compile_to_ast(code)
       units = []
       tokenizer = Tokenizer.new(code)
-      lexer = Lexer.new
       while tokenizer.has_more_token?
-        units << lexer.lexify(tokenizer.next_token)
+        units << Lexer.lexify(tokenizer.next_token)
       end
 
       syntaxer = Syntaxer.new(units.dup)
-      ast = syntaxer.run
+      syntaxer.run
     end
 
     # To Prefix Notation.
-    def compile_to_pn(code)
-      ast = compile_to_ast(code)
+    def self.compile_to_pn(code)
+      ast = self.compile_to_ast(code)
       ast.to_pn
     end
 

data/lib/electr/exceptions.rb

@@ -1,5 +1,6 @@
 module Electr
 
+  # The good old syntax error ;)
   class SyntaxError < StandardError
   end
 

data/lib/electr/parser.rb

@@ -1,5 +1,7 @@
 require "electr/parser/tokenizer"
+require "electr/parser/token"
 require "electr/parser/lexer"
 require "electr/parser/lexical_unit"
+require "electr/parser/rules"
 require "electr/parser/syntaxer"
 require "electr/parser/sya"

data/lib/electr/parser/lexer.rb

@@ -1,50 +1,27 @@
 module Electr
 
-  class Lexer
+  # Lexical analysis.
+  module Lexer
+
+    using Token
 
     # Public: Build a LexicalUnit from a given token.
     #
     # token - A String token to transform in LexicalUnit.
     #
     # Returns a LexicalUnit.
-    def lexify(token)
-      if numeric?(token)
-        LexicalUnit.numeric(token)
-      elsif operator?(token)
-        LexicalUnit.operator(token)
-      elsif constant?(token)
-        LexicalUnit.constant(token)
-      elsif value?(token)
-        LexicalUnit.value(token)
-      elsif token == '('
-        LexicalUnit.open_parenthesis()
-      elsif token == ')'
-        LexicalUnit.closed_parenthesis()
-      elsif SYMBOL_TABLE[token] == 'f'
-        LexicalUnit.fname(token)
-      else
-        LexicalUnit.name(token)
+    def self.lexify(token)
+      case token
+      when ->(x) { x.numeric? } then LexicalUnit.numeric(token)
+      when ->(x) { x.operator? } then LexicalUnit.operator(token)
+      when ->(x) { x.constant? } then LexicalUnit.constant(token)
+      when ->(x) { x.value? } then LexicalUnit.value(token)
+      when ->(x) { x == '(' } then LexicalUnit.open_parenthesis
+      when ->(x) { x == ')' } then LexicalUnit.closed_parenthesis
+      when ->(x) { SYMBOL_TABLE[x] == 'f' } then LexicalUnit.fname(token)
+      else LexicalUnit.name(token)
       end
     end
 
-    private
-
-    def numeric?(token)
-      token =~ /[0-9.]\Z/
-    end
-
-    def operator?(token)
-      %w( + - / ).include?(token)
-    end
-
-    def constant?(token)
-      %w( pi ).include?(token)
-    end
-
-    def value?(token)
-      # The unit part is redondant with Tokenizer.
-      token =~ /[0-9.][kKRuFpΩμAmWV]{1,}\Z/
-    end
-
   end
 end