jelly 0.5.4

data/generators/jelly/templates/javascripts/jquery/jquery.protify-0.3.js

@@ -0,0 +1,345 @@
+/**
+ *  Protify jQuery Plugin
+ *  version 0.3
+ *
+ * Copyright (c) 2009 Josh Powell
+ * Licensed under the MIT license.
+ *
+ *  * Date: 2009-02-04 11:45:50 (Wed, 04 Feb 2009)
+ *
+ */
+(function ($) {
+  var $break = { };
+  var arrayFunc = {
+    _each: function(iterator) {
+      for (var i = 0, length = this.length; i < length; i++) {
+        iterator(this[i]);
+      }
+    },
+
+    all: function(iterator, context) {
+      iterator = iterator || function(x) { return x; };
+      var result = true;
+      this.each(function(value, index) {
+        result = result && !!iterator.call(context, value, index);
+        if (!result) { throw $break; }
+      });
+      return result;
+    },
+
+    any: function(iterator, context) {
+      iterator = iterator || function(x) { return x; };
+      var result = false;
+      this.each(function(value, index) {
+        if (result = !!iterator.call(context, value, index)) {
+          throw $break;
+        }
+      });
+      return result;
+    },
+
+    clear: function() {
+      this.length = 0;
+      return this;
+    },
+
+    clone: function() {
+      return $.protify([].concat(this));
+    },
+
+    collect: function(iterator, context) {
+      iterator = iterator || function(x) { return x; };
+      var results = $.protify([]);
+      this.each(function(value, index) {
+        results.push(iterator.call(context, value, index));
+      });
+      return results;
+    },
+
+    detect: function(iterator, context) {
+      var result;
+      this.each(function(value, index) {
+        if (iterator.call(context, value, index)) {
+          result = value;
+          throw $break;
+        }
+      });
+      return result;
+    },
+
+    compact: function() {
+      return $.protify(this.select(function(value) {
+        return value !== null;
+      }));
+    },
+
+    each: function(iterator, context) {
+      context = context || this;
+      var index = 0;
+      try {
+        this._each(function(value) {
+          iterator.call(context, value, index++);
+        });
+      } catch (e) {
+        if (e != $break) { throw e; }
+      }
+      return this;
+    },
+
+    eachSlice: function(number, iterator, context) {
+      var index = -number, slices = [], array = this.toArray();
+      if (number < 1) { return array; }
+      while ((index += number) < array.length) {
+        slices.push(array.slice(index, index+number));
+      }
+      return $.protify($.protify(slices).collect(iterator, context));
+    },
+
+    extended : function() {
+      return true;
+    },
+
+    findAll: function(iterator, context) {
+      var results = $.protify([]);
+      this.each(function(value, index) {
+        if (iterator.call(context, value, index)) {
+          results.push(value);
+        }
+      });
+      return results;
+    },
+
+    flatten: function() {
+      return this.inject([], function(array, value) {
+        $.protify(value);
+        return $.protify(array.concat($.isArray(value) ?
+          value.flatten() : [value]));
+      });
+    },
+
+    first: function() {
+      return this[0];
+    },
+
+    grep: function(filter, iterator, context) {
+      iterator = iterator || function(x) { return x; };
+      var results = $.protify([]);
+      if (typeof filter === 'string') {
+        filter = new RegExp(filter);
+      }
+
+      this.each(function(value, index) {
+        if (filter.test(value)) {
+          results.push(iterator.call(context, value, index));
+        }
+      });
+      return results;
+    },
+
+    include: function(object) {
+        if ($.isFunction(this.indexOf)) {
+            if (this.indexOf(object) != -1) {
+              return true;
+            }
+        }
+
+      var found = false;
+      this.each(function(value) {
+        if (value == object) {
+          found = true;
+          throw $break;
+        }
+      });
+      return found;
+    },
+
+    indexOf: function(item, i) {
+        i || (i = 0);
+        var length = this.length;
+        if (i < 0) i = length + i;
+        for (; i < length; i++)
+          if (this[i] === item) return i;
+        return -1;
+    },
+
+    inGroupsOf: function(number, fillWith) {
+      fillWith = fillWith ? null : fillWith;
+      return this.eachSlice(number, function(slice) {
+        while(slice.length < number) { slice.push(fillWith); }
+        return slice;
+      });
+    },
+
+    inject: function(memo, iterator, context) {
+      this.each(function(value, index) {
+        memo = iterator.call(context, memo, value, index);
+      });
+      return memo;
+    },
+
+    inspect: function() {
+      return '[' + this.map($.inspect).join(', ') + ']';
+    },
+
+    intersect: function(array) {
+      $.protify(array);
+      return this.uniq().findAll(function(item) {
+        return array.detect(function(value) { return item === value; });
+      });
+    },
+
+    invoke: function(method) {
+      var args = $.makeArray(arguments).slice(1);
+      return this.map(function(value) {
+        return value[method].apply(value, args);
+      });
+    },
+
+    last: function() {
+      return this[this.length - 1];
+    },
+
+    lastIndexOf : function(item, i) {
+        i = isNaN(i) ? this.length : (i < 0 ? this.length + i : i) + 1;
+        var n = $.protify(this.slice(0, i).reverse()).indexOf(item);
+        return (n < 0) ? n : i - n - 1;
+    },
+    max: function(iterator, context) {
+      iterator = iterator || function(x) { return x; };
+      var result;
+      this.each(function(value, index) {
+        value = iterator.call(context, value, index);
+        if (result == null || value >= result) {
+          result = value;
+        }
+      });
+      return result;
+    },
+
+    min: function(iterator, context) {
+      iterator = iterator || function(x) { return x; };
+      var result;
+      this.each(function(value, index) {
+        value = iterator.call(context, value, index);
+        if (result == null || value < result) {
+          result = value;
+        }
+      });
+      return result;
+    },
+
+    partition: function(iterator, context) {
+      iterator = iterator || function(x) { return x; };
+      var trues = [], falses = [];
+      this.each(function(value, index) {
+        (iterator.call(context, value, index) ? trues : falses).push(value);
+      });
+      return [trues, falses];
+    },
+
+    pluck: function(property) {
+      var results = $.protify([]);
+      this.each(function(value) {
+        results.push(value[property]);
+      });
+      return results;
+    },
+
+    purge: function () {
+      return [].concat(this);
+    },
+
+    reduce: function() {
+      return this.length > 1 ? this : this[0];
+    },
+
+    reject: function(iterator, context) {
+      var results = $.protify([]);
+      this.each(function(value, index) {
+        if (!iterator.call(context, value, index)) {
+          results.push(value);
+        }
+      });
+      return results;
+    },
+
+    size: function() {
+      return this.length;
+    },
+
+    sortBy: function(iterator, context) {
+      return this.map(function(value, index) {
+        return {
+          value: value,
+          criteria: iterator.call(context, value, index)
+        };
+      }).sort(function(left, right) {
+        var a = left.criteria, b = right.criteria;
+        return a < b ? -1 : a > b ? 1 : 0;
+      }).pluck('value');
+    },
+
+    toArray: function() {
+      return $.protify(this.map());
+    },
+
+//  toJSON: function() {
+//  var results = [];
+//  this.each(function(object) {
+//    var value = Object.toJSON(object);
+//    if (!Object.isUndefined(value)) results.push(value);
+//  });
+//  return '[' + results.join(', ') + ']';
+//},
+
+    uniq: function(sorted) {
+      return $.protify(this.inject([], function(array, value, index) {
+        $.protify(array, true);
+        if (0 === index || (sorted ? array.last() != value : !array.include(value))) {
+          array.push(value);
+        }
+        return array;
+      }));
+    },
+
+    without: function() {
+      var values = $.protify($.makeArray(arguments));
+      return $.protify(this.select(function(value) {
+        return !values.include(value);
+      }));
+    },
+
+    zip: function() {
+      var iterator = function(x) { return x; }, args = $.protify($.makeArray(arguments));
+      if ($.isFunction(args.last())) {
+        iterator = args.pop();
+      }
+
+      var collections = $.protify([this].concat(args)).map();
+      return this.map(function(value, index) {
+        return iterator(collections.pluck(index));
+      });
+    }
+  };
+
+  $.extend(arrayFunc, {
+    map:     arrayFunc.collect,
+    find:    arrayFunc.detect,
+    select:  arrayFunc.findAll,
+    filter:  arrayFunc.findAll,
+    member:  arrayFunc.include,
+    entries: arrayFunc.toArray,
+    every:   arrayFunc.all,
+    some:    arrayFunc.any
+  });
+
+  $.protify = function(target, permanent) {
+    if (permanent) {
+      $.extend(target, arrayFunc);
+      return target;
+    }
+    target = $.extend(target.slice(), arrayFunc);
+    return target;
+  };
+
+})(jQuery);

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/jelly.gemspec

@@ -0,0 +1,77 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{jelly}
+  s.version = "0.5.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Pivotal Labs, Inc"]
+  s.date = %q{2009-09-28}
+  s.description = %q{Jelly provides a set of tools and conventions for creating rich ajax/javascript web applications with jQuery and Ruby on Rails.}
+  s.email = %q{opensource@pivotallabs.com}
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    ".gitignore",
+     "MIT-LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "VERSION.yml",
+     "generators/jelly/USAGE",
+     "generators/jelly/jelly_generator.rb",
+     "generators/jelly/templates/javascripts/ajax_with_jelly.js",
+     "generators/jelly/templates/javascripts/jelly.js",
+     "generators/jelly/templates/javascripts/jquery/jquery-1.3.2.js",
+     "generators/jelly/templates/javascripts/jquery/jquery.protify-0.3.js",
+     "install.rb",
+     "jelly.gemspec",
+     "lib/jelly.rb",
+     "lib/jelly/jelly_controller.rb",
+     "lib/jelly/jelly_helper.rb",
+     "tasks/jelly_tasks.rake",
+     "uninstall.rb"
+  ]
+  s.homepage = %q{http://github.com/pivotal/jelly}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{a sweet unobtrusive javascript framework for jQuery and Rails}
+  s.test_files = [
+    "spec/controllers/jelly_controller_spec.rb",
+     "spec/helpers/jelly_helper_spec.rb",
+     "spec/rails_root/app/controllers/application_controller.rb",
+     "spec/rails_root/app/helpers/application_helper.rb",
+     "spec/rails_root/config/boot.rb",
+     "spec/rails_root/config/environment.rb",
+     "spec/rails_root/config/environments/development.rb",
+     "spec/rails_root/config/environments/production.rb",
+     "spec/rails_root/config/environments/test.rb",
+     "spec/rails_root/config/initializers/backtrace_silencers.rb",
+     "spec/rails_root/config/initializers/inflections.rb",
+     "spec/rails_root/config/initializers/mime_types.rb",
+     "spec/rails_root/config/initializers/new_rails_defaults.rb",
+     "spec/rails_root/config/initializers/session_store.rb",
+     "spec/rails_root/config/routes.rb",
+     "spec/rails_root/test/performance/browsing_test.rb",
+     "spec/rails_root/test/test_helper.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rails>, [">= 2.3.0"])
+    else
+      s.add_dependency(%q<rails>, [">= 2.3.0"])
+    end
+  else
+    s.add_dependency(%q<rails>, [">= 2.3.0"])
+  end
+end

data/lib/jelly.rb

@@ -0,0 +1,16 @@
+raise "Jelly must be used in a Rails environment." unless defined?(ActionController)
+
+require 'jelly/jelly_controller'
+require 'jelly/jelly_helper'
+
+ActionController::Base.class_eval do
+  include JellyController
+end
+
+ActionView::Base.class_eval do
+  include JellyHelper
+end
+
+ActionView::Helpers::AssetTagHelper.register_javascript_expansion :jelly => ["jquery/jquery-1.3.2", "jquery/jquery.protify-0.3", 
+                                                                             "ajax_with_jelly", "jelly"]
+ActionView::Helpers::AssetTagHelper.register_javascript_expansion :only_jelly => ["jquery/jquery.protify-0.3", "jelly", "ajax_with_jelly"]

data/lib/jelly/jelly_controller.rb

@@ -0,0 +1,23 @@
+module JellyController
+  protected
+
+  def jelly_callback(callback_base_name = @action_name, options = {}, &block)
+    render :inline => jelly_callback_erb("on_#{callback_base_name}", options, block)
+  end
+
+  def jelly_callback_erb(callback_name, options, block)
+    @callback_name = callback_name
+    @options = options
+    @block = block
+    erb = <<-ERB
+      <%= begin
+        args = @block ? instance_eval(&@block) : []
+        args = [args] unless args.is_a?(Array)
+        {"method" => @callback_name, "arguments" => args}.reverse_merge(@options).to_json
+      end %>
+    ERB
+    request.xhr? ? erb : "<textarea>#{erb}</textarea>"
+  end
+
+
+end