sproutcore 0.9.0

data/jsdoc/templates/sproutcore/publish.js

@@ -0,0 +1,236 @@
+require("app/JsHilite.js");
+
+function basename(filename) {
+  filename.match(/([^\/\\]+)\.[^\/\\]+$/);
+  return RegExp.$1;
+}
+
+// This is the orginial function from Stuart Langridge at http://www.kryogenix.org/
+// This is the update function from Jeff Minard - http://www.jrm.cc/
+function superTextile(s) {
+
+  // CAJ - First, strip out extra newlines and whitespace at the start
+  // of comments.  This will yield more appropriate text for formatting.
+  s = s.split("\n").map(function(l) { return ((l=='') || (l.match(/^\s+$/))) ? "" : l.replace(/^\s+/,'') ; }).join("\n") ;
+
+  var r = s;
+  // quick tags first
+  qtags = [ ['\\*', '\\*', 'strong'],
+            ['\\?\\?', '\\?\\?', 'cite'],
+            ['\\+', '\\+', 'ins'],  //fixed
+            ['~', '~', 'sub'],   
+            ['\\^', '\\^', 'sup'], // me
+            ['{{{', '}}}', 'code']];
+  
+  for (var i=0;i<qtags.length;i++) {
+    var ttag_o = qtags[i][0], ttag_c = qtags[i][1], htag = qtags[i][2];
+    re = new RegExp(ttag_o+'\\b(.+?)\\b'+ttag_c,'g');
+    r = r.replace(re,'<'+htag+'>'+'$1'+'</'+htag+'>');
+  };
+  
+  // underscores count as part of a word, so do them separately
+  re = new RegExp('\\b_(.+?)_\\b','g');
+  r = r.replace(re,'<em>$1</em>');
+
+  //jeff: so do dashes
+  re = new RegExp('[\s\n]-(.+?)-[\s\n]','g');
+  r = r.replace(re,'<del>$1</del>');
+
+  // links
+  re = new RegExp('"\\b(.+?)\\(\\b(.+?)\\b\\)":([^\\s]+)','g');
+  r = r.replace(re,'<a href="$3" title="$2">$1</a>');
+
+  re = new RegExp('"\\b(.+?)\\b":([^\\s]+)','g');
+  r = r.replace(re,'<a href="$2">$1</a>');
+
+  // images
+  re = new RegExp('!\\b(.+?)\\(\\b(.+?)\\b\\)!','g');
+  r = r.replace(re,'<img src="$1" alt="$2">');
+  re = new RegExp('!\\b(.+?)\\b!','g');
+  r = r.replace(re,'<img src="$1">');
+
+  // block level formatting
+  lines = r.split('\n');
+  out = [] ;
+  nr = '';
+  var incode = 0 ;
+  var cur_block = [] ; // collect lines into a block before processing them.
+  for (var i=0;i<lines.length;i++) {
+    var line = lines[i].replace(/\s*$/,'');
+    changed = 0;
+
+    // handle incode behavior.
+    if (incode) {
+      
+      // Look for end closing bracket and process it.
+      if (line.match(/^\s*}}}\s*$/)) {
+        incode = 0 ;
+        out.push("<p class=\"code\"><code>" + cur_block.join("<br />") + "</code></p>") ;
+        cur_block = [] ;
+        
+      // otherwise, just add the line to the current block
+      } else {
+        cur_block.push(line) ;
+      }
+
+    // for normal text, look for line-level items to replace.  If no
+    // replacement is found, then add the line to the current block.
+    } else {
+
+      // an empty line means we should end the current paragraph
+      if ((line == '') || line.match(/^\s+$/)) {
+        changed = 1 ;
+        line = '' ;
+        
+      // convert bq. => blockquote.
+      } else if (line.search(/^\s*bq\.\s+/) != -1) { 
+        line = line.replace(/^\s*bq\.\s+/,'\t<blockquote>')+'</blockquote>'; 
+        changed = 1; 
+        
+      // convert h* => heading
+      } else if (line.search(/^\s*h[1|2|3|4|5|6]\.\s+/) != -1) { 
+        line = line.replace(/^\s*h([1|2|3|4|5|6])\.(.+)/, '<h$1>$2</h$1>');
+        changed = 1; 
+        
+      // convert * to bulletted list.  liu tag will be fixed later.
+      } else if (line.search(/^\s*\*\s+/) != -1) { 
+        line = line.replace(/^\s*\*\s+/,'\t<liu>') + '</liu>'; changed = 1;
+        changed = 1;
+        
+      // convert # to numbered list. lio tag will be fixed later. 
+      } else if (line.search(/^\s*#\s+/) != -1) { 
+        line = line.replace(/^\s*#\s+/,'\t<lio>') + '</lio>'; changed = 1; 
+        changed = 1;
+        
+      // open code tag will start code
+      } else if (line.match(/^\s*\{\{\{\s*$/)) {
+        incode++ ;
+        line = '' ;
+        changed = 1;
+      }
+
+      // if the line was changed, the emit the current block as a paragraph
+      // and emit the line itself.  Otherwise, just push the line into the
+      // current block.
+      if (changed > 0) {
+        if (cur_block.length > 0) {
+          out.push("<p>" + cur_block.join(" ") + '</p>') ;
+          cur_block = [] ;
+        }
+        out.push(line) ;
+      } else {
+        cur_block.push(line) ;
+      }
+    }
+  }
+
+  // done.  if there are any lines left, in the current block, emit it.
+  if (cur_block.length > 0) {
+    out.push("<p>" + cur_block.join(" ") + '</p>') ;
+    cur_block = [] ;
+  }
+
+  // Second pass to do lists.  This will wrap the lists in <li> | <ol> tags.
+  inlist = 0; 
+  listtype = '';
+  for (var i=0;i<out.length;i++) {
+    line = out[i];
+    var addin = null ;
+    
+    if (inlist && listtype == 'ul' && !line.match(/^\t<liu/)) { 
+      addin = '</ul>\n'; inlist = 0; 
+    }
+    
+    if (inlist && listtype == 'ol' && !line.match(/^\t<lio/)) { 
+      addin = '</ol>\n'; inlist = 0; 
+    }
+    
+    if (!inlist && line.match(/^\t<liu/)) { 
+      line = '<ul>' + line; inlist = 1; listtype = 'ul'; 
+    }
+    
+    if (!inlist && line.match(/^\t<lio/)) { 
+      line = '<ol>' + line; inlist = 1; listtype = 'ol'; 
+    }
+
+    if (addin) line = addin + line ;
+    out[i] = line;
+  }
+
+  // Now we can join the string. Yay!
+  r = out.join('\n');
+
+  // jeff added : will correctly replace <li(o|u)> AND </li(o|u)>
+  r = r.replace(/li[o|u]>/g,'li>');
+
+  return r;
+} ;
+
+function publish(fileGroup, context) {
+  var classTemplate = new JsPlate(context.t+"class.tmpl");
+  var indexTemplate = new JsPlate(context.t+"index.tmpl");
+  
+  var allFiles = {};
+  var allClasses = {};
+  var globals = {methods:[], properties:[], alias:"GLOBALS", isStatic:true};
+  
+  for (var i = 0; i < fileGroup.files.length; i++) {
+    var file_basename = basename(fileGroup.files[i].filename);
+    var file_srcname = file_basename+".src.html";
+    
+    for (var s = 0; s < fileGroup.files[i].symbols.length; s++) {
+      if (fileGroup.files[i].symbols[s].isa == "CONSTRUCTOR") {
+        var thisClass = fileGroup.files[i].symbols[s];
+        // sort inherited methods by class
+        var inheritedMethods = fileGroup.files[i].symbols[s].getInheritedMethods();
+        if (inheritedMethods.length > 0) {
+          thisClass.inherited = {};
+          for (var n = 0; n < inheritedMethods.length; n++) {
+            if (! thisClass.inherited[inheritedMethods[n].memberof]) thisClass.inherited[inheritedMethods[n].memberof] = [];
+            thisClass.inherited[inheritedMethods[n].memberof].push(inheritedMethods[n]);
+          }
+        }
+        
+        thisClass.name = fileGroup.files[i].symbols[s].alias;
+        thisClass.source = file_srcname;
+        thisClass.filename = fileGroup.files[i].filename;
+        thisClass.docs = thisClass.name+".html";
+        
+        if (!allClasses[thisClass.name]) allClasses[thisClass.name] = [];
+        allClasses[thisClass.name].push(thisClass);
+      }
+      else if (fileGroup.files[i].symbols[s].alias == fileGroup.files[i].symbols[s].name) {
+        if (fileGroup.files[i].symbols[s].isa == "FUNCTION") {
+          globals.methods.push(fileGroup.files[i].symbols[s]);
+        }
+        else {
+          globals.properties.push(fileGroup.files[i].symbols[s]);
+        }
+      }
+    }
+    
+    if (!allFiles[fileGroup.files[i].path]) {
+      var hiliter = new JsHilite(IO.readFile(fileGroup.files[i].path), JsDoc.opt.e);
+      IO.saveFile(context.d, file_srcname, hiliter.hilite());
+    }
+    fileGroup.files[i].source = file_srcname;
+    allFiles[fileGroup.files[i].path] = true;
+  }
+  
+  for (var c in allClasses) {
+    outfile = c+".html";
+    allClasses[c].outfile = outfile;
+    var output = classTemplate.process(allClasses[c]);
+    IO.saveFile(context.d, outfile, output);
+  }
+  
+  output = classTemplate.process([globals]);
+  IO.saveFile(context.d, "globals.html", output);
+  
+  var output = indexTemplate.process(allClasses);
+  IO.saveFile(context.d, "classes.js", output);
+  IO.copyFile(context.t+"index.html", context.d);
+  IO.copyFile(context.t+"splash.html", context.d);
+  IO.copyFile(context.t+"default.css", context.d) ;
+  IO.copyFile(context.t+"prototype.js", context.d) ;
+}

data/jsdoc/templates/sproutcore/splash.html

@@ -0,0 +1,7 @@
+<html>
+	<head>
+		<title>JsDoc</title>
+	</head>
+	<body>
+	</body>
+</html>

data/lib/sproutcore/build_tools/html_builder.rb

@@ -0,0 +1,88 @@
+require 'erubis'
+require 'sproutcore/helpers'
+require 'sproutcore/view_helpers'
+
+module SproutCore
+  
+  module BuildTools
+
+    # Whenever you build an HTML file for a SproutCore client, an instance of this class
+    # is created to actually process and build the HTML using Erubus.  If you want to add
+    # more methods to use in your HTML files, just include them in HtmlContext.
+    #
+    class HtmlContext 
+
+      include SproutCore::Helpers::TagHelper
+      include SproutCore::Helpers::TextHelper
+      include SproutCore::Helpers::CaptureHelper
+      include SproutCore::Helpers::StaticHelper
+      include SproutCore::ViewHelpers
+      
+      attr_reader :entry, :bundle, :filenames, :filename, :language, :library
+      
+      def initialize(entry, bundle)
+        @entry = nil
+        @language = entry.language
+        @filenames = entry.composite.nil? ? [entry.filename] : entry.composite 
+        @bundle = bundle
+        @library = bundle.library
+      end
+
+      # Actually builds the HTML file from the entry (actually from any composite entries)
+      def build
+
+        @layout_path = bundle.layout_path
+        
+        # Render each filename.  By default, the output goes to the resources string
+        @content_for_resources = ''
+        filenames.each { |fn| _render_one(fn) }
+        
+        # Finally, render the layout.  This should produce the final output to return
+        input = File.read(@layout_path)
+        return eval(Erubis::Eruby.new.convert(input))
+      end
+
+      # render a single entry
+      def _render_one(filename)
+        @filename = filename
+        @entry = bundle.entry_for(filename, :hidden => :include, :language => language)
+
+        # avoid double render of layout path
+         return if @entry.source_path == @layout_path
+        
+        # render. Result goes into @content_for_resources
+        input = File.read(@entry.source_path)
+        @content_for_resources += eval(Erubis::Eruby.new.convert(input))
+        
+        @filename =nil
+        @entry = nil
+      end
+      
+      
+      # Returns the current bundle name.  Often useful for generating titles, etc.
+      def bundle_name; bundle.bundle_name; end
+
+      #### For Rails Compatibility.  render() does not do anything useful since the
+      # new build system is nice about putting things into the right place for output.
+      def render; ''; end
+      
+    end
+    
+    def self.build_html(entry, bundle)
+      context = HtmlContext.new(entry,bundle)
+      output = context.build
+
+      puts "saving: #{entry.filename} to #{entry.build_path}: size: #{output.size}"
+      FileUtils.mkdir_p(File.dirname(entry.build_path))
+      f = File.open(entry.build_path, 'w')
+      f.write(output)
+      f.close
+      
+    end
+    
+    # Building a test is just like building a single page except that we do not include
+    # all the other html templates in the project
+    def self.build_test(entry, bundle); build_html(entry, bundle); end
+    
+  end
+end

data/lib/sproutcore/build_tools/resource_builder.rb

@@ -0,0 +1,194 @@
+module SproutCore
+  
+  module BuildTools
+
+    # Set to override the default behavior (which will follow the build mode)
+    def self.minify?; @minify.nil? ? (Bundle.build_mode != :development) : @minify; end
+    def self.minify=(setting); @minify = setting; end
+    
+    # The ResourceBuilder can combine all of the source files listed in the passed entry
+    # including some basic pre-processing.  The JavaScriptBuilder extends this to do some
+    # JavaScript specific rewriting of URLs, etc. as well.
+    #
+    # The ResourceBuilder knows how 
+    class ResourceBuilder
+
+      attr_reader :bundle, :language, :filenames
+      
+      # Utility method you can call to get the items sorted by load order
+      def self.sort_entries_by_load_order(entries, language, bundle)
+        filenames = entries.map { |e| e.filename }
+        hashed = {}
+        entries.each { |e| hashed[e.filename] = e }
+        
+        sorted = self.new(filenames, language, bundle).required
+        sorted.map { |filename| hashed[filename] }
+      end
+      
+      def initialize(filenames, language, bundle)
+        @bundle = bundle; @language = language; @filenames = filenames
+      end
+
+      # Simply returns the filenames in the order that they were required
+      def required
+        lines = []; required = []
+        while filename = next_filename
+          lines, required = _build_one(filename, lines, required, true)
+        end
+        return lines
+      end
+      
+      # Actually perform the build.  Returns the compiled resource as a single string.
+      def build
+
+        # setup context
+        lines = []
+        required = []
+        
+        # process files
+        while filename = next_filename
+          lines, required = _build_one(filename, lines, required)
+        end
+        
+        return join(lines)
+      end
+      
+      # Join the lines together.  This is one last chance to do some prep of the data
+      # (such as minifcation and comment stripping)
+      def join(lines); lines.join; end
+      
+      # Tries to build a single resource.  This may call itself recursively to handle
+      # requires.
+      #
+      # ==== Returns
+      # [lines, required] to be passed into the next call
+      #
+      def _build_one(filename, lines, required, link_only = false)
+        return [lines, required] if required.include?(filename)
+        required << filename
+
+        entry = bundle.entry_for(filename, :hidden => :include, :language => language)
+        if entry.nil?
+          puts "WARNING: Could not find require file: #{filename}"
+          return [lines, required]
+        end
+        
+        file_lines = []
+        io = entry.source_path.nil? ? [] : File.new(entry.source_path)
+        io.each do | line |
+          
+          # check for requires.  Only follow a require if the require is in the list
+          # of filenames.
+          required_file = _require_for(filename, line) 
+          unless required_file.nil? || !filenames.include?(required_file)
+            lines, required = _build_one(required_file, lines, required, link_only)
+          end
+          
+          file_lines << _rewrite_static_urls(line) unless link_only 
+        end
+
+        # The list of already required filenames is slightly out of order from the actual
+        # load order.  Instead, we use the lines array to hold the list of filenames as they
+        # are processed.
+        if link_only
+          lines << filename
+          
+        elsif file_lines.size > 0
+          lines += file_lines
+          lines << "\n"
+        end
+        
+        return [lines, required]
+      end
+
+      # Overridden by subclasses to choose first filename.
+      def next_filename; filenames.delete(filenames.first); end
+
+      # This will look for calls to static_url() and rewrite them with an actual
+      # string to the URL. Assumes the input text is JavaScript or CSS.
+      def _rewrite_static_urls(line)
+        line.gsub(/static_url\([\'\"](.+)[\'\"]\)/) do | rsrc |
+          entry = bundle.find_resource_entry($1, :language => language)
+          static_url(entry.nil? ? '' : entry.url)
+        end
+      end
+
+      # Overridden by subclass to handle static_url() in a language specific way.
+      def static_url(url); "url('#{url}')"; end
+      
+      # check line for required() pattern.  understands JS and CSS.
+      def _require_for(filename,line)
+        new_file = line.scan(/require\(['"](.*)['"]\)/)
+        ret = (new_file.size > 0) ? new_file.first.first : nil 
+        ret.nil? ? nil : filename_for_require(ret)
+      end
+      
+      def filename_for_require(ret); "#{ret}.css"; end
+      
+    end
+
+    class JavaScriptResourceBuilder < ResourceBuilder
+
+      # Final processing of file.  Remove comments & minify
+      def join(lines)
+
+        if BuildTools.minify?
+          # first suck out any comments that should be retained
+          comments = []
+          include_line = false 
+          lines.each do | line |
+            is_mark = (line =~ /@license/)
+            unless include_line
+              include_line = true if is_mark
+              is_mark = false
+            end
+
+            comments << line if include_line
+            include_line = false if include_line && is_mark
+          end
+
+          # now minify and prepend any static
+          comments.push "\n" unless comments.empty?
+          comments.push SproutCore::JSMin.run(lines * '') 
+          lines = comments
+        end
+        
+        lines.join
+      end
+      
+      def static_url(url); "'#{url}'"; end
+      def filename_for_require(ret); "#{ret}.js"; end
+      
+      def next_filename
+        filenames.delete('strings.js') || filenames.delete('core.js') || filenames.delete('Core.js') || filenames.delete('utils.js') || filenames.delete(filenames.first)
+      end
+      
+    end
+    
+    def self.build_stylesheet(entry, bundle)
+      filenames = entry.composite.nil? ? [entry.filename] : entry.composite
+      builder = ResourceBuilder.new(filenames, entry.language, bundle) 
+      if output = builder.build
+        FileUtils.mkdir_p(File.dirname(entry.build_path))
+        f = File.open(entry.build_path, 'w')
+        f.write(output)
+        f.close
+      end
+    end
+
+    def self.build_javascript(entry, bundle)
+      filenames = entry.composite.nil? ? [entry.filename] : entry.composite
+      builder = JavaScriptResourceBuilder.new(filenames, entry.language, bundle) 
+      if output = builder.build
+        FileUtils.mkdir_p(File.dirname(entry.build_path))
+        f = File.open(entry.build_path, 'w')
+        f.write(output)
+        f.close
+      end
+    end
+    
+    def self.build_fixture(entry, bundle); build_javascript(entry, bundle); end
+    
+  end
+  
+end

data/lib/sproutcore/build_tools.rb

@@ -0,0 +1,44 @@
+module SproutCore
+
+  # This module contains entry points to builds tools that handle various types of resources
+  # in a SproutCore client.  Each build tool has a method "build_xx(entry, bundle)" that can
+  # be called here.
+  #
+  # You can add your own build tools to the system here .
+  #
+  module BuildTools
+    
+    # Resources are sometimes accessed through a symlink while running in devmode.  This 
+    # method should simply ensure that symlink exists.
+    #
+    def self.build_symlink(entry, bundle)
+      symlink_path = File.join(bundle.build_root, '_src')
+      source_path = bundle.source_root
+      unless File.exist?(symlink_path)
+        FileUtils.mkdir_p(bundle.build_root)
+        FileUtils.ln_sf(source_path, symlink_path)
+      end
+    end
+    
+    # Regular resources and tests are simply copied.  Note that normally in development mode,
+    # these resources will be accessed via a symlink
+    def self.copy_resource(entry, bundle)
+      FileUtils.mkdir_p(File.dirname(entry.build_path))
+      
+      # Make the source file exists
+      unless File.exists?(entry.source_path)
+        raise "Could not copy resource #{entry.filename} because source: #{entry.source_path} does not exist!"
+      end
+      
+      # Now do the copy
+      FileUtils.cp_r(entry.source_path, entry.build_path)
+    end
+    
+    def self.build_resource(entry, bundle); copy_resource(entry, bundle); end
+    
+  end
+  
+end
+
+# Load other build tools.  The above are the simple ones.
+Dir.glob(File.join(File.dirname(__FILE__),'build_tools','**','*.rb')).each { |x| require x }