distil 0.10.4 → 0.11.0

data/Rakefile

@@ -9,10 +9,11 @@ begin
     gemspec.summary= "A build tool for Javascript and CSS that takes advantage of best-of-breed helper applications Javascript Lint and JSDoc Toolkit"
     gemspec.homepage= "http://code.google.com/p/distil-js/"
     gemspec.description= gemspec.summary
-    gemspec.files= Dir['lib/**/*', 'bin/*', '[A-Za-z]*', 'vendor/**/*']
+    gemspec.files= Dir['assets/*', 'lib/**/*', 'bin/*', '[A-Za-z]*', 'vendor/**/*']
     gemspec.files.reject! { |f| File.directory?(f) }
     gemspec.executables= ['distil']
     gemspec.extensions= ['vendor/extconf.rb']
+    gemspec.add_dependency('json', '>= 1.4.3')
   end
 
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.10.4
+0.11.0

data/assets/distil.js

@@ -0,0 +1,359 @@
+/*jsl:declare distil*/
+
+/** A resource module defined in the module that provides the module.
+ */
+
+(function(distil, window, document){
+
+  var moduleIndex= {};
+  var fetched= {};
+  var root= document.documentElement;
+  var head= document.getElementsByTagName('head')[0]||root;
+  
+  var XHR= window.XMLHttpRequest || (function(){
+    var progIdCandidates= ['Msxml2.XMLHTTP.4.0', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP'];
+    var len= progIdCandidates.length;
+
+    var progId;
+    var xhr;
+    
+    function ConstructXhr()
+    {
+      return new window.ActiveXObject(ConstructXhr.progId);
+    }
+    
+    while (len--)
+    {
+      try
+      {
+        progId= progIdCandidates[len];
+        xhr= new window.ActiveXObject(progId);
+        //  ActiveXObject constructor throws an exception
+        //  if the component isn't available.
+        xhr= null;
+        ConstructXhr.progId= progId;
+        return ConstructXhr;
+      }
+      catch (e)
+      {
+        //  Ignore the error
+      }
+    }
+    throw new Error('No XMLHttpRequest implementation found');
+  })();
+  
+  var noop= function(){};
+  var fetchAsset= function(url, callback, scope, userData)
+  {
+    if (url in fetched)
+    {
+      //  The callback will ALWAYS be called after the calling program
+      //  finishes executing.
+      window.setTimeout(function(){ callback.call(scope, userData); }, 0);
+      return;
+    }
+    
+    var xhr= new XHR();
+    xhr.open('GET', url, true);
+    
+    xhr.onreadystatechange= function()
+    {
+      if (4!==xhr.readyState)
+        return;
+      fetched[url]= true;
+      var status= xhr.status;
+      var succeeded= 0==status || (status>=200 && status<300) || 304==status;
+      
+      if (!succeeded)
+        throw new Error('Failed to load resource: status=' + status + ' url=' + url);
+        
+      callback.call(scope, userData);
+      xhr.onreadystatechange= noop;
+      xhr= null;
+    }
+    xhr.send(null);
+  };
+
+  var SCRIPT_TYPE= 'js';
+  var JSNIB_TYPE= 'jsnib';
+  var CSS_TYPE= 'css';
+  var MODULE_TYPE= 'module';
+  var NO_MODULE_ERROR= 'No module with name: ';
+  
+  var injectScript= distil.injectScript= function(url, callback, scope, userData)
+  {
+    var tag= document.createElement('script');
+
+    var complete= function()
+    {
+      if (callback)
+        callback.call(scope, userData);
+      tag.onreadystatechage= noop;
+      tag= null;
+    };
+  
+    window.__filename__= url;
+
+    tag.onreadystatechange= function()
+    {
+      var readyState= tag && tag.readyState;
+      if ('complete'===readyState || 'loaded'===readyState)
+        complete();
+    }
+    tag.onload= complete;
+    tag.type= "text/javascript";
+    tag.src= url;
+    root.insertBefore(tag, root.firstChild);
+  };
+
+  var injectStylesheet= distil.injectStylesheet= function(url, callback, scope, userData)
+  {
+    var link= document.createElement('link');
+    link.type='text/css';
+    link.rel='stylesheet';
+    link.href='url';
+    head.appendChild(link);
+    
+    if (callback)
+      callback.call(scope, url, userData);
+  };
+  
+  var getRunningScriptSource= function()
+  {
+    var scripts= document.getElementsByTagName("script");
+    if (!scripts || !scripts.length)
+      throw new Error("Could not find script");
+
+    var l= scripts.length;
+    var s, src, lastSlash;
+
+    while (l--)
+    {
+      if ((src= scripts[l].src))
+        return src;
+    }
+    
+    throw new Error("No script tags with src attribute.");
+  };
+  
+  var ResourceInfo= function(type, url, callback, scope, userData)
+  {
+    if (!type)
+    {
+      var lastDot= url.lastIndexOf('.');
+      type= (-1!==lastDot)?url.substring(lastDot+1):"";
+      type= type.split('?')[0];
+    }
+    
+    var lastSlash= url.lastIndexOf('/');
+    if (-1===lastSlash)
+      throw new Error("Couldn't determine path from script src: " + url);
+      
+    return {
+      type: type,
+      url: url,
+      callback: callback,
+      scope: scope,
+      userData: userData,
+      loadQueue: [],
+      fetched: false,
+      injected: false,
+      callbacksExecuted: false,
+      path: url.substring(0, lastSlash+1),
+      parent: null
+    };
+  };
+
+  var rootResource= ResourceInfo(SCRIPT_TYPE, getRunningScriptSource());
+  rootResource.fetched= true;
+  rootResource.injected= true;
+  
+  /** currentResource is the resource that is currently executing.
+   */
+  var currentResource= rootResource;
+
+  var injectResource= function(resource)
+  {
+    resource.injected= true;
+    switch (resource.type)
+    {
+      case SCRIPT_TYPE:
+      case JSNIB_TYPE:
+        injectScript(resource.url, injectionComplete, null, resource);
+        break;
+      case CSS_TYPE:
+        injectStylesheet(resource.url, injectionComplete, null, resource);
+        break;
+      default:
+        throw new Error('Unknown resource type: ' + resource.type);
+    }
+  };
+
+  /** The execution complete callback for the script.
+   */
+  var injectionComplete= function(resource)
+  {
+    while (resource)
+    {
+      if (resource.loadQueue.length)
+      {
+        currentResource= resource= resource.loadQueue.shift();
+        resource.complete= true;
+        if (!resource.fetched)
+          return;
+        if (MODULE_TYPE===resource.type)
+          continue;
+        injectResource(resource);
+        return;
+      }
+
+      resource.callbacksExecuted= true;
+      if (resource.callback)
+        resource.callback.call(resource.scope, resource.userData);
+        
+      resource= resource.parent;
+    }
+    
+    currentResource= resource ? resource : rootResource;
+  };
+  
+  var fetchComplete= function(resource)
+  {
+    resource.fetched= true;
+    var parent= resource.parent;
+    
+    if (resource===currentResource)
+      injectResource(resource);
+  };
+  
+  var loadResource= function(url, callback, scope, userData, parent)
+  {
+    if (distil.debug)
+      url+= '?'+(new Date()).valueOf();
+
+    var resource= ResourceInfo(null, url, callback, scope, userData);
+    parent= parent||currentResource;
+    resource.parent= parent;
+    parent.loadQueue.push(resource);
+    fetchAsset(url, fetchComplete, null, resource);
+  };
+
+  var loadFiles= function(module)
+  {
+    var files= (module.loadQueue||[]).concat(module.required);
+    var resource= module.resource;
+    var path= module.path;
+    
+    for (var i=0, len=files.length; i<len; ++i)
+      loadResource(path + files[i], null, null, null, resource);
+  };
+  
+  distil.module= function(name, def)
+  {
+    if (name in moduleIndex)
+    {
+      var module= moduleIndex[name];
+      for (var p in def)
+        module[p]= def[p];
+        
+      distil.require(name);
+      return;
+    }
+
+    def.path= currentResource.path + def.folder;
+    if ('/'!==def.path.slice(-1))
+      def.path+='/';
+      
+    def.callbacks= [];
+    def.loadQueue= [];
+    
+    if (!distil.mainModule)
+      distil.mainModule= def;
+      
+    moduleIndex[name]= def;
+    if (def.required && def.required.length)
+      distil.require(name);
+  };
+
+  distil.queue= function(name, fragment)
+  {
+    var module= moduleIndex[name];
+    if (module.resource)
+      loadResource(currentResource.path + fragment, null, null, null, module.resource);
+    else
+      module.loadQueue.push(fragment);
+  };
+  
+  distil.onready= function(callback)
+  {
+    if (rootResource.callbacksExecuted)
+      window.setTimeout(callback, 0);
+    else
+      rootResource.callback= callback;
+  }
+
+  distil.complete= function(name)
+  {
+    var module= moduleIndex[name];
+    if (module.loadQueue.length)
+      distil.require(name);
+  }    
+  
+  distil.require= function(name, callback, scope, userData)
+  {
+    var module= moduleIndex[name];
+    if (!module)
+      throw new Error(NO_MODULE_ERROR + name);
+
+    var complete= function()
+    {
+      if (callback)
+        callback.call(scope, userData);
+      module.loaded= true;
+      module.resource= null;
+    };
+
+    if (module.loaded)
+    {
+      window.setTimeout(complete, 0);
+      return;
+    }
+    
+    var resource= module.resource= ResourceInfo(MODULE_TYPE, module.path, complete);
+    resource.parent= currentResource;
+    resource.fetched= true;
+    currentResource.loadQueue.push(resource);
+
+    loadFiles(module);
+    
+    if (rootResource===currentResource)
+      injectionComplete(currentResource);
+  }
+
+  distil.kick= function()
+  {
+    if (rootResource===currentResource)
+      injectionComplete(currentResource);
+  }
+  
+  distil.urlForAssetWithNameInModule= function(asset, moduleName)
+  {
+    var module= name ? moduleIndex[moduleName] : distil.mainModule;
+    if (!module)
+      throw new Error(NO_MODULE_ERROR + moduleName);
+    if (!module.asset_map)
+      return module.path + asset;
+    return module.path + (module.asset_map[asset]||asset);
+  }
+
+  distil.dataForAssetWithNameInModule= function(asset, moduleName)
+  {
+    var module= name ? moduleIndex[moduleName] : distil.mainModule;
+    if (!module)
+      throw new Error(NO_MODULE_ERROR + moduleName);
+    if (!module.assets)
+      return null;
+    return module.assets[asset]||null;
+  }
+  
+})(window.distil={}, window, document);

data/bin/distil

@@ -1,13 +1,16 @@
 #!/usr/bin/env ruby
 
-$script_dir= File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
-$vendor_dir= File.expand_path(File.join(File.dirname(__FILE__), "..", "vendor"))
-$app_name= File.basename($0)
+LIB_DIR= File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+VENDOR_DIR= File.expand_path(File.join(File.dirname(__FILE__), "..", "vendor"))
+ASSETS_DIR= File.expand_path(File.join(File.dirname(__FILE__), "..", "assets"))
+APP_NAME= File.basename($0)
 
-require "#{$script_dir}/project"
+$:.unshift(LIB_DIR)
+
+require "distil"
 
 arg_settings= {}
-project_file= "distil.yml"
+project_file= nil
 args= []
 
 ARGV.each { |v|
@@ -32,13 +35,33 @@ ARGV.each { |v|
   arg_settings[key]= value
 }
 
+def find_project_file(dir=nil)
+  dir ||= Dir.pwd
+  
+  while dir.length > 1
+    Dir.glob(File.join(dir, '*.jsproj')) { |file|
+      return file if File.basename(dir)===File.basename(file, '.jsproj')
+    }
+    dir = File.dirname(dir)
+  end
+  
+end
+
+  
 # Change working directory to the folder containing the build YML file.
-project_file= File.expand_path(project_file)
+project_file||= find_project_file
 
-if (!File.exists?(project_file))
-  puts "#{$app_name}: can't find project file: #{project_file}"
+if !project_file
+  puts "#{APP_NAME}: can't find project file"
   exit
 end
 
-project= Project.new(project_file, arg_settings)
-project.build
+project= Distil::DistilProject.new(project_file, arg_settings)
+
+if 0==args.length
+  args << "build"
+end
+
+args.each { |cmd|
+  project.send cmd
+}

data/distil.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{distil}
-  s.version = "0.10.4"
+  s.version = "0.11.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Jeff Watkins"]
-  s.date = %q{2010-05-05}
+  s.date = %q{2010-06-06}
   s.default_executable = %q{distil}
   s.description = %q{A build tool for Javascript and CSS that takes advantage of best-of-breed helper applications Javascript Lint and JSDoc Toolkit}
   s.executables = ["distil"]
@@ -17,32 +17,40 @@ Gem::Specification.new do |s|
   s.files = [
     "Rakefile",
      "VERSION",
+     "assets/distil.js",
      "bin/distil",
      "distil.gemspec",
-     "lib/bootstrap-template.js",
-     "lib/configurable.rb",
-     "lib/file-set.rb",
-     "lib/file-types/css-file.rb",
-     "lib/file-types/html-file.rb",
-     "lib/file-types/javascript-file.rb",
-     "lib/file-types/json-file.rb",
-     "lib/filter.rb",
-     "lib/filters/css-filter.rb",
-     "lib/filters/file-reference-filter.rb",
-     "lib/filters/jsl-dependency-filter.rb",
+     "lib/distil.rb",
+     "lib/distil/configurable.rb",
+     "lib/distil/configurable/file-set.rb",
+     "lib/distil/configurable/interpolated.rb",
+     "lib/distil/configurable/output-path.rb",
+     "lib/distil/configurable/project-path.rb",
+     "lib/distil/error-reporter.rb",
+     "lib/distil/product.rb",
+     "lib/distil/product/concatenated.rb",
+     "lib/distil/product/css-product.rb",
+     "lib/distil/product/debug.rb",
+     "lib/distil/product/javascript-base-product.rb",
+     "lib/distil/product/javascript-doc-product.rb",
+     "lib/distil/product/javascript-product.rb",
+     "lib/distil/product/minified.rb",
+     "lib/distil/project.rb",
+     "lib/distil/project/distil-project.rb",
+     "lib/distil/project/external-project.rb",
+     "lib/distil/source-file.rb",
+     "lib/distil/source-file/css-file.rb",
+     "lib/distil/source-file/html-file.rb",
+     "lib/distil/source-file/javascript-file.rb",
+     "lib/distil/source-file/json-file.rb",
+     "lib/distil/target.rb",
+     "lib/distil/task.rb",
+     "lib/distil/task/css-dependency-task.rb",
+     "lib/distil/task/jsl-dependency-task.rb",
+     "lib/distil/task/nib-task.rb",
+     "lib/distil/task/validate-js-task.rb",
      "lib/jsdoc.conf",
      "lib/jsl.conf",
-     "lib/project.rb",
-     "lib/source-file.rb",
-     "lib/target.rb",
-     "lib/task.rb",
-     "lib/tasks/copy-task.rb",
-     "lib/tasks/css-task.rb",
-     "lib/tasks/javascript-task.rb",
-     "lib/tasks/multiple-output-task.rb",
-     "lib/tasks/output-task.rb",
-     "lib/tasks/single-output-task.rb",
-     "lib/tasks/test-task.rb",
      "lib/test/HtmlTestReporter.js",
      "lib/test/Test.js",
      "lib/test/TestReporter.js",
@@ -588,9 +596,12 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<json>, [">= 1.4.3"])
     else
+      s.add_dependency(%q<json>, [">= 1.4.3"])
     end
   else
+    s.add_dependency(%q<json>, [">= 1.4.3"])
   end
 end
 

data/lib/distil/configurable/file-set.rb

@@ -0,0 +1,86 @@
+module Distil
+  
+  class FileSet
+    include Enumerable
+    include ErrorReporter
+  
+    def initialize(value=[], owner=nil)
+      @owner= owner
+      @source_set= value
+    end
+
+    def files
+      return @files if @files
+      @files=[]
+      case
+        when (@source_set.is_a?(String))
+          include_file(@source_set)
+        when (@source_set.is_a?(Array))
+          @source_set.each { |f| include_file(f) }
+      end
+      @files
+    end
+    
+    def files=(set)
+      @files= nil
+      @source_set= set
+    end
+
+    def include?(file)
+      files.include?(file)
+    end
+    
+    def self.from_options(set, owner)
+      self.new(set, owner)
+    end
+  
+    def include_file(file)
+      files if !@files
+      
+      if file.is_a?(SourceFile)
+        @files << file if !@files.include?(file)
+        return
+      end
+      
+      if @owner
+        full_path= File.expand_path(File.join([@owner.source_folder, file].compact))
+      else
+        full_path= File.expand_path(file)
+      end
+    
+      if File.directory?(full_path)
+        Dir.foreach(full_path) { |f|
+            next if f[/^\./]
+            include_file(File.join(file, f))
+        }
+        return
+      end
+
+      files= Dir.glob(full_path)
+      if (files.length>0)
+        files.each { |f|
+          source_file= SourceFile.from_path(f)
+          next if (@files.include?(source_file))
+          @files << source_file
+        }
+        return
+      end
+    
+      # file not found by globbing (would also find explicit reference)
+      source_file= @owner.find_file(file) if @owner
+      if !source_file
+        puts "full_path=#{full_path}\nsource_folder=#{@owner.source_folder}"
+        error("Unable to locate file: #{file}")
+        return
+      end
+      return if (@files.include?(source_file))
+      @files << source_file
+    end
+  
+    def each
+      files.each { |f| yield f }
+    end
+  
+  end
+
+end

data/lib/distil/configurable/interpolated.rb

@@ -0,0 +1,36 @@
+module Distil
+  
+  class Interpolated
+    
+    def initialize(value, owner=nil)
+      @value=value
+      @owner=owner
+    end
+
+    def self.from_options(set, owner)
+      self.new(set, owner)
+    end
+    
+    def self.value_of(value, owner)
+      return value if !owner
+      
+      value.gsub(/\$\((\w+)\)/) { |match|
+        v= case
+        when owner.respond_to?($1)
+          owner.send $1
+        when owner.is_a?(Configurable)
+          owner.get_option($1)
+        end
+        
+        v || "$(#{$1})"
+      }
+    end
+    
+    def value_of(owner=nil)
+      owner||=@owner
+      self.class.value_of(@value, owner)
+    end
+    
+  end
+  
+end

data/lib/distil/configurable/output-path.rb

@@ -0,0 +1,25 @@
+require 'distil/configurable/project-path'
+
+module Distil
+  
+  class OutputPath < Interpolated
+    
+    def self.value_of(value, owner)
+      return value if !owner
+      
+      value= super(value, owner)
+
+      return value if 0==value.index(File::SEPARATOR)
+      return value if !owner.is_a?(Configurable)
+      
+      path= owner.get_option("output_folder")
+      return value if !path || path.empty?
+      
+      return value if value!=path && 0==value.index(path)
+      
+      File.join(path, value)
+    end
+    
+  end
+  
+end

data/lib/distil/configurable/project-path.rb

@@ -0,0 +1,25 @@
+require 'distil/configurable/interpolated'
+
+module Distil
+  
+  class ProjectPath < Interpolated
+    
+    def self.value_of(value, owner)
+      return value if !owner
+      
+      value= super(value, owner)
+
+      return value if 0==value.index(File::SEPARATOR)
+      return value if !owner.is_a?(Configurable)
+      
+      path= owner.get_option("path")
+      return value if !path || path.empty?
+      
+      return value if value!=path && 0==value.index(path)
+      
+      File.join(path, value)
+    end
+    
+  end
+  
+end