mud 0.0.4

data/.gitignore

@@ -0,0 +1,4 @@
+pkg/*
+*.gem
+.bundle
+.idea

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in mud.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,27 @@
+PATH
+  remote: .
+  specs:
+    mud (0.0.4)
+      hpricot (>= 0.8.4)
+      sinatra (>= 1.1.2)
+      thor (>= 0.14.6)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    hpricot (0.8.4)
+    rack (1.2.2)
+    sinatra (1.1.2)
+      rack (~> 1.1)
+      tilt (~> 1.2)
+    thor (0.14.6)
+    tilt (1.2.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  hpricot (>= 0.8.4)
+  mud!
+  sinatra (>= 1.1.2)
+  thor (>= 0.14.6)

data/README.md

@@ -0,0 +1,2 @@
+Ruby port of Mud (package manager for client-side Javascript).
+See [http://github.com/mafintosh/mud](http://github.com/mafintosh/mud) for (non-existing) documentation.

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/bin/mud

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'mud'
+require 'mud/cli'
+
+begin
+  Mud::CLI.start
+rescue Mud::ResolveError => err
+  puts err.message, "Try running: mud install #{err.name}"
+rescue Interrupt
+  puts "Quitting..."
+end

data/js/JSON.js

@@ -0,0 +1,219 @@
+if (typeof JSON === 'undefined') { // Fixed from the original JSON to support Google Closure compilation
+    JSON = {};
+}
+
+(function () {
+    "use strict";
+	
+    function f(n) {
+        // Format integers to have at least two digits.
+        return n < 10 ? '0' + n : n;
+    }
+
+    if (typeof Date.prototype.toJSON !== 'function') {
+
+        Date.prototype.toJSON = function (key) {
+
+            return isFinite(this.valueOf()) ?
+                this.getUTCFullYear()     + '-' +
+                f(this.getUTCMonth() + 1) + '-' +
+                f(this.getUTCDate())      + 'T' +
+                f(this.getUTCHours())     + ':' +
+                f(this.getUTCMinutes())   + ':' +
+                f(this.getUTCSeconds())   + 'Z' : null;
+        };
+
+        String.prototype.toJSON      =
+            Number.prototype.toJSON  =
+            Boolean.prototype.toJSON = function (key) {
+                return this.valueOf();
+            };
+    }
+
+    var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+        escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g,
+        gap,
+        indent,
+        meta = {    // table of character substitutions
+            '\b': '\\b',
+            '\t': '\\t',
+            '\n': '\\n',
+            '\f': '\\f',
+            '\r': '\\r',
+            '"' : '\\"',
+            '\\': '\\\\'
+        },
+        rep;
+
+
+    function quote(string) {
+
+        escapable.lastIndex = 0;
+        return escapable.test(string) ? '"' + string.replace(escapable, function (a) {
+            var c = meta[a];
+            return typeof c === 'string' ? c :
+                '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+        }) + '"' : '"' + string + '"';
+    }
+
+
+    function str(key, holder) {
+
+        var i,          // The loop counter.
+            k,          // The member key.
+            v,          // The member value.
+            length,
+            mind = gap,
+            partial,
+            value = holder[key];
+
+        if (value && typeof value === 'object' &&
+                typeof value.toJSON === 'function') {
+            value = value.toJSON(key);
+        }
+
+        if (typeof rep === 'function') {
+            value = rep.call(holder, key, value);
+        }
+
+        switch (typeof value) {
+        case 'string':
+            return quote(value);
+
+        case 'number':
+
+            return isFinite(value) ? String(value) : 'null';
+
+        case 'boolean':
+        case 'null':
+
+            return String(value);
+
+        case 'object':
+
+            if (!value) {
+                return 'null';
+            }
+
+            gap += indent;
+            partial = [];
+
+            if (Object.prototype.toString.apply(value) === '[object Array]') {
+
+                length = value.length;
+                for (i = 0; i < length; i += 1) {
+                    partial[i] = str(i, value) || 'null';
+                }
+
+                v = partial.length === 0 ? '[]' : gap ?
+                    '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']' :
+                    '[' + partial.join(',') + ']';
+                gap = mind;
+                return v;
+            }
+
+            if (rep && typeof rep === 'object') {
+                length = rep.length;
+                for (i = 0; i < length; i += 1) {
+                    if (typeof rep[i] === 'string') {
+                        k = rep[i];
+                        v = str(k, value);
+                        if (v) {
+                            partial.push(quote(k) + (gap ? ': ' : ':') + v);
+                        }
+                    }
+                }
+            } else {
+
+                for (k in value) {
+                    if (Object.prototype.hasOwnProperty.call(value, k)) {
+                        v = str(k, value);
+                        if (v) {
+                            partial.push(quote(k) + (gap ? ': ' : ':') + v);
+                        }
+                    }
+                }
+            }
+
+            v = partial.length === 0 ? '{}' : gap ?
+                '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}' :
+                '{' + partial.join(',') + '}';
+            gap = mind;
+            return v;
+        }
+    }
+
+    if (typeof JSON.stringify !== 'function') {
+        JSON.stringify = function (value, replacer, space) {
+
+            var i;
+            gap = '';
+            indent = '';
+
+            if (typeof space === 'number') {
+                for (i = 0; i < space; i += 1) {
+                    indent += ' ';
+                }
+
+            } else if (typeof space === 'string') {
+                indent = space;
+            }
+
+            rep = replacer;
+            if (replacer && typeof replacer !== 'function' &&
+                    (typeof replacer !== 'object' ||
+                    typeof replacer.length !== 'number')) {
+                throw new Error('JSON.stringify');
+            }
+
+            return str('', {'': value});
+        };
+    }
+
+    if (typeof JSON.parse !== 'function') {
+        JSON.parse = function (text, reviver) {
+
+            var j;
+
+            function walk(holder, key) {
+
+                var k, v, value = holder[key];
+                if (value && typeof value === 'object') {
+                    for (k in value) {
+                        if (Object.prototype.hasOwnProperty.call(value, k)) {
+                            v = walk(value, k);
+                            if (v !== undefined) {
+                                value[k] = v;
+                            } else {
+                                delete value[k];
+                            }
+                        }
+                    }
+                }
+                return reviver.call(holder, key, value);
+            }
+
+            text = String(text);
+            cx.lastIndex = 0;
+            if (cx.test(text)) {
+                text = text.replace(cx, function (a) {
+                    return '\\u' +
+                        ('0000' + a.charCodeAt(0).toString(16)).slice(-4);
+                });
+            }
+
+            if (/^[\],:{}\s]*$/
+                    .test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@')
+                        .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']')
+                        .replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) {
+
+                j = eval('(' + text + ')');
+
+                return typeof reviver === 'function' ?
+                    walk({'': j}, '') : j;
+            }
+
+            throw new SyntaxError('JSON.parse');
+        };
+    }
+}());

data/js/global.js.erb

@@ -0,0 +1,10 @@
+
+(function(require) {
+    <%= render :erb => 'inline_modules.js.erb', :locals => { :modules => modules } %>
+
+    <% modules.each do |mod| %>
+        window[<%= mod.name.to_json %>] = require(<%= mod.name.to_json %>);
+    <% end %>
+})();
+
+<%= render :erb => 'list.js.erb', :locals => { :list => appends } %>

data/js/inline_modules.js.erb

@@ -0,0 +1,12 @@
+
+<%= render :file => 'require.js' %>
+
+<%= render :file => 'JSON.js' %>
+
+<% modules.each do |mod| %>
+    require.define(<%= mod.name.to_json %>, function(module, exports) {
+        <%= mod.content %>
+    });
+<% end %>
+
+<%= render :erb => 'list.js.erb', :locals => { :list => appends } if defined?(appends) %>

data/js/list.js.erb

@@ -0,0 +1,3 @@
+<% list.each do |item| %>
+    <%= item %>
+<% end %>

data/js/require.js

@@ -0,0 +1,42 @@
+(function() {
+	if (typeof require !== 'undefined') {
+		return; // define only once
+	}
+	
+	var noop = function() {};
+	var modules = {};
+	var definitions = {};
+	
+	require = function(name) {
+		if (arguments.length > 1) { // this syntax allows for and module and it's plugins to be loaded
+			var val = require(arguments[0]);
+
+			for (var i = 1; i < arguments.length; i++) {
+				require(arguments[i]);
+			}
+			return val;
+		}
+		name = name.split('@')[0]; // TODO: make this versioning a lot better
+		
+		if (definitions[name] && !modules[name]) { // if not already loaded and an def exists
+			var def = definitions[name];
+			
+			delete definitions[name];
+			
+			var module = modules[name] = function() {
+				return module.exports;
+			};
+			
+			module.browser = true; // allows for non-hacky browser js detection
+			module.exports = {};
+			
+			def(module, module.exports);
+		}
+		
+		return window[name] || (modules[name] || noop)();
+	};
+	
+	require.define = function(name, def) {
+		definitions[name] = def;
+	};
+}());

data/lib/mud.rb

@@ -0,0 +1,18 @@
+$:.unshift File.expand_path(File.dirname(__FILE__))
+
+require 'net/http'
+require 'uri'
+require 'json'
+require 'erb'
+require 'rbconfig'
+
+require 'sinatra/base'
+require 'thor'
+require 'hpricot'
+
+module Mud
+  require 'mud/utils'
+  extend Mud::Utils
+end
+
+%w(context dependency js_result html_result module installed_module server).each { |f| require "mud/#{f}" }

data/lib/mud/cli.rb

@@ -0,0 +1,65 @@
+module Mud
+
+  class CLI < Thor
+    include Thor::Actions
+
+    def initialize(*)
+      super
+      @context = Mud::Context.new
+      say("(in #{@context.dir})")
+    end
+
+    map "ls" => "list"
+
+    desc "resolve PATH", "resolve the given path"
+    method_option :compile, :default => nil, :desc => "compile loaded modules"
+    def resolve(path)
+      modules = @context.resolve_document(path)
+      result = Mud::JsResult.new(modules, :compile => options[:compile])
+      say(result.to_s)
+    end
+
+    desc "inline PATH", "resolve and inline the given path"
+    method_option :compile, :default => nil, :desc => "compile loaded modules"
+    def inline(path)
+      result = @context.inline_document(path, :compile => options[:compile])
+      say(result.to_s)
+    end
+
+    desc "module A,B,...,C", "load in these modules"
+    method_option :compile, :default => nil, :desc => "compile loaded modules"
+    #method_option :output, :default => nil, :desc => "output file"
+    def modules(modules)
+      modules = modules.split(',').map { |mod_name| @context.module!(mod_name) }
+      result = @context.inline(modules, :compile => options[:compile])
+
+      if out = options[:output]
+        File.open(out, 'w') { |f| f.write(result.to_s) }
+      else
+        say(result.to_s)
+      end
+    end
+
+    desc "server", "run a mud server"
+    #method_options :fork, :default => false, :desc => "run the server as a daemon (only supported on unix platforms)"
+    def server
+      Mud::Server.context = @context
+      Mud::Server.run!
+    end
+
+    desc "list", "list all installed packages"
+    method_option :path, :default => false, :desc => "include module paths"
+    def list
+      modules = @context.available_modules.values
+      if modules.empty?
+        say("no modules found")
+      else
+        modules.each do |m|
+          msg = m.name + (options[:path] ? " => #{m.path}" : '')
+          say(msg)
+        end
+      end
+    end
+  end
+
+end

data/lib/mud/context.rb

@@ -0,0 +1,167 @@
+module Mud
+
+  class ResolveError < StandardError
+    attr_reader :name
+
+    def initialize(name_or_dependency)
+      @name = name_or_dependency.is_a?(Mud::Dependency) ? name_or_dependency.name : name_or_dependency
+      super("No module named '#{@name}' in context")
+    end
+  end
+
+  class Context
+    MODULE_DIRECTORIES  = ['js_modules', 'shared_modules']
+    MODULE_GLOBAL = Mud.home_directory('.mud', 'js_modules')
+
+    attr_reader :available_modules, :dir
+
+    def initialize(dir = '.')
+      @dir = File.absolute_path(dir)
+      @available_modules = {}
+      reload
+    end
+
+    def reload
+      dirs = dirs(@dir)
+      removed = @available_modules.dup
+
+      dirs.each do |dir|
+        Dir.glob(File.join(dir, '*.js')) do |mod_path|
+          name = Mud::Module.parse_name(mod_path)
+          mod = @available_modules[name]
+          removed.delete(name)
+
+          unless mod and mod.modified == File.mtime(mod_path) and mod.path == mod_path
+            @available_modules[name] = Mud::InstalledModule.new(mod_path, self)
+          end
+        end
+      end
+
+      @available_modules.delete_if { |key, _| removed.key?(key) }
+    end
+
+    def install(name, opts = {})
+      return if @available_modules[name]# or raise exception
+
+      src = nil # download module src from mudhub and write to disk in module global
+      path = nil
+
+      @available_modules[name] = Mud::InstalledModule.new(path, self) # check dependencies and download if not present
+    end
+
+    def uninstall(module_or_name)
+    end
+
+    def module(name)
+      @available_modules[name]
+    end
+
+    def module!(name)
+      @available_modules[name] || (raise Mud::ResolveError.new(name))
+    end
+
+    def resolve_document(path)
+      resolve analyze_document(path).first
+    end
+
+    def inline_document(path, opts = {})
+      modules, type = analyze_document(path)
+
+      result = inline(modules, opts)
+
+      if type == :js
+        main = modules.first
+        result << main.content
+      else
+        result = Mud::HtmlResult.new(path, result)
+      end
+
+      result
+    end
+
+    def resolve(module_or_list)
+      modules = module_or_list.is_a?(Mud::Module) ? [module_or_list] : module_or_list
+
+      resolved = []
+
+      resolver = proc do |modules|
+        modules.each do |mod|
+          next if resolved.include?(mod)
+          resolved.unshift(mod) if mod.is_a?(Mud::InstalledModule)
+
+          dep = mod.unresolvable_dependencies.first
+          raise Mud::ResolveError.new(dep) if dep
+
+          dependencies = mod.dependencies.map(&:resolve).delete_if { |m| resolved.include?(m) }
+          resolver.call(dependencies) unless dependencies.empty?
+        end
+      end
+      resolver.call(modules)
+
+      resolved
+    end
+
+    def inline(module_or_list, opts = {})
+      resolved = resolve(module_or_list)
+      Mud::JsResult.new(resolved, opts)
+    end
+
+    private
+
+    def analyze_document(path)
+      content = Mud.render path
+      type = content.match(/^\s*</) ? :html : :js
+
+      modules = if type == :html
+        analyze_html(path, content)
+      else
+        [Mud::Module.new(path, content, self)]
+      end
+
+      return modules, type
+    end
+
+    def analyze_html(path, html)
+      inner_modules = []
+      doc = Hpricot(html)
+
+      doc.search('//script').each do |script_tag|
+        src = script_tag.attributes['src']
+
+        if src and not src.empty? and not src.match(/^\w+:\/\//)
+          begin
+            content = Mud.render src, :basepath => path
+            inner_modules << Mud::Module.new(src, content, self)
+          rescue Errno::ENOENT, Net::HTTPError
+            # Does not exist. Ignore.
+          end
+        end
+
+        content = script_tag.inner_html
+        if content and not content.empty?
+          inner_modules << Mud::Module.new("#{File.basename(path)}-embedded-script-#{inner_modules.length}", content, self)
+        end
+      end
+
+      inner_modules
+    end
+
+    def dirs(start)
+      dirs = [MODULE_GLOBAL]
+
+      current = File.absolute_path(start)
+      while true
+        dirs += MODULE_DIRECTORIES.map { |dir| File.join(current, dir) }
+        break if current == Mud.root_directory
+        current = File.expand_path(current, '..')
+      end
+
+      dirs.keep_if { |dir| File.exists?(dir) }
+    end
+
+    def in(*paths)
+      File.join(@dir, *paths)
+    end
+  end
+
+end

data/lib/mud/dependency.rb

@@ -0,0 +1,40 @@
+module Mud
+
+  class Dependency
+    def self.analyze(src, context)
+      dependencies = Set.new
+
+      # Find all required files on the form require('name') og require('name', 'sub_name', ...)
+      src.scan(/require\(((?:'[^']+'(?:,\s)?)+)\)/).each do |req|
+        req.first.scan(/'([^']+)'/).each { |name| dependencies << new(name.first, context) }
+      end
+
+      dependencies.to_a
+    end
+
+    attr_reader :name, :context
+
+    def initialize(name, context)
+      @name = name
+      @context = context
+    end
+
+    def to_s
+      "Mud::Dependency #{@name}"
+    end
+
+    def ==(other)
+      other.is_a?(self.class) and other.name == @name
+    end
+
+    def resolvable?
+      !!resolve
+    end
+
+    # Resolves to the corresponding module if present in this context.
+    def resolve
+      @context.module(@name)
+    end
+  end
+
+end

data/lib/mud/html_result.rb

@@ -0,0 +1,39 @@
+module Mud
+
+  class HtmlResult
+    def initialize(html, js)
+      @html = html
+      @js = js
+    end
+
+    def to_s
+      doc = html_doc
+      script = doc.search('//script').find { |script_tag| /.*\/dev$/.match script_tag.attributes['src'] }
+
+      if script
+        script.remove_attribute(:src)
+      else
+        script = Hpricot::Elem.new('script', :type => 'text/javascript')
+        head = doc.at('/html/head')
+
+        unless head
+          head = Hpricot::Elem.new('head')
+          doc.root.children.unshift(head)
+        end
+
+        head.children = (head.children || []).unshift(script)
+      end
+
+      script.inner_html = @js.to_s
+
+      doc.to_html
+    end
+
+    private
+
+    def html_doc
+      Hpricot(Mud.render @html)
+    end
+  end
+
+end

data/lib/mud/installed_module.rb

@@ -0,0 +1,19 @@
+module Mud
+
+  class InstalledModule < Mud::Module
+    attr_reader :path, :modified
+
+    def initialize(path, context)
+      super(path, File.open(path) { |f| f.read }, context)
+      @content = nil
+
+      @path = path
+      @modified = File.mtime(path)
+    end
+
+    def content
+      File.open(@path) { |f| f.read }
+    end
+  end
+
+end

data/lib/mud/js_result.rb

@@ -0,0 +1,25 @@
+module Mud
+
+  class JsResult
+    def initialize(modules, opts = {})
+      opts = { :global => false, :compile => nil }.update(opts)
+
+      @modules = modules
+      @global = opts[:global]
+      @compile = opts[:compile]
+
+      @appends = []
+    end
+
+    def to_s
+      result = Mud.render :erb => (@global ? 'global.js.erb' : 'inline_modules.js.erb'),
+                  :locals => { :modules => @modules, :appends => @appends }, :basepath => Mud.js_directory
+      @compile ? Mud.compile(result, @compile) : result
+    end
+
+    def <<(src)
+      @appends << src
+    end
+  end
+  
+end

data/lib/mud/module.rb

@@ -0,0 +1,39 @@
+module Mud
+
+  class Module
+    attr_reader :name, :content, :context, :dependencies
+
+    def self.parse_name(path_or_name)
+      File.basename(path_or_name).split(/\.js$/i).first
+    end
+
+    def initialize(name, content, context)
+      @name = self.class.parse_name(name)
+      @content = content
+      @context = context
+
+      @dependencies = Mud::Dependency.analyze(content, context)
+    end
+
+    def to_s
+      "#{self.class} #{@name}"
+    end
+
+    def ==(other)
+      other.is_a?(self.class) and other.name == @name
+    end
+
+    def unresolvable_dependencies
+      @dependencies.select { |d| not d.resolvable? }
+    end
+
+    def resolvable?
+      @dependencies.all?(&:resolvable?)
+    end
+
+    def depends_on?(module_or_dependency)
+      !!@dependencies.find { |d| d.name == module_or_dependency.name }
+    end
+  end
+
+end

data/lib/mud/server.rb

@@ -0,0 +1,86 @@
+module Mud
+
+  class Server < Sinatra::Base
+    enable :logging, :dump_errors, :inline_templates
+    disable :static, :run
+
+    set :port, 10000
+
+    class << self
+      def port=(port)
+        set :port, port
+      end
+
+      def context=(context)
+        @@context = context
+      end
+    end
+
+    helpers do
+      def context
+        unless defined?(@@context)
+          @@context = Mud::Context.new
+        else
+          @@context.reload
+        end
+
+        @@context
+      end
+      
+      def js
+        content_type 'application/javascript'
+      end
+
+      def process_modules(modules, opts)
+        halt 400 if modules.nil? or modules.empty?
+        modules = modules.split(',').map { |name| context.module!(name) }
+        context.inline(modules, opts).to_s
+      end
+    end
+
+    get '/dev' do
+      ref = params[:ref] || request.referrer
+
+      js
+      if ref.nil? or ref == '/'
+        host = "#{request.host.split(':').first}:#{settings.port}"
+        erb :dev, :locals => { :host => host }
+      else
+        modules = context.resolve_document(ref)
+        Mud::JsResult.new(modules).to_s
+      end
+    end
+
+    get '/m/:modules' do |modules|
+      js
+      process_modules(modules, :global => false)
+    end
+
+    get '/g/:modules' do |modules|
+      js
+      process_modules(modules, :global => true)
+    end
+
+    get '/p/:var' do |var|
+      content_type 'text/html'
+      erb :play, :locals => { :var => var }
+    end
+  end
+
+end
+
+__END__
+
+@@ dev
+document.write('<script src="http://<%= host %>/dev?ref=' + window.location + '"></script>');
+
+@@ play
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>mud play</title>
+    <script src="<%= "/m/#{var}" %>"></script>
+  </head>
+  <body>
+  </body>
+</html>

data/lib/mud/utils.rb

@@ -0,0 +1,146 @@
+module Mud
+
+  File.class_eval do
+    def self.hide(file_name, force_rename = false)
+      os = RbConfig::CONFIG['host_os']
+
+      if os =~ /mswin|windows|cygwin/i
+        raise IOError.new("Could not hide file '#{file_name}' using attrib +h") unless system("attrib +h '#{file_name}'")
+        file_name
+      else
+        # Assume unix-like
+
+        parent, base = dirname(file_name), basename(file_name)
+
+        if base.start_with?('.')
+          file_name
+        else
+          if os =~ /darwin/i and not force_rename
+            # OS X
+            raise IOError.new("Could not hide file '#{file_name}' using SetFile -a -V") unless system("SetFile -a V '#{file_name}'")
+            return file_name
+          end
+
+          hidden = join(parent, ".#{base}")
+          raise IOError.new("Can't hide '#{file_name}' by renaming to '#{hidden} (already exists)") if exists?(hidden)
+          rename(file_name, hidden)
+          hidden
+        end
+      end
+    end
+  end
+
+  module Utils
+    JS_DIRECTORY = File.expand_path(File.join File.dirname(__FILE__), '..', '..', 'js')
+
+    ROOT_DIRECTORY = File.absolute_path('/')
+    HOME_DIRECTORY = Dir.home
+
+    [:js, :root, :home].each do |name|
+      name = "#{name}_directory"
+      module_eval %{
+        def #{name}(*paths)
+          File.join(#{name.upcase}, *paths)
+        end
+      }
+    end
+
+    def compile(src, type = 'simple', out = nil)
+      raise ArgumentError.new("Type must be either 'simple' or 'advanced', was '#{type}'") unless ['simple', 'advanced'].include?(type.to_s)
+      level = "#{type.upcase}_OPTIMIZATIONS"
+
+      response = Net::HTTP.post_form(URI.parse('http://closure-compiler.appspot.com/compile'),
+        :output_info => 'compiled_code',
+        :compilation_level => level,
+        :warning_level => 'default',
+        :js_code => src)
+
+      if out
+        File.open(out) { |f| f.write(response.body) }
+      end
+
+      response.body
+    end
+
+    def render(location, opts = {})
+      if location.is_a?(Hash)
+        opts = location
+      else
+        opts = guess(location).update(opts)
+      end
+      
+      type, path = opts.first
+
+      content = case type
+        when :erb, :file then
+          basepath = opts[:basepath] || path
+          basepath = basepath.gsub(/^file:\/\//, '')
+
+          path = opts[:basepath] ? File.join(basepath, path) : basepath
+
+          File.open(path) { |f| f.read }
+        when :http then
+          basepath = opts[:basepath] || path
+          basepath = "http://#{basepath}" unless basepath.start_with?('http://')
+
+          path = opts[:basepath] ? URI.join(basepath, path) : basepath
+
+          response = Net::HTTP.get_response(URI.parse(path))
+          response.error! unless (200..299).include?(response.code.to_i)
+          response.body
+        else
+          raise ArgumentError.new("Unknown type '#{type}'")
+      end
+
+      if type == :erb
+        locals = opts[:locals] || {}
+        content = ERB.new(content).result(LocalsBinding.new(locals).binding)
+      end
+
+      content
+    end
+    alias :cat :render
+
+    private
+
+    class LocalsBinding < BasicObject
+      def initialize(locals, &block)
+        @_locals = locals
+
+        locals.each_pair do |name, value|
+          instance_eval %{
+            def #{name}
+              _get(:#{name})
+            end
+          }
+        end
+
+        instance_eval(&block) if block
+      end
+
+      def js_directory(*paths)
+        ::Mud.js_directory(*paths)
+      end
+
+      def render(opts)
+        ::Mud.render(opts.update :basepath => js_directory)
+      end
+
+      def binding
+        ::Proc.new {}.binding
+      end
+
+      private
+
+      def _get(name)
+        @_locals[name.to_sym] || @_locals[name.to_s]
+      end
+    end
+
+    def guess(path)
+      protocol = (path.match(/^(\w+):\/\//) || [])[1] || 'file'
+      { protocol.to_sym => path }
+    end
+  end
+
+end

data/lib/mud/version.rb

@@ -0,0 +1,3 @@
+module Mud
+  VERSION = "0.0.4"
+end

data/mud.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "mud/version"
+
+Gem::Specification.new do |s|
+  s.name        = "mud"
+  s.version     = Mud::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Mirza Kapetanovic", "Mathias Buus"]
+  #s.email       = [""]
+  s.homepage    = "http://mudhub.org"
+  s.summary     = %q{Simple browser Javascript package manager}
+  s.description = %q{Mud is a simple package manager for client-side Javascript. Used for installing new packages and resolving dependencies.}
+
+  #s.rubyforge_project = "mud"
+
+  s.add_dependency("sinatra", ">= 1.1.2")
+  s.add_dependency("thor", ">= 0.14.6")
+  s.add_dependency("hpricot", ">= 0.8.4")
+
+  s.files         = `git ls-files`.split("\n")
+  #s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = ["mud"]
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification 
+name: mud
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 4
+  version: 0.0.4
+platform: ruby
+authors: 
+- Mirza Kapetanovic
+- Mathias Buus
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-29 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 1
+        - 2
+        version: 1.1.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: thor
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 14
+        - 6
+        version: 0.14.6
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 8
+        - 4
+        version: 0.8.4
+  type: :runtime
+  version_requirements: *id003
+description: Mud is a simple package manager for client-side Javascript. Used for installing new packages and resolving dependencies.
+email: 
+executables: 
+- mud
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- bin/mud
+- js/JSON.js
+- js/global.js.erb
+- js/inline_modules.js.erb
+- js/list.js.erb
+- js/require.js
+- lib/mud.rb
+- lib/mud/cli.rb
+- lib/mud/context.rb
+- lib/mud/dependency.rb
+- lib/mud/html_result.rb
+- lib/mud/installed_module.rb
+- lib/mud/js_result.rb
+- lib/mud/module.rb
+- lib/mud/server.rb
+- lib/mud/utils.rb
+- lib/mud/version.rb
+- mud.gemspec
+has_rdoc: true
+homepage: http://mudhub.org
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Simple browser Javascript package manager
+test_files: []
+