couch 0.1.1 → 0.1.2

data/.gitmodules

@@ -1,3 +1,3 @@
-[submodule "lib/couch/generators/application/templates/lib/mustache"]
-	path = lib/couch/generators/application/templates/lib/mustache
+[submodule "vendor/mustache.js"]
+	path = vendor/mustache.js
 	url = git://github.com/janl/mustache.js.git

data/README.rdoc

@@ -31,13 +31,13 @@ Building standalone CouchDB applications according to correct principles affords
 == What comes next
 
 At the moment, Couch supports generating a scaffold application, pushing to a CouchDB server and pulling from a CouchDB.
+Couch injects the !code and !json makros introduced by CouchApp.
 
 The next big steps are:
 
-* support +code+ and +json+ makros to manage shared pieces of code
-* add the powerful mustache.js Template engine (http://github.com/janl/mustache.js)
-* add more code generators to rapidly get you started
-
+* make use of mustache.js in generators
+* build a lightweight JavaScript library to assist client side JavaScript work
+* enhance generators to build a full flavored scaffold with all CRUD operations
 
 == I need your help!
 

data/Rakefile

@@ -2,6 +2,25 @@ require 'rubygems'
 require 'rake'
 require File.join(File.dirname(__FILE__), 'lib', 'couch', 'version')
 
+namespace :vendor do
+  desc "Update vendor"
+  task :update do
+    `git submodule update`
+  end
+
+  desc "vendor mustache"
+  task :mustache do
+    dir = File.expand_path('..', __FILE__)
+    source = File.join(dir, 'vendor/mustache.js/mustache.js')
+    target = File.join(dir, 'lib/couch/generators/application/templates/lib/')
+    FileUtils.cp source, target
+  end
+end
+
+desc "Vendor all"
+task :vendor => ["vendor:update", "vendor:mustache"]
+
+
 begin
   require 'jeweler'
   Jeweler::Tasks.new do |gem|

data/couch.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{couch}
-  s.version = "0.1.1"
+  s.version = "0.1.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Johannes J. Schmidt"]
@@ -47,6 +47,7 @@ Gem::Specification.new do |s|
      "lib/couch/generators/application/templates/_id.js",
      "lib/couch/generators/application/templates/couchrc",
      "lib/couch/generators/application/templates/gitignore",
+     "lib/couch/generators/application/templates/lib/mustache.js",
      "lib/couch/generators/application/templates/validate_doc_update.js",
      "lib/couch/generators/base.rb",
      "lib/couch/generators/list/USAGE",

data/lib/couch/generators/application/application_generator.rb

@@ -34,7 +34,7 @@ module Couch::Generators
     def create_lib_files
       empty_directory "lib"
       inside "lib" do
-       copy_file "mustache/mustache.js", "mustache.js"
+       copy_file "mustache.js"
       end
     end
 

data/lib/couch/generators/application/templates/lib/mustache.js

@@ -0,0 +1,305 @@
+/*
+  Shameless port of http://github.com/defunkt/mustache
+  by Jan Lehnardt <jan@apache.org>, 
+     Alexander Lang <alex@upstream-berlin.com>,
+     Sebastian Cohnen <sebastian.cohnen@googlemail.com>
+
+  Thanks @defunkt for the awesome code.
+
+  See http://github.com/defunkt/mustache for more info.
+*/
+
+var Mustache = function() {
+  var Renderer = function() {};
+
+  Renderer.prototype = {
+    otag: "{{",
+    ctag: "}}",
+    pragmas: {},
+    buffer: [],
+    pragmas_parsed: false,
+    pragmas_implemented: {
+      "IMPLICIT-ITERATOR": true
+    },
+
+    render: function(template, context, partials, in_recursion) {
+      // fail fast
+      if(template.indexOf(this.otag) == -1) {
+        if(in_recursion) {
+          return template;
+        } else {
+          this.send(template);
+          return;
+        }
+      }
+
+      if(!in_recursion) {
+        this.buffer = [];
+      }
+
+      if(!this.pragmas_parsed) {
+        template = this.render_pragmas(template);
+      }
+      var html = this.render_section(template, context, partials);
+      if(in_recursion) {
+        return this.render_tags(html, context, partials, in_recursion);
+      }
+
+      this.render_tags(html, context, partials, in_recursion);
+    },
+
+    /*
+      Sends parsed lines
+    */
+    send: function(line) {
+      if(line != "") {
+        this.buffer.push(line);
+      }
+    },
+
+    /*
+      Looks for %PRAGMAS
+    */
+    render_pragmas: function(template) {
+      this.pragmas_parsed = true;
+      // no pragmas
+      if(template.indexOf(this.otag + "%") == -1) {
+        return template;
+      }
+
+      var that = this;
+      var regex = new RegExp(this.otag + "%([\\w_-]+) ?([\\w]+=[\\w]+)?"
+        + this.ctag);
+      return template.replace(regex, function(match, pragma, options) {
+        if(!that.pragmas_implemented[pragma]) {
+          throw({message: "This implementation of mustache doesn't understand the '"
+            + pragma + "' pragma"});
+        }
+        that.pragmas[pragma] = {};
+        if(options) {
+          var opts = options.split("=");
+          that.pragmas[pragma][opts[0]] = opts[1];
+        }
+        return "";
+        // ignore unknown pragmas silently
+      });
+    },
+
+    /*
+      Tries to find a partial in the global scope and render it
+    */
+    render_partial: function(name, context, partials) {
+      if(typeof(context[name]) != "object") {
+        throw({message: "subcontext for '" + name + "' is not an object"});
+      }
+      if(!partials || !partials[name]) {
+        throw({message: "unknown_partial '" + name + "'"});
+      }
+      return this.render(partials[name], context[name], partials, true);
+    },
+
+    /*
+      Renders boolean and enumerable sections
+    */
+    render_section: function(template, context, partials) {
+      if(template.indexOf(this.otag + "#") == -1) {
+        return template;
+      }
+      var that = this;
+      // CSW - Added "+?" so it finds the tighest bound, not the widest
+      var regex = new RegExp(this.otag + "\\#(.+)" + this.ctag +
+              "\\s*([\\s\\S]+?)" + this.otag + "\\/\\1" + this.ctag + "\\s*", "mg");
+
+      // for each {{#foo}}{{/foo}} section do...
+      return template.replace(regex, function(match, name, content) {
+        var value = that.find(name, context);
+        if(that.is_array(value)) { // Enumerable, Let's loop!
+          return that.map(value, function(row) {
+            return that.render(content, that.merge(context,
+                    that.create_context(row)), partials, true);
+          }).join("");
+        } else if(value) { // boolean section
+          return that.render(content, context, partials, true);
+        } else {
+          return "";
+        }
+      });
+    },
+
+    /*
+      Replace {{foo}} and friends with values from our view
+    */
+    render_tags: function(template, context, partials, in_recursion) {
+      // tit for tat
+      var that = this;
+
+      var new_regex = function() {
+        return new RegExp(that.otag + "(=|!|>|\\{|%)?([^\/#]+?)\\1?" +
+          that.ctag + "+", "g");
+      };
+
+      var regex = new_regex();
+      var lines = template.split("\n");
+       for (var i=0; i < lines.length; i++) {
+         lines[i] = lines[i].replace(regex, function(match, operator, name) {
+           switch(operator) {
+             case "!": // ignore comments
+               return match;
+             case "=": // set new delimiters, rebuild the replace regexp
+               that.set_delimiters(name);
+               regex = new_regex();
+               return "";
+             case ">": // render partial
+               return that.render_partial(name, context, partials);
+             case "{": // the triple mustache is unescaped
+               return that.find(name, context);
+             default: // escape the value
+               return that.escape(that.find(name, context));
+           }
+         }, this);
+         if(!in_recursion) {
+           this.send(lines[i]);
+         }
+       }
+
+       if(in_recursion) {
+         return lines.join("\n");
+       }
+    },
+
+    set_delimiters: function(delimiters) {
+      var dels = delimiters.split(" ");
+      this.otag = this.escape_regex(dels[0]);
+      this.ctag = this.escape_regex(dels[1]);
+    },
+
+    escape_regex: function(text) {
+      // thank you Simon Willison
+      if(!arguments.callee.sRE) {
+        var specials = [
+          '/', '.', '*', '+', '?', '|',
+          '(', ')', '[', ']', '{', '}', '\\'
+        ];
+        arguments.callee.sRE = new RegExp(
+          '(\\' + specials.join('|\\') + ')', 'g'
+        );
+      }
+    return text.replace(arguments.callee.sRE, '\\$1');
+    },
+
+    /*
+      find `name` in current `context`. That is find me a value
+      from the view object
+    */
+    find: function(name, context) {
+      name = this.trim(name);
+      if(typeof context[name] === "function") {
+        return context[name].apply(context);
+      }
+      if(context[name] !== undefined) {
+        return context[name];
+      }
+      // silently ignore unkown variables
+      return "";
+    },
+
+    // Utility methods
+
+    /*
+      Does away with nasty characters
+    */
+    escape: function(s) {
+      return ((s == null) ? "" : s).toString().replace(/[&"<>\\]/g, function(s) {
+        switch(s) {
+          case "&": return "&amp;";
+          case "\\": return "\\\\";;
+          case '"': return '\"';;
+          case "<": return "&lt;";
+          case ">": return "&gt;";
+          default: return s;
+        }
+      });
+    },
+
+    /*
+      Merges all properties of object `b` into object `a`.
+      `b.property` overwrites a.property`
+    */
+    merge: function(a, b) {
+      var _new = {};
+      for(var name in a) {
+        if(a.hasOwnProperty(name)) {
+          _new[name] = a[name];
+        }
+      };
+      for(var name in b) {
+        if(b.hasOwnProperty(name)) {
+          _new[name] = b[name];
+        }
+      };
+      return _new;
+    },
+
+    // by @langalex, support for arrays of strings
+    create_context: function(_context) {
+      if(this.is_object(_context)) {
+        return _context;
+      } else if(this.pragmas["IMPLICIT-ITERATOR"]) {
+        var iterator = this.pragmas["IMPLICIT-ITERATOR"].iterator || ".";
+        var ctx = {};
+        ctx[iterator] = _context
+        return ctx;
+      }
+    },
+
+    is_object: function(a) {
+      return a && typeof a == "object";
+    },
+
+    is_array: function(a) {
+      return Object.prototype.toString.call(a) === '[object Array]';
+    },
+
+    /*
+      Gets rid of leading and trailing whitespace
+    */
+    trim: function(s) {
+      return s.replace(/^\s*|\s*$/g, "");
+    },
+
+    /*
+      Why, why, why? Because IE. Cry, cry cry.
+    */
+    map: function(array, fn) {
+      if (typeof array.map == "function") {
+        return array.map(fn)
+      } else {
+        var r = [];
+        var l = array.length;
+        for(i=0;i<l;i++) {
+          r.push(fn(array[i]));
+        }
+        return r;
+      }
+    }
+  };
+
+  return({
+    name: "mustache.js",
+    version: "0.2.3-dev",
+
+    /*
+      Turns a template and view into HTML
+    */
+    to_html: function(template, view, partials, send_fun) {
+      var renderer = new Renderer();
+      if(send_fun) {
+        renderer.send = send_fun;
+      }
+      renderer.render(template, view, partials);
+      if(!send_fun) {
+        return renderer.buffer.join("\n");
+      }
+    }
+  });
+}();

data/lib/couch/version.rb

@@ -1,3 +1,3 @@
 module Couch
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 1
-  version: 0.1.1
+  - 2
+  version: 0.1.2
 platform: ruby
 authors: 
 - Johannes J. Schmidt
@@ -112,6 +112,7 @@ files:
 - lib/couch/generators/application/templates/_id.js
 - lib/couch/generators/application/templates/couchrc
 - lib/couch/generators/application/templates/gitignore
+- lib/couch/generators/application/templates/lib/mustache.js
 - lib/couch/generators/application/templates/validate_doc_update.js
 - lib/couch/generators/base.rb
 - lib/couch/generators/list/USAGE