typescript-monkey 0.9.0

data/Rakefile

@@ -0,0 +1,13 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task :default => :test

data/contrib/example_package.json

@@ -0,0 +1,10 @@
+{
+  "name": "rails-project",
+  "description": "rails-project",
+  "version": "0.0.1",
+  "dependencies": {
+    "@types/jquery": "^2.0.41",
+    "@types/node": "^7.0.14",
+    "typescript": "^2.3.1"
+  }
+}

data/contrib/example_typescript.rb

@@ -0,0 +1,14 @@
+#
+# initializers/typescript.rb
+#
+# Configure typescript-monkey gem, notably which typescript path to use.
+# See: https://github.com/markeissler/typescript-monkey
+#
+
+Typescript::Monkey.configure do |config|
+  # Configure Typescript::Monkey concatenated compilation
+  # config.compile = false
+
+  # Configure Typescript::Monkey logging (for debugging your app build)
+  # config.logger = Rails.logger
+end

data/gulpfile.js

@@ -0,0 +1,67 @@
+//
+// gulpfile.js
+// typescript-monkey
+//
+var gulp = require("gulp");
+var ts = require("gulp-typescript");
+var uglify = require("gulp-uglify");
+var rename = require("gulp-rename");
+var concat = require("gulp-concat");
+var ignore = require("gulp-ignore");
+var debug = require('gulp-debug');
+var runSequence = require('run-sequence');
+
+var tsProject = ts.createProject("tsconfig.json");
+var jsOutputDir = "lib/assets/javascripts";
+
+gulp.task("transpile", function() {
+  var tsResult = tsProject.src()
+    .pipe(ignore.include(/transpiler.ts$/))
+    .pipe(tsProject());
+
+  return tsResult.js
+    .pipe(rename({ basename: "dyrt" }))
+    .pipe(gulp.dest(jsOutputDir));
+});
+
+gulp.task("transpile-min", function() {
+  var tsResult = tsProject.src()
+    .pipe(ignore.include(/transpiler.ts$/))
+    .pipe(tsProject());
+
+  return tsResult.js
+    .pipe(rename({ basename: "dyrt" }))
+    .pipe(gulp.dest(jsOutputDir))
+    .pipe(uglify())
+    .pipe(rename({ suffix: ".min" }))
+    .pipe(gulp.dest(jsOutputDir));
+});
+
+gulp.task("transpile-once", function() {
+  var tsResult = tsProject.src()
+    .pipe(tsProject());
+
+  return tsResult.js
+    .pipe(concat('dyrt_once.js'))
+    .pipe(gulp.dest(jsOutputDir));
+});
+
+gulp.task("transpile-once-min", function() {
+  var tsResult = tsProject.src()
+    .pipe(tsProject());
+
+  return tsResult.js
+    .pipe(concat('dyrt_once.js'))
+    .pipe(gulp.dest(jsOutputDir))
+    .pipe(uglify())
+    .pipe(rename({ suffix: ".min" }))
+    .pipe(gulp.dest(jsOutputDir));
+});
+
+gulp.task("all", function() {
+  runSequence("transpile-min", "transpile-once-min");
+});
+
+gulp.task("watch", ["transpile"], function() {
+  gulp.watch("lib/assets/typescripts/*.ts", ["transpile"]);
+});

data/lib/assets/javascripts/transpiler.ts.erb

@@ -0,0 +1 @@
+<%= Typescript::Monkey::Transpiler.dyrt_ts %>

data/lib/assets/javascripts/transpiler_pkg.js.erb

@@ -0,0 +1,2 @@
+<%= Typescript::Monkey::Package.services_js %>
+<%= Typescript::Monkey::Transpiler.dyrt_once_js %>

data/lib/assets/javascripts/typescript.js.erb

@@ -0,0 +1 @@
+<%= Typescript::Monkey::Package.services_js %>

data/lib/assets/typescripts/transpile_once.ts

@@ -0,0 +1,13 @@
+//
+// transpile_once.ts
+// typescript-monkey
+//
+// Run the transpiler once against the DOM.
+//
+
+/// <reference path="./transpiler.ts" />
+
+(() => {
+    const transpiler = new TypescriptRails.Transpiler();
+    transpiler.transpile();
+})();

data/lib/assets/typescripts/transpiler.ts

@@ -0,0 +1,203 @@
+//
+// transpiler.ts
+// typescript-monkey
+//
+
+/// <reference types="typescript/lib/typescriptServices" />
+
+namespace TypescriptRails {
+    export enum ScriptType {
+        Any,
+        Javascript,
+        Typescript,
+    };
+
+    /**
+     * A class to transpile typescript into javascript in the browser, at
+     * runtime.
+     *
+     * @export
+     * @class Transpiler
+     */
+    export class Transpiler {
+        public domBody: HTMLElement;
+
+        constructor() {
+            this._loadDOM();
+        }
+
+        /**
+         * Set internal DOM properties.
+         *
+         * @private
+         * @returns {void}
+         *
+         * @memberOf TypescriptRails
+         */
+        private _loadDOM(): void {
+            this.domBody = document.getElementsByTagName("body")[0];
+
+            return;
+        }
+
+        /**
+         * Transpile all typescript scripts in DOM.
+         *
+         * All previous transpiled scripts will be removed before their source
+         * is re-transpiled and re-appended to the DOM.
+         *
+         * @returns {void}
+         *
+         * @memberof Transpiler
+         */
+        public transpile(): void {
+            let typescripts: HTMLScriptElement[] = this.domScripts(ScriptType.Typescript);
+            let javascripts: HTMLScriptElement[] = [];
+
+            // remove all transpiled scripts from DOM
+            this.purgeTranspiledScripts();
+
+            // transpile all typescripts
+            for (const script of typescripts) {
+                javascripts.push(this.transpileScript(script));
+            }
+
+            // append transpiled scripts to DOM
+            this.appendScripts(javascripts);
+
+            return;
+        }
+
+        /**
+         * Transpile typescript script to javascript.
+         *
+         * @param {HTMLScriptElement} script The script object to transpile
+         * @returns {HTMLScriptElement} The transpiled script object
+         *
+         * @memberof Transpiler
+         */
+        public transpileScript(script: HTMLScriptElement): HTMLScriptElement {
+            if (script.type !== "text/typescript") return;
+
+            const compilerOptions: ts.TranspileOptions = {
+                compilerOptions: {
+                    module: ts.ModuleKind.CommonJS,
+                },
+                fileName: undefined,
+                reportDiagnostics: false,
+                moduleName: undefined,
+                renamedDependencies: undefined,
+            } as ts.TranspileOptions;
+
+            // transpile script content
+            const jsContent = ts.transpileModule(script.text, compilerOptions);
+
+            // create a new script node, insert transpiled content
+            const element = document.createElement("script");
+            element.type = "text/javascript";
+            element.innerHTML = "// Transpiled TypeScript\n\n" + jsContent.outputText;
+
+            return element;
+        }
+
+        /**
+         * Append scripts to DOM.
+         *
+         * Script objects will be assigned an id that is a combination of the
+         * prefix plus an incremented value.
+         *
+         * @param {HTMLScriptElement[]} scripts
+         * @param {string} [prefix="drty-"] Object id prefix to filter targets
+         * @returns {number} Number of scripts appended
+         *
+         * @memberof Transpiler
+         */
+        public appendScripts(scripts: HTMLScriptElement[], prefix: string = "drty-"): number {
+            let counter: number = 0;
+
+            for (const script of scripts) {
+                script.id = `${prefix + counter}`
+                this.domBody.appendChild(script);
+                counter++;
+            }
+
+            return counter;
+        }
+
+        /**
+         * Remove transpiled scripts from DOM.
+         *
+         * @param {string} [prefix="drty-"] Object id prefix to filter targets
+         * @returns {number} Number of scripts removed
+         *
+         * @memberof Transpiler
+         */
+        public purgeTranspiledScripts(prefix: string = "drty-"): number {
+            let counter: number = this.purgeScripts(ScriptType.Javascript, prefix);
+
+            return counter;
+        }
+
+        /**
+         * Remove scripts from DOM.
+         *
+         * @param {ScriptType} type Object script type
+         * @param {string} prefix Object id prefix to filter targets
+         * @returns {number} Number of scripts removed
+         *
+         * @memberof Transpiler
+         */
+        public purgeScripts(type: ScriptType, prefix: string): number {
+            let scripts: HTMLScriptElement[] = this.domScripts(type, prefix);
+            let counter: number = 0;
+
+            for (const script of scripts) {
+                this.domBody.removeChild(script);
+                counter++;
+            }
+
+            return counter;
+        }
+
+        /**
+         * Returns an array of script objects from DOM.
+         *
+         * This method returns all scripts if no idPrefix is provided.
+         *
+         * @private
+         * @param {ScriptType} [type=ScriptType.Typescript] Object script type
+         * @param {string} [prefix=""] Object id prefix to filter results
+         * @returns {HTMLScriptElement[]} Array of script objects
+         *
+         * @memberof Transpiler
+         */
+        private domScripts(type: ScriptType = ScriptType.Typescript, prefix: string = ""): HTMLScriptElement[] {
+            let nodes: NodeList = document.getElementsByTagName("script");
+            let scripts: HTMLScriptElement[] = [];
+
+            Array.prototype.forEach.call(nodes, (node, key, listObj, argument) => {
+                const script = node as HTMLScriptElement;
+
+                switch(type) {
+                    case ScriptType.Javascript:
+                        if (script.type !== "text/javascript" && script.type.length > 0) return;
+                        break;
+
+                    case ScriptType.Typescript:
+                        if (script.type !== "text/typescript") return;
+                        break;
+
+                    default:
+                        break;
+                }
+
+                const regex = new RegExp("^" + `${prefix}`);
+                if (prefix.length === 0 || (script.id.length > 0 && regex.test(script.id))) {
+                    scripts.push(script);
+                }
+            });
+
+            return scripts;
+        }
+    } // class Transpiler
+} // namespace TypescriptRails

data/lib/rails/generators/typescript/assets/assets_generator.rb

@@ -0,0 +1,13 @@
+require "rails/generators/named_base"
+
+module Typescript
+  module Generators
+    class AssetsGenerator < ::Rails::Generators::NamedBase
+      source_root File.expand_path("../templates", __FILE__)
+
+      def copy_typescript
+        template "javascript.ts", File.join('app/assets/javascripts', class_path, "#{file_name}.ts")
+      end
+    end
+  end
+end

data/lib/rails/generators/typescript/assets/templates/javascript.ts

@@ -0,0 +1,3 @@
+// Place all the behaviors and hooks related to the matching controller here.
+// All this logic will automatically be available in application.js.
+// You can use TypeScript in this file: www.typescriptlang.org

data/lib/typescript-monkey.rb

@@ -0,0 +1,8 @@
+require 'typescript/monkey'
+require 'typescript/monkey/configuration'
+require 'typescript/monkey/railtie'
+require 'typescript/monkey/engine'
+require 'typescript/monkey/template'
+require 'typescript/monkey/template_handler'
+require 'typescript/monkey/transformer'
+require 'typescript/monkey/transpiler'

data/lib/typescript/monkey.rb

@@ -0,0 +1,9 @@
+module Typescript
+  module Monkey
+    require_relative 'monkey/version'
+
+    #
+    # define the module Typescript::Monkey
+    #
+  end
+end

data/lib/typescript/monkey/cli.rb

@@ -0,0 +1,22 @@
+module Typescript::Monkey
+  require 'open3'
+
+  #
+  # The CLI class.
+  #
+  # A class that implements a basic interface to command line programs.
+  #
+  class CLI
+      # Run a command with arguments
+      #
+      # @return [String, String, Process::Status] stdout, stderr, and the status
+      #   of the command results.
+      #
+      # @see Process::Status
+      #
+      def self.run_command(command, args=[])
+        args_string = args.join(" ")
+        _stdout, _stderr, _status = Open3.capture3("\"#{command}\" #{args_string}")
+      end
+  end
+end

data/lib/typescript/monkey/compiler.rb

@@ -0,0 +1,177 @@
+require 'typescript/monkey'
+require 'typescript/monkey/package'
+
+module Typescript::Monkey::Compiler
+  class TypescriptCompileError < RuntimeError; end
+
+  class << self
+    # Replace relative paths specified in /// <reference path="..." /> with absolute paths.
+    #
+    # @param [String] ts_path Source .ts path
+    # @param [String] source. It might be pre-processed by erb.
+    # @return [String] replaces source
+    #
+    def replace_relative_references(ts_path, source)
+      ts_dir = File.dirname(File.expand_path(ts_path))
+      escaped_dir = ts_dir.gsub(/["\\]/, '\\\\\&') # "\"" => "\\\"", '\\' => '\\\\'
+
+      # Why don't we just use gsub? Because it display odd behavior with File.join on Ruby 2.0
+      # So we go the long way around.
+      (source.each_line.map do |l|
+        if l.starts_with?('///') && !(m = %r!^///\s*<reference\s+path=(?:"([^"]+)"|'([^']+)')\s*/>\s*!.match(l)).nil?
+          matched_path = m.captures.compact[0]
+          l = l.sub(matched_path, File.join(escaped_dir, matched_path))
+        end
+        next l
+      end).join
+    end
+
+    # Get all references
+    #
+    # @param [String] path Source .ts path
+    # @param [String] source. It might be pre-processed by erb.
+    # @yieldreturn [String] matched ref abs_path
+    #
+    def get_all_reference_paths(path, source, visited_paths=Set.new, &block)
+      visited_paths << path
+      source ||= File.read(path)
+      source.each_line do |l|
+        if l.starts_with?('///') && !(m = %r!^///\s*<reference\s+path=(?:"([^"]+)"|'([^']+)')\s*/>\s*!.match(l)).nil?
+          matched_path = m.captures.compact[0]
+          abs_matched_path = File.expand_path(matched_path, File.dirname(path))
+          unless visited_paths.include? abs_matched_path
+            block.call abs_matched_path
+            get_all_reference_paths(abs_matched_path, nil, visited_paths, &block)
+          end
+        end
+      end
+    end
+
+    # Compile source
+    #
+    # @param [String] ts_path
+    # @param [String] source TypeScript source code
+    # @param [Sprockets::Context] sprockets context object
+    # @return [String] compiled JavaScript source code
+    #
+    def compile(ts_path, source, context=nil, *options)
+      if context
+        get_all_reference_paths(File.expand_path(ts_path), source) do |abs_path|
+          context.depend_on abs_path
+        end
+      end
+      begin
+        command_path = Typescript::Monkey::Package.compiler_bin()
+        if command_path.nil?
+          raise RuntimeError, "Failed to find typescript compiler in local or global node environment."
+        end
+
+        log("#{module_name} processing: #{ts_path}")
+
+        # compile file
+        s = replace_relative_references(ts_path, source)
+        source_file = Tempfile.new(["typescript-monkey", ".ts"])
+        source_file.write(s)
+        source_file.close
+        args = Typescript::Monkey.configuration.options.map(&:dup)
+        # _args = [ "--out /dev/stdout", "--noResolve" ]
+        # if self.tsconfig && File.exist?(self.tsconfig)
+        #   _args.push("--project #{self.tsconfig}")
+        # end
+        args.push(source_file.path)
+        compiled_source, _, status = Typescript::Monkey::CLI.run_command(command_path, args)
+
+        filtered_output = nil
+
+        # Parse errors from output: there is no way (currently) to suppress the
+        # errors emitted when passing --noResolve argument to tsc.
+        #
+        # Status values:
+        #   Success = 0
+        #   DiagnosticsPresent_OutputsSkipped = 1
+        #   DiagnosticsPresent_OutputsGenerated = 2
+        #
+        # See: https://github.com/Microsoft/TypeScript/blob/master/src/compiler/types.ts
+        #
+        # Ignore the following error codes:
+        #   TS2304: Cannot find name ...
+        #   TS2307: Cannot find module ...
+        #   TS2318: Cannot find global type ...
+        #   TS2339: Property ... does not exist on type ... **
+        #   TS2468: Cannot find global value ...
+        #   TS2503: Cannot find namespace ...
+        #   TS2662: Cannot find name ...  Did you mean the static member ...
+        #   TS2663: Cannot find name ... Did you mean the instance member ...
+        #   TS2688: Cannot find type definition file for ...
+        #   TS2694: Namespace ... has no exported member ... **
+        #
+        # See: https://github.com/Microsoft/TypeScript/blob/master/src/compiler/diagnosticMessages.json
+        #
+        unless status.success?
+          filtered_output = ""
+          ignore_errors = [
+            "TS2304",
+            "TS2307",
+            "TS2318",
+            "TS2339",
+            "TS2468",
+            "TS2503",
+            "TS2662",
+            "TS2663",
+            "TS2688",
+            "TS2694"
+          ]
+          regex = /#{Regexp.escape(File.basename(source_file))}\(([\d]+,[\d]+)\):[\s]+error[\s]+(TS[\d]+):[\s]+(.*)$/
+          errors = []
+          compiled_source.split("\n").each do |line|
+            if (matches = line.match(regex))
+              errors << {
+                code: matches[2],
+                message: matches[3],
+                line: line,
+                line_position: matches[1]
+              }
+              next
+            end
+            filtered_output << line << "\n"
+          end
+          # iterate over errors and log ignored, raise exception for all others
+          errors.each do |error|
+            log("#{module_name} parsing error for file: #{ts_path}, #{error[:code]}@(#{error[:line_position]}): #{error[:message]}")
+            unless ignore_errors.include?(error[:code])
+              raise TypescriptCompileError, "#{error[:code]}@(#{error[:line_position]}): #{error[:message]}"
+            end
+          end
+        end
+        filtered_output ||= compiled_source
+      rescue StandardError => e
+        raise "Typescript error in file '#{ts_path}':\n#{e.message}"
+      ensure
+        source_file.unlink
+      end
+    end
+
+    private
+
+      # Log a message
+      #
+      # Checks if a logger has been configured before attempting to log.
+      #
+      # @param [String] message to be logged
+      #
+      def log(message)
+        if Typescript::Monkey.configuration.logger
+          Typescript::Monkey.configuration.logger.debug(message)
+        end
+      end
+
+      # Returns module name
+      #
+      # @return [String] module name
+      #
+      def module_name
+        Module.nesting.last
+      end
+  end
+
+end