calcula 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: acb99c969e886a94ca30cc534dc3db8c76f0ea0a
-  data.tar.gz: f5801be3a546e8aef049aa56cd566dcf53e27d0f
+  metadata.gz: 397e946ee023cbfbe15fbd3c78e7fda729e9fa41
+  data.tar.gz: ad9f8f5b4da62221b96e08e4ff3afd2887317f40
 SHA512:
-  metadata.gz: 6c254c1b82fd8b658e28b876fbaa8c2bde737e57360cc748640cca4253b5d2a451845d1196fc4ee0645cb5769faec78ecb014f7495c90967580fccdc94b60c46
-  data.tar.gz: 92c14c7803111bde6c62e52b128fccc6bc7f40d175b348f6178a67fd6def282222dea3407416076ad63bbd822255d75450ff7dc6d4d2caae982549a70142eecd
+  metadata.gz: 9017478c73db894b546a21bd0563a5e40cbca71281831223fe345b581a0d5c585791195fc1f10c988a413ba81715ddd792967c95882cca31cfe573e573a15817
+  data.tar.gz: f4033ce6ce081fbf36995db752a7f90c96844663949d78abdc5fa7846b4cef0e808728940dcce1a4bc1508f996c6fdb6092f7a69b7d08f9ab0136bca527c9778

data/.travis.yml

@@ -3,3 +3,6 @@ language: ruby
 rvm:
   - 2.3.1
 before_install: gem install bundler -v 1.13.2
+addons:
+    code_climate:
+        repo_token: 4ca379840aee24144c568378f1425a8a330e1e1ab46043ffcf16660d0ffa9de2

data/Gemfile

@@ -2,3 +2,5 @@ source 'https://rubygems.org'
 
 # Specify your gem's dependencies in calcula.gemspec
 gemspec
+
+gem "codeclimate-test-reporter", group: :test, require: nil

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2016 TODO: Write your name
+Copyright (c) 2016 Paul T.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,4 +1,4 @@
-# Calcula [![Build Status](https://travis-ci.org/plankp/Calcula.svg?branch=master)](https://travis-ci.org/plankp/Calcula) [![Inline docs](http://inch-ci.org/github/plankp/Calcula.svg?branch=master)](http://inch-ci.org/github/plankp/Calcula)
+# Calcula [![Build Status](https://travis-ci.org/plankp/Calcula.svg?branch=master)](https://travis-ci.org/plankp/Calcula) [![Code Climate](https://codeclimate.com/github/plankp/Calcula/badges/gpa.svg)](https://codeclimate.com/github/plankp/Calcula) [![Inline docs](http://inch-ci.org/github/plankp/Calcula.svg?branch=master)](http://inch-ci.org/github/plankp/Calcula) [![Gem Version](https://badge.fury.io/rb/calcula.svg)](https://badge.fury.io/rb/calcula)
 
 When mathematics meets programming
 
@@ -22,17 +22,14 @@ Or install it yourself as:
 
 ## Usage
 
-At the moment, all it does is converts source code into tokens and then a syntax tree.
-To do so, type in:
+To compile Calcula code to ruby, type in:
 
 ```ruby
 require "calcula"
 src = <<-'EOS'
-# Write some calcula code here
+# Write some Calcula code here
 EOS
-tokens = Calcula.lex(src)
-puts tokens.collect { |e| e.text }.to_s
-puts Calcula.parse(tokens).to_tree
+puts Calcula::compile(src)
 ```
 
 ## Development
@@ -47,4 +44,4 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/plankp
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](./LICENSE.txt).

data/lib/Expr.rb

@@ -1,20 +1,40 @@
+# @author Paul T.
 module Calcula
-  class Expr
-
-    def to_s()
-      ""
-    end
 
-    def to_tree()
-      "()"
-    end
+  # All valid tree expression must be childrens of this class and should be
+  # placed under the module `Calcula::Exprs`
+  #
+  # @see Calcula::Exprs
+  # @abstract
+  # @author Paul T.
+  class Expr
 
-    # binding: Hash[string, Any]
-    def exec(binding)
-      nil
+    # Converts the expression to a string. If the form is `:src`, then the
+    # resulting string should resemble as much as its source code as possible.
+    # If the form is `:tree`, the result string should resemble in a Lisp like
+    # form. If the form is `:ruby`, the result should be Ruby code that does the
+    # same thing. Otherwise, `nil` should be returned.
+    #
+    # @param form [Optional, Symbol] The type of format being converted into
+    # @return [String, nil] A string that resembles the specify form
+    def to_s(form: :src)
+      case form
+      when :src then
+        ""
+      when :tree then
+        "()"
+      when :ruby then
+        ""
+      else
+        nil
+      end
     end
 
-    def children()
+    # Returns the child nodes as a list. Child nodes must be transversible
+    # (hence also expressions).
+    #
+    # @return [Array<Calcula::Expr>] A list of transversible child nodes
+    def children
       []
     end
   end

data/lib/Exprs/AssignExpr.rb

@@ -0,0 +1,39 @@
+require_relative "../Expr"
+
+# Expression for assigning value to variables
+#
+# @author Paul T.
+class Calcula::Exprs::AssignExpr < Calcula::Expr
+
+  # @param ident [Calcula::Exprs::IdentExpr]
+  # @param value [Calcula::Expr]
+  def initialize(ident, value)
+    @ident = ident
+    @value = value
+  end
+
+  # @see Calcula::Expr#to_s
+  # @param (see Calcula::Expr#to_s)
+  # @return (see Calcula::Expr#to_s)
+  def to_s(form: :src)
+    identTxt = @ident.to_s(form: form)
+    valueTxt = @value.to_s(form: form)
+    case form
+    when :src then
+      "let #{identTxt}=#{valueTxt}"
+    when :tree then
+      "(let #{identTxt} #{valueTxt})"
+    when :ruby then
+      "#{identTxt} = #{valueTxt}"
+    else
+      nil
+    end
+  end
+
+  # @see Calcula::Expr#children
+  # @param (see Calcula::Expr#children)
+  # @return (see Calcula::Expr#children)
+  def children
+    [@ident, @value]
+  end
+end

data/lib/Exprs/BinopExpr.rb

@@ -0,0 +1,53 @@
+require_relative "../Expr"
+
+# Expression for binary operators. An expression 10(2) is also a binary operator.
+# Its operator will be `:PAREN_O`
+#
+# @author Paul T.
+class Calcula::Exprs::BinopExpr < Calcula::Expr
+
+  # @param op [Calcula::Token] Should have type prefixed with `OP_`
+  # @param left [Calcula::Expr]
+  # @param right [Calcula::Expr]
+  def initialize(op, left, right)
+    @op = op
+    @left = left
+    @right = right
+  end
+
+  # @see Calcula::Expr#to_s
+  # @param (see Calcula::Expr#to_s)
+  # @return (see Calcula::Expr#to_s)
+  def to_s(form: :src)
+    leftTxt = @left.to_s(form: form)
+    rightTxt = @right.to_s(form: form)
+    case form
+    when :src, :ruby then
+      case @op.id
+      when :PAREN_O then
+        "#{leftTxt}#{"." if form == :ruby}(#{rightTxt})"
+      when :OP_EQ then
+        "#{leftTxt}#{form == :ruby ? "==" : "="}#{rightTxt}"
+      when :AND then
+        "#{leftTxt}#{form == :ruby ? "&&" : " and "}#{rightTxt}"
+      when :OR then
+        "#{leftTxt}#{form == :ruby ? "||" : " or "}#{rightTxt}"
+      when :COMPOSE then
+        "->(*x){#{leftTxt}.(#{rightTxt}.(*x))}"
+      else
+        "#{leftTxt}#{@op.text}#{rightTxt}"
+      end
+    when :tree then
+      "(#{@op.text} #{leftTxt} #{rightTxt})"
+    else
+      nil
+    end
+  end
+
+  # @see Calcula::Expr#children
+  # @param (see Calcula::Expr#children)
+  # @return (see Calcula::Expr#children)
+  def children
+    [@left, @right]
+  end
+end

data/lib/Exprs/BracedExpr.rb

@@ -0,0 +1,48 @@
+require_relative "../Expr"
+
+# Expression for bracket operators. Floor operators also count as bracket
+# operators.
+#
+# @author Paul T.
+class Calcula::Exprs::BracedExpr < Calcula::Expr
+
+  # @param startTok [Calcula::Token] The starting token of this expression
+  # @param endTok [Calcula::Token] The ending token of this expression
+  # @param inner [Calcula::Expr]
+  def initialize(startTok, endTok, inner)
+    @startTok = startTok
+    @endTok = endTok
+    @inner = inner
+  end
+
+  # @see Calcula::Expr#to_s
+  # @param (see Calcula::Expr#to_s)
+  # @return (see Calcula::Expr#to_s)
+  def to_s(form: :src)
+    innerTxt = @inner.to_s(form: form)
+    case form
+    when :src then
+      "#{@startTok.text}#{innerTxt}#{@endTok.text}"
+    when :tree then
+      "#{@startTok.text} #{innerTxt} #{@endTok.text}"
+    when :ruby then
+      case @startTok.id
+      when :PAREN_O then
+        "(#{innerTxt})"
+      when :SQUARE_O then
+        "(#{innerTxt}).floor.to_r"
+      else
+        raise "Unknown delimiter #{@startTok.id}"
+      end
+    else
+      nil
+    end
+  end
+
+  # @see Calcula::Expr#children
+  # @param (see Calcula::Expr#children)
+  # @return (see Calcula::Expr#children)
+  def children
+    [@inner]
+  end
+end

data/lib/Exprs/FuncExpr.rb

@@ -1,39 +1,39 @@
 require_relative "../Expr"
 
-module Calcula::Exprs
-  class FuncExpr < Calcula::Expr
+# Expression for functions and lambda expression
+#
+# @author Paul T.
+class Calcula::Exprs::FuncExpr < Calcula::Expr
 
-    # name: IdentExpr | Nil (for lambdas), params: ParamsExpr, action: Expr
-    def initialize(name, params, action)
-      @name = name
-      @params = params
-      @action = action
-    end
-
-    def to_s()
-      return "\\#{@params.to_s}(#{@action.to_s})" if @name == nil
-      return "#{@name.to_s}(#{@params.to_s})=#{@action.to_s}"
-    end
-
-    def to_tree()
-      return "(lambda #{@params.to_tree} #{@action.to_tree})" if @name == nil
-      return "(func #{@name.to_tree} #{@params.to_tree} #{@action.to_tree})"
-    end
-
-    def exec(binding)
-      if @name == nil then
-        # We return it (its a lambda function afterall...)
-      else
-        # We do not invoke this function. We just add it to the `binding`
-      end
-    end
+  # @param params [Calcula::Exprs::ParamsExpr] Parameters to the function
+  # @param action [Calcula::Expr] The body of the function
+  def initialize(params, action)
+    @params = params
+    @action = action
+  end
 
-    def children()
-      [@name, @params, @action]
+  # @see Calcula::Expr#to_s
+  # @param (see Calcula::Expr#to_s)
+  # @return (see Calcula::Expr#to_s)
+  def to_s(form: :src)
+    paramsTxt = @params.to_s(form: form)
+    actionTxt = @action.to_s(form: form)
+    case form
+    when :src then
+      "\\#{paramsTxt}(#{actionTxt})"
+    when :tree then
+      "(lambda #{paramsTxt} #{actionTxt})"
+    when :ruby then
+      "->#{paramsTxt}{#{actionTxt}}"
+    else
+      nil
     end
+  end
 
-    def self.mkLambda(params, action)
-      FuncExpr.new(nil, params, action)
-    end
+  # @see Calcula::Expr#children
+  # @param (see Calcula::Expr#children)
+  # @return (see Calcula::Expr#children)
+  def children
+    [@params, @action]
   end
 end

data/lib/Exprs/IdentExpr.rb

@@ -1,27 +1,35 @@
 require_relative "../Expr"
 
-module Calcula::Exprs
-  class IdentExpr < Calcula::Expr
+# Expression for identifiers
+#
+# @author Paul T.
+class Calcula::Exprs::IdentExpr < Calcula::Expr
 
-    # name: Token
-    def initialize(name)
-      @name = name
-    end
+  # @param name [Calcula::Token] This token should have the type ID
+  def initialize(name)
+    @name = name
+  end
 
-    def to_s()
+  # @see Calcula::Expr#to_s
+  # @param (see Calcula::Expr#to_s)
+  # @return (see Calcula::Expr#to_s)
+  def to_s(form: :src)
+    case form
+    when :src then
       @name.text
-    end
-
-    def to_tree()
+    when :tree then
       "(ident #{@name.text})"
+    when :ruby then
+      @name.text.tr("'", "_")
+    else
+      nil
     end
+  end
 
-    def exec(binding)
-      binding[@name.text]
-    end
-
-    def children()
-      []
-    end
+  # @see Calcula::Expr#children
+  # @param (see Calcula::Expr#children)
+  # @return (see Calcula::Expr#children)
+  def children
+    []
   end
 end

data/lib/Exprs/NumExpr.rb

@@ -1,27 +1,35 @@
 require_relative "../Expr"
 
-module Calcula::Exprs
-  class NumExpr < Calcula::Expr
+# Expression for representing real numbers
+#
+# @author Paul T.
+class Calcula::Exprs::NumExpr < Calcula::Expr
 
-    # num: Token
-    def initialize(num)
-      @num = num
-    end
+  # @param num [Calcula::Token] The token should have the type of NUM
+  def initialize(num)
+    @num = num
+  end
 
-    def to_s()
+  # @see Calcula::Expr#to_s
+  # @param (see Calcula::Expr#to_s)
+  # @return (see Calcula::Expr#to_s)
+  def to_s(form: :src)
+    case form
+    when :src then
       @num.text
-    end
-
-    def to_tree()
+    when :tree then
       "(num #{@num.text})"
+    when :ruby then
+      "#{@num.text}r"
+    else
+      nil
     end
+  end
 
-    def exec(binding)
-      return @num.text.to_f
-    end
-
-    def children()
-      []
-    end
+  # @see Calcula::Expr#children
+  # @param (see Calcula::Expr#children)
+  # @return (see Calcula::Expr#children)
+  def children
+    []
   end
 end