rid 0.3.0

data/lib/rid/commands.rb

@@ -0,0 +1,41 @@
+if ARGV.empty?
+  ARGV << '--help'
+end
+
+HELP_TEXT = <<-EOT
+Usage: rid COMMAND [ARGS]
+
+The most common rid commands are:
+ generate    Generate new code (short-cut alias: "g")
+ push        Push application code to Couchdb
+ pull        Pull latest application code from Couchdb
+ routes      List application urls
+
+In addition to those, there are:
+ destroy      Undo code generated with "generate"
+
+All commands can be run with -h for more information.
+EOT
+
+
+case ARGV.shift
+when 'g', 'generate'
+  require 'rid/commands/generate'
+when 'destroy'
+  require 'rid/commands/destroy'
+when 'push'
+  require 'rid/commands/push'
+when 'pull'
+  require 'rid/commands/pull'
+when 'routes'
+  require 'rid/commands/routes'
+
+when '--help', '-h'
+  puts HELP_TEXT
+when '--version', '-v'
+  require 'rid/version'
+  puts "Rid #{Rid::VERSION}"
+else
+  puts "Error: Command not recognized"
+  puts HELP_TEXT
+end

data/lib/rid/commands/destroy.rb

@@ -0,0 +1,9 @@
+require 'rid/generators'
+
+if [nil, "-h", "--help"].include?(ARGV.first)
+  Rid::Generators.help 'destroy'
+  exit
+end
+
+name = ARGV.shift
+Rid::Generators.invoke name, ARGV, :behavior => :revoke, :destination_root => Rid.root

data/lib/rid/commands/generate.rb

@@ -0,0 +1,9 @@
+require 'rid/generators'
+
+if [nil, "-h", "--help"].include?(ARGV.first)
+  Rid::Generators.help 'generate'
+  exit
+end
+
+name = ARGV.shift
+Rid::Generators.invoke name, ARGV, :behavior => :invoke, :destination_root => Rid.root

data/lib/rid/commands/pull.rb

@@ -0,0 +1,4 @@
+require 'rid'
+require 'rid/actions/pull'
+
+Rid::Actions::Pull.start ARGV, :destination_root => Rid.root

data/lib/rid/commands/push.rb

@@ -0,0 +1,4 @@
+require 'rid'
+require 'rid/actions/push'
+
+Rid::Actions::Push.start ARGV, :destination_root => Rid.root

data/lib/rid/commands/routes.rb

@@ -0,0 +1,4 @@
+require 'rid'
+require 'rid/actions/routes'
+
+Rid::Actions::Routes.start ARGV, :destination_root => Rid.root

data/lib/rid/design_document.rb

@@ -0,0 +1,179 @@
+require 'rid/attachments'
+require 'rid/makros'
+
+require 'uri'
+
+module Rid
+  class DesignDocument
+    # Files that should have a .js extension
+    JAVASCRIPT_FILES = %w[
+      validate_doc_update
+      lists/*
+      shows/*
+      updates/*
+      views/*/*
+    ]
+
+    # Files that should not be included in document
+    EXCLUDE_FILES = %w[
+      README
+    ]
+
+    include Attachments
+    include Makros
+
+    attr_accessor :hash
+
+    def initialize
+      @hash = {}
+    end
+
+    # Read document from a filesystem.
+    #
+    # Takes a filename,
+    # many filenames,
+    # or an array of filenames
+    # and assign the return value of a yielded block to the hash.
+    #
+    # Nested hashes
+    # like { "hash" => { "key" => "value" } }
+    # can be constructed if the filename contains a slash (/),
+    # eg "hash/key".
+    #
+    def read(*filenames, &block)
+      filenames.flatten.uniq.each do |filename|
+        # skip exclude files
+        next if EXCLUDE_FILES.include?(filename)
+
+        key = filename.dup
+        # strip extname from javascript files
+        key.sub!(/\.js$/, '') if filename =~ /#{JAVASCRIPT_FILES.join('|')}/
+
+        set_hash_at key, block.call(filename)
+      end
+
+      map_attachments!
+      inject_makros!
+    end
+
+    # Write document to a filesystem
+    #
+    # Takes a directoy as startpoint (default is nil),
+    # a document hash (default is the design documents hash)
+    # and recursively yields all keys and values to the given block.
+    #
+    # Nested hashes
+    # like { "hash" => { "key" => "value" } }
+    # will result in the yielded filename
+    # "hash/key".
+    #
+    # The key "_attachments" has a special meaning:
+    # the value holds base64 encoded data as well as other metadata.
+    # This data will gets decoded and used as value for the key.
+    # 
+    def write(directory = nil, doc = nil, &block)
+      reduce_attachments!
+      reject_makros!
+
+      doc ||= hash
+      doc.each do |key, value|
+        filename = directory ? File.join(directory, key) : key.dup
+        if value.is_a?(Hash)
+          write(filename, value, &block)
+        else
+          # append extname to javascript files
+          filename << '.js' if filename =~ /#{JAVASCRIPT_FILES.join('|')}/
+          block.call(filename, value)
+        end
+      end
+    end
+
+    # Returns a JSON string representation of the documents hash
+    #
+    def json
+      hash.to_json
+    end
+
+    # Build the documents hash from a JSON string
+    #
+    def json=(json)
+      self.hash = JSON.parse(json)
+    end
+
+
+    # Accessor for id
+    def id
+      hash["_id"] || Rid.id
+    end
+
+    # Accessor for rev
+    def rev
+      hash["_rev"] || Rid.rev
+    end
+
+    # Updates rev in documents hash
+    def rev=(new_rev)
+      hash["_rev"] = new_rev
+    end
+
+
+    # Accessor for rid database
+    def database
+      @database ||= Rid.database
+    end
+
+    # Base URL for document
+    def base_url
+      @base_url ||= File.join(database, id)
+    end
+
+    # URL for accessing design document
+    # 
+    # Takes an optional options hash
+    # which gets converted to url encoded options
+    # and appended to the documents base url
+    #
+    def url(options = {})
+      base_url + build_options_string(options)
+    end
+
+    private
+
+    def hash_at(path)
+      current_hash = hash
+
+      parts = path.split('/')
+      key = parts.pop
+
+      parts.each do |part|
+        current_hash[part] ||= {}
+        current_hash = current_hash[part]
+      end
+
+      current_hash[key]
+    end
+
+    def set_hash_at(path, value)
+      current_hash = hash
+
+      parts = path.split('/')
+      key = parts.pop
+
+      parts.each do |part|
+        current_hash[part] ||= {}
+        current_hash = current_hash[part]
+      end
+
+      current_hash[key] = value
+    end
+
+    def build_options_string(options)
+      return '' if options.empty?
+      options_array = []
+      options.each do |key, value|
+        options_array << URI.escape([key, value].join('='))
+      end
+      '?' + options_array.join("&")
+    end
+  end
+end

data/lib/rid/generators.rb

@@ -0,0 +1,63 @@
+require 'rid'
+require 'rid/generators/base'
+
+module Rid
+  module Generators
+    # Receives a name, arguments and the behavior to invoke the generator.
+    # It's used as the default entry point for generate and destroy commands.
+    def self.invoke(name, args = ARGV, config = {})
+      if klass = lookup(name.to_s)
+        args << "--help" if args.empty? && klass.arguments.any? { |a| a.required? }
+        klass.start(args, config)
+      else
+        puts "Could not find generator #{name}."
+      end
+    end
+
+    # Show help message with available generators.
+    def self.help(command = 'generate')
+      path = File.expand_path("../generators/*/*_generator.rb", __FILE__)
+      generators = Dir.glob(path)
+      generators.sort!
+      generators.map! { |f| File.basename(f) }
+      generators.map! { |n| n.sub!(/_generator\.rb$/, '')  }
+      longest_name_size = generators.map { |g| g.size }.sort.last
+      generators.map! { |g| "%s  # %s" % [g.ljust(longest_name_size), lookup(g).info] }
+
+      puts "Usage: rid #{command} GENERATOR [args] [options]"
+      puts
+      puts "General options:"
+      puts "  -h, [--help]     # Print generators options and usage"
+      puts "  -p, [--pretend]  # Run but do not make any changes"
+      puts "  -f, [--force]    # Overwrite files that already exist"
+      puts "  -s, [--skip]     # Skip files that already exist"
+      puts "  -q, [--quiet]    # Supress status output"
+      puts
+      puts "Please choose a generator below:"
+      puts
+      puts generators
+    end
+
+    protected
+
+    def self.lookup(name)
+      # real path
+      path = File.expand_path("../generators/#{name}/#{name}_generator.rb", __FILE__)
+      # no matches?
+      unless File.exists?(path)
+        # try to find by prefix
+        found = Dir.glob(File.expand_path("../generators/#{name}*/#{name}*_generator.rb", __FILE__))
+        if found.size == 1
+          path = found.first
+          name = File.basename(path).sub(/_generator\.rb$/, '')
+        end
+      end
+      require path
+      const_get "#{name.classify}Generator"
+    rescue LoadError => e
+      raise unless e.message =~ /#{Regexp.escape(path)}$/
+    rescue Exception => e
+      warn "[WARNING] Could not load generator #{path.inspect}. Error: #{e.message}.\n#{e.backtrace.join("\n")}"
+    end
+  end
+end

data/lib/rid/generators/application/USAGE

@@ -0,0 +1,10 @@
+Description:
+    The 'application' generator creates a new Rid application
+    with a default directory structure and configuration
+    at the path you specify.
+
+Example:
+    rid generate application ~/rid/weblog
+
+    This generates a skeletal Rid installation in ~/rid/weblog.
+    See the README in the newly created application to get going.

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

@@ -0,0 +1,51 @@
+module Rid::Generators
+  class ApplicationGenerator < Base
+    argument :app_path, :type => :string
+
+    def create_root
+      self.destination_root = File.expand_path(app_path, destination_root)
+ 
+      empty_directory '.'
+      FileUtils.cd(destination_root) if File.directory?(destination_root)
+    end
+
+    def create_root_files
+      template "ridrc", ".ridrc"
+      copy_file "README"
+      copy_file "gitignore", ".gitignore" unless options[:skip_git]
+      template "_id"
+      copy_file "validate_doc_update.js"
+      empty_directory "lists"
+      empty_directory "shows"
+      empty_directory "updates"
+      empty_directory "views"
+    end
+
+    def create_attachments_files
+      empty_directory "_attachments"
+      inside "_attachments" do
+        empty_directory "images"
+        empty_directory "javascripts"
+        directory "stylesheets"
+        template "index.html"
+      end
+    end
+
+    def create_lib_files
+      empty_directory "lib"
+      inside "lib" do
+       copy_file "mustache.js"
+      end
+    end
+
+    protected
+
+    def app_name
+      @app_name ||= File.basename(destination_root)
+    end
+
+    def app_title
+      @app_title ||= app_name.humanize
+    end
+  end
+end

data/lib/rid/generators/application/templates/README

@@ -0,0 +1 @@
+# Welcome to Rid!

data/lib/rid/generators/application/templates/_attachments/index.html

@@ -0,0 +1,11 @@
+<!DOCTYPE HTML>
+<html>
+  <head>
+    <meta http-equiv="content-type" content="text/html; charset=utf-8">
+    <title><%= app_title %></title>
+    <link rel="stylesheet" href="stylesheets/application.css" type="text/css" media="screen" charset="utf-8">
+  </head>
+  <body>
+    <h1>Welcome to <%= app_title %>!</h1>
+  </body>
+</html>

data/lib/rid/generators/application/templates/_attachments/stylesheets/application.css

@@ -0,0 +1,25 @@
+body {
+  background-color: #fff;
+  color: #333;
+  margin: 1cm 1.618cm;
+}
+
+body, p, ol, ul, td {
+  font-family: verdana, arial, helvetica, sans-serif;
+  font-size:   13px;
+  line-height: 18px;
+}
+
+pre {
+  background-color: #eee;
+  padding: 10px;
+  font-size: 11px;
+}
+
+a { color: #000; }
+a:visited { color: #666; }
+a:hover { color: #fff; background-color:#000; }
+
+.notice {
+  color: green;
+}

data/lib/rid/generators/application/templates/_id

@@ -0,0 +1 @@
+_design/<%= app_name %>

data/lib/rid/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");
+      }
+    }
+  });
+}();