ruby-requirejs 0.1.0

data/lib/requirejs/runtime/runtime.rb

@@ -0,0 +1,59 @@
+require 'execjs'
+
+module Requirejs
+  # Internal: Module responsible for the ExecJS interaction. Besides handling
+  # the compilation execution, this module provide a runtime validation to ensure
+  # that the Node.JS binary is available to use.
+  class Runtime
+
+    # Internal: Module responsible for the ExecJS interaction. Besides handling
+    # the compilation execution, this module provide a runtime validation to ensure
+    # that the Node.JS binary is available to use.
+    def initialize(build_script)
+      @build_script = build_script
+    end
+
+    # Internal: Calls a specific function on the Node.JS context.
+    #
+    # Example
+    #  exec('version', 2) # => '2'
+    #
+    # Returns The function returned value.
+    def exec(*arguments)
+      check_availability!
+      context.call('optimize')
+    end
+
+    #private
+    # Internal: Queries the runtime for it's availability and raises a 'RuntimeError'
+    # if the runtime isn't available. Otherwise, this is a noop.
+    def check_availability!
+      unless runtime.available?
+        message = 'The Node.JS runtime is not available to RequireJS.'
+        message << 'Ensure that the "node" (or "nodejs") executable is present in your $PATH.'
+        raise RuntimeError, message
+      end
+    end
+
+    # Internal: Compile the Stylus compilation script into a execution context
+    # to execute functions into.
+    #
+    # Returns the compiled context.
+    def context
+      @context ||= runtime.compile(@build_script)
+    end
+
+    # Internal: Create the ExecJS external runtime with a old runner script that
+    # maintains the state of 'require', so we can use it to load modules like on
+    # any Node.JS program.
+    def runtime
+      #@runtime ||= ExecJS::Runtimes::Node
+      @runtime ||= ExecJS::ExternalRuntime.new(
+          :name => 'Node.js (V8)',
+          :command => %w{nodejs node},
+          :runner_path => File.expand_path('../node_runner.js', __FILE__),
+          :encoding => 'UTF-8'
+      )
+    end
+  end
+end

data/lib/requirejs/tilt/directive_processor.rb

@@ -0,0 +1,52 @@
+require 'tilt'
+# Public: A Tilt template to compile Stylus stylesheets.
+#
+# Examples
+#
+#  template = Tilt::StylusTemplate.new { |t| File.read('app.styl') }
+#  template.render # => the compiled CSS from the app.styl file.
+#
+#  Options should assigned on the template constructor.
+#  template = Tilt::StylusTemplate.new(compress: true) { |t| File.read('app.styl') }
+#  template.render # => the compiled CSS with compression enabled.
+module Requirejs
+  module Tilt
+    class DirectiveProcessor < ::Sprockets::DirectiveProcessor
+
+      # Internal: Compile the template Stylus using this instance options.
+      # The current 'scope' and given 'locals' are ignored and the output
+      # is cached.
+      #
+      # Returns a String with the compiled stylesheet with CSS syntax.
+      def evaluate(scope, locals, &block)
+        @result = super
+        if process_rjs?
+          Requirejs.config.setup_directories
+          dump_config
+        end
+        @result
+      end
+
+      def dump_config
+        process_include_directive(name)
+        ::Requirejs::BuildConfig.new(file).save({ 'include' => @include_modules })
+      end
+
+      protected
+
+      def process_rjs_directive(*args)
+        @rjs_directive_present = directives.any? { |directive| directive[1] == 'rjs' }
+      end
+
+      def process_include_directive(mod)
+        @include_modules ||= []
+        @include_modules << mod
+      end
+
+      def process_rjs?
+        @rjs_directive_present
+      end
+
+    end
+  end
+end

data/lib/requirejs/tilt/template.rb

@@ -0,0 +1,37 @@
+require 'tilt'
+# Public: A Tilt template to compile Stylus stylesheets.
+#
+# Examples
+#
+#  template = Tilt::StylusTemplate.new { |t| File.read('app.styl') }
+#  template.render # => the compiled CSS from the app.styl file.
+#
+#  Options should assigned on the template constructor.
+#  template = Tilt::StylusTemplate.new(compress: true) { |t| File.read('app.styl') }
+#  template.render # => the compiled CSS with compression enabled.
+module Requirejs
+  module Tilt
+    class Template < ::Tilt::Template
+
+      def prepare
+      end
+
+      # Internal: Compile the template Stylus using this instance options.
+      # The current 'scope' and given 'locals' are ignored and the output
+      # is cached.
+      #
+      # Returns a String with the compiled stylesheet with CSS syntax.
+      def evaluate(scope, locals, &block)
+        if ::Requirejs::BuildConfig.new(file).exists?
+          compiler = ::Requirejs::Compiler.new(scope: scope, data: data, file: file)
+          @output ||= compiler.exec
+        else
+          @output ||= data
+        end
+      end
+
+    end
+  end
+end
+
+Tilt.register Requirejs::Tilt::Template, 'js'

data/lib/requirejs/version.rb

@@ -0,0 +1,5 @@
+module Ruby
+  module Requirejs
+    VERSION = '0.1.0'
+  end
+end

data/lib/ruby-requirejs.rb

@@ -0,0 +1,26 @@
+require 'requirejs/version'
+require 'requirejs/config'
+require 'requirejs/manifest'
+require 'requirejs/runtime/runtime'
+require 'requirejs/builds/build_config'
+require 'requirejs/builds/build'
+require 'requirejs/builds/optimized_build'
+require 'requirejs/compiler'
+
+if defined?(Rails)
+  require 'requirejs/engine'
+else
+  Requirejs.config = Requirejs::Config.new
+end
+
+# Loading ActionView helpers
+if defined?(::ActionView)
+  require 'requirejs/action_view/tag_helper'
+  ::Requirejs::ActionView.constants.each do |k|
+    klass = ::Requirejs::ActionView.const_get(k)
+    ActionView::Base.send(:include, klass) if klass.is_a?(Module)
+  end
+end
+
+module Requirejs
+end

data/ruby-requirejs.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'requirejs/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ruby-requirejs'
+  spec.version       = Ruby::Requirejs::VERSION
+  spec.authors       = ['Alex Krasinsky']
+  spec.email         = ['lyoshakr@gmail.com']
+  spec.summary       = %q{Ruby/Rails requirejs compiler}
+  spec.description   = %q{Support of requirejs in ruby/rails projects}
+  spec.homepage      = 'https://github.com/spilin/ruby-requirejs'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'rails', '>= 4.0.0'
+
+  spec.add_dependency 'execjs'
+end

data/spec/cases/basic/in/app.js

@@ -0,0 +1,10 @@
+define([], function () {
+
+  // initialize Application
+  var initialize = function () {
+  };
+
+  return {
+    initialize: initialize
+  };
+});

data/spec/cases/basic/in/application.js

@@ -0,0 +1,7 @@
+//= rjs
+
+require.config({});
+
+require(["app"], function (App) {
+  App.initialize();
+});

data/spec/cases/basic/out/application.js

@@ -0,0 +1,6 @@
+
+require.config({});
+
+require(["app"], function (App) {
+  App.initialize();
+});

data/spec/cases/basic_almond/in/app.js

@@ -0,0 +1,10 @@
+define([], function () {
+
+  // initialize Application
+  var initialize = function () {
+  };
+
+  return {
+    initialize: initialize
+  };
+});

data/spec/cases/basic_almond/in/application.js

@@ -0,0 +1,7 @@
+//= rjs
+
+require.config({});
+
+require(["app"], function (App) {
+  App.initialize();
+});

data/spec/cases/basic_almond/out/application.js

@@ -0,0 +1,447 @@
+(function () {
+/**
+ * @license almond 0.2.9 Copyright (c) 2011-2014, The Dojo Foundation All Rights Reserved.
+ * Available via the MIT or new BSD license.
+ * see: http://github.com/jrburke/almond for details
+ */
+//Going sloppy to avoid 'use strict' string cost, but strict practices should
+//be followed.
+/*jslint sloppy: true */
+/*global setTimeout: false */
+
+
+var requirejs, require, define;
+(function (undef) {
+  var main, req, makeMap, handlers,
+    defined = {},
+    waiting = {},
+    config = {},
+    defining = {},
+    hasOwn = Object.prototype.hasOwnProperty,
+    aps = [].slice,
+    jsSuffixRegExp = /\.js$/;
+
+  function hasProp(obj, prop) {
+    return hasOwn.call(obj, prop);
+  }
+
+  /**
+   * Given a relative module name, like ./something, normalize it to
+   * a real name that can be mapped to a path.
+   * @param {String} name the relative name
+   * @param {String} baseName a real name that the name arg is relative
+   * to.
+   * @returns {String} normalized name
+   */
+  function normalize(name, baseName) {
+    var nameParts, nameSegment, mapValue, foundMap, lastIndex,
+      foundI, foundStarMap, starI, i, j, part,
+      baseParts = baseName && baseName.split("/"),
+      map = config.map,
+      starMap = (map && map['*']) || {};
+
+    //Adjust any relative paths.
+    if (name && name.charAt(0) === ".") {
+      //If have a base name, try to normalize against it,
+      //otherwise, assume it is a top-level require that will
+      //be relative to baseUrl in the end.
+      if (baseName) {
+        //Convert baseName to array, and lop off the last part,
+        //so that . matches that "directory" and not name of the baseName's
+        //module. For instance, baseName of "one/two/three", maps to
+        //"one/two/three.js", but we want the directory, "one/two" for
+        //this normalization.
+        baseParts = baseParts.slice(0, baseParts.length - 1);
+        name = name.split('/');
+        lastIndex = name.length - 1;
+
+        // Node .js allowance:
+        if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
+          name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
+        }
+
+        name = baseParts.concat(name);
+
+        //start trimDots
+        for (i = 0; i < name.length; i += 1) {
+          part = name[i];
+          if (part === ".") {
+            name.splice(i, 1);
+            i -= 1;
+          } else if (part === "..") {
+            if (i === 1 && (name[2] === '..' || name[0] === '..')) {
+              //End of the line. Keep at least one non-dot
+              //path segment at the front so it can be mapped
+              //correctly to disk. Otherwise, there is likely
+              //no path mapping for a path starting with '..'.
+              //This can still fail, but catches the most reasonable
+              //uses of ..
+              break;
+            } else if (i > 0) {
+              name.splice(i - 1, 2);
+              i -= 2;
+            }
+          }
+        }
+        //end trimDots
+
+        name = name.join("/");
+      } else if (name.indexOf('./') === 0) {
+        // No baseName, so this is ID is resolved relative
+        // to baseUrl, pull off the leading dot.
+        name = name.substring(2);
+      }
+    }
+
+    //Apply map config if available.
+    if ((baseParts || starMap) && map) {
+      nameParts = name.split('/');
+
+      for (i = nameParts.length; i > 0; i -= 1) {
+        nameSegment = nameParts.slice(0, i).join("/");
+
+        if (baseParts) {
+          //Find the longest baseName segment match in the config.
+          //So, do joins on the biggest to smallest lengths of baseParts.
+          for (j = baseParts.length; j > 0; j -= 1) {
+            mapValue = map[baseParts.slice(0, j).join('/')];
+
+            //baseName segment has  config, find if it has one for
+            //this name.
+            if (mapValue) {
+              mapValue = mapValue[nameSegment];
+              if (mapValue) {
+                //Match, update name to the new value.
+                foundMap = mapValue;
+                foundI = i;
+                break;
+              }
+            }
+          }
+        }
+
+        if (foundMap) {
+          break;
+        }
+
+        //Check for a star map match, but just hold on to it,
+        //if there is a shorter segment match later in a matching
+        //config, then favor over this star map.
+        if (!foundStarMap && starMap && starMap[nameSegment]) {
+          foundStarMap = starMap[nameSegment];
+          starI = i;
+        }
+      }
+
+      if (!foundMap && foundStarMap) {
+        foundMap = foundStarMap;
+        foundI = starI;
+      }
+
+      if (foundMap) {
+        nameParts.splice(0, foundI, foundMap);
+        name = nameParts.join('/');
+      }
+    }
+
+    return name;
+  }
+
+  function makeRequire(relName, forceSync) {
+    return function () {
+      //A version of a require function that passes a moduleName
+      //value for items that may need to
+      //look up paths relative to the moduleName
+      return req.apply(undef, aps.call(arguments, 0).concat([relName, forceSync]));
+    };
+  }
+
+  function makeNormalize(relName) {
+    return function (name) {
+      return normalize(name, relName);
+    };
+  }
+
+  function makeLoad(depName) {
+    return function (value) {
+      defined[depName] = value;
+    };
+  }
+
+  function callDep(name) {
+    if (hasProp(waiting, name)) {
+      var args = waiting[name];
+      delete waiting[name];
+      defining[name] = true;
+      main.apply(undef, args);
+    }
+
+    if (!hasProp(defined, name) && !hasProp(defining, name)) {
+      throw new Error('No ' + name);
+    }
+    return defined[name];
+  }
+
+  //Turns a plugin!resource to [plugin, resource]
+  //with the plugin being undefined if the name
+  //did not have a plugin prefix.
+  function splitPrefix(name) {
+    var prefix,
+      index = name ? name.indexOf('!') : -1;
+    if (index > -1) {
+      prefix = name.substring(0, index);
+      name = name.substring(index + 1, name.length);
+    }
+    return [prefix, name];
+  }
+
+  /**
+   * Makes a name map, normalizing the name, and using a plugin
+   * for normalization if necessary. Grabs a ref to plugin
+   * too, as an optimization.
+   */
+  makeMap = function (name, relName) {
+    var plugin,
+      parts = splitPrefix(name),
+      prefix = parts[0];
+
+    name = parts[1];
+
+    if (prefix) {
+      prefix = normalize(prefix, relName);
+      plugin = callDep(prefix);
+    }
+
+    //Normalize according
+    if (prefix) {
+      if (plugin && plugin.normalize) {
+        name = plugin.normalize(name, makeNormalize(relName));
+      } else {
+        name = normalize(name, relName);
+      }
+    } else {
+      name = normalize(name, relName);
+      parts = splitPrefix(name);
+      prefix = parts[0];
+      name = parts[1];
+      if (prefix) {
+        plugin = callDep(prefix);
+      }
+    }
+
+    //Using ridiculous property names for space reasons
+    return {
+      f: prefix ? prefix + '!' + name : name, //fullName
+      n: name,
+      pr: prefix,
+      p: plugin
+    };
+  };
+
+  function makeConfig(name) {
+    return function () {
+      return (config && config.config && config.config[name]) || {};
+    };
+  }
+
+  handlers = {
+    require: function (name) {
+      return makeRequire(name);
+    },
+    exports: function (name) {
+      var e = defined[name];
+      if (typeof e !== 'undefined') {
+        return e;
+      } else {
+        return (defined[name] = {});
+      }
+    },
+    module: function (name) {
+      return {
+        id: name,
+        uri: '',
+        exports: defined[name],
+        config: makeConfig(name)
+      };
+    }
+  };
+
+  main = function (name, deps, callback, relName) {
+    var cjsModule, depName, ret, map, i,
+      args = [],
+      callbackType = typeof callback,
+      usingExports;
+
+    //Use name if no relName
+    relName = relName || name;
+
+    //Call the callback to define the module, if necessary.
+    if (callbackType === 'undefined' || callbackType === 'function') {
+      //Pull out the defined dependencies and pass the ordered
+      //values to the callback.
+      //Default to [require, exports, module] if no deps
+      deps = !deps.length && callback.length ? ['require', 'exports', 'module'] : deps;
+      for (i = 0; i < deps.length; i += 1) {
+        map = makeMap(deps[i], relName);
+        depName = map.f;
+
+        //Fast path CommonJS standard dependencies.
+        if (depName === "require") {
+          args[i] = handlers.require(name);
+        } else if (depName === "exports") {
+          //CommonJS module spec 1.1
+          args[i] = handlers.exports(name);
+          usingExports = true;
+        } else if (depName === "module") {
+          //CommonJS module spec 1.1
+          cjsModule = args[i] = handlers.module(name);
+        } else if (hasProp(defined, depName) ||
+          hasProp(waiting, depName) ||
+          hasProp(defining, depName)) {
+          args[i] = callDep(depName);
+        } else if (map.p) {
+          map.p.load(map.n, makeRequire(relName, true), makeLoad(depName), {});
+          args[i] = defined[depName];
+        } else {
+          throw new Error(name + ' missing ' + depName);
+        }
+      }
+
+      ret = callback ? callback.apply(defined[name], args) : undefined;
+
+      if (name) {
+        //If setting exports via "module" is in play,
+        //favor that over return value and exports. After that,
+        //favor a non-undefined return value over exports use.
+        if (cjsModule && cjsModule.exports !== undef &&
+          cjsModule.exports !== defined[name]) {
+          defined[name] = cjsModule.exports;
+        } else if (ret !== undef || !usingExports) {
+          //Use the return value from the function.
+          defined[name] = ret;
+        }
+      }
+    } else if (name) {
+      //May just be an object definition for the module. Only
+      //worry about defining if have a module name.
+      defined[name] = callback;
+    }
+  };
+
+  requirejs = require = req = function (deps, callback, relName, forceSync, alt) {
+    if (typeof deps === "string") {
+      if (handlers[deps]) {
+        //callback in this case is really relName
+        return handlers[deps](callback);
+      }
+      //Just return the module wanted. In this scenario, the
+      //deps arg is the module name, and second arg (if passed)
+      //is just the relName.
+      //Normalize module name, if it contains . or ..
+      return callDep(makeMap(deps, callback).f);
+    } else if (!deps.splice) {
+      //deps is a config object, not an array.
+      config = deps;
+      if (config.deps) {
+        req(config.deps, config.callback);
+      }
+      if (!callback) {
+        return;
+      }
+
+      if (callback.splice) {
+        //callback is an array, which means it is a dependency list.
+        //Adjust args if there are dependencies
+        deps = callback;
+        callback = relName;
+        relName = null;
+      } else {
+        deps = undef;
+      }
+    }
+
+    //Support require(['a'])
+    callback = callback || function () {
+    };
+
+    //If relName is a function, it is an errback handler,
+    //so remove it.
+    if (typeof relName === 'function') {
+      relName = forceSync;
+      forceSync = alt;
+    }
+
+    //Simulate async callback;
+    if (forceSync) {
+      main(undef, deps, callback, relName);
+    } else {
+      //Using a non-zero value because of concern for what old browsers
+      //do, and latest browsers "upgrade" to 4 if lower value is used:
+      //http://www.whatwg.org/specs/web-apps/current-work/multipage/timers.html#dom-windowtimers-settimeout:
+      //If want a value immediately, use require('id') instead -- something
+      //that works in almond on the global level, but not guaranteed and
+      //unlikely to work in other AMD implementations.
+      setTimeout(function () {
+        main(undef, deps, callback, relName);
+      }, 4);
+    }
+
+    return req;
+  };
+
+  /**
+   * Just drops the config on the floor, but returns req in case
+   * the config return value is used.
+   */
+  req.config = function (cfg) {
+    return req(cfg);
+  };
+
+  /**
+   * Expose module registry for debugging and tooling
+   */
+  requirejs._defined = defined;
+
+  define = function (name, deps, callback) {
+
+    //This module may not have dependencies
+    if (!deps.splice) {
+      //deps is not an array, so probably means
+      //an object literal or factory function for
+      //the value. Adjust args.
+      callback = deps;
+      deps = [];
+    }
+
+    if (!hasProp(defined, name) && !hasProp(waiting, name)) {
+      waiting[name] = [name, deps, callback];
+    }
+  };
+
+  define.amd = {
+    jQuery: true
+  };
+}());
+
+define("almond", function(){});
+
+define('app',[], function () {
+
+  // initialize Application
+  var initialize = function () {
+  };
+
+  return {
+    initialize: initialize
+  };
+});
+
+
+require.config({});
+
+require(["app"], function (App) {
+  App.initialize();
+});
+
+define("application", function(){});
+}());