modulr 0.3.0 → 0.4.0

data/Rakefile

@@ -11,20 +11,31 @@ task :build_example do
   end
 end
 
+desc "Concatenate synchronous example file"
+task :build_sync_example do
+  File.open(File.join('output', 'example.js'), 'w') do |f|
+    f << Modulr.ize(File.join('example', 'program.js'), { :global => 'foo' })
+  end
+end
+
+desc "Concatenate synchronous example file"
+task :test do
+  Modulr.ize(File.join('example', 'program.js'))
+end
+
 desc "Run CommonJS Module 1.0 specs"
 task :spec do
   specs = ENV["SPECS"] || "**"
-  
   FileList["#{COMMONJS_SPEC_DIR}/{#{specs}}/program.js"].each do |spec|
     dir = File.dirname(spec)
     output = File.join(dir, 'output.js')
+    input = File.join(dir, 'input.js')
     system = File.join(dir, 'system.js')
     FileUtils.touch(system)
     begin
       puts File.basename(dir).center(80, "_")
-      File.open(output, 'w') do |f|
-        f << Modulr.ize(spec)
-      end
+      File.open(input, 'w') { |f| f << "require('program');" }
+      File.open(output, 'w') { |f| f << Modulr.ize(input) }
       system("js -f #{output}")
     rescue => e
       phase = e.is_a?(Modulr::ModulrError) ? "building" : "running"
@@ -32,6 +43,7 @@ task :spec do
       puts e.message
     ensure
       FileUtils.rm(output)
+      FileUtils.rm(input)
       FileUtils.rm(system)
       puts
       puts
@@ -46,9 +58,10 @@ begin
     gemspec.summary = "A CommonJS module implementation in Ruby for client-side JavaScript"
     gemspec.author = "Tobie Langel"
     gemspec.email = "tobie.langel@gmail.com"
-    gemspec.homepage = "http://github.com/tobie/modulr"
+    gemspec.homepage = "http://github.com/codespeaks/modulr"
     gemspec.files = FileList["Rakefile", "README.markdown", "LICENSE", "VERSION", "{lib,bin,assets,example}/**/*", "vendor/rkelly/**/*"]
     gemspec.executable = "modulrize"
+    gemspec.add_dependency("coffee_machine")
   end
 rescue LoadError
   puts "Jeweler not available. Install it with: sudo gem install jeweler"

data/VERSION

@@ -1 +1 @@
-0.3.0
+0.4.0

data/assets/modulr.js

@@ -4,45 +4,92 @@
 //   http://github.com/codespeaks/modulr/blob/master/LICENSE
 
 var modulr = (function(global) {
-  var _modules = {},
-      _moduleObjects = {},
+  var _dependencyGraph = {},
+      _loadingFactories = {},
+      _incompleteFactories = {},
+      _factories = {},
+      _modules = {},
       _exports = {},
-      _oldDir = '',
-      _currentDir = '',
+      _handlers = [],
+      _dirStack = [''],
       PREFIX = '__module__', // Prefix identifiers to avoid issues in IE.
-      RELATIVE_IDENTIFIER_PATTERN = /^\.\.?\//;
+      RELATIVE_IDENTIFIER_PATTERN = /^\.\.?\//,
+      _forEach,
+      _indexOf;
+      
+  _forEach = (function() {
+    var hasOwnProp = Object.prototype.hasOwnProperty,
+        DONT_ENUM_PROPERTIES = [
+          'constructor', 'toString', 'toLocaleString', 'valueOf',
+          'hasOwnProperty','isPrototypeOf', 'propertyIsEnumerable'
+        ],
+        LENGTH = DONT_ENUM_PROPERTIES.length,
+        DONT_ENUM_BUG = true;
+    
+    function _forEach(obj, callback) {
+      for(var prop in obj) {
+        if (hasOwnProp.call(obj, prop)) {
+          callback(prop, obj[prop]);
+        }
+      }
+    }
+    
+    for(var prop in { toString: true }) {
+      DONT_ENUM_BUG = false
+    }
+    
+    if (DONT_ENUM_BUG) {
+      return function(obj, callback) {
+         _forEach(obj, callback);
+         for (var i = 0; i < LENGTH; i++) {
+           var prop = DONT_ENUM_PROPERTIES[i];
+           if (hasOwnProp.call(obj, prop)) {
+             callback(prop, obj[prop]);
+           }
+         }
+       }
+    }
+    
+    return _forEach;
+  })();
   
-  function log(str) {
-    if (global.console && console.log) { console.log(str); }
-  }
+  _indexOf = (function() {
+    var nativeIndexOf = Array.prototype.indexOf;
+    if (typeof nativeIndexOf === 'function') {
+      return function(array, item) {
+        return nativeIndexOf.call(array, item);
+      }
+    }
+    
+    return function(array, item) {
+      for (var i = 0, length = array.length; i < length; i++) {
+        if (item === array[i]) { return i; }
+      }
+      return -1;
+    }
+  })();
   
   function require(identifier) {
-    var fn, modObj,
+    var fn, mod,
         id = resolveIdentifier(identifier),
         key = PREFIX + id,
         expts = _exports[key];
     
-    log('Required module "' + identifier + '".');
-    
     if (!expts) {
       _exports[key] = expts = {};
-      _moduleObjects[key] = modObj = { id: id };
-      
-      if (!require.main) { require.main = modObj; }
-      
-      fn = _modules[key];
-      _oldDir = _currentDir;
-      _currentDir = id.slice(0, id.lastIndexOf('/'));
+      _modules[key] = mod = { id: id };
       
+      fn = _factories[key];
+      _dirStack.push(id.substring(0, id.lastIndexOf('/') + 1))
       try {
         if (!fn) { throw 'Can\'t find module "' + identifier + '".'; }
         if (typeof fn === 'string') {
           fn = new Function('require', 'exports', 'module', fn);
         }
-        fn(require, expts, modObj);
-        _currentDir = _oldDir;
+        fn(require, expts, mod);
+        _dirStack.pop();
       } catch(e) {
-        _currentDir = _oldDir;
+        _dirStack.pop();
         // We'd use a finally statement here if it wasn't for IE.
         throw e;
       }
@@ -51,13 +98,13 @@ var modulr = (function(global) {
   }
   
   function resolveIdentifier(identifier) {
-    var parts, part, path;
+    var dir, parts, part, path;
     
     if (!RELATIVE_IDENTIFIER_PATTERN.test(identifier)) {
       return identifier;
     }
-    
-    parts = (_currentDir + '/' + identifier).split('/');
+    dir = _dirStack[_dirStack.length - 1];
+    parts = (dir + identifier).split('/');
     path = [];
     for (var i = 0, length = parts.length; i < length; i++) {
       part = parts[i];
@@ -75,18 +122,139 @@ var modulr = (function(global) {
     return path.join('/');
   }
   
-  function cache(id, fn) {
-    var key = PREFIX + id;
+  function define(descriptors, dependencies) {
+    var missingDependencies;
+    if (dependencies) {
+      // Check to see if any of the required dependencies 
+      // weren't previously loaded.
+      // Build an array of missing dependencies with those which weren't.
+      for (var i = 0, length = dependencies.length; i < length; i++) {
+        var key = PREFIX + dependencies[i];
+        if (!(key in _factories) && !(key in _incompleteFactories)) {
+          missingDependencies = missingDependencies || [];
+          missingDependencies.push(key);
+        }
+      }
+    }
+    
+    if (missingDependencies) {
+      // Add each newly defined descriptor to our list of
+      // factories missing dependencies.
+      // Build a dependency graph so we can handle subsequent 
+      // require.define calls easily.
+      _forEach(descriptors, function(id, factory) {
+        var key = PREFIX + id;
+        _dependencyGraph[key] = missingDependencies; // TODO clone?
+        _incompleteFactories[key] = factory;
+      });
+      // load the missing modules.
+      loadModules(missingDependencies);
+    } else {
+      // There aren't any missing dependencies in the factories
+      // which were just defined. Lets move them to a list of
+      // synchronously requirable factories.
+      prepare(descriptors);
+      // While we're at it, let's call all async handlers whose
+      // dependencies are now available.
+      callRipeHandlers();
+    }
+  }
+  
+  function prepare(descriptors) {
+    // Handles factories for which all dependencies are
+    // available.
+    _forEach(descriptors, function(id, factory) {
+      var key = PREFIX + id;
+      // Move the factory from the list of factories missing
+      // dependencies to the list of synchronously requirable
+      // factories.
+      _factories[key] = factory;
+      delete _incompleteFactories[key];
+      // Go through the dependency graph and remove the factory
+      // from all of the missing dependencies lists.
+      _forEach(_dependencyGraph, function(unused, dependencies) {
+        var i = _indexOf(i, key);
+        if (i > -1) { dependencies.splice(i, 1); }
+      });
+    });
+    
+    // Find all the factories which no longer have missing dependencies.
+    var newFactories;
+    _forEach(_dependencyGraph, function(key, dependencies) {
+      if (dependencies.length === 0) {
+        newFactories = newFactories || {};
+        newFactories[key] = _incompleteFactories[key];
+        delete _dependencyGraph[key];
+      }
+    });
+    // recurse!
+    if (newFactories) { prepare(newFactories); }
+  }
+  
+  function ensure(dependencies, callback, errorCallback) {
+    // Cache this new handler.
+    _handlers.push({
+      dependencies: dependencies,
+      callback: callback,
+      errorCallback: errorCallback
+    });
+    
+    // Immediately callRipeHandlers(): you never know,
+    // all of the required dependencies might be already
+    // available.
+    callRipeHandlers();
+  }
+  
+  function callRipeHandlers() {
+    var missingFactories;
     
-    log('Cached module "' + id + '".');
-    if (_modules[key]) {
-      throw 'Can\'t overwrite module "' + id + '".';
+    for (var i = 0, length = _handlers.length; i < length; i++) {
+      // Go through all of the stored handlers.
+      var handler = _handlers[i],
+          dependencies = handler.dependencies,
+          isRipe = true;
+      for (var j = 0, reqLength = dependencies.length; j < reqLength; j++) {
+        var id = dependencies[j];
+        // If any dependency is missing, the handler isn't ready to be called.
+        // Store those missing so we can later inform the loader.
+        if (!_factories[PREFIX + id]) {
+          missingFactories = missingFactories || [];
+          if (_indexOf(missingFactories, id) < 0) {
+            missingFactories.push(id);
+          }
+          isRipe = false;
+        }
+      }
+      
+      if (isRipe) {
+        handler.callback(); // TODO error handling
+      }
+    }
+    
+    if (missingFactories) {
+      loadModules(missingFactories);
     }
-    _modules[key] = fn;
   }
   
+  function loadModules(factories) {
+    var missingFactories;
+    for (var i = 0, length = factories.length; i < length; i++) {
+      var factory = factories[i];
+      if (!(factory in _loadingFactories)) {
+        missingFactories = missingFactories || [];
+        missingFactories.push(factory);
+      }
+    }
+    if (missingFactories) {
+      console.log(missingFactories);
+    }
+  }
+  
+  require.define = define;
+  require.ensure = ensure;
+  require.main = {};
+  
   return {
-    require: require,
-    cache: cache
+    require: require
   };
 })(this);

data/assets/modulr.sync.js

@@ -0,0 +1,116 @@
+// modulr.sync.js (c) 2010 codespeaks sàrl
+// Freely distributable under the terms of the MIT license.
+// For details, see:
+//   http://github.com/codespeaks/modulr/blob/master/LICENSE
+
+var require = (function() {
+  var _factories = {},
+      _modules = {},
+      _exports = {},
+      _handlers = [],
+      _dirStack = [''],
+      PREFIX = '__module__', // Prefix identifiers to avoid issues in IE.
+      RELATIVE_IDENTIFIER_PATTERN = /^\.\.?\//,
+      _forEach;
+      
+  _forEach = (function() {
+    var hasOwnProp = Object.prototype.hasOwnProperty,
+        DONT_ENUM_PROPERTIES = [
+          'constructor', 'toString', 'toLocaleString', 'valueOf',
+          'hasOwnProperty','isPrototypeOf', 'propertyIsEnumerable'
+        ],
+        LENGTH = DONT_ENUM_PROPERTIES.length,
+        DONT_ENUM_BUG = true;
+    
+    function _forEach(obj, callback) {
+      for(var prop in obj) {
+        if (hasOwnProp.call(obj, prop)) {
+          callback(prop, obj[prop]);
+        }
+      }
+    }
+    
+    for(var prop in { toString: true }) {
+      DONT_ENUM_BUG = false
+    }
+    
+    if (DONT_ENUM_BUG) {
+      return function(obj, callback) {
+         _forEach(obj, callback);
+         for (var i = 0; i < LENGTH; i++) {
+           var prop = DONT_ENUM_PROPERTIES[i];
+           if (hasOwnProp.call(obj, prop)) {
+             callback(prop, obj[prop]);
+           }
+         }
+       }
+    }
+    
+    return _forEach;
+  })();
+  
+  function require(identifier) {
+    var fn, mod,
+        id = resolveIdentifier(identifier),
+        key = PREFIX + id,
+        expts = _exports[key];
+    
+    if (!expts) {
+      _exports[key] = expts = {};
+      _modules[key] = mod = { id: id };
+      
+      fn = _factories[key];
+      _dirStack.push(id.substring(0, id.lastIndexOf('/') + 1))
+      
+      try {
+        if (!fn) { throw 'Can\'t find module "' + identifier + '".'; }
+        if (typeof fn === 'string') {
+          fn = new Function('require', 'exports', 'module', fn);
+        }
+        if (!require.main) { require.main = mod; }
+        fn(require, expts, mod);
+        _dirStack.pop();
+      } catch(e) {
+        _dirStack.pop();
+        // We'd use a finally statement here if it wasn't for IE.
+        throw e;
+      }
+    }
+    return expts;
+  }
+  
+  function resolveIdentifier(identifier) {
+    var dir, parts, part, path;
+    
+    if (!RELATIVE_IDENTIFIER_PATTERN.test(identifier)) {
+      return identifier;
+    }
+    dir = _dirStack[_dirStack.length - 1];
+    parts = (dir + identifier).split('/');
+    path = [];
+    for (var i = 0, length = parts.length; i < length; i++) {
+      part = parts[i];
+      switch (part) {
+        case '':
+        case '.':
+          continue;
+        case '..':
+          path.pop();
+          break;
+        default:
+          path.push(part);
+      }
+    }
+    return path.join('/');
+  }
+  
+  function define(descriptors) {
+    _forEach(descriptors, function(id, factory) {
+      _factories[PREFIX + id] = factory;
+    });
+  }
+  
+  require.define = define;
+  
+  return require;
+})();

data/bin/modulrize

@@ -9,6 +9,9 @@ options = {
 opts = OptionParser.new do |opts|
   opts.banner = 'Usage: modulrize program.js [options] > output.js'
   
+  opts.separator ''
+  opts.separator 'Options:'
+  
   opts.on('-o', '--output=FILE', 'Write the output to FILE. Defaults to stdout.') do |output|
     options[:output] = File.open(output, 'w')
   end
@@ -24,10 +27,48 @@ opts = OptionParser.new do |opts|
     options[:lazy_eval] = modules
   end
   
-  opts.on_tail('-h', '--help', 'Show this message.') do
+  opts.on('--minify', 'Minify output using YUI Compressor.') do |minify|
+    options[:minify] = minify
+  end
+  
+  opts.on('--global-export=GLOBAL_VAR', 'Export main module\'s exports to the GLOBAL_VAR global variable.') do |global|
+    options[:global] = global
+  end
+  
+  opts.on('--dependency-graph[=OUTPUT]', 'Create a dependency graph of the module.') do |output|
+    options[:dependency_graph] = true
+    options[:output] = output
+  end
+  
+  opts.on('-h', '--help', 'Show this message.') do
     puts opts
     exit
   end
+  
+  opts.separator ''
+  opts.separator 'Minification options (these are forwarded to YUI Compressor without the "minify-" prefix):'
+  
+  {
+    'line-break COLUMN'     => 'Insert a line break after the specified column number.',
+    'verbose'               => 'Display informational messages and warnings.',
+    'nomunge'               => 'Minify only, do not obfuscate.',
+    'preserve-semi'         => 'Preserve all semicolons.',
+    'disable-optimizations' => 'Disable all micro optimizations.'
+  }.each do |option, message|
+    prefixed_option = option.sub(/\A(\[no-\])?/, '--\\1minify-')
+    
+    def normalize_option(option)
+      option.gsub('-', '_').to_sym
+    end
+    
+    opts.on(prefixed_option, message) do |value|
+      if !options[:minify] || options[:minify] == true
+        options[:minify] = {}
+      end
+      options[:minify][normalize_option(option)] = value
+    end
+  end
+
 end
 
 opts.parse!
@@ -39,8 +80,12 @@ begin
     puts opts
     exit 1
   end
-  result = Modulr.ize(ARGV.first, options)
-  output.print(result)
+  if options.delete(:dependency_graph)
+    result = Modulr.graph(ARGV.first, options)
+  else
+    result = Modulr.ize(ARGV.first, options)
+    output.print(result)
+  end
 ensure
   output.close
 end

data/lib/modulr/collector.rb

@@ -18,14 +18,22 @@ module Modulr
     
     def to_js(buffer = '')
       buffer << File.read(PATH_TO_MODULR_JS)
-      modules.each do |js_module|
-        if lazy_eval_module?(js_module)
-          js_module.to_js_string(buffer)
+      buffer << "\n(function(require, module) {"
+      buffer << transport
+      buffer << main.ensure
+      buffer << "})(modulr.require, modulr.require.main);\n"
+    end
+    
+    def transport
+      pairs = modules.map do |m|
+        if lazy_eval_module?(m)
+          value = m.escaped_src
         else
-          js_module.to_js(buffer)
+          value = m.factory
         end
+        "\n'#{m.id}': #{value}"        
       end
-      buffer << "\nmodulr.require('#{main.identifier}');\n"
+      "require.define({#{pairs.join(', ')}\n});"
     end
     
     private

data/lib/modulr/dependency_graph.rb

@@ -0,0 +1,86 @@
+require 'uri'
+module Modulr
+  class DependencyGraph
+    def initialize(js_modules)
+      if js_modules.is_a?(Array)
+        @js_modules = js_modules
+      else
+        @js_modules = [js_modules]
+      end
+    end
+    
+    def to_tree
+      return @tree if @tree
+      @tree = {}
+      @stack = []
+      build_branch(@js_modules, @tree)
+      @tree
+    end
+    
+    def to_list
+      return @list if @list
+      @list = {}
+      @js_modules.each { |m| build_list(m) }
+      @list
+    end
+    
+    def to_yuml(options = {})
+      options = {
+        :ext => 'png',
+        :dir => 'lr',
+        :scale => 100,
+        :scruffy => true
+      }.merge(options)
+      dep = @js_modules.map { |m| "[#{m.id}]" }
+      to_list.map do |k, v|
+        if v
+          v.each do |i|
+            if @list[i]
+              dep << "[#{k}]->[#{i}]"
+            else
+              dep << "[#{k}]-.-Missing>[#{i}{bg:red}]"
+            end
+          end
+        end
+      end
+      opts = []
+      opts << "scruffy" if options[:scruffy]
+      opts << "dir:#{options[:dir]}"
+      opts << "scale:#{options[:scale]}"
+      
+      uri = "http://yuml.me/diagram/"
+      uri << opts.join(';')
+      uri << "/class/"
+      uri << dep.join(',')
+      uri << ".#{options[:ext]}"
+      URI.encode(uri).gsub('[', '%5B').gsub(']', '%5D')
+    end
+    
+    private
+      def build_branch(js_modules, branch)
+        js_modules.each do |m|
+          id = m.id
+          branch[id] = {}
+          unless @stack.include?(id)
+            @stack << id
+            build_branch(m.dependencies, branch[id])
+          end
+        end
+      end
+      
+      def build_list(js_module)
+        begin
+          list = @list[js_module.id] ||= []
+          js_module.dependencies.each do |m|
+            id = m.id
+            unless list.include?(id)
+              list << id
+              build_list(m)
+            end
+          end
+        rescue
+          @list[js_module.id] = false
+        end
+      end
+  end
+end

data/lib/modulr/global_export_collector.rb

@@ -0,0 +1,32 @@
+module Modulr
+  class GlobalExportCollector < Collector
+    
+    def initialize(options = {})
+      @global = options[:global]
+      super
+    end
+    
+    def to_js(buffer = '')
+      buffer << "#{define_global} = (function() {\n"
+      buffer << File.read(PATH_TO_MODULR_SYNC_JS)
+      buffer << transport
+      buffer << "\n  return require('#{main.id}');\n"
+      buffer << "})();\n"
+    end
+    
+    def define_global
+      if @global.include?('.')
+        props = @global.split('.')
+        str = props.shift
+        results = "var #{str};"
+        props.each do |prop|
+          results << "\n#{str} = #{str} || {};"
+          str << ".#{prop}"
+        end
+        "#{results}\n#{str}"
+      else
+        "var #{@global}"
+      end
+    end
+  end
+end

data/lib/modulr/js_module.rb

@@ -17,9 +17,17 @@ module Modulr
     end
     
     def self.find_dependencies(js_module)
-      expressions = parser.get_require_expressions(js_module.src)
+      begin
+        expressions = parser.get_require_expressions(js_module.src)
+      rescue ParserError
+        raise JavaScriptSyntaxError, js_module
+      end
       expressions.map do |exp|
-        new(exp[:identifier], js_module.root, js_module.path, exp[:line])
+        if exp[:identifier]
+          new(exp[:identifier], js_module.root, js_module.path, exp[:line])
+        else
+          raise DynamicModuleIdentifierError.new(exp[:src_code], js_module.path, exp[:line])
+        end
       end
     end
     
@@ -83,19 +91,23 @@ module Modulr
       }
     end
     
+    def factory
+      "function(require, exports, module) {\n#{src}\n}"
+    end
+    
     def dependencies
       @dependencies ||= self.class.find_dependencies(self)
     end
-
-    def to_js(buffer = '')
-      fn = "function(require, exports, module) {\n#{src}\n}"
-      buffer << "\nmodulr.cache('#{id}', #{fn});\n"
-    end
     
-    def to_js_string(buffer = '')
-      buffer << "\nmodulr.cache('#{id}', '#{escaped_src}');\n"
+    def dependency_array
+      '[' << dependencies.map { |d| "'#{d.id}'" }.join(', ') << ']'
     end
     
+    def ensure(buffer = '')
+      fn = "function() {\n#{src}\n}"
+      buffer << "\nrequire.ensure(#{dependency_array}, #{fn});\n"
+    end
+
     protected
       def partial_path
         File.join(*terms)
@@ -121,4 +133,22 @@ module Modulr
       super("Cannot load module '#{js_module.identifier}' in #{js_module.file} at line #{js_module.line}.\nMissing file #{js_module.path}.")
     end
   end
+  
+  class DynamicModuleIdentifierError < ModulrError
+    attr_reader :src, :file, :line
+    def initialize(src, file, line)
+      @src = src
+      @file = file
+      @line = line
+      super("Cannot do a static analysis of dynamic module identifier '#{src}' in #{file} at line #{line}.")
+    end
+  end
+  
+  class JavaScriptSyntaxError < ModulrError
+    attr_reader :js_module
+    def initialize(js_module)
+      @js_module = js_module
+      super("JavaScript Syntax Error in #{js_module.file}.")
+    end
+  end
 end

data/lib/modulr/minifier.rb

@@ -0,0 +1,41 @@
+module Modulr
+  class MinifierError < ModulrError
+  end
+  
+  class Minifier
+    YUI_COMPRESSOR_PATH = File.join(File.dirname(__FILE__), '..', '..', 'vendor', 'yuicompressor-2.4.2.jar').freeze
+    
+    def self.minify(input, options = {})
+      new(options).minify(input)
+    end
+    
+    def initialize(options = {})
+      @options = options
+    end
+    
+    def minify(input)
+      run_yui_compressor do |pipe, stderr|
+        pipe.write(input)
+        pipe.close_write
+        output, error = pipe.read, stderr.read
+        raise MinifierError, error unless error.empty?
+        output
+      end
+    end
+    
+    protected
+      def run_yui_compressor(&block)
+        require 'coffee_machine'
+        CoffeeMachine.run_jar(YUI_COMPRESSOR_PATH, :args => yui_compressor_args, &block)
+      end
+      
+      def yui_compressor_args
+        args = ['--type js']
+        @options.each do |option, value|
+          args << "--#{option.to_s.gsub('_', '-')}"
+          args << value unless value == true || value == false
+        end
+        args.join(' ')
+      end
+  end
+end

data/lib/modulr/parser.rb

@@ -4,7 +4,13 @@ module Modulr
   class Parser
     
     def parse(src)
-      parser.parse(src)
+      begin
+        ast = parser.parse(src)
+      rescue RKelly::SyntaxError
+        raise ParserError
+      end
+      raise ParserError unless ast
+      ast
     end
     
     def get_require_expressions(src)
@@ -25,11 +31,16 @@ module Modulr
       end
       
       def normalize(node)
-        str = node.arguments.first.value.first
+        arg = node.arguments.value.first
+        valid = arg.is_a?(RKelly::Nodes::StringNode)
         {
-          :identifier => str.value[1...-1],
-          :line => str.line.to_i
+          :identifier => valid ? arg.value[1...-1] : nil,
+          :src_code => arg.to_ecma,
+          :line => arg.line.to_i
         }
       end
   end
+  
+  class ParserError < ModulrError
+  end
 end

data/lib/modulr.rb

@@ -10,13 +10,41 @@ module Modulr
   require 'modulr/js_module'
   require 'modulr/parser'
   require 'modulr/collector'
+  require 'modulr/global_export_collector'
+  require 'modulr/minifier'
+  require 'modulr/dependency_graph'
+  require 'open-uri'
   require 'modulr/version'
   
   PATH_TO_MODULR_JS = File.join(LIB_DIR, '..', 'assets', 'modulr.js')
+  PATH_TO_MODULR_SYNC_JS = File.join(LIB_DIR, '..', 'assets', 'modulr.sync.js')
   
   def self.ize(input_filename, options = {})
-    collector = Collector.new(options)
+    if options[:global]
+      collector = GlobalExportCollector.new(options)
+    else
+      collector = Collector.new(options)
+    end
     collector.parse_file(input_filename)
-    collector.to_js
+    minify(collector.to_js, options[:minify])
   end
+  
+  def self.graph(file, options = {})
+    dir = File.dirname(file)
+    mod_name = File.basename(file, '.js')
+    mod = JSModule.new(mod_name, dir, file)
+    output = options.delete(:output)
+    output = "#{dir}/#{mod_name}.png" unless output
+    uri = DependencyGraph.new(mod).to_yuml(options)
+    File.open(output, 'w').write(open(uri).read)
+  end
+  
+  protected
+    def self.minify(output, options)
+      if options
+        Minifier.minify(output, options == true ? {} : options)
+      else
+        output
+      end
+    end
 end

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: modulr
 version: !ruby/object:Gem::Version 
-  version: 0.3.0
+  prerelease: false
+  segments: 
+  - 0
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Tobie Langel
@@ -9,10 +14,21 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-11 00:00:00 +01:00
+date: 2010-05-13 00:00:00 +02:00
 default_executable: modulrize
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: coffee_machine
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
 description: 
 email: tobie.langel@gmail.com
 executables: 
@@ -28,6 +44,7 @@ files:
 - Rakefile
 - VERSION
 - assets/modulr.js
+- assets/modulr.sync.js
 - bin/modulrize
 - example/foo/bar.js
 - example/foo/foo.js
@@ -37,7 +54,10 @@ files:
 - example/program.js
 - lib/modulr.rb
 - lib/modulr/collector.rb
+- lib/modulr/dependency_graph.rb
+- lib/modulr/global_export_collector.rb
 - lib/modulr/js_module.rb
+- lib/modulr/minifier.rb
 - lib/modulr/parser.rb
 - lib/modulr/version.rb
 - vendor/rkelly/CHANGELOG.rdoc
@@ -241,7 +261,7 @@ files:
 - vendor/rkelly/test/test_while_node.rb
 - vendor/rkelly/test/test_with_node.rb
 has_rdoc: true
-homepage: http://github.com/tobie/modulr
+homepage: http://github.com/codespeaks/modulr
 licenses: []
 
 post_install_message: 
@@ -253,18 +273,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: A CommonJS module implementation in Ruby for client-side JavaScript