pax_global_header00006660000000000000000000000064130523607150014514gustar00rootroot0000000000000052 comment=06e423de77795e1a847b66149cd9020b9201875a elixirscript-0.25.0/000077500000000000000000000000001305236071500143215ustar00rootroot00000000000000elixirscript-0.25.0/.babelrc000066400000000000000000000000661305236071500157160ustar00rootroot00000000000000{ "plugins": ["transform-es2015-modules-commonjs"] }elixirscript-0.25.0/.credo.exs000066400000000000000000000123431305236071500162170ustar00rootroot00000000000000# This file contains the configuration for Credo and you are probably reading # this after creating it with `mix credo.gen.config`. # # If you find anything wrong or unclear in this file, please report an # issue on GitHub: https://github.com/rrrene/credo/issues # %{ # # You can have as many configs as you like in the `configs:` field. configs: [ %{ # # Run any config using `mix credo -C `. If no config name is given # "default" is used. name: "default", # # These are the files included in the analysis: files: %{ # # You can give explicit globs or simply directories. # In the latter case `**/*.{ex,exs}` will be used. included: ["lib/", "src/", "web/", "apps/"], excluded: [~r"/_build/", ~r"/deps/"] }, # # If you create your own checks, you must specify the source files for # them here, so they can be loaded by Credo before running the analysis. requires: [], # # Credo automatically checks for updates, like e.g. Hex does. # You can disable this behaviour below: check_for_updates: true, # # If you want to enforce a style guide and need a more traditional linting # experience, you can change `strict` to `true` below: strict: false, # # If you want to use uncolored output by default, you can change `color` # to `false` below: color: true, # # You can customize the parameters of any check by adding a second element # to the tuple. # # To disable a check put `false` as second element: # # {Credo.Check.Design.DuplicatedCode, false} # checks: [ {Credo.Check.Consistency.ExceptionNames}, {Credo.Check.Consistency.LineEndings}, {Credo.Check.Consistency.MultiAliasImportRequireUse}, {Credo.Check.Consistency.ParameterPatternMatching}, {Credo.Check.Consistency.SpaceAroundOperators}, {Credo.Check.Consistency.SpaceInParentheses}, {Credo.Check.Consistency.TabsOrSpaces}, # For some checks, like AliasUsage, you can only customize the priority # Priority values are: `low, normal, high, higher` {Credo.Check.Design.AliasUsage, priority: :low}, # For others you can set parameters # If you don't want the `setup` and `test` macro calls in ExUnit tests # or the `schema` macro in Ecto schemas to trigger DuplicatedCode, just # set the `excluded_macros` parameter to `[:schema, :setup, :test]`. {Credo.Check.Design.DuplicatedCode, excluded_macros: []}, # You can also customize the exit_status of each check. # If you don't want TODO comments to cause `mix credo` to fail, just # set this value to 0 (zero). {Credo.Check.Design.TagTODO, exit_status: 2}, {Credo.Check.Design.TagFIXME}, {Credo.Check.Readability.FunctionNames}, {Credo.Check.Readability.LargeNumbers}, {Credo.Check.Readability.MaxLineLength, priority: :low, max_length: 80}, {Credo.Check.Readability.ModuleAttributeNames}, {Credo.Check.Readability.ModuleDoc}, {Credo.Check.Readability.ModuleNames}, {Credo.Check.Readability.NoParenthesesWhenZeroArity}, {Credo.Check.Readability.ParenthesesInCondition}, {Credo.Check.Readability.PredicateFunctionNames}, {Credo.Check.Readability.PreferImplicitTry}, {Credo.Check.Readability.RedundantBlankLines}, {Credo.Check.Readability.Specs}, {Credo.Check.Readability.StringSigils}, {Credo.Check.Readability.TrailingBlankLine}, {Credo.Check.Readability.TrailingWhiteSpace}, {Credo.Check.Readability.VariableNames}, {Credo.Check.Refactor.DoubleBooleanNegation}, {Credo.Check.Refactor.ABCSize}, {Credo.Check.Refactor.CondStatements}, {Credo.Check.Refactor.CyclomaticComplexity}, {Credo.Check.Refactor.FunctionArity}, {Credo.Check.Refactor.MatchInCondition}, {Credo.Check.Refactor.NegatedConditionsInUnless}, {Credo.Check.Refactor.NegatedConditionsWithElse}, {Credo.Check.Refactor.Nesting}, {Credo.Check.Refactor.PipeChainStart}, {Credo.Check.Refactor.UnlessWithElse}, {Credo.Check.Refactor.VariableRebinding}, {Credo.Check.Warning.BoolOperationOnSameValues}, {Credo.Check.Warning.IExPry}, {Credo.Check.Warning.IoInspect}, {Credo.Check.Warning.NameRedeclarationByAssignment}, {Credo.Check.Warning.NameRedeclarationByCase}, {Credo.Check.Warning.NameRedeclarationByDef}, {Credo.Check.Warning.NameRedeclarationByFn}, {Credo.Check.Warning.OperationOnSameValues}, {Credo.Check.Warning.OperationWithConstantResult}, {Credo.Check.Warning.UnusedEnumOperation}, {Credo.Check.Warning.UnusedFileOperation}, {Credo.Check.Warning.UnusedKeywordOperation}, {Credo.Check.Warning.UnusedListOperation}, {Credo.Check.Warning.UnusedPathOperation}, {Credo.Check.Warning.UnusedRegexOperation}, {Credo.Check.Warning.UnusedStringOperation}, {Credo.Check.Warning.UnusedTupleOperation}, # Custom checks can be created using `mix credo.gen.check`. # ] } ] } elixirscript-0.25.0/.eslintrc.js000066400000000000000000000004451305236071500165630ustar00rootroot00000000000000module.exports = { rules: { camelcase: "off", "no-bitwise": "off", "no-plusplus": "off", "no-restricted-syntax": "off", "no-underscore-dangle": "off" }, extends: "airbnb-base", plugins: ["import"], env: { browser: true, node: true, mocha: true } }; elixirscript-0.25.0/.flowconfig000066400000000000000000000001641305236071500164600ustar00rootroot00000000000000[ignore] .*/dist/.* .*/build/.* .*/dist_build/.* .*/node_modules/.* [include] ./priv/javascript [libs] [options] elixirscript-0.25.0/.gitignore000066400000000000000000000003611305236071500163110ustar00rootroot00000000000000/_build /deps erl_crash.dump *.ez ex2js elixirscript node_modules /dist deploy.sh .DS_Store sample/dest fprof.trace index.js /doc /bench/snapshots .tern-port test/std_lib_compile_test.exs src/elixirscript priv/**/*.js stdlib_state.bin *.log elixirscript-0.25.0/.travis.yml000066400000000000000000000014161305236071500164340ustar00rootroot00000000000000sudo: false language: elixir elixir: - 1.3.0 otp_release: - 18.0 env: - TRAVIS_NODE_VERSION="6" install: - rm -rf ~/.nvm && git clone https://github.com/creationix/nvm.git ~/.nvm && (cd ~/.nvm && git checkout `git describe --abbrev=0 --tags`) && source ~/.nvm/nvm.sh && nvm install $TRAVIS_NODE_VERSION - npm install script: - mix local.hex --force - mix local.rebar --force - mix deps.get - mix do std_lib, clean, compile - mix test - npm test notifications: webhooks: urls: - https://webhooks.gitter.im/e/fbd8944d285c0696dc41 on_success: always # options: [always|never|change] default: always on_failure: always # options: [always|never|change] default: always on_start: never # options: [always|never|change] default: always elixirscript-0.25.0/CHANGELOG.md000066400000000000000000000404421305236071500161360ustar00rootroot00000000000000# Change Log All notable changes to this project will be documented in this file. The format is based on [Keep a Changelog](http://keepachangelog.com/) and this project adheres to [Semantic Versioning](http://semver.org/). ## [0.25.0] - 2017-02-19 ### Added - Updated elixir_script mix compiler to support compiling elixir_script paths in dependencies if dependency has mix compiler defined as well - Add `Collectable` protocol implementations - Updated `for` implementation to use `Collectable` - `format` option. Can now specify the module format of output. Choices are: * `:es` (default) for ES Modules * `:umd` for UMD * `:common` for CommonJS - Default input, output and format for elixirscript mix compiler. In a mix project by default the elixirscript compiler will look in `lib/elixirscript` and input and place output in `priv/elixirscript`. The default format is `:es` ### Removed - `receive` - `Process` module ### Fixed - JS module functions not translated properly when imported - Update fs dependency to 2.12 - Incorrect handling of function heads with guards ## [0.24.0] - 2017-01-15 ### Added - Support for `sigil_r` - `Regex` module - Better JavaScript formatting ### Fixed - CLI now allows a comma-separated or space-separated list of paths - Struct not properly referenced - Tail call optimization ## [0.23.3] - 2016-11-18 ### Added - `@load_only`: lets the compiler know to load in the module, but not to compile it ## [0.23.2] - 2016-11-17 ### Fixed - Agent not functioning properly. Now uses internal store instead of making a process and using that to put data in store - Protocol incorrectly handling strings - `defgen` and `defgenp` functions not being recognized by Elixir compiler. ## [0.23.1] - 2016-11-16 ### Fixed - Incorrectly sending standard lib when using compile or compile_path by default ## [0.23.0] - 2016-11-15 ### Added - [`with` now supports `else`](https://github.com/bryanjos/elixirscript/pull/207) - [Implement `context` option on `quote`](https://github.com/bryanjos/elixirscript/pull/208) - New compiler pipeline - `@on_js_load`. Expects a 0 arity function. This function will be called when the compiled module is loaded in JavaScript - `JS.import\3`. Just like `JS.import\2` but expects options to decide if the import should be a default one or a namespace on. Only option allowed is `default`. Set to `true` by default ```elixir # translates to "import A from 'a'" JS.import A, "a" #translates to "import * as A from 'a'" JS.import A, "a", default: false ``` ### Removed - The form of `JS.import` that accepted a list of atoms as the first arg. Used `JS.import\3` with `default: false` instead to create a namespace import - `env` and `root` are no longer options for `ElixirScript`'s compile functions and cli - Syntax once supported by Elixirscript `JQuery.("#element")`, is no longer supported ### Changed - [Changed CHANGELOG.md to adhere the format from Keep a Changelog](https://github.com/bryanjos/elixirscript/pull/205) - `defmacro` now supported. No longer have to separate macros from functions in separate files. `defmacrop` still unsupported - To use anything in the `JS` module, you must `require` the `JS` module first - Elixirscript files must now contain valid Elixir syntax. - Now compiles `exjs` and `ex` files within the path can be compiled all the same. Dependencies from hex are still unsupported so these files must not rely on any code outside of the path. What this does mean is that it is now possible to share code between Elixir and Elixirscript as long as the Elixir files functionality fall within what Elixirscript currently supports. - `defgen`, `defgenp`, `yield`, `yield_to`, and `object` are now in the `JS` module - To access functions in the global JavaScript scope, either use `JS.global\0` or use the erlang module call syntax ```elixir #calling alert JS.global().alert("hi") #calling alert :window.alert("hi") ``` Calling JavaScript modules in the global scope works without using the above methods ```elixir #calls window.Date.now() Date.now() ``` ## [0.22.0] - 2016-10-16 ### Added - `defgen` and `defgenp` for defining public and private generators - `yield/0`, `yield/1`, and `yield_to\1` to `Kernel` ### Changed - Updated output folder structure. stdlib code will now go in an `elxiir` folder under the output paths while generated app code will go into an `app` folder under the output path - All process macros and functions now expect to receive and/or work using generators as entry points. Using functions defined with `def` or `defp` will not work correctly with them ### Fixed - Correctly returning list if list is only item in body ## [0.21.0] - 2016-06-28 ### Added - This is the first release with early support for processes in elixirscript. Creating a process only works currently using `spawn/1`, `spawn_link/1`, and `spawn_monitor/1`. Inside of a process, you can use functions such as `send` and `receive`, along with some defined in the `Process` module. From outside of a process, you can send messages to a process, but you cannot receive a message from a process. Eventually all code will run inside processes and this restriction will naturally lift. - The `Process` module has been implemented with the following functions: * `alive?/1` * `delete/1` * `demonitor/1` * `exit/2` * `flag/2` * `flag/3` * `get/0` * `get_keys/0` * `get_keys/1` * `link/1` * `list/0` * `monitor/1` * `put/2` * `register/2` * `registered/0` * `send/3` * `sleep/1` * `unlink/1` * `unregister/1` * `whereis/1` - The `receive` special form has been implemented with the above caveat - The following have been implemented on `Kernel`: * `spawn/1` * `spawn_link/1` * `spawn_monitor/1` * `send/2` * `make_ref/0` ## Fixed - Scoping on `fn` and `def` ## [0.20.0] - 2016-05-14 ### Added - `ElixirScript.Watcher` module and `elixirscript.watch` mix task - logging MatchError exceptions to better show terms that don't match ## [0.19.0] - 2016-04-30 ### Added - elixir_script mix compiler ### Removed - `Html`, `View`, and `VDom` modules have been removed ## [0.18.0] - 2016-04-08 ### Changed - Better support for macros. Macros should be defined in .ex or .exs files. ElixirScript code should be in .exjs files **NOTE**: The above functionality will cause either compiler errors or no output. Please change extensions of ElixirScript code to .exjs ### Deprecated - `Html`, `View`, and `VDom` modules will be removed in the next version as they can now be replicated using macros ## [0.17.0] - 2016-03-31 ### Added - `output` as an option for compiler functions. This controls whether output is returned as a list of tuples, send to stdout, or saved to a file path - `:full_build` as an option for compiler functions and `--full-build` option to CLI. These force the compiler to perform a full build - `--version` option to CLI. Outputs current version of elixirscript - `--std-lib` option to CLI. Takes a path and adds the stdlib to that path ### Changed - Renamed `copy_core_to_destination` to `copy_stdlib_to_destination` - Incremental Compilation: ElixirScript will now only build files and modules that have changed since the last build ### Removed - `--core` option from CLI and `:core` compiler option. ## [0.16.0] 2016-02-27 ### Added - Bitstring pattern matching - Bitstrings in for comprehensions - Functions with catch, after, else clauses - `with` special form - Pin operator in map keys and function clauses - Added `Kernel.object/1` function to make it more natural to create a JavaScript object with string keys. Elixirscript, by default turns the following, `%{a:"b"}` into `{[Symbol.for("a")]: "b"}` in JavaScript. In order to get string keys, one would have to do `%{"a" => "b"}` which turns into `{a: "b"}` in JavaScript. With `Kernel.object`, you can create string keyed maps conveniently, `object(a: "b")` which turns into `{a: "b"}`. **NOTE**: when updating the created by, you still have to use the string form `%{ my_map | "a" => "c" }` ### Removed - `JS.update(object, property, value)` has been removed and replaced with `JS.update(object, map)`. This allows you to update multiple values on a javascript object at once. ### Fixed - Optional parameters should now work as expected ## [0.15.2] - 2016-02-21 ### Addded - Support for variables as map keys ### Fixed - Protocol implementations for Integer and Float which where not recognized - Calling properties on non-objects ## [0.15.1] - 2016-02-19 ### Removed - Removed `catch` as a javascript keyword to filter ### Fixed - Fixed View module so that an element can have multiple elements within - struct implementation so that lists of atoms for fields are compiled correctly - head-tail pattern match to allow for more complicated scenarios - ModuleCollector to properly alias inner modules - Raise translation to properly translate when string messages are given ## [0.15.0] - 2016-01-26 ### Added - `__ENV__` and `__CALLER__` are now supported - `JS.import/1`, `JS.typeof/1`,`JS.instanceof/1`, and `JS.global/1` - Support for multi alias/require/imports statements ### Changed - `alias`, `require`, and `import` now work inside lexical scopes - Some of the standard library originally written in JavaScript has been rewritten in Elixir. - Generated JavaScript export statements are now default exports - When output is sent to standard out, there are now markers to specify where each module begins as well as what the file name would be. For the end of a file, `//:ENDFILE` is used. For the file name, `//:ENDFILENAME` is used where `` is the name of the file - `compile`, `compile_path`, and `compile_quoted` opts parameter now expects a map - The `stdlib` compiler option is now `core`. The `stdlib_path` compiler options is now `core_path` ## [0.14.1] - 2015-12-07 ### Removed - .DS_Store and LICENSE from output ## [0.14.0] - 2015-12-06 ### Added - Can now implement protocols using JavaScript types ```elixir defimpl MyProtocol, for: HTMLElement ``` - virtual-dom JavaScript library - ElixirScript.Html module for defining a virtual-dom tree - ElixirScript.VDom module for manipulating the virtual-dom tree created using the ElixirScript.Html module - Added ElixirScript.View module for handling view state and rendering virtual-dom - Added `stdlib_path` compiler option to specify the es6 path to the standard library. If used, elixir.js will not be exported with the compiled modules ### Changed - Renamed `ex2js` to `elixirscript`. This effects the escript as well as the mix task - Structs are now translated into classes - Structs and Tuples now match on their types - Can now match on JavaScript classes. Works just like matching on structs: ```elixir def my_func(%HTMLElement{id: "myId"}) ``` - Moved non-elixir JavaScript code into `core` es6 module. This will hopefully make it so ElixirScript Standard Library modules can be defined in Elixir soon. ## [0.13.0] - 2015-10-26 ### Added - `Base` module with function: encode64, decode64, and decode64! - `String` module - `Bitwise` module - `Map` module - `MapSet` module - `Set` module - Protocol support - Added `Collectable`, `Enumerable`, `Inspect`, `List.Chars`, and `String.Chars` protocols. The only one currently being used in the Standard Library, however, is String.Chars ## [0.12.0] - 2015-09-23 ### Added - Added PostOffice. Only thing that current uses it is Agent ### Changed - Updated tuple implementation. It's now a class. - Replaced pattern matching library with custom one - Moved data types to Kernel.SpecialForms - `else` now works for try expressions - for now works with `into` for lists ### Removed - Removed erlang.js. ## [0.11.0] - 2015-09-17 ### Added - Added `JS` module with `new`, `mutate`, `import` macros - Added `Keyword` module with functions, `has_key?` and `get` - Added `Agent` module with functions, `start`, `get`, `update`, and `get_and_update` ### Changed - Map keys are now correctly turned into their atom counterparts if atom keys are used - `import` works with all options - `Mutable.update` has been replaced by `JS.update` - `transpile`, `transpile_quoted`, and `transpile_path` are now `compile`, `compile_quoted`, and `compile_path` - All Standard libraries are rolled up into one elixir.js file and imported from that - Modules no longer export a default object - `alias` now translates to a namespace import unless `default` option is given ## [0.10.0] - 2015-09-02 ### Added - Added `env` option for `ElixirScript.transpile` adding macros for compilation - Added `Logger` that translates Logger functions to console ### Changed - Updated `Kernel` module to translate some functions to it's JavaScript equivalent ### Fixed - Fixed `case` implementation to add `this` to call ## [0.9.0] - 2015-08-30 ### Added - an implementation for quote. Currently ignores `:location` and `:context` options - an implementation for unquote and unquote_splicing ## [0.8.0] - 2015-08-15 ### Added - Can now support catch blocks in try expressions - Added receive ### Changed - Updated pattern matching implementation - Wrapped try's in function closure to make sure they return a value; ## [0.7.0] - 2015-08-01 ### Added - Can now support rescue and after blocks in try expressions ## [0.6.5] - 2015-07-13 ### Changed - Now using the JS code generator from elixir-estree for code generation, improving speed of transpilation - the parse functions in the ElixirScript module have been renamed to transpile ## [0.6.0] - 2015-07-02 ### Added - Added iterators for Range and BitString - Now replacing characters that can't be used in variable and function names in JavaScript with something that it (i.e. `match?` -> `match__qmark__`) - Implemented Integer module ### Changed - Made the Tuple, Range and BitString data structures more immutable - Atom now translates to an ES6 Symbol - List now translates to a frozen JS Array - Updated the pattern match binding to use ES6 destructuring for lists and tuples - Inner modules are now split out into their own files * Standard lib is now exported with file output from cli * Standard lib modules are now automatically imported * No longer have to define modules via aliases ahead of time. They will be automatically be resolved and made into JavaScript import statements ## [0.5.0] - 2015-05-31 ### Added - added `from` clause to `import`, `alias`, and `require` so that the import path can be overridden ### Changed - For statements now work with pattern matching tuples - Improved function chaining - `alias` now acts like `require` in that it is translated into an import default statement - modules now export a default object with def functions added as properties on it. - for function closures, now calling by using `.call(this)` so that `this` is available inside of it ## [0.4.0] - 2015-05-05 ### Added - bitstrings - Better Pattern Matching (Does not support bitstrings yet) - Capture Operator - Added more functions from the list standard library ### Changed - Updated variable implementation to match Elixir's (i.e. Reusing the same variable name creates a new one in the background) ### Fixed - Fixed multi arity implementation ## [0.3.0] - 2015-04-23 ### Added - function and case guards - function and case pattern matching ### Changed - Can now use ^ on a variable during assignment ## [0.2.1] - 2015-04-14 ### Changed - Renamed project to ElixirScript - Reduced escript file size ## [0.2.0] - 2015-04-12 ### Added - Pipe operator - String interpolation - Adding more functions to the Kernel module - Fully implemented Tuple module - Fully implemented Atom module - Fully implemented Range module ### Changed - Now checking to see if a function is a Kernel function and prepending Kernel to it - Now turning Atoms into an Atom javascript object instead of a Symbol - Now turning tuples into a Tuple javascript object - Can now call properties and zero parameter functions correctly - case, cond, and if are now turned into if statements wrapped in function closures - Anonymous functions are now turned into anonymous functions in javascript insteed of arrow functions ## [0.1.0] - 2015-04-04 ### Added - From standard library implemented: * Enum.map * Kernel.tl * Kernel.hd * Logger - Implemented language features: * All primitives except bitstrings * defmodule * import, alias, and require * case, cond, if * def, defp * defstruct, defexception * raise * multiple arity functions * basic binary operations * for without into elixirscript-0.25.0/CONTRIBUTING.md000066400000000000000000000140561305236071500165600ustar00rootroot00000000000000# Contributing to ElixirScript This contributing guide is based on the contributing for Elixir with changes suitable for this project. ## Using the issue tracker Use the issues tracker for: * [bug reports](#bug-reports) * [submitting pull requests](#pull-requests) * [feature requests](#feature-requests) ## Bug reports A bug is a _demonstrable problem_ that is caused by the code in the repository. Good bug reports are extremely helpful - thank you! Guidelines for bug reports: 1. **Use the GitHub issue search** — [check if the issue has already been reported](https://github.com/bryanjos/elixirscript/search?type=Issues). 2. **Check if the issue has been fixed** — try to reproduce it using the `master` branch in the repository. 3. **Isolate and report the problem** — ideally create a reduced test case. Please try to be as detailed as possible in your report. Please provide steps to reproduce the issue as well as the outcome you were expecting! All these details will help developers to fix any potential bugs. Example: > Short and descriptive example bug report title > > A summary of the issue and the environment in which it occurs. If suitable, > include the steps required to reproduce the bug. > > 1. This is the first step > 2. This is the second step > 3. Further steps, etc. > > `` - a link to the reduced test case (e.g. a GitHub Gist) > > Any other information you want to share that is relevant to the issue being > reported. This might include the lines of code that you have identified as > causing the bug, and potential solutions (and your opinions on their > merits). ## Feature requests Feature requests are welcome. But take a moment to find out whether your idea fits with the scope and aims of the project. It's up to *you* to make a strong case to convince the community of the merits of this feature. Please provide as much detail and context as possible. ## Contributing Contributions to ElixirScript are welcomed! These contributions can be in the form or code changes, documentation, or ideas of how to implement features found in Elixir in ElixirScript. ElixirScript is broken up into the following parts: * The compiler, written in Elixir * The standard library modules, mostly written in Elixir * The javascript core The ElixirScript compiler is in the `lib` folder of the project. Here is where Elixir code is converted into JavaScript. The standard library modules are in the `lib/std_lib` folder. The JavaScript code is in the `src/javascript`. This is where features such as pattern matching and the standard library are implemented. The ElixirScript tests can be run using `mix test` The JavaScript tests can be run using `npm test` Please make sure all tests pass after making changes. Also make sure to include tests for the changes you made. Contributing to the JavaScript code may be the easiest and most rewarding changes. Don't see a feature, module or function from Elixir in ElixirScript yet? You can implement it in the JavaScript code. ## Pull requests Good pull requests - patches, improvements, new features - are a fantastic help. They should remain focused in scope and avoid containing unrelated commits. **NOTE**: Do not send code style changes as pull requests like changing the indentation of some particular code snippet or how a function is called. Those will not be accepted as they pollute the repository history with non functional changes and are often based on personal preferences. **IMPORTANT**: By submitting a patch, you agree that your work will be licensed under the license used by the project. If you have any large pull request in mind (e.g. implementing features, refactoring code, etc), **please ask first** otherwise you risk spending a lot of time working on something that the project's developers might not want to merge into the project. Please adhere to the coding conventions in the project (indentation, accurate comments, etc.) and don't forget to add your own tests and documentation. When working with Git, we recommend the following process in order to craft an excellent pull request: 1. [Fork](https://help.github.com/fork-a-repo/) the project, clone your fork, and configure the remotes: ```sh # Clone your fork of the repo into the current directory git clone https://github.com//elixirscript # Navigate to the newly cloned directory cd elixirscript # Assign the original repo to a remote called "upstream" git remote add upstream https://github.com/bryanjos/elixirscript ``` 2. If you cloned a while ago, get the latest changes from upstream: ```sh git checkout master git pull upstream master ``` 3. Create a new topic branch (off of `master`) to contain your feature, change, or fix. **IMPORTANT**: Making changes in `master` is discouraged. You should always keep your local `master` in sync with upstream `master` and make your changes in topic branches. ```sh git checkout -b ``` 4. Commit your changes in logical chunks. Keep your commit messages organized, with a short description in the first line and more detailed information on the following lines. Feel free to use Git's [interactive rebase](https://help.github.com/articles/interactive-rebase) feature to tidy up your commits before making them public. 5. Make sure all the tests are still passing. ```sh mix test npm test ``` This is needed to ensure your changes can pass all the tests. 6. Push your topic branch up to your fork: ```sh git push origin ``` 7. [Open a Pull Request](https://help.github.com/articles/using-pull-requests/) with a clear title and description. 8. If you haven't updated your pull request for a while, you should consider rebasing on master and resolving any conflicts. **IMPORTANT**: _Never ever_ merge upstream `master` into your branches. You should always `git rebase` on `master` to bring your changes up to date when necessary. ```sh git checkout master git pull upstream master git checkout git rebase master ``` Thank you for your contributions! elixirscript-0.25.0/FAQ.md000066400000000000000000000035151305236071500152560ustar00rootroot00000000000000# FAQ # Q. How do I get started? ### A. Check out the [Getting Started](GettingStarted.md) Guide for more info. # Q. How much is implemented? ### A. Most of Kernel.SpecialForms as well as some modules in the Standard Library The compiler to this point has been focused on translating Kernel.SpecialForms and Kernel. Below is a list of what is complete, incomplete, as well as missing #### Kernel.SpecialForms * Complete * `__DIR__` * `__MODULE__` * `^var` * `&expr` * `for` * `%{}` * `{args}` * `<>` * `fn [clauses] end` * `cond(clauses)` * `__block__` * `__aliases__` * `unquote` * `unquote_splicing` * `%` * `left.right` * `quote` * `import` * `case` * `left = right` * `require` * `left :: right` * `alias` * `__CALLER__` * `__ENV__` * Missing * `super(args)` * `receive` * Caveats * `quote` - ignores `context` options * `left = right` does not support full unification yet. ```elixir a = 1 # works as expected 1 = a # may not work currently, but in some cases it will ``` #### Completed Modules * Tuple * List * Atom * Range * Logger * Map * MapSet #### Incomplete Modules * Kernel * Enum * Agent * Integer * Keyword * Base * String * Bitwise * Set #### Missing Modules * Everything else ## Q. Can I use it today? ### A. Yes, but realize this is not at 1.0 yet. You **can** use ElixirScript on your front ends and have it work and interoperate with JavaScript modules. The problem is since most of the standard library is incomplete. ## Q. Can I use pattern matching? ### A. Yes ## Q. Can I use processes? ### A. ElixirScript does not support processes ## Q. What about OTP? ### A. ElixirScript does not support OTP elixirscript-0.25.0/GettingStarted.md000066400000000000000000000110731305236071500175750ustar00rootroot00000000000000# Getting Started with ElixirScript The intent of this guide is to get you started with ElixirScript. It will give you instructions on using ElixirScript. I will go over the two ways you can use Elixirscript: * As a CLI * As a mix dependency ### CLI **macOS**: Elixirscript is available via homebrew `brew install elixirscript`. For everyone else, please read below Step 1: Get CLI You can download the elixirscript CLI from the [releases page on github](https://github.com/bryanjos/elixirscript/releases). It is a tar file named elixirscript.tar.gz. Step 2: Untar Next, untar elixirscript.tar.gz tar -xvzf elixirscript.tar.gz You will want to put the bin folder from the uncompressed folder into your path. This should allow you to use the elixirscript CLI. Step 3: Use This is the help output of elixirscript usage: elixirscript [options] path to elixir files or the elixir code string if passed the -ex flag options: -f --format [format] module format of output. options: es (default), common, umd -o --output [path] places output at the given path -ex --elixir read input as elixir code string --full-build informs the compiler to do a full build instead of an incremental one --core-path import path to the elixirscript standard lib only used with the [output] option. When used, Elixir.js is not exported -v --version the current version number -h --help this message the `` is the elixir code string or file path you want to convert from elixir to javascript. Below is an example of using a code string and turning it into JavaScript $ elixirscript ":atom" -ex Symbol.for('atom') It changed the elixir code, `:atom` into the JavaScript code `Symbol.for('atom')`. The `-ex` parameter lets the script know that the input is an Elixir code string instead of a file. elixirscript also takes a path to your `.ex` files as well: $ elixirscript "src" -o "dist" If you look in the dist folder, you should see 2 folders. `app` contains your code and `elixir` contains the elixirscript standard library files. ### Mix dependency Adding Elixirscript to your mix project gives you the ability to add it to your list of mix compilers. This means when you `mix compile`, Elixirscript will compile your code as well. Add dependency to your deps in mix.exs: ```elixir {:elixir_script, "~> 0.25"} ``` Elixirscript uses default input, output and module formats if options are not given. If you wish to change any or all options, add an `elixir_script` key to your project configuration. def project do [ app: :my_app, version: "0.1.0", elixir: "~> 1.0", deps: deps, elixir_script: [ input: "lib/elixirscript", output: "priv/elixirscript", format: :es], compilers: [:elixir_script] ++ Mix.compilers ] end Available options are: * `input`: The folder to look for Elixirscript files in. (defaults to `lib/elixirscript`) * `output`: The folder to place generated JavaScript code in. (defaults to `priv/elixirscript`) * `format`: The module format of generated JavaScript code. (defaults to `:es`). Choices are:     * `:es` - ES Modules * `:common` - CommonJS * `:umd` - UMD ### Macros Elixirscript supports public macros. Private macros are currently unsupported. ### JavaScript Interop Elixirscript has a couple of ways of interacting with JavaScript. #### Globally scoped functions Use the erlang module syntax, to call JavaScript functions in the global scope. # Calling alert :window.alert("hi") # console :console.log("hello") # document :document.getElementById("main") #### Globally scoped modules You can call globally scoped modules you would an Elixir module Date.now() Only works if module begins with a captial letter #### Importing Modules To import modules, first you must `require` the `JS` module. Then import the module using `JS.import` defmodule MyModule do require JS JS.import React, "react" def func() do React.render(my_component) end end #### The JS module The JS module has many other functions and macros. For more information, check out the docs. #### Frontend Project Boilerplate There is an [elixirscript frontend boilerplate project](https://github.com/bryanjos/elixirscript-project-boilerplate). This setup uses gulp and webpack to build and bundle assets. #### ElixirScript-Brunch There is an Brunch plugin, [ElixirScript-Brunch](https://www.npmjs.com/package/elixirscript-brunch). There are instructions there on how to use it with Phoenix.elixirscript-0.25.0/LICENSE000066400000000000000000000020661305236071500153320ustar00rootroot00000000000000The MIT License (MIT) Copyright (c) 2015 Bryan Joseph 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.elixirscript-0.25.0/README.md000066400000000000000000000054311305236071500156030ustar00rootroot00000000000000## ElixirScript [![Documentation](https://img.shields.io/badge/docs-hexpm-blue.svg)](http://hexdocs.pm/elixir_script/) [![Build](https://travis-ci.org/bryanjos/elixirscript.svg?branch=master)](https://travis-ci.org/bryanjos/elixirscript) [![Deps Status](https://beta.hexfaktor.org/badge/all/github/bryanjos/elixirscript.svg)](https://beta.hexfaktor.org/github/bryanjos/elixirscript) [![Join the chat at https://gitter.im/elixirscript/elixirscript](https://badges.gitter.im/elixirscript/elixirscript.svg)](https://gitter.im/elixirscript/elixirscript?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) The goal is to convert a subset (or full set) of Elixir code to JavaScript, providing the ability to write JavaScript in Elixir. This is done by taking the Elixir AST and converting it into JavaScript AST and then to JavaScript code. This is done using the [Elixir-ESTree](https://github.com/bryanjos/elixir-estree) library. Requirements =========== * Elixir * Node (only for development) Usage ======== Please check the [Getting Started Guide](GettingStarted.md) for usage FAQ, Limitations ======== Please check the [FAQ](FAQ.md) Development =========== Clone the repo git clone git@github.com:bryanjos/elixirscript.git Get dependencies mix deps.get npm install Compile mix do std_lib, clean, compile Test mix test npm test Build ============= MIX_ENV=prod mix do clean, compile, std_lib, dist This will build a tarball in the dist folder. By default the escript built will look into the folder above it for the core JavaScript files needed for ElixirScript. To change the location, update the `lib_path` config variable in the `:elixir_script` config block to the path to look in and then do a clean build. Communication ======== [gitter room](https://gitter.im/elixirscript/elixirscript) [#elixirscript](https://elixir-lang.slack.com/messages/elixirscript/) on the elixir-lang Slack Contributing ======== Please check the [CONTRIBUTING.md](CONTRIBUTING.md) ### Example projects * [hello](https://github.com/bryanjos/hello) Shows using Phoenix + Elixirscript with file watching * [Elixirscript frontend boilerplate](https://github.com/bryanjos/elixirscript-project-boilerplate) A boilerplate project for elixirscript frontends * [Elixirscript React example](https://github.com/bryanjos/elixirscript_react) An example of using with React * [Elixirscript AWS Lambda example](https://github.com/bryanjos/elixirscript_lambda) #### Using with Brunch There is a plugin for using ElixirScript in your Brunch project [here](https://www.npmjs.com/package/elixirscript-brunch) #### 1.0 Roadmap There is a [1.0.0 Milestone](https://github.com/bryanjos/elixirscript/milestones/1.0.0) defined which includes issues that are needed to be cleared before 1.0 can be reached. elixirscript-0.25.0/config/000077500000000000000000000000001305236071500155665ustar00rootroot00000000000000elixirscript-0.25.0/config/config.exs000066400000000000000000000022001305236071500175460ustar00rootroot00000000000000# This file is responsible for configuring your application # and its dependencies with the aid of the Mix.Config module. use Mix.Config # This configuration is loaded before any dependency and is restricted # to this project. If another project depends on this project, this # file won't be loaded nor affect the parent project. For this reason, # if you want to provide default values for your application for third- # party users, it should be done in your mix.exs file. # Sample configuration: # config :logger, :console, level: :debug, format: "$date $time [$level] $metadata$message\n", metadata: [:user_id] config :elixir_script, lib_path: nil #The path to the elixirscript core and standard library JavaScript files # It is also possible to import configuration files, relative to this # directory. For example, you can emulate configuration per environment # by uncommenting the line below and defining dev.exs, test.exs and such. # Configuration from the imported file will override the ones defined # here (which is why it is important to import them last). # import_config "#{Mix.env}.exs" elixirscript-0.25.0/config/dev.exs000066400000000000000000000000171305236071500170630ustar00rootroot00000000000000use Mix.Config elixirscript-0.25.0/config/prod.exs000066400000000000000000000000171305236071500172510ustar00rootroot00000000000000use Mix.Config elixirscript-0.25.0/config/test.exs000066400000000000000000000000171305236071500172640ustar00rootroot00000000000000use Mix.Config elixirscript-0.25.0/gulpfile.js000066400000000000000000000007061305236071500164710ustar00rootroot00000000000000var gulp = require('gulp'); var babel = require('gulp-babel'); var sourcemaps = require('gulp-sourcemaps'); var path = './src/javascript'; gulp.task('build', function() { return gulp.src([path + '/**/*.js', '!' + path + '/dist_build/**/*.js', '!' + path + '/tests/**/*.js']) .pipe(sourcemaps.init()) .pipe(babel({ presets: ["react", "stage-0"], babelrc: false })) .pipe(sourcemaps.write()) .pipe(gulp.dest('./src/elixirscript')); }); elixirscript-0.25.0/lib/000077500000000000000000000000001305236071500150675ustar00rootroot00000000000000elixirscript-0.25.0/lib/elixir_script.ex000066400000000000000000000216731305236071500203160ustar00rootroot00000000000000defmodule ElixirScript do require Logger @moduledoc """ Translates Elixir into JavaScript. All compile functions return a list of transpiled javascript code or a tuple consisting of the file name for the code and the transpiled javascript code. All compile functions also take an optional opts parameter that controls transpiler output. Available options are: * `:include_path` - a boolean controlling whether to return just the JavaScript code or a tuple of the file name and the JavaScript code * `:core_path` - The es6 import path used to import the elixirscript core. When using this option, the Elixir.js file is not exported * `:full_build` - For compile_path, tells the compiler to perform a full build instead of incremental one * `:output` - option to tell compiler how to output data * `nil`: Return as list * `:stdout`: Write to standard out * `path (string)`: Write to specified path """ defmacro __using__(_) do quote do import Kernel, except: [ if: 2, unless: 2, abs: 1, apply: 2, apply: 3, binary_part: 3, hd: 1, tl: 1, is_atom: 1, is_binary: 1, is_bitstring: 1, is_boolean: 1, is_float: 1, is_function: 1, is_function: 2, is_integer: 1, is_list: 1, is_number: 1, is_pid: 1, is_tuple: 1, is_map: 1, is_port: 1, is_reference: 1, length: 1, map_size: 1, max: 2, min: 2, round: 1, trunc: 1, tuple_size: 1, elem: 2, is_nil: 1, make_ref: 1, spawn: 1, spawn: 3, spawn_link: 1, spawn_link: 3, spawn_monitor: 1, spawn_monitor: 3, send: 2, self: 0, match?: 2, to_string: 1, "|>": 2, in: 2, "..": 2, sigil_r: 2 ] import ElixirScript.Kernel require JS end end # This is the serialized state of the ElixirScript.State module containing references to the standard library @external_resource stdlib_state_path = Path.join([__DIR__, "elixir_script", "translator", "stdlib_state.bin"]) @stdlib_state File.read(stdlib_state_path) @lib_path Application.get_env(:elixir_script, :lib_path) @version Mix.Project.config[:version] @doc """ Compiles the given Elixir code string """ @spec compile(binary, Map.t) :: [binary | {binary, binary} | :ok] def compile(elixir_code, opts \\ %{}) do elixir_code |> List.wrap |> Enum.map(fn(x) -> x |> Code.string_to_quoted! |> compile_quoted(opts) end) |> List.flatten end @doc """ Compiles the given Elixir code in quoted form """ @spec compile_quoted(Macro.t, Map.t) :: [binary | {binary, binary} | :ok] def compile_quoted(quoted, opts \\ %{}) do opts = build_compiler_options(Map.merge(opts, %{import_standard_libs: false})) data = quoted |> get_modules_from_quoted |> Enum.map(fn(x) -> %{ast: x, app: :app} end) result = %{data: data} |> ElixirScript.Passes.Init.execute(opts) |> ElixirScript.Passes.FindModules.execute(opts) |> ElixirScript.Passes.FindLoadOnly.execute(opts) |> ElixirScript.Passes.FindFunctions.execute(opts) |> ElixirScript.Passes.AddStdLib.execute(opts) |> ElixirScript.Passes.JavaScriptAST.execute(opts) |> ElixirScript.Passes.ConsolidateProtocols.execute(opts) |> ElixirScript.Passes.JavaScriptCode.execute(opts) |> ElixirScript.Passes.JavaScriptName.execute(opts) |> ElixirScript.Passes.HandleOutput.execute(opts) result end defp get_modules_from_quoted(quoted) do results = case quoted do {:__block__, _, list} -> {modules, not_modules} = Enum.partition(list, fn {type, _, _ } when type in [:defprotocol, :defimpl, :defmodule] -> true _ -> false end) temp_module = case not_modules do [] -> [] _ -> [{:defmodule, [], [{:__aliases__, [], [:ElixirScript, :Temp]}, [do: { :__block__, [], not_modules }]]}] end modules ++ temp_module {type, _, _ } = x when type in [:defprotocol, :defimpl, :defmodule] -> x x -> {:defmodule, [], [{:__aliases__, [], [:ElixirScript, :Temp]}, [do: { :__block__, [], [x] }]]} end List.wrap(results) end @doc """ Compiles the elixir files found at the given path """ @spec compile_path(binary | [binary] | map, Map.t) :: [binary | {binary, binary} | :ok] def compile_path(path, opts \\ %{}) def compile_path(path, opts) when is_binary(path) do compile_path([path], opts) end def compile_path(path, opts) when is_list(path) do built_opts = build_compiler_options(opts) app_name = cond do !is_nil(built_opts[:app]) -> built_opts[:app] Code.ensure_loaded?(Mix) -> Mix.Project.config()[:app] true -> :app end compile_path(Map.put(%{}, app_name, path), opts) end def compile_path(path, opts) do opts = build_compiler_options(opts) deps = path |> Map.to_list |> Enum.map(fn {app, path} -> {app, List.wrap(path)} end) result = %{data: deps} |> ElixirScript.Passes.Init.execute(opts) |> ElixirScript.Passes.ASTFromFile.execute(opts) |> ElixirScript.Passes.LoadModules.execute(opts) |> ElixirScript.Passes.FindModules.execute(opts) |> ElixirScript.Passes.FindLoadOnly.execute(opts) |> ElixirScript.Passes.FindFunctions.execute(opts) |> ElixirScript.Passes.AddStdLib.execute(opts) |> ElixirScript.Passes.JavaScriptAST.execute(opts) |> ElixirScript.Passes.ConsolidateProtocols.execute(opts) |> ElixirScript.Passes.JavaScriptCode.execute(opts) |> ElixirScript.Passes.JavaScriptName.execute(opts) |> ElixirScript.Passes.HandleOutput.execute(opts) result end @doc false def get_stdlib_state() do case @stdlib_state do {:ok, data} -> data {:error, _} -> raise RuntimeError, message: "Standard Library state not found. Please run `mix std_lib`" end end @doc false def version(), do: @version @doc false def compile_std_lib() do compile_std_lib(Path.join([File.cwd!, "priv"])) end @doc false def compile_std_lib(output_path) do opts = build_compiler_options(%{std_lib: true, include_path: true, output: output_path, app: :elixir}) libs_path = Path.join([__DIR__, "std_lib"]) result = %{data: [{:elixir, List.wrap(libs_path)}]} |> ElixirScript.Passes.Init.execute(opts) |> ElixirScript.Passes.ASTFromFile.execute(opts) |> ElixirScript.Passes.FindModules.execute(opts) |> ElixirScript.Passes.FindLoadOnly.execute(opts) |> ElixirScript.Passes.FindFunctions.execute(opts) |> ElixirScript.Passes.JavaScriptAST.execute(opts) |> ElixirScript.Passes.ConsolidateProtocols.execute(opts) |> ElixirScript.Passes.JavaScriptCode.execute(opts) |> ElixirScript.Passes.JavaScriptName.execute(opts) |> ElixirScript.Passes.HandleOutput.execute(opts) result end defp build_compiler_options(opts) do default_options = Map.new |> Map.put(:include_path, false) |> Map.put(:root, nil) |> Map.put(:env, __ENV__) |> Map.put(:import_standard_libs, true) |> Map.put(:core_path, "Elixir.Bootstrap") |> Map.put(:full_build, false) |> Map.put(:output, nil) |> Map.put(:app, :app) |> Map.put(:format, :es) options = Map.merge(default_options, opts) Map.put(options, :module_formatter, get_module_formatter(options[:format])) end defp get_module_formatter(:umd) do ElixirScript.ModuleSystems.UMD end defp get_module_formatter(:common) do ElixirScript.ModuleSystems.Common end defp get_module_formatter(_) do ElixirScript.ModuleSystems.ES end @doc """ Copies the javascript that makes up the ElixirScript stdlib to the specified location """ def copy_stdlib_to_destination(module_format, destination) do Enum.each(Path.wildcard(Path.join([operating_path, to_string(module_format), "elixir", "*.js"])), fn(path) -> base = Path.basename(path) File.mkdir_p!(Path.join([destination, "elixir"])) File.cp!(path, Path.join([destination, "elixir", base])) end) end #Gets path to js files whether the mix project is available #or when used as an escript defp operating_path do case @lib_path do nil -> if Code.ensure_loaded?(Mix.Project) do Mix.Project.build_path <> "/lib/elixir_script/priv" else split_path = Path.split(Application.app_dir(:elixirscript)) replaced_path = List.delete_at(split_path, length(split_path) - 1) replaced_path = List.delete_at(replaced_path, length(replaced_path) - 1) Path.join(replaced_path) end lib_path -> lib_path end end end elixirscript-0.25.0/lib/elixir_script/000077500000000000000000000000001305236071500177475ustar00rootroot00000000000000elixirscript-0.25.0/lib/elixir_script/cli.ex000066400000000000000000000054261305236071500210630ustar00rootroot00000000000000defmodule ElixirScript.CLI do @moduledoc false @app_version Mix.Project.config()[:version] @switches [ output: :string, elixir: :boolean, help: :boolean, core_path: :string, full_build: :boolean, version: :boolean, watch: :boolean, format: :string ] @aliases [ o: :output, ex: :elixir, h: :help, v: :version, f: :format ] def main(argv) do argv |> parse_args |> process end def parse_args(args) do { options, input, errors } = OptionParser.parse(args, switches: @switches, aliases: @aliases) cond do length(errors) > 0 -> :help Keyword.get(options, :help, false) -> :help Keyword.get(options, :version, false) -> :version length(input) == 0 -> :help true -> { input, options } end end def help_message() do """ usage: elixirscript [options] path to elixir files or the elixir code string if passed the -ex flag options: -f --format [format] module format of output. options: es (default), common, umd -o --output [path] places output at the given path -ex --elixir read input as elixir code string --full-build informs the compiler to do a full build instead of an incremental one --core-path import path to the elixirscript standard lib only used with the [output] option. When used, Elixir.js is not exported -v --version the current version number -h --help this message """ end def process(:help) do IO.write help_message end def process(:version) do IO.write @app_version end def process({ input, options }) do if options_contains_unknown_values(options) do process(:help) else do_process(input, options) end end def do_process(input, options) do {watch, options} = Keyword.pop(options, :watch, false) compile_opts = %{ include_path: true, core_path: Keyword.get(options, :core_path, "Elixir.Bootstrap"), full_build: Keyword.get(options, :full_build, false), output: Keyword.get(options, :output, :stdout), format: String.to_atom(Keyword.get(options, :format, "es")) } case options[:elixir] do true -> ElixirScript.compile(input, compile_opts) _ -> input = input |> Enum.map(fn(x) -> String.split(x, [" ", ","], trim: true) end) |> List.flatten ElixirScript.compile_path(input, compile_opts) if watch do ElixirScript.Watcher.start_link(input, compile_opts) :timer.sleep :infinity end end end defp options_contains_unknown_values(options) do Enum.any?(options, fn({key, _value}) -> if key in Keyword.keys(@switches) do false else true end end) end end elixirscript-0.25.0/lib/elixir_script/compiler/000077500000000000000000000000001305236071500215615ustar00rootroot00000000000000elixirscript-0.25.0/lib/elixir_script/compiler/cache.ex000066400000000000000000000070701305236071500231660ustar00rootroot00000000000000defmodule ElixirScript.Compiler.Cache do @moduledoc false require Logger def delete(path) do case get_tmp_file(path) do nil -> nil tmp_file -> if !File.exists?(tmp_file) do File.rm(tmp_file) end end end def get(path) do case get_tmp_file(path) do nil -> nil tmp_file -> if File.exists?(tmp_file) do case File.read(tmp_file) do {:ok, data} -> :erlang.binary_to_term(data) {:error, reason} -> Logger.info("Unable to read compiler cache") Logger.info(reason) nil end else nil end end end def write(path, stats) do case get_tmp_file(path) do nil -> { :error, nil } tmp_file -> case File.write(tmp_file, :erlang.term_to_binary(stats)) do :ok -> :ok {:error, reason} -> Logger.info("Unable to write compiler cache") Logger.info(reason) { :error, reason } end end end def get_changed_files(old_file_stats, new_file_stats) do if(length(old_file_stats) != length(new_file_stats)) do new_file_stats else old_file_stats = Enum.sort(old_file_stats, fn {file1, _}, {file2, _} -> file1 < file2 end) new_file_stats = Enum.sort(new_file_stats, fn {file1, _}, {file2, _} -> file1 < file2 end) zipped = Enum.zip(old_file_stats, new_file_stats) if(Enum.any?(zipped, fn({ {old_file, _} , {new_file, _ } }) -> old_file != new_file end)) do new_file_stats else Enum.reduce(zipped, [], fn({ {_, old_stat} , {_, new_stat } = new }, state) -> cond do old_stat.mtime != new_stat.mtime -> state ++ [new] true -> state end end) end end end def build_file_stats(path) do Enum.map(path, fn(file) -> { file, File.stat!(file) } end) end def new(state) do %{ input_files: [], state: state, full_build?: true, version: ElixirScript.version() } end defp get_tmp_file(path) do case System.tmp_dir do nil -> nil tmp -> tmp_dir = Path.join([tmp, "elixirscript"]) if !File.exists?(tmp_dir) do case File.mkdir_p(tmp_dir) do :ok -> encoded_path = Path.absname(path) |> Path.dirname |> Base.encode64 Path.join([tmp_dir, encoded_path]) {:error, reason} -> Logger.info("Unable to write compiler cache") Logger.info(reason) nil end else encoded_path = Path.absname(path) |> Path.dirname |> Base.encode64 Path.join([tmp_dir, encoded_path]) end end end def get_compiler_cache(path, opts) do refresh_cache = cond do Map.get(opts, :full_build) -> true empty?(opts.output) -> true old_version?(opts) -> true get(path) == nil -> true true -> false end if refresh_cache do delete(path) new(ElixirScript.get_stdlib_state()) else %{ get(path) | full_build?: false } end end defp empty?(path) when is_binary(path) do case File.ls(path) do {:ok, []} -> true {:error, _} -> true _ -> false end end defp empty?(_) do true end defp old_version?(opts) do cache_version = Map.get(opts, :version, nil) cache_version == ElixirScript.version() end end elixirscript-0.25.0/lib/elixir_script/module_systems/000077500000000000000000000000001305236071500230235ustar00rootroot00000000000000elixirscript-0.25.0/lib/elixir_script/module_systems/common.ex000066400000000000000000000045421305236071500246560ustar00rootroot00000000000000defmodule ElixirScript.ModuleSystems.Common do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator alias ElixirScript.Translator.State alias ElixirScript.Translator.Utils def build(body, exports, env) do js_module_refs = State.get_javascript_module_references(env.state, env.module) std_import = make_std_lib_import(env) module_refs = State.get_module_references(env.state, env.module) -- [env.module] |> module_imports_to_js_imports(env) imports = js_module_refs ++ std_import |> Enum.map(fn {module, path, true} -> import_module(module, path, env) {module, path, false} -> import_namespace_module(module, path, env) end) imports = Enum.uniq(imports ++ module_refs) export = export_module(exports) imports ++ body ++ [export] end defp module_imports_to_js_imports(module_refs, env) do Enum.map(module_refs, fn(x) -> module_name = Utils.name_to_js_name(x) app_name = State.get_module(env.state, x).app path = Utils.make_local_file_path(app_name, Utils.name_to_js_file_name(x), env) import_module(module_name, path) end) end defp make_std_lib_import(env) do compiler_opts = State.get(env.state).compiler_opts case compiler_opts.import_standard_libs do true -> [{:Elixir, Utils.make_local_file_path(:elixir, compiler_opts.core_path, env), true }] false -> [] end end def import_namespace_module(module_name, from, env) do do_import_module(Translator.translate!(module_name, env), from) end def import_module(:Elixir, from, env) do do_import_module(JS.identifier("Elixir"), from) end def import_module(module_name, from, env) do do_import_module(Translator.translate!(module_name, env), from) end def import_module(import_name, from) do do_import_module(JS.identifier(import_name), from) end defp do_import_module(ref, file_path) do ref_declarator = JS.variable_declarator( ref, JS.call_expression( JS.identifier("require"), [JS.literal(file_path)] ) ) JS.variable_declaration([ref_declarator], :const) end def export_module(exported_object) do JS.assignment_expression( :=, JS.member_expression( JS.identifier("module"), JS.identifier("exports") ), exported_object ) end end elixirscript-0.25.0/lib/elixir_script/module_systems/es.ex000066400000000000000000000050731305236071500237750ustar00rootroot00000000000000defmodule ElixirScript.ModuleSystems.ES do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator alias ElixirScript.Translator.State alias ElixirScript.Translator.Utils def build(body, exports, env) do js_module_refs = State.get_javascript_module_references(env.state, env.module) std_import = make_std_lib_import(env) module_refs = State.get_module_references(env.state, env.module) -- [env.module] |> module_imports_to_js_imports(env) imports = js_module_refs ++ std_import |> Enum.map(fn {module, path, true} -> import_module(module, path, env) {module, path, false} -> import_namespace_module(module, path, env) end) imports = Enum.uniq(imports ++ module_refs) export = export_module(exports) imports ++ body ++ [export] end defp module_imports_to_js_imports(module_refs, env) do Enum.map(module_refs, fn(x) -> module_name = Utils.name_to_js_name(x) app_name = State.get_module(env.state, x).app path = Utils.make_local_file_path(app_name, Utils.name_to_js_file_name(x), env) import_module(module_name, path) end) end defp make_std_lib_import(env) do compiler_opts = State.get(env.state).compiler_opts case compiler_opts.import_standard_libs do true -> [{:Elixir, Utils.make_local_file_path(:elixir, compiler_opts.core_path, env), true }] false -> [] end end def import_namespace_module(module_name, from, env) do import_specifier = JS.import_namespace_specifier( Translator.translate!(module_name, env), Translator.translate!(module_name, env) ) do_import_module([import_specifier], from) end def import_module(:Elixir, from, env) do import_specifier = JS.import_default_specifier( JS.identifier("Elixir"), JS.identifier("Elixir") ) do_import_module([import_specifier], from) end def import_module(module_name, from, env) do import_specifier = JS.import_default_specifier( Translator.translate!(module_name, env), Translator.translate!(module_name, env) ) do_import_module([import_specifier], from) end def import_module(import_name, from) do import_specifier = JS.import_default_specifier( JS.identifier(import_name) ) do_import_module([import_specifier], from) end defp do_import_module(import_specifiers, file_path) do JS.import_declaration( import_specifiers, JS.literal(file_path) ) end def export_module(exported_object) do JS.export_default_declaration(exported_object) end end elixirscript-0.25.0/lib/elixir_script/module_systems/umd.ex000066400000000000000000000107551305236071500241560ustar00rootroot00000000000000defmodule ElixirScript.ModuleSystems.UMD do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator alias ElixirScript.Translator.State alias ElixirScript.Translator.Utils def build(body, exports, env) do js_module_refs = State.get_javascript_module_references(env.state, env.module) std_import = make_std_lib_import(env) module_refs = State.get_module_references(env.state, env.module) -- [env.module] |> module_imports_to_js_imports(env) imports = js_module_refs ++ std_import |> Enum.map(fn {module, path, true} -> import_module(module, path, env) {module, path, false} -> import_namespace_module(module, path, env) end) imports = Enum.uniq(imports ++ module_refs) export = export_module(exports) List.wrap(make_umd(imports, body, export)) end defp module_imports_to_js_imports(module_refs, env) do Enum.map(module_refs, fn(x) -> module_name = Utils.name_to_js_name(x) app_name = State.get_module(env.state, x).app path = Utils.make_local_file_path(app_name, Utils.name_to_js_file_name(x), env) import_module(module_name, path) end) end defp make_std_lib_import(env) do compiler_opts = State.get(env.state).compiler_opts case compiler_opts.import_standard_libs do true -> [{:Elixir, Utils.make_local_file_path(:elixir, compiler_opts.core_path, env), true }] false -> [] end end def import_namespace_module(module_name, from, env) do {Translator.translate!(module_name, env), JS.literal(from)} end def import_module(:Elixir, from, env) do {JS.identifier("Elixir"), JS.literal(from)} end def import_module(module_name, from, env) do {Translator.translate!(module_name, env), JS.literal(from)} end def import_module(import_name, from) do {JS.identifier(import_name), JS.literal(from)} end def export_module(exported_object) do exported_object end def make_umd(imports, body, exports) do import_paths = Enum.map(imports, fn({_, path}) -> path end) import_identifiers = Enum.map(imports, fn({id, _}) -> id end) JS.expression_statement( JS.call_expression( JS.function_expression([JS.identifier("root"), JS.identifier("factory")], [], JS.block_statement([ JS.if_statement( JS.logical_expression( :&&, JS.binary_expression( :===, JS.unary_expression(:typeof, true, JS.identifier("define")), JS.literal("function") ), JS.member_expression( JS.identifier("define"), JS.identifier("amd") ) ), JS.block_statement([ JS.call_expression( JS.identifier("define"), [JS.array_expression(import_paths), JS.identifier("factory")] ) ]), JS.if_statement( JS.binary_expression( :===, JS.unary_expression(:typeof, true, JS.identifier("exports")), JS.literal("object") ), JS.block_statement([ JS.assignment_expression( :=, JS.member_expression( JS.identifier("module"), JS.identifier("exports") ), JS.call_expression( JS.identifier("factory"), Enum.map(import_paths, fn x -> JS.call_expression( JS.identifier("require"), [x] ) end) ) ) ]), JS.block_statement([ JS.assignment_expression( :=, JS.member_expression( JS.identifier("root"), JS.identifier("returnExports") ), JS.call_expression( JS.identifier("factory"), Enum.map(import_identifiers, fn x -> JS.member_expression( JS.identifier("root"), x ) end) ) ) ]) ) ) ])), [JS.this_expression(), JS.function_expression(import_identifiers, [], JS.block_statement(body ++ [JS.return_statement(exports)]))] ) ) end endelixirscript-0.25.0/lib/elixir_script/passes/000077500000000000000000000000001305236071500212455ustar00rootroot00000000000000elixirscript-0.25.0/lib/elixir_script/passes/add_std_lib.ex000066400000000000000000000003721305236071500240350ustar00rootroot00000000000000defmodule ElixirScript.Passes.AddStdLib do @moduledoc false alias ElixirScript.Translator.State def execute(compiler_data, opts) do State.deserialize(compiler_data.state, ElixirScript.get_stdlib_state, []) compiler_data end end elixirscript-0.25.0/lib/elixir_script/passes/ast_from_file.ex000066400000000000000000000011571305236071500244200ustar00rootroot00000000000000defmodule ElixirScript.Passes.ASTFromFile do @moduledoc false def execute(compiler_data, opts) do data = Enum.reduce(compiler_data.data, [], fn({dep, paths}, list) -> file_paths = paths |> Enum.flat_map(fn(path) -> Path.join(path, "**/*.{ex,exs,exjs}") |> Path.wildcard end) |> Enum.reduce([], fn(path, list) -> quoted = path |> File.read! |> Code.string_to_quoted! stat = File.stat!(path) list ++ [%{ path: path, app: dep, stat: stat, ast: quoted }] end) list ++ file_paths end) Map.put(compiler_data, :data, data) end end elixirscript-0.25.0/lib/elixir_script/passes/consolidate_protocols.ex000066400000000000000000000074431305236071500262230ustar00rootroot00000000000000defmodule ElixirScript.Passes.ConsolidateProtocols do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator.Utils alias ElixirScript.Translator.State require Logger def execute(compiler_data, opts) do State.set_module_data(compiler_data.state, compiler_data.data) data = State.get_module_data(compiler_data.state) only_protocols_and_impls = Enum.filter(data, fn ({_, %{type: :module}}) -> false ({_, %{type: :consolidated}}) -> false _ -> true end) grouped = group_protocol_data(only_protocols_and_impls) consolidated_protocols = update_protocols(grouped, opts) data = Enum.reduce(consolidated_protocols, data, fn({ key, value }, d) -> Keyword.put(d, key, value) end) %{ compiler_data | data: data } end defp group_protocol_data(data) do Enum.reduce(data, %{}, fn({module_name, module_data} = dat, state) -> if module_data.type == :protocol do existing = Map.get(state, module_name, %{}) existing = Map.put(existing, :protocol, dat) Map.put(state, module_name, existing) else existing = Map.get(state, module_data.implements, %{}) existing_protocol_data = Map.get(existing, :impls, []) existing_protocol_data = existing_protocol_data ++ [dat] existing = Map.put(existing, :impls, existing_protocol_data) Map.put(state, module_data.implements, existing) end end) end defp update_protocols(grouped_protocol_data, opts) do Enum.map(grouped_protocol_data, fn ({ protocol_name, %{ protocol: protocol, impls: impls } }) -> make_defimpl(protocol_name, protocol, Enum.uniq(impls), opts) ({ protocol_name, %{ protocol: protocol } }) -> make_defimpl(protocol_name, protocol, [], opts) end) end defp make_defimpl(name, { _, protocol }, implementations, compiler_opts) do declarator = JS.variable_declarator( JS.identifier("impls"), JS.array_expression([]) ) declaration = JS.variable_declaration([declarator], :let) default = JS.export_default_declaration(JS.identifier("impls")) protocol_name = Atom.to_string(name) app_name = protocol.app imports = [compiler_opts.module_formatter.import_module(:Elixir, Utils.make_local_file_path(:elixir, compiler_opts.core_path, compiler_opts.root, nil))] defimpl_imports = Enum.map(implementations, fn({_, impl_data}) -> x = Atom.to_string(Utils.quoted_to_name(impl_data.for)) x = String.to_atom(protocol_name <> ".DefImpl." <> x) name = Utils.name_to_js_name(x) compiler_opts.module_formatter.import_module(name, Utils.make_local_file_path(impl_data.app, Utils.name_to_js_file_name(x), compiler_opts.root, nil)) end) body = Enum.map(implementations, fn({_, impl_data}) -> x = Atom.to_string(Utils.quoted_to_name(impl_data.for)) x = String.to_atom(protocol_name <> ".DefImpl." <> x) name = Utils.name_to_js_name(x) JS.call_expression( JS.member_expression( JS.identifier("impls"), JS.identifier("push") ), [JS.identifier(name)] ) end) imports = imports ++ defimpl_imports body = [declaration] ++ body exports = compiler_opts.module_formatter.export_module(JS.identifier("impls")) body = case compiler_opts.format do :umd -> compiler_opts.module_formatter.make_umd( imports, body, exports ) _ -> imports ++ body ++ [exports] end module_name = String.to_atom(protocol_name <> ".DefImpl") module_data = %{ module: String.to_atom(protocol_name <> ".DefImpl"), javascript_ast: List.wrap(body), app: app_name, type: :consolidated, protocol: name } { module_name, module_data } end end elixirscript-0.25.0/lib/elixir_script/passes/deps_paths.ex000066400000000000000000000003221305236071500237320ustar00rootroot00000000000000defmodule ElixirScript.Passes.DepsPaths do @moduledoc false def execute(compiler_data, opts) do data = [{opts[:app], List.wrap(compiler_data.path)}] Map.put(compiler_data, :data, data) end end elixirscript-0.25.0/lib/elixir_script/passes/find_changed_files.ex000066400000000000000000000013001305236071500253500ustar00rootroot00000000000000defmodule ElixirScript.Passes.FindChangedFiles do @moduledoc false alias ElixirScript.Compiler.Cache alias ElixirScript.Translator.State @version Mix.Project.config[:version] def execute(compiler_data, opts) do compiler_cache = Cache.get_compiler_cache(compiler_data.path, opts) new_file_stats = Enum.map(compiler_data.data, fn({_, data}) -> { data.path, data.stat } end) |> Enum.uniq changed_files = Cache.get_changed_files(compiler_cache.input_files, new_file_stats) |> Enum.map(fn {file, _} -> file end) State.deserialize(compiler_data.state, compiler_cache.state, compiler_data.loaded_modules) Map.put(compiler_data, :changed_files, changed_files) end end elixirscript-0.25.0/lib/elixir_script/passes/find_deps.ex000066400000000000000000000061161305236071500235420ustar00rootroot00000000000000defmodule ElixirScript.Passes.FindDeps do @moduledoc false alias ElixirScript.Translator.Utils def execute(compiler_data, _) do data = Enum.map(compiler_data.data, &do_find_dependencies(&1)) Map.put(compiler_data, :data, data) end defp do_find_dependencies({ module, module_data }) do {_, deps} = Macro.prewalk(module_data.ast, [], &collect_references(&1, &2)) { module, Map.put(module_data, :deps, [ElixirScript.Kernel] ++ deps) } end defp collect_references({:import, _, [{{:., _, [{:__aliases__, _, head_import_name}, :{}]}, _, tail_imports }]}, state) do deps = Enum.map(tail_imports, fn({:__aliases__, context, name}) -> full_module_name = { :__aliases__, context, head_import_name ++ name } Utils.quoted_to_name(full_module_name) end) state ++ deps end defp collect_references({:import, _, [{:__aliases__, _, _} = module_name]} = ast, state) do module_name = Utils.quoted_to_name(module_name) { ast, state ++ [module_name] } end defp collect_references({:import, _, [{:__aliases__, _, _} = module_name, _]} = ast, state) do module_name = Utils.quoted_to_name(module_name) {ast, state ++ [module_name] } end defp collect_references({:alias, _, [{{:., _, [{:__aliases__, _, head_alias_name}, :{}]}, _, tail_aliases }]} = ast, state) do deps = Enum.map(tail_aliases, fn({:__aliases__, context, name}) -> full_module_name = { :__aliases__, context, head_alias_name ++ name } Utils.quoted_to_name(full_module_name) end) { ast, state ++ deps } end defp collect_references({:alias, _, [{:__aliases__, _, _} = module_name] } = ast, state) do module_name = Utils.quoted_to_name(module_name) { ast, state ++ [module_name] } end defp collect_references({:alias, _, [{:__aliases__, _, _} = module_name, _]} = ast, state) do module_name = Utils.quoted_to_name(module_name) {ast, state ++ [module_name] } end defp collect_references({:require, _, [{{:., _, [{:__aliases__, _, head_alias_name}, :{}]}, _, tail_aliases }]} = ast, state) do deps = Enum.map(tail_aliases, fn({:__aliases__, context, name}) -> full_module_name = { :__aliases__, context, head_alias_name ++ name } Utils.quoted_to_name(full_module_name) end) { ast, state ++ deps } end defp collect_references({:require, _, [{:__aliases__, _, _} = module_name] } = ast, state) do module_name = Utils.quoted_to_name(module_name) { ast, state ++ [module_name] } end defp collect_references({:require, _, [{:__aliases__, _, _} = module_name, _]} = ast, state) do module_name = Utils.quoted_to_name(module_name) { ast, state ++ [module_name] } end defp collect_references({:., _, [{:__aliases__, _, _} = module_name, _]} = ast, state) do module_name = Utils.quoted_to_name(module_name) { ast, state ++ [module_name] } end defp collect_references({{:., _, [{:__aliases__, _, _} = module_name, _]}, _, _ } = ast, state) do module_name = Utils.quoted_to_name(module_name) { ast, state ++ [module_name] } end defp collect_references(ast, state) do { ast, state } end end elixirscript-0.25.0/lib/elixir_script/passes/find_functions.ex000066400000000000000000000046371305236071500246250ustar00rootroot00000000000000defmodule ElixirScript.Passes.FindFunctions do @moduledoc false @function_types [:def, :defp, :defgen, :defgenp, :defmacro, :defmacrop] def execute(data, _) do new_data = Enum.map(data.data, fn { module_name, module_data } -> %{def: functions, defp: private_functions, defgen: generators, defgenp: private_generators, defmacro: macros, defmacrop: private_macros } = get_functions_from_module(module_data.ast) module_data = Map.put(module_data, :functions, functions ++ generators) |> Map.put(:private_functions, private_functions ++ private_generators) |> Map.put(:macros, macros) |> Map.put(:private_macros, private_macros) {module_name, module_data} end) %{data | data: new_data} end defp get_functions_from_module({:__block__, _, list}) do Enum.reduce(list, new_function_map(), fn ({type, _, [{:when, _, [{name, _, params} | _guards] }, _] }, state) when type in @function_types and is_atom(params) -> arity = 0 add_function_to_map(state, type, name, arity) ({type, _, [{:when, _, [{name, _, params} | _guards] }, _] }, state) when type in @function_types -> arity = if is_nil(params), do: 0, else: length(params) add_function_to_map(state, type, name, arity) ({type, _, [{name, _, params}, _]}, state) when type in @function_types and is_atom(params) -> arity = 0 add_function_to_map(state, type, name, arity) ({type, _, [{name, _, params}, _]}, state) when type in @function_types -> arity = if is_nil(params), do: 0, else: length(params) add_function_to_map(state, type, name, arity) ({type, _, [{name, _, params}]}, state) when is_atom(params) and type in @function_types -> arity = 0 add_function_to_map(state, type, name, arity) ({type, _, [{name, _, params}]}, state) when type in @function_types -> arity = length(params) add_function_to_map(state, type, name, arity) _, state -> state end) end defp new_function_map() do %{ def: Keyword.new, defp: Keyword.new, defgen: Keyword.new, defgenp: Keyword.new, defmacro: Keyword.new, defmacrop: Keyword.new } end defp get_functions_from_module(_) do new_function_map() end defp add_function_to_map(map, type, name, arity) do list = Map.get(map, type) if {name, arity} in list do map else Map.put(map, type, list ++ [{ name, arity }]) end end end elixirscript-0.25.0/lib/elixir_script/passes/find_load_only.ex000066400000000000000000000012371305236071500245660ustar00rootroot00000000000000defmodule ElixirScript.Passes.FindLoadOnly do @moduledoc false def execute(compiler_data, opts) do data = compiler_data.data |> Enum.map(fn({module_name, module_data}) -> {_, load_only} = Macro.prewalk(module_data.ast, false, fn ({:@, _, [{:load_only, _, [true]}]} = ast, state) -> {ast, true} ({:@, _, [{:load_only, _, [false]}]} = ast, state) -> {ast, false} ({:@, _, [{:load_only, _, []}]} = ast, state) -> {ast, true} (ast, state) -> {ast, state} end) { module_name, Map.put(module_data, :load_only, load_only) } end) %{ compiler_data | data: data } end end elixirscript-0.25.0/lib/elixir_script/passes/find_modules.ex000066400000000000000000000145551305236071500242650ustar00rootroot00000000000000defmodule ElixirScript.Passes.FindModules do @moduledoc false alias ElixirScript.Translator.Utils alias ElixirScript.Translator.State def execute(compiler_data, opts) do data = Enum.reduce(compiler_data.data, [], fn(data, list) -> quoted = update_quoted(data.ast) { _, modules } = Macro.postwalk(quoted, [], &get_defmodules(&1, &2, opts, compiler_data)) modules = Enum.map(modules, fn(x) -> { x.name, Map.merge(data, x) } end) list ++ modules end) Map.put(compiler_data, :data, data) end defp get_defmodules({:defprotocol, _, [{:__aliases__, _, _} = the_alias, [do: {:__block__, _, _} = block]]} = ast, state, _, _) do s = %{ name: Utils.quoted_to_name(the_alias), type: :protocol, ast: block } { ast, state ++ [s] } end defp get_defmodules({:defprotocol, _, [{:__aliases__, _, _} = the_alias, [do: spec]]} = ast, state, _, _) do s = %{ name: Utils.quoted_to_name(the_alias), type: :protocol, ast: {:__block__, [], [spec]} } { ast, state ++ [s] } end defp get_defmodules({:defimpl, _, [ the_alias, [for: {:__aliases__, _, type_name} = type], [do: {:__block__, context, spec}] ]} = ast, state, _, compiler_data) do {:__aliases__, _, original_name} = Utils.name_to_quoted(State.get_module_name(compiler_data.state, the_alias)) name = original_name ++ [DefImpl] ++ [Elixir] ++ type_name s = %{name: Utils.quoted_to_name({:__aliases__, [], name}), type: :impl, for: type, ast: {:__block__, context, spec}, implements: Utils.quoted_to_name({:__aliases__, [], original_name}) } { ast, state ++ [s] } end defp get_defmodules({:defimpl, _, [ the_alias, [for: {:__aliases__, _, type_name} = type], [do: spec] ]} = ast, state, _, compiler_data) do {:__aliases__, _, original_name} = Utils.name_to_quoted(State.get_module_name(compiler_data.state, the_alias)) name = original_name ++ [DefImpl] ++ [Elixir] ++ type_name s = %{name: Utils.quoted_to_name({:__aliases__, [], name}), type: :impl, for: type, ast: {:__block__, [], [spec]}, implements: Utils.quoted_to_name({:__aliases__, [], original_name}) } { ast, state ++ [s] } end defp get_defmodules({:defmodule, _, [{:__aliases__, _, [:ElixirScript, :Temp]}, [do: body]]} = ast, state, _, _) do s = %{name: ElixirScript.Temp, type: :module, ast: body } { ast, state ++ [s] } end defp get_defmodules({:defmodule, _, [{:__aliases__, _, _}, [do: _]]} = ast, state, opts, _) do { ast, do_module_processing(ast, state, opts) } end defp get_defmodules(ast, state, _, _) do { ast, state } end defp do_module_processing({:defmodule, context1, [{:__aliases__, _, name} = the_alias, [do: body]]}, state, opts) do { body, inner_modules } = make_inner_module_aliases(name, body) aliases = Enum.map(inner_modules, fn ({:defmodule, _, [{:__aliases__, _, inner_module_name}, [do: inner_module_body]]}) -> { :alias, [], [{:__aliases__, [alias: false], name ++ inner_module_name}, [as: {:__aliases__, [alias: false], inner_module_name }] ] } end) state = Enum.reduce(inner_modules, state, fn ({:defmodule, context1, [{:__aliases__, context2, inner_module_name}, [do: inner_module_body]]}, state) -> module_name = Utils.quoted_to_name({:__aliases__, [], tl(name) ++ inner_module_name}) state = Enum.reject(state, fn(x) -> x.name == module_name end) this_module_aliases = aliases -- [{ :alias, [], [{:__aliases__, [alias: false], name ++ inner_module_name}, [as: {:__aliases__, [alias: false], inner_module_name }] ] }] do_module_processing( {:defmodule, context1, [{:__aliases__, context2, name ++ inner_module_name}, [do: add_aliases_to_body(inner_module_body, this_module_aliases)]]}, state, opts) end) body = case body do {:__block__, context, list } -> list = Enum.map(list, fn {:use, _, [module, _] } = using -> {:use, handle_use_expression(using, module, opts) } {:use, _, [module] } = using -> {:use, handle_use_expression(using, module, opts) } ast -> {:expanded, ast} end) |> Enum.reduce([], fn {:use, ast}, state -> case ast do {:__block__, _, list} -> state ++ list _ -> state ++ [ast] end {:expanded, ast}, state -> state ++ [ast] end) {:__block__, context, list} _ -> body end body = add_aliases_to_body(body, aliases) [%{name: Utils.quoted_to_name(the_alias), type: :module, ast: body }] ++ state end defp add_aliases_to_body(body, aliases) do case body do { :__block__, context, body } -> { :__block__, context, aliases ++ List.wrap(body) } _ -> { :__block__, [], aliases ++ List.wrap(body) } end end defp make_inner_module_aliases(name, body) do case body do nil -> { { :__block__, [], [] }, [] } {:__block__, context, list2 } -> { list2, inner_modules } = Enum.partition(list2, fn(x) -> case x do {:defmodule, _, [{:__aliases__, _, inner_module_name}, [do: inner_module_body]]} -> false _ -> true end end) { {:__block__, context, list2}, inner_modules } {:defmodule, _, [{:__aliases__, context, inner_module_name}, [do: inner_module_body]]} = mod -> { {:__block__, context, [] }, [mod] } _ -> { body, [] } end end defp handle_use_expression(using_ast, module, opts) do module = Utils.quoted_to_name(module) eval = """ require #{inspect module} __ENV__ """ {env, _} = Code.eval_string(eval, [], opts.env) case Macro.expand(using_ast, env) do {:__block__, _, [{:__block__, _, [{:require, _, _}, {{:., _, [_, :__using__]}, _, _} = ast]}]} -> Macro.expand_once(ast, env) end end defp update_quoted(quoted) do Macro.prewalk(quoted, fn ({name, context, parms}) -> context = if context[:import] == Kernel do context = Keyword.update!(context, :import, fn(_) -> ElixirScript.Kernel end) else context end {name, context, parms} (x) -> x end) end end elixirscript-0.25.0/lib/elixir_script/passes/handle_output.ex000066400000000000000000000047761305236071500244740ustar00rootroot00000000000000defmodule ElixirScript.Passes.HandleOutput do @moduledoc false alias ElixirScript.Translator.State def execute(compiler_data, opts) do if Map.get(opts, :std_lib, false) do State.set_module_data(compiler_data.state, compiler_data.data) new_std_state = State.serialize(compiler_data.state) stdlib_state_path = Path.join([File.cwd!(), "lib", "elixir_script", "translator", "stdlib_state.bin"]) File.write!(stdlib_state_path, new_std_state) State.stop(compiler_data.state) else State.stop(compiler_data.state) out(compiler_data, opts) end end defp out(compiler_output, %{import_standard_libs: false} = compiler_opts) do data = Enum.filter(compiler_output.data, fn({m, d}) -> d.app != :elixir end) out(%{ compiler_output | data: data }, Map.delete(compiler_opts, :import_standard_libs)) end defp out(compiler_output, %{output: nil} = compiler_opts) do compiler_output |> remove_load_only |> process_include_path(compiler_opts) end defp out(compiler_output, %{output: :stdout} = compiler_opts) do compiler_output |> remove_load_only |> process_include_path(compiler_opts) |> Enum.each(fn {_, code, _} -> IO.write(code) code -> IO.write(code) end) end defp out(compiler_output, %{output: output_path, core_path: _} = compiler_opts) do if Map.get(compiler_opts, :std_lib, false) == false do ElixirScript.copy_stdlib_to_destination(compiler_opts.format, output_path) end compiler_output = remove_load_only(compiler_output) compiler_output.data |> Enum.each(fn({_, x}) -> write_to_file(x, output_path) end) end defp write_to_file(module_data, destination) do file_name = Path.join([destination, to_string(module_data.app), module_data.javascript_name]) if !File.exists?(Path.dirname(file_name)) do File.mkdir_p!(Path.dirname(file_name)) end File.write!(file_name, module_data.javascript_code) end defp process_include_path(compiler_output, compiler_opts) do compiler_output.data |> Enum.map(fn {_, module_data} -> case compiler_opts.include_path do true -> { module_data.javascript_name, module_data.javascript_code, module_data.app } false -> module_data.javascript_code end end) end defp remove_load_only(compiler_output) do data = Enum.filter(compiler_output.data, fn({m, d}) -> Map.get(d, :load_only, false) == false end) %{ compiler_output | data: data } end end elixirscript-0.25.0/lib/elixir_script/passes/init.ex000066400000000000000000000003511305236071500225450ustar00rootroot00000000000000defmodule ElixirScript.Passes.Init do @moduledoc false alias ElixirScript.Translator.State def execute(compiler_data, opts) do {:ok, pid} = State.start_link(opts, []) Map.put(compiler_data, :state, pid) end end elixirscript-0.25.0/lib/elixir_script/passes/java_script_ast.ex000066400000000000000000000031241305236071500247570ustar00rootroot00000000000000defmodule ElixirScript.Passes.JavaScriptAST do @moduledoc false alias ElixirScript.Translator.Utils alias ElixirScript.Translator.State def execute(compiler_data, opts) do State.set_module_data(compiler_data.state, compiler_data.data) State.set_loaded_modules(compiler_data.state, Map.get(compiler_data, :loaded_modules, [])) parent = self data = State.get_module_data(compiler_data.state) |> Enum.map(fn({module_name, module_data}) -> spawn_link fn -> module_data = compile(module_data, opts, compiler_data.state) result = {module_name, module_data} send parent, {self, result } end end) |> Enum.map(fn pid -> receive do {^pid, result} -> result end end) %{ compiler_data | data: data } end defp compile(%{load_only: true} = module_data, opts, state) do module_data end defp compile(module_data, opts, state) do env = ElixirScript.Translator.LexicalScope.module_scope(module_data.name, Utils.name_to_js_file_name(module_data.name) <> ".js", opts.env, state, opts) module = case module_data.type do :module -> ElixirScript.Translator.Defmodule.make_module(module_data.name, module_data.ast, env) :protocol -> ElixirScript.Translator.Defprotocol.make(module_data.name, module_data.functions, env) :impl -> ElixirScript.Translator.Defimpl.make(module_data.name, module_data.for, module_data.ast, env) end Map.put(module_data, :javascript_ast, module.body) end end elixirscript-0.25.0/lib/elixir_script/passes/java_script_code.ex000066400000000000000000000023151305236071500251030ustar00rootroot00000000000000defmodule ElixirScript.Passes.JavaScriptCode do @moduledoc false alias ESTree.Tools.{ Builder, Generator } def execute(compiler_data, _) do parent = self data = Enum.map(compiler_data.data, fn({module_name, module_data}) -> spawn_link fn -> module_data = compile(module_data) result = {module_name, module_data} send parent, {self, result } end end) |> Enum.map(fn pid -> receive do {^pid, result} -> result end end) %{ compiler_data | data: data } end defp compile(%{load_only: true} = module_data) do module_data end defp compile(module_data) do js_ast = Builder.program(module_data.javascript_ast) js_code = js_ast |> prepare_js_ast |> Generator.generate Map.put(module_data, :javascript_code, js_code) end defp prepare_js_ast(js_ast) do case js_ast do modules when is_list(modules) -> modules |> Enum.reduce([], &(&2 ++ &1.body)) |> Builder.program %ElixirScript.Translator.Group{ body: body } -> Builder.program(body) %ElixirScript.Translator.Empty{ } -> Builder.program([]) _ -> js_ast end end end elixirscript-0.25.0/lib/elixir_script/passes/java_script_name.ex000066400000000000000000000006651305236071500251170ustar00rootroot00000000000000defmodule ElixirScript.Passes.JavaScriptName do @moduledoc false alias ElixirScript.Translator.Utils def execute(compiler_data, _) do data = Enum.map(compiler_data.data, fn({module_name, module_data}) -> js_name = Utils.name_to_js_file_name(module_name) <> ".js" module_data = Map.put(module_data, :javascript_name, js_name) {module_name, module_data} end) %{ compiler_data | data: data } end end elixirscript-0.25.0/lib/elixir_script/passes/load_modules.ex000066400000000000000000000010121305236071500242440ustar00rootroot00000000000000defmodule ElixirScript.Passes.LoadModules do @moduledoc false def execute(compiler_data, _) do ex_files = Enum.map(compiler_data.data, fn { _, %{path: path} } -> path %{path: path} -> path end) loaded_modules = case Enum.reverse(ex_files) do [] -> [] files -> Kernel.ParallelCompiler.files(files) end Map.put(compiler_data, :loaded_modules, loaded_modules) end end elixirscript-0.25.0/lib/elixir_script/passes/remove_unused.ex000066400000000000000000000011431305236071500244620ustar00rootroot00000000000000defmodule ElixirScript.Passes.RemoveUnused do @moduledoc false def execute(compiler_data, opts) do data = Enum.filter(compiler_data.data, fn({module_name, _}) -> module_found_in_deps(module_name, compiler_data.data, [opts[:app]]) == true end) Map.put(compiler_data, :data, data) end defp module_found_in_deps(module_name, module_filepath_map, apps_not_to_touch) do Enum.any?(module_filepath_map, fn ({_, %{deps: deps, app: app, type: :module}}) -> Enum.member?(apps_not_to_touch, app) or Enum.member?(deps, module_name) _ -> true end) end end elixirscript-0.25.0/lib/elixir_script/passes/write_cache.ex000066400000000000000000000013311305236071500240560ustar00rootroot00000000000000defmodule ElixirScript.Passes.WriteCache do @moduledoc false alias ElixirScript.Compiler.Cache alias ElixirScript.Translator.State def execute(compiler_data, opts) do compiler_cache = Cache.get_compiler_cache(compiler_data.path, opts) State.set_module_data(compiler_data.state, compiler_data.data) new_state = State.serialize(compiler_data.state) new_file_stats = Enum.filter(compiler_data.data, fn({ _, data }) -> Map.has_key?(data, :path) end) |> Enum.map(fn({_, data}) -> { data.path, data.stat } end) |> Enum.uniq compiler_cache = %{compiler_cache | input_files: new_file_stats, state: new_state } Cache.write(compiler_data.path, compiler_cache) compiler_data end end elixirscript-0.25.0/lib/elixir_script/translator.ex000066400000000000000000000514521305236071500225050ustar00rootroot00000000000000defmodule ElixirScript.Translator do @moduledoc false alias ElixirScript.Translator.Primitive alias ElixirScript.Translator.Identifier alias ElixirScript.Translator.Expression alias ElixirScript.Translator.Match alias ElixirScript.Translator.Map alias ElixirScript.Translator.Function alias ElixirScript.Translator.Call alias ElixirScript.Translator.Def alias ElixirScript.Translator.Capture alias ElixirScript.Translator.Cond alias ElixirScript.Translator.Case alias ElixirScript.Translator.For alias ElixirScript.Translator.Try alias ElixirScript.Translator.With alias ElixirScript.Translator.Block alias ElixirScript.Translator.Struct alias ElixirScript.Translator.Defmodule alias ElixirScript.Translator.Utils alias ElixirScript.Translator.Bitstring alias ElixirScript.Translator.Quote alias ElixirScript.Translator.Utils alias ElixirScript.Translator.JS, as: JSLib alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator.Rewriter # A list of erlang modules. These are rewritten into equivalent # JavaScript functions using ElixirScript.Translator.Rewriter @erlang_modules [ :erlang, :maps, :lists, :gen, :elixir_errors, :supervisor, :application, :code, :elixir_utils, :file ] @module_attributes_to_ignore [ :doc, :moduledoc, :type, :typep, :spec, :opaque, :callback, :macrocallback, :after_compile, :before_compile, :behaviour, :compile, :file, :on_definition, :on_load, :dialyzer, :vsn, :external_resource ] @function_types [:def, :defp, :defgen, :defgenp] @generator_types [:defgen, :defgenp] @doc """ Translates the given Elixir AST to JavaScript AST. The given `env` is a `ElixirScript.Macro.Env` used to track the variables, imports, aliases, and scopes like `Macro.Env`. The JavaScript AST and the an updated `ElixirScript.Macro.Env` is returned """ @spec translate(term, ElixirScript.Macro.Env.t) :: { ESTree.Node.t, ElixirScript.Macro.Env.t } def translate(ast, env) do do_translate(ast, env) end @doc """ Same as `translate/2`, but returns only the JavaScript AST """ @spec translate!(term, ElixirScript.Macro.Env.t) :: ESTree.Node.t def translate!(ast, env) do { js_ast, _ } = translate(ast, env) js_ast end defp do_translate(ast, env) when is_number(ast) or is_binary(ast) or is_boolean(ast) or is_nil(ast) do { Primitive.make_literal(ast), env } end defp do_translate(ast, env) when is_atom(ast) do { Primitive.make_atom(ast), env } end defp do_translate([ {:|, _, [left, right] } ], env) do quoted = quote do [unquote(left)].concat(unquote(right)) end translate(quoted, env) end defp do_translate(ast, env) when is_list(ast) do Primitive.make_list(ast, env) end defp do_translate({ one, two }, env) do quoted = quote do JS.new(Elixir.Core.Tuple, [unquote(one), unquote(two)]) end translate(quoted, env) end defp do_translate({operator, _, [value]}, env) when operator in [:-, :!, :+] do Expression.make_unary_expression(operator, value, env) end defp do_translate({:not, _, [value]}, env) do Expression.make_unary_expression(:!, value, env) end defp do_translate({:"~~~", _, [value]}, env) do Expression.make_unary_expression(:"~~~", value, env) end defp do_translate({operator, _, [left, right]}, env) when operator in [:+, :-, :/, :*, :==, :!=, :&&, :||, :>, :<, :>=, :<=, :===, :!==, :"**"] do Expression.make_binary_expression(operator, left, right, env) end defp do_translate({:&&&, _, [left, right]}, env) do Expression.make_binary_expression(:&, left, right, env) end defp do_translate({:<<<, _, [left, right]}, env) do Expression.make_binary_expression(:<, left, right, env) end defp do_translate({:>>>, _, [left, right]}, env) do Expression.make_binary_expression(:^, left, right, env) end defp do_translate({:^^^, _, [left, right]}, env) do Expression.make_binary_expression(:^, left, right, env) end defp do_translate({:|||, _, [left, right]}, env) do Expression.make_binary_expression(:|, left, right, env) end defp do_translate({:and, _, [left, right]}, env) do Expression.make_binary_expression(:&&, left, right, env) end defp do_translate({:or, _, [left, right]}, env) do Expression.make_binary_expression(:||, left, right, env) end defp do_translate({:div, _, [left, right]}, env) do Expression.make_binary_expression(:/, left, right, env) end defp do_translate({:rem, _, [left, right]}, env) do Expression.make_binary_expression(:%, left, right, env) end defp do_translate({:throw, _, [params]}, env) do { result, env } = translate(params, env) { JS.throw_statement(result), env } end defp do_translate({:<>, context, [left, right]}, env) do translate({:+, context, [left, right]}, env) end defp do_translate({:++, _, [left, right]}, env) do translate({{:., [], [left, :concat]}, [], [right]}, env) end defp do_translate({:&, _, [number]}, env) when is_number(number) do { Identifier.make_identifier(String.to_atom("__#{number}")), env } end defp do_translate({:&, _, [{:/, _, [{{:., _, [module_name, function_name]}, _, []}, arity]}]}, env) do { Capture.make_capture(module_name, function_name, arity, env), env } end defp do_translate({:&, _, [{:/, _, [{function_name, _, _}, arity]}]}, env) do { Capture.make_capture(function_name, arity, env), env } end defp do_translate({:&, _, [body]}, env) do params = Capture.find_value_placeholders(body) |> List.flatten Function.make_anonymous_function([{:->, [], [params, body]}], env) end defp do_translate({:@, _, [{name, _, _}]}, env) when name in @module_attributes_to_ignore do { %ElixirScript.Translator.Empty{}, env } end defp do_translate({:@, _, [{:on_js_load, _, [value]}]}, env) do Call.make_function_call(value, [], env) end defp do_translate({:@, _, [{name, _, [value]}]}, env) do { Defmodule.make_attribute(name, value, env), env } end defp do_translate({:@, _, [{name, _, _}]}, env) do { Identifier.make_identifier(name), env } end defp do_translate({:%, _, [alias_info, data]}, env) do { Struct.new_struct(alias_info, data, env), env } end defp do_translate({:%{}, _, [{:|, _, [map, data]}]}, env) do Map.make_map_update(map, data, env) end defp do_translate({:%{}, _, properties}, env) do { Map.make_object(properties, env), env } end defp do_translate({:<<>>, _, elements}, env) do is_interpolated_string = Enum.all?(elements, fn(x) -> case x do b when is_binary(b) -> true {:::, _, [_target, {:binary, _, _}]} -> true _ -> false end end) case is_interpolated_string do true -> Bitstring.make_interpolated_string(elements, env) _ -> Bitstring.make_bitstring(elements, env) end end defp do_translate({{:., _, [erlang_module, _]}, _, _} = erlang_function_call, env) when erlang_module in @erlang_modules do Rewriter.rewrite(erlang_function_call) |> translate(env) end defp do_translate({{:., _, [Access, :get]}, _, [target, property]}, env) do { Map.make_get_property(target, property, env), env } end defp do_translate({{:., _, [function_name]}, _, params}, env) do Call.make_function_call(function_name, params, env) end defp do_translate({:., _, [module_name, function_name]} = ast, env) do expanded_ast = Macro.expand(ast, env.env) if expanded_ast == ast do module_name = create_module_name(module_name, env) Call.make_function_or_property_call(module_name, function_name, env) else translate(expanded_ast, env) end end defp do_translate({{:., _, [module_name, function_name]}, _, [] } = ast, env) do expanded_ast = Macro.expand(ast, env.env) if expanded_ast == ast do module_name = create_module_name(module_name, env) Call.make_function_or_property_call(module_name, function_name, env) else translate(expanded_ast, env) end end defp do_translate({{:., _, [{:__aliases__, _, _} = module_name]}, _, params} = ast, env) do expanded_ast = Macro.expand(ast, env.env) if expanded_ast == ast do module_name = create_module_name(module_name, env) Call.make_function_call(module_name, params, env) else translate(expanded_ast, env) end end defp do_translate({{:., context1, [{:__aliases__, context2, [:Enum]}, function_name]}, context3, params }, env) do translate({{:., context1, [{:__aliases__, context2, [:Elixir, :Enum]}, function_name]}, context3, params }, env) end defp do_translate({{:., _, [{:__aliases__, _, [:JS]}, function_name]}, _, params }, env) when function_name in @generator_types do do_translate({function_name, [], params}, env) end defp do_translate({{:., _, [{:__aliases__, _, [:JS]}, function_name]}, _, params }, env) do JSLib.translate_js_function(function_name, params, env) end defp do_translate({{:., _, [module_name, function_name]}, _, params } = ast, env) do expanded_ast = Macro.expand(ast, env.env) if expanded_ast == ast do module_name = create_module_name(module_name, env) Call.make_function_call(module_name, function_name, params, env) else translate(expanded_ast, env) end end defp do_translate({:_, _, _}, env) do { Identifier.make_identifier(:undefined), env } end defp do_translate({:__aliases__, _, aliases} = ast, env) do module_name = create_module_name(ast, env) Call.make_module_name(module_name, env) end defp do_translate({:__MODULE__, _, _ }, env) do translate(env.module, env) end defp do_translate({:__block__, _, expressions }, env) do Block.make_block(expressions, env) end defp do_translate({:__DIR__, _, _}, env) do case env.file do nil -> { JS.identifier(:null), env } filepath -> { JS.literal(Path.dirname(filepath)), env } end end defp do_translate({:try, _, [ blocks ]}, env) do Try.make_try(blocks, env) end defp do_translate({:with, _, args }, env ) do With.make_with(args, env) end defp do_translate({:super, _, _expressions }, _ ) do raise ElixirScript.Translator.UnsupportedError, "super" end defp do_translate({:__CALLER__, _, _expressions }, env) do env_to_translate = ElixirScript.Translator.LexicalScope.caller(env) quoted = Macro.escape(env_to_translate) translate(quoted, env) end defp do_translate({:__ENV__, _, _expressions }, env) do env_to_translate = ElixirScript.Translator.LexicalScope.env(env) quoted = Macro.escape(env_to_translate) translate(quoted, env) end defp do_translate({:quote, _, [[do: expr]]}, env) do { Quote.make_quote([], expr, env), env } end defp do_translate({:quote, _, [opts, [do: expr]]}, env) do { Quote.make_quote(opts, expr, env), env } end defp do_translate({:import, _, [{{:., _, [{:__aliases__, _, head_import_name}, :{}]}, _, tail_imports }]}, env) do env = Enum.reduce(tail_imports, env, fn({:__aliases__, context, name}, acc) -> full_module_name = { :__aliases__, context, head_import_name ++ name } module_name = Utils.quoted_to_name(full_module_name) ElixirScript.Translator.LexicalScope.add_import(acc, module_name) end) { %ElixirScript.Translator.Empty{}, env } end defp do_translate({:import, _, [{:__aliases__, _, _} = module_name]}, env) do module_name = Utils.quoted_to_name(module_name) env = ElixirScript.Translator.LexicalScope.add_import(env, module_name) { %ElixirScript.Translator.Empty{}, env } end defp do_translate({:import, _, [{:__aliases__, _, _} = module_name, options]}, env) do module_name = Utils.quoted_to_name(module_name) env = ElixirScript.Translator.LexicalScope.add_import(env, module_name, options) { %ElixirScript.Translator.Empty{}, env } end defp do_translate({:alias, _, [{{:., _, [{:__aliases__, _, head_alias_name}, :{}]}, _, tail_aliases }]}, env) do env = Enum.reduce(tail_aliases, env, fn({:__aliases__, context, name}, acc) -> full_module_name = { :__aliases__, context, head_alias_name ++ name } module_name = Utils.quoted_to_name(full_module_name) alias_name = Utils.quoted_to_name({:__aliases__, [], [List.last(name)] }) ElixirScript.Translator.LexicalScope.add_alias(acc, module_name, alias_name) end) { %ElixirScript.Translator.Empty{}, env } end defp do_translate({:alias, _, [{:__aliases__, _, _} = module_name] }, env) do {_, _, name} = module_name name = [List.last(name)] module_name = Utils.quoted_to_name(module_name) alias_name = Utils.quoted_to_name({:__aliases__, [], name }) env = ElixirScript.Translator.LexicalScope.add_alias(env, module_name, alias_name) { %ElixirScript.Translator.Empty{}, env } end defp do_translate({:alias, _, [{:__aliases__, _, _} = module_name, [as: {:__aliases__, _, _} = alias_name]]}, env) do module_name = Utils.quoted_to_name(module_name) alias_name = Utils.quoted_to_name(alias_name) env = ElixirScript.Translator.LexicalScope.add_alias(env, module_name, alias_name) { %ElixirScript.Translator.Empty{}, env } end defp do_translate({:require, _, [{{:., _, [{:__aliases__, _, head_require_name}, :{}]}, _, tail_requires }]}, env) do env = Enum.reduce(tail_requires, env, fn({:__aliases__, context, name}, acc) -> full_module_name = { :__aliases__, context, head_require_name ++ name } module_name = Utils.quoted_to_name(full_module_name) ElixirScript.Translator.LexicalScope.add_require(acc, module_name) end) { %ElixirScript.Translator.Empty{}, env } end defp do_translate({:require, _, [{:__aliases__, _, _} = module_name] }, env) do module_name = Utils.quoted_to_name(module_name) env = ElixirScript.Translator.LexicalScope.add_require(env, module_name) { %ElixirScript.Translator.Empty{}, env } end defp do_translate({:require, _, [{:__aliases__, _, _} = module_name, [as: {:__aliases__, _, _} = alias_name]]}, env) do module_name = Utils.quoted_to_name(module_name) alias_name = Utils.quoted_to_name(alias_name) env = ElixirScript.Translator.LexicalScope.add_require(env, module_name, alias_name) { %ElixirScript.Translator.Empty{}, env } end defp do_translate({:case, _, [condition, [do: clauses]]}, env) do Case.make_case(condition, clauses, env) end defp do_translate({:cond, _, [[do: clauses]]}, env) do Cond.make_cond(clauses, env) end defp do_translate({:for, _, generators}, env) do For.make_for(generators, env) end defp do_translate({:fn, _, clauses}, env) do Function.make_anonymous_function(clauses, env) end defp do_translate({:receive, _, _ }, _) do raise ElixirScript.Translator.UnsupportedError, "receive" end defp do_translate({:{}, _, elements}, env) do quoted = quote do JS.new(Elixir.Core.Tuple, unquote(elements)) end translate(quoted, env) end defp do_translate({:=, _, [left, right]}, env) do Match.make_match(left, right, env) end defp do_translate({function, _, [{:when, _, [{name, _, _params} | _guards] }, _] } = ast, env) when function in @generator_types do Def.process_function(name, [ast], %{ env | context: :generator}) end defp do_translate({function, _, [{name, _, params}, _]} = ast, env) when function in @generator_types and is_atom(params) do Def.process_function(name, [ast], %{ env | context: :generator}) end defp do_translate({function, _, [{name, _, _params}, _]} = ast, env) when function in @generator_types do Def.process_function(name, [ast], %{ env | context: :generator}) end defp do_translate({function, _, [{:when, _, [{name, _, _params} | _guards] }, _] } = ast, env) when function in @function_types do Def.process_function(name, [ast], env) end defp do_translate({function, _, [{name, _, params}, _]} = ast, env) when function in @function_types and is_atom(params) do Def.process_function(name, [ast], env) end defp do_translate({function, _, [{name, _, _params}, _]} = ast, env) when function in @function_types do Def.process_function(name, [ast], env) end defp do_translate({:defstruct, _, attributes}, env) do { Struct.make_defstruct(attributes, env), env } end defp do_translate({:defexception, _, attributes}, env) do { Struct.make_defexception(attributes, env), env } end defp do_translate({:defmodule, _, [{:__aliases__, _, module_name_list}, [do: body]]}, env) do { Defmodule.make_module(module_name_list, body, env), env } end defp do_translate({:defprotocol, _, _}, env) do { %ElixirScript.Translator.Empty{}, env } end defp do_translate({:defmacro, _, _}, env) do { %ElixirScript.Translator.Empty{}, env } end defp do_translate({:defmacrop, _, _}, env) do { %ElixirScript.Translator.Empty{}, env } end defp do_translate({:defimpl, _, _}, env) do { %ElixirScript.Translator.Empty{}, env } end defp do_translate({:|, _, [item, list]}, env) do quoted = quote do [unquote(item)].concat(unquote(list)) end translate(quoted, env) end defp do_translate({:raise, _, [alias_info, attributes]}, env) when is_list(attributes) do js_ast = JS.throw_statement( Struct.new_struct(alias_info, {:%{}, [], attributes }, env) ) { js_ast, env } end defp do_translate({:raise, _, [alias_info, message]}, env) do js_ast = JS.throw_statement( Struct.new_struct(alias_info, {:%{}, [], [message: message] }, env) ) { js_ast, env } end defp do_translate({:raise, _, [message]}, env) do js_ast = JS.throw_statement( JS.object_expression( [ Map.make_property(translate!(:__struct__, env), translate!(:RuntimeError, env)), Map.make_property(translate!(:__exception__, env), translate!(true, env)), Map.make_property(translate!(:message, env), translate!(message, env)) ] ) ) { js_ast, env } end defp do_translate({name, _, params} = ast, env) when is_list(params) do if is_from_js_module(name, params, env) do do_translate({{:., [], [{:__aliases__, [], [:JS]}, name]}, [], params }, env) else expanded_ast = Macro.expand(ast, env.env) if expanded_ast == ast do name_arity = {name, length(params)} module = ElixirScript.Translator.State.get_module(env.state, env.module) cond do name_arity in module.functions or name_arity in module.private_functions -> Call.make_function_call(name, params, env) ElixirScript.Translator.LexicalScope.find_module(env, name_arity) -> imported_module_name = ElixirScript.Translator.LexicalScope.find_module(env, name_arity) Call.make_function_call(imported_module_name, name, params, env) true -> Call.make_function_call(name, params, env) end else translate(expanded_ast, env) end end end defp do_translate({ name, _, params }, env) when is_atom(params) do cond do is_from_js_module(name, params, env) -> do_translate({{:., [], [{:__aliases__, [], [:JS]}, name]}, [], params }, env) ElixirScript.Translator.LexicalScope.has_var?(env, name) -> { Identifier.make_identifier(name), env } has_function?(env.module, {name, 0}, env) -> Call.make_function_call(name, [], env) ElixirScript.Translator.LexicalScope.find_module(env, {name, 0}) -> imported_module_name = ElixirScript.Translator.LexicalScope.find_module(env, {name, 0}) Call.make_function_call(imported_module_name, name, params, env) true -> { Identifier.make_identifier(name), env } end end defp is_from_js_module(name, params, env) do func = if is_list(params) do {name, length(params)} else {name, 0} end {_, macros} = Enum.find(env.env.macros, {nil, []}, fn({k, v}) -> to_string(k) == "Elixir.JS" end) {_, functions} = Enum.find(env.env.functions, {nil, []}, fn({k, v}) -> to_string(k) == "Elixir.JS" end) js = macros ++ functions if func in js do true else false end end def create_module_name(module_name, env) do case module_name do {:__aliases__, _, _} -> candiate_module_name = ElixirScript.Translator.State.get_module_name(env.state, Utils.quoted_to_name(module_name)) if ElixirScript.Translator.LexicalScope.get_module_name(env, candiate_module_name) in ElixirScript.Translator.State.list_module_names(env.state) do ElixirScript.Translator.LexicalScope.get_module_name(env, candiate_module_name) else module_name end _ -> module_name end end def has_function?(module_name, name_arity, env) do case ElixirScript.Translator.State.get_module(env.state, module_name) do nil -> false module -> name_arity in module.functions or name_arity in module.private_functions end end end elixirscript-0.25.0/lib/elixir_script/translator/000077500000000000000000000000001305236071500221405ustar00rootroot00000000000000elixirscript-0.25.0/lib/elixir_script/translator/empty.ex000066400000000000000000000002641305236071500236360ustar00rootroot00000000000000defmodule ElixirScript.Translator.Empty do @moduledoc false # Represents no translation to JS AST @type t :: %ElixirScript.Translator.Empty{} defstruct type: "Empty" end elixirscript-0.25.0/lib/elixir_script/translator/group.ex000066400000000000000000000015121305236071500236310ustar00rootroot00000000000000defmodule ElixirScript.Translator.Group do @moduledoc false # Represents a collection of JavaScript AST. # Contents in body are expanded within outer AST before JS code generation @type t :: %ElixirScript.Translator.Group{ type: binary, body: [ESTree.Statement.t] } defstruct type: "Group", body: [] def inflate_groups(body) do Enum.map(body, fn(x) -> case x do %ElixirScript.Translator.Empty{} -> [] %ElixirScript.Translator.Group{body: group_body} -> group_body %ESTree.BlockStatement{} -> %ESTree.BlockStatement{ body: inflate_groups(x.body) } %ESTree.IfStatement{} -> %{x | consequent: inflate_groups(x.consequent), alternate: inflate_groups(x.alternate) } _ -> x end end) |> List.flatten end end elixirscript-0.25.0/lib/elixir_script/translator/kernel/000077500000000000000000000000001305236071500234205ustar00rootroot00000000000000elixirscript-0.25.0/lib/elixir_script/translator/kernel/def.ex000066400000000000000000000007351305236071500245210ustar00rootroot00000000000000defmodule ElixirScript.Translator.Def do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator.Function alias ElixirScript.Translator.Identifier def process_function(name, functions, env) do { result, _ } = Function.make_anonymous_function(functions, env, name) declarator = JS.variable_declarator( Identifier.make_identifier(name), result ) { JS.variable_declaration([declarator], :const), env } end end elixirscript-0.25.0/lib/elixir_script/translator/kernel/defimpl.ex000066400000000000000000000054521305236071500254040ustar00rootroot00000000000000defmodule ElixirScript.Translator.Defimpl do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator.Defmodule alias ElixirScript.Translator.State alias ElixirScript.Translator.Utils def make(name, type, body, env) do type = map_to_js(type, env) {body, export} = Defmodule.process_module(name, body, env) protocol_name = Atom.to_string(name) |> String.split(".DefImpl.") |> hd |> String.to_atom export = JS.object_expression([ JS.property( JS.literal("Type"), type ), JS.property( JS.literal("Implementation"), export ) ]) body = env.module_formatter.build(body, export, env) %{ name: Utils.quoted_to_name({:__aliases__, [], name }), body: body, app_name: State.get_module(env.state, name).app, protocol: protocol_name } end defp map_to_js({:__aliases__, _, [:Integer]}, _) do JS.member_expression( JS.member_expression( JS.identifier(:Elixir), JS.identifier(:Core) ), JS.identifier(:Integer) ) end defp map_to_js({:__aliases__, _, [:Tuple]}, _) do JS.member_expression( JS.member_expression( JS.identifier(:Elixir), JS.identifier(:Core) ), JS.identifier(:Tuple) ) end defp map_to_js({:__aliases__, _, [:Atom]}, _) do JS.identifier(:Symbol) end defp map_to_js({:__aliases__, _, [:List]}, _) do JS.identifier(:Array) end defp map_to_js({:__aliases__, _, [:BitString]}, _) do JS.member_expression( JS.member_expression( JS.identifier(:Elixir), JS.identifier(:Core) ), JS.identifier(:BitString) ) end defp map_to_js({:__aliases__, _, [:Float]}, _) do JS.member_expression( JS.member_expression( JS.identifier(:Elixir), JS.identifier(:Core) ), JS.identifier(:Float) ) end defp map_to_js({:__aliases__, _, [:Function]}, _) do JS.identifier(:Function) end defp map_to_js({:__aliases__, _, [:PID]}, _) do JS.member_expression( JS.member_expression( JS.identifier(:Elixir), JS.identifier(:Core) ), JS.identifier(:PID) ) end defp map_to_js({:__aliases__, _, [:Port]}, _) do JS.member_expression( JS.identifier(:Elixir), JS.identifier(:Port) ) end defp map_to_js({:__aliases__, _, [:Reference]}, _) do JS.member_expression( JS.identifier(:Elixir), JS.identifier(:Reference) ) end defp map_to_js({:__aliases__, _, [:Map]}, _) do JS.identifier(:Object) end defp map_to_js({:__aliases__, _, [:Any]}, _) do JS.identifier(:null) end defp map_to_js({:__aliases__, _, _} = module, env) do ElixirScript.Translator.Struct.get_struct_class( module, env ) end end elixirscript-0.25.0/lib/elixir_script/translator/kernel/defmodule.ex000066400000000000000000000164511305236071500257310ustar00rootroot00000000000000defmodule ElixirScript.Translator.Defmodule do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator alias ElixirScript.Translator.State alias ElixirScript.Translator.Utils alias ElixirScript.Translator.Group alias ElixirScript.Translator.Def alias ElixirScript.Translator.Identifier def make_module(ElixirScript.Temp, body, env) do { body, _ } = translate_body(body, env) %{ name: ElixirScript.Temp, body: body |> Group.inflate_groups, app_name: ElixirScript.Translator.State.get(env.state).compiler_opts.app } end def make_module(module, nil, env) do %{ name: module, body: [], app_name: ElixirScript.Translator.State.get(env.state).compiler_opts.app } end def make_module(module, body, env) do {body, exported_object} = process_module(module, body, env) body = env.module_formatter.build(body, exported_object, env) app_name = State.get_module(env.state, module).app result = %{ name: Utils.quoted_to_name({:__aliases__, [], module }), body: body, app_name: app_name } result end def process_module(module, body, env) do { body, functions } = extract_functions_from_module(body) { body, env } = translate_body(body, env) { exported_functions, private_functions } = process_functions(functions, env) {structs, body} = extract_structs_from_body(body, env) #Collect all the functions so that we can process their arity body = Enum.map(body, fn(x) -> case x do %ESTree.CallExpression{} -> JS.expression_statement(x) _ -> x end end) body = Group.inflate_groups(body) exported_object = JS.object_expression( make_defstruct_property(module, structs) ++ Enum.map(exported_functions, fn({key, _value}) -> JS.property(Identifier.make_identifier(key), Identifier.make_identifier(key), :init, true) end) ) exported_functions = Enum.map(exported_functions, fn({_key, value}) -> value end) private_functions = Enum.map(private_functions, fn({_key, value}) -> value end) body = structs ++ private_functions ++ exported_functions ++ body {body, exported_object} end def translate_body(body, env) do { body, env } = Translator.translate(body, env) body = case body do [%ESTree.BlockStatement{ body: body }] -> body %ESTree.BlockStatement{ body: body } -> body _ -> List.wrap(body) end { body, env } end def extract_functions_from_module({:__block__, meta, body_list}) do { body_list, functions } = Enum.map_reduce(body_list, %{exported: Map.new(), private: Map.new(), exported_generators: Map.new(), private_generators: Map.new()}, fn ({:def, _, [{:when, _, [{name, _, _} | _guards] }, _] } = function, state) -> { nil, %{ state | exported: Map.put(state.exported, name, Map.get(state.exported, name, []) ++ [function]) } } ({:def, _, [{name, _, _}, _]} = function, state) -> { nil, %{ state | exported: Map.put(state.exported, name, Map.get(state.exported, name, []) ++ [function]) } } ({:defp, _, [{:when, _, [{name, _, _} | _guards] }, _] } = function, state) -> { nil, %{ state | private: Map.put(state.private, name, Map.get(state.private, name, []) ++ [function]) } } ({:defp, _, [{name, _, _}, _]} = function, state) -> { nil, %{ state | private: Map.put(state.private, name, Map.get(state.private, name, []) ++ [function]) } } ({:defgen, _, [{:when, _, [{name, _, _} | _guards] }, _] } = function, state) -> { nil, %{ state | exported_generators: Map.put(state.exported_generators, name, Map.get(state.exported_generators, name, []) ++ [function]) } } ({:defgen, _, [{name, _, _}, _]} = function, state) -> { nil, %{ state | exported_generators: Map.put(state.exported_generators, name, Map.get(state.exported_generators, name, []) ++ [function]) } } ({:defgenp, _, [{:when, _, [{name, _, _} | _guards] }, _] } = function, state) -> { nil, %{ state | private_generators: Map.put(state.private_generators, name, Map.get(state.private_generators, name, []) ++ [function]) } } ({:defgenp, _, [{name, _, _}, _]} = function, state) -> { nil, %{ state | private_generators: Map.put(state.private_generators, name, Map.get(state.private_generators, name, []) ++ [function]) } } (x, state) -> { x, state } end) body_list = Enum.filter(body_list, fn(x) -> !is_nil(x) end) body = {:__block__, meta, body_list} { body, functions } end def extract_functions_from_module(body) do extract_functions_from_module({:__block__, [], List.wrap(body)}) end def extract_imports_from_body(body) do Enum.partition(body, fn(x) -> case x do %ESTree.ImportDeclaration{} -> true _ -> false end end) end def extract_structs_from_body(body, env) do module_js_name = Utils.name_to_js_name(env.module) Enum.partition(body, fn(x) -> case x do %ESTree.VariableDeclaration{declarations: [%ESTree.VariableDeclarator{id: %ESTree.Identifier{name: ^module_js_name} } ] } -> true _ -> false end end) end defp make_defstruct_property(_, []) do [] end defp make_defstruct_property(module_name, [the_struct]) do module_js_name = Utils.name_to_js_name(module_name) case the_struct do %ESTree.VariableDeclaration{declarations: [%ESTree.VariableDeclarator{id: %ESTree.Identifier{name: ^module_js_name} } ] } -> [JS.property(JS.identifier(module_js_name), JS.identifier(module_js_name), :init, true)] end end def process_functions(%{ exported: exported, private: private, exported_generators: exported_generators, private_generators: private_generators }, env) do exported_functions = Enum.map(Dict.keys(exported), fn(key) -> functions = Dict.get(exported, key) { functions, _ } = Def.process_function(key, functions, env) { key, functions } end) exported_generators = Enum.map(Dict.keys(exported_generators), fn(key) -> functions = Dict.get(exported_generators, key) { functions, _ } = Def.process_function(key, functions, %{ env | context: :generator}) { key, functions } end) private_functions = Enum.map(Dict.keys(private), fn(key) -> functions = Dict.get(private, key) { functions, _ } = Def.process_function(key, functions, env) { key, functions } end) private_generators = Enum.map(Dict.keys(private_generators), fn(key) -> functions = Dict.get(private_generators, key) { functions, _ } = Def.process_function(key, functions, %{ env | context: :generator}) { key, functions } end) { exported_functions ++ exported_generators, private_functions ++ private_generators } end def make_attribute(name, value, env) do declarator = JS.variable_declarator( Identifier.make_identifier(name), ElixirScript.Translator.translate!(value, env) ) JS.variable_declaration([declarator], :const) end end elixirscript-0.25.0/lib/elixir_script/translator/kernel/defprotocol.ex000066400000000000000000000054001305236071500262750ustar00rootroot00000000000000defmodule ElixirScript.Translator.Defprotocol do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator.Defmodule alias ElixirScript.Translator.Map alias ElixirScript.Translator.Utils alias ElixirScript.Translator.State alias ElixirScript.Translator.Identifier require Logger @doc """ Takes a protocol and turns it into a module """ def make(name, functions, env) do { body, _ } = Defmodule.translate_body( {:__block__, [], [] }, env) app_name = State.get_module(env.state, name).app State.add_javascript_module_reference( env.state, env.module, {:__aliases__, [], [:Implementations]}, Utils.make_local_file_path(app_name, Utils.name_to_js_file_name(name) <> ".Defimpl", env) ) object = process_spec_functions(functions) |> Enum.map(fn({key, value}) -> Map.make_property(Identifier.make_identifier(key), value) end) |> JS.object_expression declarator = JS.variable_declarator( JS.identifier(Utils.name_to_js_name(name)), JS.call_expression( JS.member_expression( JS.identifier(:Elixir), JS.member_expression( JS.identifier(:Core), JS.member_expression( JS.identifier(:Functions), JS.identifier(:defprotocol) ) ) ), [object] ) ) declaration = JS.variable_declaration([declarator], :const) implementations = JS.for_of_statement( JS.variable_declaration([JS.variable_declarator( JS.object_pattern([ JS.assignment_property(JS.identifier("Type")), JS.assignment_property(JS.identifier("Implementation")) ]), nil )], :let), JS.identifier("Implementations"), JS.call_expression( JS.member_expression( JS.identifier(:Elixir), JS.member_expression( JS.identifier(:Core), JS.member_expression( JS.identifier(:Functions), JS.identifier(:defimpl) ) ) ), [ JS.identifier(Utils.name_to_js_name(name)), JS.identifier("Type"), JS.identifier("Implementation") ] ) ) body = body ++ [declaration] ++ [implementations] body = env.module_formatter.build(body, JS.identifier(Utils.name_to_js_name(name)), env) %{ name: name, body: body, app_name: app_name } end defp process_spec_functions(functions) do Enum.map(Keyword.keys(functions), fn(function_name) -> {function_name, JS.function_expression([], [], JS.block_statement([]))} end) end end elixirscript-0.25.0/lib/elixir_script/translator/kernel/expression.ex000066400000000000000000000010341305236071500261530ustar00rootroot00000000000000defmodule ElixirScript.Translator.Expression do @moduledoc false alias ESTree.Tools.Builder alias ElixirScript.Translator def make_unary_expression(operator, expr, env) do { js_ast, env } = Translator.translate(expr, env) { Builder.unary_expression(operator, true, js_ast), env } end def make_binary_expression(operator, left, right, env) do { left, _ } = Translator.translate(left, env) { right, _ } = Translator.translate(right, env) { Builder.binary_expression(operator, left, right), env } end end elixirscript-0.25.0/lib/elixir_script/translator/kernel/js.ex000066400000000000000000000057561305236071500244070ustar00rootroot00000000000000defmodule ElixirScript.Translator.JS do @moduledoc false alias ESTree.Tools.Builder alias ElixirScript.Translator alias ElixirScript.Translator.Identifier alias ElixirScript.Translator.State @doc false def translate_js_function(name, params, env) do { do_translate({name, [], params}, env), env } end defp do_translate({op, _, [param]}, env) when op in [:typeof, :delete, :void, :-, :+, :!, :"~"] do Builder.unary_expression( op, true, Translator.translate!(param, env) ) end defp do_translate({op, _, [value, type]}, env) when op in [:"**", :==, :!=, :===, :!==, :<, :<=, :>, :>=, :"<<", :">>", :<<<, :+, :-, :*, :/, :%, :|, :^, :&, :in, :instanceof] do Builder.binary_expression( op, Translator.translate!(value, env), Translator.translate!(type, env) ) end defp do_translate({op, _, [value, type]}, env) when op in [:||, :&&] do Builder.logical_expression( op, Translator.translate!(value, env), Translator.translate!(type, env) ) end defp do_translate({:yield, _, []}, env) do Builder.yield_expression() end defp do_translate({:yield, _, [term]}, env) do Builder.yield_expression( Translator.translate!(term, env) ) end defp do_translate({:yield_to, _, [term]}, env) do Builder.yield_expression( Translator.translate!(term, env), true ) end defp do_translate({:throw, _, [term]}, env) do Builder.throw_statement( Translator.translate!(term, env) ) end defp do_translate({:new, _, [module_name, params]}, env) when not is_list(params) do Builder.new_expression( Translator.translate!(module_name, env), [Builder.rest_element(Translator.translate!(params, env))] ) end defp do_translate({:new, _, [module_name, params]}, env) do Builder.new_expression( Translator.translate!(module_name, env), Enum.map(params, &Translator.translate!(&1, env)) ) end defp do_translate({:update, _, [object, map]}, env) do quoted = quote do Object.assign(unquote(object), unquote(map)) end Translator.translate!(quoted, env) end defp do_translate({:import, _, [module_name, from, [default: false]]}, env) do State.add_javascript_module_reference(env.state, env.module, module_name, from, false) %ElixirScript.Translator.Empty{} end defp do_translate({:import, _, [module_name, from, [default: true]]}, env) do State.add_javascript_module_reference(env.state, env.module, module_name, from, true) %ElixirScript.Translator.Empty{} end defp do_translate({:import, _, [module_name, from]}, env) do State.add_javascript_module_reference(env.state, env.module, module_name, from, true) %ElixirScript.Translator.Empty{} end defp do_translate({:object, _, [args]}, env) do args = Enum.map(args, fn { k, v } when Kernel.is_atom(k) -> { Atom.to_string(k), v } pair -> pair end) Translator.translate!({ :%{}, [], args }, env) end end elixirscript-0.25.0/lib/elixir_script/translator/kernel/special_forms/000077500000000000000000000000001305236071500262465ustar00rootroot00000000000000elixirscript-0.25.0/lib/elixir_script/translator/kernel/special_forms/bitstring.ex000066400000000000000000000110131305236071500306050ustar00rootroot00000000000000defmodule ElixirScript.Translator.Bitstring do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator def make_bitstring(elements, env) do js_ast = JS.new_expression( JS.member_expression( JS.member_expression( JS.identifier("Elixir"), JS.identifier("Core") ), JS.identifier("BitString") ), Enum.map(elements, &make_bitstring_element(&1, env)) ) { js_ast, env } end def make_bitstring_element(element, env) when is_number(element) do do_make_bitstring_element({:integer, Translator.translate!(element, env)}) end def make_bitstring_element(element, env) when is_binary(element) do do_make_bitstring_element({:binary, Translator.translate!(element, env)}) end def make_bitstring_element({:<<>>, [], elements}, env) do {ast, _} = make_bitstring(elements, env) ast end def make_bitstring_element({:::, _, [element, {type, _, _}]}, env) when type in [:integer, :float, :bitstring, :bits, :binary, :bytes, :utf8, :utf16, :utf32, :signed, :unsigned] do do_make_bitstring_element({type, translate_element(element, env)}) end def make_bitstring_element({:::, _, [element, {type, _, params}]}, env) when type in [:size, :unit] do do_make_bitstring_element({type, translate_element(element, env), Enum.map(params, &translate_element(&1, env))}) end def make_bitstring_element({:::, _, [element, {:*, _, [size, unit]}]}, env) do size_ast = do_make_bitstring_element({:size, translate_element(element, env), [translate_element(size, env)]}) do_make_bitstring_element({:unit, size_ast, [translate_element(unit, env)]}) end def make_bitstring_element({:::, _, [element, {:-, _, types}]}, env) do handle_type_adjectives({:-, [], types}, translate_element(element, env), env) end def make_bitstring_element({:::, _, [element, size]}, env) do do_make_bitstring_element({:size, translate_element(element, env), [translate_element(size, env)]}) end def make_bitstring_element(element, env) do do_make_bitstring_element({:binary, translate_element(element, env)}) end def translate_element(ElixirScript.Translator.PatternMatching, _) do JS.object_expression([JS.property( JS.literal("value"), ElixirScript.Translator.PatternMatching.parameter() ) ]) end def translate_element(element, env) do Translator.translate!(element, env) end defp handle_type_adjectives({:-, _, types}, ast, env) do Enum.reduce(types, ast, fn(type, current_ast) -> case type do {:-, _, sub_types} -> handle_type_adjectives({:-, [], sub_types}, current_ast, env) {:*, _, [size, unit]} -> size_ast = do_make_bitstring_element({:size, current_ast, [Translator.translate!(size, env)]}) do_make_bitstring_element({:unit, size_ast, [Translator.translate!(unit, env)]}) {the_type, _, params} when is_list(params) -> do_make_bitstring_element({the_type, current_ast, Enum.map(params, &Translator.translate!(&1, env))}) {the_type, _, _} -> do_make_bitstring_element({the_type, current_ast}) end end) end defp bitstring_class() do JS.member_expression( JS.member_expression( JS.identifier("Elixir"), JS.identifier("Core") ), JS.identifier("BitString") ) end defp do_make_bitstring_element({type, ast}) do JS.call_expression( JS.member_expression( bitstring_class, JS.identifier(type) ), [ ast ] ) end defp do_make_bitstring_element({type, ast, params}) when is_list(params) do JS.call_expression( JS.member_expression( bitstring_class, JS.identifier(type) ), [ ast ] ++ params ) end def make_interpolated_string(elements, env) do translated_elements = Enum.map(elements, fn(x)-> case x do elem when is_binary(elem) -> Translator.translate!(elem, env) {:::, _, data} -> Translator.translate!(hd(data), env) end end) { do_make_interpolated_string(tl(translated_elements), hd(translated_elements), env), env } end defp do_make_interpolated_string([], ast, _) do ast end defp do_make_interpolated_string(elements, ast, env) do JS.binary_expression( :+, ast, do_make_interpolated_string(tl(elements), hd(elements), env) ) end end elixirscript-0.25.0/lib/elixir_script/translator/kernel/special_forms/block.ex000066400000000000000000000005341305236071500277000ustar00rootroot00000000000000defmodule ElixirScript.Translator.Block do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator def make_block(expressions, env) do { list, env } = Enum.map_reduce(expressions, env, fn(x, updated_env) -> Translator.translate(x, updated_env) end) { JS.block_statement(list), env } end end elixirscript-0.25.0/lib/elixir_script/translator/kernel/special_forms/call.ex000066400000000000000000000143131305236071500275210ustar00rootroot00000000000000defmodule ElixirScript.Translator.Call do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator alias ElixirScript.Translator.Utils alias ElixirScript.Translator.Identifier def make_module_name(module_name, env) do the_name = get_module_name_for_function(module_name, env) { make_module_expression_tree(the_name, false, env), env } end def make_function_or_property_call(module_name, function_name, env) do the_name = get_module_name_for_function(module_name, env) js_ast = JS.call_expression( JS.member_expression( JS.member_expression( JS.identifier("Elixir"), JS.member_expression( JS.identifier("Core"), JS.identifier("Functions") ) ), JS.identifier("call_property") ), [ make_module_expression_tree(the_name, false, env), Translator.translate!(to_string(function_name), env) ] ) { js_ast, env } end def get_module_name_for_function(module_name, env) do case module_name do {:__aliases__, _, name} -> module_name = Utils.quoted_to_name(name) get_js_name(module_name, env) {name, _, _} when is_atom(name) -> get_js_name(name, env) {{:., _, [_, _]}, _, _ } = ast -> ast {{:., _, [{:__aliases__, _, _}]}, _, _} = ast -> ast ast when is_list(ast) -> ast name -> get_js_name(name, env) end end def make_function_call(function_name, params, env) when is_tuple(function_name) do { make_call_expression(function_name, params, env), env } end def make_function_call(function_name, params, env) do { make_call_expression(function_name, params, env), env } end def make_function_call(module_name, function_name, params, env) when is_list(module_name) do call = JS.call_expression( JS.member_expression( Translator.translate!(module_name, env), Identifier.make_identifier(function_name) ), Enum.map(params, &Translator.translate!(&1, env)) ) { call, env } end def make_function_call(module_name, function_name, params, env) do params = case params do atom when is_atom(atom) -> [] nil -> [] _ -> params end the_name = get_module_name_for_function(module_name, env) { make_call_expression(the_name, function_name, params, env), env } end defp make_call_expression(module_name, function_name, params, env) do JS.call_expression( make_member_expression(module_name, function_name, env), Enum.map(params, &Translator.translate!(&1, env)) ) end defp make_call_expression(function_name, params, env) when is_tuple(function_name) do JS.call_expression( Translator.translate!(function_name, env), Enum.map(params, &Translator.translate!(&1, env)) ) end defp make_call_expression(function_name, params, env) do JS.call_expression( Identifier.make_identifier(function_name), Enum.map(params, &Translator.translate!(&1, env)) ) end def get_js_name([Elixir | _] = list, _) do list end def get_js_name({:__aliases__, _, _} = name, env) do Utils.quoted_to_name(name) |> get_js_name(env) end def get_js_name(module_name, env) when is_list(module_name) do Utils.quoted_to_name({:__aliases__, [], module_name}) |> get_js_name(env) end def get_js_name(module_name, env) do cond do module_name in env.requires -> Utils.name_to_js_name(module_name) module_name in ElixirScript.Translator.State.list_module_names(env.state) -> ElixirScript.Translator.State.add_module_reference(env.state, env.module, module_name) Utils.name_to_js_name(module_name) true -> case Atom.to_string(module_name) do "Elixir." <> _ -> {:__aliases__, _, name } = Utils.name_to_quoted(module_name) name _ -> module_name end end end def make_member_expression(module_name, function_name, env, computed \\ false) do case module_name do modules when is_list(modules) and length(modules) > 1 -> ast = make_module_expression_tree(modules, computed, env) JS.member_expression( ast, Identifier.make_identifier(function_name), computed ) modules when is_list(modules) and length(modules) == 1 -> JS.member_expression( Identifier.make_identifier(hd(modules)), Identifier.make_identifier(function_name), computed ) {{:., _, [_module_name, _function_name]}, _, _params } = ast -> JS.member_expression( Translator.translate!(ast, env), Identifier.make_identifier(function_name), computed ) {{:., _, [{:__aliases__, _, _}]}, _, _} = ast -> JS.member_expression( Translator.translate!(ast, env), Identifier.make_identifier(function_name), computed ) {:., _, _} = ast -> JS.member_expression( Translator.translate!(ast, env), Identifier.make_identifier(function_name), computed ) _ -> JS.member_expression( Identifier.make_identifier(module_name), Identifier.make_identifier(function_name), computed ) end end defp make_module_expression_tree([module], computed, env) do make_module_expression_tree(module, computed, env) end defp make_module_expression_tree(modules, computed, _) when is_list(modules) do Enum.reduce(modules, nil, fn(x, ast) -> case ast do nil -> JS.member_expression(Identifier.make_identifier(x), nil, computed) %ESTree.MemberExpression{ property: nil } -> %{ ast | property: Identifier.make_identifier(x) } _ -> JS.member_expression(ast, Identifier.make_identifier(x), computed) end end) end defp make_module_expression_tree(module, _, _) when is_binary(module) or is_atom(module) do Identifier.make_identifier(module) end defp make_module_expression_tree(module, _, env) do Translator.translate!(module, env) end end elixirscript-0.25.0/lib/elixir_script/translator/kernel/special_forms/capture.ex000066400000000000000000000017531305236071500302550ustar00rootroot00000000000000defmodule ElixirScript.Translator.Capture do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator.PatternMatching alias ElixirScript.Translator.Function alias ElixirScript.Translator.Call alias ElixirScript.Translator.Identifier alias ElixirScript.Translator def make_capture(function_name, arity, env) do Identifier.make_identifier(function_name) end def make_capture(module_name, function_name, arity, env) do JS.member_expression( Translator.translate!(module_name, env), JS.identifier(function_name) ) end def find_value_placeholders(ast) do case ast do list when is_list(list) -> Enum.map(list, &find_value_placeholders(&1)) {:&, _, [number]} when is_number(number) -> [{String.to_atom("__#{number}"), [], ElixirScript.Translator.Capture}] tuple when is_tuple(tuple) -> Enum.map(Tuple.to_list(tuple), &find_value_placeholders(&1)) _ -> [] end end end elixirscript-0.25.0/lib/elixir_script/translator/kernel/special_forms/case.ex000066400000000000000000000007401305236071500275200ustar00rootroot00000000000000defmodule ElixirScript.Translator.Case do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator alias ElixirScript.Translator.Function def make_case(condition, clauses, env) do { func, env } = Function.make_anonymous_function(clauses, env) js_ast = JS.call_expression( JS.member_expression( func, JS.identifier("call")), [JS.identifier(:this), Translator.translate!(condition, env)] ) { js_ast, env } end end elixirscript-0.25.0/lib/elixir_script/translator/kernel/special_forms/cond.ex000066400000000000000000000016211305236071500275270ustar00rootroot00000000000000defmodule ElixirScript.Translator.Cond do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator alias ElixirScript.Translator.Primitive alias ElixirScript.Translator.Function def make_cond(clauses, env) do js_ast = JS.call_expression( JS.member_expression( Primitive.special_forms(), JS.identifier("cond") ), process_cond(clauses, env) ) { js_ast, env } end defp process_cond(clauses, env) do Enum.map(clauses, fn({:->, _, [clause, clause_body]}) -> { translated_body, env } = Function.prepare_function_body(clause_body, env) translated_body = JS.block_statement(translated_body) function = JS.function_expression([], [], translated_body) translated_clause = Translator.translate!(hd(clause), env) Primitive.make_list_no_translate([translated_clause, function]) end) end end elixirscript-0.25.0/lib/elixir_script/translator/kernel/special_forms/fn.ex000066400000000000000000000151211305236071500272070ustar00rootroot00000000000000defmodule ElixirScript.Translator.Function do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator alias ElixirScript.Translator.Group alias ElixirScript.Translator.PatternMatching alias ElixirScript.Translator.Block @patterns JS.member_expression( JS.member_expression( JS.identifier("Elixir"), JS.identifier("Core") ), JS.identifier("Patterns") ) @spec make_anonymous_function(list(), ElixirScript.Translator.LexicalScope.t, binary | atom) :: tuple() def make_anonymous_function(functions, env, name \\ nil) def make_anonymous_function(functions, env, name) do clauses = functions |> Enum.map(fn ({:->, _, [ [{:when, _, params}], body ]}) -> guards = List.last(params) |> List.wrap params = params |> Enum.reverse |> tl |> Enum.reverse process_function_body(params, body, env, name, guards) ({:->, _, [params, body]}) -> process_function_body(params, body, env, name) ({_, _, [{:when, _, [{_, _, params} | guards]}, body]}) -> body = convert_to_try(body) process_function_body(params, body, env, name, guards) ({_, _, [{_, _, params}, body]}) -> body = convert_to_try(body) process_function_body(params, body, env, name) ({_, _, [{_, _, params}]}) -> process_function_body(params, [], env, name) end) {make_defmatch(clauses, env.context == :generator), env} end defp convert_to_try([do: body]) do body end defp convert_to_try(function_kw_list) do {:__block__, [], [{:try, [], [function_kw_list]}]} end defp make_defmatch(clauses, true) do JS.call_expression( JS.member_expression( @patterns, JS.identifier("defmatchgen") ), clauses ) end defp make_defmatch(clauses, _) do JS.call_expression( JS.member_expression( @patterns, JS.identifier("defmatch") ), clauses ) end defp process_function_body(params, body, env, name, guards \\ nil) do env = ElixirScript.Translator.LexicalScope.function_scope(env, {name, get_arity(params)}) {patterns, params, env} = process_params(params, env) {body, _} = make_function_body(body, env) if guards do {guard_body, _} = guards |> List.wrap |> hd |> prepare_function_body(%{env | context: :guard}) guard_body = JS.block_statement(guard_body) make_function_clause(patterns, params, body, guard_body, env.context == :generator) else make_function_clause(patterns, params, body, nil, env.context == :generator) end end defp wrap_params(params) when is_atom(params), do: [] defp wrap_params(params), do: List.wrap(params) @spec make_function_body(list | tuple, ElixirScript.Translator.LexicalScope.t) :: tuple() def make_function_body(body, env) do {body, _} = body |> prepare_function_body(env) {JS.block_statement(body), env} end defp get_arity(params) when is_atom(params), do: 0 defp get_arity(params) when is_tuple(params), do: 1 defp get_arity(params), do: length(params) defp make_params(params) do Enum.filter(params, fn (%ESTree.Identifier{name: :undefined}) -> false (_) -> true end) end defp process_params(params, env) do params = wrap_params(params) {patterns, params, env} = PatternMatching.process_match(params, env) {patterns, make_params(params), env} end defp make_function_clause(patterns, params, body, guard_body, is_generator?) do arguments = case guard_body do nil -> [ JS.array_expression(patterns), JS.function_expression(params, [], body, is_generator?) ] _ -> [ JS.array_expression(patterns), JS.function_expression(params, [], body, is_generator?), JS.function_expression(params, [], guard_body) ] end JS.call_expression( JS.member_expression( @patterns, JS.identifier("clause") ), arguments ) end def prepare_function_body(body, env) do {list, env} = case body do nil -> {[], env} list when is_list(list) -> t = Translator.translate!(list, env) {[t], env} {:__block__, _, list} -> Enum.map_reduce(list, env, fn(x, env) -> Translator.translate(x, env) end) _ -> Enum.map_reduce(List.wrap(body), env, fn(x, env) -> Translator.translate(x, env) end) end list = Group.inflate_groups(list) |> return_last_expression {list, env} end defp return_last_expression(nil) do nil end defp return_last_expression([]) do [JS.return_statement(JS.literal(nil))] end defp return_last_expression(%ESTree.BlockStatement{} = block) do %ESTree.BlockStatement{block | body: return_last_expression(block.body)} end defp return_last_expression(list) when is_list(list) do last_item = List.last(list) last_item = case last_item do %ESTree.YieldExpression{} -> JS.return_statement(last_item) %ESTree.Literal{} -> JS.return_statement(last_item) %ESTree.Identifier{} -> JS.return_statement(last_item) %ESTree.VariableDeclaration{} -> declaration = hd(last_item.declarations).id return_statement = case declaration do %ESTree.ArrayPattern{elements: elements} -> if(length(elements) == 1) do JS.return_statement(hd(declaration.elements)) else JS.return_statement(JS.array_expression(declaration.elements)) end _ -> JS.return_statement(declaration) end [last_item, return_statement] %ESTree.BlockStatement{} -> last_item = %ESTree.BlockStatement{last_item | body: return_last_expression(last_item.body)} _ -> if String.contains?(last_item.type, "Expression") do JS.return_statement(last_item) else [last_item, JS.return_statement(JS.literal(nil))] end end list = Enum.take(list, length(list)-1) |> Enum.map(fn(x) -> case x do %ESTree.MemberExpression{} -> JS.expression_statement(x) %ESTree.CallExpression{} -> JS.expression_statement(x) _ -> x end end) if is_list(last_item) do list ++ last_item else list ++ [last_item] end end end elixirscript-0.25.0/lib/elixir_script/translator/kernel/special_forms/for.ex000066400000000000000000000073651305236071500274050ustar00rootroot00000000000000defmodule ElixirScript.Translator.For do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator alias ElixirScript.Translator.PatternMatching alias ElixirScript.Translator.Primitive alias ElixirScript.Translator.Function alias ElixirScript.Translator.Utils def make_for(generators, env) do ElixirScript.Translator.State.add_module_reference(env.state, env.module, ElixirScript.Collectable) args = handle_args(generators, env) generators = JS.array_expression(args.generators) into = args.into || Primitive.make_list_no_translate([]) filter = args.filter || JS.function_expression([], [], JS.block_statement([JS.return_statement(JS.identifier("true"))])) fun = args.fun expression = JS.call_expression( JS.member_expression( JS.member_expression( JS.member_expression( JS.identifier("Elixir"), JS.identifier("Core") ), JS.identifier("Patterns") ), JS.identifier("clause") ), [JS.array_expression(args.patterns), fun, filter] ) js_ast = JS.call_expression( JS.member_expression( Primitive.special_forms(), JS.identifier("_for") ), [expression, generators, JS.identifier(Utils.name_to_js_name(ElixirScript.Collectable)), into] ) {js_ast, env} end defp handle_args(generators, env) do Enum.reduce(generators, %{generators: [], args: [], filter: nil, fun: nil, into: nil, patterns: []}, fn ({:<<>>, [], body}, state) -> {bs_parts, collection} = Enum.map_reduce(body, nil, fn {:::, _, _} = ast, state -> {ast, state} {:<-, [], [var, collection]}, _ -> {var, collection} end) {patterns, params, env} = PatternMatching.process_match([{:<<>>, [], bs_parts}], env) gen = JS.call_expression( JS.member_expression( JS.member_expression( JS.member_expression( JS.identifier("Elixir"), JS.identifier("Core") ), JS.identifier("Patterns") ), JS.identifier("bitstring_generator") ), [hd(patterns), Translator.translate!(collection, env)] ) %{state | generators: state.generators ++ [gen], args: state.args ++ params, patterns: state.patterns ++ patterns} ({:<-, _, [identifier, enum]}, state) -> {patterns, params, env} = PatternMatching.process_match([identifier], env) gen = JS.call_expression( JS.member_expression( JS.member_expression( JS.member_expression( JS.identifier("Elixir"), JS.identifier("Core") ), JS.identifier("Patterns") ), JS.identifier("list_generator") ), [hd(patterns), Translator.translate!(enum, env)] ) %{state | generators: state.generators ++ [gen], args: state.args ++ params, patterns: state.patterns ++ patterns} ([into: expression], state) -> %{state | into: Translator.translate(expression, env)} ([into: expression, do: expression2], state) -> fun = create_function_expression(expression2, env, state) %{state | into: Translator.translate!(expression, env), fun: fun} ([do: expression], state) -> fun = create_function_expression(expression, env, state) %{state | fun: fun} (filter, state) -> fun = create_function_expression(filter, env, state) %{state | filter: fun} end) end defp create_function_expression(ast, env, state) do {ast, _} = Function.make_function_body(ast, env) JS.function_expression( state.args, [], ast ) end end elixirscript-0.25.0/lib/elixir_script/translator/kernel/special_forms/identifier.ex000066400000000000000000000022311305236071500307240ustar00rootroot00000000000000defmodule ElixirScript.Translator.Identifier do @moduledoc false alias ESTree.Tools.Builder, as: JS @js_reserved_words [ :break, :case, :class, :const, :continue, :debugger, :default, :delete, :do, :else, :export, :extends, :finally, :function, :if, :import, :in, :instanceof, :new, :return, :super, :switch, :throw, :try, :typeof, :var, :void, :while, :with, :yield ] def make_identifier({:__aliases__, _, aliases}) do aliases |> Enum.reverse |> make_alias end def make_identifier([ast]) do make_identifier(ast) end def make_identifier(ast) do ast |> filter_name |> JS.identifier end defp filter_name(reserved_word) when reserved_word in @js_reserved_words do "__#{Atom.to_string(reserved_word)}__" end defp filter_name(name) do to_string(name) |> String.replace("?", "__qmark__") |> String.replace("!", "__emark__") end defp make_alias([x]) do make_identifier(x) end defp make_alias([h|t]) do JS.member_expression(make_alias(t), make_identifier(h)) end end elixirscript-0.25.0/lib/elixir_script/translator/kernel/special_forms/map.ex000066400000000000000000000036771305236071500273760ustar00rootroot00000000000000defmodule ElixirScript.Translator.Map do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator alias ElixirScript.Translator.Primitive def make_map(object_expression) do JS.call_expression( JS.member_expression( JS.identifier(:Object), JS.identifier(:freeze) ), [object_expression] ) end def make_get_property(target, property, env) do JS.member_expression( Translator.translate!(target, env), Translator.translate!(property, env), true ) end def make_object(properties, env) do properties |> Enum.map(fn ({x, {:__aliases__, _, [value]}}) -> make_property(Translator.translate!(x, env), JS.identifier(value)) ({x, y}) -> case x do {_, _, atom } when is_atom(atom) -> JS.property(Translator.translate!(x, env), Translator.translate!(y, env), :init, false, false, true) _ -> make_property(Translator.translate!(x, env), Translator.translate!(y, env)) end end) |> JS.object_expression |> make_map end def make_property(%ESTree.Identifier{} = key, value) do JS.property(key, value) end def make_property(%ESTree.Literal{value: k}, value) when is_binary(k) do key = case String.contains?(k, "-") do true -> JS.literal(k) false -> JS.identifier(k) end JS.property(key, value) end def make_property(key, value) do JS.property(key, value, :init, false, false, true) end def make_shorthand_property(%ESTree.Identifier{} = key) do JS.property(key, key, :init, true) end def make_map_update(map, data, env) do map = Translator.translate!(map, env) data = Translator.translate!({:%{}, [], data}, env) js_ast = JS.call_expression( JS.member_expression( Primitive.special_forms(), JS.identifier("map_update") ), [map, data] ) { js_ast, env } end end elixirscript-0.25.0/lib/elixir_script/translator/kernel/special_forms/match.ex000066400000000000000000000045141305236071500277040ustar00rootroot00000000000000defmodule ElixirScript.Translator.Match do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator alias ElixirScript.Translator.PatternMatching alias ElixirScript.Translator.Primitive def make_match(left, right, env) do { right_ast, env } = Translator.translate(right, env) { patterns, params, env } = PatternMatching.process_match([left], env) declarator = JS.variable_declarator( JS.array_pattern(params), JS.call_expression( JS.member_expression( JS.member_expression( JS.member_expression( JS.identifier("Elixir"), JS.identifier("Core") ), JS.identifier("Patterns") ), JS.identifier("match") ), [hd(patterns), right_ast] ) ) array_pattern = JS.variable_declaration([declarator], :let) js_ast = case left do list when is_list(list) -> make_list_ref(array_pattern, params) { _, _ } -> make_tuple_ref(array_pattern, params) {:{}, _, _ } -> make_tuple_ref(array_pattern, params) _ -> array_pattern end { js_ast, env } end defp make_list_ref(array_pattern, params) do {ref, params} = make_params(params) ref_declarator = JS.variable_declarator( ref, Primitive.do_make_list(params) ) make_variable_declaration_and_group(ref_declarator, array_pattern) end defp make_tuple_ref(array_pattern, params) do {ref, params} = make_params(params) ref_declarator = JS.variable_declarator( ref, JS.new_expression( JS.member_expression( JS.identifier("Elixir"), JS.member_expression( JS.identifier("Core"), JS.identifier("Tuple") ) ), params ) ) make_variable_declaration_and_group(ref_declarator, array_pattern) end defp make_params(params) do ref = JS.identifier("_ref") params = Enum.map(params, fn (nil) -> JS.identifier(:undefined) (x) -> x end) { ref, params } end defp make_variable_declaration_and_group(ref_declarator, array_pattern) do ref_declaration = JS.variable_declaration([ref_declarator], :let) %ElixirScript.Translator.Group{ body: [array_pattern, ref_declaration] } end end elixirscript-0.25.0/lib/elixir_script/translator/kernel/special_forms/primitive.ex000066400000000000000000000042071305236071500306170ustar00rootroot00000000000000defmodule ElixirScript.Translator.Primitive do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator alias ElixirScript.Translator.Quote def special_forms() do JS.member_expression( JS.identifier("Elixir"), JS.member_expression( JS.identifier("Core"), JS.identifier("SpecialForms") ) ) end def tuple_class() do JS.member_expression( JS.member_expression( JS.identifier("Elixir"), JS.identifier("Core") ), JS.identifier("Tuple") ) end def list_ast() do JS.member_expression( JS.member_expression( JS.identifier("Elixir"), JS.member_expression( JS.identifier("Core"), JS.identifier("SpecialForms") ) ), JS.identifier("list") ) end def make_atom(ast) when is_atom(ast) do JS.call_expression( JS.member_expression( JS.identifier("Symbol"), JS.identifier("for") ), [JS.literal(ast)] ) end def make_literal(ast) when is_number(ast) or is_binary(ast) or is_boolean(ast) or is_nil(ast) do JS.literal(ast) end def make_list(ast, env) when is_list(ast) do js_ast = Enum.map(ast, &Translator.translate!(&1, env)) |> do_make_list { js_ast, env } end def make_list_quoted(opts, ast, env) when is_list(ast) do Enum.map(ast, fn(x) -> Quote.make_quote(opts, x, env) end) |> do_make_list end def make_list_no_translate(ast) when is_list(ast) do do_make_list(ast) end def do_make_list(ast) do JS.call_expression( JS.member_expression( JS.identifier("Object"), JS.identifier("freeze") ), [JS.array_expression(ast)] ) end def make_tuple({ one, two }, env) do make_tuple([one, two], env) end def make_tuple(elements, env) do list = Enum.map(elements, &Translator.translate!(&1, env)) js_ast = JS.new_expression(tuple_class, list) { js_ast, env } end def make_tuple_quoted(opts, elements, env) do JS.new_expression( tuple_class, Enum.map(elements, fn(x) -> Quote.make_quote(opts, x, env) end) ) end end elixirscript-0.25.0/lib/elixir_script/translator/kernel/special_forms/quote.ex000066400000000000000000000044161305236071500277460ustar00rootroot00000000000000defmodule ElixirScript.Translator.Quote do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator alias ElixirScript.Translator.Primitive def make_quote(_opts, expr, env) when is_number(expr) or is_binary(expr) or is_boolean(expr) or is_nil(expr) or is_atom(expr) do Translator.translate!(expr, env) end def make_quote(opts, expr, env) when is_list(expr) do has_unquote_splicing = Enum.any?(expr, fn ({:unquote_splicing, _, _}) -> true (_) -> false end) if(has_unquote_splicing) do expr = Enum.map(expr, fn ({:unquote_splicing, _, [param]}) -> make_unquote_slicing(param, env) (x) -> Primitive.make_list_no_translate([make_quote(opts, x, env)]) end ) JS.call_expression( JS.member_expression( JS.identifier("Elixir"), JS.member_expression( JS.identifier("Enum"), JS.identifier("concat") ) ), expr ) else Primitive.make_list_quoted(opts, expr, env) end end def make_quote(opts, {one, two}, env) do Primitive.make_tuple_quoted(opts, [one, two], env) end def make_quote([unquote: false] = opts, {:unquote, context, params}, env) do Primitive.make_tuple_quoted(opts, [:unquote, context, params], env) end def make_quote([context: {_, _, [new_context]}] = opts, {name, context, params}, env) do updated_context = Keyword.put(context, :context, new_context) Primitive.make_tuple_quoted(opts, [name, updated_context, params], env) end def make_quote(_, {:alias!, _, [the_alias]}, _) do the_alias end def make_quote(_, {:unquote, _, [param]}, env) do make_unquote(param, env) end def make_quote(opts, {name, context, elements }, env) do if is_in_bind_quoted(opts[:bind_quoted], name) do Translator.translate!({name, context, elements }, env) else Primitive.make_tuple_quoted(opts, [name, context, elements], env) end end def make_unquote(expr, env) do Translator.translate!(expr, env) end def make_unquote_slicing(expr, env) do Translator.translate!(expr, env) end defp is_in_bind_quoted(nil, _) do false end defp is_in_bind_quoted(binds, name) do binds[name] != nil end end elixirscript-0.25.0/lib/elixir_script/translator/kernel/special_forms/struct.ex000066400000000000000000000075251305236071500301410ustar00rootroot00000000000000defmodule ElixirScript.Translator.Struct do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator alias ElixirScript.Translator.Utils alias ElixirScript.Translator.Map alias ElixirScript.Translator.Identifier def get_struct_class(module_name, env) do candiate_module_name = ElixirScript.Translator.State.get_module_name(env.state, Utils.quoted_to_name(module_name)) if ElixirScript.Translator.LexicalScope.get_module_name(env, candiate_module_name) in ElixirScript.Translator.State.list_module_names(env.state) do name = ElixirScript.Translator.LexicalScope.get_module_name(env, candiate_module_name) ident = JS.identifier(Utils.name_to_js_name(name)) ElixirScript.Translator.State.add_module_reference(env.state, env.module, name) JS.member_expression(ident, ident) else Identifier.make_identifier(module_name) end end def new_struct(module_name, data, env) do JS.call_expression( JS.member_expression( get_struct_class(module_name, env), JS.identifier(:create) ), [Translator.translate!(data, env)] ) end def make_defstruct(attributes, env) when length(attributes) == 1 do attributes = Enum.flat_map(attributes, fn(x) -> x end) defaults = Enum.map(attributes, fn ({x, y}) -> Map.make_property( Translator.translate!(x, env), Translator.translate!(y, env) ) (attribute) -> Map.make_property( Translator.translate!(attribute, env), Translator.translate!(nil, env) ) end) |> JS.object_expression do_make_defstruct(:defstruct, defaults, env) end def make_defstruct(attributes, env) do defaults = Enum.map(attributes, fn(x) -> Map.make_property( Translator.translate!(x, env), Translator.translate!(nil, env) ) end) |> JS.object_expression do_make_defstruct(:defstruct, defaults, env) end def make_defexception(attributes, env) when length(attributes) == 1 do exception_key_value = Map.make_property(Translator.translate!(:__exception__, env), Translator.translate!(true, env)) attributes = Enum.flat_map(attributes, fn(x) -> x end) defaults = [exception_key_value] ++ Enum.map(attributes, fn ({x, y}) -> Map.make_property( Translator.translate!(x, env), Translator.translate!(y, env) ) (x) -> Map.make_property( Translator.translate!(x, env), Translator.translate!(nil, env) ) end) |> JS.object_expression do_make_defstruct(:defexception, defaults, env) end def make_defexceptions(attributes, env) do exception_key_value = Map.make_property(Translator.translate!(:__exception__, env), Translator.translate!(true, env)) defaults = [exception_key_value] ++ Enum.map(attributes, fn (x) -> Map.make_property( Translator.translate!(x, env), Translator.translate!(nil, env) ) end) |> JS.object_expression do_make_defstruct(:defexception, defaults, env) end defp do_make_defstruct(name, defaults, env) do struct_name = Map.make_property(Translator.translate!(:__struct__, env), Translator.translate!({:__MODULE__, [], []}, env)) defaults = %{ defaults | properties: [struct_name] ++ defaults.properties } ref = JS.identifier(Utils.name_to_js_name(env.module)) ref_declarator = JS.variable_declarator( ref, JS.call_expression( JS.member_expression( JS.member_expression( JS.identifier("Elixir"), JS.member_expression( JS.identifier("Core"), JS.identifier("Functions") ) ), JS.identifier(name) ), [defaults] ) ) JS.variable_declaration([ref_declarator], :const) end end elixirscript-0.25.0/lib/elixir_script/translator/kernel/special_forms/try.ex000066400000000000000000000055371305236071500274340ustar00rootroot00000000000000defmodule ElixirScript.Translator.Try do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator.Function alias ElixirScript.Translator.Primitive def make_try(blocks, env) do try_block = Dict.get(blocks, :do) rescue_block = Dict.get(blocks, :rescue, nil) catch_block = Dict.get(blocks, :catch, nil) after_block = Dict.get(blocks, :after, nil) else_block = Dict.get(blocks, :else, nil) { translated_body, _ } = Function.prepare_function_body(try_block, env) translated_body = JS.block_statement(translated_body) try_block = JS.function_expression([], [], translated_body) rescue_block = if rescue_block do process_rescue_block(rescue_block, env) else JS.identifier(:null) end catch_block = if catch_block do process_catch_block(catch_block, env) else JS.identifier(:null) end after_block = if after_block do process_after_block(after_block, env) else JS.identifier(:null) end else_block = if else_block do Function.make_anonymous_function(else_block, env) |> elem(0) else JS.identifier(:null) end js_ast = JS.call_expression( JS.member_expression( Primitive.special_forms(), JS.identifier("_try") ), [ try_block, rescue_block, catch_block, else_block, after_block ] ) { js_ast, env } end defp process_rescue_block(rescue_block, env) do { func, _ } = Enum.map(rescue_block, fn(x) -> case x do {:->, _, [[{value, _, module}], block]} when not is_list(module) -> {:->, [], [[{value, [], convert_to_struct(module)}], block]} {:->, _, [[{:in, meta, [value, error_names]}], block]} -> error_names = Enum.map(error_names, fn(x) -> convert_to_struct(x) end) guards = {:in, meta, [value, error_names]} {:->, [], [ [{:when, [], [value | [guards]]}], block ]} {:->, _, [error_names, block]} -> Enum.map(error_names, fn(x) -> {:->, [], [[convert_to_struct(x)], block]} end) end end) |> List.flatten |> Function.make_anonymous_function(env) func end defp process_catch_block(catch_block, env) do {func, _} = catch_block |> Function.make_anonymous_function(env) func end defp process_after_block(after_block, env) do { translated_body, _ } = Function.prepare_function_body(after_block, env) translated_body = JS.block_statement(translated_body) JS.function_expression([], [], translated_body) end defp convert_to_struct([module]) do convert_to_struct(module) end defp convert_to_struct(module) do case module do {:__aliases__, _, _} = alias_ast-> {:%, [], [alias_ast, {:%{}, [], []}]} ast -> ast end end end elixirscript-0.25.0/lib/elixir_script/translator/kernel/special_forms/with.ex000066400000000000000000000033341305236071500275620ustar00rootroot00000000000000defmodule ElixirScript.Translator.With do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator.Function alias ElixirScript.Translator.Primitive alias ElixirScript.Translator.PatternMatching def make_with(args, env) do result = Enum.reduce(args, %{ expressions: [], arguments: [] }, fn {symbol, _, [pattern, expr] }, state when symbol in [:<-, :=] -> {body , _} = Function.prepare_function_body(expr, env) translated_body = JS.block_statement(body) expr_function = JS.function_expression(state.arguments, [], translated_body) { patterns, params, _ } = PatternMatching.process_match([pattern], env) %{state | arguments: state.arguments ++ params, expressions: state.expressions ++ [ JS.array_expression([hd(patterns), expr_function]) ] } [do: expr], state -> expr_function = process_do_block(expr, state.arguments, env) %{state | expressions: state.expressions ++ [ expr_function ] } [do: do_expr, else: else_expr], state -> do_function = process_do_block(do_expr, state.arguments, env) { else_function, _ } = Function.make_anonymous_function(else_expr, env) %{state | expressions: state.expressions ++ [ do_function, else_function ] } end) expressions = result.expressions js_ast = JS.call_expression( JS.member_expression( Primitive.special_forms(), JS.identifier("_with") ), expressions ) { js_ast, env } end defp process_do_block(expr, arguments, env) do {body , _} = Function.prepare_function_body(expr, env) translated_body = JS.block_statement(body) JS.function_expression(arguments, [], translated_body) end end elixirscript-0.25.0/lib/elixir_script/translator/lexical_scope.ex000066400000000000000000000250341305236071500253140ustar00rootroot00000000000000defmodule ElixirScript.Translator.LexicalScope do @moduledoc false @type t :: %ElixirScript.Translator.LexicalScope{ module: atom, file: binary, line: non_neg_integer, function: { atom, non_neg_integer } | nil, context: :match | :guard | :generator | nil, aliases: [{atom, atom}], requires: [atom], functions: [{atom, [{ atom, non_neg_integer }]}], macros: [{atom, [{ atom, non_neg_integer }]}], macro_aliases: [{atom, {integer, atom}}], context_modules: [atom], vars: [{atom, atom | non_neg_integer}], export_vars: [{atom, atom | non_neg_integer}] | nil, lexical_tracker: nil, caller: t | nil, env: nil, state: pid, format: atom, module_formatter: atom } defstruct [ module: nil, file: nil, line: 0, function: nil, context: nil, aliases: [], requires: [], functions: [], macros: [], macro_aliases: [], context_modules: [], vars: [], export_vars: nil, lexical_tracker: nil, caller: nil, env: nil, state: nil, format: :es, module_formatter: ElixirScript.ModuleSystems.ES ] def env(scope) do %Macro.Env{ module: scope.module, file: scope.file, line: scope.line, function: scope.function, context: scope.context, aliases: scope.aliases, requires: scope.requires, functions: scope.functions, macros: scope.macros, macro_aliases: scope.macro_aliases, context_modules: scope.context_modules, vars: Enum.map(scope.vars, fn({key, _}) -> {key, nil} end), export_vars: scope.export_vars, lexical_tracker: scope.lexical_tracker } end def caller(scope) do %Macro.Env{ module: scope.caller.module, file: scope.caller.file, line: scope.caller.line, function: scope.caller.function, context: scope.caller.context, aliases: scope.caller.aliases, requires: scope.caller.requires, functions: scope.caller.functions, macros: scope.caller.macros, macro_aliases: scope.caller.macro_aliases, context_modules: scope.caller.context_modules, vars: Enum.map(scope.vars, fn({key, _}) -> {key, nil} end), export_vars: scope.caller.export_vars, lexical_tracker: scope.caller.lexical_tracker } end def module_scope(ElixirScript.Temp, filename, env, state, opts) do env = %ElixirScript.Translator.LexicalScope { module: ElixirScript.Temp, file: filename, requires: [], functions: [], macros: [], env: env, state: state, format: opts.format, module_formatter: opts.module_formatter } add_import(env, ElixirScript.Kernel) end def module_scope(module_name, filename, env, state, opts) do module = ElixirScript.Translator.State.get_module(state, module_name) env = %ElixirScript.Translator.LexicalScope { module: module_name, file: filename, requires: [], functions: [{ module.name, module.functions}], macros: [{module.name, module.macros}], env: env, state: state, format: opts.format, module_formatter: opts.module_formatter } env = add_import(env, ElixirScript.Kernel) cond do module_name == JS -> env ElixirScript.Translator.State.is_module_loaded?(env.state, module_name) and length(module.macros) > 0 -> add_import(env, module_name, [only: :macros]) true -> env end end def function_scope(env, { _, _ } = func) do %{ env | function: func, caller: env, vars: [] } end def function_scope(env, nil) do %{ env | function: nil, caller: env } end def find_module(env, name_arity) do result = Enum.find(env.functions ++ env.macros, fn({_, functions}) -> name_arity in functions end) if result == nil do nil else elem(result, 0) end end def add_var(env, variable_name) when is_binary(variable_name) do add_var(env, String.to_atom(variable_name)) end def add_var(env, variable_name) do %{ env | vars: Keyword.update(env.vars, variable_name, 0, &(&1 + 1)) } end def get_var(env, variable_name) when is_binary(variable_name) do get_var(env, String.to_atom(variable_name)) end def get_var(env, variable_name) do count = Keyword.get(env.vars, variable_name, nil) case count do nil -> nil 0 -> String.to_atom(Atom.to_string(variable_name)) _ -> String.to_atom(Atom.to_string(variable_name) <> to_string(count)) end end def has_var?(env, variable_name) when is_binary(variable_name) do has_var?(env, String.to_atom(variable_name)) end def has_var?(env, variable_name) do Keyword.get(env.vars, variable_name, nil) != nil end defp get_module(env, Kernel) do get_module(env, ElixirScript.Kernel) end defp get_module(env, module_name) do module = ElixirScript.Translator.State.get_module(env.state, get_module_name(env, module_name)) unless module do module_name = case module_name do {:__aliases__, _, _} -> ElixirScript.Translator.Utils.quoted_to_name(module_name) |> Atom.to_string |> String.split(".") |> tl |> Enum.join(".") _ -> module_name end raise "Module #{inspect module_name} not found" end if Map.get(module, :load_only, false) == false do ElixirScript.Translator.State.add_module_reference(env.state, env.module, module.name) end module end defp has_module?(env, module_name) do try do module = get_module(env, module_name) case module do %{load_only: true} -> false _ -> true end rescue _ -> false end end def add_alias(env, module_name, alias_name) do module = get_module(env, module_name) %{ env | aliases: Enum.uniq(env.aliases ++ [{alias_name, module.name}]) } end def add_import(env, module_name) do check_for_module_existence(env, module_name) env = if ElixirScript.Translator.State.is_module_loaded?(env.state, module_name) do add_import_macro(env, module_name, []) else env end if has_module?(env, module_name) do module = get_module(env, module_name) %{ env | requires: Enum.uniq(env.requires ++ [module.name]), functions: env.functions ++ [{ module.name, module.functions }] } else env end end def add_import(env, module_name, [only: :functions]) do module = get_module(env, module_name) %{ env | functions: List.keydelete(env.functions, module_name, 0) ++ [{ module.name, module.functions }], requires: Enum.uniq(env.requires ++ [module.name]) } end def add_import(env, module_name, [only: :macros]) do if !ElixirScript.Translator.State.is_module_loaded?(env.state, module_name) do raise "Module #{inspect module_name} not found" end add_import_macro(env, module_name, [only: :macros]) end def add_import(env, module_name, [only: only]) do check_for_module_existence(env, module_name) env = if ElixirScript.Translator.State.is_module_loaded?(env.state, module_name) do list = module_name.__info__(:macros) list = Enum.filter(list, fn(mac) -> mac in only end) add_import_macro(env, module_name, [only: list]) else env end if has_module?(env, module_name) do module = get_module(env, module_name) functions = Enum.filter(module.functions, fn(func) -> func in only end) %{ env | requires: Enum.uniq(env.requires ++ [module.name]), functions: List.keydelete(env.functions, module.name, 0) ++ [{ module.name, functions }] } else env end end def add_import(env, module_name, [except: except]) do check_for_module_existence(env, module_name) env = if ElixirScript.Translator.State.is_module_loaded?(env.state, module_name) do list = module_name.__info__(:macros) list = Enum.filter(list, fn(mac) -> mac in except end) add_import_macro(env, module_name, [except: list]) else env end if has_module?(env, module_name) do module = get_module(env, module_name) {_, current_functions } = List.keyfind(env.functions, module.name, 0, { module.name, module.functions }) functions = Enum.filter(current_functions, fn(func) -> not(func in except) end) %{ env | requires: env.requires ++ [module.name], functions: List.keydelete(env.functions, module.name, 0) ++ [{ module.name, functions }] } else env end end def add_require(env, module_name) do check_for_module_existence(env, module_name) env = if ElixirScript.Translator.State.is_module_loaded?(env.state, module_name) do add_require_macro(env, module_name, []) else env end if has_module?(env, module_name) do module = get_module(env, module_name) %{ env | requires: Enum.uniq(env.requires ++ [module.name]) } else env end end def add_require(env, module_name, alias_name) do check_for_module_existence(env, module_name) env = if ElixirScript.Translator.State.is_module_loaded?(env.state, module_name) do add_require_macro(env, module_name, [as: alias_name]) else env end if has_module?(env, module_name) do module = get_module(env, module_name) %{ env | aliases: Enum.uniq(env.aliases ++ [{alias_name, module.name}]), requires: Enum.uniq(env.requires ++ [module.name]) } else env end end def get_module_name(env, module_name) do module_name = ElixirScript.Translator.State.get_module_name(env.state, module_name) if Keyword.has_key?(env.aliases, module_name) do Keyword.fetch!(env.aliases, module_name) else module_name end end defp check_for_module_existence(env, module_name) do if ElixirScript.Translator.State.is_module_loaded?(env.state, module_name) == false and has_module?(env, module_name) == false do raise "Module #{inspect module_name} not found" end end defp add_import_macro(elixirscript_env, module, opts) do eval = """ import #{inspect module}, #{inspect opts} __ENV__ """ do_macro(eval, elixirscript_env) end defp add_require_macro(elixirscript_env, module, opts) do eval = """ require #{inspect module}, #{inspect opts} __ENV__ """ do_macro(eval, elixirscript_env) end defp do_macro(eval, elixirscript_env) do {env, _} = Code.eval_string(eval, [], elixirscript_env.env) %{ elixirscript_env | env: env } end end elixirscript-0.25.0/lib/elixir_script/translator/pattern_matching.ex000066400000000000000000000153551305236071500260360ustar00rootroot00000000000000defmodule ElixirScript.Translator.PatternMatching do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator alias ElixirScript.Translator.Primitive alias ElixirScript.Translator.Identifier alias ElixirScript.Translator.Map alias ElixirScript.Translator.Struct alias ElixirScript.Translator.Bitstring @patterns JS.member_expression( JS.member_expression( JS.identifier("Elixir"), JS.identifier("Core") ), JS.identifier("Patterns") ) @wildcard JS.member_expression( @patterns, JS.identifier(:wildcard) ) @parameter JS.member_expression( @patterns, JS.identifier(:variable) ) @head_tail JS.member_expression( @patterns, JS.identifier(:headTail) ) @starts_with JS.member_expression( @patterns, JS.identifier(:startsWith) ) @capture JS.member_expression( @patterns, JS.identifier(:capture) ) @bound JS.member_expression( @patterns, JS.identifier(:bound) ) @_type JS.member_expression( @patterns, JS.identifier(:type) ) @bitstring_match JS.member_expression( @patterns, JS.identifier(:bitStringMatch) ) def wildcard() do JS.call_expression( @wildcard, [] ) end def parameter() do JS.call_expression( @parameter, [] ) end def parameter(default_value) do JS.call_expression( @parameter, [default_value] ) end def head_tail(headParameter, tailParameter) do JS.call_expression( @head_tail, [headParameter, tailParameter] ) end def starts_with(prefix) do JS.call_expression( @starts_with, [JS.literal(prefix)] ) end def capture(value) do JS.call_expression( @capture, [value] ) end def bound(value) do JS.call_expression( @bound, [value] ) end def type(prototype, value) do JS.call_expression( @_type, [prototype, value] ) end def bitstring_match(values) do JS.call_expression( @bitstring_match, values ) end def process_match(params, env) do build_match(params, env) |> update_env(env) end defp update_env({ patterns, params }, env) do { params, env } = Enum.map_reduce(params, env, fn (%ESTree.Identifier{name: :undefined} = param, env) -> { param, env } (%ESTree.Identifier{} = param, env) -> env = ElixirScript.Translator.LexicalScope.add_var(env, param.name) new_name = ElixirScript.Translator.LexicalScope.get_var(env, param.name) { %{ param | name: new_name }, env } (param, env) -> { param, env } end) { patterns, params, env } end def build_match(params, env) do Enum.map(params, &do_build_match(&1, env)) |> reduce_patterns end defp do_build_match({:^, _, [value]}, env) do { [bound(Translator.translate!(value, env))], [nil] } end defp do_build_match({:_, _, _}, _) do { [wildcard()], [JS.identifier(:undefined)] } end defp do_build_match({:<<>>, _, elements}, env) do params = Enum.reduce(elements, [], fn ({:::, _, [{ variable, _, params }, _]}, state) when is_atom(params) -> state ++ [JS.identifier(variable)] _, state -> state end) elements = Enum.map(elements, fn ({:::, context, [{ _, _, params }, options]}) when is_atom(params) -> Bitstring.make_bitstring_element({:::, context, [ElixirScript.Translator.PatternMatching, options]}, env) x -> Bitstring.make_bitstring_element(x, env) end) { [bitstring_match(elements)], params } end defp do_build_match([{:|, _, [head, tail]}], env) do { head_patterns, head_params } = do_build_match(head, env) { tail_patterns, tail_params } = do_build_match(tail, env) params = head_params ++ tail_params { [head_tail(hd(head_patterns), hd(tail_patterns))], params } end defp do_build_match({:<>, _, [prefix, value]}, env) do { [starts_with(prefix)], [Translator.translate!(value, env)] } end defp do_build_match({:%{}, _, props}, env) do properties = Enum.map(props, fn({key, value}) -> {pattern, params} = do_build_match(value, env) property = case key do {:^, _, [the_key]} -> JS.property(Translator.translate!(the_key, env), hd(List.wrap(pattern)), :init, false, false, true) _ -> Map.make_property(Translator.translate!(key, env), hd(List.wrap(pattern))) end { property, params } end) {props, params} = Enum.reduce(properties, {[], []}, fn({prop, param}, {props, params}) -> { props ++ [prop], params ++ param } end) { JS.object_expression(List.wrap(props)), params } end defp do_build_match({:%, _, [{:__aliases__, _, _} = name, {:%{}, meta, props}]}, env) do struct_name = Struct.get_struct_class(name, env) {pattern, params} = do_build_match({:%{}, meta, props}, env) { [type(struct_name, pattern)], params } end defp do_build_match({:=, _, [{name, _, _}, right]}, env) when not name in [:%, :{}, :__aliases__, :^, :%{}] do unify(name, right, env) end defp do_build_match({:=, _, [left, {name, _, _}]}, env) when not name in [:%, :{}, :__aliases__, :^, :%{}] do unify(name, left, env) end defp do_build_match(list, env) when is_list(list) do { patterns, params } = list |> Enum.map(&build_match([&1], env)) |> reduce_patterns {[Primitive.make_list_no_translate(patterns)], params} end defp do_build_match(term, env) when is_number(term) or is_binary(term) or is_boolean(term) or is_atom(term) or is_nil(term) do { [Translator.translate!(term, env)], [] } end defp do_build_match({ one, two }, env) do do_build_match({:{}, [], [one, two]}, env) end defp do_build_match({:{}, _, list}, env) do { patterns, params } = list |> Enum.map(&build_match([&1], env)) |> reduce_patterns pattern = JS.object_expression([ JS.property( JS.identifier("values"), JS.array_expression(patterns) ) ]) { [type(Primitive.tuple_class, pattern)], params } end defp do_build_match({:\\, _, [{name, _, _}, default]}, env) do { [parameter(Translator.translate!(default, env))], [Identifier.make_identifier(name)] } end defp do_build_match({name, _, _}, _) do { [parameter()], [Identifier.make_identifier(name)] } end defp reduce_patterns(patterns) do patterns |> Enum.reduce({ [], [] }, fn({ pattern, new_param }, { patterns, new_params }) -> { patterns ++ List.wrap(pattern), new_params ++ List.wrap(new_param) } end) end defp unify(target, source, env) do { patterns, params } = build_match([source], env) { [capture(hd(patterns))], params ++ [Identifier.make_identifier(target)] } end end elixirscript-0.25.0/lib/elixir_script/translator/rewriter.ex000066400000000000000000000400101305236071500243340ustar00rootroot00000000000000defmodule ElixirScript.Translator.Rewriter do @moduledoc false # :erlang, :lists, :maps, :beam_lib, :binary, :calendar, :digraph, # :epp, :erl_lint, :erl_internal, :erl_expand_records, :erl_eval, # :ets, :filename, :gen_event, :gen_server, :io, :io_lib, :math, # :ordsets, :proc_lib, :rand, :re, :sets, :supervisor,:sys, :timer, # :unicode, :os, :application, :code, :gen_tcp, :error_logger, :gen, # :file # http://erlang.org/doc/applications.html def rewrite({{:., _, [:erlang, :abs]}, _, [number]}) do quote do: Math.abs(unquote(number)) end def rewrite({{:., _, [:erlang, :apply]}, _, [fun, args]}) do quote do: unquote(fun).apply(nil, unquote(args)) end def rewrite({{:., _, [:erlang, :apply]}, _, [module, fun, args]}) do quote do: unquote(module).unquote(fun).apply(nil, unquote(args)) end def rewrite({{:., _, [:erlang, :binary_part]}, _, [binary, start, length]})do quote do: unquote(binary).substring(unquote(start), unquote(length)) end def rewrite({{:., _, [:erlang, :bit_size]}, _, [bitstring]})do quote do: unquote(bitstring).bit_size end def rewrite({{:., _, [:erlang, :byte_size]}, _, [bitstring]})do quote do: unquote(bitstring).byte_size end def rewrite({{:., _, [:erlang, :div]}, _, [left, right]}) do quote do: unquote(left) / unquote(right) end def rewrite({{:., _, [:erlang, :exit]}, _, [reason]}) do # TODO: implement exit quote do: nil end def rewrite({{:., _, [:erlang, :hd]}, _, [list]}) do quote do: unquote(list)[0] end def rewrite({{:., _, [:erlang, :is_atom]}, _, [term]}) do quote do: JS.typeof(unquote(term)) === "symbol" end def rewrite({{:., _, [:erlang, :is_binary]}, _, [term]}) do quote do: JS.typeof(unquote(term)) === "string" end def rewrite({{:., _, [:erlang, :is_bitstring]}, _, [term]}) do quote do: is_binary(unquote(term)) || JS.instanceof(unquote(term), Elixir.Core.BitString) end def rewrite({{:., _, [:erlang, :is_boolean]}, _, [term]}) do quote do: JS.typeof(unquote(term)) === "boolean" || JS.instanceof(unquote(term), Boolean) end def rewrite({{:., _, [:erlang, :is_float]}, _, [term]}) do quote do: (JS.typeof(unquote(term)) === "number" || JS.instanceof(unquote(term), Number)) && !Number.isInteger(unquote(term)) end def rewrite({{:., _, [:erlang, :is_function]}, _, [term]}) do quote do: JS.typeof(unquote(term)) === "function" || JS.instanceof(unquote(term), Function) end def rewrite({{:., _, [:erlang, :is_function]}, _, [term, _]}) do quote do: JS.typeof(unquote(term)) === "function" || JS.instanceof(unquote(term), Function) end def rewrite({{:., _, [:erlang, :is_integer]}, _, [term]}) do quote do: Number.isInteger(unquote(term)) end def rewrite({{:., _, [:erlang, :is_list]}, _, [term]}) do quote do: Array.isArray(unquote(term)) end def rewrite({{:., _, [:erlang, :is_number]}, _, [term]}) do quote do: JS.typeof(unquote(term)) === "number" || JS.instanceof(unquote(term), Number) end def rewrite({{:., _, [:erlang, :is_pid]}, _, [term]}) do quote do: JS.instanceof(unquote(term), Elixir.Core.PID) end def rewrite({{:., _, [:erlang, :is_port]}, _, [_term]}) do #TODO implement is_port quote do: false end def rewrite({{:., _, [:erlang, :is_reference]}, _, [_term]}) do #TODO implement is_reference quote do: false end def rewrite({{:., _, [:erlang, :is_tuple]}, _, [term]}) do quote do: JS.instanceof(unquote(term), Elixir.Core.Tuple) end def rewrite({{:., _, [:erlang, :is_map]}, _, [term]}) do quote do: JS.typeof(unquote(term)) === "object" || JS.instanceof(unquote(term), Object) end def rewrite({{:., _, [:erlang, :length]}, _, [list]}) do quote do: unquote(list).length end def rewrite({{:., _, [:erlang, :make_ref]}, _, []}) do #TODO: implement make_ref quote do: nil end def rewrite({{:., _, [:erlang, :map_size]}, _, [map]}) do quote do: Object.keys(unquote(map)).length end def rewrite({{:., _, [:erlang, :max]}, _, [first, second]}) do quote do: Math.max(unquote(first), unquote(second)) end def rewrite({{:., _, [:erlang, :min]}, _, [first, second]}) do quote do: Math.min(unquote(first), unquote(second)) end def rewrite({{:., _, [:erlang, :node]}, _, []}) do quote do: :nonode@nohost end def rewrite({{:., _, [:erlang, :node]}, _, [_]}) do quote do: :nonode@nohost end def rewrite({{:., _, [:erlang, :rem]}, _, [first, second]}) do {:%, [], [first, second]} end def rewrite({{:., _, [:erlang, :round]}, _, [number]}) do quote do: Math.round(unquote(number)) end def rewrite({{:., _, [:erlang, :send]}, _, [dest, msg]}) do #TODO implement send quote do: unquote(msg) end def rewrite({{:., _, [:erlang, :self]}, _, []}) do #TODO: implement self quote do: nil end def rewrite({{:., _, [:erlang, :spawn]}, _, [_fun]}) do #TODO: implement spawn quote do: nil end def rewrite({{:., _, [:erlang, :spawn]}, _, [_module, _fun, _args]}) do #TODO: implement spawn quote do: nil end def rewrite({{:., _, [:erlang, :spawn_link]}, _, [_fun]}) do #TODO: implement spawn_link quote do: nil end def rewrite({{:., _, [:erlang, :spawn_link]}, _, [_module, _fun, _args]}) do #TODO: implement spawn_link quote do: nil end def rewrite({{:., _, [:erlang, :spawn_monitor]}, _, [_fun]}) do #TODO: implement spawn_monitor quote do: nil end def rewrite({{:., _, [:erlang, :spawn_monitor]}, _, [_module, _fun, _args]}) do #TODO: implement spawn_monitor quote do: nil end def rewrite({{:., _, [:erlang, :throw]}, _, [term]}) do quote do: JS.throw(unquote(term)) end def rewrite({{:., _, [:erlang, :tl]}, _, [list]}) do quote do: unquote(list).splice(1) end def rewrite({{:., _, [:erlang, :trunc]}, _, [number]}) do quote do: Math.floor(unquote(number)) end def rewrite({{:., _, [:erlang, :tuple_size]}, _, [tuple]}) do quote do: unquote(tuple).length end def rewrite({{:., _, [:erlang, operator]}, _, [left, right]}) when operator in [:+, :-, :*, :/, :<, :>, :>=, :==] do {operator, [], [left, right]} end def rewrite({{:., _, [:erlang, operator]}, _, [value]}) when operator in [:+, :-] do {operator, [], [value]} end def rewrite({{:., _, [:erlang, :++]}, _, [left, right]}) do quote do: unquote(left).concat(unquote(right)) end def rewrite({{:., _, [:erlang, :--]}, _, [list, element]}) do quote do: unquote(list).slice(unquote(list).indexOf(unquote(element)) + 1) end def rewrite({{:., _, [:erlang, :not]}, _, [value]}) do {:!, [], [value]} end def rewrite({{:., _, [:erlang, :"=<"]}, _, [left, right]}) do {:<=, [], [left, right]} end def rewrite({{:., _, [:erlang, :"/="]}, _, [left, right]}) do {:!=, [], [left, right]} end def rewrite({{:., _, [:erlang, :"=:="]}, _, [left, right]}) do {:===, [], [left, right]} end def rewrite({{:., _, [:erlang, :"=/="]}, _, [left, right]}) do {:!==, [], [left, right]} end def rewrite({{:., _, [:erlang, :element]}, _, [index, tuple]}) do quote do: unquote(tuple).get(unquote(index) - 1) end def rewrite({{:., _, [:erlang, :setelement]}, _, [index, tuple, value]}) do quote do: unquote(tuple).put_elem(unquote(index) - 1, unquote(value)) end def rewrite({{:., _, [:erlang, :orelse]}, _, [left, right]}) do {:||, [], [left, right]} end def rewrite({{:., _, [:erlang, :or]}, _, [left, right]}) do {:||, [], [left, right]} end def rewrite({{:., _, [:erlang, :andalso]}, _, [left, right]}) do {:&&, [], [left, right]} end def rewrite({{:., _, [:erlang, :error]}, _, [error]}) do quote do: JS.throw(unquote(error)) end def rewrite({{:., _, [:erlang, :raise]}, _, [_class, reason, _stacktrace]}) do quote do: JS.throw(unquote(reason)) end def rewrite({{:., _, [:erlang, :atom_to_binary]}, _, [atom, _]}) do quote do: Symbol.keyFor(unquote(atom)) end def rewrite({{:., _, [:erlang, :atom_to_list]}, _, [atom]}) do quote do: to_string(unquote(atom)).split("") end def rewrite({{:., _, [:erlang, :bnot]}, _, [expr]}) do {:"~", [], [expr]} end def rewrite({{:., _, [:erlang, :band]}, _, [left, right]}) do {:&, [], [left, right]} end def rewrite({{:., _, [:erlang, :bor]}, _, [left, right]}) do {:|, [], [left, right]} end def rewrite({{:., _, [:erlang, :bxor]}, _, [left, right]}) do {:^, [], [left, right]} end def rewrite({{:., _, [:erlang, :bsl]}, _, [left, right]}) do {:"<<", [], [left, right]} end def rewrite({{:., _, [:erlang, :bsr]}, _, [left, right]}) do {:">>", [], [left, right]} end def rewrite({{:., _, [:erlang, :function_exported]}, _, [_, _, _]}) do quote do: true end def rewrite({{:., _, [:erlang, :make_tuple]}, _, [size, data]}) do quote do: JS.new(Elixir.Core.Tuple, List.duplicate(unquote(size), unquote(data))) end def rewrite({{:., _, [:erlang, :insert_element]}, _, [index, tuple, term]}) do quote do: unquote(tuple).put_elem(unquote(index) - 1, unquote(term)) end def rewrite({{:., _, [:erlang, :tuple_to_list]}, _, [tuple]}) do quote do: unquote(tuple).values end def rewrite({{:., _, [:erlang, :append_element]}, _, [tuple, value]}) do quote do: unquote(tuple).put_elem(unquote(tuple).length, unquote(value)) end def rewrite({{:., _, [:erlang, :delete_element]}, _, [index, tuple]}) do quote do: unquote(tuple).remove_elem(unquote(index)) end def rewrite({{:., _, [:lists, :map]}, _, [fun, list]}) do quote do: unquote(list).map(unquote(fun)) end def rewrite({{:., _, [:lists, :member]}, _, [elem, list]}) do quote do: unquote(list).indexOf(unquote(elem)) > -1 end def rewrite({{:., _, [:lists, :foldl]}, _, [fun, acc, list]}) do quote do: Elixir.Core.Functions.foldl(unquote(fun), unquote(acc), unquote(list)) end def rewrite({{:., _, [:lists, :foldr]}, _, [fun, acc, list]}) do quote do: Elixir.Core.Functions.foldr(unquote(fun), unquote(acc), unquote(list)) end def rewrite({{:., _, [:lists, :keymember]}, _, [key, n, list]}) do quote do: Elixir.Core.Functions.keymember(unquote(key), unquote(n), unquote(list)) end def rewrite({{:., _, [:lists, :keydelete]}, _, [key, n, list]}) do quote do: Elixir.Core.Functions.keydelete(unquote(key), unquote(n), unquote(list)) end def rewrite({{:., _, [:lists, :keystore]}, _, [key, n, list, newtuple]}) do quote do: Elixir.Core.Functions.keystore(unquote(key), unquote(n), unquote(list), unquote(newtuple)) end def rewrite({{:., _, [:lists, :keytake]}, _, [key, n, list]}) do quote do: Elixir.Core.Functions.keystore(unquote(key), unquote(n), unquote(list)) end def rewrite({{:., _, [:lists, :keyfind]}, _, [key, n, list]}) do quote do: Elixir.Core.Functions.keyfind(unquote(key), unquote(n), unquote(list)) end def rewrite({{:., _, [:lists, :keyreplace]}, _, [key, n, list, newtuple]}) do quote do: Elixir.Core.Functions.keyreplace(unquote(key), unquote(n), unquote(list), unquote(newtuple)) end def rewrite({{:., _, [:lists, :keysort]}, _, [n, tuplelist]}) do #TODO: implement keysort quote do: unquote(tuplelist) end def rewrite({{:., _, [:lists, :reverse]}, _, [list]}) do quote do: Elixir.Core.Functions.reverse(unquote(list)) end def rewrite({{:., _, [:lists, :reverse]}, _, [list, tail]}) do quote do: Elixir.Core.Functions.reverse(unquote(list)) ++ unquote(tail) end def rewrite({{:., _, [:lists, :flatten]}, _, [list]}) do quote do: Elixir.Core.Functions.flatten(unquote(list)) end def rewrite({{:., _, [:lists, :flatten]}, _, [list, tail]}) do quote do: Elixir.Core.Functions.flatten(unquote(list), unquote(tail)) end def rewrite({{:., _, [:lists, :delete]}, _, [elem, list]}) do quote do: Elixir.Core.Functions.remove_from_list(unquote(list), unquote(elem)) end def rewrite({{:., _, [:lists, :duplicate]}, _, [n, elem]}) do quote do: Elixir.Core.Functions.duplicate(unquote(n), unquote(elem)) end def rewrite({{:., _, [:lists, :mapfoldl]}, _, [fun, acc, list]}) do quote do: Elixir.Core.Functions.mapfoldl(unquote(fun), unquote(acc), unquote(list)) end def rewrite({{:., _, [:lists, :sort]}, _, [list]}) do quote do: unquote(list).sort() end #TODO: Implement sort def rewrite({{:., _, [:lists, :sort]}, _, [_fun, list]}) do quote do: unquote(list) end def rewrite({{:., _, [:lists, :filter]}, _, [pred, list]}) do quote do: unquote(list).filter(unquote(pred)) end def rewrite({{:., _, [:lists, :filtermap]}, _, [fun, list]}) do quote do: Elixir.Core.Functions.filtermap(unquote(fun), unquote(list)) end def rewrite({{:., _, [:lists, :concat]}, _, [things]}) do quote do: unquote(things).join("") end def rewrite({{:., _, [:erlang, :binary_to_atom]}, _, [binary, _]}) do quote do: Symbol.for(unquote(binary)) end def rewrite({{:., _, [:erlang, :binary_to_existing_atom]}, _, [binary, _]}) do quote do: Symbol.for(unquote(binary)) end def rewrite({{:., _, [:erlang, :list_to_atom]}, _, [char_list]}) do quote do: Symbol.for(unquote(char_list)) end def rewrite({{:., _, [:erlang, :list_to_existing_atom]}, _, [char_list]}) do quote do: Symbol.for(unquote(char_list)) end def rewrite({{:., _, [:erlang, :list_to_tuple]}, _, [list]}) do quote do: JS.new(Elixir.Core.Tuple, unquote(list)) end def rewrite({{:., _, [:erlang, :list_to_float]}, _, [list]}) do quote do: parseFloat(unquote(list)) end def rewrite({{:., _, [:erlang, :list_to_integer]}, _, [list]}) do quote do: parseInt(unquote(list)) end def rewrite({{:., _, [:erlang, :list_to_integer]}, _, [list, base]}) do quote do: parseInt(unquote(list), unquote(base)) end def rewrite({{:., _, [:erlang, :integer_to_binary]}, _, [integer]}) do quote do: unquote(integer).toString() end def rewrite({{:., _, [:erlang, :integer_to_binary]}, _, [integer, base]}) do quote do: unquote(integer).toString(unquote(base)) end def rewrite({{:., _, [:erlang, :integer_to_list]}, _, [integer]}) do quote do: unquote(integer).toString() end def rewrite({{:., _, [:erlang, :integer_to_list]}, _, [integer, base]}) do quote do: unquote(integer).toString(unquote(base)) end def rewrite({{:., _, [:erlang, :float_to_binary]}, _, [float]}) do quote do: unquote(float).toString() end def rewrite({{:., _, [:erlang, :float_to_binary]}, _, [float, base]}) do quote do: unquote(float).toString(unquote(base)) end def rewrite({{:., _, [:erlang, :float_to_list]}, _, [float]}) do quote do: unquote(float).toString() end def rewrite({{:., _, [:erlang, :float_to_list]}, _, [float, base]}) do quote do: unquote(float).toString(unquote(base)) end def rewrite({{:., _, [:erlang, :binary_to_float]}, _, [binary]}) do quote do: parseFloat(unquote(binary)) end def rewrite({{:., _, [:erlang, :binary_to_integer]}, _, [binary]}) do quote do: parseInt(unquote(binary)) end def rewrite({{:., _, [:erlang, :binary_to_integer]}, _, [binary, base]}) do quote do: parseInt(unquote(binary), unquote(base)) end def rewrite({{:., _, [:maps, :is_key]}, _, [key, map]}) do quote do: unquote(key) in Elixir.Core.Functions.get_object_keys(unquote(map)) end def rewrite({{:., _, [:maps, :put]}, _, [key, value, map]}) do quote do: Elixir.Core.Functions.add_property_to_map(unquote(map), unquote(key), unquote(value)) end def rewrite({{:., _, [:maps, :update]}, _, [key, value, map]}) do quote do: Elixir.Core.Functions.update_map(unquote(map), unquote(key), unquote(value)) end def rewrite({{:., _, [:maps, :find]}, _, [key, map]}) do quote do: Elixir.Core.Functions.maps_find(unquote(key), unquote(map)) end def rewrite({{:., _, [:maps, :remove]}, _, [key, map]}) do quote do: Elixir.Core.Functions.delete_property_from_map(unquote(map), unquote(key)) end def rewrite({{:., _, [:maps, :fold]}, _, [fun, init, map]}) do quote do: Elixir.Core.Functions.maps_fold(unquote(fun), unquote(init), unquote(map)) end def rewrite({{:., _, [:maps, :from_list]}, _, [list]}) do quote do: Elixir.Core.Functions.maps_fold(unquote(list)) end end elixirscript-0.25.0/lib/elixir_script/translator/state.ex000066400000000000000000000135271305236071500236260ustar00rootroot00000000000000# This agent holds references to the compiler options, a map all of the modules, and # a map of modules that define the standard library. # # The modules map has the module's name a the key and a ElixirScript.Module struct as the value. # # The std_lib_map holds a mapping of the Elixir standard lib module to the # version implemented here in ElixirScript. defmodule ElixirScript.Translator.State do @moduledoc false alias ElixirScript.Translator.Utils def start_link(compiler_opts, loaded_modules) do Agent.start_link(fn -> %{ compiler_opts: compiler_opts, modules: Keyword.new, std_lib_map: build_standard_lib_map(), loaded_modules: [JS | loaded_modules] } end) end def serialize(pid) do Agent.get(pid, fn(state) -> modules = state.modules modules = Enum.map(modules, fn {m, d} -> d = Map.delete(d, :javascript_ast) |> Map.delete(:javascript_code) |> Map.delete(:javascript_name) {m, d} end) |> Enum.filter(fn {_, d} -> d.type != :consolidated end) state = Map.delete(state, :changed_modules) |> Map.put(:modules, modules) :erlang.term_to_binary(state) end) end def deserialize(pid, frozen_state, loaded_modules \\ []) do Agent.update(pid, fn state -> frozen_state = :erlang.binary_to_term(frozen_state) modules = Keyword.delete(frozen_state.modules, ElixirScript.Temp) %{ state | modules: modules, std_lib_map: frozen_state.std_lib_map, loaded_modules: [JS | loaded_modules] } end) end defp build_standard_lib_map() do Map.new |> Map.put(Kernel, ElixirScript.Kernel) |> Map.put(Tuple, ElixirScript.Tuple) |> Map.put(Atom, ElixirScript.Atom) |> Map.put(Collectable, ElixirScript.Collectable) |> Map.put(String.Chars, ElixirScript.String.Chars) |> Map.put(Enumerable, ElixirScript.Enumerable) |> Map.put(Integer, ElixirScript.Integer) |> Map.put(Macro.Env, ElixirScript.Macro.Env) |> Map.put(View, ElixirScript.View) |> Map.put(Agent, ElixirScript.Agent) |> Map.put(Range, ElixirScript.Range) |> Map.put(String, ElixirScript.String) |> Map.put(Base, ElixirScript.Base) |> Map.put(Module, ElixirScript.Module) |> Map.put(Map, ElixirScript.Map) |> Map.put(Keyword, ElixirScript.Keyword) |> Map.put(Bitwise, ElixirScript.Bitwise) |> Map.put(MapSet, ElixirScript.MapSet) |> Map.put(List, ElixirScript.List) |> Map.put(Process, ElixirScript.Process) |> Map.put(Regex, ElixirScript.Regex) end def set_module_data(pid, module_data) do Agent.update(pid, fn state -> data = Enum.filter(state.modules, fn {module_name, data} -> data.app == :elixir end) %{ state | modules: Keyword.merge(data, module_data) } end) end def get_module_data(pid) do Agent.get(pid, fn state -> state.modules end) end def set_loaded_modules(pid, modules) do Agent.update(pid, fn state -> %{ state | loaded_modules: [ JS | modules ] } end) end def get(pid) do Agent.get(pid, &(&1)) end def get_module_name(pid, {:__aliases__, _, _} = name) do get_module_name(pid, Utils.quoted_to_name(name)) end def get_module_name(pid, module_name) do Agent.get(pid, fn(state) -> do_get_module_name(module_name, state) end) end defp do_get_module_name(module_name, state) do std_lib_map = state.std_lib_map case Map.get(std_lib_map, module_name) do nil -> module_name actual_module_name -> actual_module_name end end def is_module_loaded?(pid, module) when is_atom(module) do Agent.get(pid, fn(state) -> (module in state.loaded_modules) end) end def is_module_loaded?(pid, {:__aliases__, _, _} = module) do is_module_loaded?(pid, Utils.quoted_to_name(module)) end def get_module(pid, module) when is_atom(module) do do_get_module(pid, module) end def get_module(pid, {:__aliases__, _, _} = name) do do_get_module(pid, Utils.quoted_to_name(name)) end def get_module(pid, module_name_list) when is_list(module_name_list) do do_get_module(pid, Utils.quoted_to_name({:__aliases__, [], module_name_list})) end defp do_get_module(pid, name) do Agent.get(pid, fn(state) -> Keyword.get(state.modules, do_get_module_name(name, state)) end) end def add_module_reference(pid, module_name, module_ref) do Agent.update(pid, fn(state) -> case Keyword.get(state.modules, do_get_module_name(module_name, state)) do nil -> state module -> module = Map.update(module, :deps, [module_ref], fn(x) -> Enum.uniq(x ++ [module_ref]) end) modules = Keyword.put(state.modules, module.name, module) %{ state | modules: modules } end end) end def get_module_references(pid, module_name) do case get_module(pid, module_name) do nil -> [] module -> Map.get(module, :deps, []) end end def list_modules(pid) do Agent.get(pid, fn(state) -> Keyword.values(state.modules) end) end def list_module_names(pid) do Agent.get(pid, fn(state) -> Keyword.keys(state.modules) end) end def stop(pid) do Agent.stop(pid) end def add_javascript_module_reference(pid, module_name, name, path, default \\ true) do Agent.update(pid, fn(state) -> case Keyword.get(state.modules, do_get_module_name(module_name, state)) do nil -> state module -> module = Map.update(module, :js_modules, [{name, path, default}], fn(x) -> Enum.uniq(x ++ [{name, path, default}]) end) modules = Keyword.put(state.modules, module.name, module) %{ state | modules: modules } end end) end def get_javascript_module_references(pid, module_name) do case get_module(pid, module_name) do nil -> [] module -> Map.get(module, :js_modules, []) end end end elixirscript-0.25.0/lib/elixir_script/translator/unsupported_error.ex000066400000000000000000000003441305236071500263000ustar00rootroot00000000000000defmodule ElixirScript.Translator.UnsupportedError do defexception [:message] def exception(value) do msg = "Currently unsupported #{inspect value}" %ElixirScript.Translator.UnsupportedError{message: msg} end end elixirscript-0.25.0/lib/elixir_script/translator/utils.ex000066400000000000000000000031121305236071500236330ustar00rootroot00000000000000defmodule ElixirScript.Translator.Utils do @moduledoc false def quoted_to_name(the_alias) do {name, _} = Code.eval_quoted(the_alias) name end def name_to_quoted(name) when is_list(name) do { :__aliases__, [], name } end def name_to_quoted(name) do name = name |> Atom.to_string |> String.split(".") |> tl |> Enum.map(fn x -> String.to_atom(x) end) { :__aliases__, [], name } end def name_to_js_name(name) do { :__aliases__, _, name } = name_to_quoted(name) Enum.join([:Elixir] ++ name, "$") end def name_to_js_file_name(name) do { :__aliases__, _, name } = name_to_quoted(name) Enum.join([:Elixir] ++ name, ".") end def make_local_file_path(module_app_name, file_name, env) do root = ElixirScript.Translator.State.get(env.state).compiler_opts.root app_name = if is_binary(module_app_name), do: module_app_name, else: to_string(module_app_name) case root do nil -> Path.join(["..", app_name, file_name]) root -> Path.join([root, app_name, file_name]) end end def make_local_file_path(file_name, env) do root = ElixirScript.Translator.State.get(env.state).compiler_opts.root case root do nil -> Path.join([".", file_name]) root -> Path.join([root, file_name]) end end def make_local_file_path(module_app_name, file_name, root, _) do app_name = to_string(module_app_name) case root do nil -> Path.join(["..", app_name, file_name]) root -> Path.join([root, app_name, file_name]) end end end elixirscript-0.25.0/lib/elixir_script/watcher.ex000066400000000000000000000021011305236071500217340ustar00rootroot00000000000000defmodule ElixirScript.Watcher do use GenServer require Logger @moduledoc """ Watches the input folder for changes and calls the ElixirScript compiler """ def start_link(input, options) do GenServer.start_link(__MODULE__, [input: input, options: options]) end def init(args) do {:ok, _} = Application.ensure_all_started(:elixir_script) {:ok, _} = Application.ensure_all_started(:fs) :fs.subscribe() {:ok, args} end def handle_info({_pid, {:fs, :file_event}, {path, event}}, state) do try do if input_changed?(to_string(path), state) do Logger.debug "Event: #{inspect event} Path: #{path}" ElixirScript.compile_path(state[:input], state[:options]) end rescue x -> Logger.error(x.message) end {:noreply, state} end defp input_changed?(path, state) do file = Path.basename(path) case file do "." <> _ -> false _ -> Enum.any?(List.wrap(state[:input]), fn(x) -> path == Path.absname(Path.join([x, file])) end) end end end elixirscript-0.25.0/lib/mix/000077500000000000000000000000001305236071500156645ustar00rootroot00000000000000elixirscript-0.25.0/lib/mix/tasks/000077500000000000000000000000001305236071500170115ustar00rootroot00000000000000elixirscript-0.25.0/lib/mix/tasks/compile.elixir_script.ex000066400000000000000000000054151305236071500236630ustar00rootroot00000000000000defmodule Mix.Tasks.Compile.ElixirScript do use Mix.Task @moduledoc """ Mix compiler to allow mix to compile Elixirscript source files into JavaScript Looks for an `elixir_script` or `elixirscript` key in your mix project config def project do [ app: :my_app, version: "0.1.0", elixir: "~> 1.0", deps: deps, elixir_script: [ input: "src/exjs", output: "dest/js"], compilers: [:elixir_script] ++ Mix.compilers ] end Available options are: * `input`: The folder to look for Elixirscript files in. (defaults to `lib/elixirscript`) * `output`: The folder to place generated JavaScript code in. (defaults to `priv/elixirscript`) * `format`: The module format of generated JavaScript code. (defaults to `:es`). Choices are: * `:es` - ES Modules * `:common` - CommonJS * `:umd` - UMD The mix compiler will also compile any dependencies that have the elixirscript compiler in its mix compilers as well """ @spec run(any()) :: :ok def run(_) do elixirscript_config = get_elixirscript_config() elixirscript_base = Path.join([Mix.Project.build_path, "elixirscript"]) File.mkdir_p!(elixirscript_base) elixirscript_path = Path.join([elixirscript_base, "#{Mix.Project.config[:app]}"]) input_path = elixirscript_config |> Keyword.get(:input) |> List.wrap |> Enum.map(fn(path) -> Path.absname(path) end) |> Enum.join("\n") File.write!(elixirscript_path, input_path) paths = [elixirscript_base, "*"] |> Path.join() |> Path.wildcard |> Enum.map(fn(path) -> app = Path.basename(path) paths = path |> File.read!() |> String.split("\n") {app, paths} end) |> Map.new output_path = Keyword.get(elixirscript_config, :output) format = Keyword.get(elixirscript_config, :format) ElixirScript.compile_path(paths, %{output: output_path, format: format}) :ok end def clean do elixirscript_config = get_elixirscript_config() output_path = Keyword.get(elixirscript_config, :output) output_path |> File.ls! |> Enum.each(fn(x) -> if String.contains?(Path.basename(x), "Elixir.") do File.rm!(Path.join(output_path, x)) end end) :ok end defp get_elixirscript_config() do config = Mix.Project.config exjs_config = cond do Keyword.has_key?(config, :elixir_script) -> Keyword.get(config, :elixir_script, []) Keyword.has_key?(config, :elixirscript) -> Keyword.get(config, :elixirscript, []) true -> defaults() end Keyword.merge(defaults(), exjs_config) end defp defaults() do [ input: "lib/elixirscript", output: "priv/elixirscript", format: :es ] end end elixirscript-0.25.0/lib/mix/tasks/elixirscript.ex000066400000000000000000000004711305236071500220720ustar00rootroot00000000000000defmodule Mix.Tasks.Elixirscript do @moduledoc """ A command-line interface to the elixirscript compiler """ use Mix.Task @shortdoc "Translate Elixir to JavaScript" def run(args) do Mix.Task.run "app.start" args |> ElixirScript.CLI.parse_args |> ElixirScript.CLI.process end end elixirscript-0.25.0/lib/mix/tasks/elixirscript.watch.ex000066400000000000000000000026131305236071500231770ustar00rootroot00000000000000defmodule Mix.Tasks.Elixirscript.Watch do use Mix.Task @shortdoc "Watches ElixirScript files for changes" @moduledoc """ Watches ElixirScript files for changes Looks for the `elixir_script` key in your mix project config def project do [ app: :my_app, version: "0.1.0", elixir: "~> 1.0", deps: deps, elixir_script: [ input: "src/exjs", output: "dest/js"], compilers: [:elixir_script] ++ Mix.compilers ] end """ def run(_) do Mix.Task.run "app.start" elixirscript_config = get_elixirscript_config() input_path = Keyword.get(elixirscript_config, :input) output_path = Keyword.get(elixirscript_config, :output) format = Keyword.get(elixirscript_config, :format) {:ok, _} = ElixirScript.Watcher.start_link(input_path, %{output: output_path, format: format}) :timer.sleep :infinity end defp get_elixirscript_config() do config = Mix.Project.config exjs_config = cond do Keyword.has_key?(config, :elixir_script) -> Keyword.get(config, :elixir_script, []) Keyword.has_key?(config, :elixirscript) -> Keyword.get(config, :elixirscript, []) true -> defaults() end Keyword.merge(defaults(), exjs_config) end defp defaults() do [ input: "lib/elixirscript", output: "priv/elixirscript", format: :es ] end end elixirscript-0.25.0/lib/std_lib/000077500000000000000000000000001305236071500165075ustar00rootroot00000000000000elixirscript-0.25.0/lib/std_lib/agent.ex000066400000000000000000000021571305236071500201500ustar00rootroot00000000000000defmodule ElixirScript.Agent do @moduledoc false require JS def start(fun, options \\ []) do pid = JS.new Elixir.Core.PID, [] name = if Elixir.Keyword.has_key?(options, :name) do Elixir.Keyword.get(options, :name) else nil end Elixir.Core.Store.create(pid, fun.(), name) { :ok, pid } end def start_link(fun, options \\ []) do pid = JS.new Elixir.Core.PID, [] name = if Elixir.Keyword.has_key?(options, :name) do Elixir.Keyword.get(options, :name) else nil end Elixir.Core.Store.create(pid, fun.(), name) { :ok, pid } end def stop(agent) do Elixir.Core.Store.remove(agent) :ok end def update(agent, fun) do current_state = Elixir.Core.Store.read(agent) Elixir.Core.Store.update(agent, fun.(current_state)) :ok end def get(agent, fun) do current_state = Elixir.Core.Store.read(agent) fun.(current_state) end def get_and_update(agent, fun) do current_state = Elixir.Core.Store.read(agent) {val, new_state} = fun.(current_state) Elixir.Core.Store.update(agent, new_state) val end end elixirscript-0.25.0/lib/std_lib/atom.ex000066400000000000000000000003321305236071500200030ustar00rootroot00000000000000defmodule ElixirScript.Atom do @moduledoc false import Kernel, except: [to_string: 1] def to_char_list(atom) do to_string(atom).split("") end def to_string(atom) do Symbol.keyFor(atom) end end elixirscript-0.25.0/lib/std_lib/base.ex000066400000000000000000000005131305236071500177560ustar00rootroot00000000000000defmodule ElixirScript.Base do @moduledoc false def encode64(data) do Elixir.Core.b64EncodeUnicode(data) end def decode64(data) do if Elixir.Core.can_decode64(data) do {:ok, decode64!(data) } else :error end end def decode64!(data) do Elixir.Core.get_global().atob(data) end end elixirscript-0.25.0/lib/std_lib/bitwise.ex000066400000000000000000000025111305236071500205120ustar00rootroot00000000000000defmodule ElixirScript.Bitwise do @moduledoc false defmacro bnot(expr) do quote do Elixir.Core.bnot(unquote(expr)) end end defmacro ~~~(expr) do quote do Elixir.Core.bnot(unquote(expr)) end end defmacro band(left, right) do quote do Elixir.Core.band(unquote(left), unquote(right)) end end defmacro left &&& right do quote do Elixir.Core.band(unquote(left), unquote(right)) end end defmacro bor(left, right) do quote do Elixir.Core.bor(unquote(left), unquote(right)) end end defmacro left ||| right do quote do Elixir.Core.bor(unquote(left), unquote(right)) end end defmacro bxor(left, right) do quote do Elixir.Core.bxor(unquote(left), unquote(right)) end end defmacro left ^^^ right do quote do Elixir.Core.bxor(unquote(left), unquote(right)) end end defmacro bsl(left, right) do quote do Elixir.Core.bsl(unquote(left), unquote(right)) end end defmacro left <<< right do quote do Elixir.Core.bsl(unquote(left), unquote(right)) end end defmacro bsr(left, right) do quote do Elixir.Core.bsr(unquote(left), unquote(right)) end end defmacro left >>> right do quote do Elixir.Core.bsr(unquote(left), unquote(right)) end end end elixirscript-0.25.0/lib/std_lib/collectable.ex000066400000000000000000000013331305236071500213160ustar00rootroot00000000000000defprotocol ElixirScript.Collectable do @moduledoc false def into(collectable) end defimpl ElixirScript.Collectable, for: List do def into(original) do {[], fn list, {:cont, x} -> list ++ [x] list, :done -> original ++ list _, :halt -> :ok end} end end defimpl ElixirScript.Collectable, for: BitString do def into(original) do {original, fn acc, {:cont, x} when is_bitstring(x) -> <> acc, :done -> acc _, :halt -> :ok end} end end defimpl ElixirScript.Collectable, for: Map do def into(original) do {original, fn map, {:cont, {k, v}} -> Map.put(map, k, v) map, :done -> map _, :halt -> :ok end} end endelixirscript-0.25.0/lib/std_lib/enumerable.ex000066400000000000000000000023161305236071500211660ustar00rootroot00000000000000defprotocol ElixirScript.Enumerable do @moduledoc false def reduce(enumerable, acc, fun) def member?(enumerable, element) def count(enumerable) end defimpl ElixirScript.Enumerable, for: List do def count(list), do: length(list) def member?(list, value), do: value in list def reduce(_, {:halt, acc}, _fun), do: {:halted, acc} def reduce(list, {:suspend, acc}, fun), do: {:suspended, acc, &reduce(list, &1, fun)} def reduce([], {:cont, acc}, _fun), do: {:done, acc} def reduce([h | t], {:cont, acc}, fun), do: reduce(t, fun.(h, acc), fun) end defimpl ElixirScript.Enumerable, for: Map do def count(map) do {:ok, map_size(map)} end def member?(map, {key, value}) do {:ok, match?(^value, Map.get(map, key))} end def member?(_, _) do {:ok, false} end def reduce(map, acc, fun) do do_reduce(Map.to_list(map), acc, fun) end defp do_reduce(_, {:halt, acc}, _fun), do: {:halted, acc} defp do_reduce(list, {:suspend, acc}, fun), do: {:suspended, acc, &do_reduce(list, &1, fun)} defp do_reduce([], {:cont, acc}, _fun), do: {:done, acc} defp do_reduce([h | t], {:cont, acc}, fun), do: do_reduce(t, fun.(h, acc), fun) end elixirscript-0.25.0/lib/std_lib/integer.ex000066400000000000000000000012411305236071500205000ustar00rootroot00000000000000defmodule ElixirScript.Integer do @moduledoc false def is_even(number) do rem(number, 2) == 0 end def is_odd(number) do rem(number, 2) != 0 end def to_char_list(number) do to_char_list(number, 10) end def to_char_list(number, base) do number.toString(base).split('') end def parse(bin) do result = Elixir.Core.Functions.get_global().parseInt(bin) if Elixir.Core.Functions.get_global().isNaN(result) do :error else case bin.indexOf(".") do index_of_dot when index_of_dot < 0 -> {result, ""} index_of_dot -> {result, bin.substring(index_of_dot)} end end end end elixirscript-0.25.0/lib/std_lib/js.ex000066400000000000000000000055661305236071500174750ustar00rootroot00000000000000defmodule JS do @moduledoc """ This module defines macros and functions which implement JavaScript functionality that may not translate easily to Elixir. For instance, creating a new object, or updating an existing one. """ @doc """ Creates new JavaScript objects. ex: JS.new User, ["first_name", "last_name"] """ defmacro new(module, params) do end @doc """ Updates an existing JavaScript object. ex: JS.update elem, %{"width" => 100} """ defmacro update(object, map) do end @doc """ Imports a JavaScript module. Elixir modules can use the normal `import`, `alias` and `require`, but JavaScript modules work differently and have to be imported using this. If `default` is set to true then it is treated as a default import. Otherwise it is treated as a namespace import. ex: JS.import A, "a" #translates to "import A from 'a'" JS.import A, "a", default: false #translates to "import * as A from 'a'" """ defmacro import(module, from, opts \\ [default: true]) do end @doc """ Returns the type of the given value """ defmacro typeof(value) do end @doc """ Determines if value is an instance of type. """ defmacro instanceof(value, type) do end @doc """ Throws the term given """ defmacro throw(term) do end @doc """ Returns a reference to the global JavaScript object. In browsers this would be window or self. In node this would be the global object. """ def global() do Elixir.Core.Functions.get_global() end @doc """ Defines a generator. This is compiled into a generator function in JavaScript. defgen and defgenp are currently the only ways to use process in Elixirscript right now. """ defmacro defgen(call, expr \\ nil) do quote do def unquote(call), unquote(expr) end end @doc """ Defines a private generator. This is compiled into a generator function in JavaScript. """ defmacro defgenp(call, expr \\ nil) do quote do defp unquote(call), unquote(expr) end end @doc """ Determines if term is a generator """ def is_generator(term) do term.constructor.name === "GeneratorFunction" end @doc """ Yields the current generator function """ defmacro yield() do end @doc """ Yields the current generator function with the given term """ defmacro yield(term) do end @doc """ Yields control to the given generator """ defmacro yield_to(gen) do end @doc """ Provides a convenient way to create a string-based map. Elixirscript, by default turns the following, `%{a: "b"}` into `{[Symbol.for("a")]: "b"}` in JavaScript. In order to get string keys, one would have to do `%{"a" => "b"}` which turns into `{a: "b"}` in JavaScript. With `Kernel.object`, you can create string keyed maps conveniently, `object(a: "b")` which turns into `{a: "b"}` """ defmacro object(args) do end end elixirscript-0.25.0/lib/std_lib/kernel.ex000066400000000000000000000076151305236071500203360ustar00rootroot00000000000000defmodule ElixirScript.Kernel do @moduledoc false import Kernel, only: [defmodule: 2, def: 1, def: 2, defp: 2, defmacro: 1, defmacro: 2, defmacrop: 2, ||: 2, !: 1, ++: 2, in: 2, &&: 2, ===: 2, @: 1, sigil_r: 2] require JS defmacro if(condition, clauses) do build_if(condition, clauses) end defp build_if(condition, do: do_clause) do build_if(condition, do: do_clause, else: nil) end defp build_if(condition, do: do_clause, else: else_clause) do quote do case unquote(condition) do x when x in [false, nil] -> unquote(else_clause) _ -> unquote(do_clause) end end end defmacro unless(condition, clauses) do build_unless(condition, clauses) end defp build_unless(condition, do: do_clause) do build_unless(condition, do: do_clause, else: nil) end defp build_unless(condition, do: do_clause, else: else_clause) do quote do if(unquote(condition), do: unquote(else_clause), else: unquote(do_clause)) end end def abs(number) do Math.abs(number) end def apply(fun, args) do Elixir.Core.Functions.apply(fun, args) end def apply(module, fun, args) do Elixir.Core.Functions.apply(module, Atom.to_string(fun), args) end def binary_part(binary, start, len) do binary.substring(start, len) end def hd(list) do list[0] end def tl(list) do list.slice(1) end def is_atom(term) do JS.typeof(term) === "symbol" end def is_binary(term) do JS.typeof(term) === "string" end def is_bitstring(term) do is_binary(term) || JS.instanceof(term, Elixir.Core.BitString) end def is_boolean(term) do JS.typeof(term) === "boolean" || JS.instanceof(term, Boolean) end def is_float(term) do is_number(term) && !Number.isInteger(term) end def is_function(term) do is_function(term, 0) end def is_function(term, _) do JS.typeof(term) === "function" || JS.instanceof(term, Function) end def is_integer(term) do Number.isInteger(term) end def is_list(term) do Array.isArray(term) end def is_number(term) do JS.typeof(term) === "number" || JS.instanceof(term, Number) end def is_pid(term) do JS.instanceof(term, Elixir.Core.PID) end def is_tuple(term) do JS.instanceof(term, Elixir.Core.Tuple) end def is_map(term) do JS.typeof(term) === "object" || JS.instanceof(term, Object) end def is_port(_) do false end def is_reference(_) do false end def length(term) do term.length end def map_size(term) do Object.keys(term).length end def max(first, second) do Math.max(first, second) end def min(first, second) do Math.min(first, second) end def round(number) do Math.round(number) end def trunc(number) do Math.floor(number) end def tuple_size(tuple) do Elixir.Core.Functions.size(tuple) end def elem(tuple, index) do Elixir.Core.Functions.apply(tuple, "get", [index]) end def is_nil(term) do term === nil end defmacro sigil_r({:<<>>, _meta, [string]}, options) do str_options = List.to_string(options) quote do Regex.compile!(unquote(string), unquote(str_options)) end end defmacro match?(left, right) do quote do case unquote(right) do unquote(left) -> true _ -> false end end end defmacro to_string(arg) when Kernel.is_binary(arg) do arg end defmacro to_string(arg) do quote do String.Chars.to_string(unquote(arg)) end end defmacro left |> {fun, context, params} do {fun, context, [left] ++ params } end defmacro left in right do quote do Elixir.Core.Functions.contains(unquote(left), unquote(right)) end end defmacro first .. last do quote do %ElixirScript.Range{ first: unquote(first), last: unquote(last) } end end end elixirscript-0.25.0/lib/std_lib/keyword.ex000066400000000000000000000012671305236071500205370ustar00rootroot00000000000000defmodule ElixirScript.Keyword do @moduledoc false def has_key?(kw, key) do do_has_key?(kw, key) end defp do_has_key?([], _) do false end defp do_has_key?(kw, key) do case hd(kw) do {the_key, _} when the_key == key -> true _ -> do_has_key?(tl(kw), key) end end def get(kw, key) do get(kw, key, nil) end def get(kw, key, default_value) do case has_key?(kw, key) do true -> do_get(kw, key) false -> default_value end end defp do_get(kw, key) do case hd(kw) do { kw_key, value } when kw_key == key -> value _ -> do_get(tl(kw), key) end end end elixirscript-0.25.0/lib/std_lib/list.ex000066400000000000000000000124231305236071500200220ustar00rootroot00000000000000defmodule ElixirScript.List do @moduledoc false require JS def duplicate(data, size) do do_duplicate(data, size, []) end defp do_duplicate(_, 0, list) do list end defp do_duplicate(data, size, list) do do_duplicate(data, size - 1, list ++ [data]) end def to_tuple(list) do JS.new(Elixir.Core.Tuple, list) end def wrap(list) when is_list(list), do: list def wrap(nil), do: [] def wrap(term), do: [term] def append(list, term) do concat(list, [term]) end def prepend(list, term) do concat([term], list) end def concat(list_a, list_b) do list_a.concat(list_b) end def first(list) do list[0] end def last(list) do list[length(list) - 1] end def delete(list, item) do do_delete(list, item, 0, []) end defp do_delete(list, item, current_index, new_list) do if current_index == length(list) do new_list else new_list = case list[current_index] do ^item -> new_list _ -> new_list ++ [list[current_index]] end do_delete(list, item, current_index + 1, new_list) end end def delete_at(list, index) do do_delete_at(list, index, 0, []) end defp do_delete_at(list, index, current_index, new_list) do if current_index == length(list) do new_list else new_list = case current_index == index do true -> new_list _ -> new_list ++ [list[current_index]] end do_delete_at(list, index, current_index + 1, new_list) end end def insert_at(list, index, value) do do_insert_at(list, index, value, 0, []) end defp do_insert_at(list, index, value, current_index, new_list) do if current_index == length(list) do new_list else new_list = case current_index == index do true -> new_list ++ [value, list[current_index]] _ -> new_list ++ [list[current_index]] end do_insert_at(list, index, value, current_index + 1, new_list) end end def replace_at(list, index, value) do do_replace_at(list, index, value, 0, []) end defp do_replace_at(list, index, value, current_index, new_list) do if current_index == length(list) do new_list else new_list = case current_index == index do true -> new_list ++ [value] _ -> new_list ++ [list[current_index]] end do_replace_at(list, index, value, current_index + 1, new_list) end end def update_at(list, index, func) do do_update_at(list, index, func, 0, []) end defp do_update_at(list, index, func, current_index, new_list) do if current_index == length(list) do new_list else new_list = case current_index == index do true -> new_list ++ [func.(list[current_index])] _ -> new_list ++ [list[current_index]] end do_update_at(list, index, func, current_index + 1, new_list) end end def foldl(list, acc, func) do do_foldl(list, acc, func, []) end def foldr(list, acc, func) do do_foldl(list.concat([]).reverse(), acc, func, []) end defp do_foldl([], acc, _, new_list) do { acc, new_list } end defp do_foldl(list, acc, func, new_list) do { acc, value } = func.(hd(list), acc) do_foldl(tl(list), acc, func, new_list ++ [value]) end def flatten(list) do do_flatten(list, []) end def flatten(list, tail) do do_flatten(list, []) ++ tail end defp do_flatten([], flattened_list) do flattened_list end defp do_flatten(list, flattened_list) do flattened_list = case hd(list) do l when is_list(l) -> flattened_list ++ do_flatten(l, []) item -> flattened_list ++ [item] end do_flatten(tl(list), flattened_list) end def keydelete(list, key, position) do do_keydelete(list, key, position, []) end defp do_keydelete([], _, _, new_list) do new_list end defp do_keydelete(list, key, position, new_list) do current_value = hd(list) new_list = if elem(current_value, position) == key do new_list else new_list ++ [current_value] end do_keydelete(tl(list), key, position, new_list) end def keyfind(list, key, position) do do_keyfind(list, key, position, nil) end def keyfind(list, key, position, default) do do_keyfind(list, key, position, default) end defp do_keyfind([], _, _, default) do default end defp do_keyfind(list, key, position, default) do current_value = hd(list) if elem(current_value, position) == key do current_value else do_keyfind(tl(list), key, position, default) end end def keymember?(list, key, position) do keyfind(list, key, position) != nil end def keyreplace(list, key, position, new_tuple) do do_keyreplace(list, key, position, [], new_tuple) end defp do_keyreplace([], _, _, new_list, _) do new_list end defp do_keyreplace(list, key, position, new_list, new_tuple) do current_value = hd(list) new_list = if elem(current_value, position) == key do new_list ++ [new_tuple] else new_list ++ [current_value] end do_keyreplace(tl(list), key, position, new_list, new_tuple) end def zip(list_of_lists) do Elixir.Core.Functions.zip(list_of_lists) end end elixirscript-0.25.0/lib/std_lib/macro/000077500000000000000000000000001305236071500176105ustar00rootroot00000000000000elixirscript-0.25.0/lib/std_lib/macro/env.ex000066400000000000000000000016041305236071500207370ustar00rootroot00000000000000defmodule ElixirScript.Macro.Env do @moduledoc false @type t :: %ElixirScript.Macro.Env{ module: atom, file: binary, line: non_neg_integer, function: { atom, non_neg_integer } | nil, context: :match | :guard | :generator | nil, aliases: [{atom, atom}], requires: [atom], functions: [{atom, [{ atom, non_neg_integer }]}], macros: [{atom, [{ atom, non_neg_integer }]}], macro_aliases: [{atom, {integer, atom}}], context_modules: [atom], vars: [{atom, atom | non_neg_integer}], export_vars: [{atom, atom | non_neg_integer}] | nil, lexical_tracker: nil } defstruct [ module: nil, file: nil, line: 0, function: nil, context: nil, aliases: [], requires: [], functions: [], macros: [], macro_aliases: [], context_modules: [], vars: [], export_vars: nil, lexical_tracker: nil ] end elixirscript-0.25.0/lib/std_lib/map.ex000066400000000000000000000071021305236071500176220ustar00rootroot00000000000000defmodule ElixirScript.Map do @moduledoc false def new() do %{} end def keys(map) do Elixir.Core.Functions.get_object_keys(map) end def size(map) do keys(map).length end def to_list(map) do do_to_list(map, []) end def do_to_list(map, list) do case size(map) do 0 -> list _ -> key = hd(keys(map)) value = map[key] do_to_list(Map.delete(map, key), list ++ [{key, value}]) end end def values(map) do Object.values(map) end def from_struct(struct) do struct |> Elixir.Core.Functions.class_to_obj |> delete(:__struct__) end def delete(map, key) do map |> Elixir.Core.Functions.delete_property_from_map(key) end def equal?(map1, map2) do map1 === map2 end def fetch!(map, key) do case key in keys(map) do true -> map[key] false -> raise "#{key} not found in map" end end def fetch(map, key) do case key in keys(map) do true -> { :ok, map[key] } false -> :error end end def has_key?(map, key) do key in keys(map) end def merge(map1, map2) do Elixir.Core.SpecialForms.map_update(map1, map2) end def split(map, keys) do do_split(map, keys, { %{}, %{} }) end defp do_split(_, [], split_tuple) do split_tuple end defp do_split(map, keys, { key_map, non_key_map }) do key = hd(keys) new_split_tuple = case key in keys(map) do true -> { Map.put(key_map, key, map[key]), non_key_map } false -> { key_map, Map.put(non_key_map, key, map[key]) } end do_split(map, tl(keys), new_split_tuple) end def take(map, keys) do {key_map, _} = split(map, keys) key_map end def drop(map, keys) do {_, non_key_map} = split(map, keys) non_key_map end def put_new(map, key, value) do case key in keys(map) do true -> map false -> Map.put(map, key, value) end end def put_new_lazy(map, key, func) do case key in keys(map) do true -> map false -> Map.put(map, key, func.()) end end def put(map, key, value) do Elixir.Core.Functions.add_property_to_map(map, key, value) end def get(map, key) do get(map, key, nil) end def get(map, key, default_value) do case key in keys(map) do true -> map[key] false -> default_value end end def get_lazy(map, key, func) do case key in keys(map) do true -> func.(map[key]) false -> func.() end end def get_and_update(map, key, func) do case key in keys(map) do true -> { nil, map } false -> new_value = func.(map[key]) { new_value, Map.put(map, key, new_value) } end end def pop(map, key) do pop(map, key, nil) end def pop(map, key, default_value) do case key in keys(map) do true -> { map[key], Map.delete(map, key) } false -> { default_value, map } end end def pop_lazy(map, key, func) do case key in keys(map) do true -> { func.(map[key]), Map.delete(map, key) } false -> { func.(), map } end end def update!(map, key, func) do case key in keys(map) do true -> Map.put(map, key, func.(map[key])) false -> raise "#{key} not found in map" end end def update(map, key, initial, func) do case key in keys(map) do true -> Map.put(map, key, func.(map[key])) false -> Map.put(map, key, initial) end end end elixirscript-0.25.0/lib/std_lib/map_set.ex000066400000000000000000000037021305236071500204770ustar00rootroot00000000000000defmodule ElixirScript.MapSet do @moduledoc false defstruct set: [] def new() do %MapSet{} end def size(set) do length(set.set) end def to_list(set) do set.set end def delete(set, term) do %{ set | set: Elixir.List.remove(set.set, term) } end def put(set, term) do case member?(set, term) do false -> %{ set | set: set.set ++ term } true -> set end end def member?(set, term) do set.set.indexOf(term) >= 0 end def equal?(set1, set2) do set1 === set2 end def difference(set1, set2) do do_difference(to_list(set1), set2, new()) end def do_difference([], _, difference_set) do difference_set end def do_difference(set1_list, set2, difference_set) do term = hd(set1_list) case member?(set2, term) do true -> do_difference(tl(set1_list), set2, difference_set) false -> do_difference(tl(set1_list), set2, %{ difference_set | set: difference_set.set ++ [term]}) end end def intersection(set1, set2) do do_intersection(to_list(set1), set2, new()) end def do_intersection([], _, intersection_set) do intersection_set end def do_intersection(set1_list, set2, intersection_set) do term = hd(set1_list) case member?(set2, term) do false -> do_intersection(tl(set1_list), set2, intersection_set) true -> do_intersection(tl(set1_list), set2, %{ intersection_set | set: intersection_set.set ++ [term]}) end end def union(set1, set2) do %{ set1 | set: set1.set ++ set2.set} end def disjoint?(set1, set2) do size(intersection(set1, set2)) == 0 end def subset?(set1, set2) do do_subset?(to_list(set1), set2) end def do_subset?([], _) do true end def do_subset?(set1_list, set2) do term = hd(set1_list) case member?(set2, term) do false -> false true -> do_subset?(tl(set1_list), set2) end end end elixirscript-0.25.0/lib/std_lib/module.ex000066400000000000000000000003701305236071500203320ustar00rootroot00000000000000defmodule ElixirScript.Module do @moduledoc false defstruct name: nil, functions: Keyword.new, private_functions: Keyword.new, body: nil, js_imports: [], module_refs: [], type: :module, impls: Map.new, impl_type: nil, app_name: nil end elixirscript-0.25.0/lib/std_lib/range.ex000066400000000000000000000003711305236071500201420ustar00rootroot00000000000000defmodule ElixirScript.Range do @moduledoc false defstruct first: nil, last: nil def new(first, last) do %ElixirScript.Range{first: first, last: last} end def range?(%ElixirScript.Range{}), do: true def range?(_), do: false end elixirscript-0.25.0/lib/std_lib/regex.ex000066400000000000000000000024411305236071500201600ustar00rootroot00000000000000defmodule ElixirScript.Regex do @moduledoc false require JS def compile(source, options \\ "") do try do {:ok, JS.new(RegExp, [source, options])} rescue x -> {:error, x.message} end end def compile!(source, options \\ "") do JS.new(RegExp, [source, options]) end def regex?(term) do JS.instanceof(term, RegExp) end def match?(regex, string) do regex.test(string) end def source(regex) do regex.source end def opts(regex) do regex.flags end def run(regex, string, options \\ []) do regex.exec(string) end def scan(regex, string, options \\ []) do reg = make_global(regex) do_scan(reg, string, options, []) end def replace(regex, string, replacement, options \\ []) do reg = if Keyword.get(options, :global, true) do make_global(regex) else regex end string.replace(regex, replacement) end defp do_scan(regex, string, options, results) do case run(regex, string, options) do nil -> results match -> do_scan(regex, string, options, results ++ match) end end defp make_global(regex) do if String.contains?(regex.flags, "g") do regex else JS.new(RegExp, [ source(regex), opts(regex) <> "g" ]) end end end elixirscript-0.25.0/lib/std_lib/string.ex000066400000000000000000000067471305236071500203710ustar00rootroot00000000000000defmodule ElixirScript.String do @moduledoc false import Kernel, except: [length: 1] def to_atom(str) do Symbol.for(str) end def to_existing_atom(str) do Symbol.for(str) end def to_char_list(str) do str.split("") end def to_float(str) do Elixir.Core.get_global().parseFloat(str) end def to_integer(str) do Elixir.Core.get_global().parseInt(str, 10) end def to_integer(str, base) do Elixir.Core.get_global().parseInt(str, base) end def upcase(str) do str.toUpperCase() end def downcase(str) do str.toLowerCase() end def at(str, pos) do case pos > length(str) do true -> nil _ -> str[pos] end end def capitalize(str) do first = str[0].toUpperCase() rest = str.substr(1).toLowerCase() first <> rest end def split(str) do str.split() end def split(str, replace, options \\ []) do limit = Keyword.get(options, :parts, -1) trim = Keyword.get(options, :trim, false) split = str.split(replace, limit) Enum.map(split, fn(x) -> if trim do x.trim() else x end end) end def next_grapheme(nil), do: nil def next_grapheme(""), do: nil def next_grapheme(str) do { str[0], str.substr(1) } end def first(nil), do: nil def first(str) do str[0] end def last(nil), do: nil def last(str) do str[length(str) - 1] end def graphemes(str) do str.split('') end def length(str) do str.length() end def match?(str, regex) do str.match(regex) != nil end def next_codepoint(nil), do: nil def next_codepoint(""), do: nil def next_codepoint(str) do { str[0].codePointAt(0), str.substr(1) } end def reverse(str) do do_reverse(str, "") end defp do_reverse("", str) do str end defp do_reverse(str, reverse_str) do do_reverse(str.substr(1), reverse_str <> last(str)) end def starts_with?(str, prefix) when is_binary(prefix) do str.startsWith(prefix) end def starts_with?(str, prefixes) when is_list(prefixes) do do_starts_with?(str, prefixes) end def do_starts_with?(_, []) do false end def do_starts_with?(str, prefixes) do case starts_with?(str, hd(prefixes)) do true -> true _ -> do_starts_with?(str, tl(prefixes)) end end def ends_with?(str, suffix) when is_binary(suffix) do str.endsWith(suffix) end def ends_with?(str, suffixes) when is_list(suffixes) do do_ends_with?(str, suffixes) end def do_ends_with?(_, []) do false end def do_ends_with?(str, suffixes) do case ends_with?(str, hd(suffixes)) do true -> true _ -> do_ends_with?(str, tl(suffixes)) end end def duplicate(str, n) do str.repeat(n) end def contains?(str, s) when is_binary(s) do str.indexOf(s) > -1 end def contains?(str, s) when is_list(s) do do_contains?(str, s) end def do_contains?(_, []) do false end def do_contains?(str, prefixes) do case contains?(str, hd(prefixes)) do true -> true _ -> do_contains?(str, tl(prefixes)) end end def codepoints(str) do do_codepoints(str, []) end def do_codepoints("", codepoint_list) do codepoint_list end def do_codepoints(str, codepoint_list) do do_codepoints(str.substr(1), codepoint_list ++ [first(str).codePointAt(0)]) end def valid_character?(codepoint) do Elixir.Core.Functions.is_valid_character(codepoint) end end elixirscript-0.25.0/lib/std_lib/string/000077500000000000000000000000001305236071500200155ustar00rootroot00000000000000elixirscript-0.25.0/lib/std_lib/string/chars.ex000066400000000000000000000015121305236071500214520ustar00rootroot00000000000000defprotocol ElixirScript.String.Chars do @moduledoc false def to_string(item) end defimpl ElixirScript.String.Chars, for: Atom do def to_string(nil) do "" end def to_string(atom) do Atom.to_string(atom) end end defimpl ElixirScript.String.Chars, for: BitString do def to_string(thing) when is_binary(thing) do thing end def to_string(thing) do thing.toString() end end defimpl ElixirScript.String.Chars, for: List do def to_string(list) do list.toString() end end defimpl ElixirScript.String.Chars, for: Tuple do def to_string(tuple) do tuple.toString() end end defimpl ElixirScript.String.Chars, for: Integer do def to_string(integer) do integer.toString() end end defimpl ElixirScript.String.Chars, for: Float do def to_string(float) do float.toString() end end elixirscript-0.25.0/lib/std_lib/tuple.ex000066400000000000000000000026101305236071500201750ustar00rootroot00000000000000defmodule ElixirScript.Tuple do @moduledoc false require JS def duplicate(data, size) do JS.new(Elixir.Core.Tuple, do_duplicate(data, size, [])) end defp do_duplicate(_, 0, list) do list end defp do_duplicate(data, size, list) do do_duplicate(data, size - 1, list ++ [data]) end def to_list(tuple) do tuple["value"] end def insert_at(tuple, index, value) do JS.new(Elixir.Core.Tuple, do_insert_at(tuple, index, value, 0, [])) end defp do_insert_at(tuple, index, value, current_index, list) do if current_index == length(tuple) do list else list = case index == current_index do true -> list ++ [value, tuple.get(current_index)] false -> list ++ [tuple.get(current_index)] end do_insert_at(tuple, index, value, current_index + 1, list) end end def delete_at(tuple, index) do JS.new(Elixir.Core.Tuple, do_delete_at(tuple, index, 0, [])) end defp do_delete_at(tuple, index, current_index, list) do if current_index == length(tuple) do list else list = case index == current_index do true -> list false -> list ++ [tuple.get(current_index)] end do_delete_at(tuple, index, current_index + 1, list) end end def append(tuple, value) do JS.new(Elixir.Core.Tuple, to_list(tuple) ++ [value]) end end elixirscript-0.25.0/mix.exs000066400000000000000000000047261305236071500156500ustar00rootroot00000000000000defmodule ElixirScript.Mixfile do use Mix.Project def project do [ app: :elixir_script, version: "0.25.0", elixir: "~> 1.0", escript: escript_config(), deps: deps(), description: description(), package: package(), source_url: "https://github.com/elixirscript/elixirscript", aliases: aliases(), test_coverage: [tool: ExCoveralls], preferred_cli_env: [coveralls: :test], docs: [ extras: ["GettingStarted.md", "FAQ.md"] ] ] end def application do [ applications: [:logger, :estree] ] end defp deps do [ {:estree, "~> 2.5"}, {:fs, "~> 2.12"}, {:ex_doc, "~> 0.14", only: :dev}, {:excoveralls, "~> 0.5", only: :test}, {:credo, "~> 0.4", only: [:dev, :test]} ] end defp escript_config do [main_module: ElixirScript.CLI, name: "elixirscript"] end defp description do """ ElixirScript: compiles Elixir code to JavaScript """ end defp package do [ files: ["lib", "priv/**/*.js", "mix.exs", "README.md", "LICENSE", "CHANGELOG.md"], maintainers: ["Bryan Joseph"], licenses: ["MIT"], links: %{ "GitHub" => "https://github.com/elixirscript/elixirscript" }, build_tools: ["mix"] ] end defp aliases do [dist: &dist/1, install: &install/1, std_lib: &std_lib/1] end def std_lib(_) do Mix.Task.run "app.start" {_ , _} = System.cmd("npm", ["run", "build"]) ElixirScript.compile_std_lib() end def dist(_) do Mix.Task.run "app.start" dist_folder = "dist" folder_name = "#{dist_folder}/elixirscript" archive_file_name = "#{dist_folder}/elixirscript.tar.gz" Mix.Tasks.Escript.Build.run([]) if File.exists?(dist_folder) do File.rm_rf(dist_folder) end File.mkdir_p(folder_name <> "/bin") File.cp!("elixirscript", "#{folder_name}/bin/elixirscript") if File.exists?("priv/.DS_Store") do File.rm!("priv/.DS_Store") end File.cp_r!("priv/", "#{folder_name}") File.cp!("LICENSE", "#{folder_name}/LICENSE") System.cmd("tar", ["czf", archive_file_name, folder_name]) File.rm_rf(folder_name) end def install(_) do Mix.Task.run "app.start" System.cmd("tar", ["-zxvf", "dist/elixirscript.tar.gz"]) File.rm_rf!("/usr/local/elixirscript") System.cmd("mv", ["dist/elixirscript", "/usr/local/elixirscript"]) IO.puts("installed at /usr/local/elixirscript") end end elixirscript-0.25.0/mix.lock000066400000000000000000000044551305236071500160000ustar00rootroot00000000000000%{"bunt": {:hex, :bunt, "0.2.0", "951c6e801e8b1d2cbe58ebbd3e616a869061ddadcc4863d0a2182541acae9a38", [:mix], []}, "certifi": {:hex, :certifi, "0.7.0", "861a57f3808f7eb0c2d1802afeaae0fa5de813b0df0979153cbafcd853ababaf", [:rebar3], []}, "credo": {:hex, :credo, "0.6.1", "a941e2591bd2bd2055dc92b810c174650b40b8290459c89a835af9d59ac4a5f8", [:mix], [{:bunt, "~> 0.2.0", [hex: :bunt, optional: false]}]}, "earmark": {:hex, :earmark, "1.1.1", "433136b7f2e99cde88b745b3a0cfc3fbc81fe58b918a09b40fce7f00db4d8187", [:mix], []}, "estree": {:hex, :estree, "2.5.1", "c93a8fa8a29886e6a6f6c489ba6dc949b998d2985b189967e41e69a92b58e846", [:mix], []}, "ex_doc": {:hex, :ex_doc, "0.14.5", "c0433c8117e948404d93ca69411dd575ec6be39b47802e81ca8d91017a0cf83c", [:mix], [{:earmark, "~> 1.0", [hex: :earmark, optional: false]}]}, "excoveralls": {:hex, :excoveralls, "0.6.2", "0e993d096f1fbb6e70a3daced5c89aac066bda6bce57829622aa2d1e2b338cfb", [:mix], [{:exjsx, "~> 3.0", [hex: :exjsx, optional: false]}, {:hackney, ">= 0.12.0", [hex: :hackney, optional: false]}]}, "exjsx": {:hex, :exjsx, "3.2.1", "1bc5bf1e4fd249104178f0885030bcd75a4526f4d2a1e976f4b428d347614f0f", [:mix], [{:jsx, "~> 2.8.0", [hex: :jsx, optional: false]}]}, "fs": {:hex, :fs, "2.12.0", "ad631efacc9a5683c8eaa1b274e24fa64a1b8eb30747e9595b93bec7e492e25e", [:rebar3], []}, "hackney": {:hex, :hackney, "1.6.5", "8c025ee397ac94a184b0743c73b33b96465e85f90a02e210e86df6cbafaa5065", [:rebar3], [{:certifi, "0.7.0", [hex: :certifi, optional: false]}, {:idna, "1.2.0", [hex: :idna, optional: false]}, {:metrics, "1.0.1", [hex: :metrics, optional: false]}, {:mimerl, "1.0.2", [hex: :mimerl, optional: false]}, {:ssl_verify_fun, "1.1.1", [hex: :ssl_verify_fun, optional: false]}]}, "idna": {:hex, :idna, "1.2.0", "ac62ee99da068f43c50dc69acf700e03a62a348360126260e87f2b54eced86b2", [:rebar3], []}, "jsx": {:hex, :jsx, "2.8.2", "7acc7d785b5abe8a6e9adbde926a24e481f29956dd8b4df49e3e4e7bcc92a018", [:mix, :rebar3], []}, "metrics": {:hex, :metrics, "1.0.1", "25f094dea2cda98213cecc3aeff09e940299d950904393b2a29d191c346a8486", [:rebar3], []}, "mimerl": {:hex, :mimerl, "1.0.2", "993f9b0e084083405ed8252b99460c4f0563e41729ab42d9074fd5e52439be88", [], []}, "ssl_verify_fun": {:hex, :ssl_verify_fun, "1.1.1", "28a4d65b7f59893bc2c7de786dec1e1555bd742d336043fe644ae956c3497fbe", [:make, :rebar], []}} elixirscript-0.25.0/package.json000066400000000000000000000031521305236071500166100ustar00rootroot00000000000000{ "name": "elixirscript", "version": "0.25.0", "description": "Convert Elixir to JavaScript", "main": "elixir.js", "bin": { "elixirscript": "./elixirscript" }, "scripts": { "lint": "eslint src/javascript/lib/**/*.js src/javascript/tests/**/*.js", "lint:fix": "eslint src/javascript/lib/**/*.js src/javascript/tests/**/*.js --fix", "build": "npm run build:es && npm run build:umd && npm run build:common", "build:es": "rollup -c rollup.config.js", "build:umd": "rollup -c rollup.config.js -f umd -o priv/umd/elixir/Elixir.Bootstrap.js", "build:common": "rollup -c rollup.config.js -f cjs -o priv/common/elixir/Elixir.Bootstrap.js", "clean": "rm -rf priv", "test": "mocha src/javascript/tests --recursive --compilers js:babel-core/register" }, "repository": { "type": "git", "url": "git@github.com:bryanjos/elixirscript.git" }, "author": "", "license": "MIT", "dependencies": { "erlang-types": "^1.0.0", "tailored": "2.3.2" }, "devDependencies": { "babel": "^6.5.2", "babel-core": "^6.7.7", "babel-plugin-transform-class-properties": "^6.9.1", "babel-preset-es2015": "^6.6.0", "babel-preset-es2015-rollup": "^1.1.1", "babel-preset-react": "^6.5.0", "babel-preset-stage-0": "^6.5.0", "chai": "^3.5.0", "eslint": "^3.15.0", "eslint-config-airbnb-base": "^11.1.0", "eslint-plugin-import": "^2.2.0", "gulp": "^3.9.1", "gulp-babel": "^6.1.2", "gulp-sourcemaps": "^2.0.0-alpha", "mocha": "^2.4.5", "rollup": "^0.41.4", "rollup-plugin-babel": "^2.7.1", "rollup-plugin-node-resolve": "^2.0.0" } }elixirscript-0.25.0/rollup.config.js000066400000000000000000000005541305236071500174440ustar00rootroot00000000000000import nodeResolve from "rollup-plugin-node-resolve"; import babel from "rollup-plugin-babel"; export default { entry: "src/javascript/elixir.js", dest: "priv/es/elixir/Elixir.Bootstrap.js", sourceMap: "inline", format: "es", moduleName: "Elixir.Bootstrap", plugins: [ nodeResolve({ jsnext: true }), babel({ babelrc: false }) ] }; elixirscript-0.25.0/src/000077500000000000000000000000001305236071500151105ustar00rootroot00000000000000elixirscript-0.25.0/src/javascript/000077500000000000000000000000001305236071500172565ustar00rootroot00000000000000elixirscript-0.25.0/src/javascript/elixir.js000066400000000000000000000001421305236071500211050ustar00rootroot00000000000000import Core from './lib/core'; import Enum from './lib/enum'; export default { Core, Enum }; elixirscript-0.25.0/src/javascript/lib/000077500000000000000000000000001305236071500200245ustar00rootroot00000000000000elixirscript-0.25.0/src/javascript/lib/core.js000066400000000000000000000006311305236071500213120ustar00rootroot00000000000000import Patterns from "tailored"; import ErlangTypes from "erlang-types"; import Functions from "./core/functions"; import SpecialForms from "./core/special_forms"; import Store from "./core/store"; class Integer {} class Float {} export default { Tuple: ErlangTypes.Tuple, PID: ErlangTypes.PID, BitString: ErlangTypes.BitString, Patterns, Integer, Float, Functions, SpecialForms, Store }; elixirscript-0.25.0/src/javascript/lib/core/000077500000000000000000000000001305236071500207545ustar00rootroot00000000000000elixirscript-0.25.0/src/javascript/lib/core/functions.js000066400000000000000000000176751305236071500233420ustar00rootroot00000000000000import Protocol from './protocol'; import Core from '../core'; function call_property(item, property) { let prop = null; if ( typeof item === 'number' || typeof item === 'symbol' || typeof item === 'boolean' || typeof item === 'string' ) { if (item[property] !== undefined) { prop = property; } else if (item[Symbol.for(property)] !== undefined) { prop = Symbol.for(property); } } else if (property in item) { prop = property; } else if (Symbol.for(property) in item) { prop = Symbol.for(property); } if (prop === null) { throw new Error(`Property ${property} not found in ${item}`); } if (item[prop] instanceof Function) { return item[prop](); } return item[prop]; } function apply(...args) { if (args.length === 2) { args[0].apply(null, args.slice(1)); } else { args[0][args[1]].apply(null, args.slice(2)); } } function contains(left, right) { for (const x of right) { if (Core.Patterns.match_or_default(left, x) != null) { return true; } } return false; } function get_global() { if (typeof self !== 'undefined') { return self; } else if (typeof window !== 'undefined') { return window; } else if (typeof global !== 'undefined') { return global; } throw new Error('No global state found'); } function defstruct(defaults) { return class { constructor(update = {}) { const the_values = Object.assign(defaults, update); Object.assign(this, the_values); } static create(updates = {}) { const x = new this(updates); return Object.freeze(x); } }; } function defexception(defaults) { return class extends Error { constructor(update = {}) { const message = update.message || ''; super(message); const the_values = Object.assign(defaults, update); Object.assign(this, the_values); this.name = this.constructor.name; this.message = message; this[Symbol.for('__exception__')] = true; Error.captureStackTrace(this, this.constructor.name); } static create(updates = {}) { const x = new this(updates); return Object.freeze(x); } }; } function defprotocol(spec) { return new Protocol(spec); } function defimpl(protocol, type, impl) { protocol.implementation(type, impl); } function get_object_keys(obj) { return Object.keys(obj).concat(Object.getOwnPropertySymbols(obj)); } function is_valid_character(codepoint) { try { return String.fromCodePoint(codepoint) != null; } catch (e) { return false; } } // https://developer.mozilla.org/en-US/docs/Web/API/WindowBase64/Base64_encoding_and_decoding#Solution_2_%E2%80%93_rewrite_the_DOMs_atob()_and_btoa()_using_JavaScript's_TypedArrays_and_UTF-8 function b64EncodeUnicode(str) { return btoa( encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, (match, p1) => String.fromCharCode(`0x${p1}`)), ); } function delete_property_from_map(map, property) { const new_map = Object.assign(Object.create(map.constructor.prototype), map); delete new_map[property]; return Object.freeze(new_map); } function class_to_obj(map) { const new_map = Object.assign({}, map); return Object.freeze(new_map); } function add_property_to_map(map, property, value) { const new_map = Object.assign({}, map); new_map[property] = value; return Object.freeze(new_map); } function update_map(map, property, value) { if (property in get_object_keys(map)) { return add_property_to_map(map, property, value); } throw 'map does not have key'; } function bnot(expr) { return ~expr; } function band(left, right) { return left & right; } function bor(left, right) { return left | right; } function bsl(left, right) { return left << right; } function bsr(left, right) { return left >> right; } function bxor(left, right) { return left ^ right; } function zip(list_of_lists) { if (list_of_lists.length === 0) { return Object.freeze([]); } const new_value = []; let smallest_length = list_of_lists[0]; for (const x of list_of_lists) { if (x.length < smallest_length) { smallest_length = x.length; } } for (let i = 0; i < smallest_length; i++) { const current_value = []; for (let j = 0; j < list_of_lists.length; j++) { current_value.push(list_of_lists[j][i]); } new_value.push(new Core.Tuple(...current_value)); } return Object.freeze(new_value); } function can_decode64(data) { try { atob(data); return true; } catch (e) { return false; } } function remove_from_list(list, element) { let found = false; return list.filter((elem) => { if (!found && elem === element) { found = true; return false; } return true; }); } function foldl(fun, acc, list) { let acc1 = acc; for (const el of list) { acc1 = fun(el, acc1); } return acc1; } function foldr(fun, acc, list) { let acc1 = acc; for (let i = list.length - 1; i >= 0; i--) { acc1 = fun(list[i], acc1); } return acc1; } function keyfind(key, n, tuplelist) { for (let i = tuplelist.length - 1; i >= 0; i--) { if (tuplelist[i].get(n) === key) { return tuplelist[i]; } } return false; } function keydelete(key, n, tuplelist) { for (let i = tuplelist.length - 1; i >= 0; i--) { if (tuplelist[i].get(n) === key) { return tuplelist.concat([]).splice(i, 1); } } return tuplelist; } function keystore(key, n, list, newtuple) { for (let i = list.length - 1; i >= 0; i--) { if (list[i].get(n) === key) { return list.concat([]).splice(i, 1, newtuple); } } return list.concat([]).push(newtuple); } function keymember(key, n, list) { for (let i = list.length - 1; i >= 0; i--) { if (list[i].get(n) === key) { return true; } } return false; } function keytake(key, n, list) { if (!keymember(key, n, list)) { return false; } const tuple = keyfind(key, n, list); return new Core.Tuple(tuple.get(n), tuple, keydelete(key, n, list)); } function keyreplace(key, n, list, newtuple) { for (let i = list.length - 1; i >= 0; i--) { if (list[i].get(n) === key) { return list.concat([]).splice(i, 1, newtuple); } } return list; } function reverse(list) { return list.concat([]).reverse(); } function maps_find(key, map) { if (key in get_object_keys(map)) { return new Core.Tuple(Symbol.for('ok'), map[key]); } return Symbol.for('error'); } function flatten(list, tail = []) { let new_list = []; for (const e of list) { if (Array.isArray(e)) { new_list = new_list.concat(flatten(e)); } else { new_list.push(e); } } return Object.freeze(new_list.concat(tail)); } function duplicate(n, elem) { const list = []; for (let i = 0; i < n; i++) { list.push(elem); } return Object.freeze(list); } function mapfoldl(fun, acc, list) { const newlist = []; let new_acc = acc; for (const x of list) { const tup = fun(x, new_acc); newlist.push(tup.get(0)); new_acc = tup.get(1); } return new Core.Tuple(Object.freeze(newlist), new_acc); } function filtermap(fun, list) { const newlist = []; for (const x of list) { const result = fun(x); if (result === true) { newlist.push(x); } else if (result instanceof Core.Tuple) { newlist.push(result.get(1)); } } return Object.freeze(newlist); } function maps_fold(fun, acc, map) { let acc1 = acc; for (const k of get_object_keys(map)) { acc1 = fun(k, map[k], acc1); } return acc1; } export default { call_property, apply, contains, get_global, defstruct, defexception, defprotocol, defimpl, get_object_keys, is_valid_character, b64EncodeUnicode, delete_property_from_map, add_property_to_map, class_to_obj, can_decode64, bnot, band, bor, bsl, bsr, bxor, zip, foldl, foldr, remove_from_list, keydelete, keystore, keyfind, keytake, keyreplace, reverse, update_map, maps_find, flatten, duplicate, mapfoldl, filtermap, maps_fold, }; elixirscript-0.25.0/src/javascript/lib/core/protocol.js000066400000000000000000000033061305236071500231550ustar00rootroot00000000000000import Core from '../core'; // https://github.com/airportyh/protomorphism class Protocol { constructor(spec) { this.registry = new Map(); this.fallback = null; for (const funName in spec) { this[funName] = createFun(funName).bind(this); } function createFun(funName) { return function (...args) { const thing = args[0]; let fun = null; if (Number.isInteger(thing) && this.hasImplementation(Core.Integer)) { fun = this.registry.get(Core.Integer)[funName]; } else if ( typeof thing === 'number' && !Number.isInteger(thing) && this.hasImplementation(Core.Float) ) { fun = this.registry.get(Core.Float)[funName]; } else if ( typeof thing === 'string' && this.hasImplementation(Core.BitString) ) { fun = this.registry.get(Core.BitString)[funName]; } else if (this.hasImplementation(thing)) { fun = this.registry.get(thing.constructor)[funName]; } else if (this.fallback) { fun = this.fallback[funName]; } if (fun != null) { const retval = fun.apply(this, args); return retval; } throw new Error(`No implementation found for ${thing}`); }; } } implementation(type, implementation) { if (type === null) { this.fallback = implementation; } else { this.registry.set(type, implementation); } } hasImplementation(thing) { if ( thing === Core.Integer || thing === Core.Float || thing === Core.BitString ) { return this.registry.has(thing); } return this.registry.has(thing.constructor); } } export default Protocol; elixirscript-0.25.0/src/javascript/lib/core/special_forms.js000066400000000000000000000057721305236071500241530ustar00rootroot00000000000000import Core from '../core'; function _case(condition, clauses) { return Core.Patterns.defmatch(...clauses)(condition); } function cond(clauses) { for (const clause of clauses) { if (clause[0]) { return clause[1](); } } throw new Error(); } function map_update(map, values) { return Object.freeze( Object.assign(Object.create(map.constructor.prototype), map, values), ); } function _for(expression, generators, collectable_protocol, into = []) { let [result, fun] = collectable_protocol.into(into); const generatedValues = run_list_generators(generators.pop()(), generators); for (const value of generatedValues) { if (expression.guard.apply(this, value)) { result = fun(result, new Core.Tuple( Symbol.for('cont'), expression.fn.apply(this, value), )); } } return fun(result, Symbol.for('done')); } function run_list_generators(generator, generators) { if (generators.length == 0) { return generator.map((x) => { if (Array.isArray(x)) { return x; } return [x]; }); } const list = generators.pop(); const next_gen = []; for (const j of list()) { for (const i of generator) { next_gen.push([j].concat(i)); } } return run_list_generators(next_gen, generators); } function _try( do_fun, rescue_function, catch_fun, else_function, after_function, ) { let result = null; try { result = do_fun(); } catch (e) { let ex_result = null; if (rescue_function) { try { ex_result = rescue_function(e); return ex_result; } catch (ex) { if (ex instanceof Core.Patterns.MatchError) { throw ex; } } } if (catch_fun) { try { ex_result = catch_fun(e); return ex_result; } catch (ex) { if (ex instanceof Core.Patterns.MatchError) { throw ex; } } } throw e; } finally { if (after_function) { after_function(); } } if (else_function) { try { return else_function(result); } catch (ex) { if (ex instanceof Core.Patterns.MatchError) { throw new Error('No Match Found in Else'); } throw ex; } } else { return result; } } function _with(...args) { let argsToPass = []; let successFunction = null; let elseFunction = null; if (typeof args[args.length - 2] === 'function') { [successFunction, elseFunction] = args.splice(-2); } else { successFunction = args.pop(); } for (let i = 0; i < args.length; i++) { const [pattern, func] = args[i]; const result = func(...argsToPass); const patternResult = Core.Patterns.match_or_default(pattern, result); if (patternResult == null) { if (elseFunction) { return elseFunction.call(null, result); } return result; } argsToPass = argsToPass.concat(patternResult); } return successFunction(...argsToPass); } export default { _case, cond, map_update, _for, _try, _with, }; elixirscript-0.25.0/src/javascript/lib/core/store.js000066400000000000000000000013061305236071500224460ustar00rootroot00000000000000const store = new Map(); const names = new Map(); function get_key(key) { let real_key = key; if (names.has(key)) { real_key = names.get(key); } if (store.has(real_key)) { return real_key; } return new Error('Key Not Found'); } function create(key, value, name = null) { if (name != null) { names.set(name, key); } store.set(key, value); } function update(key, value) { const real_key = get_key(key); store.set(real_key, value); } function read(key) { const real_key = get_key(key); return store.get(real_key); } function remove(key) { const real_key = get_key(key); return store.delete(real_key); } export default { create, read, update, remove, }; elixirscript-0.25.0/src/javascript/lib/enum.js000066400000000000000000000074461305236071500213410ustar00rootroot00000000000000import Core from './core'; let Enum = { all__qmark__: function(collection, fun = (x) => x){ for(let elem of collection){ if(!fun(elem)){ return false; } } return true; }, any__qmark__: function(collection, fun = (x) => x){ for(let elem of collection){ if(fun(elem)){ return true; } } return false; }, at: function(collection, n, the_default = null){ if(n > this.count(collection) || n < 0){ return the_default; } return collection[n]; }, concat: function(...enumables){ return enumables[0].concat(enumables[1]); }, count: function(collection, fun = null){ if(fun == null){ return collection.length; } else { return collection.filter(fun).length; } }, drop: function(collection, count){ return collection.slice(count); }, drop_while: function(collection, fun){ let count = 0; for(let elem of collection){ if(fun(elem)){ count = count + 1; }else{ break; } } return collection.slice(count); }, each: function(collection, fun){ for(let elem of collection){ fun(elem); } }, empty__qmark__: function(collection){ return collection.length === 0; }, fetch: function(collection, n){ if(Array.isArray(collection)){ if(n < this.count(collection) && n >= 0){ return new Core.Tuple(Symbol.for("ok"), collection[n]); }else{ return Symbol.for("error"); } } throw new Error("collection is not an Enumerable"); }, fetch__emark__: function(collection, n){ if(Array.isArray(collection)){ if(n < this.count(collection) && n >= 0){ return collection[n]; }else{ throw new Error("out of bounds error"); } } throw new Error("collection is not an Enumerable"); }, filter: function(collection, fun){ let result = []; for(let elem of collection){ if(fun(elem)){ result.push(elem); } } return result; }, filter_map: function(collection, filter, mapper){ return Enum.map(Enum.filter(collection, filter), mapper); }, find: function(collection, if_none = null, fun){ for(let elem of collection){ if(fun(elem)){ return elem; } } return if_none; }, into: function(collection, list){ return list.concat(collection); }, map: function(collection, fun){ let result = []; for(let elem of collection){ result.push(fun(elem)); } return result; }, map_reduce: function(collection, acc, fun){ let mapped = Object.freeze([]); let the_acc = acc; for (var i = 0; i < this.count(collection); i++) { let tuple = fun(collection[i], the_acc); the_acc = tuple.get(1); mapped = Object.freeze(mapped.concat([tuple.get(0)])); } return new Core.Tuple(mapped, the_acc); }, member__qmark__: function(collection, value){ return collection.includes(value); }, reduce: function(collection, acc, fun){ let the_acc = acc; for (var i = 0; i < this.count(collection); i++) { let tuple = fun(collection[i], the_acc); the_acc = tuple.get(1); } return the_acc; }, take: function(collection, count){ return collection.slice(0, count); }, take_every: function(collection, nth){ let result = []; let index = 0; for(let elem of collection){ if(index % nth === 0){ result.push(elem); } } return Object.freeze(result); }, take_while: function(collection, fun){ let count = 0; for(let elem of collection){ if(fun(elem)){ count = count + 1; }else{ break; } } return collection.slice(0, count); }, to_list: function(collection){ return collection; } }; export default Enum; elixirscript-0.25.0/src/javascript/tests/000077500000000000000000000000001305236071500204205ustar00rootroot00000000000000elixirscript-0.25.0/src/javascript/tests/case.spec.js000066400000000000000000000013141305236071500226210ustar00rootroot00000000000000import Core from "../lib/core"; const Patterns = Core.Patterns; const SpecialForms = Core.SpecialForms; const Tuple = Core.Tuple; import Enum from "../lib/enum"; import chai from 'chai'; var expect = chai.expect; describe('case', () => { it('case', () => { let clauses = [ Patterns.clause( [new Tuple(Symbol.for("selector"), Patterns.variable(), Patterns.variable())], function(i, value){ return value; }, function(i){ return Kernel.is_integer(i); } ), Patterns.clause( [Patterns.variable()], function(value){ return value; } ) ]; let result = SpecialForms._case("thing", clauses); expect(result).to.equal("thing"); }); }); elixirscript-0.25.0/src/javascript/tests/cond.spec.js000066400000000000000000000007551305236071500226410ustar00rootroot00000000000000import Core from "../lib/core"; const Patterns = Core.Patterns; const SpecialForms = Core.SpecialForms; import Enum from "../lib/enum"; import chai from 'chai'; var expect = chai.expect; describe('cond', () => { it('cond', () => { let clauses = [ [ 1 + 1 == 1, () => "This will never match"], [ 2 * 2 != 4, () => "Nor this"], [ true, () => "This will"], ]; let result = SpecialForms.cond(clauses); expect(result).to.equal("This will"); }); }); elixirscript-0.25.0/src/javascript/tests/core/000077500000000000000000000000001305236071500213505ustar00rootroot00000000000000elixirscript-0.25.0/src/javascript/tests/core/functions.spec.js000066400000000000000000000013721305236071500246520ustar00rootroot00000000000000import Core from '../../lib/core'; const Functions = Core.Functions; import chai from 'chai'; const expect = chai.expect; describe('Functions', () => { it('call_property', () => { expect(Functions.call_property(1, 'toString')).to.equal('1'); expect(Functions.call_property([], 'toString')).to.equal(''); expect(Functions.call_property([], 'length')).to.equal(0); expect(Functions.call_property('', 'toString')).to.equal(''); expect(Functions.call_property('', 'length')).to.equal(0); expect(Functions.call_property(Symbol('test'), 'toString')).to.equal('Symbol(test)'); expect(Functions.call_property({ completed: false }, 'completed')).to.equal(false); expect(Functions.call_property({ id: 0 }, 'id')).to.equal(0); }); }); elixirscript-0.25.0/src/javascript/tests/for.spec.js000066400000000000000000000065661305236071500225120ustar00rootroot00000000000000import Core from "../lib/core"; const Patterns = Core.Patterns; const SpecialForms = Core.SpecialForms; const Tuple = Core.Tuple; const BitString = Core.BitString; import Enum from "../lib/enum"; import chai from "chai"; var expect = chai.expect; const $ = Patterns.variable(); const collectable = { into: function(original) { const fun = Patterns.defmatch( Patterns.clause( [ $, Patterns.type(Tuple, { values: [Symbol.for("cont"), Patterns.variable()] }) ], (list, x) => list.concat([x]) ), Patterns.clause([$, Symbol.for("done")], list => list) ); return new Tuple([], fun); } }; describe("for", () => { it("simple for", () => { let gen = Patterns.list_generator($, [1, 2, 3, 4]); let result = SpecialForms._for( Patterns.clause([$], x => x * 2), [gen], collectable ); expect(result).to.eql([2, 4, 6, 8]); }); it("for with multiple generators", () => { //for x <- [1, 2], y <- [2, 3], do: x*y let gen = Patterns.list_generator($, [1, 2]); let gen2 = Patterns.list_generator($, [2, 3]); let result = SpecialForms._for( Patterns.clause([$, $], (x, y) => x * y), [gen, gen2], collectable ); expect(result).to.eql([2, 3, 4, 6]); }); it("for with filter", () => { //for n <- [1, 2, 3, 4, 5, 6], rem(n, 2) == 0, do: n let gen = Patterns.list_generator($, [1, 2, 3, 4, 5, 6]); let result = SpecialForms._for( Patterns.clause([$], x => x, x => x % 2 === 0), [gen], collectable ); expect(result).to.eql([2, 4, 6]); }); it("for with pattern matching", () => { //for {:user, name} <- [user: "john", admin: "john", user: "meg"], do // String.upcase(name) //end let gen = Patterns.list_generator([Symbol.for("user"), $], [ [Symbol.for("user"), "john"], [Symbol.for("admin"), "john"], [Symbol.for("user"), "meg"] ]); let result = SpecialForms._for( Patterns.clause([[Symbol.for("user"), $]], name => name.toUpperCase()), [gen], collectable ); expect(result).to.eql(["JOHN", "MEG"]); }); it("for with bitstring", () => { //for <> >>, do: {r, g, b} let gen = Patterns.bitstring_generator( Patterns.bitStringMatch( BitString.integer({ value: $ }), BitString.integer({ value: $ }), BitString.integer({ value: $ }) ), new BitString( BitString.integer(213), BitString.integer(45), BitString.integer(132), BitString.integer(64), BitString.integer(76), BitString.integer(32), BitString.integer(76), BitString.integer(0), BitString.integer(0), BitString.integer(234), BitString.integer(32), BitString.integer(15) ) ); let expression = Patterns.clause( [ Patterns.bitStringMatch( BitString.integer({ value: $ }), BitString.integer({ value: $ }), BitString.integer({ value: $ }) ) ], (r, g, b) => new Tuple(r, g, b) ); let result = SpecialForms._for(expression, [gen], collectable); expect(result).to.eql([ new Tuple(213, 45, 132), new Tuple(64, 76, 32), new Tuple(76, 0, 0), new Tuple(234, 32, 15) ]); }); }); elixirscript-0.25.0/src/javascript/tests/special_forms.spec.js000066400000000000000000000017321305236071500245400ustar00rootroot00000000000000import Core from "../lib/core"; const SpecialForms = Core.SpecialForms; import chai from 'chai'; var expect = chai.expect; describe('SpecialForms', function(){ describe('map_update', function(){ it('creates new object', function(){ const foo = Object.freeze({foo: "bar", fizz: "buzz"}); const bar = SpecialForms.map_update(foo, {baz: "bar", fizz: "fizzbuzz"}); expect(foo instanceof Object).to.equal(bar instanceof Object); expect(foo.foo).to.equal(bar.foo); expect(bar.fizz).to.equal("fizzbuzz"); expect(foo === bar).to.equal(false); }); it('creates new class', function(){ function MyClass(foo){ this.foo = foo; } const foo = new MyClass("bar"); const bar = SpecialForms.map_update(foo, {baz: "bar", fizz: "fizzbuzz"}); expect(foo instanceof MyClass).to.equal(bar instanceof MyClass); expect(foo.foo).to.equal(bar.foo); expect(bar.fizz).to.equal("fizzbuzz"); }); }); }); elixirscript-0.25.0/src/javascript/tests/try.spec.js000066400000000000000000000014671305236071500225350ustar00rootroot00000000000000import Core from "../lib/core"; const Patterns = Core.Patterns; const SpecialForms = Core.SpecialForms; import Enum from "../lib/enum"; import chai from 'chai'; var expect = chai.expect; describe('try', () => { it('try', () => { /* try do 1 / x else y when y < 1 and y > -1 -> :small _ -> :large end */ let x = 1; let value = SpecialForms._try(function() { return 1 / x; }, null, null, Patterns.defmatch(Patterns.clause([Patterns.variable()], function(y) { return Symbol.for('small'); }, function(y) { return (y < 1) && (y > -1); }), Patterns.clause([Patterns.wildcard()], function() { return Symbol.for('large'); })), null); expect(value).to.equal(Symbol.for('large')); }); }); elixirscript-0.25.0/src/javascript/tests/with.spec.js000066400000000000000000000077111305236071500226700ustar00rootroot00000000000000import Core from "../lib/core"; const Patterns = Core.Patterns; const SpecialForms = Core.SpecialForms; const Tuple = Core.Tuple; const MatchError = Core.Patterns.MatchError; import Enum from "../lib/enum"; import chai from 'chai'; var expect = chai.expect; const $ = Patterns.variable(); function map_fetch(map, key){ if(key in map){ return new Tuple(Symbol.for('ok'), map[key]); } return Symbol.for('error'); } describe('with', () => { it('normal', () => { /* opts = %{width: 10, height: 15} with {:ok, width} <- Map.fetch(opts, :width), {:ok, height} <- Map.fetch(opts, :height), do: {:ok, width * height} {:ok, 150} */ let opts = { width: 10, height: 15 }; let value = SpecialForms._with( [new Tuple(Symbol.for('ok'), $), () => map_fetch(opts, "width")], [new Tuple(Symbol.for('ok'), $), (width) => map_fetch(opts, "height")], (width, height) => new Tuple(Symbol.for('ok'), width * height) ); expect(value).to.eql(new Tuple(Symbol.for('ok'), 150)); }); it('without match', () => { /* opts = %{width: 10} with {:ok, width} <- Map.fetch(opts, :width), {:ok, height} <- Map.fetch(opts, :height), do: {:ok, width * height} :error */ let opts = { width: 10 }; let value = SpecialForms._with( [new Tuple(Symbol.for('ok'), $), () => map_fetch(opts, "width")], [new Tuple(Symbol.for('ok'), $), (width) => map_fetch(opts, "height")], (width, height) => new Tuple(Symbol.for('ok'), width * height) ); expect(value).to.eql(Symbol.for('error')); }); it('bare expression', () => { /* opts = %{width: 10} with {:ok, width} <- Map.fetch(opts, :width), double_width = width * 2, {:ok, height} <- Map.fetch(opts, :height), do: {:ok, double_width * height} {:ok, 300} */ let opts = { width: 10, height: 15 }; let value = SpecialForms._with( [new Tuple(Symbol.for('ok'), $), () => map_fetch(opts, "width")], [$, (width) => width * 2], [new Tuple(Symbol.for('ok'), $), (width, double_width) => map_fetch(opts, "height")], (width, double_width, height) => new Tuple(Symbol.for('ok'), double_width * height) ); expect(value).to.eql(new Tuple(Symbol.for('ok'), 300)); }); it('with else', () => { /* opts = %{width: 10} with {:ok, width} <- Map.fetch(opts, :width), {:ok, height} <- Map.fetch(opts, :height) do {:ok, width * height} else :error -> {:error, :wrong_data} end {:error, :wrong_data} */ let opts = { width: 10 }; let value = SpecialForms._with( [new Tuple(Symbol.for('ok'), $), () => map_fetch(opts, "width")], [new Tuple(Symbol.for('ok'), $), (width) => map_fetch(opts, "height")], (width, height) => new Tuple(Symbol.for('ok'), width * height), Patterns.defmatch( Patterns.clause([Symbol.for('error')], () => new Tuple(Symbol.for('error'), Symbol.for('wrong_data'))) ) ); expect(value).to.eql(new Tuple(Symbol.for('error'), Symbol.for('wrong_data'))); }); it('with else that don`t match', () => { /* opts = %{width: 10} with {:ok, width} <- Map.fetch(opts, :width), {:ok, height} <- Map.fetch(opts, :height) do {:ok, width * height} else :fail -> {:error, :wrong_data} end {:error, :wrong_data} */ let opts = { width: 10 }; let withFunction = SpecialForms._with.bind( null, [new Tuple(Symbol.for('ok'), $), () => map_fetch(opts, "width")], [new Tuple(Symbol.for('ok'), $), (width) => map_fetch(opts, "height")], (width, height) => new Tuple(Symbol.for('ok'), width * height), Patterns.defmatch( Patterns.clause([Symbol.for('fail')], () => new Tuple(Symbol.for('error'), Symbol.for('wrong_data'))) ) ); expect(withFunction).to.throw(MatchError, 'No match for: Symbol(error)'); }); }); elixirscript-0.25.0/test/000077500000000000000000000000001305236071500153005ustar00rootroot00000000000000elixirscript-0.25.0/test/compiler/000077500000000000000000000000001305236071500171125ustar00rootroot00000000000000elixirscript-0.25.0/test/compiler/cache_test.exs000066400000000000000000000027131305236071500217400ustar00rootroot00000000000000defmodule ElixirScript.Compiler.Cache.Test do use ExUnit.Case alias ElixirScript.Compiler.Cache test "no changes found when old and new are empty" do old = [] new = [] assert Cache.get_changed_files(old, new) == [] end test "all new changes found when old empty and new has files" do old = [] new = [{"file.ex", %{mtime: 1}}] assert Cache.get_changed_files(old, new) == new end test "all new changes found when old not emtpy and new is empty" do old = [{"file.ex", %{mtime: 1}}] new = [] assert Cache.get_changed_files(old, new) == new end test "all new changes found when old and new have same size but different file" do old = [{"file.ex", %{mtime: 1}}] new = [{"new_file.ex", %{mtime: 1}}] assert Cache.get_changed_files(old, new) == new end test "all new changes found when old and new have same file and different size" do old = [{"file.ex", %{mtime: 1}}] new = [{"file.ex", %{mtime: 2}}] assert Cache.get_changed_files(old, new) == new end test "no changes found when old and new have same file and size" do old = [{"file.ex", %{mtime: 1}}] new = [{"file.ex", %{mtime: 1}}] assert Cache.get_changed_files(old, new) == [] end test "all new changes found when old has less files than new" do old = [{"file.ex", %{mtime: 1}}] new = [{"file.ex", %{mtime: 1}}, {"new_file.ex", %{mtime: 1}}] assert Cache.get_changed_files(old, new) == new end end elixirscript-0.25.0/test/elixir_script_test.exs000066400000000000000000000034751305236071500217510ustar00rootroot00000000000000defmodule ElixirScript.Test do use ExUnit.Case import ElixirScript.TestHelper test "turn javascript ast into javascript code strings" do js_code = ElixirScript.compile(":atom") assert Enum.join(js_code, "\n") |> String.trim == "Symbol.for('atom')" end test "parse macros" do js_code = ElixirScript.compile(""" defmodule Animals do use ElixirScript.Using defp something_else() do ElixirScript.Math.squared(1) end end """, %{ env: make_custom_env() }) assert_js_matches """ import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; const something_else = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([],function() { return 1 * 1; })); const sandwich = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([],function() { return null; })); export default { sandwich }; """, List.last(js_code) end test "set standard lib path" do js_code = ElixirScript.compile(""" defmodule Animals do use ElixirScript.Using defp something_else() do ElixirScript.Math.squared(1) end end """, %{ env: make_custom_env(), core_path: "elixirscript"} ) assert_js_matches """ import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; const something_else = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([],function() { return 1 * 1; })); const sandwich = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([],function() { return null; })); export default { sandwich }; """, List.last(js_code) end end elixirscript-0.25.0/test/prelude/000077500000000000000000000000001305236071500167405ustar00rootroot00000000000000elixirscript-0.25.0/test/prelude/js_test.exs000066400000000000000000000012411305236071500211320ustar00rootroot00000000000000defmodule ElixirScript.Lib.JS.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate new" do ex_ast = quote do JS.new A.B, [1, 2, 3] end js_code = """ new A.B(1, 2, 3) """ assert_translation(ex_ast, js_code) ex_ast = quote do JS.new A, [1, 2, 3] end js_code = """ new A(1, 2, 3) """ assert_translation(ex_ast, js_code) end test "translate update" do ex_ast = quote do JS.update A, %{"b" => [1, 2, 3]} end js_code = """ Object.assign(A, Object.freeze({ b: Object.freeze([1, 2, 3]) })) """ assert_translation(ex_ast, js_code) end end elixirscript-0.25.0/test/prelude/kernel_test.exs000066400000000000000000000014731305236071500220050ustar00rootroot00000000000000defmodule ElixirScript.Lib.Elixir.Kernel.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate range" do ex_ast = quote do 1..4 end js_code = """ Elixir$ElixirScript$Range.Elixir$ElixirScript$Range.create(Object.freeze({ [Symbol.for('first')]: 1, [Symbol.for('last')]: 4 })) """ assert_translation(ex_ast, js_code) end test "translate sigil_r" do ex_ast = quote do ~r/foo/ end js_code = """ Elixir$ElixirScript$Regex.compile__emark__('foo','') """ assert_translation(ex_ast, js_code) end test "translate sigil_r with options" do ex_ast = quote do ~r/foo/ig end js_code = """ Elixir$ElixirScript$Regex.compile__emark__('foo', 'ig') """ assert_translation(ex_ast, js_code) end end elixirscript-0.25.0/test/test_helper.exs000066400000000000000000000026301305236071500203400ustar00rootroot00000000000000exclude = if Node.alive?, do: [], else: [skip: true] ExUnit.start(exclude: exclude) defmodule ElixirScript.Math do defmacro squared(x) do quote do unquote(x) * unquote(x) end end end defmodule ElixirScript.Using do defmacro __using__(_) do quote do def sandwich() do end end end end defmodule ElixirScript.TestHelper do use ExUnit.Case def make_custom_env do use ElixirScript require ElixirScript.Math require ElixirScript.Using __ENV__ end def ex_ast_to_js(ex_ast, format) do ElixirScript.compile_quoted(ex_ast, %{ env: make_custom_env(), import_standard_libs: false, format: format }) end def strip_spaces(js) do js |> String.replace(~r/\s+/, "") end def assert_translation(ex_ast, js_code) do assert_translation(ex_ast, js_code, :es) end def assert_translation(ex_ast, js_code, format) do converted_code = ex_ast_to_js(ex_ast, format) |> Elixir.Enum.join("\n\n") assert converted_code |> strip_spaces == strip_spaces(js_code), """ **Code Does Not Match ** ***Expected*** #{js_code} ***Actual*** #{converted_code} """ end def assert_js_matches(expected_js_code, actual_js_code) do assert strip_spaces(expected_js_code) == strip_spaces(actual_js_code), """ **Code Does Not Match ** ***Expected*** #{expected_js_code} ***Actual*** #{actual_js_code} """ end end elixirscript-0.25.0/test/translator/000077500000000000000000000000001305236071500174715ustar00rootroot00000000000000elixirscript-0.25.0/test/translator/access_test.exs000066400000000000000000000005241305236071500225130ustar00rootroot00000000000000defmodule ElixirScript.Translator.Access.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate access" do ex_ast = quote do: a[:b] js_code = "a[Symbol.for('b')]" assert_translation(ex_ast, js_code) ex_ast = quote do: a["b"] js_code = "a['b']" assert_translation(ex_ast, js_code) end end elixirscript-0.25.0/test/translator/atom_test.exs000066400000000000000000000006041305236071500222110ustar00rootroot00000000000000defmodule ElixirScript.Translator.Atom.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate atom" do ex_ast = quote do: :atom assert_translation(ex_ast, "Symbol.for('atom')") end test "Call Atom module" do ex_ast = quote do: Atom.to_string(:atom) assert_translation(ex_ast, "Elixir$ElixirScript$Atom.to_string(Symbol.for('atom'))") end end elixirscript-0.25.0/test/translator/bitstring_test.exs000066400000000000000000000076201305236071500232630ustar00rootroot00000000000000defmodule ElixirScript.Translator.Bitstring.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate bitstring" do ex_ast = quote do: <<1, 2, 3>> assert_translation(ex_ast, "new Elixir.Core.BitString(Elixir.Core.BitString.integer(1), Elixir.Core.BitString.integer(2), Elixir.Core.BitString.integer(3))") ex_ast = quote do: <<1, "foo">> assert_translation(ex_ast, "new Elixir.Core.BitString(Elixir.Core.BitString.integer(1), Elixir.Core.BitString.binary('foo'))") ex_ast = quote do: <<1, "foo" :: binary>> assert_translation(ex_ast, "new Elixir.Core.BitString(Elixir.Core.BitString.integer(1), Elixir.Core.BitString.binary('foo'))") ex_ast = quote do: <<1, "foo" :: utf8, "bar" :: utf32>> assert_translation(ex_ast, "new Elixir.Core.BitString(Elixir.Core.BitString.integer(1), Elixir.Core.BitString.utf8('foo'), Elixir.Core.BitString.utf32('bar'))") ex_ast = quote do: <<102 :: integer-native, rest :: binary>> assert_translation(ex_ast, "new Elixir.Core.BitString(Elixir.Core.BitString.native(Elixir.Core.BitString.integer(102)), Elixir.Core.BitString.binary(rest))") ex_ast = quote do: <<102 :: unsigned-big-integer, rest :: binary>> assert_translation(ex_ast, "new Elixir.Core.BitString(Elixir.Core.BitString.integer(Elixir.Core.BitString.big(Elixir.Core.BitString.unsigned(102))), Elixir.Core.BitString.binary(rest))") ex_ast = quote do: <<102, _rest :: size(16)>> assert_translation(ex_ast, "new Elixir.Core.BitString(Elixir.Core.BitString.integer(102), Elixir.Core.BitString.size(_rest, 16))") ex_ast = quote do: <<102, _rest :: size(16)-unit(4)>> assert_translation(ex_ast, "new Elixir.Core.BitString(Elixir.Core.BitString.integer(102), Elixir.Core.BitString.unit(Elixir.Core.BitString.size(_rest, 16), 4))") ex_ast = quote do: <<102, _rest :: 16 * 4>> assert_translation(ex_ast, "new Elixir.Core.BitString(Elixir.Core.BitString.integer(102), Elixir.Core.BitString.unit(Elixir.Core.BitString.size(_rest, 16), 4))") ex_ast = quote do: <<102, _rest :: _ * 4>> assert_translation(ex_ast, "new Elixir.Core.BitString(Elixir.Core.BitString.integer(102), Elixir.Core.BitString.unit(Elixir.Core.BitString.size(_rest, undefined), 4))") ex_ast = quote do: <<102, _rest :: 16>> assert_translation(ex_ast, "new Elixir.Core.BitString(Elixir.Core.BitString.integer(102), Elixir.Core.BitString.size(_rest, 16))") ex_ast = quote do: << 1, <<2>> >> assert_translation(ex_ast, "new Elixir.Core.BitString(Elixir.Core.BitString.integer(1), new Elixir.Core.BitString(Elixir.Core.BitString.integer(2)))") end test "translate pattern matching bitstring" do ex_ast = quote do: <> = <<"Frank the Walrus">> js_code = """ let [name,species] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.bitStringMatch(Elixir.Core.BitString.size(Elixir.Core.BitString.binary({ 'value': Elixir.Core.Patterns.variable() }),5),Elixir.Core.BitString.binary(' the '),Elixir.Core.BitString.binary({ 'value': Elixir.Core.Patterns.variable() })),'Frank the Walrus'); """ assert_translation(ex_ast, js_code) ex_ast = quote do: <> = <<-100>> js_code = """ let [int] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.bitStringMatch(Elixir.Core.BitString.integer({ 'value': Elixir.Core.Patterns.variable() })),new Elixir.Core.BitString(Elixir.Core.BitString.binary(-100))); """ assert_translation(ex_ast, js_code) ex_ast = quote do: <<-100::signed, _rest::binary>> = <<-100, "foo">> js_code = """ let [_rest] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.bitStringMatch(Elixir.Core.BitString.signed(-100),Elixir.Core.BitString.binary({ 'value': Elixir.Core.Patterns.variable() })),new Elixir.Core.BitString(Elixir.Core.BitString.binary(-100),Elixir.Core.BitString.binary('foo'))); """ assert_translation(ex_ast, js_code) end end elixirscript-0.25.0/test/translator/bitwise_test.exs000066400000000000000000000004231305236071500227160ustar00rootroot00000000000000defmodule ElixirScript.Translator.Bitwise.Test do use ExUnit.Case import ElixirScript.TestHelper test "bitwise when imported" do ex_ast = quote do import Bitwise 1 &&& 2 end js_code = "1 & 2" assert_translation(ex_ast, js_code) end end elixirscript-0.25.0/test/translator/bug_test.exs000066400000000000000000000103271305236071500220310ustar00rootroot00000000000000defmodule ElixirScript.Translator.Bug.Test do use ExUnit.Case import ElixirScript.TestHelper test "Translate function with 0 arguments" do ex_ast = quote do def test do :atom end end js_code = """ const test = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([],function(){ return Symbol.for('atom'); })); """ assert_translation(ex_ast, js_code) end test "Translate react element" do ex_ast = quote do React.createElement( React.Text, %{"style" => styles().welcome}, "Welcome to React Native!" ) end js_code = """ React.createElement(React.Text,Object.freeze({ style: Elixir.Core.Functions.call_property(styles,'welcome') }),'Welcome to React Native!') """ assert_translation(ex_ast, js_code) end test "correctly not create 2 imports" do ex_ast = quote do defmodule App.Todo do JS.import JQuery, "jquery" JQuery.(e.target) end end js_code = """ import JQuery from 'jquery'; import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; JQuery(Elixir.Core.Functions.call_property(e,'target')); export default {}; """ assert_translation(ex_ast, js_code) end test "correctly translate module names when used" do ex_ast = quote do @graphic_store App.Stores.GraphicStore.create_store() end js_code = """ const graphic_store = Elixir.Core.Functions.call_property(App.Stores.GraphicStore, 'create_store'); """ assert_translation(ex_ast, js_code) end test "replace !" do ex_ast = quote do Elixir.Enum.fetch!(data, i) end js_code = """ Elixir.Enum.fetch__emark__(data, i) """ assert_translation(ex_ast, js_code) end test "chain calls correctly" do ex_ast = quote do :this.getRawCanvas().getContext("2d") end js_code = """ Elixir.Core.Functions.call_property(this, 'getRawCanvas').getContext('2d') """ assert_translation(ex_ast, js_code) ex_ast = quote do :this.getRawCanvas(one).get("fg").getContext("2d") end js_code = """ this.getRawCanvas(one).get('fg').getContext('2d') """ assert_translation(ex_ast, js_code) end test "correctly call multi-module functions" do ex_ast = quote do def getDispatcher() do DeLorean.Flux.createDispatcher(%{ startPainting: fn() -> this.dispatch("startPainting") end, stopPainting: fn() -> this.dispatch("stopPainting") end, addPoint: fn(data) -> this.dispatch("addPoint", data) end, getStores: fn() -> %{ graphic: GraphicStore } end }) end end js_code = """ const getDispatcher = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([],function() { return DeLorean.Flux.createDispatcher(Object.freeze({ [Symbol.for('startPainting')]: Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([],function() { return this.dispatch('startPainting'); })), [Symbol.for('stopPainting')]: Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([],function() { return this.dispatch('stopPainting'); })), [Symbol.for('addPoint')]: Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()],function(data) { return this.dispatch('addPoint',data); })), [Symbol.for('getStores')]: Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([],function() { return Object.freeze({ [Symbol.for('graphic')]: GraphicStore }); })) })); })); """ assert_translation(ex_ast, js_code) end test "test array returns correctly" do ex_ast = quote do def my_func(x) do [x.a, x.b] end end js_code = """ const my_func = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()],function(x){ return Object.freeze([Elixir.Core.Functions.call_property(x,'a'), Elixir.Core.Functions.call_property(x,'b')]); })); """ assert_translation(ex_ast, js_code) end end elixirscript-0.25.0/test/translator/capture_test.exs000066400000000000000000000064051305236071500227210ustar00rootroot00000000000000defmodule ElixirScript.Translator.Capture.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate capture operator with Module, function, and arity" do ex_ast = quote do fun = &Elixir.Kernel.is_atom/1 end js_code = """ let [fun] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),Elixir$ElixirScript$Kernel.is_atom); """ assert_translation(ex_ast, js_code) end test "translate capture operator with function, and parameters" do ex_ast = quote do fun = &is_atom(&1) end js_code = """ let [fun] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()],function(__1) { return Elixir$ElixirScript$Kernel.is_atom(__1); }))); """ assert_translation(ex_ast, js_code) end test "translate capture operator with function, and arity" do ex_ast = quote do fun = &local_function/1 end js_code = """ let [fun] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),local_function); """ assert_translation(ex_ast, js_code) end test "translate capture operator with anonymous function" do ex_ast = quote do fun = &(&1 * 2) end js_code = """ let [fun] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()],function(__1) { return __1 * 2; }))); """ assert_translation(ex_ast, js_code) end test "translate capture operator with anonymous function tuple" do ex_ast = quote do fun = &{&1, &2} end js_code = """ let [fun] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()],function(__1,__2) { return new Elixir.Core.Tuple(__1,__2); }))); """ assert_translation(ex_ast, js_code) ex_ast = quote do fun = &{&1, &2, &3} end js_code = """ let [fun] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()],function(__1,__2,__3) { return new Elixir.Core.Tuple(__1,__2,__3); }))); """ assert_translation(ex_ast, js_code) end test "translate capture operator with anonymous functions as parameters" do ex_ast = quote do Elixir.Enum.map(items, &process(&1)) end js_code = """ Elixir.Enum.map(items,Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()],function(__1) { return process(__1); }))) """ assert_translation(ex_ast, js_code) ex_ast = quote do elem.keypress(&process_event(&1)) end js_code = """ elem.keypress(Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()],function(__1) { return process_event(__1); }))) """ assert_translation(ex_ast, js_code) end end elixirscript-0.25.0/test/translator/case_test.exs000066400000000000000000000150221305236071500221640ustar00rootroot00000000000000defmodule ElixirScript.Translator.Case.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate case" do ex_ast = quote do case data do :ok -> value :error -> nil end end js_code = """ Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Symbol.for('ok')],function() { return value; }),Elixir.Core.Patterns.clause([Symbol.for('error')],function() { return null; })).call(this,data) """ assert_translation(ex_ast, js_code) ex_ast = quote do case data do false -> value = 13 true -> true end end js_code = """ Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([false],function() { let [value] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),13); return value; }),Elixir.Core.Patterns.clause([true],function() { return true; })).call(this,data) """ assert_translation(ex_ast, js_code) ex_ast = quote do case data do false -> value = 13 _ -> true end end js_code = """ Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([false],function() { let [value] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),13); return value; }),Elixir.Core.Patterns.clause([Elixir.Core.Patterns.wildcard()],function() { return true; })).call(this,data) """ assert_translation(ex_ast, js_code) end test "translate case with guard" do ex_ast = quote do case data do number when number in [1,2,3,4] -> value = 13 _ -> true end end js_code = """ Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()],function(number) { let [value] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),13); return value; },function(number) { return Elixir.Core.Functions.contains(number,Object.freeze([1, 2, 3, 4])); }),Elixir.Core.Patterns.clause([Elixir.Core.Patterns.wildcard()],function() { return true; })).call(this,data) """ assert_translation(ex_ast, js_code) end test "translate case with multiple statements in body" do ex_ast = quote do case data do :ok -> :console.info("info") Todo.add(data) :error -> nil end end js_code = """ Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Symbol.for('ok')],function() { console.info('info'); return Todo.add(data); }),Elixir.Core.Patterns.clause([Symbol.for('error')],function() { return null; })).call(this,data) """ assert_translation(ex_ast, js_code) end test "translate case with destructing" do ex_ast = quote do case data do { one, two } -> :console.info(one) :error -> nil end end js_code = """ Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.type(Elixir.Core.Tuple, { values: [Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()] })], function(one, two) { return console.info(one); }), Elixir.Core.Patterns.clause([Symbol.for('error')], function() { return null; })).call(this, data) """ assert_translation(ex_ast, js_code) end test "translate case with nested destructing" do ex_ast = quote do case data do { {one, two} , three } -> :console.info(one) :error -> nil end end js_code = """ Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.type(Elixir.Core.Tuple, { values: [Elixir.Core.Patterns.type(Elixir.Core.Tuple, { values: [Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()] }), Elixir.Core.Patterns.variable()] })], function(one, two, three) { return console.info(one); }), Elixir.Core.Patterns.clause([Symbol.for('error')], function() { return null; })).call(this, data) """ assert_translation(ex_ast, js_code) ex_ast = quote do case data do { one, {two, three} } -> :console.info(one) :error -> nil end end js_code = """ Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.type(Elixir.Core.Tuple, { values: [Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.type(Elixir.Core.Tuple, { values: [Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()] })] })], function(one, two, three) { return console.info(one); }), Elixir.Core.Patterns.clause([Symbol.for('error')], function() { return null; })).call(this, data) """ assert_translation(ex_ast, js_code) ex_ast = quote do case data do %AStruct{key: %BStruct{ key2: value }} -> :console.info(value) :error -> nil end end js_code = """ Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.type(AStruct, { [Symbol.for('key')]: Elixir.Core.Patterns.type(BStruct, { [Symbol.for('key2')]: Elixir.Core.Patterns.variable() }) })], function(value) { return console.info(value); }), Elixir.Core.Patterns.clause([Symbol.for('error')], function() { return null; })).call(this, data) """ assert_translation(ex_ast, js_code) ex_ast = quote do case data do %AStruct{key: %BStruct{ key2: value, key3: %CStruct{ key4: value2 } }} -> :console.info(value) :error -> nil end end js_code = """ Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.type(AStruct, { [Symbol.for('key')]: Elixir.Core.Patterns.type(BStruct, { [Symbol.for('key2')]: Elixir.Core.Patterns.variable(), [Symbol.for('key3')]: Elixir.Core.Patterns.type(CStruct, { [Symbol.for('key4')]: Elixir.Core.Patterns.variable() }) }) })], function(value, value2) { return console.info(value); }), Elixir.Core.Patterns.clause([Symbol.for('error')], function() { return null; })).call(this, data) """ assert_translation(ex_ast, js_code) end end elixirscript-0.25.0/test/translator/commonjs_test.exs000066400000000000000000000074321305236071500231040ustar00rootroot00000000000000defmodule ElixirScript.Translator.CommonJS.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate module to commonjs" do ex_ast = quote do defmodule Elephant do @ul JQuery.("#todo-list") def something() do @ul end defgenp something_else() do end end end js_code = """ const Elixir$ElixirScript$Kernel = require('../elixir/Elixir.ElixirScript.Kernel'); const something_else = Elixir.Core.Patterns.defmatchgen(Elixir.Core.Patterns.clause([], function*() { return null; })); const something = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([], function() { return ul; })); const ul = JQuery('#todo-list'); module.exports = { something } """ assert_translation(ex_ast, js_code, :common) end test "protocol to commonjs" do ex_ast = quote do defprotocol Blank do def blank?(data) end defimpl Blank, for: Integer do def blank?(number), do: false end defimpl Blank, for: List do def blank?([]), do: true def blank?(_), do: false end defimpl Blank, for: Atom do def blank?(false), do: true def blank?(nil), do: true def blank?(_), do: false end end js_code = """ const Elixir = require('../elixir/Elixir.Bootstrap'); const Elixir$Blank$DefImpl$Elixir$Integer = require('../app/Elixir.Blank.DefImpl.Elixir.Integer'); const Elixir$Blank$DefImpl$Elixir$List = require('../app/Elixir.Blank.DefImpl.Elixir.List'); const Elixir$Blank$DefImpl$Elixir$Atom = require('../app/Elixir.Blank.DefImpl.Elixir.Atom'); let impls = []; impls.push(Elixir$Blank$DefImpl$Elixir$Integer) impls.push(Elixir$Blank$DefImpl$Elixir$List) impls.push(Elixir$Blank$DefImpl$Elixir$Atom) module.exports = impls const Implementations = require('../app/Elixir.Blank.Defimpl'); const Elixir$ElixirScript$Kernel = require('../elixir/Elixir.ElixirScript.Kernel'); const Elixir$Blank = Elixir.Core.Functions.defprotocol({ blank__qmark__: function() {} }); for (let {Type, Implementation} of Implementations) Elixir.Core.Functions.defimpl(Elixir$Blank, Type, Implementation) module.exports = Elixir$Blank const Elixir$ElixirScript$Kernel = require('../elixir/Elixir.ElixirScript.Kernel'); const blank__qmark__ = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()], function(number) { return false; })); module.exports = { 'Type': Elixir.Core.Integer, 'Implementation': { blank__qmark__ } } const Elixir$ElixirScript$Kernel = require('../elixir/Elixir.ElixirScript.Kernel'); const blank__qmark__ = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Object.freeze([])], function() { return true; }), Elixir.Core.Patterns.clause([Elixir.Core.Patterns.wildcard()], function() { return false; })); module.exports = { 'Type': Array, 'Implementation': { blank__qmark__ } } const Elixir$ElixirScript$Kernel = require('../elixir/Elixir.ElixirScript.Kernel'); const blank__qmark__ = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([false], function() { return true; }), Elixir.Core.Patterns.clause([null], function() { return true; }), Elixir.Core.Patterns.clause([Elixir.Core.Patterns.wildcard()], function() { return false; })); module.exports = { 'Type': Symbol, 'Implementation': { blank__qmark__ } } """ assert_translation(ex_ast, js_code, :common) end end elixirscript-0.25.0/test/translator/cond_test.exs000066400000000000000000000031251305236071500221750ustar00rootroot00000000000000defmodule ElixirScript.Translator.Cond.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate cond" do ex_ast = quote do cond do 1 + 1 == 1 -> "This will never match" 2 * 2 != 4 -> "Nor this" true -> "This will" end end js_code = """ Elixir.Core.SpecialForms.cond(Object.freeze([1 + 1 == 1, function() { return 'This will never match'; }]),Object.freeze([2 * 2 != 4, function() { return 'Nor this'; }]),Object.freeze([true, function() { return 'This will'; }])) """ assert_translation(ex_ast, js_code) ex_ast = quote do cond do 1 + 1 == 1 -> a = 1 "This will never match" 2 * 2 != 4 -> a = 2 "Nor this" true -> a = 3 "This will" end end js_code = """ Elixir.Core.SpecialForms.cond(Object.freeze([1 + 1 == 1, function() { let [a] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),1); return 'This will never match'; }]),Object.freeze([2 * 2 != 4, function() { let [a] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),2); return 'Nor this'; }]),Object.freeze([true, function() { let [a] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),3); return 'This will'; }])) """ assert_translation(ex_ast, js_code) end end elixirscript-0.25.0/test/translator/defmodule_test.exs000066400000000000000000000210521305236071500232150ustar00rootroot00000000000000defmodule ElixirScript.Translator.Defmodule.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate empty module" do ex_ast = quote do defmodule Elephant do end end js_code = """ import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; export default {}; """ assert_translation(ex_ast, js_code) end test "translate defmodules" do ex_ast = quote do defmodule Elephant do @ul JQuery.("#todo-list") def something() do @ul end defgenp something_else() do end end end js_code = """ import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; const something_else = Elixir.Core.Patterns.defmatchgen(Elixir.Core.Patterns.clause([],function*() { return null; })); const something = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([],function() { return ul; })); const ul = JQuery('#todo-list'); export default { something }; """ assert_translation(ex_ast, js_code) end test "translate modules with inner modules" do ex_ast = quote do defmodule Animals do defmodule Elephant do defstruct trunk: true end def something() do %Elephant{} end defp something_else() do end end end js_code = """ import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; import Elixir$Animals$Elephant from '../app/Elixir.Animals.Elephant'; const something_else = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([],function() { return null; })); const something = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([],function() { return Elixir$Animals$Elephant.Elixir$Animals$Elephant.create(Object.freeze({})); })); export default { something }; import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; const Elixir$Animals$Elephant = Elixir.Core.Functions.defstruct({ [Symbol.for('__struct__')]: Symbol.for('Elixir.Animals.Elephant'), [Symbol.for('trunk')]: true }); export default { Elixir$Animals$Elephant }; """ assert_translation(ex_ast, js_code) end test "translate modules with inner module that has inner module" do ex_ast = quote do defmodule Animals do defmodule Elephant do defstruct trunk: true defmodule Bear do defstruct trunk: true end end def something() do %Elephant{} end defp something_else() do end end end js_code = """ import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; import Elixir$Animals$Elephant from '../app/Elixir.Animals.Elephant'; const something_else = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([],function() { return null; })); const something = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([],function() { return Elixir$Animals$Elephant.Elixir$Animals$Elephant.create(Object.freeze({})); })); export default { something }; import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; import Elixir$Animals$Elephant$Bear from '../app/Elixir.Animals.Elephant.Bear'; const Elixir$Animals$Elephant = Elixir.Core.Functions.defstruct({ [Symbol.for('__struct__')]: Symbol.for('Elixir.Animals.Elephant'), [Symbol.for('trunk')]: true }); export default { Elixir$Animals$Elephant }; import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; const Elixir$Animals$Elephant$Bear = Elixir.Core.Functions.defstruct({ [Symbol.for('__struct__')]: Symbol.for('Elixir.Animals.Elephant.Bear'), [Symbol.for('trunk')]: true }); export default { Elixir$Animals$Elephant$Bear }; """ assert_translation(ex_ast, js_code) end test "Pull out module references and make them into imports if modules listed" do ex_ast = quote do defmodule Animals do Lions.Tigers.oh_my() end defmodule Lions.Tigers do Lions.Tigers.Bears.oh_my() end end js_code = """ import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; import Elixir$Lions$Tigers from '../app/Elixir.Lions.Tigers'; Elixir.Core.Functions.call_property(Elixir$Lions$Tigers,'oh_my'); export default {}; import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; Elixir.Core.Functions.call_property(Lions.Tigers.Bears,'oh_my'); export default {}; """ assert_translation(ex_ast, js_code) end test "ignore aliases already added" do ex_ast = quote do defmodule Animals do alias Lions.Tigers Tigers.oh_my() end defmodule Lions.Tigers do Lions.Tigers.Bears.oh_my() def oh_my() do end end end js_code = """ import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; import Elixir$Lions$Tigers from '../app/Elixir.Lions.Tigers'; Elixir.Core.Functions.call_property(Elixir$Lions$Tigers,'oh_my'); export default {}; import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; const oh_my = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([],function() { return null; })); Elixir.Core.Functions.call_property(Lions.Tigers.Bears,'oh_my'); export default { oh_my }; """ assert_translation(ex_ast, js_code) end test "import only" do ex_ast = quote do defmodule Lions.Tigers do def oh_my() do end def oh_my2() do end end defmodule Animals do import Lions.Tigers, only: [oh_my: 0] oh_my() end end js_code = """ import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; const oh_my = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([], function() { return null; })); const oh_my2 = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([], function() { return null; })); export default { oh_my, oh_my2 }; import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; import Elixir$Lions$Tigers from '../app/Elixir.Lions.Tigers'; Elixir$Lions$Tigers.oh_my(); export default {}; """ assert_translation(ex_ast, js_code) end test "import except" do ex_ast = quote do defmodule Lions.Tigers do def oh_my() do end def oh_my2() do end end defmodule Animals do import Lions.Tigers, except: [oh_my: 1] oh_my2() end end js_code = """ import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; const oh_my = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([], function() { return null; })); const oh_my2 = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([], function() { return null; })); export default { oh_my, oh_my2 }; import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; import Elixir$Lions$Tigers from '../app/Elixir.Lions.Tigers'; Elixir$Lions$Tigers.oh_my2(); export default {}; """ assert_translation(ex_ast, js_code) end test "translate inner module has another inner module alias" do ex_ast = quote do defmodule Version do defmodule Parser do import Parser.DSL end defmodule Parser.DSL do end end end js_code = """ import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; import Elixir$Version$Parser from '../app/Elixir.Version.Parser'; import Elixir$Version$Parser$DSL from '../app/Elixir.Version.Parser.DSL'; export default {}; import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; import Elixir$Version$Parser from '../app/Elixir.Version.Parser'; export default {}; import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; import Elixir$Version$Parser$DSL from '../app/Elixir.Version.Parser.DSL'; export default {}; """ assert_translation(ex_ast, js_code) end end elixirscript-0.25.0/test/translator/for_test.exs000066400000000000000000000147751305236071500220550ustar00rootroot00000000000000defmodule ElixirScript.Translator.For.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate simple for" do ex_ast = quote do for n <- [1, 2, 3, 4], do: n * 2 end js_code = """ Elixir.Core.SpecialForms._for( Elixir.Core.Patterns.clause( [Elixir.Core.Patterns.variable()], function(n) { return n * 2; }, function() { return true; } ), [ Elixir.Core.Patterns.list_generator( Elixir.Core.Patterns.variable(), Object.freeze([1, 2, 3, 4]) ) ], Elixir$ElixirScript$Collectable, Object.freeze([]) ) """ assert_translation(ex_ast, js_code) end test "translate simple for with into" do ex_ast = quote do for n <- [1, 2, 3, 4], into: [], do: n * 2 end js_code = """ Elixir.Core.SpecialForms._for( Elixir.Core.Patterns.clause( [Elixir.Core.Patterns.variable()], function(n) { return n * 2; }, function() { return true; } ), [ Elixir.Core.Patterns.list_generator( Elixir.Core.Patterns.variable(), Object.freeze([1, 2, 3, 4]) ) ], Elixir$ElixirScript$Collectable, Object.freeze([]) ) """ assert_translation(ex_ast, js_code) end test "translate for with string" do ex_ast = quote do for n <- "Opera", do: n end js_code = """ Elixir.Core.SpecialForms._for( Elixir.Core.Patterns.clause( [Elixir.Core.Patterns.variable()], function(n) { return n; }, function() { return true; } ), [ Elixir.Core.Patterns.list_generator( Elixir.Core.Patterns.variable(), 'Opera' ) ], Elixir$ElixirScript$Collectable, Object.freeze([]) ) """ assert_translation(ex_ast, js_code) end test "translate multiple generator for" do ex_ast = quote do for x <- [1, 2], y <- [2, 3], do: x*y end js_code = """ Elixir.Core.SpecialForms._for( Elixir.Core.Patterns.clause( [Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()], function(x, y) { return x * y; }, function() { return true; } ), [ Elixir.Core.Patterns.list_generator( Elixir.Core.Patterns.variable(), Object.freeze([1, 2]) ), Elixir.Core.Patterns.list_generator( Elixir.Core.Patterns.variable(), Object.freeze([2, 3]) ) ], Elixir$ElixirScript$Collectable, Object.freeze([]) ) """ assert_translation(ex_ast, js_code) end test "translate multiple generator for, assignment, and do block" do ex_ast = quote do r = for x <- [1, 2], y <- [2, 3] do x*y end end js_code = """ let [r] = Elixir.Core.Patterns.match( Elixir.Core.Patterns.variable(), Elixir.Core.SpecialForms._for( Elixir.Core.Patterns.clause( [Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()], function(x, y) { return x * y; }, function() { return true; } ), [ Elixir.Core.Patterns.list_generator( Elixir.Core.Patterns.variable(), Object.freeze([1, 2]) ), Elixir.Core.Patterns.list_generator( Elixir.Core.Patterns.variable(), Object.freeze([2, 3]) ) ], Elixir$ElixirScript$Collectable, Object.freeze([]) ) ); """ assert_translation(ex_ast, js_code) end test "translate for with filter" do ex_ast = quote do for n <- [1, 2, 3, 4, 5, 6], rem(n, 2) == 0, do: n end js_code = """ Elixir.Core.SpecialForms._for( Elixir.Core.Patterns.clause( [Elixir.Core.Patterns.variable()], function(n) { return n; }, function(n) { return n % 2 == 0; } ), [ Elixir.Core.Patterns.list_generator( Elixir.Core.Patterns.variable(), Object.freeze([1, 2, 3, 4, 5, 6]) ) ], Elixir$ElixirScript$Collectable, Object.freeze([]) ) """ assert_translation(ex_ast, js_code) end test "translate for with pattern matched input" do ex_ast = quote do for {:user, name} <- [user: "john", admin: "john", user: "meg"] do Elixir.String.upcase(name) end end js_code = """ Elixir.Core.SpecialForms._for( Elixir.Core.Patterns.clause([Elixir.Core.Patterns.type(Elixir.Core.Tuple, { values: [Symbol.for('user'), Elixir.Core.Patterns.variable()] })], function(name) { return Elixir$ElixirScript$String.upcase(name); }, function() { return true; }), [ Elixir.Core.Patterns.list_generator(Elixir.Core.Patterns.type(Elixir.Core.Tuple, { values: [Symbol.for('user'), Elixir.Core.Patterns.variable()] }), Object.freeze([new Elixir.Core.Tuple(Symbol.for('user'), 'john'), new Elixir.Core.Tuple(Symbol.for('admin'), 'john'), new Elixir.Core.Tuple(Symbol.for('user'), 'meg')])) ], Elixir$ElixirScript$Collectable, Object.freeze([])) """ assert_translation(ex_ast, js_code) end test "translate for with bitstring" do ex_ast = quote do for <> do {r, g, b} end end js_code = """ Elixir.Core.SpecialForms._for(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.bitStringMatch(Elixir.Core.BitString.size({ 'value': Elixir.Core.Patterns.variable() }, 8), Elixir.Core.BitString.size({ 'value': Elixir.Core.Patterns.variable() }, 8), Elixir.Core.BitString.size({ 'value': Elixir.Core.Patterns.variable() }, 8))], function(r, g, b) { return new Elixir.Core.Tuple(r, g, b); }, function() { return true; }), [Elixir.Core.Patterns.bitstring_generator(Elixir.Core.Patterns.bitStringMatch(Elixir.Core.BitString.size({ 'value': Elixir.Core.Patterns.variable() }, 8), Elixir.Core.BitString.size({ 'value': Elixir.Core.Patterns.variable() }, 8), Elixir.Core.BitString.size({ 'value': Elixir.Core.Patterns.variable() }, 8)), pixels)], Elixir$ElixirScript$Collectable, Object.freeze([])) """ assert_translation(ex_ast, js_code) end end elixirscript-0.25.0/test/translator/function_test.exs000066400000000000000000000565301305236071500231070ustar00rootroot00000000000000defmodule ElixirScript.Translator.Function.Test do use ExUnit.Case import ElixirScript.TestHelper test "call fun" do ex_ast = quote do fun.(:atom) end js_code = """ fun(Symbol.for('atom')) """ assert_translation(ex_ast, js_code) end test "translate function with a macro" do ex_ast = quote do def test1() do ElixirScript.Math.squared(1) end end js_code = """ const test1 = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([],function() { return 1 * 1; })); """ assert_translation(ex_ast, js_code) end test "translate functions" do ex_ast = quote do def test1() do end end js_code = """ const test1 = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([],function() { return null; })); """ assert_translation(ex_ast, js_code) ex_ast = quote do def test1(alpha, beta) do end end js_code = """ const test1 = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()],function(alpha,beta) { return null; })); """ assert_translation(ex_ast, js_code) ex_ast = quote do def test1(alpha, beta) do a = alpha end end js_code = """ const test1 = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()],function(alpha,beta) { let [a] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),alpha); return a; })); """ assert_translation(ex_ast, js_code) ex_ast = quote do def test1(alpha, beta) do if 1 == 1 do 1 else 2 end end end js_code = """ const test1 = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()],function(alpha,beta) { return Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()],function(x) { return 2; },function(x) { return x === null || x === false; }),Elixir.Core.Patterns.clause([Elixir.Core.Patterns.wildcard()],function() { return 1; })).call(this,1 == 1); })); """ assert_translation(ex_ast, js_code) ex_ast = quote do def test1(alpha, beta) do if 1 == 1 do if 2 == 2 do 4 else a = 1 end else 2 end end end js_code = """ const test1 = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()], function(alpha, beta) { return Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()], function(x) { return 2; }, function(x) { return x === null || x === false; }), Elixir.Core.Patterns.clause([Elixir.Core.Patterns.wildcard()], function() { return Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()], function(x) { let [a] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(), 1); return a; }, function(x) { return x === null || x === false; }), Elixir.Core.Patterns.clause([Elixir.Core.Patterns.wildcard()], function() { return 4; })).call(this, 2 == 2); })).call(this, 1 == 1); })); """ assert_translation(ex_ast, js_code) ex_ast = quote do def test1(alpha, beta) do {a, b} = {1, 2} end end js_code = """ const test1 = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()], function(alpha, beta) { let [a, b] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.type(Elixir.Core.Tuple, { values: [Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()] }), new Elixir.Core.Tuple(1, 2)); let _ref = new Elixir.Core.Tuple(a, b); return _ref; })); """ assert_translation(ex_ast, js_code) end test "translate function calls" do ex_ast = quote do test1() end js_code = "test1()" assert_translation(ex_ast, js_code) ex_ast = quote do test?() end js_code = "test__qmark__()" assert_translation(ex_ast, js_code) ex_ast = quote do test1(3, 2) end js_code = "test1(3,2)" assert_translation(ex_ast, js_code) ex_ast = quote do Taco.test1() end js_code = "Elixir.Core.Functions.call_property(Taco, 'test1')" assert_translation(ex_ast, js_code) ex_ast = quote do Taco.test1(3, 2) end js_code = "Taco.test1(3,2)" assert_translation(ex_ast, js_code) ex_ast = quote do Taco.test1(Taco.test2(1), 2) end js_code = "Taco.test1(Taco.test2(1),2)" assert_translation(ex_ast, js_code) end test "translate anonymous functions" do ex_ast = quote do Elixir.Enum.map(list, fn(x) -> x * 2 end) end js_code = """ Elixir.Enum.map(list,Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()],function(x) { return x * 2; }))) """ assert_translation(ex_ast, js_code) end test "translate function arity" do ex_ast = quote do defmodule Example do defp example() do end defp example(oneArg) do end defp example(oneArg, twoArg) do end defp example(oneArg, twoArg, redArg) do end defp example(oneArg, twoArg, redArg, blueArg) do end end end js_code = """ import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; const example = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([],function() { return null; }),Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()],function(oneArg) { return null; }),Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()],function(oneArg,twoArg) { return null; }),Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()],function(oneArg,twoArg,redArg) { return null; }),Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()],function(oneArg,twoArg,redArg,blueArg) { return null; })); export default {}; """ assert_translation(ex_ast, js_code) ex_ast = quote do defmodule Example do def example() do end def example(oneArg) do end def example(oneArg, twoArg) do end def example(oneArg, twoArg, redArg) do end def example(oneArg, twoArg, redArg, blueArg) do end end end js_code = """ import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; const example = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([],function() { return null; }),Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()],function(oneArg) { return null; }),Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()],function(oneArg,twoArg) { return null; }),Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()],function(oneArg,twoArg,redArg) { return null; }),Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()],function(oneArg,twoArg,redArg,blueArg) { return null; })); export default { example }; """ assert_translation(ex_ast, js_code) ex_ast = quote do defmodule Example do def example(oneArg) do end end end js_code = """ import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; const example = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()],function(oneArg) { return null; })); export default { example }; """ assert_translation(ex_ast, js_code) end test "test |> operator" do ex_ast = quote do 1 |> Taco.test end js_code = "Taco.test(1)" assert_translation(ex_ast, js_code) ex_ast = quote do 1 |> Taco.test |> Home.hello("hi") end js_code = "Home.hello(Taco.test(1), 'hi')" assert_translation(ex_ast, js_code) end test "test Elixir.Kernel function" do ex_ast = quote do is_atom(:atom) end js_code = "Elixir$ElixirScript$Kernel.is_atom(Symbol.for('atom'))" assert_translation(ex_ast, js_code) end test "guards" do ex_ast = quote do def something(one) when is_number(one) do end end js_code = """ const something = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()],function(one) { return null; },function(one) { return Elixir$ElixirScript$Kernel.is_number(one); })); """ assert_translation(ex_ast, js_code) ex_ast = quote do def something(one) when is_number(one) or is_atom(one) do end end js_code = """ const something = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()],function(one) { return null; },function(one) { return Elixir$ElixirScript$Kernel.is_number(one) || Elixir$ElixirScript$Kernel.is_atom(one); })); """ assert_translation(ex_ast, js_code) ex_ast = quote do defp something(one) when is_number(one) or is_atom(one) do end end js_code = """ const something = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()],function(one) { return null; },function(one) { return Elixir$ElixirScript$Kernel.is_number(one) || Elixir$ElixirScript$Kernel.is_atom(one); })); """ assert_translation(ex_ast, js_code) ex_ast = quote do defp something(one, two) when one in [1, 2, 3] do end end js_code = """ const something = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()],function(one,two) { return null; },function(one,two) { return Elixir.Core.Functions.contains(one,Object.freeze([1, 2, 3])); })); """ assert_translation(ex_ast, js_code) ex_ast = quote do defmodule Example do def something(one) when one in [1, 2, 3] do end def something(one) when is_number(one) or is_atom(one) do end end end js_code = """ import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; const something = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()],function(one) { return null; },function(one) { return Elixir.Core.Functions.contains(one,Object.freeze([1, 2, 3])); }),Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()],function(one) { return null; },function(one) { return Elixir$ElixirScript$Kernel.is_number(one) || Elixir$ElixirScript$Kernel.is_atom(one); })); export default { something }; """ assert_translation(ex_ast, js_code) end test "pattern match function with literal" do ex_ast = quote do def something(1) do end end js_code = """ const something = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([1],function() { return null; })); """ assert_translation(ex_ast, js_code) end test "pattern match function with list" do ex_ast = quote do def something([apple | fruits]) do end end js_code = """ const something = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.headTail(Elixir.Core.Patterns.variable(),Elixir.Core.Patterns.variable())],function(apple,fruits) { return null; })); """ assert_translation(ex_ast, js_code) end test "pattern match function with multiple items in list" do ex_ast = quote do def something([apple, pear, banana]) do end end js_code = """ const something = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Object.freeze([Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()])],function(apple,pear,banana) { return null; })); """ assert_translation(ex_ast, js_code) end test "pattern match function with tuple" do ex_ast = quote do def something({ apple , fruits }) do end end js_code = """ const something = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.type(Elixir.Core.Tuple, { values: [Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()] })], function(apple, fruits) { return null; })); """ assert_translation(ex_ast, js_code) end test "pattern match function with struct" do ex_ast = quote do def something(%AStruct{}) do end end js_code = """ const something = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.type(AStruct, {})], function() { return null; })); """ assert_translation(ex_ast, js_code) end test "pattern match function with struct reference" do ex_ast = quote do def something(%AStruct{} = a) do end end js_code = """ const something = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.capture(Elixir.Core.Patterns.type(AStruct, {}))], function(a) { return null; })); """ assert_translation(ex_ast, js_code) end test "pattern match function with map reference" do ex_ast = quote do def something(%{ which: 13 } = a) do end end js_code = """ const something = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.capture({ [Symbol.for('which')]: 13 })],function(a) { return null; })); """ assert_translation(ex_ast, js_code) end test "pattern match function with struct decontructed" do ex_ast = quote do def something(%AStruct{key: value, key1: 2}) do end end js_code = """ const something = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.type(AStruct, { [Symbol.for('key')]: Elixir.Core.Patterns.variable(), [Symbol.for('key1')]: 2 })], function(value) { return null; })); """ assert_translation(ex_ast, js_code) ex_ast = quote do def something(%AStruct{key: value, key1: 2}) when is_number(value) do end end js_code = """ const something = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.type(AStruct, { [Symbol.for('key')]: Elixir.Core.Patterns.variable(), [Symbol.for('key1')]: 2 })], function(value) { return null; }, function(value) { return Elixir$ElixirScript$Kernel.is_number(value); })); """ assert_translation(ex_ast, js_code) end test "pattern match function with binary part" do ex_ast = quote do def something("Bearer " <> token) do end end js_code = """ const something = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.startsWith('Bearer ')],function(token) { return null; })); """ assert_translation(ex_ast, js_code) ex_ast = quote do def something("Bearer " <> token, hotel) do end end js_code = """ const something = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.startsWith('Bearer '), Elixir.Core.Patterns.variable()],function(token,hotel) { return null; })); """ assert_translation(ex_ast, js_code) ex_ast = quote do def something("Bearer " <> token, hotel, 1) do end end js_code = """ const something = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.startsWith('Bearer '), Elixir.Core.Patterns.variable(), 1],function(token,hotel) { return null; })); """ assert_translation(ex_ast, js_code) end test "combine pattern matched functions of same arity" do ex_ast = quote do defmodule Example do def something(1) do end def something(2) do end def something(one) when is_binary(one) do end def something(one) do end end end js_code = """ import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; const something = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([1],function() { return null; }),Elixir.Core.Patterns.clause([2],function() { return null; }),Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()],function(one) { return null; },function(one) { return Elixir$ElixirScript$Kernel.is_binary(one); }),Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()],function(one) { return null; })); export default { something }; """ assert_translation(ex_ast, js_code) end test "translate varible declaration correctly" do ex_ast = quote do def test1(alpha, beta) do a = 1 a = 2 end end js_code = """ const test1 = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()],function(alpha,beta) { let [a] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),1); let [a1] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),2); return a1; })); """ assert_translation(ex_ast, js_code) ex_ast = quote do def test1(alpha, beta) do a = 1 a = a a = 2 end end js_code = """ const test1 = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()],function(alpha,beta) { let [a] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),1); let [a1] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),a); let [a2] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),2); return a2; })); """ assert_translation(ex_ast, js_code) ex_ast = quote do def test1(alpha, beta) do a = 1 [a, b, c] = [a, 2, 3] end end js_code = """ const test1 = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()],function(alpha,beta) { let [a] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),1); let [a1,b,c] = Elixir.Core.Patterns.match(Object.freeze([Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()]),Object.freeze([a, 2, 3])); let _ref = Object.freeze([a1, b, c]); return _ref; })); """ assert_translation(ex_ast, js_code) end test "translate function variables with ? or !" do ex_ast = quote do def test1(alpha?, beta!) do a? = 1 b! = 2 end end js_code = """ const test1 = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()],function(alpha__qmark__,beta__emark__) { let [a__qmark__] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),1); let [b__emark__] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),2); return b__emark__; })); """ assert_translation(ex_ast, js_code) end test "translate function params with defaults" do ex_ast = quote do def test1(alpha, beta \\ 0) do end end js_code = """ const test1 = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable(0)],function(alpha,beta) { return null; })); """ assert_translation(ex_ast, js_code) ex_ast = quote do def test1(alpha \\ fn x -> x end) do end end js_code = """ const test1 = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable(Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()],function(x) { return x; })))], function(alpha) { return null; })); """ assert_translation(ex_ast, js_code) end test "def with catch" do ex_ast = quote do defp func(param) do if true do nil else :error end catch :invalid -> :error end end js_code = """ const func = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()], function(param) { return Elixir.Core.SpecialForms._try(function() { return Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()], function(x) { return Symbol.for('error'); }, function(x) { return x === null || x === false; }), Elixir.Core.Patterns.clause([Elixir.Core.Patterns.wildcard()], function() { return null; })).call(this, true); }, null, Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Symbol.for('invalid')], function() { return Symbol.for('error'); })), null, null ); })); """ assert_translation(ex_ast, js_code) end test "translate anonymous function with variable bound" do ex_ast = quote do key = "test" fn ^key -> :ok end end js_code = """ let [key] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),'test'); Elixir.Core.Patterns.defmatch( Elixir.Core.Patterns.clause( [Elixir.Core.Patterns.bound(key)], function() { return Symbol.for('ok'); } ) ) """ assert_translation(ex_ast, js_code) end end elixirscript-0.25.0/test/translator/kernel_test.exs000066400000000000000000000041521305236071500225330ustar00rootroot00000000000000defmodule ElixirScript.Translator.Kernel.Test do use ExUnit.Case import ElixirScript.TestHelper test "raise with bitstring" do ex_ast = quote do raise ArgumentError, "cannot convert list to string. The list must contain only integers, strings or nested such lists; got: #{inspect list}" end js_code = """ throw ArgumentError.create(Object.freeze({ [Symbol.for('message')]: 'cannot convert list to string. The list must contain only integers, strings or nested such lists; got: ' + Elixir$ElixirScript$String$Chars.to_string(inspect(list)) })); """ assert_translation(ex_ast, js_code) end test "raise with string" do ex_ast = quote do raise ArgumentError, "cannot convert list to string. The list must contain only integers, strings or nested such lists; got" end js_code = """ throw ArgumentError.create(Object.freeze({ [Symbol.for('message')]: 'cannot convert list to string. The list must contain only integers, strings or nested such lists; got' })); """ assert_translation(ex_ast, js_code) end test "max" do ex_ast = quote do max(1, 2) end js_code = """ Elixir$ElixirScript$Kernel.max(1, 2) """ assert_translation(ex_ast, js_code) end test "apply/2" do ex_ast = quote do apply(fun, [1, 2, 3]) end js_code = """ Elixir$ElixirScript$Kernel.apply(fun, Object.freeze([1, 2, 3])) """ assert_translation(ex_ast, js_code) end test "apply/3" do ex_ast = quote do apply(Enum, :reverse, [1, 2, 3]) end js_code = """ Elixir$ElixirScript$Kernel.apply(Enum,Symbol.for('reverse'),Object.freeze([1, 2, 3])) """ assert_translation(ex_ast, js_code) end test "hd" do ex_ast = quote do hd([1, 2, 3]) end js_code = """ Elixir$ElixirScript$Kernel.hd(Object.freeze([1, 2, 3])) """ assert_translation(ex_ast, js_code) end test "tl" do ex_ast = quote do tl([1, 2, 3]) end js_code = """ Elixir$ElixirScript$Kernel.tl(Object.freeze([1, 2, 3])) """ assert_translation(ex_ast, js_code) end end elixirscript-0.25.0/test/translator/list_test.exs000066400000000000000000000030231305236071500222220ustar00rootroot00000000000000defmodule ElixirScript.Translator.List.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate list" do ex_ast = quote do: [1, 2, 3] js_code = "Object.freeze([1, 2, 3])" assert_translation(ex_ast, js_code) ex_ast = quote do: ["a", "b", "c"] js_code = "Object.freeze(['a', 'b', 'c'])" assert_translation(ex_ast, js_code) ex_ast = quote do: [:a, :b, :c] js_code = "Object.freeze([Symbol.for('a'), Symbol.for('b'), Symbol.for('c')])" assert_translation(ex_ast, js_code) ex_ast = quote do: [:a, 2, "c"] js_code = "Object.freeze([Symbol.for('a'), 2, 'c'])" assert_translation(ex_ast, js_code) end test "concatenate lists" do ex_ast = quote do: [1, 2, 3] ++ [4, 5, 6] js_code = "Object.freeze([1, 2, 3]).concat(Object.freeze([4, 5, 6]))" assert_translation(ex_ast, js_code) ex_ast = quote do: this.list ++ [4, 5, 6] js_code = "Elixir.Core.Functions.call_property(this,'list').concat(Object.freeze([4, 5, 6]))" assert_translation(ex_ast, js_code) end test "prepend element" do ex_ast = quote do: [x | list] js_code = "Object.freeze([x]).concat(list)" assert_translation(ex_ast, js_code) end test "prepend element in function" do ex_ast = quote do fn (_) -> [x|list] end end js_code = """ Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.wildcard()],function(){ return Object.freeze([x]).concat(list); })) """ assert_translation(ex_ast, js_code) end end elixirscript-0.25.0/test/translator/map_test.exs000066400000000000000000000034021305236071500220250ustar00rootroot00000000000000defmodule ElixirScript.Translator.Map.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate empty map" do ex_ast = quote do: %{} js_code = "Object.freeze({})" assert_translation(ex_ast, js_code) end test "translate map with elements" do ex_ast = quote do: %{one: "one", two: "two"} js_code = "Object.freeze({[Symbol.for('one')]: 'one', [Symbol.for('two')]: 'two'})" assert_translation(ex_ast, js_code) end test "translate map within map" do ex_ast = quote do: %{one: "one", two: %{three: "three"}} js_code = """ Object.freeze({ [Symbol.for('one')]: 'one', [Symbol.for('two')]: Object.freeze({ [Symbol.for('three')]: 'three' }) }) """ assert_translation(ex_ast, js_code) end test "translate map with string keys" do ex_ast = quote do: %{"one" => "one", "two" => "two"} js_code = """ Object.freeze({ one: 'one', two: 'two' }) """ assert_translation(ex_ast, js_code) end test "translate map update" do ex_ast = quote do: %{ map | value: 1 } js_code = """ Elixir.Core.SpecialForms.map_update(map,Object.freeze({ [Symbol.for('value')]: 1 })) """ assert_translation(ex_ast, js_code) end test "translate variable key" do ex_ast = quote do: %{key => value} js_code = "Object.freeze({ [key]: value })" assert_translation(ex_ast, js_code) end test "translate bound map key" do ex_ast = quote do: %{^key => value} = %{key => value} js_code = """ let [value] = Elixir.Core.Patterns.match( { [key]: Elixir.Core.Patterns.variable() }, Object.freeze({ [key]: value }) ); """ assert_translation(ex_ast, js_code) end end elixirscript-0.25.0/test/translator/match_test.exs000066400000000000000000000051741305236071500223540ustar00rootroot00000000000000defmodule ElixirScript.Translator.Match.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate simple match" do ex_ast = quote do: a = 1 js_code = "let [a] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(), 1);" assert_translation(ex_ast, js_code) ex_ast = quote do: a = :atom js_code = "let [a] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(), Symbol.for('atom'));" assert_translation(ex_ast, js_code) end test "translate tuple match" do ex_ast = quote do {a, b} = {1, 2} end js_code = """ let [a, b] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.type(Elixir.Core.Tuple, { values: [Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()] }), new Elixir.Core.Tuple(1, 2)); let _ref = new Elixir.Core.Tuple(a, b); """ assert_translation(ex_ast, js_code) ex_ast = quote do: {a, _, c} = {1, 2, 3} js_code = """ let [a, undefined, c] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.type(Elixir.Core.Tuple, { values: [Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.wildcard(), Elixir.Core.Patterns.variable()] }), new Elixir.Core.Tuple(1, 2, 3)); let _ref = new Elixir.Core.Tuple(a, undefined, c); """ assert_translation(ex_ast, js_code) ex_ast = quote do: {^a, _, c} = {1, 2, 3} js_code = """ let [, undefined, c] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.type(Elixir.Core.Tuple, { values: [Elixir.Core.Patterns.bound(a), Elixir.Core.Patterns.wildcard(), Elixir.Core.Patterns.variable()] }), new Elixir.Core.Tuple(1, 2, 3)); let _ref = new Elixir.Core.Tuple(undefined, undefined, c); """ assert_translation(ex_ast, js_code) end test "translate bound match" do ex_ast = quote do: ^a = 1 js_code = """ let [] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.bound(a),1); """ assert_translation(ex_ast, js_code) end test "translate list match" do ex_ast = quote do: [a, b] = [1, 2] js_code = """ let [a,b] = Elixir.Core.Patterns.match(Object.freeze([Elixir.Core.Patterns.variable(), Elixir.Core.Patterns.variable()]),Object.freeze([1, 2])); let _ref = Object.freeze([a, b]); """ assert_translation(ex_ast, js_code) end test "translate head/tail match" do ex_ast = quote do: [a | b] = [1, 2, 3, 4] js_code = """ let [a,b] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.headTail(Elixir.Core.Patterns.variable(),Elixir.Core.Patterns.variable()),Object.freeze([1, 2, 3, 4])); let _ref = Object.freeze([a, b]); """ assert_translation(ex_ast, js_code) end end elixirscript-0.25.0/test/translator/nil_test.exs000066400000000000000000000003101305236071500220250ustar00rootroot00000000000000defmodule ElixirScript.Translator.Nil.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate nil" do ex_ast = quote do: nil assert_translation(ex_ast, "null") end end elixirscript-0.25.0/test/translator/number_test.exs000066400000000000000000000006251305236071500225440ustar00rootroot00000000000000defmodule ElixirScript.Translator.Number.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate numbers" do ex_ast = quote do: 1 assert_translation(ex_ast, "1") ex_ast = quote do: 1_000 assert_translation(ex_ast, "1000") ex_ast = quote do: 1.1 assert_translation(ex_ast, "1.1") ex_ast = quote do: -1.1 assert_translation(ex_ast, "-1.1") end end elixirscript-0.25.0/test/translator/pattern_matching_test.exs000066400000000000000000000171301305236071500246020ustar00rootroot00000000000000defmodule ElixirScript.Translator.PatternMatching.Test do use ExUnit.Case alias ElixirScript.Translator alias ElixirScript.Translator.Primitive alias ElixirScript.Translator.PatternMatching alias ElixirScript.Translator.Map alias ESTree.Tools.Builder, as: JS @std_lib_state File.read!(File.cwd!() <> "/lib/elixir_script/translator/stdlib_state.bin") setup do {:ok, pid} = ElixirScript.Translator.State.start_link(%{env: __ENV__}, []) ElixirScript.Translator.State.deserialize(pid, @std_lib_state) scope = ElixirScript.Translator.LexicalScope.module_scope(ElixirScript.Temp, "temp.ex", __ENV__, pid, %{ format: :es, module_formatter: ElixirScript.ModuleSystems.ES }) {:ok, [scope: scope]} end test "match wildcard", %{scope: scope} do params = [{:_, [], Test}] result = PatternMatching.build_match(params, scope) expected_result = {[PatternMatching.wildcard], [JS.identifier(:undefined)]} assert result == expected_result end test "match one identifier param", %{scope: scope} do params = [{:a, [], Test}] result = PatternMatching.build_match(params, scope ) expected_result = {[PatternMatching.parameter], [JS.identifier("a")]} assert result == expected_result end test "match multiple identifier params", %{scope: scope} do params = [{:a, [], Test}, {:b, [], Test}, {:c, [], Test}] result = PatternMatching.build_match(params, scope ) expected_result = { List.duplicate(PatternMatching.parameter, 3), [JS.identifier("a"), JS.identifier("b"), JS.identifier("c")] } assert result == expected_result end test "match head and tail param", %{scope: scope} do params = [[{:|, [], [{:head, [], Elixir}, {:tail, [], Elixir}]}]] result = PatternMatching.build_match(params, scope ) expected_result = { [PatternMatching.head_tail(PatternMatching.parameter, PatternMatching.parameter)], [JS.identifier("head"), JS.identifier("tail")] } assert result == expected_result end test "match prefix param", %{scope: scope} do params = [{:<>, [context: Elixir, import: Elixir.Kernel], ["Bearer ", {:token, [], Elixir}]}] result = PatternMatching.build_match(params, scope ) expected_result = { [PatternMatching.starts_with("Bearer ")], [JS.identifier("token")] } assert result == expected_result end test "match list", %{scope: scope} do params = [[{:a, [], Elixir}, {:b, [], Elixir}, {:c, [], Elixir}]] result = PatternMatching.build_match(params, scope ) expected_result = { [Primitive.make_list_no_translate(List.duplicate(PatternMatching.parameter, 3))], [JS.identifier("a"), JS.identifier("b"), JS.identifier("c")] } assert result == expected_result end test "match list with a literal", %{scope: scope} do params = [[1, {:b, [], Elixir}, {:c, [], Elixir}]] result = PatternMatching.build_match(params, scope ) expected_result = { [Primitive.make_list_no_translate([JS.literal(1), PatternMatching.parameter, PatternMatching.parameter])], [JS.identifier("b"), JS.identifier("c")] } assert result == expected_result end test "match number", %{scope: scope} do params = [1] result = PatternMatching.build_match(params, scope ) expected_result = { [JS.literal(1)], [] } assert result == expected_result end test "match struct pattern", %{scope: scope} do params = [{:%, [], [{:__aliases__, [alias: false], [:Hello]}, {:%{}, [], []}]}] result = PatternMatching.build_match(params, scope ) expected_result = { [PatternMatching.type(JS.identifier("Hello"), JS.object_expression([]))], [] } assert result == expected_result end test "match struct pattern with property", %{scope: scope} do params = [{:%, [], [{:__aliases__, [alias: false], [:Hello]}, {:%{}, [], [key: 1]}]}] result = PatternMatching.build_match(params, scope ) expected_result = { [PatternMatching.type(JS.identifier("Hello"), JS.object_expression([ Map.make_property(Translator.translate!(:key, scope ), Translator.translate!(1, scope )) ])) ], [] } assert result == expected_result end test "match struct pattern with property param", %{scope: scope} do params = [{:%, [], [{:__aliases__, [alias: false], [:Hello]}, {:%{}, [], [key: {:key, [], Elixir}]}]}] result = PatternMatching.build_match(params, scope ) expected_result = { [PatternMatching.type(JS.identifier("Hello"), JS.object_expression([ Map.make_property(Translator.translate!(:key, scope ), PatternMatching.parameter) ])) ], [JS.identifier("key")] } assert result == expected_result end test "capture parameter when assigning it", %{scope: scope} do params = [{:=, [], [1, {:a, [], Elixir}]}] result = PatternMatching.build_match(params, scope ) expected_result = { [PatternMatching.capture(JS.literal(1))], [JS.identifier("a")] } assert result == expected_result params = [{:=, [], [{:a, [], Elixir}, 1]}] result = PatternMatching.build_match(params, scope ) expected_result = { [PatternMatching.capture(JS.literal(1))], [JS.identifier("a")] } assert result == expected_result params = [{:=, [], [{:%, [], [{:__aliases__, [alias: false], [:AStruct]}, {:%{}, [], []}]}, {:a, [], ElixirScript.Translator.Function.Test}]}] result = PatternMatching.build_match(params, scope ) expected_result = { [PatternMatching.capture(PatternMatching.type(JS.identifier("AStruct"), JS.object_expression([])))], [JS.identifier("a")] } assert result == expected_result end test "match and assign list", %{scope: scope} do params = [{:=, [], [[{:a, [], Elixir}, {:b, [], Elixir}, {:c, [], Elixir}], {:d, [], Elixir}]}] result = PatternMatching.build_match(params, scope ) expected_result = { [PatternMatching.capture(Primitive.make_list_no_translate([PatternMatching.parameter, PatternMatching.parameter, PatternMatching.parameter]))], [JS.identifier("a"), JS.identifier("b"), JS.identifier("c"), JS.identifier("d")] } assert result == expected_result end test "match on tuple", %{scope: scope} do params = [{:{}, [], [1, {:b, [], Elixir}, 3]}] result = PatternMatching.build_match(params, scope ) expected_result = { [PatternMatching.type(Primitive.tuple_class, JS.object_expression([JS.property( JS.identifier("values"), JS.array_expression([JS.literal(1), PatternMatching.parameter, JS.literal(3)]) ) ] )) ], [JS.identifier("b")] } assert result == expected_result params = [{1, {:b, [], Elixir}}] result = PatternMatching.build_match(params, scope ) expected_result = { [PatternMatching.type(Primitive.tuple_class, JS.object_expression([JS.property( JS.identifier("values"), JS.array_expression([JS.literal(1), PatternMatching.parameter]) ) ] )) ], [JS.identifier("b")] } assert result == expected_result end test "match on map", %{scope: scope} do params = [{:%{}, [], [which: 13]}] result = PatternMatching.build_match(params, scope ) expected_result = { [JS.object_expression([ Map.make_property(Translator.translate!(:which, scope ), JS.literal(13)) ])], [] } assert result == expected_result end test "match on bound value", %{scope: scope} do params = [{:^, [], [{:a, [], Elixir}]}] result = PatternMatching.build_match(params, scope ) expected_result = { [PatternMatching.bound(JS.identifier("a"))], [nil] } assert result == expected_result end end elixirscript-0.25.0/test/translator/protocol_test.exs000066400000000000000000000062441305236071500231200ustar00rootroot00000000000000defmodule ElixirScript.Translator.Defprotocol.Test do use ExUnit.Case import ElixirScript.TestHelper test "parse protocol spec with implementations" do ex_ast = quote do defprotocol Blank do def blank?(data) end defimpl Blank, for: Integer do def blank?(number), do: false end defimpl Blank, for: List do def blank?([]), do: true def blank?(_), do: false end defimpl Blank, for: Atom do def blank?(false), do: true def blank?(nil), do: true def blank?(_), do: false end end js_code = """ import Elixir from '../elixir/Elixir.Bootstrap'; import Elixir$Blank$DefImpl$Elixir$Integer from '../app/Elixir.Blank.DefImpl.Elixir.Integer'; import Elixir$Blank$DefImpl$Elixir$List from '../app/Elixir.Blank.DefImpl.Elixir.List'; import Elixir$Blank$DefImpl$Elixir$Atom from '../app/Elixir.Blank.DefImpl.Elixir.Atom'; let impls = []; impls.push(Elixir$Blank$DefImpl$Elixir$Integer) impls.push(Elixir$Blank$DefImpl$Elixir$List) impls.push(Elixir$Blank$DefImpl$Elixir$Atom) export default impls; import Implementations from '../app/Elixir.Blank.Defimpl'; import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; const Elixir$Blank = Elixir.Core.Functions.defprotocol({ blank__qmark__: function() { } }); for(let {Type,Implementation} of Implementations) Elixir.Core.Functions.defimpl(Elixir$Blank,Type,Implementation) export default Elixir$Blank; import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; const blank__qmark__ = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()],function(number) { return false; })); export default { 'Type': Elixir.Core.Integer, 'Implementation': { blank__qmark__ } }; import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; const blank__qmark__ = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Object.freeze([])],function() { return true; }),Elixir.Core.Patterns.clause([Elixir.Core.Patterns.wildcard()],function() { return false; })); export default { 'Type': Array, 'Implementation': { blank__qmark__ } }; import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; const blank__qmark__ = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([false],function() { return true; }),Elixir.Core.Patterns.clause([null],function() { return true; }),Elixir.Core.Patterns.clause([Elixir.Core.Patterns.wildcard()],function() { return false; })); export default { 'Type': Symbol, 'Implementation': { blank__qmark__ } }; """ assert_translation(ex_ast, js_code) end end elixirscript-0.25.0/test/translator/quote_test.exs000066400000000000000000000067511305236071500224170ustar00rootroot00000000000000defmodule ElixirScript.Translator.Quote.Test do use ExUnit.Case import ElixirScript.TestHelper test "quote number" do ex_ast = quote do quote do: 1 end js_code = "1" assert_translation(ex_ast, js_code) end test "quote atom" do ex_ast = quote do quote do: :time end js_code = "Symbol.for('time')" assert_translation(ex_ast, js_code) end test "quote 2 element tuple" do ex_ast = quote do quote do: {1, 2} end js_code = "new Elixir.Core.Tuple(1, 2)" assert_translation(ex_ast, js_code) end test "quote 3 element tuple" do ex_ast = quote do quote do: {1, 2, 3} end js_code = "new Elixir.Core.Tuple(Symbol.for('{}'), Object.freeze([]), Object.freeze([1, 2, 3]))" assert_translation(ex_ast, js_code) end test "quote function call" do ex_ast = quote do quote do: test(1) end js_code = """ new Elixir.Core.Tuple( Symbol.for('test'), Object.freeze([new Elixir.Core.Tuple(Symbol.for('context'),Symbol.for('Elixir.ElixirScript.Translator.Quote.Test')), new Elixir.Core.Tuple(Symbol.for('import'),Symbol.for('Elixir.ExUnit.Case'))]),Object.freeze([1]) ) """ assert_translation(ex_ast, js_code) end test "quote function with variable" do ex_ast = quote do quote do: test(x) end js_code = """ new Elixir.Core.Tuple( Symbol.for('test'), Object.freeze([new Elixir.Core.Tuple(Symbol.for('context'), Symbol.for('Elixir.ElixirScript.Translator.Quote.Test')), new Elixir.Core.Tuple(Symbol.for('import'),Symbol.for('Elixir.ExUnit.Case'))]),Object.freeze([new Elixir.Core.Tuple(Symbol.for('x'),Object.freeze([]),Symbol.for('Elixir.ElixirScript.Translator.Quote.Test'))])) """ assert_translation(ex_ast, js_code) end test "quote function call with unquote" do ex_ast = quote do quote do: test(unquote(x)) end js_code = """ new Elixir.Core.Tuple( Symbol.for('test'), Object.freeze([new Elixir.Core.Tuple(Symbol.for('context'),Symbol.for('Elixir.ElixirScript.Translator.Quote.Test')), new Elixir.Core.Tuple(Symbol.for('import'),Symbol.for('Elixir.ExUnit.Case'))]),Object.freeze([x]) ) """ assert_translation(ex_ast, js_code) end test "quote function call with unquote_slicing" do ex_ast = quote do quote do: sum(1, unquote_splicing(values), 5) end js_code = """ new Elixir.Core.Tuple(Symbol.for('sum'),Object.freeze([]),Elixir.Enum.concat(Object.freeze([1]),values,Object.freeze([5]))) """ assert_translation(ex_ast, js_code) end test "bind_quoted" do ex_ast = quote do quote bind_quoted: [x: x] do x * x end end js_code = """ new Elixir.Core.Tuple( Symbol.for('*'), Object.freeze([new Elixir.Core.Tuple(Symbol.for('context'), Symbol.for('Elixir.ElixirScript.Translator.Quote.Test')), new Elixir.Core.Tuple(Symbol.for('import'),Symbol.for('Elixir.ElixirScript.Kernel'))]),Object.freeze([x, x]) ) """ assert_translation(ex_ast, js_code) end test "quote with context option" do ex_ast = quote do quote context: Elixir do test(1) end end js_code = """ new Elixir.Core.Tuple( Symbol.for('test'), Object.freeze([new Elixir.Core.Tuple(Symbol.for('context'),Symbol.for('Elixir')), new Elixir.Core.Tuple(Symbol.for('import'),Symbol.for('Elixir.ExUnit.Case'))]),Object.freeze([1]) ) """ assert_translation(ex_ast, js_code) end end elixirscript-0.25.0/test/translator/string_test.exs000066400000000000000000000030261305236071500225600ustar00rootroot00000000000000defmodule ElixirScript.Translator.String.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate string" do ex_ast = quote do: "Hello" assert_translation(ex_ast, "'Hello'") end test "translate multiline string" do ex_ast = quote do: """ Hello This is another line """ assert_translation(ex_ast, "'Hello\\nThis is another line\\n'") end test "translate string concatenation" do ex_ast = quote do: "Hello" <> "World" assert_translation(ex_ast, "'Hello' + 'World'") end test "translate string interpolation" do ex_ast = quote do: "Hello #{"world"}" assert_translation(ex_ast, "'Hello ' + Elixir$ElixirScript$String$Chars.to_string('world')") ex_ast = quote do: "Hello #{length([])}" assert_translation(ex_ast, "'Hello ' + Elixir$ElixirScript$String$Chars.to_string(Elixir$ElixirScript$Kernel.length(Object.freeze([])))") end test "translate multiline string interpolation" do ex_ast = quote do: """ Hello #{length([])} """ assert_translation(ex_ast, "'Hello ' + (Elixir$ElixirScript$String$Chars.to_string(Elixir$ElixirScript$Kernel.length(Object.freeze([]))) + '\\n')") ex_ast = quote do: """ Hello #{length([])} How are you, #{length([])}? """ assert_translation(ex_ast, "'Hello ' + (Elixir$ElixirScript$String$Chars.to_string(Elixir$ElixirScript$Kernel.length(Object.freeze([]))) + ('\\nHow are you, ' + (Elixir$ElixirScript$String$Chars.to_string(Elixir$ElixirScript$Kernel.length(Object.freeze([]))) + '?\\n')))") end end elixirscript-0.25.0/test/translator/struct_test.exs000066400000000000000000000130061305236071500225750ustar00rootroot00000000000000defmodule ElixirScript.Translator.Struct.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate struct with default values" do ex_ast = quote do defmodule User do defstruct name: "john", age: 27 end end js_code = """ import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; const Elixir$User = Elixir.Core.Functions.defstruct({ [Symbol.for('__struct__')]: Symbol.for('Elixir.User'), [Symbol.for('name')]: 'john', [Symbol.for('age')]: 27 }); export default { Elixir$User }; """ assert_translation(ex_ast, js_code) end test "translate struct without default values" do ex_ast = quote do defmodule User do defstruct [:name, :age] end end js_code = """ import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; const Elixir$User = Elixir.Core.Functions.defstruct({ [Symbol.for('__struct__')]: Symbol.for('Elixir.User'), [Symbol.for('name')]: null, [Symbol.for('age')]: null }); export default { Elixir$User }; """ assert_translation(ex_ast, js_code) end test "translate struct creation" do ex_ast = quote do defmodule User do defstruct :name, :age end user = %User{} end js_code = """ import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; const Elixir$User = Elixir.Core.Functions.defstruct({ [Symbol.for('__struct__')]: Symbol.for('Elixir.User'), [Symbol.for('name')]: null, [Symbol.for('age')]: null }); export default { Elixir$User }; let [user] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(), Elixir$User.Elixir$User.create(Object.freeze({}))); """ assert_translation(ex_ast, js_code) ex_ast = quote do defmodule User do defstruct :name, :age end user = %User{name: "John"} end js_code = """ import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; const Elixir$User = Elixir.Core.Functions.defstruct({ [Symbol.for('__struct__')]: Symbol.for('Elixir.User'), [Symbol.for('name')]: null, [Symbol.for('age')]: null }); export default { Elixir$User }; let [user] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),Elixir$User.Elixir$User.create(Object.freeze({ [Symbol.for('name')]: 'John' }))); """ assert_translation(ex_ast, js_code) end test "translate struct update" do ex_ast = quote do user = %{ map | key: value } end js_code = """ let [user] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),Elixir.Core.SpecialForms.map_update(map,Object.freeze({ [Symbol.for('key')]: value }))); """ assert_translation(ex_ast, js_code) ex_ast = quote do user = %{ map | key: value, key1: value1 } end js_code = """ let [user] = Elixir.Core.Patterns.match(Elixir.Core.Patterns.variable(),Elixir.Core.SpecialForms.map_update(map,Object.freeze({ [Symbol.for('key')]: value, [Symbol.for('key1')]: value1 }))); """ assert_translation(ex_ast, js_code) end test "translate defexception" do ex_ast = quote do defmodule MyAppError do defexception message: "This is a message" end end js_code = """ import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; const Elixir$MyAppError = Elixir.Core.Functions.defexception({ [Symbol.for('__struct__')]: Symbol.for('Elixir.MyAppError'), [Symbol.for('__exception__')]: true, [Symbol.for('message')]: 'This is a message' }); export default { Elixir$MyAppError }; """ assert_translation(ex_ast, js_code) ex_ast = quote do defmodule MyAppError do defexception [:message] end end js_code = """ import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; const Elixir$MyAppError = Elixir.Core.Functions.defexception({ [Symbol.for('__struct__')]: Symbol.for('Elixir.MyAppError'), [Symbol.for('__exception__')]: true, [Symbol.for('message')]: null }); export default { Elixir$MyAppError }; """ assert_translation(ex_ast, js_code) end test "translate raise exception" do ex_ast = quote do defmodule MyAppError do defexception [:message] end raise MyAppError, message: "did not get what was expected" end js_code = """ import Elixir$ElixirScript$Kernel from '../elixir/Elixir.ElixirScript.Kernel'; const Elixir$MyAppError = Elixir.Core.Functions.defexception({ [Symbol.for('__struct__')]: Symbol.for('Elixir.MyAppError'), [Symbol.for('__exception__')]: true, [Symbol.for('message')]: null }); export default { Elixir$MyAppError }; throw Elixir$MyAppError.Elixir$MyAppError.create(Object.freeze({ [Symbol.for('message')]: 'did not get what was expected' })); """ assert_translation(ex_ast, js_code) ex_ast = quote do raise "did not get what was expected" end js_code = """ throw { [Symbol.for('__struct__')]: Symbol.for('RuntimeError'), [Symbol.for('__exception__')]: true, [Symbol.for('message')]: 'did not get what was expected' }; """ assert_translation(ex_ast, js_code) end end elixirscript-0.25.0/test/translator/try_test.exs000066400000000000000000000142441305236071500220740ustar00rootroot00000000000000defmodule ElixirScript.Translator.Try.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate with a rescue with one match" do ex_ast = quote do try do do_something_that_may_fail(some_arg) rescue ArgumentError -> IO.puts "Invalid argument given" end end js_code = """ Elixir.Core.SpecialForms._try(function() { return do_something_that_may_fail(some_arg); }, Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.type(ArgumentError, {})], function() { return IO.puts('Invalid argument given'); })), null, null, null) """ assert_translation(ex_ast, js_code) end test "translate with a rescue with a list match" do ex_ast = quote do try do do_something_that_may_fail(some_arg) rescue [ArgumentError] -> IO.puts "Invalid argument given" end end js_code = """ Elixir.Core.SpecialForms._try(function() { return do_something_that_may_fail(some_arg); }, Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.type(ArgumentError, {})], function() { return IO.puts('Invalid argument given'); })), null, null, null) """ assert_translation(ex_ast, js_code) end test "translate with a rescue with an in guard" do ex_ast = quote do try do do_something_that_may_fail(some_arg) rescue x in [ArgumentError] -> IO.puts "Invalid argument given" end end js_code = """ Elixir.Core.SpecialForms._try(function() { return do_something_that_may_fail(some_arg); },Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()],function(x) { return IO.puts('Invalid argument given'); },function(x) { return Elixir.Core.Functions.contains(x,Object.freeze([ArgumentError.create(Object.freeze({}))])); })),null,null,null) """ assert_translation(ex_ast, js_code) end test "translate with a rescue with an identifier" do ex_ast = quote do try do do_something_that_may_fail(some_arg) rescue x -> IO.puts "Invalid argument given" end end js_code = """ Elixir.Core.SpecialForms._try(function() { return do_something_that_may_fail(some_arg); },Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()],function(x) { return IO.puts('Invalid argument given'); })),null,null,null) """ assert_translation(ex_ast, js_code) end test "translate with a rescue with multiple patterns" do ex_ast = quote do try do do_something_that_may_fail(some_arg) rescue [ArgumentError] -> IO.puts "ArgumentError" x -> IO.puts "x" end end js_code = """ Elixir.Core.SpecialForms._try(function() { return do_something_that_may_fail(some_arg); }, Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.type(ArgumentError, {})], function() { return IO.puts('ArgumentError'); }), Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()], function(x) { return IO.puts('x'); })), null, null, null) """ assert_translation(ex_ast, js_code) end test "translate with a rescue and after clause" do ex_ast = quote do try do do_something_that_may_fail(some_arg) rescue ArgumentError -> IO.puts "Invalid argument given" after IO.puts "This is printed regardless if it failed or succeed" end end js_code = """ Elixir.Core.SpecialForms._try(function() { return do_something_that_may_fail(some_arg); }, Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.type(ArgumentError, {})], function() { return IO.puts('Invalid argument given'); })), null, null, function() { return IO.puts('This is printed regardless if it failed or succeed'); }) """ assert_translation(ex_ast, js_code) end test "translate with an after clause" do ex_ast = quote do try do do_something_that_may_fail(some_arg) after IO.puts "This is printed regardless if it failed or succeed" end end js_code = """ Elixir.Core.SpecialForms._try(function() { return do_something_that_may_fail(some_arg); },null,null,null,function() { return IO.puts('This is printed regardless if it failed or succeed'); }) """ assert_translation(ex_ast, js_code) end test "translate else" do ex_ast = quote do try do 1 / x else y when y < 1 and y > -1 -> :small _ -> :large end end js_code = """ Elixir.Core.SpecialForms._try(function() { return 1 / x; }, null, null, Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()], function(y) { return Symbol.for('small'); }, function(y) { return y < 1 && y > -1; }), Elixir.Core.Patterns.clause([Elixir.Core.Patterns.wildcard()], function() { return Symbol.for('large'); })), null) """ assert_translation(ex_ast, js_code) end test "translate catch" do ex_ast = quote do try do do_something_that_may_fail(some_arg) rescue ArgumentError -> IO.puts "Invalid argument given" catch :throw, :Error -> IO.puts "caught error" end end js_code = """ Elixir.Core.SpecialForms._try(function() { return do_something_that_may_fail(some_arg); }, Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.type(ArgumentError, {})], function() { return IO.puts('Invalid argument given'); })), Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Symbol.for('throw'), Symbol.for('Error')], function() { return IO.puts('caught error'); })), null, null) """ assert_translation(ex_ast, js_code) end end elixirscript-0.25.0/test/translator/tuple_test.exs000066400000000000000000000016601305236071500224050ustar00rootroot00000000000000defmodule ElixirScript.Translator.Tuple.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate 2 item tuple" do ex_ast = quote do: {1, 2} js_code = "new Elixir.Core.Tuple(1, 2)" assert_translation(ex_ast, js_code) end test "translate multiple item tuple" do ex_ast = quote do: {1, 2, 3, 4, 5} js_code = "new Elixir.Core.Tuple(1, 2, 3, 4, 5)" assert_translation(ex_ast, js_code) end test "translate tuples of different typed items" do ex_ast = quote do: {"a", "b", "c"} js_code = "new Elixir.Core.Tuple('a', 'b', 'c')" assert_translation(ex_ast, js_code) ex_ast = quote do: {:a, :b, :c} js_code = "new Elixir.Core.Tuple(Symbol.for('a'), Symbol.for('b'), Symbol.for('c'))" assert_translation(ex_ast, js_code) ex_ast = quote do: {:a, 2, "c"} js_code = "new Elixir.Core.Tuple(Symbol.for('a'), 2, 'c')" assert_translation(ex_ast, js_code) end end elixirscript-0.25.0/test/translator/umd_test.exs000066400000000000000000000145251305236071500220450ustar00rootroot00000000000000defmodule ElixirScript.Translator.UMD.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate module to umd" do ex_ast = quote do defmodule Elephant do @ul JQuery.("#todo-list") def something() do @ul end defgenp something_else() do end end end js_code = """ (function(root, factory) { if (typeof define === 'function' && define.amd) { define(['../elixir/Elixir.ElixirScript.Kernel'], factory) } else if (typeof exports === 'object') { module.exports = factory(require('../elixir/Elixir.ElixirScript.Kernel')) } else { root.returnExports = factory(root.Elixir$ElixirScript$Kernel) } })(this, function(Elixir$ElixirScript$Kernel) { const something_else = Elixir.Core.Patterns.defmatchgen(Elixir.Core.Patterns.clause([], function*() { return null; })); const something = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([], function() { return ul; })); const ul = JQuery('#todo-list'); return { something }; }); """ assert_translation(ex_ast, js_code, :umd) end test "protocol to umd" do ex_ast = quote do defprotocol Blank do def blank?(data) end defimpl Blank, for: Integer do def blank?(number), do: false end defimpl Blank, for: List do def blank?([]), do: true def blank?(_), do: false end defimpl Blank, for: Atom do def blank?(false), do: true def blank?(nil), do: true def blank?(_), do: false end end js_code = """ (function(root, factory) { if (typeof define === 'function' && define.amd) { define(['../elixir/Elixir.Bootstrap', '../app/Elixir.Blank.DefImpl.Elixir.Integer', '../app/Elixir.Blank.DefImpl.Elixir.List', '../app/Elixir.Blank.DefImpl.Elixir.Atom'], factory) } else if (typeof exports === 'object') { module.exports = factory(require('../elixir/Elixir.Bootstrap'), require('../app/Elixir.Blank.DefImpl.Elixir.Integer'), require('../app/Elixir.Blank.DefImpl.Elixir.List'), require('../app/Elixir.Blank.DefImpl.Elixir.Atom')) } else { root.returnExports = factory(root.Elixir, root.Elixir$Blank$DefImpl$Elixir$Integer, root.Elixir$Blank$DefImpl$Elixir$List, root.Elixir$Blank$DefImpl$Elixir$Atom) } })(this, function(Elixir, Elixir$Blank$DefImpl$Elixir$Integer, Elixir$Blank$DefImpl$Elixir$List, Elixir$Blank$DefImpl$Elixir$Atom) { let impls = []; impls.push(Elixir$Blank$DefImpl$Elixir$Integer) impls.push(Elixir$Blank$DefImpl$Elixir$List) impls.push(Elixir$Blank$DefImpl$Elixir$Atom) return impls; }); (function(root, factory) { if (typeof define === 'function' && define.amd) { define(['../app/Elixir.Blank.Defimpl', '../elixir/Elixir.ElixirScript.Kernel'], factory) } else if (typeof exports === 'object') { module.exports = factory(require('../app/Elixir.Blank.Defimpl'), require('../elixir/Elixir.ElixirScript.Kernel')) } else { root.returnExports = factory(root.Implementations, root.Elixir$ElixirScript$Kernel) } })(this, function(Implementations, Elixir$ElixirScript$Kernel) { const Elixir$Blank = Elixir.Core.Functions.defprotocol({ blank__qmark__: function() {} }); for (let {Type, Implementation} of Implementations) Elixir.Core.Functions.defimpl(Elixir$Blank, Type, Implementation) return Elixir$Blank; }); (function(root, factory) { if (typeof define === 'function' && define.amd) { define(['../elixir/Elixir.ElixirScript.Kernel'], factory) } else if (typeof exports === 'object') { module.exports = factory(require('../elixir/Elixir.ElixirScript.Kernel')) } else { root.returnExports = factory(root.Elixir$ElixirScript$Kernel) } })(this, function(Elixir$ElixirScript$Kernel) { const blank__qmark__ = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Elixir.Core.Patterns.variable()], function(number) { return false; })); return { 'Type': Elixir.Core.Integer, 'Implementation': { blank__qmark__ } }; }); (function(root, factory) { if (typeof define === 'function' && define.amd) { define(['../elixir/Elixir.ElixirScript.Kernel'], factory) } else if (typeof exports === 'object') { module.exports = factory(require('../elixir/Elixir.ElixirScript.Kernel')) } else { root.returnExports = factory(root.Elixir$ElixirScript$Kernel) } })(this, function(Elixir$ElixirScript$Kernel) { const blank__qmark__ = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Object.freeze([])], function() { return true; }), Elixir.Core.Patterns.clause([Elixir.Core.Patterns.wildcard()], function() { return false; })); return { 'Type': Array, 'Implementation': { blank__qmark__ } }; }); (function(root, factory) { if (typeof define === 'function' && define.amd) { define(['../elixir/Elixir.ElixirScript.Kernel'], factory) } else if (typeof exports === 'object') { module.exports = factory(require('../elixir/Elixir.ElixirScript.Kernel')) } else { root.returnExports = factory(root.Elixir$ElixirScript$Kernel) } })(this, function(Elixir$ElixirScript$Kernel) { const blank__qmark__ = Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([false], function() { return true; }), Elixir.Core.Patterns.clause([null], function() { return true; }), Elixir.Core.Patterns.clause([Elixir.Core.Patterns.wildcard()], function() { return false; })); return { 'Type': Symbol, 'Implementation': { blank__qmark__ } }; }); """ assert_translation(ex_ast, js_code, :umd) end endelixirscript-0.25.0/test/translator/with_test.exs000066400000000000000000000057741305236071500222410ustar00rootroot00000000000000defmodule ElixirScript.Translator.With.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate with" do ex_ast = quote do with {:ok, width} <- Map.fetch(opts, :width), {:ok, height} <- Map.fetch(opts, :height), do: {:ok, width * height} end js_code = """ Elixir.Core.SpecialForms._with([Elixir.Core.Patterns.type(Elixir.Core.Tuple,{ values: [Symbol.for('ok'), Elixir.Core.Patterns.variable()] }), function() { return Elixir$ElixirScript$Map.fetch(opts,Symbol.for('width')); }],[Elixir.Core.Patterns.type(Elixir.Core.Tuple,{ values: [Symbol.for('ok'), Elixir.Core.Patterns.variable()] }), function(width) { return Elixir$ElixirScript$Map.fetch(opts,Symbol.for('height')); }],function(width,height) { return new Elixir.Core.Tuple(Symbol.for('ok'),width * height); }) """ assert_translation(ex_ast, js_code) end test "translate with with bare expression" do ex_ast = quote do with {:ok, width} <- Map.fetch(opts, :width), double_width = width * 2, {:ok, height} <- Map.fetch(opts, :height), do: {:ok, double_width * height} end js_code = """ Elixir.Core.SpecialForms._with([Elixir.Core.Patterns.type(Elixir.Core.Tuple,{ values: [Symbol.for('ok'), Elixir.Core.Patterns.variable()] }), function() { return Elixir$ElixirScript$Map.fetch(opts,Symbol.for('width')); }],[Elixir.Core.Patterns.variable(), function(width) { return width * 2; }],[Elixir.Core.Patterns.type(Elixir.Core.Tuple,{ values: [Symbol.for('ok'), Elixir.Core.Patterns.variable()] }), function(width,double_width) { return Elixir$ElixirScript$Map.fetch(opts,Symbol.for('height')); }],function(width,double_width,height) { return new Elixir.Core.Tuple(Symbol.for('ok'),double_width * height); }) """ assert_translation(ex_ast, js_code) end test "translate with with else" do ex_ast = quote do with {:ok, width} <- Map.fetch(opts, :width), {:ok, height} <- Map.fetch(opts, :height) do {:ok, width * height} else :error -> {:error, :wrong_data} end end js_code = """ Elixir.Core.SpecialForms._with([Elixir.Core.Patterns.type(Elixir.Core.Tuple,{ values: [Symbol.for('ok'), Elixir.Core.Patterns.variable()] }), function() { return Elixir$ElixirScript$Map.fetch(opts,Symbol.for('width')); }],[Elixir.Core.Patterns.type(Elixir.Core.Tuple,{ values: [Symbol.for('ok'), Elixir.Core.Patterns.variable()] }), function(width) { return Elixir$ElixirScript$Map.fetch(opts,Symbol.for('height')); }],function(width,height) { return new Elixir.Core.Tuple(Symbol.for('ok'),width * height); },Elixir.Core.Patterns.defmatch(Elixir.Core.Patterns.clause([Symbol.for('error')],function() { return new Elixir.Core.Tuple(Symbol.for('error'),Symbol.for('wrong_data')); }))) """ assert_translation(ex_ast, js_code) end end