pax_global_header00006660000000000000000000000064130631047200014506gustar00rootroot0000000000000052 comment=b2b5da7134b15479e90c9733cf2574776227104f elixirscript-0.27.0/000077500000000000000000000000001306310472000143155ustar00rootroot00000000000000elixirscript-0.27.0/.babelrc000066400000000000000000000000661306310472000157120ustar00rootroot00000000000000{ "plugins": ["transform-es2015-modules-commonjs"] }elixirscript-0.27.0/.credo.exs000066400000000000000000000123521306310472000162130ustar00rootroot00000000000000# 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, false}, {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.27.0/.eslintrc.js000066400000000000000000000004451306310472000165570ustar00rootroot00000000000000module.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.27.0/.flowconfig000066400000000000000000000001641306310472000164540ustar00rootroot00000000000000[ignore] .*/dist/.* .*/build/.* .*/dist_build/.* .*/node_modules/.* [include] ./priv/javascript [libs] [options] elixirscript-0.27.0/.gitignore000066400000000000000000000004001306310472000162770ustar00rootroot00000000000000/_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 test/app/build elixirscript-0.27.0/.travis.yml000066400000000000000000000014551306310472000164330ustar00rootroot00000000000000sudo: false language: elixir elixir: - 1.4.2 otp_release: - 19.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 -g yarn - yarn script: - mix local.hex --force - mix local.rebar --force - mix deps.get - mix compile - yarn build - mix test - yarn test - yarn test-app 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.27.0/CHANGELOG.md000066400000000000000000000447121306310472000161360ustar00rootroot00000000000000# 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.27.0] - 2017-03-17 ### Added - `super` - `defoverridable` - `IO.inspect\1`, `IO.puts\1`, `IO.puts\2`, `IO.warn\1` - `Elixir.load` for loading generated JavaScript modules in bundled output. Unlike `Elixir.start`, this will only call `__load` on the module and return the functions on it ```javascript const exports = Elixir.load(Elixir.MyApp); exports.hello(); ``` ### Changed - `-ex` alias is now `-e` - A filename can be specified for output - To access global JavaScript functions, modules, and properties, use the `JS` module ```elixir JS.length # translates to 'length' JS.alert() # translates to 'alert()' JS.String.raw("hi") # translate to String.raw('hi') JS.console.log("hi") # translates to console.log('hi') ``` ### Fixed - Make sure mix compiler works in umbrella apps ## [0.26.1] - 2017-02-27 ### Fixed - Fixed `for` translation - Updated documentation ## [0.26.0] - 2017-02-27 ### Added - Multiple `when` clauses in guards - Kernel.defdelegate/2 - `js_modules` configuration option has been added. This is a list of JavaScript modules that will be used. ``` js_modules: [ {React, "react"}, {ReactDOM, "react-dom"} ] ``` - `js-module` flag has been added to the CLI in order to pass js modules. ``` elixirscript "app/elixirscript" -o dist --js-module React:react --js-module ReactDOM:react-dom ``` ### Removed - `@on_js_load` has been removed in favor of having a `start/2` function defined. More info below - `JS.import` has been removed in favor of defining JavaScript modules used in configuration ### Changed - Now bundles all output, including the boostrap code. The exported object has Elixir modules in JavaScript namespaces that are lazily loaded when called. To start your application import the bundle according to whichever module format was selected and then call start giving it the module and the initial args ```javascript //ES module example import Elixir from './Elixir.App' Elixir.start(Elixir.App, []) ``` The `start` function will look for a `start/2` function there. This is analogous to a [Application module callback](https://hexdocs.pm/elixir/Application.html#module-application-module-callback) ## [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.27.0/CONTRIBUTING.md000066400000000000000000000140561306310472000165540ustar00rootroot00000000000000# 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.27.0/FAQ.md000066400000000000000000000035001306310472000152440ustar00rootroot00000000000000# 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__` * `super(args)` * Missing * `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 * 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.27.0/GettingStarted.md000066400000000000000000000117541306310472000175770ustar00rootroot00000000000000# 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 -e flag options: --js-module [:] A js module used in your code. ex: React:react Multiple can be defined -f --format [format] module format of output. options: es (default), common, umd -o --output [path] places output at the given path. Can be a directory or filename. -e --elixir read input as elixir code string --full-build informs the compiler to do a full build instead of an incremental one -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" -e elixirscript also takes a path to your `.ex` files as well: $ elixirscript "src" -o "dist" If you look in the dist folder you'll see a file called `Elixir.App.js` To start your application import the bundle according to whichever module format was selected and then call start giving it the module and the initial args. Ex. If you have a module like so ```elixir defmodule Example do start(type, args) do :console.log("Hello, world") end end ``` You would start it like so ```javascript //ES module example import Elixir from './Elixir.App' Elixir.start(Elixir.Example, []) ``` ### 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.26"} ``` 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/Elixir.App.js", format: :es, js_modules: [ {React, "react"}, {ReactDOM, "react-dom"} ] ], compilers: [:elixir_script] ++ Mix.compilers ] end Available options are: * `input`: The folder to look for Elixirscript files in. (defaults to `lib/elixirscript`) * `output`: The path of the generated JavaScript file. (defaults to `priv/elixirscript`) If path ends in `.js` then that will be the name of the file. If a directory is given, file will be named `Elixir.App.js` * `format`: The module format of generated JavaScript code. (defaults to `:es`). Choices are:     * `:es` - ES Modules * `:common` - CommonJS * `:umd` - UMD * `js_modules`: A list of JavaScript imports to add. Each item must be 2-tuple or a 3-tuple. The third element is an optional keyword list of options. ### 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 #### 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/elixirscript/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). #### elixirscript-loader There is also a webpack loader, [elixirscript-loader](https://www.npmjs.com/package/elixirscript-loader). elixirscript-0.27.0/LICENSE000066400000000000000000000020661306310472000153260ustar00rootroot00000000000000The 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.27.0/README.md000066400000000000000000000057141306310472000156030ustar00rootroot00000000000000## ElixirScript [![Documentation](https://img.shields.io/badge/docs-hexpm-blue.svg)](http://hexdocs.pm/elixir_script/) [![Build](https://travis-ci.org/elixirscript/elixirscript.svg?branch=master)](https://travis-ci.org/elixirscript/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/elixirscript/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 yarn Create Elixir.Bootstrap.js yarn build Compile mix compile Test mix test yarn test Build ============= MIX_ENV=prod mix do clean, compile, 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/elixirscript/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) #### Using with Webpack There is a loader for using ElixirScript in your Webpack project [here](https://www.npmjs.com/package/elixirscript-loader) #### 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.27.0/config/000077500000000000000000000000001306310472000155625ustar00rootroot00000000000000elixirscript-0.27.0/config/config.exs000066400000000000000000000022001306310472000175420ustar00rootroot00000000000000# 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.27.0/config/dev.exs000066400000000000000000000000171306310472000170570ustar00rootroot00000000000000use Mix.Config elixirscript-0.27.0/config/prod.exs000066400000000000000000000000171306310472000172450ustar00rootroot00000000000000use Mix.Config elixirscript-0.27.0/config/test.exs000066400000000000000000000000171306310472000172600ustar00rootroot00000000000000use Mix.Config elixirscript-0.27.0/gulpfile.js000066400000000000000000000006611306310472000164650ustar00rootroot00000000000000const gulp = require('gulp'); const babel = require('gulp-babel'); const sourcemaps = require('gulp-sourcemaps'); const path = './src/javascript'; gulp.task('build', () => 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.27.0/lib/000077500000000000000000000000001306310472000150635ustar00rootroot00000000000000elixirscript-0.27.0/lib/elixir_script.ex000066400000000000000000000171471306310472000203130ustar00rootroot00000000000000defmodule 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 @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(opts) data = quoted |> get_modules_from_quoted |> Enum.map(fn(x) -> %{ast: x, app: :app} end) std_lib_quoted = get_quoted_std_lib() %{data: std_lib_quoted ++ data} |> ElixirScript.Passes.Init.execute(opts) |> shared_passes(opts) end defp shared_passes(compiler_data, opts) do compiler_data |> ElixirScript.Passes.FindModules.execute(opts) |> ElixirScript.Passes.FindLoadOnly.execute(opts) |> ElixirScript.Passes.HandleOverridables.execute(opts) |> ElixirScript.Passes.FindFunctions.execute(opts) |> ElixirScript.Passes.JavaScriptAST.execute(opts) |> ElixirScript.Passes.ConsolidateProtocols.execute(opts) |> ElixirScript.Passes.CreateJSModules.execute(opts) |> ElixirScript.Passes.JavaScriptCode.execute(opts) |> ElixirScript.Passes.HandleOutput.execute(opts) end defp get_quoted_std_lib() do files = [get_std_lib_path(), "**", "*.ex"] |> Path.join |> Path.wildcard files |> Enum.map(fn path -> File.read!(path) end) |> Enum.map(&Code.string_to_quoted!(&1)) |> Enum.flat_map(&get_modules_from_quoted(&1)) |> Enum.map(fn(x) -> %{ast: x, app: :elixir} end) 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) deps_wrapped = [{:elixir, List.wrap(get_std_lib_path())}] ++ deps result = %{data: deps_wrapped} |> ElixirScript.Passes.Init.execute(opts) |> ElixirScript.Passes.ASTFromFile.execute(opts) |> ElixirScript.Passes.LoadModules.execute(opts) |> shared_passes(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) |> Map.put(:js_modules, []) 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 """ Returns the contents of the bootrstrap js file """ @spec get_bootstrap_js(string) :: string def get_bootstrap_js(module_format) do path = Path.join([operating_path, "build", to_string(module_format), "Elixir.Bootstrap.js"]) File.read!(path) 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 Path.join([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 defp get_std_lib_path() do Path.join([operating_path(), "std_lib"]) end end elixirscript-0.27.0/lib/elixir_script/000077500000000000000000000000001306310472000177435ustar00rootroot00000000000000elixirscript-0.27.0/lib/elixir_script/cli.ex000066400000000000000000000066571306310472000210660ustar00rootroot00000000000000defmodule ElixirScript.CLI do @moduledoc false @app_version Mix.Project.config()[:version] @switches [ output: :string, elixir: :boolean, help: :boolean, full_build: :boolean, version: :boolean, watch: :boolean, format: :string, js_module: [:string, :keep] ] @aliases [ o: :output, e: :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 -e flag options: --js-module [:] A js module used in your code. ex: React:react Multiple can be defined -f --format [format] module format of output. options: es (default), common, umd -o --output [path] places output at the given path. Can be a directory or filename. -e --elixir read input as elixir code string --full-build informs the compiler to do a full build instead of an incremental one -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) js_modules = Keyword.get_values(options, :js_module) |> build_js_modules 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")), js_modules: js_modules } case options[:elixir] do true -> ElixirScript.compile(input, compile_opts) _ -> input = handle_input(input) 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 defp handle_input(input) do input = input |> Enum.map(fn(x) -> String.split(x, [" ", ","], trim: true) end) |> List.flatten end defp build_js_modules(values) do values |> Enum.map(fn x -> [identifier, path] = String.split(x,":", trim: true) { format_identifier(identifier), format_path(path) } end) end defp format_identifier(id) do id |> String.split(".") |> Module.concat end defp format_path(path) do path |> String.replace("\"", "") |> String.replace("`", "") |> String.replace("'", "") end end elixirscript-0.27.0/lib/elixir_script/elixir_script_compile_error.ex000066400000000000000000000001041306310472000260750ustar00rootroot00000000000000defmodule ElixirScriptCompileError do defexception [:message] end elixirscript-0.27.0/lib/elixir_script/module_systems/000077500000000000000000000000001306310472000230175ustar00rootroot00000000000000elixirscript-0.27.0/lib/elixir_script/module_systems/common.ex000066400000000000000000000025211306310472000246450ustar00rootroot00000000000000defmodule 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(imports, js_imports, body, exports) do module_imports = Enum.map(imports, fn {module, path} -> import_module(module, path) end) imports = js_imports |> Enum.map(fn {module, path} -> import_module(module, path) {module, path, _} -> import_module(module, path) end) imports = Enum.uniq(imports ++ module_imports) export = if is_nil(exports), do: [], else: [export_module(exports)] imports ++ body ++ export end defp import_module(module_name, from) do js_module_name = ElixirScript.Translator.Identifier.make_namespace_members(module_name) do_import_module(js_module_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 defp export_module(exported_object) do JS.assignment_expression( :=, JS.member_expression( JS.identifier("module"), JS.identifier("exports") ), exported_object ) end end elixirscript-0.27.0/lib/elixir_script/module_systems/es.ex000066400000000000000000000030701306310472000237640ustar00rootroot00000000000000defmodule 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(imports, js_imports, body, exports) do module_imports = Enum.map(imports, fn {module, path} -> import_module(module, path) end) imports = js_imports |> Enum.map(fn {module, path} -> import_module(module, path) {module, path, default: true} -> import_module(module, path) {module, path, default: false} -> import_namespace_module(module, path) end) imports = Enum.uniq(imports ++ module_imports) export = if is_nil(exports), do: [], else: [export_module(exports)] imports ++ body ++ export end defp import_namespace_module(module_name, from) do js_module_name = ElixirScript.Translator.Identifier.make_namespace_members(module_name) import_specifier = JS.import_namespace_specifier( js_module_name, js_module_name ) do_import_module([import_specifier], from) end defp import_module(import_name, from) do js_module_name = ElixirScript.Translator.Identifier.make_namespace_members(import_name) import_specifier = JS.import_default_specifier( js_module_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 defp export_module(exported_object) do JS.export_default_declaration(exported_object) end end elixirscript-0.27.0/lib/elixir_script/module_systems/namespace.ex000066400000000000000000000044331306310472000253150ustar00rootroot00000000000000defmodule ElixirScript.ModuleSystems.Namespace do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator alias ElixirScript.Translator.State alias ElixirScript.Translator.Utils alias ElixirScript.Translator.Identifier def build(module_name, body, exports, env) do List.wrap(make_namespace_body(module_name, body, exports)) end defp module_name_function_call(module_name, function) do members = ["Elixir"] ++ Module.split(module_name) ++ [function] Identifier.make_namespace_members(members) end def import_module(module_name) do name = ["Elixir" | Module.split(module_name) ] |> Enum.join("$") declarator = JS.variable_declarator( JS.identifier(name), JS.call_expression( module_name_function_call(module_name, "__load"), [JS.identifier("Elixir")] ) ) JS.variable_declaration([declarator], :const) end defp build_namespace() do JS.member_expression( JS.identifier("Bootstrap"), JS.member_expression( JS.identifier(:Core), JS.member_expression( JS.identifier(:Functions), JS.identifier(:build_namespace) ) ) ) end defp make_namespace_body(module_name, body, exports) do values = module_name_function_call(module_name, "__exports") _if = JS.if_statement( values, JS.return_statement(values) ) exports = if is_nil(exports) do JS.object_expression([]) else exports end declarator = JS.variable_declarator( JS.identifier("__exports"), exports ) declaration = JS.variable_declaration([declarator], :const) assign = JS.assignment_expression( :=, values, JS.identifier("__exports") ) exports = [JS.return_statement(JS.identifier("__exports"))] make = JS.member_expression( JS.call_expression( build_namespace(), [JS.identifier("Elixir"), JS.literal(Utils.name_to_js_file_name(module_name))] ), JS.identifier("__load") ) func_body = JS.block_statement([_if] ++ body ++ [declaration, assign] ++ exports) func = JS.function_expression([JS.identifier("Elixir")], [], func_body) JS.assignment_expression( :=, make, func ) end endelixirscript-0.27.0/lib/elixir_script/module_systems/umd.ex000066400000000000000000000067711306310472000241550ustar00rootroot00000000000000defmodule 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(imports, js_imports, body, exports) do module_imports = Enum.map(imports, fn {module, path} -> import_module(module, path) end) imports = js_imports |> Enum.map(fn {module, path} -> import_module(module, path) {module, path, _} -> import_module(module, path) end) imports = Enum.uniq(imports ++ module_imports) export = export_module(exports) List.wrap(make_umd(imports, body, export)) end defp import_module(module_name, from) do js_module_name = ElixirScript.Translator.Identifier.make_namespace_members(module_name) {js_module_name, JS.literal(from)} end defp export_module(exported_object) do exported_object end defp make_umd(imports, body, exports) do import_paths = Enum.map(imports, fn({_, path}) -> path end) import_identifiers = Enum.map(imports, fn({id, _}) -> id end) exports = if is_nil(exports), do: [], else: [JS.return_statement(exports)] 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("Elixir") ), 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 ++ exports))] ) ) end endelixirscript-0.27.0/lib/elixir_script/passes/000077500000000000000000000000001306310472000212415ustar00rootroot00000000000000elixirscript-0.27.0/lib/elixir_script/passes/ast_from_file.ex000066400000000000000000000011571306310472000244140ustar00rootroot00000000000000defmodule 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.27.0/lib/elixir_script/passes/consolidate_protocols.ex000066400000000000000000000061011306310472000262050ustar00rootroot00000000000000defmodule ElixirScript.Passes.ConsolidateProtocols do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator.Utils alias ElixirScript.Translator.State alias ElixirScript.Translator.Identifier 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 body = Enum.map(implementations, fn({_, impl_data}) -> x = Utils.quoted_to_name(impl_data.for) members = ["Elixir"] ++ Module.split(name) ++ ["DefImpl", "Elixir"] ++ Module.split(x) ++ ["__load"] ast = JS.call_expression( Identifier.make_namespace_members(members), [JS.identifier("Elixir")] ) JS.call_expression( JS.member_expression( JS.identifier("impls"), JS.identifier("push") ), [ast] ) end) module_name = String.to_atom(protocol_name <> ".DefImpl") module_data = %{ name: name, module: String.to_atom(protocol_name <> ".DefImpl"), body: [declaration] ++ body, exports: JS.identifier("impls"), app: app_name, type: :consolidated, protocol: name } {module_name, module_data} end end elixirscript-0.27.0/lib/elixir_script/passes/create_js_modules.ex000066400000000000000000000061601306310472000252710ustar00rootroot00000000000000defmodule ElixirScript.Passes.CreateJSModules do @moduledoc false alias ElixirScript.Translator.Utils alias ESTree.Tools.Builder, as: JS def execute(compiler_data, opts) do namespace_modules = Enum.reduce(compiler_data.data, [], fn ({_, %{load_only: true} = module_data}, acc) -> acc ({module_name, module_data}, acc) -> if module_data.app == :elixir && opts.import_standard_libs == false do acc else body = generate_namespace_module( module_data.type, module_name, Map.get(module_data, :javascript_module, module_data), opts, compiler_data.state ) acc ++ List.wrap(body) end end) compiled = compile(namespace_modules, opts) Map.put(compiler_data, :compiled, compiled) end defp generate_namespace_module(:consolidated, module_name, js_module, opts, state) do env = ElixirScript.Translator.LexicalScope.module_scope( js_module.name, Utils.name_to_js_file_name(js_module.name) <> ".js", opts.env, state, opts) body = ElixirScript.ModuleSystems.Namespace.build( module_name, js_module.body, js_module.exports, env ) body end defp generate_namespace_module(_, module_name, js_module, _, _) do body = ElixirScript.ModuleSystems.Namespace.build( module_name, js_module.body, js_module.exports, js_module.env ) body end defp compile(body, opts) do declarator = JS.variable_declarator( JS.identifier("Elixir"), JS.object_expression([]) ) elixir = JS.variable_declaration([declarator], :const) ast = opts.module_formatter.build( [], opts.js_modules, [elixir, start, load] ++ body, JS.identifier("Elixir") ) ast end def start do JS.assignment_expression( :=, JS.member_expression( JS.identifier("Elixir"), JS.identifier("start") ), JS.function_expression( [JS.identifier(:app), JS.identifier(:args)], [], JS.block_statement([ JS.call_expression( JS.member_expression( JS.call_expression( JS.member_expression( JS.identifier(:app), JS.identifier("__load") ), [JS.identifier("Elixir")] ), JS.identifier("start") ), [ElixirScript.Translator.Primitive.make_atom(:normal), JS.identifier(:args)] ) ]) ) ) end def load do JS.assignment_expression( :=, JS.member_expression( JS.identifier("Elixir"), JS.identifier("load") ), JS.function_expression( [JS.identifier(:module)], [], JS.block_statement([ JS.return_statement( JS.call_expression( JS.member_expression( JS.identifier(:module), JS.identifier("__load") ), [JS.identifier("Elixir")] ) ) ]) ) ) end end elixirscript-0.27.0/lib/elixir_script/passes/find_functions.ex000066400000000000000000000053701306310472000246140ustar00rootroot00000000000000defmodule 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, defdelegate: delegates } = get_functions_from_module(module_data.ast) module_data = Map.put(module_data, :functions, functions ++ generators ++ delegates) |> 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) ({:defdelegate, _, [{name, _, params}], _}, state) -> arity = length(params) add_function_to_map(state, :defdelegate, 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, defdelegate: 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.27.0/lib/elixir_script/passes/find_load_only.ex000066400000000000000000000012371306310472000245620ustar00rootroot00000000000000defmodule 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.27.0/lib/elixir_script/passes/find_modules.ex000066400000000000000000000147221306310472000242550ustar00rootroot00000000000000defmodule ElixirScript.Passes.FindModules do @moduledoc false alias ElixirScript.Translator.Utils alias ElixirScript.Translator.State @spec execute(map, map) :: map 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(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 = do_module_processing_state(inner_modules, state, name, aliases, opts) [%{name: Utils.quoted_to_name(the_alias), type: :module, ast: do_module_processing_body(body, aliases, opts) }] ++ state end defp do_module_processing_state(inner_modules, state, name, aliases, opts) do 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) end defp do_module_processing_body(body, aliases, opts) do body |> case do {:__block__, context, list } -> list = list |> Enum.map(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, {:__block__, _, list}}, state -> state ++ list {:use, ast}, state -> state ++ [ast] {:expanded, ast}, state -> state ++ [ast] end) {:__block__, context, list} _ -> body end |> add_aliases_to_body(aliases) 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(body) do case body do nil -> { { :__block__, [], [] }, [] } {:__block__, context, list2 } -> { list2, inner_modules } = Enum.partition(list2, fn {:defmodule, _, [{:__aliases__, _, _inner_module_name}, [do: _inner_module_body]]} -> false _ -> true 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 Keyword.update!(context, :import, fn(_) -> ElixirScript.Kernel end) else context end {name, context, parms} (x) -> x end) end end elixirscript-0.27.0/lib/elixir_script/passes/handle_output.ex000066400000000000000000000030311306310472000244470ustar00rootroot00000000000000defmodule ElixirScript.Passes.HandleOutput do @moduledoc false alias ElixirScript.Translator.State @generated_name "Elixir.App.js" def execute(compiler_data, opts) do State.stop(compiler_data.state) out(compiler_data, opts) end defp out(compiler_output, %{output: nil} = compiler_opts) do compiler_output |> process_include_path(compiler_opts) end defp out(compiler_output, %{output: :stdout} = compiler_opts) do out = compiler_output |> process_include_path(compiler_opts) code = case out do {code, _} -> code code -> code end IO.write(concat(code)) end defp out(compiler_output, %{output: output_path, core_path: _}) do file_name = get_js_path(output_path) if !File.exists?(Path.dirname(file_name)) do File.mkdir_p!(Path.dirname(file_name)) end File.write!(file_name, concat(compiler_output.generated)) end defp concat(code) do "'use strict';\n" <> ElixirScript.get_bootstrap_js("iife") <> "\n" <> code end def get_js_path(nil), do: @generated_name def get_js_path(:stdout), do: @generated_name def get_js_path(output_path) do case Path.extname(output_path) do ".js" -> output_path _ -> Path.join([output_path, @generated_name]) end end defp process_include_path(compiler_output, compiler_opts) do case compiler_opts.include_path do true -> {compiler_output.generated, get_js_path(compiler_opts.output)} false -> compiler_output.generated end end end elixirscript-0.27.0/lib/elixir_script/passes/handle_overridables.ex000066400000000000000000000044651306310472000256040ustar00rootroot00000000000000defmodule ElixirScript.Passes.HandleOverridables do @moduledoc false @function_types [:def, :defp] def execute(compiler_data, opts) do new_data = Enum.map(compiler_data.data, fn { module_name, module_data } -> overridables = get_overridables(module_data.ast) ast = handle_overridable(module_data.ast, overridables) module_data = Map.put(module_data, :ast, ast) {module_name, module_data} end) Map.put(compiler_data, :data, new_data) end defp get_overridables({:__block__, [], body}) do defover = Enum.find(body, fn {:defoverridable, _, _} -> true _ -> false end) if is_nil(defover) do [] else {:defoverridable, _, [overridables]} = defover overridables end end defp handle_overridable(ast, []) do ast end defp handle_overridable({:__block__, [], body}, overridables) do result = body |> Enum.reduce(%{overridables: [], overridable_found: false, body: []}, fn {type, def_context, [{name, context, params}, function_body] } = ast, %{overridable_found: false} = acc when type in @function_types -> Map.put(acc, :overridables, acc.overridables ++ [ast]) {:defoverridable, _, _}, acc -> Map.put(acc, :overridable_found, true) x, acc -> Map.put(acc, :body, acc.body ++ [x]) end) processed_overridables = Enum.map(result.overridables, fn {type, def_context, [{name, context, params}, function_body] } = ast when type in @function_types -> arity = get_arity(params) found = Enum.any?(result.body, fn {type, _, [{name_from_body, _, params_from_body}, _] } -> if {name, arity} == {name_from_body, get_arity(params_from_body)} do true else false end _ -> false end) if found do super_name = String.to_atom("__super__" <> to_string(name)) {:defp, def_context, [{super_name, context, params}, function_body] } else ast end end) body = processed_overridables ++ result.body {:__block__, [], body} end defp get_arity(params) do cond do is_nil(params) -> 0 is_atom(params) -> 0 true -> length(params) end end endelixirscript-0.27.0/lib/elixir_script/passes/init.ex000066400000000000000000000003511306310472000225410ustar00rootroot00000000000000defmodule 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.27.0/lib/elixir_script/passes/java_script_ast.ex000066400000000000000000000030061306310472000247520ustar00rootroot00000000000000defmodule 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, [])) data = compiler_data.state |> State.get_module_data |> Enum.reject(fn {_,module_data} -> module_data.app == :elixir && opts.import_standard_libs == false end) |> Enum.map(fn({module_name, module_data}) -> module_data = compile(module_data, opts, compiler_data.state) {module_name, module_data} 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_module, module) end end elixirscript-0.27.0/lib/elixir_script/passes/java_script_code.ex000066400000000000000000000013201306310472000250720ustar00rootroot00000000000000defmodule ElixirScript.Passes.JavaScriptCode do @moduledoc false alias ESTree.Tools.{Builder, Generator} def execute(compiler_data, _) do parent = self js_code = compiler_data.compiled |> List.wrap |> Builder.program |> prepare_js_ast |> Generator.generate Map.put(compiler_data, :generated, 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.27.0/lib/elixir_script/passes/load_modules.ex000066400000000000000000000012171306310472000242470ustar00rootroot00000000000000defmodule ElixirScript.Passes.LoadModules do @moduledoc false def execute(compiler_data, _) do ex_files = compiler_data.data |> Enum.filter(fn {_, %{app: :elixir}} -> false %{app: :elixir} -> false _ -> true end) |> Enum.map(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.27.0/lib/elixir_script/passes/load_modules_for_quoted.ex000066400000000000000000000012301306310472000264710ustar00rootroot00000000000000defmodule ElixirScript.Passes.LoadModulesForQuoted do @moduledoc false def execute(compiler_data, _) do quoted = compiler_data.data |> Enum.filter(fn {_, %{app: :elixir}} -> false %{app: :elixir} -> false _ -> true end) |> Enum.map(fn {_, %{ast: ast}} -> ast %{ast: ast} -> ast end) loaded_modules = Map.get(compiler_data, :loaded_modules, []) loaded_modules_from_quoted = quoted |> Enum.map(&Code.compile_quoted(&1)) |> List.flatten |> Enum.map(fn {mod, _} -> mod end) Map.put(compiler_data, :loaded_modules, loaded_modules ++ loaded_modules_from_quoted) end endelixirscript-0.27.0/lib/elixir_script/translator.ex000066400000000000000000000560331306310472000225010ustar00rootroot00000000000000defmodule 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({{:., _, [{:__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({{:., _, [{:__aliases__, context, [:JS | rest]}, function_name]}, _, params }, env) do JSLib.translate_js_function({:__aliases__, context, rest}, function_name, params, env) 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(Bootstrap.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 module_name = create_module_name2(module_name, env) js_ast = case module_name do {mod, :local} -> Capture.make_capture(mod, function_name, arity, env) mod -> Capture.make_extern_capture(mod, function_name, arity, env) end { js_ast, 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({:@, _, [{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({:super, _, params }, env) do { name, _ } = env.function super_name = String.to_atom("__super__" <> to_string(name)) Call.make_local_function_call(super_name, params, env) end defp do_translate({{:., _, [function_name]}, _, params}, env) do Call.make_local_function_call(function_name, params, env) end defp do_translate({:., _, [{:__aliases__, _, _} = module_name, function_name]} = ast, env) do do_translate({{:., [], [module_name, function_name]}, [], []}, env) end defp do_translate({{:., _, [{:__aliases__, _, _} = module_name, function_name]}, _, [] } = ast, env) do expanded_ast = Macro.expand(ast, env.env) if expanded_ast == ast do module_name = create_module_name2(module_name, env) case module_name do {mod, :local} -> Call.make_module_function_call(mod, function_name, env) mod -> Call.make_extern_function_or_property_call(mod, function_name, env) end 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 Call.make_function_or_property_call(module_name, function_name, env) else translate(expanded_ast, env) end end defp do_translate({{:., context1, [{:__aliases__, context2, [:Elixir, :Enum]}, function_name]}, context3, params }, env) do translate({{:., context1, [{:__aliases__, context2, [:Enum]}, function_name]}, context3, params }, env) end defp do_translate({{:., context1, [{:__aliases__, context2, [:Enum]}, function_name]}, context3, params }, env) do translate({{:., context1, [{:__aliases__, context2, [:Bootstrap, :Enum]}, function_name]}, context3, params }, env) end defp do_translate({{:., _, [{:__aliases__, _, _} = module_name, function_name]}, _, params } = ast, env) do expanded_ast = Macro.expand(ast, env.env) if expanded_ast == ast do module_name = create_module_name2(module_name, env) case module_name do {mod, :local} -> Call.make_module_function_call(mod, function_name, params, env) mod -> Call.make_extern_function_call(mod, function_name, params, env) end else translate(expanded_ast, env) end end defp do_translate({{:., _, [module_name, function_name]}, _, params} = ast, env) when is_atom(module_name) and is_atom(function_name) do expanded_ast = Macro.expand(ast, env.env) if expanded_ast == ast do Call.make_function_call(module_name, function_name, params, env) else translate(expanded_ast, env) end end defp do_translate({{:., _, [module_name, function_name]}, _, params } = ast, env) do expanded_ast = Macro.expand(ast, env.env) if expanded_ast == ast do 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_name2(ast, env) case module_name do {mod, :local} -> Call.make_module_name(mod, env) mod -> Call.make_extern_module_name(mod, env) end 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(Bootstrap.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({:defdelegate, _, [{name, _, params}, options]}, env) do Def.process_delegate(name, params, options, 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_local_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_module_function_call(imported_module_name, name, params, env) true -> Call.make_local_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_module_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 create_module_name2(module_name, env) do module_name = Utils.quoted_to_name(module_name) candiate_module_name = ElixirScript.Translator.State.get_module_name(env.state, 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), :local } else 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.27.0/lib/elixir_script/translator/000077500000000000000000000000001306310472000221345ustar00rootroot00000000000000elixirscript-0.27.0/lib/elixir_script/translator/empty.ex000066400000000000000000000002641306310472000236320ustar00rootroot00000000000000defmodule ElixirScript.Translator.Empty do @moduledoc false # Represents no translation to JS AST @type t :: %ElixirScript.Translator.Empty{} defstruct type: "Empty" end elixirscript-0.27.0/lib/elixir_script/translator/group.ex000066400000000000000000000015121306310472000236250ustar00rootroot00000000000000defmodule 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.27.0/lib/elixir_script/translator/kernel/000077500000000000000000000000001306310472000234145ustar00rootroot00000000000000elixirscript-0.27.0/lib/elixir_script/translator/kernel/def.ex000066400000000000000000000020671306310472000245150ustar00rootroot00000000000000defmodule ElixirScript.Translator.Def do @moduledoc false alias ESTree.Tools.Builder, as: JS alias ElixirScript.Translator.Function alias ElixirScript.Translator.Identifier alias ElixirScript.Translator 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 def process_delegate(name, params, options, env) do translated_params = Enum.map(params, &Translator.translate!(&1, env)) to = options[:to] as = options[:as] || name function = JS.function_expression(translated_params, [], JS.block_statement([ JS.return_statement( Translator.translate!({{:., [], [to, as]}, [], params}, env) ) ]) ) declarator = JS.variable_declarator( Identifier.make_identifier(name), function ) { JS.variable_declaration([declarator], :const), env } end end elixirscript-0.27.0/lib/elixir_script/translator/kernel/defimpl.ex000066400000000000000000000054711306310472000254010ustar00rootroot00000000000000defmodule 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 ) ]) %{ name: Utils.quoted_to_name({:__aliases__, [], name }), exports: export, body: body, app_name: State.get_module(env.state, name).app, protocol: protocol_name, env: env } end defp map_to_js({:__aliases__, _, [:Integer]}, _) do JS.member_expression( JS.member_expression( JS.identifier("Bootstrap"), JS.identifier(:Core) ), JS.identifier(:Integer) ) end defp map_to_js({:__aliases__, _, [:Tuple]}, _) do JS.member_expression( JS.member_expression( JS.identifier("Bootstrap"), 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("Bootstrap"), JS.identifier(:Core) ), JS.identifier(:BitString) ) end defp map_to_js({:__aliases__, _, [:Float]}, _) do JS.member_expression( JS.member_expression( JS.identifier("Bootstrap"), 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("Bootstrap"), JS.identifier(:Core) ), JS.identifier(:PID) ) end defp map_to_js({:__aliases__, _, [:Port]}, _) do JS.member_expression( JS.identifier("Bootstrap"), JS.identifier(:Port) ) end defp map_to_js({:__aliases__, _, [:Reference]}, _) do JS.member_expression( JS.identifier("Bootstrap"), 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.27.0/lib/elixir_script/translator/kernel/defmodule.ex000066400000000000000000000165051306310472000257250ustar00rootroot00000000000000defmodule 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, exports: nil, app_name: ElixirScript.Translator.State.get(env.state).compiler_opts.app, env: env } end def make_module(module, nil, env) do %{ name: module, body: [], exports: nil, app_name: ElixirScript.Translator.State.get(env.state).compiler_opts.app, env: env } end def make_module(module, body, env) do {body, exported_object} = process_module(module, body, env) app_name = State.get_module(env.state, module).app result = %{ name: Utils.quoted_to_name({:__aliases__, [], module }), exports: exported_object, body: body, app_name: app_name, env: env } 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) 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(Map.keys(exported), fn(key) -> functions = Map.get(exported, key) { functions, _ } = Def.process_function(key, functions, env) { key, functions } end) exported_generators = Enum.map(Map.keys(exported_generators), fn(key) -> functions = Map.get(exported_generators, key) { functions, _ } = Def.process_function(key, functions, %{ env | context: :generator}) { key, functions } end) private_functions = Enum.map(Map.keys(private), fn(key) -> functions = Map.get(private, key) { functions, _ } = Def.process_function(key, functions, env) { key, functions } end) private_generators = Enum.map(Map.keys(private_generators), fn(key) -> functions = Map.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.27.0/lib/elixir_script/translator/kernel/defprotocol.ex000066400000000000000000000055531306310472000263020ustar00rootroot00000000000000defmodule 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 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("Bootstrap"), JS.member_expression( JS.identifier(:Core), JS.member_expression( JS.identifier(:Functions), JS.identifier(:defprotocol) ) ) ), [object] ) ) declaration = JS.variable_declaration([declarator], :const) implementation_name_split = Module.split(name) ++ ["DefImpl"] implementation_name = Enum.join(["Elixir"] ++ implementation_name_split, "$") implementation_name_module = Module.concat(implementation_name_split) 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(implementation_name), JS.call_expression( JS.member_expression( JS.identifier("Bootstrap"), 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] defimpl_import = ElixirScript.ModuleSystems.Namespace.import_module(implementation_name_module) %{ name: name, body: [defimpl_import] ++ body, exports: JS.identifier(Utils.name_to_js_name(name)), app_name: app_name, env: env } 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.27.0/lib/elixir_script/translator/kernel/expression.ex000066400000000000000000000010341306310472000261470ustar00rootroot00000000000000defmodule 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.27.0/lib/elixir_script/translator/kernel/js.ex000066400000000000000000000106031306310472000243660ustar00rootroot00000000000000defmodule ElixirScript.Translator.JS do @moduledoc false alias ESTree.Tools.Builder alias ElixirScript.Translator alias ElixirScript.Translator.Utils alias ElixirScript.Translator.Identifier def call_property() do Builder.member_expression( Builder.member_expression( Builder.identifier("Bootstrap"), Builder.member_expression( Builder.identifier("Core"), Builder.identifier("Functions") ) ), Builder.identifier("call_property") ) end def global() do Builder.member_expression( Builder.member_expression( Builder.identifier("Bootstrap"), Builder.member_expression( Builder.identifier("Core"), Builder.identifier("Functions") ) ), Builder.identifier("get_global") ) end @doc false def translate_js_function({:__aliases__, _, module}, name, params, env) do { do_translate(module, {name, [], params}, env), env } end @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, _, []}, _) 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({: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 defp do_translate({function, _, []}, env) do Builder.call_expression( call_property(), [ Builder.call_expression(global(), []), Translator.translate!(to_string(function), env) ] ) end defp do_translate({function, _, params}, env) do Builder.call_expression( Builder.member_expression( Builder.call_expression(global(), []), Builder.identifier(function) ), Enum.map(params, &Translator.translate!(&1, env)) ) end defp do_translate(module, {function, _, []}, env) do members = Identifier.make_namespace_members(module) Builder.call_expression( call_property(), [ Builder.member_expression( Builder.call_expression(global(), []), members ), Translator.translate!(to_string(function), env) ] ) end defp do_translate(module, {function, _, params}, env) do members = Identifier.make_namespace_members(module) Builder.call_expression( Builder.member_expression( Builder.member_expression( Builder.call_expression(global(), []), members ), Builder.identifier(function) ), Enum.map(params, &Translator.translate!(&1, env)) ) end end elixirscript-0.27.0/lib/elixir_script/translator/kernel/special_forms/000077500000000000000000000000001306310472000262425ustar00rootroot00000000000000elixirscript-0.27.0/lib/elixir_script/translator/kernel/special_forms/bitstring.ex000066400000000000000000000110211306310472000306000ustar00rootroot00000000000000defmodule 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("Bootstrap"), 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("Bootstrap"), 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.27.0/lib/elixir_script/translator/kernel/special_forms/block.ex000066400000000000000000000005341306310472000276740ustar00rootroot00000000000000defmodule 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.27.0/lib/elixir_script/translator/kernel/special_forms/call.ex000066400000000000000000000132411306310472000275140ustar00rootroot00000000000000defmodule 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 members = ["Elixir"] ++ Module.split(module_name) { Identifier.make_namespace_members(members), env } end def make_extern_module_name(module_name, env) do members = Module.split(module_name) { Identifier.make_namespace_members(members), env } end def make_local_function_call({fun, _, nil}, params, env) do ast = JS.call_expression( Identifier.make_identifier(fun), Enum.map(params, &Translator.translate!(&1, env)) ) {ast, env} end def make_local_function_call(function_name, params, env) do ast = JS.call_expression( Identifier.make_identifier(function_name), Enum.map(params, &Translator.translate!(&1, env)) ) {ast, env} end def make_module_function_call(module_name, function_name, params, env) do members = ["Elixir"] ++ Module.split(module_name) ++ ["__load"] ast = JS.call_expression( JS.member_expression( JS.call_expression( Identifier.make_namespace_members(members), [JS.identifier("Elixir")] ), Identifier.make_identifier(function_name) ), Enum.map(params, &Translator.translate!(&1, env)) ) {ast, env} end def make_module_function_call(module_name, function_name, env) do make_module_function_call(module_name, function_name, [], env) end def make_extern_function_or_property_call(module_name, function_name, env) do members = Module.split(module_name) Identifier.make_namespace_members(members) js_ast = JS.call_expression( JS.member_expression( JS.member_expression( JS.identifier("Bootstrap"), JS.member_expression( JS.identifier("Core"), JS.identifier("Functions") ) ), JS.identifier("call_property") ), [ Identifier.make_namespace_members(members), Translator.translate!(to_string(function_name), env) ] ) {js_ast, env} end def make_extern_function_call(module_name, function_name, params, env) do members = Module.split(module_name) ++ [to_string(function_name)] ast = JS.call_expression( Identifier.make_namespace_members(members), Enum.map(params, &Translator.translate!(&1, env)) ) {ast, env} end def make_function_or_property_call(module_name, function_name, env) do js_ast = JS.call_expression( JS.member_expression( JS.member_expression( JS.identifier("Bootstrap"), JS.member_expression( JS.identifier("Core"), JS.identifier("Functions") ) ), JS.identifier("call_property") ), [ Translator.translate!(module_name), Translator.translate!(to_string(function_name), env) ] ) { js_ast, env } end def make_function_call(module_name, function_name, [], env) when is_atom(module_name) and is_atom(function_name) do js_ast = JS.call_expression( JS.member_expression( JS.member_expression( JS.identifier("Bootstrap"), JS.member_expression( JS.identifier("Core"), JS.identifier("Functions") ) ), JS.identifier("call_property") ), [ Identifier.make_identifier(module_name), Translator.translate!(to_string(function_name), env) ] ) {js_ast, env} end def make_function_call(module_name, function_name, params, env) when is_atom(module_name) and is_atom(function_name) do js_ast = JS.call_expression( JS.member_expression( Identifier.make_identifier(module_name), Identifier.make_identifier(function_name) ), Enum.map(params, &Translator.translate!(&1, env)) ) {js_ast, env} end def make_function_call({{:., _, _}, _, _} = module_name, function_name, [], env) do js_ast = JS.call_expression( JS.member_expression( JS.member_expression( JS.identifier("Bootstrap"), JS.member_expression( JS.identifier("Core"), JS.identifier("Functions") ) ), JS.identifier("call_property") ), [ Translator.translate!(module_name, env), Translator.translate!(to_string(function_name), env) ] ) {js_ast, env} end def make_function_call({{:., _, _}, _, _} = module_name, function_name, params, env) do js_ast = JS.call_expression( JS.member_expression( Translator.translate!(module_name, env), Identifier.make_identifier(function_name) ), Enum.map(params, &Translator.translate!(&1, env)) ) {js_ast, env} end def make_function_call(module_name, function_name, [], env) do js_ast = JS.call_expression( JS.member_expression( JS.member_expression( JS.identifier("Bootstrap"), JS.member_expression( JS.identifier("Core"), JS.identifier("Functions") ) ), JS.identifier("call_property") ), [ Translator.translate!(module_name, env), Translator.translate!(to_string(function_name), env) ] ) {js_ast, env} end def make_function_call(module_name, function_name, params, env) 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 end elixirscript-0.27.0/lib/elixir_script/translator/kernel/special_forms/capture.ex000066400000000000000000000025321306310472000302450ustar00rootroot00000000000000defmodule 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, _, _) do Identifier.make_identifier(function_name) end def make_capture(module_name, function_name, _, env) do members = ["Elixir"] ++ Module.split(module_name) ++ ["__load"] ast = JS.member_expression( JS.call_expression( Identifier.make_namespace_members(members), [JS.identifier("Elixir")] ), Identifier.make_identifier(function_name) ) end def make_extern_capture(module_name, function_name, _, env) do members = Module.split(module_name) ++ [to_string(function_name)] Identifier.make_namespace_members(members) 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.27.0/lib/elixir_script/translator/kernel/special_forms/case.ex000066400000000000000000000007401306310472000275140ustar00rootroot00000000000000defmodule 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.27.0/lib/elixir_script/translator/kernel/special_forms/cond.ex000066400000000000000000000016211306310472000275230ustar00rootroot00000000000000defmodule 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.27.0/lib/elixir_script/translator/kernel/special_forms/fn.ex000066400000000000000000000155621306310472000272140ustar00rootroot00000000000000defmodule 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("Bootstrap"), 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) 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 guards = case guards do {:when, _, whens} -> whens wh -> List.wrap(wh) end guards = guards |> Enum.reverse |> process_guards {guard_body, _} = prepare_function_body(guards, %{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 process_guards([guard]) do guard end defp process_guards([head | tail]) do {:or, [], [process_guards(tail), head]} 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.27.0/lib/elixir_script/translator/kernel/special_forms/for.ex000066400000000000000000000077351306310472000274020ustar00rootroot00000000000000defmodule 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 alias ElixirScript.Translator.Identifier 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 members = ["Elixir"] ++ Module.split(ElixirScript.Collectable) ++ ["__load"] collectable_module = JS.call_expression( Identifier.make_namespace_members(members), [JS.identifier("Elixir")] ) expression = JS.call_expression( JS.member_expression( JS.member_expression( JS.member_expression( JS.identifier("Bootstrap"), 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, collectable_module, 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("Bootstrap"), 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("Bootstrap"), 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.27.0/lib/elixir_script/translator/kernel/special_forms/identifier.ex000066400000000000000000000026451306310472000307310ustar00rootroot00000000000000defmodule 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 def make_namespace_members(module_name) do case module_name do m when is_list(m) -> m m when is_binary(m) -> String.split(m, ".") m when is_atom(m) -> Module.split(m) end |> Enum.reverse |> make_alias end end elixirscript-0.27.0/lib/elixir_script/translator/kernel/special_forms/map.ex000066400000000000000000000036771306310472000273720ustar00rootroot00000000000000defmodule 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.27.0/lib/elixir_script/translator/kernel/special_forms/match.ex000066400000000000000000000045221306310472000276770ustar00rootroot00000000000000defmodule 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("Bootstrap"), 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("Bootstrap"), 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.27.0/lib/elixir_script/translator/kernel/special_forms/primitive.ex000066400000000000000000000042201306310472000306060ustar00rootroot00000000000000defmodule 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("Bootstrap"), JS.member_expression( JS.identifier("Core"), JS.identifier("SpecialForms") ) ) end def tuple_class() do JS.member_expression( JS.member_expression( JS.identifier("Bootstrap"), JS.identifier("Core") ), JS.identifier("Tuple") ) end def list_ast() do JS.member_expression( JS.member_expression( JS.identifier("Bootstrap"), 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.27.0/lib/elixir_script/translator/kernel/special_forms/quote.ex000066400000000000000000000044211306310472000277360ustar00rootroot00000000000000defmodule 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("Bootstrap"), 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.27.0/lib/elixir_script/translator/kernel/special_forms/struct.ex000066400000000000000000000100421306310472000301210ustar00rootroot00000000000000defmodule 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) members = ["Elixir"] ++ Module.split(name) ++ ["__load"] JS.member_expression( JS.call_expression( Identifier.make_namespace_members(members), [JS.identifier("Elixir")] ), 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("Bootstrap"), JS.member_expression( JS.identifier("Core"), JS.identifier("Functions") ) ), JS.identifier(name) ), [defaults] ) ) JS.variable_declaration([ref_declarator], :const) end end elixirscript-0.27.0/lib/elixir_script/translator/kernel/special_forms/try.ex000066400000000000000000000055561306310472000274310ustar00rootroot00000000000000defmodule 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 = Keyword.get(blocks, :do) rescue_block = Keyword.get(blocks, :rescue, nil) catch_block = Keyword.get(blocks, :catch, nil) after_block = Keyword.get(blocks, :after, nil) else_block = Keyword.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.27.0/lib/elixir_script/translator/kernel/special_forms/with.ex000066400000000000000000000033341306310472000275560ustar00rootroot00000000000000defmodule 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.27.0/lib/elixir_script/translator/lexical_scope.ex000066400000000000000000000250341306310472000253100ustar00rootroot00000000000000defmodule 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.27.0/lib/elixir_script/translator/pattern_matching.ex000066400000000000000000000153601306310472000260260ustar00rootroot00000000000000defmodule 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("Bootstrap"), 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.27.0/lib/elixir_script/translator/rewriter.ex000066400000000000000000000401341306310472000243370ustar00rootroot00000000000000defmodule 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), Bootstrap.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), Bootstrap.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), Bootstrap.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(Bootstrap.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: Bootstrap.Core.Functions.foldl(unquote(fun), unquote(acc), unquote(list)) end def rewrite({{:., _, [:lists, :foldr]}, _, [fun, acc, list]}) do quote do: Bootstrap.Core.Functions.foldr(unquote(fun), unquote(acc), unquote(list)) end def rewrite({{:., _, [:lists, :keymember]}, _, [key, n, list]}) do quote do: Bootstrap.Core.Functions.keymember(unquote(key), unquote(n), unquote(list)) end def rewrite({{:., _, [:lists, :keydelete]}, _, [key, n, list]}) do quote do: Bootstrap.Core.Functions.keydelete(unquote(key), unquote(n), unquote(list)) end def rewrite({{:., _, [:lists, :keystore]}, _, [key, n, list, newtuple]}) do quote do: Bootstrap.Core.Functions.keystore(unquote(key), unquote(n), unquote(list), unquote(newtuple)) end def rewrite({{:., _, [:lists, :keytake]}, _, [key, n, list]}) do quote do: Bootstrap.Core.Functions.keystore(unquote(key), unquote(n), unquote(list)) end def rewrite({{:., _, [:lists, :keyfind]}, _, [key, n, list]}) do quote do: Bootstrap.Core.Functions.keyfind(unquote(key), unquote(n), unquote(list)) end def rewrite({{:., _, [:lists, :keyreplace]}, _, [key, n, list, newtuple]}) do quote do: Bootstrap.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: Bootstrap.Core.Functions.reverse(unquote(list)) end def rewrite({{:., _, [:lists, :reverse]}, _, [list, tail]}) do quote do: Bootstrap.Core.Functions.reverse(unquote(list)) ++ unquote(tail) end def rewrite({{:., _, [:lists, :flatten]}, _, [list]}) do quote do: Bootstrap.Core.Functions.flatten(unquote(list)) end def rewrite({{:., _, [:lists, :flatten]}, _, [list, tail]}) do quote do: Bootstrap.Core.Functions.flatten(unquote(list), unquote(tail)) end def rewrite({{:., _, [:lists, :delete]}, _, [elem, list]}) do quote do: Bootstrap.Core.Functions.remove_from_list(unquote(list), unquote(elem)) end def rewrite({{:., _, [:lists, :duplicate]}, _, [n, elem]}) do quote do: Bootstrap.Core.Functions.duplicate(unquote(n), unquote(elem)) end def rewrite({{:., _, [:lists, :mapfoldl]}, _, [fun, acc, list]}) do quote do: Bootstrap.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: Bootstrap.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(Bootstrap.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 Bootstrap.Core.Functions.get_object_keys(unquote(map)) end def rewrite({{:., _, [:maps, :put]}, _, [key, value, map]}) do quote do: Bootstrap.Core.Functions.add_property_to_map(unquote(map), unquote(key), unquote(value)) end def rewrite({{:., _, [:maps, :update]}, _, [key, value, map]}) do quote do: Bootstrap.Core.Functions.update_map(unquote(map), unquote(key), unquote(value)) end def rewrite({{:., _, [:maps, :find]}, _, [key, map]}) do quote do: Bootstrap.Core.Functions.maps_find(unquote(key), unquote(map)) end def rewrite({{:., _, [:maps, :remove]}, _, [key, map]}) do quote do: Bootstrap.Core.Functions.delete_property_from_map(unquote(map), unquote(key)) end def rewrite({{:., _, [:maps, :fold]}, _, [fun, init, map]}) do quote do: Bootstrap.Core.Functions.maps_fold(unquote(fun), unquote(init), unquote(map)) end def rewrite({{:., _, [:maps, :from_list]}, _, [list]}) do quote do: Bootstrap.Core.Functions.maps_fold(unquote(list)) end end elixirscript-0.27.0/lib/elixir_script/translator/state.ex000066400000000000000000000107241306310472000236160ustar00rootroot00000000000000# 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 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) |> Map.put(IO, ElixirScript.IO) end def set_module_data(pid, module_data) do Agent.update(pid, fn state -> %{ state | modules: Keyword.merge(state.modules, 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_ref, state)) do nil -> state module -> module = Map.update(module, :refs, [module_name], fn(x) -> Enum.uniq(x ++ [module_name]) 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, :refs, []) end end def list_module_references(pid) do Agent.get(pid, fn(state) -> Enum.map(state.modules, fn {name, module} -> {name, Map.get(module, :refs, [])} end) 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 end elixirscript-0.27.0/lib/elixir_script/translator/unsupported_error.ex000066400000000000000000000003441306310472000262740ustar00rootroot00000000000000defmodule ElixirScript.Translator.UnsupportedError do defexception [:message] def exception(value) do msg = "Currently unsupported #{inspect value}" %ElixirScript.Translator.UnsupportedError{message: msg} end end elixirscript-0.27.0/lib/elixir_script/translator/utils.ex000066400000000000000000000030451306310472000236340ustar00rootroot00000000000000defmodule 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 |> Module.split |> 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.27.0/lib/elixir_script/watcher.ex000066400000000000000000000021011306310472000217300ustar00rootroot00000000000000defmodule 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.27.0/lib/mix/000077500000000000000000000000001306310472000156605ustar00rootroot00000000000000elixirscript-0.27.0/lib/mix/tasks/000077500000000000000000000000001306310472000170055ustar00rootroot00000000000000elixirscript-0.27.0/lib/mix/tasks/compile.elixir_script.ex000066400000000000000000000062211306310472000236530ustar00rootroot00000000000000defmodule Mix.Tasks.Compile.ElixirScript do use Mix.Task @recursive true @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 path of the generated JavaScript file. (defaults to `priv/elixirscript`) If path ends in `.js` then that will be the name of the file. If a directory is given, file will be named `Elixir.App.js` * `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_base = Path.join([Mix.Project.build_path, "elixirscript"]) do_compile(elixirscript_base, Mix.Project.config[:app]) :ok end defp do_compile(_, nil) do raise ElixirScriptCompileError, message: "Unable to find mix project app name" end defp do_compile(elixirscript_base, app) do elixirscript_config = get_elixirscript_config() File.mkdir_p!(elixirscript_base) elixirscript_path = Path.join([elixirscript_base, "#{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) js_modules = Keyword.get(elixirscript_config, :js_modules, []) ElixirScript.compile_path(paths, %{output: output_path, format: format, js_modules: js_modules}) end def clean do elixirscript_config = get_elixirscript_config() output_path = Keyword.get(elixirscript_config, :output) path = ElixirScript.Passes.HandleOutput.get_js_path(output_path) if File.exists?(path) do File.rm!(path) 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.27.0/lib/mix/tasks/elixirscript.ex000066400000000000000000000004711306310472000220660ustar00rootroot00000000000000defmodule 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.27.0/lib/mix/tasks/elixirscript.watch.ex000066400000000000000000000027741306310472000232030ustar00rootroot00000000000000defmodule 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) js_modules = Keyword.get(elixirscript_config, :js_modules, []) {:ok, _} = ElixirScript.Watcher.start_link( input_path, %{output: output_path, format: format, js_modules: js_modules} ) :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.27.0/mix.exs000066400000000000000000000046621306310472000156430ustar00rootroot00000000000000defmodule ElixirScript.Mixfile do use Mix.Project def project do [ app: :elixir_script, version: "0.27.0", elixir: "~> 1.0", elixirc_paths: elixirc_paths(), 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 elixirc_paths(), do: ["lib", "priv/std_lib"] 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/**/*.*", "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] 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 System.cmd("npm", ["run", "build"]) 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.27.0/mix.lock000066400000000000000000000044551306310472000157740ustar00rootroot00000000000000%{"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.27.0/package.json000066400000000000000000000032161306310472000166050ustar00rootroot00000000000000{ "name": "elixirscript", "version": "0.26.1", "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": "rollup -c rollup.config.js", "clean": "rm -rf priv/build", "test": "mocha src/javascript/tests --recursive --compilers js:babel-core/register", "build:test-app": "mix elixirscript test/app/src/ -f common -o test/app/build/", "test-app": "yarn run build:test-app && NODE_ENV=test mocha 'test/app/spec/*.spec.js' --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", "rollup-plugin-uglify": "^1.0.1", "sinon": "^1.17.7", "sinon-chai": "^2.8.0" } } elixirscript-0.27.0/priv/000077500000000000000000000000001306310472000152755ustar00rootroot00000000000000elixirscript-0.27.0/priv/std_lib/000077500000000000000000000000001306310472000167155ustar00rootroot00000000000000elixirscript-0.27.0/priv/std_lib/agent.ex000066400000000000000000000022151306310472000203510ustar00rootroot00000000000000defmodule ElixirScript.Agent do @moduledoc false require JS def start(fun, options \\ []) do pid = JS.new Bootstrap.Core.PID, [] name = if Elixir.Keyword.has_key?(options, :name) do Elixir.Keyword.get(options, :name) else nil end Bootstrap.Core.Store.create(pid, fun.(), name) { :ok, pid } end def start_link(fun, options \\ []) do pid = JS.new Bootstrap.Core.PID, [] name = if Elixir.Keyword.has_key?(options, :name) do Elixir.Keyword.get(options, :name) else nil end Bootstrap.Core.Store.create(pid, fun.(), name) { :ok, pid } end def stop(agent) do Bootstrap.Core.Store.remove(agent) :ok end def update(agent, fun) do current_state = Bootstrap.Core.Store.read(agent) Bootstrap.Core.Store.update(agent, fun.(current_state)) :ok end def get(agent, fun) do current_state = Bootstrap.Core.Store.read(agent) fun.(current_state) end def get_and_update(agent, fun) do current_state = Bootstrap.Core.Store.read(agent) {val, new_state} = fun.(current_state) Bootstrap.Core.Store.update(agent, new_state) val end end elixirscript-0.27.0/priv/std_lib/atom.ex000066400000000000000000000003341306310472000202130ustar00rootroot00000000000000defmodule 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 JS.Symbol.keyFor(atom) end end elixirscript-0.27.0/priv/std_lib/base.ex000066400000000000000000000004711306310472000201670ustar00rootroot00000000000000defmodule ElixirScript.Base do @moduledoc false def encode64(data) do Bootstrap.Core.b64EncodeUnicode(data) end def decode64(data) do if Bootstrap.Core.can_decode64(data) do {:ok, decode64!(data) } else :error end end def decode64!(data) do JS.atob(data) end end elixirscript-0.27.0/priv/std_lib/bitwise.ex000066400000000000000000000025551306310472000207300ustar00rootroot00000000000000defmodule ElixirScript.Bitwise do @moduledoc false defmacro bnot(expr) do quote do Bootstrap.Core.bnot(unquote(expr)) end end defmacro ~~~(expr) do quote do Bootstrap.Core.bnot(unquote(expr)) end end defmacro band(left, right) do quote do Bootstrap.Core.band(unquote(left), unquote(right)) end end defmacro left &&& right do quote do Bootstrap.Core.band(unquote(left), unquote(right)) end end defmacro bor(left, right) do quote do Bootstrap.Core.bor(unquote(left), unquote(right)) end end defmacro left ||| right do quote do Bootstrap.Core.bor(unquote(left), unquote(right)) end end defmacro bxor(left, right) do quote do Bootstrap.Core.bxor(unquote(left), unquote(right)) end end defmacro left ^^^ right do quote do Bootstrap.Core.bxor(unquote(left), unquote(right)) end end defmacro bsl(left, right) do quote do Bootstrap.Core.bsl(unquote(left), unquote(right)) end end defmacro left <<< right do quote do Bootstrap.Core.bsl(unquote(left), unquote(right)) end end defmacro bsr(left, right) do quote do Bootstrap.Core.bsr(unquote(left), unquote(right)) end end defmacro left >>> right do quote do Bootstrap.Core.bsr(unquote(left), unquote(right)) end end end elixirscript-0.27.0/priv/std_lib/collectable.ex000066400000000000000000000013331306310472000215240ustar00rootroot00000000000000defprotocol 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.27.0/priv/std_lib/enumerable.ex000066400000000000000000000023161306310472000213740ustar00rootroot00000000000000defprotocol 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.27.0/priv/std_lib/integer.ex000066400000000000000000000010671306310472000207140ustar00rootroot00000000000000defmodule 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, base \\ 10) do number.toString(base).split('') end def parse(bin, base \\ 10) do result = JS.parseInt(bin, base) if JS.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.27.0/priv/std_lib/io.ex000066400000000000000000000006371306310472000176700ustar00rootroot00000000000000defmodule ElixirScript.IO do def inspect(item, opts \\ []) do JS.console.log(item) item end def puts(device \\ :stdio, item) when is_binary(item) do case device do :stdio -> JS.console.log(item) :stderr -> JS.console.warn(item) end end def warn(message) when is_binary(message) do JS.console.warn("warning: #{message}") JS.console.trace() end end elixirscript-0.27.0/priv/std_lib/js.ex000066400000000000000000000044271306310472000176760ustar00rootroot00000000000000defmodule 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) @doc """ Updates an existing JavaScript object. ex: JS.update elem, %{"width" => 100} """ defmacro update(object, map) @doc """ Returns the type of the given value """ defmacro typeof(value) @doc """ Determines if value is an instance of type. """ defmacro instanceof(value, type) @doc """ Throws the term given """ defmacro throw(term) @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 Bootstrap.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() @doc """ Yields the current generator function with the given term """ defmacro yield(term) @doc """ Yields control to the given generator """ defmacro yield_to(gen) @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) end elixirscript-0.27.0/priv/std_lib/kernel.ex000066400000000000000000000076671306310472000205530ustar00rootroot00000000000000defmodule 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 JS.Math.abs(number) end def apply(fun, args) do Bootstrap.Core.Functions.apply(fun, args) end def apply(module, fun, args) do Bootstrap.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, Bootstrap.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, Bootstrap.Core.PID) end def is_tuple(term) do JS.instanceof(term, Bootstrap.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 JS.Object.keys(term).length end def max(first, second) do JS.Math.max(first, second) end def min(first, second) do JS.Math.min(first, second) end def round(number) do JS.Math.round(number) end def trunc(number) do JS.Math.floor(number) end def tuple_size(tuple) do Bootstrap.Core.Functions.size(tuple) end def elem(tuple, index) do Bootstrap.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 Bootstrap.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.27.0/priv/std_lib/keyword.ex000066400000000000000000000013241306310472000207370ustar00rootroot00000000000000defmodule ElixirScript.Keyword do @moduledoc false def new() do [] end 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.27.0/priv/std_lib/list.ex000066400000000000000000000123731306310472000202340ustar00rootroot00000000000000defmodule 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(Bootstrap.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 updated = case list[current_index] do ^item -> new_list _ -> new_list ++ [list[current_index]] end do_delete(list, item, current_index + 1, updated) 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 updated = case current_index == index do true -> new_list _ -> new_list ++ [list[current_index]] end do_delete_at(list, index, current_index + 1, updated) 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 updated = 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, updated) 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 updated = case current_index == index do true -> new_list ++ [value] _ -> new_list ++ [list[current_index]] end do_replace_at(list, index, value, current_index + 1, updated) 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 updated = 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, updated) 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 updated = case hd(list) do l when is_list(l) -> flattened_list ++ do_flatten(l, []) item -> flattened_list ++ [item] end do_flatten(tl(list), updated) 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) updated = if elem(current_value, position) == key do new_list else new_list ++ [current_value] end do_keydelete(tl(list), key, position, updated) 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) updated = if elem(current_value, position) == key do new_list ++ [new_tuple] else new_list ++ [current_value] end do_keyreplace(tl(list), key, position, updated, new_tuple) end def zip(list_of_lists) do Bootstrap.Core.Functions.zip(list_of_lists) end end elixirscript-0.27.0/priv/std_lib/macro/000077500000000000000000000000001306310472000200165ustar00rootroot00000000000000elixirscript-0.27.0/priv/std_lib/macro/env.ex000066400000000000000000000016041306310472000211450ustar00rootroot00000000000000defmodule 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.27.0/priv/std_lib/map.ex000066400000000000000000000071221306310472000200320ustar00rootroot00000000000000defmodule ElixirScript.Map do @moduledoc false def new() do %{} end def keys(map) do Bootstrap.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 JS.Object.values(map) end def from_struct(struct) do struct |> Bootstrap.Core.Functions.class_to_obj |> delete(:__struct__) end def delete(map, key) do map |> Bootstrap.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 Bootstrap.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 Bootstrap.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.27.0/priv/std_lib/map_set.ex000066400000000000000000000037021306310472000207050ustar00rootroot00000000000000defmodule 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.27.0/priv/std_lib/module.ex000066400000000000000000000003701306310472000205400ustar00rootroot00000000000000defmodule 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.27.0/priv/std_lib/range.ex000066400000000000000000000003711306310472000203500ustar00rootroot00000000000000defmodule 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.27.0/priv/std_lib/regex.ex000066400000000000000000000025721306310472000203730ustar00rootroot00000000000000defmodule ElixirScript.Regex do @moduledoc false require JS def compile(source, options \\ "") do try do {:ok, JS.new(JS.RegExp, [source, options])} rescue x -> {:error, x.message} end end def compile!(source, options \\ "") do JS.new(JS.RegExp, [source, options]) end def regex?(term) do JS.instanceof(term, JS.RegExp) end def match?(regex, string) do reg = if regex?(regex), do: regex, else: compile!(source(regex), opts(regex)) reg.test(string) end def source(regex) do regex.source end def opts(regex) do regex.opts 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(reg, 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?(opts(regex), "g") do regex else JS.new(JS.RegExp, [ source(regex), opts(regex) <> "g" ]) end end end elixirscript-0.27.0/priv/std_lib/string.ex000066400000000000000000000066561306310472000205760ustar00rootroot00000000000000defmodule ElixirScript.String do @moduledoc false import Kernel, except: [length: 1] def to_atom(str) do JS.Symbol.for(str) end def to_existing_atom(str) do JS.Symbol.for(str) end def to_char_list(str) do str.split("") end def to_float(str) do JS.parseFloat(str) end def to_integer(str) do JS.parseInt(str, 10) end def to_integer(str, base) do JS.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 Bootstrap.Core.Functions.is_valid_character(codepoint) end end elixirscript-0.27.0/priv/std_lib/string/000077500000000000000000000000001306310472000202235ustar00rootroot00000000000000elixirscript-0.27.0/priv/std_lib/string/chars.ex000066400000000000000000000015121306310472000216600ustar00rootroot00000000000000defprotocol 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.27.0/priv/std_lib/tuple.ex000066400000000000000000000026401306310472000204060ustar00rootroot00000000000000defmodule ElixirScript.Tuple do @moduledoc false require JS def duplicate(data, size) do JS.new(Bootstrap.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.values end def insert_at(tuple, index, value) do JS.new(Bootstrap.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 new_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, new_list) end end def delete_at(tuple, index) do JS.new(Bootstrap.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 new_list = case index == current_index do true -> list false -> list ++ [tuple.get(current_index)] end do_delete_at(tuple, index, current_index + 1, new_list) end end def append(tuple, value) do JS.new(Bootstrap.Core.Tuple, to_list(tuple) ++ [value]) end end elixirscript-0.27.0/rollup.config.js000066400000000000000000000005411306310472000174340ustar00rootroot00000000000000import nodeResolve from 'rollup-plugin-node-resolve'; import babel from 'rollup-plugin-babel'; export default { entry: 'src/javascript/elixir.js', moduleName: 'Bootstrap', plugins: [ nodeResolve({ jsnext: true }), babel({ babelrc: false, }), ], targets: [{ dest: 'priv/build/iife/Elixir.Bootstrap.js', format: 'iife' }], }; elixirscript-0.27.0/src/000077500000000000000000000000001306310472000151045ustar00rootroot00000000000000elixirscript-0.27.0/src/javascript/000077500000000000000000000000001306310472000172525ustar00rootroot00000000000000elixirscript-0.27.0/src/javascript/elixir.js000066400000000000000000000001421306310472000211010ustar00rootroot00000000000000import Core from './lib/core'; import Enum from './lib/enum'; export default { Core, Enum }; elixirscript-0.27.0/src/javascript/lib/000077500000000000000000000000001306310472000200205ustar00rootroot00000000000000elixirscript-0.27.0/src/javascript/lib/core.js000066400000000000000000000006311306310472000213060ustar00rootroot00000000000000import 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.27.0/src/javascript/lib/core/000077500000000000000000000000001306310472000207505ustar00rootroot00000000000000elixirscript-0.27.0/src/javascript/lib/core/functions.js000066400000000000000000000206121306310472000233170ustar00rootroot00000000000000import 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) { return args[0].apply(args[0], args.slice(1)); } else { return args[0][args[1]].apply(args[0], 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; } function build_namespace(ns, ns_string) { let parts = ns_string.split('.'); const root = ns; let parent = ns; if (parts[0] === 'Elixir') { parts = parts.slice(1); } for (const part of parts) { if (typeof parent[part] === 'undefined') { parent[part] = {}; } parent = parent[part]; } root.__table = ns.__table || {}; root.__table[Symbol.for(ns_string)] = parent; return parent; } 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, build_namespace }; elixirscript-0.27.0/src/javascript/lib/core/protocol.js000066400000000000000000000033061306310472000231510ustar00rootroot00000000000000import 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.27.0/src/javascript/lib/core/special_forms.js000066400000000000000000000057721306310472000241470ustar00rootroot00000000000000import 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.27.0/src/javascript/lib/core/store.js000066400000000000000000000013061306310472000224420ustar00rootroot00000000000000const 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.27.0/src/javascript/lib/enum.js000066400000000000000000000074461306310472000213350ustar00rootroot00000000000000import 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.27.0/src/javascript/tests/000077500000000000000000000000001306310472000204145ustar00rootroot00000000000000elixirscript-0.27.0/src/javascript/tests/case.spec.js000066400000000000000000000013141306310472000226150ustar00rootroot00000000000000import 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.27.0/src/javascript/tests/cond.spec.js000066400000000000000000000007551306310472000226350ustar00rootroot00000000000000import 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.27.0/src/javascript/tests/core/000077500000000000000000000000001306310472000213445ustar00rootroot00000000000000elixirscript-0.27.0/src/javascript/tests/core/functions.spec.js000066400000000000000000000013721306310472000246460ustar00rootroot00000000000000import 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.27.0/src/javascript/tests/for.spec.js000066400000000000000000000065661306310472000225060ustar00rootroot00000000000000import 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.27.0/src/javascript/tests/special_forms.spec.js000066400000000000000000000017321306310472000245340ustar00rootroot00000000000000import 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.27.0/src/javascript/tests/try.spec.js000066400000000000000000000014671306310472000225310ustar00rootroot00000000000000import 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.27.0/src/javascript/tests/with.spec.js000066400000000000000000000077111306310472000226640ustar00rootroot00000000000000import 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.27.0/test/000077500000000000000000000000001306310472000152745ustar00rootroot00000000000000elixirscript-0.27.0/test/app/000077500000000000000000000000001306310472000160545ustar00rootroot00000000000000elixirscript-0.27.0/test/app/spec/000077500000000000000000000000001306310472000170065ustar00rootroot00000000000000elixirscript-0.27.0/test/app/spec/atom.spec.js000066400000000000000000000006731306310472000212430ustar00rootroot00000000000000const expect = require('chai').expect; const Elixir = require('../build/Elixir.App'); describe('Atom', () => { it('to_string/1', () => { const exports = Elixir.load(Elixir.ElixirScript.Atom); expect(exports.to_string(Symbol.for('héllo'))).to.eq('héllo'); }); it('to_charlist/1', () => { const exports = Elixir.load(Elixir.ElixirScript.Atom); expect(exports.to_string(Symbol.for('héllo'))).to.eq('héllo'); }); }); elixirscript-0.27.0/test/app/spec/integer.spec.js000066400000000000000000000043541306310472000217400ustar00rootroot00000000000000const expect = require('chai').expect; const Elixir = require('../build/Elixir.App'); describe('Integer', () => { it('is_odd/1', () => { const Integer = Elixir.load(Elixir.ElixirScript.Integer); expect(Integer.is_odd(0)).to.eq(false); expect(Integer.is_odd(1)).to.eq(true); expect(Integer.is_odd(2)).to.eq(false); expect(Integer.is_odd(3)).to.eq(true); expect(Integer.is_odd(-1)).to.eq(true); expect(Integer.is_odd(-2)).to.eq(false); expect(Integer.is_odd(-3)).to.eq(true); }); it('is_even/1', () => { const Integer = Elixir.load(Elixir.ElixirScript.Integer); expect(Integer.is_even(0)).to.eq(true); expect(Integer.is_even(1)).to.eq(false); expect(Integer.is_even(2)).to.eq(true); expect(Integer.is_even(3)).to.eq(false); expect(Integer.is_even(-1)).to.eq(false); expect(Integer.is_even(-2)).to.eq(true); expect(Integer.is_even(-3)).to.eq(false); }); it('parse/2', () => { const Integer = Elixir.load(Elixir.ElixirScript.Integer); expect(Integer.parse('12').values).to.eql([12, '']); expect(Integer.parse('012').values).to.eql([12, '']); expect(Integer.parse('+12').values).to.eql([12, '']); expect(Integer.parse('-12').values).to.eql([-12, '']); expect(Integer.parse('123456789').values).to.eql([123456789, '']); expect(Integer.parse('12.5').values).to.eql([12, '.5']); expect(Integer.parse('7.5e-3').values).to.eql([7, '.5e-3']); // expect(Integer.parse('12x').values).to.eql([12, 'x']); expect(Integer.parse('++1')).to.eql(Symbol.for('error')); expect(Integer.parse('--1')).to.eql(Symbol.for('error')); expect(Integer.parse('+-1')).to.eql(Symbol.for('error')); expect(Integer.parse('three')).to.eql(Symbol.for('error')); expect(Integer.parse('12', 10).values).to.eql([12, '']); expect(Integer.parse('-12', 12).values).to.eql([-14, '']); expect(Integer.parse('12345678', 9).values).to.eql([6053444, '']); expect(Integer.parse('3.14', 4).values).to.eql([3, '.14']); expect(Integer.parse('64eb', 16).values).to.eql([25835, '']); // expect(Integer.parse('64eb', 10).values).to.eql([64, 'eb']); expect(Integer.parse('10', 2).values).to.eql([2, '']); expect(Integer.parse('++4', 10)).to.eql(Symbol.for('error')); }); }); elixirscript-0.27.0/test/app/spec/main.spec.js000066400000000000000000000011651306310472000212240ustar00rootroot00000000000000const expect = require('chai').expect; const sinon = require('sinon'); const Elixir = require('../build/Elixir.App'); describe('Elixir.start', function () { it('calls the modules start function', function () { const callback = sinon.spy(); Elixir.start(Elixir.Main, callback); expect(callback).to.have.been.calledWith('started'); }); }); describe('Elixir.load', function () { it('loads the modules exports', function () { const main = Elixir.load(Elixir.Main); expect(main).to.have.property('start'); expect(main).to.have.property('hello'); expect(main.hello()).to.eq('Hello!'); }); }); elixirscript-0.27.0/test/app/spec/setup.spec.js000066400000000000000000000004261306310472000214370ustar00rootroot00000000000000const sinon = require('sinon'); const chai = require('chai'); const sinonChai = require('sinon-chai'); before(function () { chai.use(sinonChai); }); beforeEach(function () { this.sandbox = sinon.sandbox.create(); }); afterEach(function () { this.sandbox.restore(); }); elixirscript-0.27.0/test/app/spec/tuple.spec.js000066400000000000000000000025061306310472000214310ustar00rootroot00000000000000const expect = require('chai').expect; const Elixir = require('../build/Elixir.App'); const Tuple = require('../../../src/javascript/lib/core').default.Tuple; describe('Tuple', () => { it('duplicate/2', () => { const TupleModule = Elixir.load(Elixir.ElixirScript.Tuple); expect(TupleModule.duplicate(Symbol.for('foo'), 0).values).to.eql([]); expect(TupleModule.duplicate(Symbol.for('foo'), 3).values).to.eql([Symbol.for('foo'), Symbol.for('foo'), Symbol.for('foo')]); }); it('insert_at/3', () => { const TupleModule = Elixir.load(Elixir.ElixirScript.Tuple); const t = new Tuple(Symbol.for('bar'), Symbol.for('baz')); expect(TupleModule.insert_at(t, 0, Symbol.for('foo')).values).to.eql([Symbol.for('foo'), Symbol.for('bar'), Symbol.for('baz')]); }); it('append/2', () => { const TupleModule = Elixir.load(Elixir.ElixirScript.Tuple); const t = new Tuple(Symbol.for('foo'), Symbol.for('bar')); expect(TupleModule.append(t, Symbol.for('baz')).values).to.eql([Symbol.for('foo'), Symbol.for('bar'), Symbol.for('baz')]); }); it('delete_at/2', () => { const TupleModule = Elixir.load(Elixir.ElixirScript.Tuple); const t = new Tuple(Symbol.for('foo'), Symbol.for('bar'), Symbol.for('baz')); expect(TupleModule.delete_at(t, 0).values).to.eql([Symbol.for('bar'), Symbol.for('baz')]); }); }); elixirscript-0.27.0/test/app/src/000077500000000000000000000000001306310472000166435ustar00rootroot00000000000000elixirscript-0.27.0/test/app/src/main.ex000066400000000000000000000001721306310472000201250ustar00rootroot00000000000000defmodule Main do def start(:normal, callback) do callback.("started") end def hello do "Hello!" end end elixirscript-0.27.0/test/cli_test.exs000066400000000000000000000003131306310472000176200ustar00rootroot00000000000000defmodule ElixirScript.CLI.Test do use ExUnit.Case test "parse_args -e expands to elixir" do {_, args} = ElixirScript.CLI.parse_args(["1 + 1", "-e"]) assert args == [elixir: true] end end elixirscript-0.27.0/test/passes/000077500000000000000000000000001306310472000165725ustar00rootroot00000000000000elixirscript-0.27.0/test/passes/create_js_modules_test.exs000066400000000000000000000011611306310472000240400ustar00rootroot00000000000000defmodule ElixirScript.Passes.CreateJSModules.Test do use ExUnit.Case import ElixirScript.TestHelper alias ElixirScript.Passes.CreateJSModules alias ESTree.Tools.Generator test "start" do ex_ast = quote do: CreateJSModules.start js = """ Elixir.start = function(app, args) { app.__load(Elixir).start(Symbol.for('normal'), args) } """ assert_translation(ex_ast, js) end test "load" do ex_ast = quote do: CreateJSModules.load js = """ Elixir.load = function(module) { return module.__load(Elixir); } """ assert_translation(ex_ast, js) end end elixirscript-0.27.0/test/passes/handle_output_test.exs000066400000000000000000000012631306310472000232270ustar00rootroot00000000000000defmodule ElixirScript.Passes.HandleOutput.Test do use ExUnit.Case alias ElixirScript.Passes.HandleOutput test "get_js_path output: nil" do assert HandleOutput.get_js_path(nil) == "Elixir.App.js" end test "get_js_path output: stdout" do assert HandleOutput.get_js_path(:stdout) == "Elixir.App.js" end test "get_js_path output is directory" do assert HandleOutput.get_js_path("/path/to/file/") == "/path/to/file/Elixir.App.js" assert HandleOutput.get_js_path("/path/to/file") == "/path/to/file/Elixir.App.js" end test "get_js_path output ends in js" do assert HandleOutput.get_js_path("/path/to/file/myfile.js") == "/path/to/file/myfile.js" end endelixirscript-0.27.0/test/prelude/000077500000000000000000000000001306310472000167345ustar00rootroot00000000000000elixirscript-0.27.0/test/prelude/js_test.exs000066400000000000000000000015001306310472000211240ustar00rootroot00000000000000defmodule ElixirScript.Lib.JS.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate new" do ex_ast = quote do require JS def execute() do JS.new A.B, [1, 2, 3] end end js_code = """ new A.B(1, 2, 3) """ assert_translation(ex_ast, js_code) ex_ast = quote do require JS def execute() do JS.new A, [1, 2, 3] end end js_code = """ new A(1, 2, 3) """ assert_translation(ex_ast, js_code) end test "translate update" do ex_ast = quote do require JS def execute() do JS.update A, %{"b" => [1, 2, 3]} end end js_code = """ Object.assign(A, Object.freeze({ b: Object.freeze([1, 2, 3]) })) """ assert_translation(ex_ast, js_code) end end elixirscript-0.27.0/test/prelude/kernel_test.exs000066400000000000000000000015541306310472000220010ustar00rootroot00000000000000defmodule 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.__load(Elixir).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.__load(Elixir).compile__emark__('foo', '') """ assert_translation(ex_ast, js_code) end test "translate sigil_r with options" do ex_ast = quote do ~r/foo/i end js_code = """ Elixir.ElixirScript.Regex.__load(Elixir).compile__emark__('foo', 'i') """ assert_translation(ex_ast, js_code) end end elixirscript-0.27.0/test/test_helper.exs000066400000000000000000000034231306310472000203350ustar00rootroot00000000000000exclude = 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) 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(hd(List.wrap(actual_js_code))) =~ strip_spaces(expected_js_code), """ **Code Does Not Match ** ***Expected*** #{expected_js_code} ***Actual*** #{actual_js_code} """ end def refute_translation(ex_ast, js_code) do refute_translation(ex_ast, js_code, :es) end def refute_translation(ex_ast, js_code, format) do converted_code = ex_ast_to_js(ex_ast, format) refute converted_code |> strip_spaces =~ strip_spaces(js_code), """ **Code Does Not Match ** ***Expected*** #{js_code} ***Actual*** #{converted_code} """ end end elixirscript-0.27.0/test/translator/000077500000000000000000000000001306310472000174655ustar00rootroot00000000000000elixirscript-0.27.0/test/translator/access_test.exs000066400000000000000000000004211306310472000225030ustar00rootroot00000000000000defmodule ElixirScript.Translator.Access.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate access" do ex_ast = quote do a = [] a[:b] end js_code = "a[Symbol.for('b')]" assert_translation(ex_ast, js_code) end end elixirscript-0.27.0/test/translator/atom_test.exs000066400000000000000000000006231306310472000222060ustar00rootroot00000000000000defmodule 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.__load(Elixir).to_string(Symbol.for('atom'))") end end elixirscript-0.27.0/test/translator/bitstring_test.exs000066400000000000000000000100541306310472000232520ustar00rootroot00000000000000defmodule 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 Bootstrap.Core.BitString(Bootstrap.Core.BitString.integer(1), Bootstrap.Core.BitString.integer(2), Bootstrap.Core.BitString.integer(3))") ex_ast = quote do: <<1, "foo">> assert_translation(ex_ast, "new Bootstrap.Core.BitString(Bootstrap.Core.BitString.integer(1), Bootstrap.Core.BitString.binary('foo'))") ex_ast = quote do: <<1, "foo" :: binary>> assert_translation(ex_ast, "new Bootstrap.Core.BitString(Bootstrap.Core.BitString.integer(1), Bootstrap.Core.BitString.binary('foo'))") ex_ast = quote do: <<1, "foo" :: utf8, "bar" :: utf32>> assert_translation(ex_ast, "new Bootstrap.Core.BitString(Bootstrap.Core.BitString.integer(1), Bootstrap.Core.BitString.utf8('foo'), Bootstrap.Core.BitString.utf32('bar'))") ex_ast = quote do rest = "oo" <<102 :: integer-native, rest :: binary>> end assert_translation(ex_ast, "new Bootstrap.Core.BitString(Bootstrap.Core.BitString.native(Bootstrap.Core.BitString.integer(102)), Bootstrap.Core.BitString.binary(rest))") ex_ast = quote do rest = "oo" <<102 :: unsigned-big-integer, rest :: binary>> end assert_translation(ex_ast, "new Bootstrap.Core.BitString(Bootstrap.Core.BitString.integer(Bootstrap.Core.BitString.big(Bootstrap.Core.BitString.unsigned(102))), Bootstrap.Core.BitString.binary(rest))") ex_ast = quote do rest = 100 <<102, rest :: size(16)>> end assert_translation(ex_ast, "new Bootstrap.Core.BitString(Bootstrap.Core.BitString.integer(102), Bootstrap.Core.BitString.size(rest, 16))") ex_ast = quote do rest = 100 <<102, rest :: size(16)-unit(4)>> end assert_translation(ex_ast, "new Bootstrap.Core.BitString(Bootstrap.Core.BitString.integer(102), Bootstrap.Core.BitString.unit(Bootstrap.Core.BitString.size(rest, 16), 4))") ex_ast = quote do rest = 100 <<102, rest :: 16 * 4>> end assert_translation(ex_ast, "new Bootstrap.Core.BitString(Bootstrap.Core.BitString.integer(102), Bootstrap.Core.BitString.unit(Bootstrap.Core.BitString.size(rest, 16), 4))") ex_ast = quote do rest = 100 <<102, rest :: 16>> end assert_translation(ex_ast, "new Bootstrap.Core.BitString(Bootstrap.Core.BitString.integer(102), Bootstrap.Core.BitString.size(rest, 16))") ex_ast = quote do: << 1, <<2>> >> assert_translation(ex_ast, "new Bootstrap.Core.BitString(Bootstrap.Core.BitString.integer(1), new Bootstrap.Core.BitString(Bootstrap.Core.BitString.integer(2)))") end test "translate pattern matching bitstring" do ex_ast = quote do: <> = <<"Frank the Walrus">> js_code = """ let [name,species] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.bitStringMatch(Bootstrap.Core.BitString.size(Bootstrap.Core.BitString.binary({ 'value': Bootstrap.Core.Patterns.variable() }),5),Bootstrap.Core.BitString.binary(' the '),Bootstrap.Core.BitString.binary({ 'value': Bootstrap.Core.Patterns.variable() })),'Frank the Walrus'); """ assert_translation(ex_ast, js_code) ex_ast = quote do: <> = <<-100>> js_code = """ let [int] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.bitStringMatch(Bootstrap.Core.BitString.integer({ 'value': Bootstrap.Core.Patterns.variable() })),new Bootstrap.Core.BitString(Bootstrap.Core.BitString.binary(-100))); """ assert_translation(ex_ast, js_code) ex_ast = quote do: <<-100::signed, _rest::binary>> = <<-100, "foo">> js_code = """ let [_rest] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.bitStringMatch(Bootstrap.Core.BitString.signed(-100),Bootstrap.Core.BitString.binary({ 'value': Bootstrap.Core.Patterns.variable() })),new Bootstrap.Core.BitString(Bootstrap.Core.BitString.binary(-100),Bootstrap.Core.BitString.binary('foo'))); """ assert_translation(ex_ast, js_code) end end elixirscript-0.27.0/test/translator/bitwise_test.exs000066400000000000000000000004231306310472000227120ustar00rootroot00000000000000defmodule 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.27.0/test/translator/bug_test.exs000066400000000000000000000102771306310472000220310ustar00rootroot00000000000000defmodule 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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([],function(){ return Symbol.for('atom'); })); """ assert_translation(ex_ast, js_code) end test "Translate react element" do ex_ast = quote do def execute() do React.createElement( React.Text, %{"style" => ""}, "Welcome to React Native!" ) end end js_code = """ React.createElement(React.Text,Object.freeze({ style: '' }),'Welcome to React Native!') """ assert_translation(ex_ast, js_code) end test "replace !" do ex_ast = quote do def execute(data, i) do Enum.fetch!(data, i) end end js_code = """ Bootstrap.Enum.fetch__emark__(data, i) """ assert_translation(ex_ast, js_code) end test "chain calls correctly" do ex_ast = quote do def execute() do :this.getRawCanvas().getContext("2d") end end js_code = """ Bootstrap.Core.Functions.call_property(this, 'getRawCanvas').getContext('2d') """ assert_translation(ex_ast, js_code) ex_ast = quote do def execute(one) do :this.getRawCanvas(one).get("fg").getContext("2d") end 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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([],function() { return DeLorean.Flux.createDispatcher(Object.freeze({ [Symbol.for('startPainting')]: Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([],function() { return this.dispatch('startPainting'); })), [Symbol.for('stopPainting')]: Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([],function() { return this.dispatch('stopPainting'); })), [Symbol.for('addPoint')]: Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()],function(data) { return this.dispatch('addPoint',data); })), [Symbol.for('getStores')]: Bootstrap.Core.Patterns.defmatch(Bootstrap.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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()],function(x){ return Object.freeze([Bootstrap.Core.Functions.call_property(x,'a'), Bootstrap.Core.Functions.call_property(x,'b')]); })); """ assert_translation(ex_ast, js_code) end test "Elixir.Enum.member__qmark__ does not show up in translation" do ex_ast = quote do Enum.member?([1, 2, 3], 1) end js_code = """ Elixir.Enum.member__qmark__ """ refute_translation(ex_ast, js_code) end test "pipe translates correctly" do ex_ast = quote do def execute() do :document.getElementById("main") |> JS.update(%{"innerHTML" => @html}) end end js_code = """ Object.assign(document.getElementById('main'), Object.freeze({ innerHTML: html })) """ assert_translation(ex_ast, js_code) end end elixirscript-0.27.0/test/translator/capture_test.exs000066400000000000000000000070221306310472000227110ustar00rootroot00000000000000defmodule 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] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.variable(), Elixir.ElixirScript.Kernel.__load(Elixir).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] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.variable(),Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()],function(__1) { return Elixir.ElixirScript.Kernel.__load(Elixir).is_atom(__1); }))); """ assert_translation(ex_ast, js_code) end test "translate capture operator with function, and arity" do ex_ast = quote do fun = &is_atom/1 end js_code = """ let [fun] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.variable(),is_atom); """ 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] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.variable(),Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.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] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.variable(),Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable()],function(__1,__2) { return new Bootstrap.Core.Tuple(__1,__2); }))); """ assert_translation(ex_ast, js_code) ex_ast = quote do fun = &{&1, &2, &3} end js_code = """ let [fun] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.variable(),Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable()],function(__1,__2,__3) { return new Bootstrap.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 def process(a) do end def execute() do Enum.map([], &process(&1)) end end js_code = """ Bootstrap.Enum.map(Object.freeze([]),Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()],function(__1) { return process(__1); }))) """ assert_translation(ex_ast, js_code) ex_ast = quote do def process_event(a) do end def execute() do Elem.keypress(&process_event(&1)) end end js_code = """ Elem.keypress(Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()],function(__1) { return process_event(__1); }))) """ assert_translation(ex_ast, js_code) end end elixirscript-0.27.0/test/translator/case_test.exs000066400000000000000000000146541306310472000221720ustar00rootroot00000000000000defmodule ElixirScript.Translator.Case.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate case" do ex_ast = quote do def execute() do data = :ok case data do :ok -> 1 :error -> nil end end end js_code = """ Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Symbol.for('ok')],function() { return 1; }),Bootstrap.Core.Patterns.clause([Symbol.for('error')],function() { return null; })).call(this,data) """ assert_translation(ex_ast, js_code) ex_ast = quote do data = true case data do false -> value = 13 true -> true end end js_code = """ Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([false],function() { let [value] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.variable(),13); return value; }),Bootstrap.Core.Patterns.clause([true],function() { return true; })).call(this,data) """ assert_translation(ex_ast, js_code) ex_ast = quote do data = :ok case data do false -> value = 13 _ -> true end end js_code = """ Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([false],function() { let [value] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.variable(),13); return value; }),Bootstrap.Core.Patterns.clause([Bootstrap.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 data = :ok case data do number when number in [1,2,3,4] -> value = 13 _ -> true end end js_code = """ Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()],function(number) { let [value] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.variable(),13); return value; },function(number) { return Bootstrap.Core.Functions.contains(number,Object.freeze([1, 2, 3, 4])); }),Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.wildcard()],function() { return true; })).call(this,data) """ assert_translation(ex_ast, js_code) end test "translate case with multiple guards" do ex_ast = quote do data = :ok case data do number when number in [1,2,3,4] when number in [4, 3, 2, 1] -> value = 13 _ -> true end end js_code = """ Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()],function(number) { let [value] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.variable(),13); return value; },function(number) { return Bootstrap.Core.Functions.contains(number,Object.freeze([1, 2, 3, 4])) || Bootstrap.Core.Functions.contains(number,Object.freeze([4, 3, 2, 1])); }),Bootstrap.Core.Patterns.clause([Bootstrap.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 def execute() do data = :ok case data do :ok -> :console.info("info") Todo.add(data) :error -> nil end end end js_code = """ Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Symbol.for('ok')],function() { console.info('info'); return Todo.add(data); }),Bootstrap.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 def execute() do data = :ok case data do { one, two } -> :console.info(one) :error -> nil end end end js_code = """ Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.type(Bootstrap.Core.Tuple, { values: [Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable()] })], function(one, two) { return console.info(one); }), Bootstrap.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 def execute() do data = :error case data do { {one, two} , three } -> :console.info(one) :error -> nil end end end js_code = """ Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.type(Bootstrap.Core.Tuple, { values: [Bootstrap.Core.Patterns.type(Bootstrap.Core.Tuple, { values: [Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable()] }), Bootstrap.Core.Patterns.variable()] })], function(one, two, three) { return console.info(one); }), Bootstrap.Core.Patterns.clause([Symbol.for('error')], function() { return null; })).call(this, data) """ assert_translation(ex_ast, js_code) ex_ast = quote do data = :error case data do { one, {two, three} } -> :console.info(one) :error -> nil end end js_code = """ Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.type(Bootstrap.Core.Tuple, { values: [Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.type(Bootstrap.Core.Tuple, { values: [Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable()] })] })], function(one, two, three) { return console.info(one); }), Bootstrap.Core.Patterns.clause([Symbol.for('error')], function() { return null; })).call(this, data) """ assert_translation(ex_ast, js_code) end end elixirscript-0.27.0/test/translator/commonjs_test.exs000066400000000000000000000006271306310472000230770ustar00rootroot00000000000000defmodule 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 "#todo-list" def something() do @ul end end end js_code = """ module.exports = Elixir """ assert_translation(ex_ast, js_code, :common) end end elixirscript-0.27.0/test/translator/cond_test.exs000066400000000000000000000031551306310472000221740ustar00rootroot00000000000000defmodule 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 = """ Bootstrap.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 = """ Bootstrap.Core.SpecialForms.cond(Object.freeze([1 + 1 == 1, function() { let [a] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.variable(),1); return 'This will never match'; }]),Object.freeze([2 * 2 != 4, function() { let [a] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.variable(),2); return 'Nor this'; }]),Object.freeze([true, function() { let [a] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.variable(),3); return 'This will'; }])) """ assert_translation(ex_ast, js_code) end end elixirscript-0.27.0/test/translator/defdelegate_test.exs000066400000000000000000000013061306310472000234760ustar00rootroot00000000000000defmodule ElixirScript.Translator.Defdelegate.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate defdelegate" do ex_ast = quote do: defdelegate reverse(list), to: :lists js_code = """ const reverse = function(list) { return Bootstrap.Core.Functions.reverse(list); }; """ assert_translation(ex_ast, js_code) end test "translate defdelegate as another name" do ex_ast = quote do: defdelegate other_reverse(list), to: :lists, as: :reverse js_code = """ const other_reverse = function(list) { return Bootstrap.Core.Functions.reverse(list); }; """ assert_translation(ex_ast, js_code) end endelixirscript-0.27.0/test/translator/defmodule_test.exs000066400000000000000000000053701306310472000232160ustar00rootroot00000000000000defmodule 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 = """ const __exports = {}; """ assert_translation(ex_ast, js_code) end test "translate defmodules" do ex_ast = quote do defmodule Elephant do require JS @ul "#todo-list" def something() do @ul end JS.defgenp something_else() do end end end js_code = """ const something = Bootstrap.Core.Patterns.defmatchgen(Bootstrap.Core.Patterns.clause([], function*() { return ul; })); const ul = '#todo-list'; const something_else = Bootstrap.Core.Patterns.defmatchgen(Bootstrap.Core.Patterns.clause([], function*() { return null; })); const __exports = { 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 %Animals.Elephant{} end defp something_else() do end end end js_code = """ const Elixir$Animals$Elephant = Bootstrap.Core.Functions.defstruct({ [Symbol.for('__struct__')]: Symbol.for('Elixir.Animals.Elephant'), [Symbol.for('trunk')]: true }); """ 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 %Animals.Elephant{} end defp something_else() do end end end js_code = """ const Elixir$Animals$Elephant$Bear = Bootstrap.Core.Functions.defstruct({ [Symbol.for('__struct__')]: Symbol.for('Elixir.Animals.Elephant.Bear'), [Symbol.for('trunk')]: true }); """ 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 Lions.Tigers.Bears do def oh_my() do end end defmodule Lions.Tigers do def oh_my() do end Lions.Tigers.Bears.oh_my() end defmodule Animals do Lions.Tigers.oh_my() end end js_code = """ Elixir.Lions.Tigers.Bears.__load(Elixir).oh_my() """ assert_translation(ex_ast, js_code) end end elixirscript-0.27.0/test/translator/for_test.exs000066400000000000000000000143521306310472000220400ustar00rootroot00000000000000defmodule 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 = """ Bootstrap.Core.SpecialForms._for( Bootstrap.Core.Patterns.clause( [Bootstrap.Core.Patterns.variable()], function(n) { return n * 2; }, function() { return true; } ), [ Bootstrap.Core.Patterns.list_generator( Bootstrap.Core.Patterns.variable(), Object.freeze([1, 2, 3, 4]) ) ], Elixir.ElixirScript.Collectable.__load(Elixir), 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 = """ Bootstrap.Core.SpecialForms._for( Bootstrap.Core.Patterns.clause( [Bootstrap.Core.Patterns.variable()], function(n) { return n * 2; }, function() { return true; } ), [ Bootstrap.Core.Patterns.list_generator( Bootstrap.Core.Patterns.variable(), Object.freeze([1, 2, 3, 4]) ) ], Elixir.ElixirScript.Collectable.__load(Elixir), 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 = """ Bootstrap.Core.SpecialForms._for( Bootstrap.Core.Patterns.clause( [Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable()], function(x, y) { return x * y; }, function() { return true; } ), [ Bootstrap.Core.Patterns.list_generator( Bootstrap.Core.Patterns.variable(), Object.freeze([1, 2]) ), Bootstrap.Core.Patterns.list_generator( Bootstrap.Core.Patterns.variable(), Object.freeze([2, 3]) ) ], Elixir.ElixirScript.Collectable.__load(Elixir), 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] = Bootstrap.Core.Patterns.match( Bootstrap.Core.Patterns.variable(), Bootstrap.Core.SpecialForms._for( Bootstrap.Core.Patterns.clause( [Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable()], function(x, y) { return x * y; }, function() { return true; } ), [ Bootstrap.Core.Patterns.list_generator( Bootstrap.Core.Patterns.variable(), Object.freeze([1, 2]) ), Bootstrap.Core.Patterns.list_generator( Bootstrap.Core.Patterns.variable(), Object.freeze([2, 3]) ) ], Elixir.ElixirScript.Collectable.__load(Elixir), 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 = """ Bootstrap.Core.SpecialForms._for( Bootstrap.Core.Patterns.clause( [Bootstrap.Core.Patterns.variable()], function(n) { return n; }, function(n) { return n % 2 == 0; } ), [ Bootstrap.Core.Patterns.list_generator( Bootstrap.Core.Patterns.variable(), Object.freeze([1, 2, 3, 4, 5, 6]) ) ], Elixir.ElixirScript.Collectable.__load(Elixir), 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 = """ Bootstrap.Core.SpecialForms._for( Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.type(Bootstrap.Core.Tuple, { values: [Symbol.for('user'), Bootstrap.Core.Patterns.variable()] })], function(name) { return Elixir.ElixirScript.String.__load(Elixir).upcase(name); }, function() { return true; }), [ Bootstrap.Core.Patterns.list_generator(Bootstrap.Core.Patterns.type(Bootstrap.Core.Tuple, { values: [Symbol.for('user'), Bootstrap.Core.Patterns.variable()] }), Object.freeze([new Bootstrap.Core.Tuple(Symbol.for('user'), 'john'), new Bootstrap.Core.Tuple(Symbol.for('admin'), 'john'), new Bootstrap.Core.Tuple(Symbol.for('user'), 'meg')])) ], Elixir.ElixirScript.Collectable.__load(Elixir), Object.freeze([])) """ assert_translation(ex_ast, js_code) end test "translate for with bitstring" do ex_ast = quote do pixels = <<1, 2, 3, 4, 5, 6>> for <> do {r, g, b} end end js_code = """ Bootstrap.Core.SpecialForms._for(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.bitStringMatch(Bootstrap.Core.BitString.size({ 'value': Bootstrap.Core.Patterns.variable() }, 8), Bootstrap.Core.BitString.size({ 'value': Bootstrap.Core.Patterns.variable() }, 8), Bootstrap.Core.BitString.size({ 'value': Bootstrap.Core.Patterns.variable() }, 8))], function(r, g, b) { return new Bootstrap.Core.Tuple(r, g, b); }, function() { return true; }), [Bootstrap.Core.Patterns.bitstring_generator(Bootstrap.Core.Patterns.bitStringMatch(Bootstrap.Core.BitString.size({ 'value': Bootstrap.Core.Patterns.variable() }, 8), Bootstrap.Core.BitString.size({ 'value': Bootstrap.Core.Patterns.variable() }, 8), Bootstrap.Core.BitString.size({ 'value': Bootstrap.Core.Patterns.variable() }, 8)), pixels)], Elixir.ElixirScript.Collectable.__load(Elixir), Object.freeze([])) """ assert_translation(ex_ast, js_code) end end elixirscript-0.27.0/test/translator/function_test.exs000066400000000000000000000570771306310472000231120ustar00rootroot00000000000000defmodule ElixirScript.Translator.Function.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate functions" do ex_ast = quote do def test1() do end end js_code = """ const test1 = Bootstrap.Core.Patterns.defmatch(Bootstrap.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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable(), Bootstrap.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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable()],function(alpha,beta) { let [a] = Bootstrap.Core.Patterns.match(Bootstrap.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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable()],function(alpha,beta) { return Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()],function(x) { return 2; },function(x) { return x === null || x === false; }),Bootstrap.Core.Patterns.clause([Bootstrap.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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable()], function(alpha, beta) { return Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()], function(x) { return 2; }, function(x) { return x === null || x === false; }), Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.wildcard()], function() { return Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()], function(x) { let [a] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.variable(), 1); return a; }, function(x) { return x === null || x === false; }), Bootstrap.Core.Patterns.clause([Bootstrap.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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable()], function(alpha, beta) { let [a, b] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.type(Bootstrap.Core.Tuple, { values: [Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable()] }), new Bootstrap.Core.Tuple(1, 2)); let _ref = new Bootstrap.Core.Tuple(a, b); return _ref; })); """ assert_translation(ex_ast, js_code) end test "translate function calls" do ex_ast = quote do defmodule Taco do def test1() do end end Taco.test1() end js_code = "Elixir.Taco.__load(Elixir).test1()" assert_translation(ex_ast, js_code) ex_ast = quote do defmodule Taco do def test1(a, b) do end end Taco.test1(3, 2) end js_code = "Elixir.Taco.__load(Elixir).test1(3,2)" assert_translation(ex_ast, js_code) ex_ast = quote do defmodule Taco do def test1(a, b) do end def test2(a) do end end Taco.test1(Taco.test2(1), 2) end js_code = "Elixir.Taco.__load(Elixir).test1(Elixir.Taco.__load(Elixir).test2(1), 2)" assert_translation(ex_ast, js_code) end test "translate anonymous functions" do ex_ast = quote do list = [] Enum.map(list, fn(x) -> x * 2 end) end js_code = """ Bootstrap.Enum.map(list,Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.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 = """ const example = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([],function() { return null; }),Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()],function(oneArg) { return null; }),Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable()],function(oneArg,twoArg) { return null; }),Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable()],function(oneArg,twoArg,redArg) { return null; }),Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable()],function(oneArg,twoArg,redArg,blueArg) { return null; })); """ 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 = """ const example = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([],function() { return null; }),Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()],function(oneArg) { return null; }),Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable()],function(oneArg,twoArg) { return null; }),Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable()],function(oneArg,twoArg,redArg) { return null; }),Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable()],function(oneArg,twoArg,redArg,blueArg) { return null; })); """ assert_translation(ex_ast, js_code) ex_ast = quote do defmodule Example do def example(oneArg) do end end end js_code = """ const example = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()],function(oneArg) { return null; })); """ 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.__load(Elixir).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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()],function(one) { return null; },function(one) { return Elixir.ElixirScript.Kernel.__load(Elixir).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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()],function(one) { return null; },function(one) { return Elixir.ElixirScript.Kernel.__load(Elixir).is_number(one) || Elixir.ElixirScript.Kernel.__load(Elixir).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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()],function(one) { return null; },function(one) { return Elixir.ElixirScript.Kernel.__load(Elixir).is_number(one) || Elixir.ElixirScript.Kernel.__load(Elixir).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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable()],function(one,two) { return null; },function(one,two) { return Bootstrap.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 = """ const something = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()],function(one) { return null; },function(one) { return Bootstrap.Core.Functions.contains(one,Object.freeze([1, 2, 3])); }),Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()],function(one) { return null; },function(one) { return Elixir.ElixirScript.Kernel.__load(Elixir).is_number(one) || Elixir.ElixirScript.Kernel.__load(Elixir).is_atom(one); })); """ 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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.headTail(Bootstrap.Core.Patterns.variable(),Bootstrap.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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Object.freeze([Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable(), Bootstrap.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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.type(Bootstrap.Core.Tuple, { values: [Bootstrap.Core.Patterns.variable(), Bootstrap.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 defmodule AStruct do defstruct [] end def something(%AStruct{}) do end end js_code = """ const something = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.type(Elixir.AStruct.__load(Elixir).Elixir$AStruct, {})], function() { return null; })); """ assert_translation(ex_ast, js_code) end test "pattern match function with struct reference" do ex_ast = quote do defmodule AStruct do defstruct [] end def something(%AStruct{} = a) do end end js_code = """ const something = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.capture(Bootstrap.Core.Patterns.type(Elixir.AStruct.__load(Elixir).Elixir$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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.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 defmodule AStruct do defstruct [:key, :key1] end def something(%AStruct{key: value, key1: 2}) do end end js_code = """ const something = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.type(Elixir.AStruct.__load(Elixir).Elixir$AStruct, { [Symbol.for('key')]: Bootstrap.Core.Patterns.variable(), [Symbol.for('key1')]: 2 })], function(value) { return null; })); """ assert_translation(ex_ast, js_code) ex_ast = quote do defmodule AStruct do defstruct [:key, :key1] end def something(%AStruct{key: value, key1: 2}) when is_number(value) do end end js_code = """ const something = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.type(Elixir.AStruct.__load(Elixir).Elixir$AStruct, { [Symbol.for('key')]: Bootstrap.Core.Patterns.variable(), [Symbol.for('key1')]: 2 })], function(value) { return null; }, function(value) { return Elixir.ElixirScript.Kernel.__load(Elixir).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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.startsWith('Bearer '), Bootstrap.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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.startsWith('Bearer '), Bootstrap.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 = """ const something = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([1],function() { return null; }),Bootstrap.Core.Patterns.clause([2],function() { return null; }),Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()],function(one) { return null; },function(one) { return Elixir.ElixirScript.Kernel.__load(Elixir).is_binary(one); }),Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()],function(one) { return null; })); """ 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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable()],function(alpha,beta) { let [a] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.variable(),1); let [a1] = Bootstrap.Core.Patterns.match(Bootstrap.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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable()],function(alpha,beta) { let [a] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.variable(),1); let [a1] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.variable(),a); let [a2] = Bootstrap.Core.Patterns.match(Bootstrap.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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable()],function(alpha,beta) { let [a] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.variable(),1); let [a1,b,c] = Bootstrap.Core.Patterns.match(Object.freeze([Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable(), Bootstrap.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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable()],function(alpha__qmark__,beta__emark__) { let [a__qmark__] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.variable(),1); let [b__emark__] = Bootstrap.Core.Patterns.match(Bootstrap.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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable(), Bootstrap.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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable(Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.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 = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()], function(param) { return Bootstrap.Core.SpecialForms._try(function() { return Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()], function(x) { return Symbol.for('error'); }, function(x) { return x === null || x === false; }), Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.wildcard()], function() { return null; })).call(this, true); }, null, Bootstrap.Core.Patterns.defmatch(Bootstrap.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] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.variable(),'test'); Bootstrap.Core.Patterns.defmatch( Bootstrap.Core.Patterns.clause( [Bootstrap.Core.Patterns.bound(key)], function() { return Symbol.for('ok'); } ) ) """ assert_translation(ex_ast, js_code) end test "multiple when guards" do ex_ast = quote do def something(one) when is_number(one) when is_atom(one) do end end js_code = """ const something = Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()],function(one) { return null; },function(one) { return Elixir.ElixirScript.Kernel.__load(Elixir).is_number(one) || Elixir.ElixirScript.Kernel.__load(Elixir).is_atom(one); })); """ assert_translation(ex_ast, js_code) end end elixirscript-0.27.0/test/translator/js_test.exs000066400000000000000000000033321306310472000216620ustar00rootroot00000000000000defmodule ElixirScript.Translator.JS.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate global function calls" do ex_ast = quote do: JS.alert("hi") js_code = "Bootstrap.Core.Functions.get_global().alert('hi')" assert_translation(ex_ast, js_code) ex_ast = quote do: JS.back() js_code = "Bootstrap.Core.Functions.call_property(Bootstrap.Core.Functions.get_global(), 'back')" assert_translation(ex_ast, js_code) end test "translate global properties" do ex_ast = quote do: JS.length js_code = "Bootstrap.Core.Functions.call_property(Bootstrap.Core.Functions.get_global(), 'length')" assert_translation(ex_ast, js_code) end test "translate global module" do ex_ast = quote do: JS.String.toString() js_code = "Bootstrap.Core.Functions.call_property(Bootstrap.Core.Functions.get_global().String, 'toString')" assert_translation(ex_ast, js_code) ex_ast = quote do: JS.String.raw("hi") js_code = "Bootstrap.Core.Functions.get_global().String.raw('hi')" assert_translation(ex_ast, js_code) ex_ast = quote do: JS.Something.Other.raw("hi") js_code = "Bootstrap.Core.Functions.get_global().Something.Other.raw('hi')" assert_translation(ex_ast, js_code) end test "translate global lowercase" do ex_ast = quote do: JS.console.log("hi") js_code = "Bootstrap.Core.Functions.call_property(Bootstrap.Core.Functions.get_global(), 'console').log('hi')" assert_translation(ex_ast, js_code) ex_ast = quote do: JS.window.length js_code = "Bootstrap.Core.Functions.call_property(Bootstrap.Core.Functions.call_property(Bootstrap.Core.Functions.get_global(), 'window'), 'length')" assert_translation(ex_ast, js_code) end end elixirscript-0.27.0/test/translator/kernel_test.exs000066400000000000000000000041041306310472000225240ustar00rootroot00000000000000defmodule ElixirScript.Translator.Kernel.Test do use ExUnit.Case import ElixirScript.TestHelper test "raise with bitstring" do ex_ast = quote do def execute() do list = [] raise ArgumentError, "cannot convert list to string. The list must contain only integers, strings or nested such lists; got: #{inspect list}" end 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.__load(Elixir).to_string(inspect(list)) })); """ assert_translation(ex_ast, js_code) end test "raise with string" do ex_ast = quote do def execute() do raise ArgumentError, "cannot convert list to string. The list must contain only integers, strings or nested such lists; got" end 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.__load(Elixir).max(1, 2) """ 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.__load(Elixir).apply(Enum, Symbol.for('reverse'), Object.freeze([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.__load(Elixir).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.__load(Elixir).tl(Object.freeze([1, 2, 3])) """ assert_translation(ex_ast, js_code) end end elixirscript-0.27.0/test/translator/list_test.exs000066400000000000000000000031231306310472000222170ustar00rootroot00000000000000defmodule 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 list = [] list ++ [4, 5, 6] end js_code = "list.concat(Object.freeze([4, 5, 6]))" assert_translation(ex_ast, js_code) end test "prepend element" do ex_ast = quote do x = 1 list = [] [x | list] end js_code = "Object.freeze([x]).concat(list)" assert_translation(ex_ast, js_code) end test "prepend element in function" do ex_ast = quote do x = 1 list = [] fn (_) -> [x|list] end end js_code = """ Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.wildcard()],function(){ return Object.freeze([x]).concat(list); })) """ assert_translation(ex_ast, js_code) end end elixirscript-0.27.0/test/translator/map_test.exs000066400000000000000000000036521306310472000220300ustar00rootroot00000000000000defmodule 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: 2} %{ map | value: 1 } end js_code = """ Bootstrap.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 = 1 value = 2 %{key => value} end js_code = "Object.freeze({ [key]: value })" assert_translation(ex_ast, js_code) end test "translate bound map key" do ex_ast = quote do key = 1 value = 2 %{^key => value} = %{key => value} end js_code = """ let [value1] = Bootstrap.Core.Patterns.match({ [key]: Bootstrap.Core.Patterns.variable() }, Object.freeze({ [key]: value })); """ assert_translation(ex_ast, js_code) end end elixirscript-0.27.0/test/translator/match_test.exs000066400000000000000000000054341306310472000223470ustar00rootroot00000000000000defmodule 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] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.variable(), 1);" assert_translation(ex_ast, js_code) ex_ast = quote do: a = :atom js_code = "let [a] = Bootstrap.Core.Patterns.match(Bootstrap.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] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.type(Bootstrap.Core.Tuple, { values: [Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.variable()] }), new Bootstrap.Core.Tuple(1, 2)); let _ref = new Bootstrap.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] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.type(Bootstrap.Core.Tuple, { values: [Bootstrap.Core.Patterns.variable(), Bootstrap.Core.Patterns.wildcard(), Bootstrap.Core.Patterns.variable()] }), new Bootstrap.Core.Tuple(1, 2, 3)); let _ref = new Bootstrap.Core.Tuple(a, undefined, c); """ assert_translation(ex_ast, js_code) ex_ast = quote do a = 1 {^a, _, c} = {1, 2, 3} end js_code = """ let [, undefined, c] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.type(Bootstrap.Core.Tuple, { values: [Bootstrap.Core.Patterns.bound(a), Bootstrap.Core.Patterns.wildcard(), Bootstrap.Core.Patterns.variable()] }), new Bootstrap.Core.Tuple(1, 2, 3)); let _ref = new Bootstrap.Core.Tuple(undefined, undefined, c); """ assert_translation(ex_ast, js_code) end test "translate bound match" do ex_ast = quote do a = 1 ^a = 1 end js_code = """ let [] = Bootstrap.Core.Patterns.match(Bootstrap.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] = Bootstrap.Core.Patterns.match(Object.freeze([Bootstrap.Core.Patterns.variable(), Bootstrap.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] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.headTail(Bootstrap.Core.Patterns.variable(),Bootstrap.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.27.0/test/translator/nil_test.exs000066400000000000000000000003101306310472000220210ustar00rootroot00000000000000defmodule 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.27.0/test/translator/number_test.exs000066400000000000000000000006251306310472000225400ustar00rootroot00000000000000defmodule 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.27.0/test/translator/pattern_matching_test.exs000066400000000000000000000172001306310472000245740ustar00rootroot00000000000000defmodule 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 alias ElixirScript.Translator.State setup do {:ok, pid} = State.start_link(%{env: __ENV__}, []) State.set_module_data(pid, [{ ElixirScript.Kernel, %{app: :elixir, name: ElixirScript.Kernel, ast: {}, functions: []} }]) 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.27.0/test/translator/quote_test.exs000066400000000000000000000071301306310472000224030ustar00rootroot00000000000000defmodule 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 Bootstrap.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 Bootstrap.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 Bootstrap.Core.Tuple( Symbol.for('test'), Object.freeze([new Bootstrap.Core.Tuple(Symbol.for('context'),Symbol.for('Elixir.ElixirScript.Translator.Quote.Test')), new Bootstrap.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 Bootstrap.Core.Tuple( Symbol.for('test'), Object.freeze([new Bootstrap.Core.Tuple(Symbol.for('context'), Symbol.for('Elixir.ElixirScript.Translator.Quote.Test')), new Bootstrap.Core.Tuple(Symbol.for('import'),Symbol.for('Elixir.ExUnit.Case'))]),Object.freeze([new Bootstrap.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 x = 1 quote do: test(unquote(x)) end js_code = """ new Bootstrap.Core.Tuple( Symbol.for('test'), Object.freeze([new Bootstrap.Core.Tuple(Symbol.for('context'),Symbol.for('Elixir.ElixirScript.Translator.Quote.Test')), new Bootstrap.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([1, 2, 3]), 5) end js_code = """ new Bootstrap.Core.Tuple(Symbol.for('sum'), Object.freeze([]), Bootstrap.Enum.concat(Object.freeze([1]), Object.freeze([1, 2, 3]), Object.freeze([5]))) """ assert_translation(ex_ast, js_code) end test "bind_quoted" do ex_ast = quote do x = 1 quote bind_quoted: [x: x] do x * x end end js_code = """ new Bootstrap.Core.Tuple( Symbol.for('*'), Object.freeze([new Bootstrap.Core.Tuple(Symbol.for('context'), Symbol.for('Elixir.ElixirScript.Translator.Quote.Test')), new Bootstrap.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 Bootstrap.Core.Tuple( Symbol.for('test'), Object.freeze([new Bootstrap.Core.Tuple(Symbol.for('context'),Symbol.for('Elixir')), new Bootstrap.Core.Tuple(Symbol.for('import'),Symbol.for('Elixir.ExUnit.Case'))]),Object.freeze([1]) ) """ assert_translation(ex_ast, js_code) end end elixirscript-0.27.0/test/translator/string_test.exs000066400000000000000000000032351306310472000225560ustar00rootroot00000000000000defmodule 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.__load(Elixir).to_string('world')") ex_ast = quote do: "Hello #{length([])}" assert_translation(ex_ast, "'Hello ' + Elixir.ElixirScript.String.Chars.__load(Elixir).to_string(Elixir.ElixirScript.Kernel.__load(Elixir).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.__load(Elixir).to_string(Elixir.ElixirScript.Kernel.__load(Elixir).length(Object.freeze([]))) + '\\n')") ex_ast = quote do: """ Hello #{length([])} How are you, #{length([])}? """ assert_translation(ex_ast, "'Hello ' + (Elixir.ElixirScript.String.Chars.__load(Elixir).to_string(Elixir.ElixirScript.Kernel.__load(Elixir).length(Object.freeze([]))) + ('\\nHow are you, ' + (Elixir.ElixirScript.String.Chars.__load(Elixir).to_string(Elixir.ElixirScript.Kernel.__load(Elixir).length(Object.freeze([]))) + '?\\n')))") end end elixirscript-0.27.0/test/translator/struct_test.exs000066400000000000000000000103511306310472000225710ustar00rootroot00000000000000defmodule 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 = """ const Elixir$User = Bootstrap.Core.Functions.defstruct({ [Symbol.for('__struct__')]: Symbol.for('Elixir.User'), [Symbol.for('name')]: 'john', [Symbol.for('age')]: 27 }); """ 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 = """ const Elixir$User = Bootstrap.Core.Functions.defstruct({ [Symbol.for('__struct__')]: Symbol.for('Elixir.User'), [Symbol.for('name')]: null, [Symbol.for('age')]: null }); """ 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 = """ const Elixir$User = Bootstrap.Core.Functions.defstruct({ [Symbol.for('__struct__')]: Symbol.for('Elixir.User'), [Symbol.for('name')]: null, [Symbol.for('age')]: null }); """ assert_translation(ex_ast, js_code) ex_ast = quote do defmodule User do defstruct [:name, :age] end user = %User{name: "John"} end js_code = """ const Elixir$User = Bootstrap.Core.Functions.defstruct({ [Symbol.for('__struct__')]: Symbol.for('Elixir.User'), [Symbol.for('name')]: null, [Symbol.for('age')]: null }); """ assert_translation(ex_ast, js_code) end test "translate struct update" do ex_ast = quote do map = %{key: nil} user = %{ map | key: 1 } end js_code = """ let [user] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.variable(),Bootstrap.Core.SpecialForms.map_update(map,Object.freeze({ [Symbol.for('key')]: 1 }))); """ assert_translation(ex_ast, js_code) ex_ast = quote do map = %{key: nil, key1: nil} user = %{ map | key: 1, key1: 11 } end js_code = """ let [user] = Bootstrap.Core.Patterns.match(Bootstrap.Core.Patterns.variable(),Bootstrap.Core.SpecialForms.map_update(map,Object.freeze({ [Symbol.for('key')]: 1, [Symbol.for('key1')]: 11 }))); """ 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 = """ const Elixir$MyAppError = Bootstrap.Core.Functions.defexception({ [Symbol.for('__struct__')]: Symbol.for('Elixir.MyAppError'), [Symbol.for('__exception__')]: true, [Symbol.for('message')]: 'This is a message' }); """ assert_translation(ex_ast, js_code) ex_ast = quote do defmodule MyAppError do defexception [:message] end end js_code = """ const Elixir$MyAppError = Bootstrap.Core.Functions.defexception({ [Symbol.for('__struct__')]: Symbol.for('Elixir.MyAppError'), [Symbol.for('__exception__')]: true, [Symbol.for('message')]: null }); """ assert_translation(ex_ast, js_code) end test "translate raise exception" do ex_ast = quote do defmodule MyAppError do defexception [:message] def do_it() do raise MyAppError, message: "did not get what was expected" end end end js_code = """ throw Elixir.MyAppError.__load(Elixir).Elixir$MyAppError.create(Object.freeze({ [Symbol.for('message')]: 'did not get what was expected' })); """ assert_translation(ex_ast, js_code) ex_ast = quote do def do_it() do raise "did not get what was expected" end 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.27.0/test/translator/try_test.exs000066400000000000000000000141311306310472000220630ustar00rootroot00000000000000defmodule 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 1 rescue ArgumentError -> IO.puts "Invalid argument given" end end js_code = """ Bootstrap.Core.SpecialForms._try(function() { return 1; }, Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.type(ArgumentError, {})], function() { return Elixir.ElixirScript.IO.__load(Elixir).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 1 rescue [ArgumentError] -> IO.puts "Invalid argument given" end end js_code = """ Bootstrap.Core.SpecialForms._try(function() { return 1; }, Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.type(ArgumentError, {})], function() { return Elixir.ElixirScript.IO.__load(Elixir).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 1 rescue x in [ArgumentError] -> IO.puts "Invalid argument given" end end js_code = """ Bootstrap.Core.SpecialForms._try(function() { return 1; },Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()],function(x) { return Elixir.ElixirScript.IO.__load(Elixir).puts('Invalid argument given'); },function(x) { return Bootstrap.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 1 rescue x -> IO.puts "Invalid argument given" end end js_code = """ Bootstrap.Core.SpecialForms._try(function() { return 1; },Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()],function(x) { return Elixir.ElixirScript.IO.__load(Elixir).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 1 rescue [ArgumentError] -> IO.puts "ArgumentError" x -> IO.puts "x" end end js_code = """ Bootstrap.Core.SpecialForms._try(function() { return 1; }, Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.type(ArgumentError, {})], function() { return Elixir.ElixirScript.IO.__load(Elixir).puts('ArgumentError'); }), Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()], function(x) { return Elixir.ElixirScript.IO.__load(Elixir).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 1 rescue ArgumentError -> IO.puts "Invalid argument given" after IO.puts "This is printed regardless if it failed or succeed" end end js_code = """ Bootstrap.Core.SpecialForms._try(function() { return 1; }, Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.type(ArgumentError, {})], function() { return Elixir.ElixirScript.IO.__load(Elixir).puts('Invalid argument given'); })), null, null, function() { return Elixir.ElixirScript.IO.__load(Elixir).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 1 after IO.puts "This is printed regardless if it failed or succeed" end end js_code = """ Bootstrap.Core.SpecialForms._try(function() { return 1; },null,null,null,function() { return Elixir.ElixirScript.IO.__load(Elixir).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 x = 1 try do 1 / x else y when y < 1 and y > -1 -> :small _ -> :large end end js_code = """ Bootstrap.Core.SpecialForms._try(function() { return 1 / x; }, null, null, Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.variable()], function(y) { return Symbol.for('small'); }, function(y) { return y < 1 && y > -1; }), Bootstrap.Core.Patterns.clause([Bootstrap.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 1 rescue ArgumentError -> IO.puts "Invalid argument given" catch :throw, :Error -> IO.puts "caught error" end end js_code = """ Bootstrap.Core.SpecialForms._try(function() { return 1; }, Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Bootstrap.Core.Patterns.type(ArgumentError, {})], function() { return Elixir.ElixirScript.IO.__load(Elixir).puts('Invalid argument given'); })), Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Symbol.for('throw'), Symbol.for('Error')], function() { return Elixir.ElixirScript.IO.__load(Elixir).puts('caught error'); })), null, null) """ assert_translation(ex_ast, js_code) end end elixirscript-0.27.0/test/translator/tuple_test.exs000066400000000000000000000016771306310472000224110ustar00rootroot00000000000000defmodule 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 Bootstrap.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 Bootstrap.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 Bootstrap.Core.Tuple('a', 'b', 'c')" assert_translation(ex_ast, js_code) ex_ast = quote do: {:a, :b, :c} js_code = "new Bootstrap.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 Bootstrap.Core.Tuple(Symbol.for('a'), 2, 'c')" assert_translation(ex_ast, js_code) end end elixirscript-0.27.0/test/translator/umd_test.exs000066400000000000000000000012111306310472000220250ustar00rootroot00000000000000defmodule 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 "#todo-list" def something() do @ul end end end js_code = """ (function(root, factory) { if (typeof define === 'function' && define.amd) { define([], factory) } else if (typeof exports === 'object') { module.exports = factory() } else { root.Elixir = factory() } """ assert_translation(ex_ast, js_code, :umd) end endelixirscript-0.27.0/test/translator/with_test.exs000066400000000000000000000063341306310472000222260ustar00rootroot00000000000000defmodule ElixirScript.Translator.With.Test do use ExUnit.Case import ElixirScript.TestHelper test "translate with" do ex_ast = quote do opts = %{} with {:ok, width} <- Map.fetch(opts, :width), {:ok, height} <- Map.fetch(opts, :height), do: {:ok, width * height} end js_code = """ Bootstrap.Core.SpecialForms._with([Bootstrap.Core.Patterns.type(Bootstrap.Core.Tuple,{ values: [Symbol.for('ok'), Bootstrap.Core.Patterns.variable()] }), function() { return Elixir.ElixirScript.Map.__load(Elixir).fetch(opts,Symbol.for('width')); }],[Bootstrap.Core.Patterns.type(Bootstrap.Core.Tuple,{ values: [Symbol.for('ok'), Bootstrap.Core.Patterns.variable()] }), function(width) { return Elixir.ElixirScript.Map.__load(Elixir).fetch(opts,Symbol.for('height')); }],function(width,height) { return new Bootstrap.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 opts = %{} 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 = """ Bootstrap.Core.SpecialForms._with([Bootstrap.Core.Patterns.type(Bootstrap.Core.Tuple,{ values: [Symbol.for('ok'), Bootstrap.Core.Patterns.variable()] }), function() { return Elixir.ElixirScript.Map.__load(Elixir).fetch(opts,Symbol.for('width')); }],[Bootstrap.Core.Patterns.variable(), function(width) { return width * 2; }],[Bootstrap.Core.Patterns.type(Bootstrap.Core.Tuple,{ values: [Symbol.for('ok'), Bootstrap.Core.Patterns.variable()] }), function(width,double_width) { return Elixir.ElixirScript.Map.__load(Elixir).fetch(opts,Symbol.for('height')); }],function(width,double_width,height) { return new Bootstrap.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 opts = %{} 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 = """ Bootstrap.Core.SpecialForms._with([Bootstrap.Core.Patterns.type(Bootstrap.Core.Tuple,{ values: [Symbol.for('ok'), Bootstrap.Core.Patterns.variable()] }), function() { return Elixir.ElixirScript.Map.__load(Elixir).fetch(opts,Symbol.for('width')); }],[Bootstrap.Core.Patterns.type(Bootstrap.Core.Tuple,{ values: [Symbol.for('ok'), Bootstrap.Core.Patterns.variable()] }), function(width) { return Elixir.ElixirScript.Map.__load(Elixir).fetch(opts,Symbol.for('height')); }],function(width,height) { return new Bootstrap.Core.Tuple(Symbol.for('ok'),width * height); },Bootstrap.Core.Patterns.defmatch(Bootstrap.Core.Patterns.clause([Symbol.for('error')],function() { return new Bootstrap.Core.Tuple(Symbol.for('error'),Symbol.for('wrong_data')); }))) """ assert_translation(ex_ast, js_code) end end elixirscript-0.27.0/yarn.lock000066400000000000000000003207571306310472000161560ustar00rootroot00000000000000# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY. # yarn lockfile v1 acorn-jsx@^3.0.0: version "3.0.1" resolved "https://registry.yarnpkg.com/acorn-jsx/-/acorn-jsx-3.0.1.tgz#afdf9488fb1ecefc8348f6fb22f464e32a58b36b" dependencies: acorn "^3.0.4" acorn@4.0.4: version "4.0.4" resolved "https://registry.yarnpkg.com/acorn/-/acorn-4.0.4.tgz#17a8d6a7a6c4ef538b814ec9abac2779293bf30a" acorn@4.X: version "4.0.11" resolved "https://registry.yarnpkg.com/acorn/-/acorn-4.0.11.tgz#edcda3bd937e7556410d42ed5860f67399c794c0" acorn@^3.0.4: version "3.3.0" resolved "https://registry.yarnpkg.com/acorn/-/acorn-3.3.0.tgz#45e37fb39e8da3f25baee3ff5369e2bb5f22017a" ajv-keywords@^1.0.0: version "1.5.1" resolved "https://registry.yarnpkg.com/ajv-keywords/-/ajv-keywords-1.5.1.tgz#314dd0a4b3368fad3dfcdc54ede6171b886daf3c" ajv@^4.7.0: version "4.11.3" resolved "https://registry.yarnpkg.com/ajv/-/ajv-4.11.3.tgz#ce30bdb90d1254f762c75af915fb3a63e7183d22" dependencies: co "^4.6.0" json-stable-stringify "^1.0.1" align-text@^0.1.1, align-text@^0.1.3: version "0.1.4" resolved "https://registry.yarnpkg.com/align-text/-/align-text-0.1.4.tgz#0cd90a561093f35d0a99256c22b7069433fad117" dependencies: kind-of "^3.0.2" longest "^1.0.1" repeat-string "^1.5.2" amdefine@>=0.0.4: version "1.0.1" resolved "https://registry.yarnpkg.com/amdefine/-/amdefine-1.0.1.tgz#4a5282ac164729e93619bcfd3ad151f817ce91f5" ansi-escapes@^1.1.0: version "1.4.0" resolved "https://registry.yarnpkg.com/ansi-escapes/-/ansi-escapes-1.4.0.tgz#d3a8a83b319aa67793662b13e761c7911422306e" ansi-regex@^2.0.0: version "2.1.1" resolved "https://registry.yarnpkg.com/ansi-regex/-/ansi-regex-2.1.1.tgz#c3b33ab5ee360d86e0e628f0468ae7ef27d654df" ansi-styles@^2.2.1: version "2.2.1" resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-2.2.1.tgz#b432dd3358b634cf75e1e4664368240533c1ddbe" archy@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/archy/-/archy-1.0.0.tgz#f9c8c13757cc1dd7bc379ac77b2c62a5c2868c40" argparse@^1.0.7: version "1.0.9" resolved "https://registry.yarnpkg.com/argparse/-/argparse-1.0.9.tgz#73d83bc263f86e97f8cc4f6bae1b0e90a7d22c86" dependencies: sprintf-js "~1.0.2" arr-diff@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/arr-diff/-/arr-diff-2.0.0.tgz#8f3b827f955a8bd669697e4a4256ac3ceae356cf" dependencies: arr-flatten "^1.0.1" arr-flatten@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/arr-flatten/-/arr-flatten-1.0.1.tgz#e5ffe54d45e19f32f216e91eb99c8ce892bb604b" array-differ@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/array-differ/-/array-differ-1.0.0.tgz#eff52e3758249d33be402b8bb8e564bb2b5d4031" array-union@^1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/array-union/-/array-union-1.0.2.tgz#9a34410e4f4e3da23dea375be5be70f24778ec39" dependencies: array-uniq "^1.0.1" array-uniq@^1.0.1, array-uniq@^1.0.2: version "1.0.3" resolved "https://registry.yarnpkg.com/array-uniq/-/array-uniq-1.0.3.tgz#af6ac877a25cc7f74e058894753858dfdb24fdb6" array-unique@^0.2.1: version "0.2.1" resolved "https://registry.yarnpkg.com/array-unique/-/array-unique-0.2.1.tgz#a1d97ccafcbc2625cc70fadceb36a50c58b01a53" arrify@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/arrify/-/arrify-1.0.1.tgz#898508da2226f380df904728456849c1501a4b0d" assertion-error@^1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/assertion-error/-/assertion-error-1.0.2.tgz#13ca515d86206da0bac66e834dd397d87581094c" async@~0.2.6: version "0.2.10" resolved "https://registry.yarnpkg.com/async/-/async-0.2.10.tgz#b6bbe0b0674b9d719708ca38de8c237cb526c3d1" atob@~1.1.0: version "1.1.3" resolved "https://registry.yarnpkg.com/atob/-/atob-1.1.3.tgz#95f13629b12c3a51a5d215abdce2aa9f32f80773" babel-code-frame@^6.16.0, babel-code-frame@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-code-frame/-/babel-code-frame-6.22.0.tgz#027620bee567a88c32561574e7fd0801d33118e4" dependencies: chalk "^1.1.0" esutils "^2.0.2" js-tokens "^3.0.0" babel-core@6, babel-core@^6.0.2, babel-core@^6.23.0, babel-core@^6.7.7: version "6.23.1" resolved "https://registry.yarnpkg.com/babel-core/-/babel-core-6.23.1.tgz#c143cb621bb2f621710c220c5d579d15b8a442df" dependencies: babel-code-frame "^6.22.0" babel-generator "^6.23.0" babel-helpers "^6.23.0" babel-messages "^6.23.0" babel-register "^6.23.0" babel-runtime "^6.22.0" babel-template "^6.23.0" babel-traverse "^6.23.1" babel-types "^6.23.0" babylon "^6.11.0" convert-source-map "^1.1.0" debug "^2.1.1" json5 "^0.5.0" lodash "^4.2.0" minimatch "^3.0.2" path-is-absolute "^1.0.0" private "^0.1.6" slash "^1.0.0" source-map "^0.5.0" babel-generator@^6.23.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-generator/-/babel-generator-6.23.0.tgz#6b8edab956ef3116f79d8c84c5a3c05f32a74bc5" dependencies: babel-messages "^6.23.0" babel-runtime "^6.22.0" babel-types "^6.23.0" detect-indent "^4.0.0" jsesc "^1.3.0" lodash "^4.2.0" source-map "^0.5.0" trim-right "^1.0.1" babel-helper-bindify-decorators@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-helper-bindify-decorators/-/babel-helper-bindify-decorators-6.22.0.tgz#d7f5bc261275941ac62acfc4e20dacfb8a3fe952" dependencies: babel-runtime "^6.22.0" babel-traverse "^6.22.0" babel-types "^6.22.0" babel-helper-builder-binary-assignment-operator-visitor@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-helper-builder-binary-assignment-operator-visitor/-/babel-helper-builder-binary-assignment-operator-visitor-6.22.0.tgz#29df56be144d81bdeac08262bfa41d2c5e91cdcd" dependencies: babel-helper-explode-assignable-expression "^6.22.0" babel-runtime "^6.22.0" babel-types "^6.22.0" babel-helper-builder-react-jsx@^6.23.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-helper-builder-react-jsx/-/babel-helper-builder-react-jsx-6.23.0.tgz#d53fc8c996e0bc56d0de0fc4cc55a7138395ea4b" dependencies: babel-runtime "^6.22.0" babel-types "^6.23.0" esutils "^2.0.0" lodash "^4.2.0" babel-helper-call-delegate@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-helper-call-delegate/-/babel-helper-call-delegate-6.22.0.tgz#119921b56120f17e9dae3f74b4f5cc7bcc1b37ef" dependencies: babel-helper-hoist-variables "^6.22.0" babel-runtime "^6.22.0" babel-traverse "^6.22.0" babel-types "^6.22.0" babel-helper-define-map@^6.23.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-helper-define-map/-/babel-helper-define-map-6.23.0.tgz#1444f960c9691d69a2ced6a205315f8fd00804e7" dependencies: babel-helper-function-name "^6.23.0" babel-runtime "^6.22.0" babel-types "^6.23.0" lodash "^4.2.0" babel-helper-explode-assignable-expression@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-helper-explode-assignable-expression/-/babel-helper-explode-assignable-expression-6.22.0.tgz#c97bf76eed3e0bae4048121f2b9dae1a4e7d0478" dependencies: babel-runtime "^6.22.0" babel-traverse "^6.22.0" babel-types "^6.22.0" babel-helper-explode-class@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-helper-explode-class/-/babel-helper-explode-class-6.22.0.tgz#646304924aa6388a516843ba7f1855ef8dfeb69b" dependencies: babel-helper-bindify-decorators "^6.22.0" babel-runtime "^6.22.0" babel-traverse "^6.22.0" babel-types "^6.22.0" babel-helper-function-name@^6.22.0, babel-helper-function-name@^6.23.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-helper-function-name/-/babel-helper-function-name-6.23.0.tgz#25742d67175c8903dbe4b6cb9d9e1fcb8dcf23a6" dependencies: babel-helper-get-function-arity "^6.22.0" babel-runtime "^6.22.0" babel-template "^6.23.0" babel-traverse "^6.23.0" babel-types "^6.23.0" babel-helper-get-function-arity@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-helper-get-function-arity/-/babel-helper-get-function-arity-6.22.0.tgz#0beb464ad69dc7347410ac6ade9f03a50634f5ce" dependencies: babel-runtime "^6.22.0" babel-types "^6.22.0" babel-helper-hoist-variables@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-helper-hoist-variables/-/babel-helper-hoist-variables-6.22.0.tgz#3eacbf731d80705845dd2e9718f600cfb9b4ba72" dependencies: babel-runtime "^6.22.0" babel-types "^6.22.0" babel-helper-optimise-call-expression@^6.23.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-helper-optimise-call-expression/-/babel-helper-optimise-call-expression-6.23.0.tgz#f3ee7eed355b4282138b33d02b78369e470622f5" dependencies: babel-runtime "^6.22.0" babel-types "^6.23.0" babel-helper-regex@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-helper-regex/-/babel-helper-regex-6.22.0.tgz#79f532be1647b1f0ee3474b5f5c3da58001d247d" dependencies: babel-runtime "^6.22.0" babel-types "^6.22.0" lodash "^4.2.0" babel-helper-remap-async-to-generator@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-helper-remap-async-to-generator/-/babel-helper-remap-async-to-generator-6.22.0.tgz#2186ae73278ed03b8b15ced089609da981053383" dependencies: babel-helper-function-name "^6.22.0" babel-runtime "^6.22.0" babel-template "^6.22.0" babel-traverse "^6.22.0" babel-types "^6.22.0" babel-helper-replace-supers@^6.22.0, babel-helper-replace-supers@^6.23.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-helper-replace-supers/-/babel-helper-replace-supers-6.23.0.tgz#eeaf8ad9b58ec4337ca94223bacdca1f8d9b4bfd" dependencies: babel-helper-optimise-call-expression "^6.23.0" babel-messages "^6.23.0" babel-runtime "^6.22.0" babel-template "^6.23.0" babel-traverse "^6.23.0" babel-types "^6.23.0" babel-helpers@^6.23.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-helpers/-/babel-helpers-6.23.0.tgz#4f8f2e092d0b6a8808a4bde79c27f1e2ecf0d992" dependencies: babel-runtime "^6.22.0" babel-template "^6.23.0" babel-messages@^6.23.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-messages/-/babel-messages-6.23.0.tgz#f3cdf4703858035b2a2951c6ec5edf6c62f2630e" dependencies: babel-runtime "^6.22.0" babel-plugin-check-es2015-constants@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-check-es2015-constants/-/babel-plugin-check-es2015-constants-6.22.0.tgz#35157b101426fd2ffd3da3f75c7d1e91835bbf8a" dependencies: babel-runtime "^6.22.0" babel-plugin-external-helpers@^6.4.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-external-helpers/-/babel-plugin-external-helpers-6.22.0.tgz#2285f48b02bd5dede85175caf8c62e86adccefa1" dependencies: babel-runtime "^6.22.0" babel-plugin-syntax-async-functions@^6.8.0: version "6.13.0" resolved "https://registry.yarnpkg.com/babel-plugin-syntax-async-functions/-/babel-plugin-syntax-async-functions-6.13.0.tgz#cad9cad1191b5ad634bf30ae0872391e0647be95" babel-plugin-syntax-async-generators@^6.5.0: version "6.13.0" resolved "https://registry.yarnpkg.com/babel-plugin-syntax-async-generators/-/babel-plugin-syntax-async-generators-6.13.0.tgz#6bc963ebb16eccbae6b92b596eb7f35c342a8b9a" babel-plugin-syntax-class-constructor-call@^6.18.0: version "6.18.0" resolved "https://registry.yarnpkg.com/babel-plugin-syntax-class-constructor-call/-/babel-plugin-syntax-class-constructor-call-6.18.0.tgz#9cb9d39fe43c8600bec8146456ddcbd4e1a76416" babel-plugin-syntax-class-properties@^6.8.0: version "6.13.0" resolved "https://registry.yarnpkg.com/babel-plugin-syntax-class-properties/-/babel-plugin-syntax-class-properties-6.13.0.tgz#d7eb23b79a317f8543962c505b827c7d6cac27de" babel-plugin-syntax-decorators@^6.13.0: version "6.13.0" resolved "https://registry.yarnpkg.com/babel-plugin-syntax-decorators/-/babel-plugin-syntax-decorators-6.13.0.tgz#312563b4dbde3cc806cee3e416cceeaddd11ac0b" babel-plugin-syntax-do-expressions@^6.8.0: version "6.13.0" resolved "https://registry.yarnpkg.com/babel-plugin-syntax-do-expressions/-/babel-plugin-syntax-do-expressions-6.13.0.tgz#5747756139aa26d390d09410b03744ba07e4796d" babel-plugin-syntax-dynamic-import@^6.18.0: version "6.18.0" resolved "https://registry.yarnpkg.com/babel-plugin-syntax-dynamic-import/-/babel-plugin-syntax-dynamic-import-6.18.0.tgz#8d6a26229c83745a9982a441051572caa179b1da" babel-plugin-syntax-exponentiation-operator@^6.8.0: version "6.13.0" resolved "https://registry.yarnpkg.com/babel-plugin-syntax-exponentiation-operator/-/babel-plugin-syntax-exponentiation-operator-6.13.0.tgz#9ee7e8337290da95288201a6a57f4170317830de" babel-plugin-syntax-export-extensions@^6.8.0: version "6.13.0" resolved "https://registry.yarnpkg.com/babel-plugin-syntax-export-extensions/-/babel-plugin-syntax-export-extensions-6.13.0.tgz#70a1484f0f9089a4e84ad44bac353c95b9b12721" babel-plugin-syntax-flow@^6.18.0: version "6.18.0" resolved "https://registry.yarnpkg.com/babel-plugin-syntax-flow/-/babel-plugin-syntax-flow-6.18.0.tgz#4c3ab20a2af26aa20cd25995c398c4eb70310c8d" babel-plugin-syntax-function-bind@^6.8.0: version "6.13.0" resolved "https://registry.yarnpkg.com/babel-plugin-syntax-function-bind/-/babel-plugin-syntax-function-bind-6.13.0.tgz#48c495f177bdf31a981e732f55adc0bdd2601f46" babel-plugin-syntax-jsx@^6.3.13, babel-plugin-syntax-jsx@^6.8.0: version "6.18.0" resolved "https://registry.yarnpkg.com/babel-plugin-syntax-jsx/-/babel-plugin-syntax-jsx-6.18.0.tgz#0af32a9a6e13ca7a3fd5069e62d7b0f58d0d8946" babel-plugin-syntax-object-rest-spread@^6.8.0: version "6.13.0" resolved "https://registry.yarnpkg.com/babel-plugin-syntax-object-rest-spread/-/babel-plugin-syntax-object-rest-spread-6.13.0.tgz#fd6536f2bce13836ffa3a5458c4903a597bb3bf5" babel-plugin-syntax-trailing-function-commas@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-syntax-trailing-function-commas/-/babel-plugin-syntax-trailing-function-commas-6.22.0.tgz#ba0360937f8d06e40180a43fe0d5616fff532cf3" babel-plugin-transform-async-generator-functions@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-async-generator-functions/-/babel-plugin-transform-async-generator-functions-6.22.0.tgz#a720a98153a7596f204099cd5409f4b3c05bab46" dependencies: babel-helper-remap-async-to-generator "^6.22.0" babel-plugin-syntax-async-generators "^6.5.0" babel-runtime "^6.22.0" babel-plugin-transform-async-to-generator@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-async-to-generator/-/babel-plugin-transform-async-to-generator-6.22.0.tgz#194b6938ec195ad36efc4c33a971acf00d8cd35e" dependencies: babel-helper-remap-async-to-generator "^6.22.0" babel-plugin-syntax-async-functions "^6.8.0" babel-runtime "^6.22.0" babel-plugin-transform-class-constructor-call@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-class-constructor-call/-/babel-plugin-transform-class-constructor-call-6.22.0.tgz#11a4d2216abb5b0eef298b493748f4f2f4869120" dependencies: babel-plugin-syntax-class-constructor-call "^6.18.0" babel-runtime "^6.22.0" babel-template "^6.22.0" babel-plugin-transform-class-properties@^6.22.0, babel-plugin-transform-class-properties@^6.9.1: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-class-properties/-/babel-plugin-transform-class-properties-6.23.0.tgz#187b747ee404399013563c993db038f34754ac3b" dependencies: babel-helper-function-name "^6.23.0" babel-plugin-syntax-class-properties "^6.8.0" babel-runtime "^6.22.0" babel-template "^6.23.0" babel-plugin-transform-decorators@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-decorators/-/babel-plugin-transform-decorators-6.22.0.tgz#c03635b27a23b23b7224f49232c237a73988d27c" dependencies: babel-helper-explode-class "^6.22.0" babel-plugin-syntax-decorators "^6.13.0" babel-runtime "^6.22.0" babel-template "^6.22.0" babel-types "^6.22.0" babel-plugin-transform-do-expressions@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-do-expressions/-/babel-plugin-transform-do-expressions-6.22.0.tgz#28ccaf92812d949c2cd1281f690c8fdc468ae9bb" dependencies: babel-plugin-syntax-do-expressions "^6.8.0" babel-runtime "^6.22.0" babel-plugin-transform-es2015-arrow-functions@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-arrow-functions/-/babel-plugin-transform-es2015-arrow-functions-6.22.0.tgz#452692cb711d5f79dc7f85e440ce41b9f244d221" dependencies: babel-runtime "^6.22.0" babel-plugin-transform-es2015-block-scoped-functions@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-block-scoped-functions/-/babel-plugin-transform-es2015-block-scoped-functions-6.22.0.tgz#bbc51b49f964d70cb8d8e0b94e820246ce3a6141" dependencies: babel-runtime "^6.22.0" babel-plugin-transform-es2015-block-scoping@^6.22.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-block-scoping/-/babel-plugin-transform-es2015-block-scoping-6.23.0.tgz#e48895cf0b375be148cd7c8879b422707a053b51" dependencies: babel-runtime "^6.22.0" babel-template "^6.23.0" babel-traverse "^6.23.0" babel-types "^6.23.0" lodash "^4.2.0" babel-plugin-transform-es2015-classes@^6.22.0, babel-plugin-transform-es2015-classes@^6.9.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-classes/-/babel-plugin-transform-es2015-classes-6.23.0.tgz#49b53f326202a2fd1b3bbaa5e2edd8a4f78643c1" dependencies: babel-helper-define-map "^6.23.0" babel-helper-function-name "^6.23.0" babel-helper-optimise-call-expression "^6.23.0" babel-helper-replace-supers "^6.23.0" babel-messages "^6.23.0" babel-runtime "^6.22.0" babel-template "^6.23.0" babel-traverse "^6.23.0" babel-types "^6.23.0" babel-plugin-transform-es2015-computed-properties@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-computed-properties/-/babel-plugin-transform-es2015-computed-properties-6.22.0.tgz#7c383e9629bba4820c11b0425bdd6290f7f057e7" dependencies: babel-runtime "^6.22.0" babel-template "^6.22.0" babel-plugin-transform-es2015-destructuring@^6.22.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-destructuring/-/babel-plugin-transform-es2015-destructuring-6.23.0.tgz#997bb1f1ab967f682d2b0876fe358d60e765c56d" dependencies: babel-runtime "^6.22.0" babel-plugin-transform-es2015-duplicate-keys@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-duplicate-keys/-/babel-plugin-transform-es2015-duplicate-keys-6.22.0.tgz#672397031c21610d72dd2bbb0ba9fb6277e1c36b" dependencies: babel-runtime "^6.22.0" babel-types "^6.22.0" babel-plugin-transform-es2015-for-of@^6.22.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-for-of/-/babel-plugin-transform-es2015-for-of-6.23.0.tgz#f47c95b2b613df1d3ecc2fdb7573623c75248691" dependencies: babel-runtime "^6.22.0" babel-plugin-transform-es2015-function-name@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-function-name/-/babel-plugin-transform-es2015-function-name-6.22.0.tgz#f5fcc8b09093f9a23c76ac3d9e392c3ec4b77104" dependencies: babel-helper-function-name "^6.22.0" babel-runtime "^6.22.0" babel-types "^6.22.0" babel-plugin-transform-es2015-literals@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-literals/-/babel-plugin-transform-es2015-literals-6.22.0.tgz#4f54a02d6cd66cf915280019a31d31925377ca2e" dependencies: babel-runtime "^6.22.0" babel-plugin-transform-es2015-modules-amd@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-modules-amd/-/babel-plugin-transform-es2015-modules-amd-6.22.0.tgz#bf69cd34889a41c33d90dfb740e0091ccff52f21" dependencies: babel-plugin-transform-es2015-modules-commonjs "^6.22.0" babel-runtime "^6.22.0" babel-template "^6.22.0" babel-plugin-transform-es2015-modules-commonjs@^6.22.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-modules-commonjs/-/babel-plugin-transform-es2015-modules-commonjs-6.23.0.tgz#cba7aa6379fb7ec99250e6d46de2973aaffa7b92" dependencies: babel-plugin-transform-strict-mode "^6.22.0" babel-runtime "^6.22.0" babel-template "^6.23.0" babel-types "^6.23.0" babel-plugin-transform-es2015-modules-systemjs@^6.22.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-modules-systemjs/-/babel-plugin-transform-es2015-modules-systemjs-6.23.0.tgz#ae3469227ffac39b0310d90fec73bfdc4f6317b0" dependencies: babel-helper-hoist-variables "^6.22.0" babel-runtime "^6.22.0" babel-template "^6.23.0" babel-plugin-transform-es2015-modules-umd@^6.22.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-modules-umd/-/babel-plugin-transform-es2015-modules-umd-6.23.0.tgz#8d284ae2e19ed8fe21d2b1b26d6e7e0fcd94f0f1" dependencies: babel-plugin-transform-es2015-modules-amd "^6.22.0" babel-runtime "^6.22.0" babel-template "^6.23.0" babel-plugin-transform-es2015-object-super@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-object-super/-/babel-plugin-transform-es2015-object-super-6.22.0.tgz#daa60e114a042ea769dd53fe528fc82311eb98fc" dependencies: babel-helper-replace-supers "^6.22.0" babel-runtime "^6.22.0" babel-plugin-transform-es2015-parameters@^6.22.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-parameters/-/babel-plugin-transform-es2015-parameters-6.23.0.tgz#3a2aabb70c8af945d5ce386f1a4250625a83ae3b" dependencies: babel-helper-call-delegate "^6.22.0" babel-helper-get-function-arity "^6.22.0" babel-runtime "^6.22.0" babel-template "^6.23.0" babel-traverse "^6.23.0" babel-types "^6.23.0" babel-plugin-transform-es2015-shorthand-properties@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-shorthand-properties/-/babel-plugin-transform-es2015-shorthand-properties-6.22.0.tgz#8ba776e0affaa60bff21e921403b8a652a2ff723" dependencies: babel-runtime "^6.22.0" babel-types "^6.22.0" babel-plugin-transform-es2015-spread@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-spread/-/babel-plugin-transform-es2015-spread-6.22.0.tgz#d6d68a99f89aedc4536c81a542e8dd9f1746f8d1" dependencies: babel-runtime "^6.22.0" babel-plugin-transform-es2015-sticky-regex@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-sticky-regex/-/babel-plugin-transform-es2015-sticky-regex-6.22.0.tgz#ab316829e866ee3f4b9eb96939757d19a5bc4593" dependencies: babel-helper-regex "^6.22.0" babel-runtime "^6.22.0" babel-types "^6.22.0" babel-plugin-transform-es2015-template-literals@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-template-literals/-/babel-plugin-transform-es2015-template-literals-6.22.0.tgz#a84b3450f7e9f8f1f6839d6d687da84bb1236d8d" dependencies: babel-runtime "^6.22.0" babel-plugin-transform-es2015-typeof-symbol@^6.22.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-typeof-symbol/-/babel-plugin-transform-es2015-typeof-symbol-6.23.0.tgz#dec09f1cddff94b52ac73d505c84df59dcceb372" dependencies: babel-runtime "^6.22.0" babel-plugin-transform-es2015-unicode-regex@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-es2015-unicode-regex/-/babel-plugin-transform-es2015-unicode-regex-6.22.0.tgz#8d9cc27e7ee1decfe65454fb986452a04a613d20" dependencies: babel-helper-regex "^6.22.0" babel-runtime "^6.22.0" regexpu-core "^2.0.0" babel-plugin-transform-exponentiation-operator@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-exponentiation-operator/-/babel-plugin-transform-exponentiation-operator-6.22.0.tgz#d57c8335281918e54ef053118ce6eb108468084d" dependencies: babel-helper-builder-binary-assignment-operator-visitor "^6.22.0" babel-plugin-syntax-exponentiation-operator "^6.8.0" babel-runtime "^6.22.0" babel-plugin-transform-export-extensions@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-export-extensions/-/babel-plugin-transform-export-extensions-6.22.0.tgz#53738b47e75e8218589eea946cbbd39109bbe653" dependencies: babel-plugin-syntax-export-extensions "^6.8.0" babel-runtime "^6.22.0" babel-plugin-transform-flow-strip-types@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-flow-strip-types/-/babel-plugin-transform-flow-strip-types-6.22.0.tgz#84cb672935d43714fdc32bce84568d87441cf7cf" dependencies: babel-plugin-syntax-flow "^6.18.0" babel-runtime "^6.22.0" babel-plugin-transform-function-bind@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-function-bind/-/babel-plugin-transform-function-bind-6.22.0.tgz#c6fb8e96ac296a310b8cf8ea401462407ddf6a97" dependencies: babel-plugin-syntax-function-bind "^6.8.0" babel-runtime "^6.22.0" babel-plugin-transform-object-rest-spread@^6.22.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-object-rest-spread/-/babel-plugin-transform-object-rest-spread-6.23.0.tgz#875d6bc9be761c58a2ae3feee5dc4895d8c7f921" dependencies: babel-plugin-syntax-object-rest-spread "^6.8.0" babel-runtime "^6.22.0" babel-plugin-transform-react-display-name@^6.23.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-react-display-name/-/babel-plugin-transform-react-display-name-6.23.0.tgz#4398910c358441dc4cef18787264d0412ed36b37" dependencies: babel-runtime "^6.22.0" babel-plugin-transform-react-jsx-self@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-react-jsx-self/-/babel-plugin-transform-react-jsx-self-6.22.0.tgz#df6d80a9da2612a121e6ddd7558bcbecf06e636e" dependencies: babel-plugin-syntax-jsx "^6.8.0" babel-runtime "^6.22.0" babel-plugin-transform-react-jsx-source@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-react-jsx-source/-/babel-plugin-transform-react-jsx-source-6.22.0.tgz#66ac12153f5cd2d17b3c19268f4bf0197f44ecd6" dependencies: babel-plugin-syntax-jsx "^6.8.0" babel-runtime "^6.22.0" babel-plugin-transform-react-jsx@^6.23.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-react-jsx/-/babel-plugin-transform-react-jsx-6.23.0.tgz#23e892f7f2e759678eb5e4446a8f8e94e81b3470" dependencies: babel-helper-builder-react-jsx "^6.23.0" babel-plugin-syntax-jsx "^6.8.0" babel-runtime "^6.22.0" babel-plugin-transform-regenerator@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-regenerator/-/babel-plugin-transform-regenerator-6.22.0.tgz#65740593a319c44522157538d690b84094617ea6" dependencies: regenerator-transform "0.9.8" babel-plugin-transform-strict-mode@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-plugin-transform-strict-mode/-/babel-plugin-transform-strict-mode-6.22.0.tgz#e008df01340fdc87e959da65991b7e05970c8c7c" dependencies: babel-runtime "^6.22.0" babel-types "^6.22.0" babel-preset-es2015-rollup@^1.1.1: version "1.2.0" resolved "https://registry.yarnpkg.com/babel-preset-es2015-rollup/-/babel-preset-es2015-rollup-1.2.0.tgz#feedf80346e01fa22d4de15e72cde1cefc59bf67" dependencies: babel-plugin-external-helpers "^6.4.0" babel-preset-es2015 "^6.3.13" modify-babel-preset "^2.1.1" babel-preset-es2015@^6.3.13, babel-preset-es2015@^6.6.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-preset-es2015/-/babel-preset-es2015-6.22.0.tgz#af5a98ecb35eb8af764ad8a5a05eb36dc4386835" dependencies: babel-plugin-check-es2015-constants "^6.22.0" babel-plugin-transform-es2015-arrow-functions "^6.22.0" babel-plugin-transform-es2015-block-scoped-functions "^6.22.0" babel-plugin-transform-es2015-block-scoping "^6.22.0" babel-plugin-transform-es2015-classes "^6.22.0" babel-plugin-transform-es2015-computed-properties "^6.22.0" babel-plugin-transform-es2015-destructuring "^6.22.0" babel-plugin-transform-es2015-duplicate-keys "^6.22.0" babel-plugin-transform-es2015-for-of "^6.22.0" babel-plugin-transform-es2015-function-name "^6.22.0" babel-plugin-transform-es2015-literals "^6.22.0" babel-plugin-transform-es2015-modules-amd "^6.22.0" babel-plugin-transform-es2015-modules-commonjs "^6.22.0" babel-plugin-transform-es2015-modules-systemjs "^6.22.0" babel-plugin-transform-es2015-modules-umd "^6.22.0" babel-plugin-transform-es2015-object-super "^6.22.0" babel-plugin-transform-es2015-parameters "^6.22.0" babel-plugin-transform-es2015-shorthand-properties "^6.22.0" babel-plugin-transform-es2015-spread "^6.22.0" babel-plugin-transform-es2015-sticky-regex "^6.22.0" babel-plugin-transform-es2015-template-literals "^6.22.0" babel-plugin-transform-es2015-typeof-symbol "^6.22.0" babel-plugin-transform-es2015-unicode-regex "^6.22.0" babel-plugin-transform-regenerator "^6.22.0" babel-preset-flow@^6.23.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-preset-flow/-/babel-preset-flow-6.23.0.tgz#e71218887085ae9a24b5be4169affb599816c49d" dependencies: babel-plugin-transform-flow-strip-types "^6.22.0" babel-preset-react@^6.5.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-preset-react/-/babel-preset-react-6.23.0.tgz#eb7cee4de98a3f94502c28565332da9819455195" dependencies: babel-plugin-syntax-jsx "^6.3.13" babel-plugin-transform-react-display-name "^6.23.0" babel-plugin-transform-react-jsx "^6.23.0" babel-plugin-transform-react-jsx-self "^6.22.0" babel-plugin-transform-react-jsx-source "^6.22.0" babel-preset-flow "^6.23.0" babel-preset-stage-0@^6.5.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-preset-stage-0/-/babel-preset-stage-0-6.22.0.tgz#707eeb5b415da769eff9c42f4547f644f9296ef9" dependencies: babel-plugin-transform-do-expressions "^6.22.0" babel-plugin-transform-function-bind "^6.22.0" babel-preset-stage-1 "^6.22.0" babel-preset-stage-1@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-preset-stage-1/-/babel-preset-stage-1-6.22.0.tgz#7da05bffea6ad5a10aef93e320cfc6dd465dbc1a" dependencies: babel-plugin-transform-class-constructor-call "^6.22.0" babel-plugin-transform-export-extensions "^6.22.0" babel-preset-stage-2 "^6.22.0" babel-preset-stage-2@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-preset-stage-2/-/babel-preset-stage-2-6.22.0.tgz#ccd565f19c245cade394b21216df704a73b27c07" dependencies: babel-plugin-syntax-dynamic-import "^6.18.0" babel-plugin-transform-class-properties "^6.22.0" babel-plugin-transform-decorators "^6.22.0" babel-preset-stage-3 "^6.22.0" babel-preset-stage-3@^6.22.0: version "6.22.0" resolved "https://registry.yarnpkg.com/babel-preset-stage-3/-/babel-preset-stage-3-6.22.0.tgz#a4e92bbace7456fafdf651d7a7657ee0bbca9c2e" dependencies: babel-plugin-syntax-trailing-function-commas "^6.22.0" babel-plugin-transform-async-generator-functions "^6.22.0" babel-plugin-transform-async-to-generator "^6.22.0" babel-plugin-transform-exponentiation-operator "^6.22.0" babel-plugin-transform-object-rest-spread "^6.22.0" babel-register@^6.23.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-register/-/babel-register-6.23.0.tgz#c9aa3d4cca94b51da34826c4a0f9e08145d74ff3" dependencies: babel-core "^6.23.0" babel-runtime "^6.22.0" core-js "^2.4.0" home-or-tmp "^2.0.0" lodash "^4.2.0" mkdirp "^0.5.1" source-map-support "^0.4.2" babel-runtime@^6.18.0, babel-runtime@^6.22.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-runtime/-/babel-runtime-6.23.0.tgz#0a9489f144de70efb3ce4300accdb329e2fc543b" dependencies: core-js "^2.4.0" regenerator-runtime "^0.10.0" babel-template@^6.22.0, babel-template@^6.23.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-template/-/babel-template-6.23.0.tgz#04d4f270adbb3aa704a8143ae26faa529238e638" dependencies: babel-runtime "^6.22.0" babel-traverse "^6.23.0" babel-types "^6.23.0" babylon "^6.11.0" lodash "^4.2.0" babel-traverse@^6.22.0, babel-traverse@^6.23.0, babel-traverse@^6.23.1: version "6.23.1" resolved "https://registry.yarnpkg.com/babel-traverse/-/babel-traverse-6.23.1.tgz#d3cb59010ecd06a97d81310065f966b699e14f48" dependencies: babel-code-frame "^6.22.0" babel-messages "^6.23.0" babel-runtime "^6.22.0" babel-types "^6.23.0" babylon "^6.15.0" debug "^2.2.0" globals "^9.0.0" invariant "^2.2.0" lodash "^4.2.0" babel-types@^6.19.0, babel-types@^6.22.0, babel-types@^6.23.0: version "6.23.0" resolved "https://registry.yarnpkg.com/babel-types/-/babel-types-6.23.0.tgz#bb17179d7538bad38cd0c9e115d340f77e7e9acf" dependencies: babel-runtime "^6.22.0" esutils "^2.0.2" lodash "^4.2.0" to-fast-properties "^1.0.1" babel@^6.5.2: version "6.23.0" resolved "https://registry.yarnpkg.com/babel/-/babel-6.23.0.tgz#d0d1e7d803e974765beea3232d4e153c0efb90f4" babylon@^6.11.0, babylon@^6.15.0: version "6.16.1" resolved "https://registry.yarnpkg.com/babylon/-/babylon-6.16.1.tgz#30c5a22f481978a9e7f8cdfdf496b11d94b404d3" balanced-match@^0.4.1: version "0.4.2" resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-0.4.2.tgz#cb3f3e3c732dc0f01ee70b403f302e61d7709838" beeper@^1.0.0: version "1.1.1" resolved "https://registry.yarnpkg.com/beeper/-/beeper-1.1.1.tgz#e6d5ea8c5dad001304a70b22638447f69cb2f809" brace-expansion@^1.0.0: version "1.1.6" resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.6.tgz#7197d7eaa9b87e648390ea61fc66c84427420df9" dependencies: balanced-match "^0.4.1" concat-map "0.0.1" braces@^1.8.2: version "1.8.5" resolved "https://registry.yarnpkg.com/braces/-/braces-1.8.5.tgz#ba77962e12dff969d6b76711e914b737857bf6a7" dependencies: expand-range "^1.8.1" preserve "^0.2.0" repeat-element "^1.1.2" browser-resolve@^1.11.0: version "1.11.2" resolved "https://registry.yarnpkg.com/browser-resolve/-/browser-resolve-1.11.2.tgz#8ff09b0a2c421718a1051c260b32e48f442938ce" dependencies: resolve "1.1.7" buffer-shims@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/buffer-shims/-/buffer-shims-1.0.0.tgz#9978ce317388c649ad8793028c3477ef044a8b51" builtin-modules@^1.1.0, builtin-modules@^1.1.1: version "1.1.1" resolved "https://registry.yarnpkg.com/builtin-modules/-/builtin-modules-1.1.1.tgz#270f076c5a72c02f5b65a47df94c5fe3a278892f" caller-path@^0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/caller-path/-/caller-path-0.1.0.tgz#94085ef63581ecd3daa92444a8fe94e82577751f" dependencies: callsites "^0.2.0" callsites@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/callsites/-/callsites-0.2.0.tgz#afab96262910a7f33c19a5775825c69f34e350ca" camelcase@^1.0.2: version "1.2.1" resolved "https://registry.yarnpkg.com/camelcase/-/camelcase-1.2.1.tgz#9bb5304d2e0b56698b2c758b08a3eaa9daa58a39" center-align@^0.1.1: version "0.1.3" resolved "https://registry.yarnpkg.com/center-align/-/center-align-0.1.3.tgz#aa0d32629b6ee972200411cbd4461c907bc2b7ad" dependencies: align-text "^0.1.3" lazy-cache "^1.0.3" chai@^3.5.0: version "3.5.0" resolved "https://registry.yarnpkg.com/chai/-/chai-3.5.0.tgz#4d02637b067fe958bdbfdd3a40ec56fef7373247" dependencies: assertion-error "^1.0.1" deep-eql "^0.1.3" type-detect "^1.0.0" chalk@^1.0.0, chalk@^1.1.0, chalk@^1.1.1, chalk@^1.1.3: version "1.1.3" resolved "https://registry.yarnpkg.com/chalk/-/chalk-1.1.3.tgz#a8115c55e4a702fe4d150abd3872822a7e09fc98" dependencies: ansi-styles "^2.2.1" escape-string-regexp "^1.0.2" has-ansi "^2.0.0" strip-ansi "^3.0.0" supports-color "^2.0.0" circular-json@^0.3.1: version "0.3.1" resolved "https://registry.yarnpkg.com/circular-json/-/circular-json-0.3.1.tgz#be8b36aefccde8b3ca7aa2d6afc07a37242c0d2d" cli-cursor@^1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/cli-cursor/-/cli-cursor-1.0.2.tgz#64da3f7d56a54412e59794bd62dc35295e8f2987" dependencies: restore-cursor "^1.0.1" cli-width@^2.0.0: version "2.1.0" resolved "https://registry.yarnpkg.com/cli-width/-/cli-width-2.1.0.tgz#b234ca209b29ef66fc518d9b98d5847b00edf00a" cliui@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/cliui/-/cliui-2.1.0.tgz#4b475760ff80264c762c3a1719032e91c7fea0d1" dependencies: center-align "^0.1.1" right-align "^0.1.1" wordwrap "0.0.2" clone-stats@^0.0.1: version "0.0.1" resolved "https://registry.yarnpkg.com/clone-stats/-/clone-stats-0.0.1.tgz#b88f94a82cf38b8791d58046ea4029ad88ca99d1" clone@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/clone/-/clone-0.2.0.tgz#c6126a90ad4f72dbf5acdb243cc37724fe93fc1f" clone@^1.0.0, clone@^1.0.2: version "1.0.2" resolved "https://registry.yarnpkg.com/clone/-/clone-1.0.2.tgz#260b7a99ebb1edfe247538175f783243cb19d149" co@^4.6.0: version "4.6.0" resolved "https://registry.yarnpkg.com/co/-/co-4.6.0.tgz#6ea6bdf3d853ae54ccb8e47bfa0bf3f9031fb184" code-point-at@^1.0.0: version "1.1.0" resolved "https://registry.yarnpkg.com/code-point-at/-/code-point-at-1.1.0.tgz#0d070b4d043a5bea33a2f1a40e2edb3d9a4ccf77" commander@0.6.1: version "0.6.1" resolved "https://registry.yarnpkg.com/commander/-/commander-0.6.1.tgz#fa68a14f6a945d54dbbe50d8cdb3320e9e3b1a06" commander@2.3.0: version "2.3.0" resolved "https://registry.yarnpkg.com/commander/-/commander-2.3.0.tgz#fd430e889832ec353b9acd1de217c11cb3eef873" concat-map@0.0.1: version "0.0.1" resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b" concat-stream@^1.4.6: version "1.6.0" resolved "https://registry.yarnpkg.com/concat-stream/-/concat-stream-1.6.0.tgz#0aac662fd52be78964d5532f694784e70110acf7" dependencies: inherits "^2.0.3" readable-stream "^2.2.2" typedarray "^0.0.6" contains-path@^0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/contains-path/-/contains-path-0.1.0.tgz#fe8cf184ff6670b6baef01a9d4861a5cbec4120a" convert-source-map@1.X, convert-source-map@^1.1.0: version "1.4.0" resolved "https://registry.yarnpkg.com/convert-source-map/-/convert-source-map-1.4.0.tgz#e3dad195bf61bfe13a7a3c73e9876ec14a0268f3" core-js@^2.4.0: version "2.4.1" resolved "https://registry.yarnpkg.com/core-js/-/core-js-2.4.1.tgz#4de911e667b0eae9124e34254b53aea6fc618d3e" core-util-is@~1.0.0: version "1.0.2" resolved "https://registry.yarnpkg.com/core-util-is/-/core-util-is-1.0.2.tgz#b5fd54220aa2bc5ab57aab7140c940754503c1a7" css@2.X: version "2.2.1" resolved "https://registry.yarnpkg.com/css/-/css-2.2.1.tgz#73a4c81de85db664d4ee674f7d47085e3b2d55dc" dependencies: inherits "^2.0.1" source-map "^0.1.38" source-map-resolve "^0.3.0" urix "^0.1.0" d@^0.1.1, d@~0.1.1: version "0.1.1" resolved "https://registry.yarnpkg.com/d/-/d-0.1.1.tgz#da184c535d18d8ee7ba2aa229b914009fae11309" dependencies: es5-ext "~0.10.2" dateformat@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/dateformat/-/dateformat-2.0.0.tgz#2743e3abb5c3fc2462e527dca445e04e9f4dee17" debug-fabulous@0.0.X: version "0.0.4" resolved "https://registry.yarnpkg.com/debug-fabulous/-/debug-fabulous-0.0.4.tgz#fa071c5d87484685424807421ca4b16b0b1a0763" dependencies: debug "2.X" lazy-debug-legacy "0.0.X" object-assign "4.1.0" debug@2.2.0: version "2.2.0" resolved "https://registry.yarnpkg.com/debug/-/debug-2.2.0.tgz#f87057e995b1a1f6ae6a4960664137bc56f039da" dependencies: ms "0.7.1" debug@2.X, debug@^2.1.1, debug@^2.2.0: version "2.6.1" resolved "https://registry.yarnpkg.com/debug/-/debug-2.6.1.tgz#79855090ba2c4e3115cc7d8769491d58f0491351" dependencies: ms "0.7.2" decamelize@^1.0.0: version "1.2.0" resolved "https://registry.yarnpkg.com/decamelize/-/decamelize-1.2.0.tgz#f6534d15148269b20352e7bee26f501f9a191290" deep-eql@^0.1.3: version "0.1.3" resolved "https://registry.yarnpkg.com/deep-eql/-/deep-eql-0.1.3.tgz#ef558acab8de25206cd713906d74e56930eb69f2" dependencies: type-detect "0.1.1" deep-is@~0.1.3: version "0.1.3" resolved "https://registry.yarnpkg.com/deep-is/-/deep-is-0.1.3.tgz#b369d6fb5dbc13eecf524f91b070feedc357cf34" defaults@^1.0.0: version "1.0.3" resolved "https://registry.yarnpkg.com/defaults/-/defaults-1.0.3.tgz#c656051e9817d9ff08ed881477f3fe4019f3ef7d" dependencies: clone "^1.0.2" del@^2.0.2: version "2.2.2" resolved "https://registry.yarnpkg.com/del/-/del-2.2.2.tgz#c12c981d067846c84bcaf862cff930d907ffd1a8" dependencies: globby "^5.0.0" is-path-cwd "^1.0.0" is-path-in-cwd "^1.0.0" object-assign "^4.0.1" pify "^2.0.0" pinkie-promise "^2.0.0" rimraf "^2.2.8" deprecated@^0.0.1: version "0.0.1" resolved "https://registry.yarnpkg.com/deprecated/-/deprecated-0.0.1.tgz#f9c9af5464afa1e7a971458a8bdef2aa94d5bb19" detect-file@^0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/detect-file/-/detect-file-0.1.0.tgz#4935dedfd9488648e006b0129566e9386711ea63" dependencies: fs-exists-sync "^0.1.0" detect-indent@^4.0.0: version "4.0.0" resolved "https://registry.yarnpkg.com/detect-indent/-/detect-indent-4.0.0.tgz#f76d064352cdf43a1cb6ce619c4ee3a9475de208" dependencies: repeating "^2.0.0" detect-newline@2.X: version "2.1.0" resolved "https://registry.yarnpkg.com/detect-newline/-/detect-newline-2.1.0.tgz#f41f1c10be4b00e87b5f13da680759f2c5bfd3e2" diff@1.4.0: version "1.4.0" resolved "https://registry.yarnpkg.com/diff/-/diff-1.4.0.tgz#7f28d2eb9ee7b15a97efd89ce63dcfdaa3ccbabf" doctrine@1.5.0, doctrine@^1.2.2: version "1.5.0" resolved "https://registry.yarnpkg.com/doctrine/-/doctrine-1.5.0.tgz#379dce730f6166f76cefa4e6707a159b02c5a6fa" dependencies: esutils "^2.0.2" isarray "^1.0.0" duplexer2@0.0.2: version "0.0.2" resolved "https://registry.yarnpkg.com/duplexer2/-/duplexer2-0.0.2.tgz#c614dcf67e2fb14995a91711e5a617e8a60a31db" dependencies: readable-stream "~1.1.9" end-of-stream@~0.1.5: version "0.1.5" resolved "https://registry.yarnpkg.com/end-of-stream/-/end-of-stream-0.1.5.tgz#8e177206c3c80837d85632e8b9359dfe8b2f6eaf" dependencies: once "~1.3.0" erlang-types@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/erlang-types/-/erlang-types-1.0.0.tgz#e555bd091667498a01d340d18203231dc96d962f" es5-ext@^0.10.7, es5-ext@^0.10.8, es5-ext@~0.10.11, es5-ext@~0.10.2, es5-ext@~0.10.7: version "0.10.12" resolved "https://registry.yarnpkg.com/es5-ext/-/es5-ext-0.10.12.tgz#aa84641d4db76b62abba5e45fd805ecbab140047" dependencies: es6-iterator "2" es6-symbol "~3.1" es6-iterator@2: version "2.0.0" resolved "https://registry.yarnpkg.com/es6-iterator/-/es6-iterator-2.0.0.tgz#bd968567d61635e33c0b80727613c9cb4b096bac" dependencies: d "^0.1.1" es5-ext "^0.10.7" es6-symbol "3" es6-map@^0.1.3: version "0.1.4" resolved "https://registry.yarnpkg.com/es6-map/-/es6-map-0.1.4.tgz#a34b147be224773a4d7da8072794cefa3632b897" dependencies: d "~0.1.1" es5-ext "~0.10.11" es6-iterator "2" es6-set "~0.1.3" es6-symbol "~3.1.0" event-emitter "~0.3.4" es6-set@~0.1.3: version "0.1.4" resolved "https://registry.yarnpkg.com/es6-set/-/es6-set-0.1.4.tgz#9516b6761c2964b92ff479456233a247dc707ce8" dependencies: d "~0.1.1" es5-ext "~0.10.11" es6-iterator "2" es6-symbol "3" event-emitter "~0.3.4" es6-symbol@3, es6-symbol@~3.1, es6-symbol@~3.1.0: version "3.1.0" resolved "https://registry.yarnpkg.com/es6-symbol/-/es6-symbol-3.1.0.tgz#94481c655e7a7cad82eba832d97d5433496d7ffa" dependencies: d "~0.1.1" es5-ext "~0.10.11" es6-weak-map@^2.0.1: version "2.0.1" resolved "https://registry.yarnpkg.com/es6-weak-map/-/es6-weak-map-2.0.1.tgz#0d2bbd8827eb5fb4ba8f97fbfea50d43db21ea81" dependencies: d "^0.1.1" es5-ext "^0.10.8" es6-iterator "2" es6-symbol "3" escape-string-regexp@1.0.2, escape-string-regexp@^1.0.2: version "1.0.2" resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.2.tgz#4dbc2fe674e71949caf3fb2695ce7f2dc1d9a8d1" escape-string-regexp@^1.0.5: version "1.0.5" resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4" escope@^3.6.0: version "3.6.0" resolved "https://registry.yarnpkg.com/escope/-/escope-3.6.0.tgz#e01975e812781a163a6dadfdd80398dc64c889c3" dependencies: es6-map "^0.1.3" es6-weak-map "^2.0.1" esrecurse "^4.1.0" estraverse "^4.1.1" eslint-config-airbnb-base@^11.1.0: version "11.1.0" resolved "https://registry.yarnpkg.com/eslint-config-airbnb-base/-/eslint-config-airbnb-base-11.1.0.tgz#dc9b3ec70b8c74dcbe6d6257c9da3992c39ca2ca" eslint-import-resolver-node@^0.2.0: version "0.2.3" resolved "https://registry.yarnpkg.com/eslint-import-resolver-node/-/eslint-import-resolver-node-0.2.3.tgz#5add8106e8c928db2cba232bcd9efa846e3da16c" dependencies: debug "^2.2.0" object-assign "^4.0.1" resolve "^1.1.6" eslint-module-utils@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/eslint-module-utils/-/eslint-module-utils-2.0.0.tgz#a6f8c21d901358759cdc35dbac1982ae1ee58bce" dependencies: debug "2.2.0" pkg-dir "^1.0.0" eslint-plugin-import@^2.2.0: version "2.2.0" resolved "https://registry.yarnpkg.com/eslint-plugin-import/-/eslint-plugin-import-2.2.0.tgz#72ba306fad305d67c4816348a4699a4229ac8b4e" dependencies: builtin-modules "^1.1.1" contains-path "^0.1.0" debug "^2.2.0" doctrine "1.5.0" eslint-import-resolver-node "^0.2.0" eslint-module-utils "^2.0.0" has "^1.0.1" lodash.cond "^4.3.0" minimatch "^3.0.3" pkg-up "^1.0.0" eslint@^3.15.0: version "3.16.1" resolved "https://registry.yarnpkg.com/eslint/-/eslint-3.16.1.tgz#9bc31fc7341692cf772e80607508f67d711c5609" dependencies: babel-code-frame "^6.16.0" chalk "^1.1.3" concat-stream "^1.4.6" debug "^2.1.1" doctrine "^1.2.2" escope "^3.6.0" espree "^3.4.0" estraverse "^4.2.0" esutils "^2.0.2" file-entry-cache "^2.0.0" glob "^7.0.3" globals "^9.14.0" ignore "^3.2.0" imurmurhash "^0.1.4" inquirer "^0.12.0" is-my-json-valid "^2.10.0" is-resolvable "^1.0.0" js-yaml "^3.5.1" json-stable-stringify "^1.0.0" levn "^0.3.0" lodash "^4.0.0" mkdirp "^0.5.0" natural-compare "^1.4.0" optionator "^0.8.2" path-is-inside "^1.0.1" pluralize "^1.2.1" progress "^1.1.8" require-uncached "^1.0.2" shelljs "^0.7.5" strip-bom "^3.0.0" strip-json-comments "~2.0.1" table "^3.7.8" text-table "~0.2.0" user-home "^2.0.0" espree@^3.4.0: version "3.4.0" resolved "https://registry.yarnpkg.com/espree/-/espree-3.4.0.tgz#41656fa5628e042878025ef467e78f125cb86e1d" dependencies: acorn "4.0.4" acorn-jsx "^3.0.0" esprima@^3.1.1: version "3.1.3" resolved "https://registry.yarnpkg.com/esprima/-/esprima-3.1.3.tgz#fdca51cee6133895e3c88d535ce49dbff62a4633" esrecurse@^4.1.0: version "4.1.0" resolved "https://registry.yarnpkg.com/esrecurse/-/esrecurse-4.1.0.tgz#4713b6536adf7f2ac4f327d559e7756bff648220" dependencies: estraverse "~4.1.0" object-assign "^4.0.1" estraverse@^4.1.1, estraverse@^4.2.0: version "4.2.0" resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.2.0.tgz#0dee3fed31fcd469618ce7342099fc1afa0bdb13" estraverse@~4.1.0: version "4.1.1" resolved "https://registry.yarnpkg.com/estraverse/-/estraverse-4.1.1.tgz#f6caca728933a850ef90661d0e17982ba47111a2" estree-walker@^0.2.1: version "0.2.1" resolved "https://registry.yarnpkg.com/estree-walker/-/estree-walker-0.2.1.tgz#bdafe8095383d8414d5dc2ecf4c9173b6db9412e" esutils@^2.0.0, esutils@^2.0.2: version "2.0.2" resolved "https://registry.yarnpkg.com/esutils/-/esutils-2.0.2.tgz#0abf4f1caa5bcb1f7a9d8acc6dea4faaa04bac9b" event-emitter@~0.3.4: version "0.3.4" resolved "https://registry.yarnpkg.com/event-emitter/-/event-emitter-0.3.4.tgz#8d63ddfb4cfe1fae3b32ca265c4c720222080bb5" dependencies: d "~0.1.1" es5-ext "~0.10.7" exit-hook@^1.0.0: version "1.1.1" resolved "https://registry.yarnpkg.com/exit-hook/-/exit-hook-1.1.1.tgz#f05ca233b48c05d54fff07765df8507e95c02ff8" expand-brackets@^0.1.4: version "0.1.5" resolved "https://registry.yarnpkg.com/expand-brackets/-/expand-brackets-0.1.5.tgz#df07284e342a807cd733ac5af72411e581d1177b" dependencies: is-posix-bracket "^0.1.0" expand-range@^1.8.1: version "1.8.2" resolved "https://registry.yarnpkg.com/expand-range/-/expand-range-1.8.2.tgz#a299effd335fe2721ebae8e257ec79644fc85337" dependencies: fill-range "^2.1.0" expand-tilde@^1.2.1, expand-tilde@^1.2.2: version "1.2.2" resolved "https://registry.yarnpkg.com/expand-tilde/-/expand-tilde-1.2.2.tgz#0b81eba897e5a3d31d1c3d102f8f01441e559449" dependencies: os-homedir "^1.0.1" extend@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/extend/-/extend-3.0.0.tgz#5a474353b9f3353ddd8176dfd37b91c83a46f1d4" extglob@^0.3.1: version "0.3.2" resolved "https://registry.yarnpkg.com/extglob/-/extglob-0.3.2.tgz#2e18ff3d2f49ab2765cec9023f011daa8d8349a1" dependencies: is-extglob "^1.0.0" fancy-log@^1.1.0: version "1.3.0" resolved "https://registry.yarnpkg.com/fancy-log/-/fancy-log-1.3.0.tgz#45be17d02bb9917d60ccffd4995c999e6c8c9948" dependencies: chalk "^1.1.1" time-stamp "^1.0.0" fast-levenshtein@~2.0.4: version "2.0.6" resolved "https://registry.yarnpkg.com/fast-levenshtein/-/fast-levenshtein-2.0.6.tgz#3d8a5c66883a16a30ca8643e851f19baa7797917" figures@^1.3.5: version "1.7.0" resolved "https://registry.yarnpkg.com/figures/-/figures-1.7.0.tgz#cbe1e3affcf1cd44b80cadfed28dc793a9701d2e" dependencies: escape-string-regexp "^1.0.5" object-assign "^4.1.0" file-entry-cache@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/file-entry-cache/-/file-entry-cache-2.0.0.tgz#c392990c3e684783d838b8c84a45d8a048458361" dependencies: flat-cache "^1.2.1" object-assign "^4.0.1" filename-regex@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/filename-regex/-/filename-regex-2.0.0.tgz#996e3e80479b98b9897f15a8a58b3d084e926775" fill-range@^2.1.0: version "2.2.3" resolved "https://registry.yarnpkg.com/fill-range/-/fill-range-2.2.3.tgz#50b77dfd7e469bc7492470963699fe7a8485a723" dependencies: is-number "^2.1.0" isobject "^2.0.0" randomatic "^1.1.3" repeat-element "^1.1.2" repeat-string "^1.5.2" find-index@^0.1.1: version "0.1.1" resolved "https://registry.yarnpkg.com/find-index/-/find-index-0.1.1.tgz#675d358b2ca3892d795a1ab47232f8b6e2e0dde4" find-up@^1.0.0: version "1.1.2" resolved "https://registry.yarnpkg.com/find-up/-/find-up-1.1.2.tgz#6b2e9822b1a2ce0a60ab64d610eccad53cb24d0f" dependencies: path-exists "^2.0.0" pinkie-promise "^2.0.0" findup-sync@^0.4.2: version "0.4.3" resolved "https://registry.yarnpkg.com/findup-sync/-/findup-sync-0.4.3.tgz#40043929e7bc60adf0b7f4827c4c6e75a0deca12" dependencies: detect-file "^0.1.0" is-glob "^2.0.1" micromatch "^2.3.7" resolve-dir "^0.1.0" fined@^1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/fined/-/fined-1.0.2.tgz#5b28424b760d7598960b7ef8480dff8ad3660e97" dependencies: expand-tilde "^1.2.1" lodash.assignwith "^4.0.7" lodash.isempty "^4.2.1" lodash.isplainobject "^4.0.4" lodash.isstring "^4.0.1" lodash.pick "^4.2.1" parse-filepath "^1.0.1" first-chunk-stream@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/first-chunk-stream/-/first-chunk-stream-1.0.0.tgz#59bfb50cd905f60d7c394cd3d9acaab4e6ad934e" flagged-respawn@^0.3.2: version "0.3.2" resolved "https://registry.yarnpkg.com/flagged-respawn/-/flagged-respawn-0.3.2.tgz#ff191eddcd7088a675b2610fffc976be9b8074b5" flat-cache@^1.2.1: version "1.2.2" resolved "https://registry.yarnpkg.com/flat-cache/-/flat-cache-1.2.2.tgz#fa86714e72c21db88601761ecf2f555d1abc6b96" dependencies: circular-json "^0.3.1" del "^2.0.2" graceful-fs "^4.1.2" write "^0.2.1" for-in@^0.1.5: version "0.1.6" resolved "https://registry.yarnpkg.com/for-in/-/for-in-0.1.6.tgz#c9f96e89bfad18a545af5ec3ed352a1d9e5b4dc8" for-own@^0.1.4: version "0.1.4" resolved "https://registry.yarnpkg.com/for-own/-/for-own-0.1.4.tgz#0149b41a39088c7515f51ebe1c1386d45f935072" dependencies: for-in "^0.1.5" formatio@1.1.1: version "1.1.1" resolved "https://registry.yarnpkg.com/formatio/-/formatio-1.1.1.tgz#5ed3ccd636551097383465d996199100e86161e9" dependencies: samsam "~1.1" fs-exists-sync@^0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/fs-exists-sync/-/fs-exists-sync-0.1.0.tgz#982d6893af918e72d08dec9e8673ff2b5a8d6add" fs.realpath@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f" function-bind@^1.0.2: version "1.1.0" resolved "https://registry.yarnpkg.com/function-bind/-/function-bind-1.1.0.tgz#16176714c801798e4e8f2cf7f7529467bb4a5771" gaze@^0.5.1: version "0.5.2" resolved "https://registry.yarnpkg.com/gaze/-/gaze-0.5.2.tgz#40b709537d24d1d45767db5a908689dfe69ac44f" dependencies: globule "~0.1.0" generate-function@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/generate-function/-/generate-function-2.0.0.tgz#6858fe7c0969b7d4e9093337647ac79f60dfbe74" generate-object-property@^1.1.0: version "1.2.0" resolved "https://registry.yarnpkg.com/generate-object-property/-/generate-object-property-1.2.0.tgz#9c0e1c40308ce804f4783618b937fa88f99d50d0" dependencies: is-property "^1.0.0" glob-base@^0.3.0: version "0.3.0" resolved "https://registry.yarnpkg.com/glob-base/-/glob-base-0.3.0.tgz#dbb164f6221b1c0b1ccf82aea328b497df0ea3c4" dependencies: glob-parent "^2.0.0" is-glob "^2.0.0" glob-parent@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/glob-parent/-/glob-parent-2.0.0.tgz#81383d72db054fcccf5336daa902f182f6edbb28" dependencies: is-glob "^2.0.0" glob-stream@^3.1.5: version "3.1.18" resolved "https://registry.yarnpkg.com/glob-stream/-/glob-stream-3.1.18.tgz#9170a5f12b790306fdfe598f313f8f7954fd143b" dependencies: glob "^4.3.1" glob2base "^0.0.12" minimatch "^2.0.1" ordered-read-streams "^0.1.0" through2 "^0.6.1" unique-stream "^1.0.0" glob-watcher@^0.0.6: version "0.0.6" resolved "https://registry.yarnpkg.com/glob-watcher/-/glob-watcher-0.0.6.tgz#b95b4a8df74b39c83298b0c05c978b4d9a3b710b" dependencies: gaze "^0.5.1" glob2base@^0.0.12: version "0.0.12" resolved "https://registry.yarnpkg.com/glob2base/-/glob2base-0.0.12.tgz#9d419b3e28f12e83a362164a277055922c9c0d56" dependencies: find-index "^0.1.1" glob@3.2.11: version "3.2.11" resolved "https://registry.yarnpkg.com/glob/-/glob-3.2.11.tgz#4a973f635b9190f715d10987d5c00fd2815ebe3d" dependencies: inherits "2" minimatch "0.3" glob@^4.3.1: version "4.5.3" resolved "https://registry.yarnpkg.com/glob/-/glob-4.5.3.tgz#c6cb73d3226c1efef04de3c56d012f03377ee15f" dependencies: inflight "^1.0.4" inherits "2" minimatch "^2.0.1" once "^1.3.0" glob@^7.0.0, glob@^7.0.3, glob@^7.0.5: version "7.1.1" resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.1.tgz#805211df04faaf1c63a3600306cdf5ade50b2ec8" dependencies: fs.realpath "^1.0.0" inflight "^1.0.4" inherits "2" minimatch "^3.0.2" once "^1.3.0" path-is-absolute "^1.0.0" glob@~3.1.21: version "3.1.21" resolved "https://registry.yarnpkg.com/glob/-/glob-3.1.21.tgz#d29e0a055dea5138f4d07ed40e8982e83c2066cd" dependencies: graceful-fs "~1.2.0" inherits "1" minimatch "~0.2.11" global-modules@^0.2.3: version "0.2.3" resolved "https://registry.yarnpkg.com/global-modules/-/global-modules-0.2.3.tgz#ea5a3bed42c6d6ce995a4f8a1269b5dae223828d" dependencies: global-prefix "^0.1.4" is-windows "^0.2.0" global-prefix@^0.1.4: version "0.1.5" resolved "https://registry.yarnpkg.com/global-prefix/-/global-prefix-0.1.5.tgz#8d3bc6b8da3ca8112a160d8d496ff0462bfef78f" dependencies: homedir-polyfill "^1.0.0" ini "^1.3.4" is-windows "^0.2.0" which "^1.2.12" globals@^9.0.0, globals@^9.14.0: version "9.16.0" resolved "https://registry.yarnpkg.com/globals/-/globals-9.16.0.tgz#63e903658171ec2d9f51b1d31de5e2b8dc01fb80" globby@^5.0.0: version "5.0.0" resolved "https://registry.yarnpkg.com/globby/-/globby-5.0.0.tgz#ebd84667ca0dbb330b99bcfc68eac2bc54370e0d" dependencies: array-union "^1.0.1" arrify "^1.0.0" glob "^7.0.3" object-assign "^4.0.1" pify "^2.0.0" pinkie-promise "^2.0.0" globule@~0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/globule/-/globule-0.1.0.tgz#d9c8edde1da79d125a151b79533b978676346ae5" dependencies: glob "~3.1.21" lodash "~1.0.1" minimatch "~0.2.11" glogg@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/glogg/-/glogg-1.0.0.tgz#7fe0f199f57ac906cf512feead8f90ee4a284fc5" dependencies: sparkles "^1.0.0" graceful-fs@4.X, graceful-fs@^4.1.2: version "4.1.11" resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.1.11.tgz#0e8bdfe4d1ddb8854d64e04ea7c00e2a026e5658" graceful-fs@^3.0.0: version "3.0.11" resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-3.0.11.tgz#7613c778a1afea62f25c630a086d7f3acbbdd818" dependencies: natives "^1.1.0" graceful-fs@~1.2.0: version "1.2.3" resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-1.2.3.tgz#15a4806a57547cb2d2dbf27f42e89a8c3451b364" growl@1.9.2: version "1.9.2" resolved "https://registry.yarnpkg.com/growl/-/growl-1.9.2.tgz#0ea7743715db8d8de2c5ede1775e1b45ac85c02f" gulp-babel@^6.1.2: version "6.1.2" resolved "https://registry.yarnpkg.com/gulp-babel/-/gulp-babel-6.1.2.tgz#7c0176e4ba3f244c60588a0c4b320a45d1adefce" dependencies: babel-core "^6.0.2" gulp-util "^3.0.0" object-assign "^4.0.1" replace-ext "0.0.1" through2 "^2.0.0" vinyl-sourcemaps-apply "^0.2.0" gulp-sourcemaps@^2.0.0-alpha: version "2.4.1" resolved "https://registry.yarnpkg.com/gulp-sourcemaps/-/gulp-sourcemaps-2.4.1.tgz#8f65dc5c0d07b2fd5c88bc60ec7f13e56716bf74" dependencies: acorn "4.X" convert-source-map "1.X" css "2.X" debug-fabulous "0.0.X" detect-newline "2.X" graceful-fs "4.X" source-map "0.X" strip-bom "3.X" through2 "2.X" vinyl "1.X" gulp-util@^3.0.0: version "3.0.8" resolved "https://registry.yarnpkg.com/gulp-util/-/gulp-util-3.0.8.tgz#0054e1e744502e27c04c187c3ecc505dd54bbb4f" dependencies: array-differ "^1.0.0" array-uniq "^1.0.2" beeper "^1.0.0" chalk "^1.0.0" dateformat "^2.0.0" fancy-log "^1.1.0" gulplog "^1.0.0" has-gulplog "^0.1.0" lodash._reescape "^3.0.0" lodash._reevaluate "^3.0.0" lodash._reinterpolate "^3.0.0" lodash.template "^3.0.0" minimist "^1.1.0" multipipe "^0.1.2" object-assign "^3.0.0" replace-ext "0.0.1" through2 "^2.0.0" vinyl "^0.5.0" gulp@^3.9.1: version "3.9.1" resolved "https://registry.yarnpkg.com/gulp/-/gulp-3.9.1.tgz#571ce45928dd40af6514fc4011866016c13845b4" dependencies: archy "^1.0.0" chalk "^1.0.0" deprecated "^0.0.1" gulp-util "^3.0.0" interpret "^1.0.0" liftoff "^2.1.0" minimist "^1.1.0" orchestrator "^0.3.0" pretty-hrtime "^1.0.0" semver "^4.1.0" tildify "^1.0.0" v8flags "^2.0.2" vinyl-fs "^0.3.0" gulplog@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/gulplog/-/gulplog-1.0.0.tgz#e28c4d45d05ecbbed818363ce8f9c5926229ffe5" dependencies: glogg "^1.0.0" has-ansi@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/has-ansi/-/has-ansi-2.0.0.tgz#34f5049ce1ecdf2b0649af3ef24e45ed35416d91" dependencies: ansi-regex "^2.0.0" has-gulplog@^0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/has-gulplog/-/has-gulplog-0.1.0.tgz#6414c82913697da51590397dafb12f22967811ce" dependencies: sparkles "^1.0.0" has@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/has/-/has-1.0.1.tgz#8461733f538b0837c9361e39a9ab9e9704dc2f28" dependencies: function-bind "^1.0.2" home-or-tmp@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/home-or-tmp/-/home-or-tmp-2.0.0.tgz#e36c3f2d2cae7d746a857e38d18d5f32a7882db8" dependencies: os-homedir "^1.0.0" os-tmpdir "^1.0.1" homedir-polyfill@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/homedir-polyfill/-/homedir-polyfill-1.0.1.tgz#4c2bbc8a758998feebf5ed68580f76d46768b4bc" dependencies: parse-passwd "^1.0.0" ignore@^3.2.0: version "3.2.4" resolved "https://registry.yarnpkg.com/ignore/-/ignore-3.2.4.tgz#4055e03596729a8fabe45a43c100ad5ed815c4e8" imurmurhash@^0.1.4: version "0.1.4" resolved "https://registry.yarnpkg.com/imurmurhash/-/imurmurhash-0.1.4.tgz#9218b9b2b928a238b13dc4fb6b6d576f231453ea" inflight@^1.0.4: version "1.0.6" resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9" dependencies: once "^1.3.0" wrappy "1" inherits@1: version "1.0.2" resolved "https://registry.yarnpkg.com/inherits/-/inherits-1.0.2.tgz#ca4309dadee6b54cc0b8d247e8d7c7a0975bdc9b" inherits@2, inherits@^2.0.1, inherits@^2.0.3, inherits@~2.0.1: version "2.0.3" resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.3.tgz#633c2c83e3da42a502f52466022480f4208261de" inherits@2.0.1: version "2.0.1" resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.1.tgz#b17d08d326b4423e568eff719f91b0b1cbdf69f1" ini@^1.3.4: version "1.3.4" resolved "https://registry.yarnpkg.com/ini/-/ini-1.3.4.tgz#0537cb79daf59b59a1a517dff706c86ec039162e" inquirer@^0.12.0: version "0.12.0" resolved "https://registry.yarnpkg.com/inquirer/-/inquirer-0.12.0.tgz#1ef2bfd63504df0bc75785fff8c2c41df12f077e" dependencies: ansi-escapes "^1.1.0" ansi-regex "^2.0.0" chalk "^1.0.0" cli-cursor "^1.0.1" cli-width "^2.0.0" figures "^1.3.5" lodash "^4.3.0" readline2 "^1.0.1" run-async "^0.1.0" rx-lite "^3.1.2" string-width "^1.0.1" strip-ansi "^3.0.0" through "^2.3.6" interpret@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/interpret/-/interpret-1.0.1.tgz#d579fb7f693b858004947af39fa0db49f795602c" invariant@^2.2.0: version "2.2.2" resolved "https://registry.yarnpkg.com/invariant/-/invariant-2.2.2.tgz#9e1f56ac0acdb6bf303306f338be3b204ae60360" dependencies: loose-envify "^1.0.0" is-absolute@^0.2.3: version "0.2.6" resolved "https://registry.yarnpkg.com/is-absolute/-/is-absolute-0.2.6.tgz#20de69f3db942ef2d87b9c2da36f172235b1b5eb" dependencies: is-relative "^0.2.1" is-windows "^0.2.0" is-buffer@^1.0.2: version "1.1.4" resolved "https://registry.yarnpkg.com/is-buffer/-/is-buffer-1.1.4.tgz#cfc86ccd5dc5a52fa80489111c6920c457e2d98b" is-dotfile@^1.0.0: version "1.0.2" resolved "https://registry.yarnpkg.com/is-dotfile/-/is-dotfile-1.0.2.tgz#2c132383f39199f8edc268ca01b9b007d205cc4d" is-equal-shallow@^0.1.3: version "0.1.3" resolved "https://registry.yarnpkg.com/is-equal-shallow/-/is-equal-shallow-0.1.3.tgz#2238098fc221de0bcfa5d9eac4c45d638aa1c534" dependencies: is-primitive "^2.0.0" is-extendable@^0.1.1: version "0.1.1" resolved "https://registry.yarnpkg.com/is-extendable/-/is-extendable-0.1.1.tgz#62b110e289a471418e3ec36a617d472e301dfc89" is-extglob@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/is-extglob/-/is-extglob-1.0.0.tgz#ac468177c4943405a092fc8f29760c6ffc6206c0" is-finite@^1.0.0: version "1.0.2" resolved "https://registry.yarnpkg.com/is-finite/-/is-finite-1.0.2.tgz#cc6677695602be550ef11e8b4aa6305342b6d0aa" dependencies: number-is-nan "^1.0.0" is-fullwidth-code-point@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-1.0.0.tgz#ef9e31386f031a7f0d643af82fde50c457ef00cb" dependencies: number-is-nan "^1.0.0" is-fullwidth-code-point@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/is-fullwidth-code-point/-/is-fullwidth-code-point-2.0.0.tgz#a3b30a5c4f199183167aaab93beefae3ddfb654f" is-glob@^2.0.0, is-glob@^2.0.1: version "2.0.1" resolved "https://registry.yarnpkg.com/is-glob/-/is-glob-2.0.1.tgz#d096f926a3ded5600f3fdfd91198cb0888c2d863" dependencies: is-extglob "^1.0.0" is-my-json-valid@^2.10.0: version "2.16.0" resolved "https://registry.yarnpkg.com/is-my-json-valid/-/is-my-json-valid-2.16.0.tgz#f079dd9bfdae65ee2038aae8acbc86ab109e3693" dependencies: generate-function "^2.0.0" generate-object-property "^1.1.0" jsonpointer "^4.0.0" xtend "^4.0.0" is-number@^2.0.2, is-number@^2.1.0: version "2.1.0" resolved "https://registry.yarnpkg.com/is-number/-/is-number-2.1.0.tgz#01fcbbb393463a548f2f466cce16dece49db908f" dependencies: kind-of "^3.0.2" is-path-cwd@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/is-path-cwd/-/is-path-cwd-1.0.0.tgz#d225ec23132e89edd38fda767472e62e65f1106d" is-path-in-cwd@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/is-path-in-cwd/-/is-path-in-cwd-1.0.0.tgz#6477582b8214d602346094567003be8a9eac04dc" dependencies: is-path-inside "^1.0.0" is-path-inside@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/is-path-inside/-/is-path-inside-1.0.0.tgz#fc06e5a1683fbda13de667aff717bbc10a48f37f" dependencies: path-is-inside "^1.0.1" is-posix-bracket@^0.1.0: version "0.1.1" resolved "https://registry.yarnpkg.com/is-posix-bracket/-/is-posix-bracket-0.1.1.tgz#3334dc79774368e92f016e6fbc0a88f5cd6e6bc4" is-primitive@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/is-primitive/-/is-primitive-2.0.0.tgz#207bab91638499c07b2adf240a41a87210034575" is-property@^1.0.0: version "1.0.2" resolved "https://registry.yarnpkg.com/is-property/-/is-property-1.0.2.tgz#57fe1c4e48474edd65b09911f26b1cd4095dda84" is-relative@^0.2.1: version "0.2.1" resolved "https://registry.yarnpkg.com/is-relative/-/is-relative-0.2.1.tgz#d27f4c7d516d175fb610db84bbeef23c3bc97aa5" dependencies: is-unc-path "^0.1.1" is-resolvable@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/is-resolvable/-/is-resolvable-1.0.0.tgz#8df57c61ea2e3c501408d100fb013cf8d6e0cc62" dependencies: tryit "^1.0.1" is-unc-path@^0.1.1: version "0.1.2" resolved "https://registry.yarnpkg.com/is-unc-path/-/is-unc-path-0.1.2.tgz#6ab053a72573c10250ff416a3814c35178af39b9" dependencies: unc-path-regex "^0.1.0" is-utf8@^0.2.0: version "0.2.1" resolved "https://registry.yarnpkg.com/is-utf8/-/is-utf8-0.2.1.tgz#4b0da1442104d1b336340e80797e865cf39f7d72" is-windows@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/is-windows/-/is-windows-0.2.0.tgz#de1aa6d63ea29dd248737b69f1ff8b8002d2108c" isarray@0.0.1: version "0.0.1" resolved "https://registry.yarnpkg.com/isarray/-/isarray-0.0.1.tgz#8a18acfca9a8f4177e09abfc6038939b05d1eedf" isarray@1.0.0, isarray@^1.0.0, isarray@~1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/isarray/-/isarray-1.0.0.tgz#bb935d48582cba168c06834957a54a3e07124f11" isexe@^1.1.1: version "1.1.2" resolved "https://registry.yarnpkg.com/isexe/-/isexe-1.1.2.tgz#36f3e22e60750920f5e7241a476a8c6a42275ad0" isobject@^2.0.0: version "2.1.0" resolved "https://registry.yarnpkg.com/isobject/-/isobject-2.1.0.tgz#f065561096a3f1da2ef46272f815c840d87e0c89" dependencies: isarray "1.0.0" jade@0.26.3: version "0.26.3" resolved "https://registry.yarnpkg.com/jade/-/jade-0.26.3.tgz#8f10d7977d8d79f2f6ff862a81b0513ccb25686c" dependencies: commander "0.6.1" mkdirp "0.3.0" js-tokens@^3.0.0: version "3.0.1" resolved "https://registry.yarnpkg.com/js-tokens/-/js-tokens-3.0.1.tgz#08e9f132484a2c45a30907e9dc4d5567b7f114d7" js-yaml@^3.5.1: version "3.8.1" resolved "https://registry.yarnpkg.com/js-yaml/-/js-yaml-3.8.1.tgz#782ba50200be7b9e5a8537001b7804db3ad02628" dependencies: argparse "^1.0.7" esprima "^3.1.1" jsesc@^1.3.0: version "1.3.0" resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-1.3.0.tgz#46c3fec8c1892b12b0833db9bc7622176dbab34b" jsesc@~0.5.0: version "0.5.0" resolved "https://registry.yarnpkg.com/jsesc/-/jsesc-0.5.0.tgz#e7dee66e35d6fc16f710fe91d5cf69f70f08911d" json-stable-stringify@^1.0.0, json-stable-stringify@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/json-stable-stringify/-/json-stable-stringify-1.0.1.tgz#9a759d39c5f2ff503fd5300646ed445f88c4f9af" dependencies: jsonify "~0.0.0" json5@^0.5.0: version "0.5.1" resolved "https://registry.yarnpkg.com/json5/-/json5-0.5.1.tgz#1eade7acc012034ad84e2396767ead9fa5495821" jsonify@~0.0.0: version "0.0.0" resolved "https://registry.yarnpkg.com/jsonify/-/jsonify-0.0.0.tgz#2c74b6ee41d93ca51b7b5aaee8f503631d252a73" jsonpointer@^4.0.0: version "4.0.1" resolved "https://registry.yarnpkg.com/jsonpointer/-/jsonpointer-4.0.1.tgz#4fd92cb34e0e9db3c89c8622ecf51f9b978c6cb9" kind-of@^3.0.2: version "3.1.0" resolved "https://registry.yarnpkg.com/kind-of/-/kind-of-3.1.0.tgz#475d698a5e49ff5e53d14e3e732429dc8bf4cf47" dependencies: is-buffer "^1.0.2" lazy-cache@^1.0.3: version "1.0.4" resolved "https://registry.yarnpkg.com/lazy-cache/-/lazy-cache-1.0.4.tgz#a1d78fc3a50474cb80845d3b3b6e1da49a446e8e" lazy-debug-legacy@0.0.X: version "0.0.1" resolved "https://registry.yarnpkg.com/lazy-debug-legacy/-/lazy-debug-legacy-0.0.1.tgz#537716c0776e4cf79e3ed1b621f7658c2911b1b1" levn@^0.3.0, levn@~0.3.0: version "0.3.0" resolved "https://registry.yarnpkg.com/levn/-/levn-0.3.0.tgz#3b09924edf9f083c0490fdd4c0bc4421e04764ee" dependencies: prelude-ls "~1.1.2" type-check "~0.3.2" liftoff@^2.1.0: version "2.3.0" resolved "https://registry.yarnpkg.com/liftoff/-/liftoff-2.3.0.tgz#a98f2ff67183d8ba7cfaca10548bd7ff0550b385" dependencies: extend "^3.0.0" findup-sync "^0.4.2" fined "^1.0.1" flagged-respawn "^0.3.2" lodash.isplainobject "^4.0.4" lodash.isstring "^4.0.1" lodash.mapvalues "^4.4.0" rechoir "^0.6.2" resolve "^1.1.7" lodash._basecopy@^3.0.0: version "3.0.1" resolved "https://registry.yarnpkg.com/lodash._basecopy/-/lodash._basecopy-3.0.1.tgz#8da0e6a876cf344c0ad8a54882111dd3c5c7ca36" lodash._basetostring@^3.0.0: version "3.0.1" resolved "https://registry.yarnpkg.com/lodash._basetostring/-/lodash._basetostring-3.0.1.tgz#d1861d877f824a52f669832dcaf3ee15566a07d5" lodash._basevalues@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/lodash._basevalues/-/lodash._basevalues-3.0.0.tgz#5b775762802bde3d3297503e26300820fdf661b7" lodash._getnative@^3.0.0: version "3.9.1" resolved "https://registry.yarnpkg.com/lodash._getnative/-/lodash._getnative-3.9.1.tgz#570bc7dede46d61cdcde687d65d3eecbaa3aaff5" lodash._isiterateecall@^3.0.0: version "3.0.9" resolved "https://registry.yarnpkg.com/lodash._isiterateecall/-/lodash._isiterateecall-3.0.9.tgz#5203ad7ba425fae842460e696db9cf3e6aac057c" lodash._reescape@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/lodash._reescape/-/lodash._reescape-3.0.0.tgz#2b1d6f5dfe07c8a355753e5f27fac7f1cde1616a" lodash._reevaluate@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/lodash._reevaluate/-/lodash._reevaluate-3.0.0.tgz#58bc74c40664953ae0b124d806996daca431e2ed" lodash._reinterpolate@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/lodash._reinterpolate/-/lodash._reinterpolate-3.0.0.tgz#0ccf2d89166af03b3663c796538b75ac6e114d9d" lodash._root@^3.0.0: version "3.0.1" resolved "https://registry.yarnpkg.com/lodash._root/-/lodash._root-3.0.1.tgz#fba1c4524c19ee9a5f8136b4609f017cf4ded692" lodash.assignwith@^4.0.7: version "4.2.0" resolved "https://registry.yarnpkg.com/lodash.assignwith/-/lodash.assignwith-4.2.0.tgz#127a97f02adc41751a954d24b0de17e100e038eb" lodash.cond@^4.3.0: version "4.5.2" resolved "https://registry.yarnpkg.com/lodash.cond/-/lodash.cond-4.5.2.tgz#f471a1da486be60f6ab955d17115523dd1d255d5" lodash.escape@^3.0.0: version "3.2.0" resolved "https://registry.yarnpkg.com/lodash.escape/-/lodash.escape-3.2.0.tgz#995ee0dc18c1b48cc92effae71a10aab5b487698" dependencies: lodash._root "^3.0.0" lodash.isarguments@^3.0.0: version "3.1.0" resolved "https://registry.yarnpkg.com/lodash.isarguments/-/lodash.isarguments-3.1.0.tgz#2f573d85c6a24289ff00663b491c1d338ff3458a" lodash.isarray@^3.0.0: version "3.0.4" resolved "https://registry.yarnpkg.com/lodash.isarray/-/lodash.isarray-3.0.4.tgz#79e4eb88c36a8122af86f844aa9bcd851b5fbb55" lodash.isempty@^4.2.1: version "4.4.0" resolved "https://registry.yarnpkg.com/lodash.isempty/-/lodash.isempty-4.4.0.tgz#6f86cbedd8be4ec987be9aaf33c9684db1b31e7e" lodash.isplainobject@^4.0.4: version "4.0.6" resolved "https://registry.yarnpkg.com/lodash.isplainobject/-/lodash.isplainobject-4.0.6.tgz#7c526a52d89b45c45cc690b88163be0497f550cb" lodash.isstring@^4.0.1: version "4.0.1" resolved "https://registry.yarnpkg.com/lodash.isstring/-/lodash.isstring-4.0.1.tgz#d527dfb5456eca7cc9bb95d5daeaf88ba54a5451" lodash.keys@^3.0.0: version "3.1.2" resolved "https://registry.yarnpkg.com/lodash.keys/-/lodash.keys-3.1.2.tgz#4dbc0472b156be50a0b286855d1bd0b0c656098a" dependencies: lodash._getnative "^3.0.0" lodash.isarguments "^3.0.0" lodash.isarray "^3.0.0" lodash.mapvalues@^4.4.0: version "4.6.0" resolved "https://registry.yarnpkg.com/lodash.mapvalues/-/lodash.mapvalues-4.6.0.tgz#1bafa5005de9dd6f4f26668c30ca37230cc9689c" lodash.pick@^4.2.1: version "4.4.0" resolved "https://registry.yarnpkg.com/lodash.pick/-/lodash.pick-4.4.0.tgz#52f05610fff9ded422611441ed1fc123a03001b3" lodash.restparam@^3.0.0: version "3.6.1" resolved "https://registry.yarnpkg.com/lodash.restparam/-/lodash.restparam-3.6.1.tgz#936a4e309ef330a7645ed4145986c85ae5b20805" lodash.template@^3.0.0: version "3.6.2" resolved "https://registry.yarnpkg.com/lodash.template/-/lodash.template-3.6.2.tgz#f8cdecc6169a255be9098ae8b0c53d378931d14f" dependencies: lodash._basecopy "^3.0.0" lodash._basetostring "^3.0.0" lodash._basevalues "^3.0.0" lodash._isiterateecall "^3.0.0" lodash._reinterpolate "^3.0.0" lodash.escape "^3.0.0" lodash.keys "^3.0.0" lodash.restparam "^3.0.0" lodash.templatesettings "^3.0.0" lodash.templatesettings@^3.0.0: version "3.1.1" resolved "https://registry.yarnpkg.com/lodash.templatesettings/-/lodash.templatesettings-3.1.1.tgz#fb307844753b66b9f1afa54e262c745307dba8e5" dependencies: lodash._reinterpolate "^3.0.0" lodash.escape "^3.0.0" lodash@^4.0.0, lodash@^4.2.0, lodash@^4.3.0: version "4.17.4" resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.4.tgz#78203a4d1c328ae1d86dca6460e369b57f4055ae" lodash@~1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/lodash/-/lodash-1.0.2.tgz#8f57560c83b59fc270bd3d561b690043430e2551" lolex@1.3.2: version "1.3.2" resolved "https://registry.yarnpkg.com/lolex/-/lolex-1.3.2.tgz#7c3da62ffcb30f0f5a80a2566ca24e45d8a01f31" longest@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/longest/-/longest-1.0.1.tgz#30a0b2da38f73770e8294a0d22e6625ed77d0097" loose-envify@^1.0.0: version "1.3.1" resolved "https://registry.yarnpkg.com/loose-envify/-/loose-envify-1.3.1.tgz#d1a8ad33fa9ce0e713d65fdd0ac8b748d478c848" dependencies: js-tokens "^3.0.0" lru-cache@2: version "2.7.3" resolved "https://registry.yarnpkg.com/lru-cache/-/lru-cache-2.7.3.tgz#6d4524e8b955f95d4f5b58851ce21dd72fb4e952" map-cache@^0.2.0: version "0.2.2" resolved "https://registry.yarnpkg.com/map-cache/-/map-cache-0.2.2.tgz#c32abd0bd6525d9b051645bb4f26ac5dc98a0dbf" micromatch@^2.3.7: version "2.3.11" resolved "https://registry.yarnpkg.com/micromatch/-/micromatch-2.3.11.tgz#86677c97d1720b363431d04d0d15293bd38c1565" dependencies: arr-diff "^2.0.0" array-unique "^0.2.1" braces "^1.8.2" expand-brackets "^0.1.4" extglob "^0.3.1" filename-regex "^2.0.0" is-extglob "^1.0.0" is-glob "^2.0.1" kind-of "^3.0.2" normalize-path "^2.0.1" object.omit "^2.0.0" parse-glob "^3.0.4" regex-cache "^0.4.2" minimatch@0.3: version "0.3.0" resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-0.3.0.tgz#275d8edaac4f1bb3326472089e7949c8394699dd" dependencies: lru-cache "2" sigmund "~1.0.0" minimatch@^2.0.1: version "2.0.10" resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-2.0.10.tgz#8d087c39c6b38c001b97fca7ce6d0e1e80afbac7" dependencies: brace-expansion "^1.0.0" minimatch@^3.0.2, minimatch@^3.0.3: version "3.0.3" resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.3.tgz#2a4e4090b96b2db06a9d7df01055a62a77c9b774" dependencies: brace-expansion "^1.0.0" minimatch@~0.2.11: version "0.2.14" resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-0.2.14.tgz#c74e780574f63c6f9a090e90efbe6ef53a6a756a" dependencies: lru-cache "2" sigmund "~1.0.0" minimist@0.0.8: version "0.0.8" resolved "https://registry.yarnpkg.com/minimist/-/minimist-0.0.8.tgz#857fcabfc3397d2625b8228262e86aa7a011b05d" minimist@^1.1.0: version "1.2.0" resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.0.tgz#a35008b20f41383eec1fb914f4cd5df79a264284" mkdirp@0.3.0: version "0.3.0" resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.3.0.tgz#1bbf5ab1ba827af23575143490426455f481fe1e" mkdirp@0.5.1, mkdirp@^0.5.0, mkdirp@^0.5.1: version "0.5.1" resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.1.tgz#30057438eac6cf7f8c4767f38648d6697d75c903" dependencies: minimist "0.0.8" mocha@^2.4.5: version "2.5.3" resolved "https://registry.yarnpkg.com/mocha/-/mocha-2.5.3.tgz#161be5bdeb496771eb9b35745050b622b5aefc58" dependencies: commander "2.3.0" debug "2.2.0" diff "1.4.0" escape-string-regexp "1.0.2" glob "3.2.11" growl "1.9.2" jade "0.26.3" mkdirp "0.5.1" supports-color "1.2.0" to-iso-string "0.0.2" modify-babel-preset@^2.1.1: version "2.1.1" resolved "https://registry.yarnpkg.com/modify-babel-preset/-/modify-babel-preset-2.1.1.tgz#2d3190162ee62fb67aaa3325c242f026322ebbac" dependencies: require-relative "^0.8.7" ms@0.7.1: version "0.7.1" resolved "https://registry.yarnpkg.com/ms/-/ms-0.7.1.tgz#9cd13c03adbff25b65effde7ce864ee952017098" ms@0.7.2: version "0.7.2" resolved "https://registry.yarnpkg.com/ms/-/ms-0.7.2.tgz#ae25cf2512b3885a1d95d7f037868d8431124765" multipipe@^0.1.2: version "0.1.2" resolved "https://registry.yarnpkg.com/multipipe/-/multipipe-0.1.2.tgz#2a8f2ddf70eed564dff2d57f1e1a137d9f05078b" dependencies: duplexer2 "0.0.2" mute-stream@0.0.5: version "0.0.5" resolved "https://registry.yarnpkg.com/mute-stream/-/mute-stream-0.0.5.tgz#8fbfabb0a98a253d3184331f9e8deb7372fac6c0" natives@^1.1.0: version "1.1.0" resolved "https://registry.yarnpkg.com/natives/-/natives-1.1.0.tgz#e9ff841418a6b2ec7a495e939984f78f163e6e31" natural-compare@^1.4.0: version "1.4.0" resolved "https://registry.yarnpkg.com/natural-compare/-/natural-compare-1.4.0.tgz#4abebfeed7541f2c27acfb29bdbbd15c8d5ba4f7" normalize-path@^2.0.1: version "2.0.1" resolved "https://registry.yarnpkg.com/normalize-path/-/normalize-path-2.0.1.tgz#47886ac1662760d4261b7d979d241709d3ce3f7a" number-is-nan@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/number-is-nan/-/number-is-nan-1.0.1.tgz#097b602b53422a522c1afb8790318336941a011d" object-assign@4.1.0: version "4.1.0" resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.0.tgz#7a3b3d0e98063d43f4c03f2e8ae6cd51a86883a0" object-assign@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-3.0.0.tgz#9bedd5ca0897949bca47e7ff408062d549f587f2" object-assign@^4.0.1, object-assign@^4.1.0: version "4.1.1" resolved "https://registry.yarnpkg.com/object-assign/-/object-assign-4.1.1.tgz#2109adc7965887cfc05cbbd442cac8bfbb360863" object.omit@^2.0.0: version "2.0.1" resolved "https://registry.yarnpkg.com/object.omit/-/object.omit-2.0.1.tgz#1a9c744829f39dbb858c76ca3579ae2a54ebd1fa" dependencies: for-own "^0.1.4" is-extendable "^0.1.1" once@^1.3.0: version "1.4.0" resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1" dependencies: wrappy "1" once@~1.3.0: version "1.3.3" resolved "https://registry.yarnpkg.com/once/-/once-1.3.3.tgz#b2e261557ce4c314ec8304f3fa82663e4297ca20" dependencies: wrappy "1" onetime@^1.0.0: version "1.1.0" resolved "https://registry.yarnpkg.com/onetime/-/onetime-1.1.0.tgz#a1f7838f8314c516f05ecefcbc4ccfe04b4ed789" optionator@^0.8.2: version "0.8.2" resolved "https://registry.yarnpkg.com/optionator/-/optionator-0.8.2.tgz#364c5e409d3f4d6301d6c0b4c05bba50180aeb64" dependencies: deep-is "~0.1.3" fast-levenshtein "~2.0.4" levn "~0.3.0" prelude-ls "~1.1.2" type-check "~0.3.2" wordwrap "~1.0.0" orchestrator@^0.3.0: version "0.3.8" resolved "https://registry.yarnpkg.com/orchestrator/-/orchestrator-0.3.8.tgz#14e7e9e2764f7315fbac184e506c7aa6df94ad7e" dependencies: end-of-stream "~0.1.5" sequencify "~0.0.7" stream-consume "~0.1.0" ordered-read-streams@^0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/ordered-read-streams/-/ordered-read-streams-0.1.0.tgz#fd565a9af8eb4473ba69b6ed8a34352cb552f126" os-homedir@^1.0.0, os-homedir@^1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/os-homedir/-/os-homedir-1.0.2.tgz#ffbc4988336e0e833de0c168c7ef152121aa7fb3" os-tmpdir@^1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/os-tmpdir/-/os-tmpdir-1.0.2.tgz#bbe67406c79aa85c5cfec766fe5734555dfa1274" parse-filepath@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/parse-filepath/-/parse-filepath-1.0.1.tgz#159d6155d43904d16c10ef698911da1e91969b73" dependencies: is-absolute "^0.2.3" map-cache "^0.2.0" path-root "^0.1.1" parse-glob@^3.0.4: version "3.0.4" resolved "https://registry.yarnpkg.com/parse-glob/-/parse-glob-3.0.4.tgz#b2c376cfb11f35513badd173ef0bb6e3a388391c" dependencies: glob-base "^0.3.0" is-dotfile "^1.0.0" is-extglob "^1.0.0" is-glob "^2.0.0" parse-passwd@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/parse-passwd/-/parse-passwd-1.0.0.tgz#6d5b934a456993b23d37f40a382d6f1666a8e5c6" path-exists@^2.0.0: version "2.1.0" resolved "https://registry.yarnpkg.com/path-exists/-/path-exists-2.1.0.tgz#0feb6c64f0fc518d9a754dd5efb62c7022761f4b" dependencies: pinkie-promise "^2.0.0" path-is-absolute@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f" path-is-inside@^1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/path-is-inside/-/path-is-inside-1.0.2.tgz#365417dede44430d1c11af61027facf074bdfc53" path-parse@^1.0.5: version "1.0.5" resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.5.tgz#3c1adf871ea9cd6c9431b6ea2bd74a0ff055c4c1" path-root-regex@^0.1.0: version "0.1.2" resolved "https://registry.yarnpkg.com/path-root-regex/-/path-root-regex-0.1.2.tgz#bfccdc8df5b12dc52c8b43ec38d18d72c04ba96d" path-root@^0.1.1: version "0.1.1" resolved "https://registry.yarnpkg.com/path-root/-/path-root-0.1.1.tgz#9a4a6814cac1c0cd73360a95f32083c8ea4745b7" dependencies: path-root-regex "^0.1.0" pify@^2.0.0: version "2.3.0" resolved "https://registry.yarnpkg.com/pify/-/pify-2.3.0.tgz#ed141a6ac043a849ea588498e7dca8b15330e90c" pinkie-promise@^2.0.0: version "2.0.1" resolved "https://registry.yarnpkg.com/pinkie-promise/-/pinkie-promise-2.0.1.tgz#2135d6dfa7a358c069ac9b178776288228450ffa" dependencies: pinkie "^2.0.0" pinkie@^2.0.0: version "2.0.4" resolved "https://registry.yarnpkg.com/pinkie/-/pinkie-2.0.4.tgz#72556b80cfa0d48a974e80e77248e80ed4f7f870" pkg-dir@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/pkg-dir/-/pkg-dir-1.0.0.tgz#7a4b508a8d5bb2d629d447056ff4e9c9314cf3d4" dependencies: find-up "^1.0.0" pkg-up@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/pkg-up/-/pkg-up-1.0.0.tgz#3e08fb461525c4421624a33b9f7e6d0af5b05a26" dependencies: find-up "^1.0.0" pluralize@^1.2.1: version "1.2.1" resolved "https://registry.yarnpkg.com/pluralize/-/pluralize-1.2.1.tgz#d1a21483fd22bb41e58a12fa3421823140897c45" prelude-ls@~1.1.2: version "1.1.2" resolved "https://registry.yarnpkg.com/prelude-ls/-/prelude-ls-1.1.2.tgz#21932a549f5e52ffd9a827f570e04be62a97da54" preserve@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/preserve/-/preserve-0.2.0.tgz#815ed1f6ebc65926f865b310c0713bcb3315ce4b" pretty-hrtime@^1.0.0: version "1.0.3" resolved "https://registry.yarnpkg.com/pretty-hrtime/-/pretty-hrtime-1.0.3.tgz#b7e3ea42435a4c9b2759d99e0f201eb195802ee1" private@^0.1.6: version "0.1.7" resolved "https://registry.yarnpkg.com/private/-/private-0.1.7.tgz#68ce5e8a1ef0a23bb570cc28537b5332aba63ef1" process-nextick-args@~1.0.6: version "1.0.7" resolved "https://registry.yarnpkg.com/process-nextick-args/-/process-nextick-args-1.0.7.tgz#150e20b756590ad3f91093f25a4f2ad8bff30ba3" progress@^1.1.8: version "1.1.8" resolved "https://registry.yarnpkg.com/progress/-/progress-1.1.8.tgz#e260c78f6161cdd9b0e56cc3e0a85de17c7a57be" randomatic@^1.1.3: version "1.1.6" resolved "https://registry.yarnpkg.com/randomatic/-/randomatic-1.1.6.tgz#110dcabff397e9dcff7c0789ccc0a49adf1ec5bb" dependencies: is-number "^2.0.2" kind-of "^3.0.2" "readable-stream@>=1.0.33-1 <1.1.0-0": version "1.0.34" resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-1.0.34.tgz#125820e34bc842d2f2aaafafe4c2916ee32c157c" dependencies: core-util-is "~1.0.0" inherits "~2.0.1" isarray "0.0.1" string_decoder "~0.10.x" readable-stream@^2.1.5, readable-stream@^2.2.2: version "2.2.3" resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-2.2.3.tgz#9cf49463985df016c8ae8813097a9293a9b33729" dependencies: buffer-shims "^1.0.0" core-util-is "~1.0.0" inherits "~2.0.1" isarray "~1.0.0" process-nextick-args "~1.0.6" string_decoder "~0.10.x" util-deprecate "~1.0.1" readable-stream@~1.1.9: version "1.1.14" resolved "https://registry.yarnpkg.com/readable-stream/-/readable-stream-1.1.14.tgz#7cf4c54ef648e3813084c636dd2079e166c081d9" dependencies: core-util-is "~1.0.0" inherits "~2.0.1" isarray "0.0.1" string_decoder "~0.10.x" readline2@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/readline2/-/readline2-1.0.1.tgz#41059608ffc154757b715d9989d199ffbf372e35" dependencies: code-point-at "^1.0.0" is-fullwidth-code-point "^1.0.0" mute-stream "0.0.5" rechoir@^0.6.2: version "0.6.2" resolved "https://registry.yarnpkg.com/rechoir/-/rechoir-0.6.2.tgz#85204b54dba82d5742e28c96756ef43af50e3384" dependencies: resolve "^1.1.6" regenerate@^1.2.1: version "1.3.2" resolved "https://registry.yarnpkg.com/regenerate/-/regenerate-1.3.2.tgz#d1941c67bad437e1be76433add5b385f95b19260" regenerator-runtime@^0.10.0: version "0.10.3" resolved "https://registry.yarnpkg.com/regenerator-runtime/-/regenerator-runtime-0.10.3.tgz#8c4367a904b51ea62a908ac310bf99ff90a82a3e" regenerator-transform@0.9.8: version "0.9.8" resolved "https://registry.yarnpkg.com/regenerator-transform/-/regenerator-transform-0.9.8.tgz#0f88bb2bc03932ddb7b6b7312e68078f01026d6c" dependencies: babel-runtime "^6.18.0" babel-types "^6.19.0" private "^0.1.6" regex-cache@^0.4.2: version "0.4.3" resolved "https://registry.yarnpkg.com/regex-cache/-/regex-cache-0.4.3.tgz#9b1a6c35d4d0dfcef5711ae651e8e9d3d7114145" dependencies: is-equal-shallow "^0.1.3" is-primitive "^2.0.0" regexpu-core@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/regexpu-core/-/regexpu-core-2.0.0.tgz#49d038837b8dcf8bfa5b9a42139938e6ea2ae240" dependencies: regenerate "^1.2.1" regjsgen "^0.2.0" regjsparser "^0.1.4" regjsgen@^0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/regjsgen/-/regjsgen-0.2.0.tgz#6c016adeac554f75823fe37ac05b92d5a4edb1f7" regjsparser@^0.1.4: version "0.1.5" resolved "https://registry.yarnpkg.com/regjsparser/-/regjsparser-0.1.5.tgz#7ee8f84dc6fa792d3fd0ae228d24bd949ead205c" dependencies: jsesc "~0.5.0" repeat-element@^1.1.2: version "1.1.2" resolved "https://registry.yarnpkg.com/repeat-element/-/repeat-element-1.1.2.tgz#ef089a178d1483baae4d93eb98b4f9e4e11d990a" repeat-string@^1.5.2: version "1.6.1" resolved "https://registry.yarnpkg.com/repeat-string/-/repeat-string-1.6.1.tgz#8dcae470e1c88abc2d600fff4a776286da75e637" repeating@^2.0.0: version "2.0.1" resolved "https://registry.yarnpkg.com/repeating/-/repeating-2.0.1.tgz#5214c53a926d3552707527fbab415dbc08d06dda" dependencies: is-finite "^1.0.0" replace-ext@0.0.1: version "0.0.1" resolved "https://registry.yarnpkg.com/replace-ext/-/replace-ext-0.0.1.tgz#29bbd92078a739f0bcce2b4ee41e837953522924" require-relative@^0.8.7: version "0.8.7" resolved "https://registry.yarnpkg.com/require-relative/-/require-relative-0.8.7.tgz#7999539fc9e047a37928fa196f8e1563dabd36de" require-uncached@^1.0.2: version "1.0.3" resolved "https://registry.yarnpkg.com/require-uncached/-/require-uncached-1.0.3.tgz#4e0d56d6c9662fd31e43011c4b95aa49955421d3" dependencies: caller-path "^0.1.0" resolve-from "^1.0.0" resolve-dir@^0.1.0: version "0.1.1" resolved "https://registry.yarnpkg.com/resolve-dir/-/resolve-dir-0.1.1.tgz#b219259a5602fac5c5c496ad894a6e8cc430261e" dependencies: expand-tilde "^1.2.2" global-modules "^0.2.3" resolve-from@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/resolve-from/-/resolve-from-1.0.1.tgz#26cbfe935d1aeeeabb29bc3fe5aeb01e93d44226" resolve-url@~0.2.1: version "0.2.1" resolved "https://registry.yarnpkg.com/resolve-url/-/resolve-url-0.2.1.tgz#2c637fe77c893afd2a663fe21aa9080068e2052a" resolve@1.1.7: version "1.1.7" resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.1.7.tgz#203114d82ad2c5ed9e8e0411b3932875e889e97b" resolve@^1.1.6, resolve@^1.1.7: version "1.3.1" resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.3.1.tgz#5d0a1632609b6b00a22284293db1d5d973676314" dependencies: path-parse "^1.0.5" restore-cursor@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/restore-cursor/-/restore-cursor-1.0.1.tgz#34661f46886327fed2991479152252df92daa541" dependencies: exit-hook "^1.0.0" onetime "^1.0.0" right-align@^0.1.1: version "0.1.3" resolved "https://registry.yarnpkg.com/right-align/-/right-align-0.1.3.tgz#61339b722fe6a3515689210d24e14c96148613ef" dependencies: align-text "^0.1.1" rimraf@^2.2.8: version "2.6.1" resolved "https://registry.yarnpkg.com/rimraf/-/rimraf-2.6.1.tgz#c2338ec643df7a1b7fe5c54fa86f57428a55f33d" dependencies: glob "^7.0.5" rollup-plugin-babel@^2.7.1: version "2.7.1" resolved "https://registry.yarnpkg.com/rollup-plugin-babel/-/rollup-plugin-babel-2.7.1.tgz#16528197b0f938a1536f44683c7a93d573182f57" dependencies: babel-core "6" babel-plugin-transform-es2015-classes "^6.9.0" object-assign "^4.1.0" rollup-pluginutils "^1.5.0" rollup-plugin-node-resolve@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/rollup-plugin-node-resolve/-/rollup-plugin-node-resolve-2.0.0.tgz#07e0ae94ac002a3ea36e8f33ca121d9f836b1309" dependencies: browser-resolve "^1.11.0" builtin-modules "^1.1.0" resolve "^1.1.6" rollup-plugin-uglify@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/rollup-plugin-uglify/-/rollup-plugin-uglify-1.0.1.tgz#11d0b0c8bcd2d07e6908f74fd16b0152390b922a" dependencies: uglify-js "^2.6.1" rollup-pluginutils@^1.5.0: version "1.5.2" resolved "https://registry.yarnpkg.com/rollup-pluginutils/-/rollup-pluginutils-1.5.2.tgz#1e156e778f94b7255bfa1b3d0178be8f5c552408" dependencies: estree-walker "^0.2.1" minimatch "^3.0.2" rollup@^0.41.4: version "0.41.4" resolved "https://registry.yarnpkg.com/rollup/-/rollup-0.41.4.tgz#a970580176329f9ead86854d7fd4c46de752aef8" dependencies: source-map-support "^0.4.0" run-async@^0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/run-async/-/run-async-0.1.0.tgz#c8ad4a5e110661e402a7d21b530e009f25f8e389" dependencies: once "^1.3.0" rx-lite@^3.1.2: version "3.1.2" resolved "https://registry.yarnpkg.com/rx-lite/-/rx-lite-3.1.2.tgz#19ce502ca572665f3b647b10939f97fd1615f102" samsam@1.1.2, samsam@~1.1: version "1.1.2" resolved "https://registry.yarnpkg.com/samsam/-/samsam-1.1.2.tgz#bec11fdc83a9fda063401210e40176c3024d1567" semver@^4.1.0: version "4.3.6" resolved "https://registry.yarnpkg.com/semver/-/semver-4.3.6.tgz#300bc6e0e86374f7ba61068b5b1ecd57fc6532da" sequencify@~0.0.7: version "0.0.7" resolved "https://registry.yarnpkg.com/sequencify/-/sequencify-0.0.7.tgz#90cff19d02e07027fd767f5ead3e7b95d1e7380c" shelljs@^0.7.5: version "0.7.6" resolved "https://registry.yarnpkg.com/shelljs/-/shelljs-0.7.6.tgz#379cccfb56b91c8601e4793356eb5382924de9ad" dependencies: glob "^7.0.0" interpret "^1.0.0" rechoir "^0.6.2" sigmund@~1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/sigmund/-/sigmund-1.0.1.tgz#3ff21f198cad2175f9f3b781853fd94d0d19b590" sinon-chai@^2.8.0: version "2.8.0" resolved "https://registry.yarnpkg.com/sinon-chai/-/sinon-chai-2.8.0.tgz#432a9bbfd51a6fc00798f4d2526a829c060687ac" sinon@^1.17.7: version "1.17.7" resolved "https://registry.yarnpkg.com/sinon/-/sinon-1.17.7.tgz#4542a4f49ba0c45c05eb2e9dd9d203e2b8efe0bf" dependencies: formatio "1.1.1" lolex "1.3.2" samsam "1.1.2" util ">=0.10.3 <1" slash@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/slash/-/slash-1.0.0.tgz#c41f2f6c39fc16d1cd17ad4b5d896114ae470d55" slice-ansi@0.0.4: version "0.0.4" resolved "https://registry.yarnpkg.com/slice-ansi/-/slice-ansi-0.0.4.tgz#edbf8903f66f7ce2f8eafd6ceed65e264c831b35" source-map-resolve@^0.3.0: version "0.3.1" resolved "https://registry.yarnpkg.com/source-map-resolve/-/source-map-resolve-0.3.1.tgz#610f6122a445b8dd51535a2a71b783dfc1248761" dependencies: atob "~1.1.0" resolve-url "~0.2.1" source-map-url "~0.3.0" urix "~0.1.0" source-map-support@^0.4.0, source-map-support@^0.4.2: version "0.4.11" resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.4.11.tgz#647f939978b38535909530885303daf23279f322" dependencies: source-map "^0.5.3" source-map-url@~0.3.0: version "0.3.0" resolved "https://registry.yarnpkg.com/source-map-url/-/source-map-url-0.3.0.tgz#7ecaf13b57bcd09da8a40c5d269db33799d4aaf9" source-map@0.X, source-map@^0.5.0, source-map@^0.5.1, source-map@^0.5.3, source-map@~0.5.1: version "0.5.6" resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.5.6.tgz#75ce38f52bf0733c5a7f0c118d81334a2bb5f412" source-map@^0.1.38: version "0.1.43" resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.1.43.tgz#c24bc146ca517c1471f5dacbe2571b2b7f9e3346" dependencies: amdefine ">=0.0.4" sparkles@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/sparkles/-/sparkles-1.0.0.tgz#1acbbfb592436d10bbe8f785b7cc6f82815012c3" sprintf-js@~1.0.2: version "1.0.3" resolved "https://registry.yarnpkg.com/sprintf-js/-/sprintf-js-1.0.3.tgz#04e6926f662895354f3dd015203633b857297e2c" stream-consume@~0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/stream-consume/-/stream-consume-0.1.0.tgz#a41ead1a6d6081ceb79f65b061901b6d8f3d1d0f" string-width@^1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/string-width/-/string-width-1.0.2.tgz#118bdf5b8cdc51a2a7e70d211e07e2b0b9b107d3" dependencies: code-point-at "^1.0.0" is-fullwidth-code-point "^1.0.0" strip-ansi "^3.0.0" string-width@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/string-width/-/string-width-2.0.0.tgz#635c5436cc72a6e0c387ceca278d4e2eec52687e" dependencies: is-fullwidth-code-point "^2.0.0" strip-ansi "^3.0.0" string_decoder@~0.10.x: version "0.10.31" resolved "https://registry.yarnpkg.com/string_decoder/-/string_decoder-0.10.31.tgz#62e203bc41766c6c28c9fc84301dab1c5310fa94" strip-ansi@^3.0.0: version "3.0.1" resolved "https://registry.yarnpkg.com/strip-ansi/-/strip-ansi-3.0.1.tgz#6a385fb8853d952d5ff05d0e8aaf94278dc63dcf" dependencies: ansi-regex "^2.0.0" strip-bom@3.X, strip-bom@^3.0.0: version "3.0.0" resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-3.0.0.tgz#2334c18e9c759f7bdd56fdef7e9ae3d588e68ed3" strip-bom@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/strip-bom/-/strip-bom-1.0.0.tgz#85b8862f3844b5a6d5ec8467a93598173a36f794" dependencies: first-chunk-stream "^1.0.0" is-utf8 "^0.2.0" strip-json-comments@~2.0.1: version "2.0.1" resolved "https://registry.yarnpkg.com/strip-json-comments/-/strip-json-comments-2.0.1.tgz#3c531942e908c2697c0ec344858c286c7ca0a60a" supports-color@1.2.0: version "1.2.0" resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-1.2.0.tgz#ff1ed1e61169d06b3cf2d588e188b18d8847e17e" supports-color@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-2.0.0.tgz#535d045ce6b6363fa40117084629995e9df324c7" table@^3.7.8: version "3.8.3" resolved "https://registry.yarnpkg.com/table/-/table-3.8.3.tgz#2bbc542f0fda9861a755d3947fefd8b3f513855f" dependencies: ajv "^4.7.0" ajv-keywords "^1.0.0" chalk "^1.1.1" lodash "^4.0.0" slice-ansi "0.0.4" string-width "^2.0.0" tailored@2.3.2: version "2.3.2" resolved "https://registry.yarnpkg.com/tailored/-/tailored-2.3.2.tgz#4081db326b339dd31048c142d52cda3f95c6a135" dependencies: erlang-types "^1.0.0" text-table@~0.2.0: version "0.2.0" resolved "https://registry.yarnpkg.com/text-table/-/text-table-0.2.0.tgz#7f5ee823ae805207c00af2df4a84ec3fcfa570b4" through2@2.X, through2@^2.0.0: version "2.0.3" resolved "https://registry.yarnpkg.com/through2/-/through2-2.0.3.tgz#0004569b37c7c74ba39c43f3ced78d1ad94140be" dependencies: readable-stream "^2.1.5" xtend "~4.0.1" through2@^0.6.1: version "0.6.5" resolved "https://registry.yarnpkg.com/through2/-/through2-0.6.5.tgz#41ab9c67b29d57209071410e1d7a7a968cd3ad48" dependencies: readable-stream ">=1.0.33-1 <1.1.0-0" xtend ">=4.0.0 <4.1.0-0" through@^2.3.6: version "2.3.8" resolved "https://registry.yarnpkg.com/through/-/through-2.3.8.tgz#0dd4c9ffaabc357960b1b724115d7e0e86a2e1f5" tildify@^1.0.0: version "1.2.0" resolved "https://registry.yarnpkg.com/tildify/-/tildify-1.2.0.tgz#dcec03f55dca9b7aa3e5b04f21817eb56e63588a" dependencies: os-homedir "^1.0.0" time-stamp@^1.0.0: version "1.0.1" resolved "https://registry.yarnpkg.com/time-stamp/-/time-stamp-1.0.1.tgz#9f4bd23559c9365966f3302dbba2b07c6b99b151" to-fast-properties@^1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/to-fast-properties/-/to-fast-properties-1.0.2.tgz#f3f5c0c3ba7299a7ef99427e44633257ade43320" to-iso-string@0.0.2: version "0.0.2" resolved "https://registry.yarnpkg.com/to-iso-string/-/to-iso-string-0.0.2.tgz#4dc19e664dfccbe25bd8db508b00c6da158255d1" trim-right@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/trim-right/-/trim-right-1.0.1.tgz#cb2e1203067e0c8de1f614094b9fe45704ea6003" tryit@^1.0.1: version "1.0.3" resolved "https://registry.yarnpkg.com/tryit/-/tryit-1.0.3.tgz#393be730a9446fd1ead6da59a014308f36c289cb" type-check@~0.3.2: version "0.3.2" resolved "https://registry.yarnpkg.com/type-check/-/type-check-0.3.2.tgz#5884cab512cf1d355e3fb784f30804b2b520db72" dependencies: prelude-ls "~1.1.2" type-detect@0.1.1: version "0.1.1" resolved "https://registry.yarnpkg.com/type-detect/-/type-detect-0.1.1.tgz#0ba5ec2a885640e470ea4e8505971900dac58822" type-detect@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/type-detect/-/type-detect-1.0.0.tgz#762217cc06db258ec48908a1298e8b95121e8ea2" typedarray@^0.0.6: version "0.0.6" resolved "https://registry.yarnpkg.com/typedarray/-/typedarray-0.0.6.tgz#867ac74e3864187b1d3d47d996a78ec5c8830777" uglify-js@^2.6.1: version "2.7.5" resolved "https://registry.yarnpkg.com/uglify-js/-/uglify-js-2.7.5.tgz#4612c0c7baaee2ba7c487de4904ae122079f2ca8" dependencies: async "~0.2.6" source-map "~0.5.1" uglify-to-browserify "~1.0.0" yargs "~3.10.0" uglify-to-browserify@~1.0.0: version "1.0.2" resolved "https://registry.yarnpkg.com/uglify-to-browserify/-/uglify-to-browserify-1.0.2.tgz#6e0924d6bda6b5afe349e39a6d632850a0f882b7" unc-path-regex@^0.1.0: version "0.1.2" resolved "https://registry.yarnpkg.com/unc-path-regex/-/unc-path-regex-0.1.2.tgz#e73dd3d7b0d7c5ed86fbac6b0ae7d8c6a69d50fa" unique-stream@^1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/unique-stream/-/unique-stream-1.0.0.tgz#d59a4a75427447d9aa6c91e70263f8d26a4b104b" urix@^0.1.0, urix@~0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/urix/-/urix-0.1.0.tgz#da937f7a62e21fec1fd18d49b35c2935067a6c72" user-home@^1.1.1: version "1.1.1" resolved "https://registry.yarnpkg.com/user-home/-/user-home-1.1.1.tgz#2b5be23a32b63a7c9deb8d0f28d485724a3df190" user-home@^2.0.0: version "2.0.0" resolved "https://registry.yarnpkg.com/user-home/-/user-home-2.0.0.tgz#9c70bfd8169bc1dcbf48604e0f04b8b49cde9e9f" dependencies: os-homedir "^1.0.0" util-deprecate@~1.0.1: version "1.0.2" resolved "https://registry.yarnpkg.com/util-deprecate/-/util-deprecate-1.0.2.tgz#450d4dc9fa70de732762fbd2d4a28981419a0ccf" "util@>=0.10.3 <1": version "0.10.3" resolved "https://registry.yarnpkg.com/util/-/util-0.10.3.tgz#7afb1afe50805246489e3db7fe0ed379336ac0f9" dependencies: inherits "2.0.1" v8flags@^2.0.2: version "2.0.11" resolved "https://registry.yarnpkg.com/v8flags/-/v8flags-2.0.11.tgz#bca8f30f0d6d60612cc2c00641e6962d42ae6881" dependencies: user-home "^1.1.1" vinyl-fs@^0.3.0: version "0.3.14" resolved "https://registry.yarnpkg.com/vinyl-fs/-/vinyl-fs-0.3.14.tgz#9a6851ce1cac1c1cea5fe86c0931d620c2cfa9e6" dependencies: defaults "^1.0.0" glob-stream "^3.1.5" glob-watcher "^0.0.6" graceful-fs "^3.0.0" mkdirp "^0.5.0" strip-bom "^1.0.0" through2 "^0.6.1" vinyl "^0.4.0" vinyl-sourcemaps-apply@^0.2.0: version "0.2.1" resolved "https://registry.yarnpkg.com/vinyl-sourcemaps-apply/-/vinyl-sourcemaps-apply-0.2.1.tgz#ab6549d61d172c2b1b87be5c508d239c8ef87705" dependencies: source-map "^0.5.1" vinyl@1.X: version "1.2.0" resolved "https://registry.yarnpkg.com/vinyl/-/vinyl-1.2.0.tgz#5c88036cf565e5df05558bfc911f8656df218884" dependencies: clone "^1.0.0" clone-stats "^0.0.1" replace-ext "0.0.1" vinyl@^0.4.0: version "0.4.6" resolved "https://registry.yarnpkg.com/vinyl/-/vinyl-0.4.6.tgz#2f356c87a550a255461f36bbeb2a5ba8bf784847" dependencies: clone "^0.2.0" clone-stats "^0.0.1" vinyl@^0.5.0: version "0.5.3" resolved "https://registry.yarnpkg.com/vinyl/-/vinyl-0.5.3.tgz#b0455b38fc5e0cf30d4325132e461970c2091cde" dependencies: clone "^1.0.0" clone-stats "^0.0.1" replace-ext "0.0.1" which@^1.2.12: version "1.2.12" resolved "https://registry.yarnpkg.com/which/-/which-1.2.12.tgz#de67b5e450269f194909ef23ece4ebe416fa1192" dependencies: isexe "^1.1.1" window-size@0.1.0: version "0.1.0" resolved "https://registry.yarnpkg.com/window-size/-/window-size-0.1.0.tgz#5438cd2ea93b202efa3a19fe8887aee7c94f9c9d" wordwrap@0.0.2: version "0.0.2" resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-0.0.2.tgz#b79669bb42ecb409f83d583cad52ca17eaa1643f" wordwrap@~1.0.0: version "1.0.0" resolved "https://registry.yarnpkg.com/wordwrap/-/wordwrap-1.0.0.tgz#27584810891456a4171c8d0226441ade90cbcaeb" wrappy@1: version "1.0.2" resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f" write@^0.2.1: version "0.2.1" resolved "https://registry.yarnpkg.com/write/-/write-0.2.1.tgz#5fc03828e264cea3fe91455476f7a3c566cb0757" dependencies: mkdirp "^0.5.1" "xtend@>=4.0.0 <4.1.0-0", xtend@^4.0.0, xtend@~4.0.1: version "4.0.1" resolved "https://registry.yarnpkg.com/xtend/-/xtend-4.0.1.tgz#a5c6d532be656e23db820efb943a1f04998d63af" yargs@~3.10.0: version "3.10.0" resolved "https://registry.yarnpkg.com/yargs/-/yargs-3.10.0.tgz#f7ee7bd857dd7c1d2d38c0e74efbd681d1431fd1" dependencies: camelcase "^1.0.2" cliui "^2.1.0" decamelize "^1.0.0" window-size "0.1.0"