deepalgo_il 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f640d104e1a26c56d3a0504ad08e110de3ea840ebd17a4d57ba89f989da39dd6
+  data.tar.gz: 83afcaded5bf20f8cb823a75ac740095bd144322d264449802a58d60dee3c5a4
+SHA512:
+  metadata.gz: 42907545732c415ea57425fc65f09c8b0648bcfd538d4e306afbcb5887774bb40aa46a366b08938f7d9ff2cefbb8908fe3453fb9538028b7f1c3f404a08d56a7
+  data.tar.gz: e7f67f9284b5773cf21452389eef4f587166063e64143cf724f44da4cb87cccbdb6acf8a64188a092c86abf40e3405cdb86eef070d34bf07d662bb93416a8226

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.3.1
+before_install: gem install bundler -v 1.11.2

data/Gemfile

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in deepalgo_il.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Valderane Potong Mboucheko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,47 @@
+# DeepalgoIl
+
+DeepalgoIl is a litte module that aim to convert the <i>Deepalgo IL</i> into a certain human readable form (it can be javascript, html, tex, etc...)
+The goal is have a bunch of <i>backends</i> in which the <i>Deepalgo IL</i> can be represented. More, we should to be able to implement a new backend rapidly
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'deepalgo_il'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install deepalgo_il
+
+## Usage
+To use this library, you have to import it in your code. Thus you can call the method 
+```
+deepalgoIl_to(il, backends)
+```
+where
+* il : stream of characters that represent a file in a <b>Deepalgo IL</b> form 
+* backends : A list of backends in which you want your <b>il<b> to be represented. For example you can pass ["tex", "js"] to generate the <b>il</b> into a tex and javascript form. Obviously, these backends have to be implemented, otherwise every backend not implemented will be ignored. Not setting a value for this parameter will make the program generating outputs for every implemented backend
+
+### To gene
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/deepalgo_il.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'deepalgo_il'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/deepalgo_il.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'deepalgo_il/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'deepalgo_il'
+  spec.version       = DeepalgoIl::VERSION
+  spec.authors       = ['Valderane Potong Mboucheko']
+  spec.email         = ['valderane.potongmboucheko@margo-group.com']
+
+  spec.summary       = 'Little formula traductor from IL to a backend of your choice (Latex for exemple)'
+  spec.description   = 'This gem provides some functions to convert IL into a backend we want.'
+  # spec.homepage      = "TODO: Put your gem's website or public repo URL here."
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.'
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 2.1'
+  spec.add_development_dependency 'logger'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'treetop'
+end

data/lib/backend_manager.rb

@@ -0,0 +1,300 @@
+# frozen_string_literal: true
+
+require 'logging.rb'
+
+module DeepAlgo
+  module IL
+    module Backend
+      class Generic
+        def generate(_tree)
+          raise 'not yep implemented'
+        end
+
+        def document(_tree)
+          raise 'not yep implemented'
+        end
+
+        def expr(_tree)
+          raise 'not yep implemented'
+        end
+
+        def add_expr(_tree)
+          raise 'not yep implemented'
+        end
+
+        def assignment(_tree)
+          raise 'not yet implemented'
+        end
+
+        def while_expr(_tree)
+          raise 'not yep implemented'
+        end
+
+        def while_cond_expr(_tree)
+          raise 'not yep implemented'
+        end
+
+        def plus_expr(_tree)
+          raise 'not yep implemented'
+        end
+
+        def minus_expr(_tree)
+          raise 'not yep implemented'
+        end
+
+        def time_expr(_tree)
+          raise 'not yep implemented'
+        end
+
+        def div_expr(_tree)
+          raise 'not yep implemented'
+        end
+
+        def dotted_expr(_tree)
+          raise 'not yep implemented'
+        end
+
+        def factor(_tree)
+          raise 'not yep implemented'
+        end
+
+        def tab_ref(_tree)
+          raise 'not yep implemented'
+        end
+
+        def terminal(_tree)
+          raise 'not yep implemented'
+        end
+
+        def dotted_terminal(_tree)
+          raise 'not yep implemented'
+        end
+
+        def atom(_tree)
+          raise 'not yep implemented'
+        end
+
+        def descriptor(_tree)
+          raise 'not yep implemented'
+        end
+
+        def descriptor_items(_tree)
+          raise 'not yep implemented'
+        end
+
+        def descriptor_item(_tree)
+          raise 'not yep implemented'
+        end
+
+        def call(_tree)
+          raise 'not yep implemented'
+        end
+
+        def args(_tree)
+          raise 'not yep implemented'
+        end
+
+        def parenthesed(_tree)
+          raise 'not yep implemented'
+        end
+
+        def colored(_tree)
+          raise 'not yep implemented'
+        end
+
+        def color(_tree)
+          raise 'not yep implemented'
+        end
+
+        def colorcode(_tree)
+          raise 'not yep implemented'
+        end
+
+        def identifier(_tree)
+          raise 'not yep implemented'
+        end
+
+        def number(_tree)
+          raise 'not yep implemented'
+        end
+
+        def unary_minus(_tree)
+          'not yep implemented'
+        end
+
+        def text(_tree)
+          raise 'not yep implemented'
+        end
+      end
+
+      class Latex < Generic
+        def initialize
+          @curr_backend = nil
+        end
+
+        def generate(tree, curr_backend)
+          @curr_backend = curr_backend
+          latex = tree.value(@curr_backend)
+          latex
+        end
+
+        def document(tree)
+          tree.elements[0].value(@curr_backend)
+        end
+
+        def add_expr(tree)
+          tree.elements[0].value(@curr_backend)
+        end
+
+        def assignment(tree)
+          left = tree.elements[0].value(@curr_backend)
+          right = tree.elements[4].value(@curr_backend)
+          "#{left} \\text{equals} #{right}"
+        end
+
+        def plus_expr(tree)
+          left = tree.elements[0].value(@curr_backend)
+          right = tree.elements[4].value(@curr_backend)
+          "#{left} + #{right}"
+        end
+
+        def minus_expr(tree)
+          left = tree.elements[0].value(@curr_backend)
+          right = tree.elements[4].value(@curr_backend)
+          "#{left} - #{right}"
+        end
+
+        def time_expr(tree)
+          left = tree.elements[0].value(@curr_backend)
+          right = tree.elements[4].value(@curr_backend)
+          "#{left} \\times #{right}"
+        end
+
+        def parenthesed(tree)
+          "\\left( #{tree.elements[2].value(@curr_backend)} \\right)"
+        end
+
+        def colored(tree)
+          color = "##{tree.elements[0].value(@curr_backend)}"
+          expr = tree.elements[4].value(@curr_backend)
+          "\\color{ #{color} }{ #{expr} }"
+        end
+
+        def color(tree)
+          tree.elements[1].value(@curr_backend)
+          # tree.text_value
+        end
+
+        def colorcode(tree)
+          tree.text_value
+        end
+
+        def atom(tree)
+          tree.text_value
+        end
+
+        def while_expr(tree)
+          statements = tree.elements[4].value(@curr_backend)
+          cond = tree.elements[8].value(@curr_backend)
+          "\\text{repeat} \\left[ #{statements} \\right]#{cond}"
+        end
+
+        def while_cond_expr(tree)
+          "_{ \\text{ while #{tree.elements[4].value(@curr_backend)} } }"
+        end
+
+        def text(tree)
+          tree.text_value
+        end
+
+        def dotted_expr(tree)
+          to_return = ''
+          if !tree.elements[1].nil? && tree.elements[1] != ''
+            tree
+              .elements[1]
+              .elements
+              .each do |son_expr|
+              to_return = "#{to_return}. \
+              #{son_expr.elements[2].value(@curr_backend)}"
+            end
+          end
+
+          "#{tree.elements[0].value(@curr_backend)}#{to_return}"
+        end
+
+        def call(tree)
+          caller_name = tree.elements[0].value(@curr_backend)
+          params = tree.elements[4].value(@curr_backend)
+          "#{caller_name} \\left( #{params} \\right)"
+        end
+
+        def dotted_terminal(tree)
+          first_expr = tree.elements[0].value(@curr_backend)
+          second_expr = tree.elements[2].value(@curr_backend)
+          "#{first_expr}.#{second_expr}"
+        end
+
+        def args(tree)
+          # parse arg, arg, arg, ...
+          to_return = ''
+          tree
+            .elements[1]
+            &.elements
+            &.each do |arg|
+            to_return = "#{to_return}, \
+            #{arg.elements[3].value(@curr_backend)}"
+          end
+          "#{tree.elements[0].value(@curr_backend)}#{to_return}"
+        end
+
+        def tab_ref(tree)
+          tab = tree.elements[0].value(@curr_backend)
+          index = tree.elements[6].value(@curr_backend)
+          "#{tab}_{ #{index} }"
+        end
+
+        def descriptor(tree)
+          label = tree.elements[2].value(@curr_backend)
+          items = tree.elements[8].value(@curr_backend)
+          "\\text{ #{label} } \
+           \\left\\{\\begin{array}{l} #{items} \\\\ \\end{array}\\right."
+        end
+
+        def descriptor_items(tree)
+          to_return = ''
+          tree
+            .elements[1]
+            &.elements
+            &.each do |arg|
+            to_return = "#{to_return} \\\\ \
+             #{arg.elements[1].value(@curr_backend)} "
+          end
+          "#{tree.elements[0].value(@curr_backend)} #{to_return}"
+        end
+
+        def descriptor_item(tree)
+          label = tree.elements[4].value(@curr_backend)
+          assignee = tree
+                     .elements[10]
+                     .elements[0]
+                     .value(@curr_backend)
+          "\\text{ #{label} } = #{assignee}"
+        end
+
+        def div_expr(tree)
+          numerator = tree.elements[6].value(@curr_backend)
+          denominator = tree.elements[14].value(@curr_backend)
+          "\\dfrac{ #{numerator} }{ #{denominator} }"
+        end
+
+        def unary_minus(tree)
+          "-#{tree.elements[2].value(@curr_backend)}"
+        end
+
+        def identifier(tree)
+          tree.text_value
+        end
+      end
+    end
+  end
+end