traceur-rb 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MDdiZWFhN2Q5NjZiMTYyMTgyN2I5NWM5YzUyYjcxNTk2NDBiOWMwMQ==
+  data.tar.gz: !binary |-
+    YzZiOTQ3NmY0NTRlMjczN2I0NzdmMGIwNWUwZTljYmE5OTk1MTBlMA==
+SHA512:
+  metadata.gz: !binary |-
+    ZDM3NjcwZmE1MWViOTg0NzU2YzJiYzA3NzI4OWEzMzg2ZDljZmI0YzQyNTQ4
+    ZjdmMjg3MTAxYzI5MjUyMWFhZmVlODkxZTI5MDg2ZjViMWQ1MTM3MTEwN2Vj
+    MDgzZGMxMDkxNTBkZjFhZGIzNjRiMzljNDBlYjI0NzZkMGNiMjc=
+  data.tar.gz: !binary |-
+    ODI2NzJkN2VkNWJjNDdmMzhjN2FiZGM0YWUwNmRhOGIyY2FmMGNlYzcxZjI5
+    NzJjODRhZTI1ZTI2NjE0YjQ5YTEzZGQ1MTkzOGM0ZWZiMjk3NjYyZDE2NTBl
+    MDc2ZWZkYzk4N2M1Njg2NDA1ZjcxYWRlODAxNjMwNDUzZTUzYmU=

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1 @@
+--color

data/.ruby-gemset

@@ -0,0 +1 @@
+traceur

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in traceur-rb.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,8 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec, failed_mode: :keep do
+  watch(%r{^spec/.+_spec\.rb$}) { "spec" }
+  watch(%r{^lib/(.+)\.(rb|js)$}) { "spec" }
+  watch('spec/spec_helper.rb') { "spec" }
+end

data/LICENSE.txt

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

data/README.md

@@ -0,0 +1,87 @@
+# traceur-rb
+
+This gem provides a Ruby wrapper around [Google Traceur][gtraceur].
+
+## Google Traceur
+
+Google Traceur is a transpiler, which allows you to compile ECMAScript 6 (JS.next) features in today's browsers.
+
+## Dependencies
+
+Google Traceur depends on Node.js. On Ubuntu, you can install Node.js with command:
+
+```bash
+sudo apt-get install node
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'traceur-rb'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install traceur-rb
+
+## Basic Usage
+
+You can compile a snippet of ECMAScript 6 by calling the following method:
+
+```ruby
+require 'traceur'
+
+compiled_source = Traceur.compile(es6_source, additional_compilation_flags) 
+```
+
+simmilarly, you can compile a file using:
+
+```
+require 'traceur'
+
+compiled_source = Traceur.compile_file(path_to_es6_file, additional_compilation_flags)
+```
+
+## Configuration
+
+traceur-rb can be configured using a `Traceur.configure`:
+
+```ruby
+Traceur.configure do |c|
+  # Configure path of the node.js binary.
+  # By default, traceur-rb loooks for node in $PATH.
+  c.node_binary = "/path/to/node"
+
+  # Configure path of node_modules folder, where
+  # traceur is installed.
+  # By default, traceur-rb uses traceur version
+  # which comes bundled with the gem.
+  c.node_modules_path = "/path/to/node_modules/"
+
+  # Configure path to traceur-runtime.js, which is
+  # a runtime dependency of the code compiled using
+  # Google Traceur.
+  # By default, this is computed based on node_modules_path.
+  c.traceur_runtime_path = "/path/to/node_modules/traceur/bin/traceur-runtime.js"
+
+  # Configure the default compilation options.
+  # For a complete list of options available, see:
+  # https://github.com/google/traceur-compiler/wiki/Options-for-Compiling
+  c.default_compilation_options.modules = :amd
+  c.default_compilation_options.source_map = true
+end
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/traceur-rb/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+[gtraceur]: https://github.com/google/traceur-compiler

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/js/compile.js

@@ -0,0 +1,31 @@
+var traceur = require('traceur');
+var fs = require('fs');
+
+if (process.argv.length < 5) {
+  throw "Usage: compile.js infile outfile options_as_json";
+}
+
+var infile = process.argv[2];
+var outfile = process.argv[3];
+var customOptions = JSON.parse(process.argv[4]);
+
+var contents = fs.readFileSync(infile).toString();
+
+var options = {
+  filename: infile
+};
+
+for (var key in customOptions) {
+  if (customOptions.hasOwnProperty(key)) {
+    options[key] = customOptions[key];
+  }
+}
+
+var result = traceur.compile(contents, options);
+
+if (result.error) {
+  throw result.error;
+}
+
+fs.writeFileSync(outfile, result.js);
+fs.writeFileSync(outfile + '.map', result.sourceMap);

data/lib/traceur-rb.rb

@@ -0,0 +1 @@
+require 'traceur'

data/lib/traceur.rb

@@ -0,0 +1,43 @@
+require "traceur/version"
+require "traceur/configuration"
+require "traceur/compilation_options"
+require "traceur/node"
+require "traceur/compiler"
+
+module Traceur
+  def self.compile(source, opts = {})
+    compiler.compile(source, opts)
+  end
+
+  def self.compile_file(source_file, opts = {})
+    compiler.compile_file(File.new(source_file), opts)
+  end
+
+  def self.config
+    @config ||= Configuration.new
+    yield @config if block_given?
+    @config
+  end
+
+  def self.assets_path
+    config.assets_path
+  end
+
+  def self.configure
+    yield config
+  end
+
+  def self.node_runner(opts = {})
+    Node::Runner.new({
+      binary: config.node_binary.to_s,
+      modules_path: config.node_modules_path.to_s,
+      env: ENV.to_hash
+    }.merge(opts))
+  end
+
+  def self.compiler
+    Compiler.new(runner: node_runner,
+                 compile_script_path: config.compile_script_path.to_s,
+                 default_compilation_options: config.default_compilation_options)
+  end
+end

data/lib/traceur/compilation_options.rb

@@ -0,0 +1,65 @@
+require 'json'
+
+module Traceur
+  class CompilationOptions
+    def initialize(options = {})
+      @options = {}
+      merge!(options)
+    end
+
+    def []=(name, value)
+      @options[normalize(name)] = value
+    end
+
+    def [](name)
+      @options[normalize(name)]
+    end
+
+    def merge!(options)
+      options.each do |key, value|
+        self[key] = value
+      end
+      self
+    end
+
+    def merge(options)
+      CompilationOptions.new(self).merge!(options)
+    end
+
+    def each(&block)
+      @options.each(&block)
+    end
+
+    def to_hash
+      @options
+    end
+
+    def to_json
+      to_hash.to_json
+    end
+
+    private
+
+    def respond_to_missing?(name, include_private)
+      true
+    end
+
+    def method_missing(name, *args, &block)
+      return self[name] = args.first if setter?(name, args)
+      return self[name] if getter?(name, args)
+      super
+    end
+
+    def setter?(name, args)
+      name.to_s.end_with?("=") && args.size == 1
+    end
+
+    def getter?(name, args)
+      args.size == 0
+    end
+
+    def normalize(name)
+      name.to_s.gsub(/_[a-z]/) { |m| m.upcase }.gsub('_', '').gsub(/=$/, '').to_sym
+    end
+  end
+end

data/lib/traceur/compiler.rb

@@ -0,0 +1,33 @@
+require 'tempfile'
+
+module Traceur
+  class Compiler
+    def initialize(opts = {})
+      @runner = opts.fetch(:runner)
+      @compile_script_path = opts.fetch(:compile_script_path)
+      @default_compilation_options = opts.fetch(:default_compilation_options)
+    end
+
+    def compile(source, opts = {})
+      compile_file(tempfile(source), opts)
+    end
+
+    def compile_file(infile, opts = {})
+      options = default_compilation_options.merge(opts)
+      outfile = Tempfile.new('out.js')
+      runner.run(arguments: [compile_script_path, infile.path, outfile.path, options.to_json])
+      outfile.read
+    end
+
+    private
+
+    def tempfile(source)
+      Tempfile.new('in.js').tap do |f|
+        f.write(source)
+        f.close
+      end
+    end
+
+    attr_reader :runner, :compile_script_path, :default_compilation_options
+  end
+end

data/lib/traceur/configuration.rb

@@ -0,0 +1,47 @@
+require 'pathname'
+
+module Traceur
+  class Configuration
+    attr_writer :node_binary
+    attr_writer :node_modules_path
+    attr_writer :traceur_runtime_path
+    attr_writer :compile_script_path
+
+    def node_binary
+      @node_binary ||= "node"
+    end
+
+    def node_modules_path
+      @node_modules_path ||= root_dir.join("vendor", "node_modules")
+    end
+
+    def traceur_runtime_path
+      @traceur_runtime_path ||= node_modules_path.join("traceur", "bin", "traceur-runtime.js")
+    end
+
+    def assets_path
+      traceur_runtime_path.dirname.to_s
+    end
+
+    def compile_script_path
+      @compile_script_path ||= root_dir.join("lib", "js", "compile.js")
+    end
+
+    def default_compilation_options
+      @default_compilation_options ||= CompilationOptions.new(
+        modules: :inline,
+        source_map: true,
+      )
+    end
+
+    def default_compilation_options=(hash)
+      @default_compilation_options = CompilationOptions.new(hash)
+    end
+
+    private
+
+    def root_dir
+      Pathname.new(__FILE__).join("..", "..", "..")
+    end
+  end
+end

data/lib/traceur/node.rb

@@ -0,0 +1,26 @@
+require "traceur/node/runner"
+require "traceur/node/command_result"
+
+module Traceur
+  class NodeCommandError < StandardError
+  end
+
+  module Node
+    def self.eval(script)
+      Traceur.node_runner.run(
+        input: script,
+        on_error: ->(r){raise_command_error(r)}).stdout
+    end
+
+    def self.exec(*args)
+      Traceur.node_runner.run(
+        arguments: args,
+        on_error: ->(r){raise_command_error(r)}).stdout
+    end
+
+    def self.raise_command_error(result)
+      raise NodeCommandError,
+        "Node command returned non-0 exit status: #{result.exit_status}. Stderr was:\n#{result.stderr}"
+    end
+  end
+end

data/lib/traceur/node/command_result.rb

@@ -0,0 +1,28 @@
+module Traceur
+  module Node
+    class CommandResult < Struct.new(:status, :stdout, :stderr)
+      def initialize(opts = {})
+        self.status = opts[:status]
+        self.stdout = opts[:stdout]
+        self.stderr = opts[:stderr]
+      end
+
+      def on_error
+        yield(self) if error?
+        self
+      end
+
+      def error?
+        !success?
+      end
+
+      def success?
+        exit_status == 0
+      end
+
+      def exit_status
+        status.exitstatus
+      end
+    end
+  end
+end