wyngle-ripple 0.1.0

data/Rakefile

@@ -0,0 +1,63 @@
+require 'rubygems'
+require 'rubygems/package_task'
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+def gemspec
+  $ripple_gemspec ||= Gem::Specification.load("ripple.gemspec")
+end
+
+Gem::PackageTask.new(gemspec) do |pkg|
+  pkg.need_zip = false
+  pkg.need_tar = false
+end
+
+task :gem => :gemspec
+
+desc %{Validate the gemspec file.}
+task :gemspec do
+  gemspec.validate
+end
+
+desc %{Release the gem to RubyGems.org}
+task :release => :gem do
+  system "gem push pkg/#{gemspec.name}-#{gemspec.version}.gem"
+end
+
+desc "Cleans up white space in source files"
+task :clean_whitespace do
+  no_file_cleaned = true
+
+  Dir["**/*.rb"].each do |file|
+    contents = File.read(file)
+    cleaned_contents = contents.gsub(/([ \t]+)$/, '')
+    unless cleaned_contents == contents
+      no_file_cleaned = false
+      puts " - Cleaned #{file}"
+      File.open(file, 'w') { |f| f.write(cleaned_contents) }
+    end
+  end
+
+  if no_file_cleaned
+    puts "No files with trailing whitespace found"
+  end
+end
+
+desc "Run Unit Specs Only"
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.rspec_opts = %w[--profile --tag ~integration]
+end
+
+namespace :spec do
+  desc "Run Integration Specs Only"
+  RSpec::Core::RakeTask.new(:integration) do |spec|
+    spec.rspec_opts = %w[--profile --tag integration]
+  end
+
+  desc "Run All Specs"
+  RSpec::Core::RakeTask.new(:all) do |spec|
+    spec.rspec_opts = %w[--profile]
+  end
+end
+
+task :default => "spec:all"

data/lib/rails/generators/ripple/configuration/configuration_generator.rb

@@ -0,0 +1,13 @@
+require 'rails/generators/ripple_generator'
+
+module Ripple
+  module Generators
+    class ConfigurationGenerator < Base
+      desc 'Generates a configuration file for Ripple.'
+
+      def create_configuration_file
+        template 'ripple.yml', 'config/ripple.yml'
+      end
+    end
+  end
+end

data/lib/rails/generators/ripple/configuration/templates/ripple.yml

@@ -0,0 +1,25 @@
+# Configure Riak connections for the Ripple library.
+development:
+  http_port: 8098
+  pb_port: 8087
+  host: 127.0.0.1
+  source: /usr/local/bin  #Default for Homebrew.
+
+# The test environment has additional keys for configuring the
+# Riak::TestServer for your test/spec suite:
+#
+# * bin_dir specifies the path to the "riak" script that you use to
+#           start Riak (just the directory)
+# * js_source_dir specifies where your custom Javascript functions for
+#           MapReduce should be loaded from. Usually app/mapreduce.
+test:
+  http_port: 9000
+  pb_port: 9002
+  host: 127.0.0.1
+  source: /usr/local/bin   # Default for Homebrew.
+  js_source_dir: <%%= Rails.root + "app/mapreduce" %>
+
+production:
+  http_port: 8098
+  pb_port: 8087
+  host: 127.0.0.1

data/lib/rails/generators/ripple/js/js_generator.rb

@@ -0,0 +1,13 @@
+require 'rails/generators/ripple_generator'
+
+module Ripple
+  module Generators
+    class JsGenerator < Base
+      desc 'Generates Javascript built-ins for use in your queries.'
+
+      def create_js_files
+        directory 'js', 'app/mapreduce'
+      end
+    end
+  end
+end

data/lib/rails/generators/ripple/js/templates/js/contrib.js

@@ -0,0 +1,63 @@
+// -------------------------------------------------------------------
+//
+// This file contains Javascript MapReduce functions copied from the
+// "Riak Function Contrib" project.
+//
+Riak.Contrib = {
+    // Count keys in a group of results.
+    // http://contrib.basho.com/count_keys.html
+    mapCount: function(){
+        return [1];
+    },
+
+    // Generate commonly used statistics from an array of numbers.
+    // Supports count, sum, min, max, percentiles, mean, variance, and
+    // stddev.
+    // http://contrib.basho.com/stats.html
+    reduceStats: function(data) {
+        var result = {};
+
+        data.sort(function(a,b){return a-b;});
+        result.count = data.length;
+
+        // Since the data is sorted, the minimum value
+        // is at the beginning of the array, the median
+        // value is in the middle of the array, and the
+        // maximum value is at the end of the array.
+        result.min = data[0];
+        result.max = data[data.length - 1];
+
+        var ntileFunc = function(percentile){
+            if (data.length == 1) return data[0];
+            var ntileRank = ((percentile/100) * (data.length - 1)) + 1;
+            var integralRank = Math.floor(ntileRank);
+            var fractionalRank = ntileRank - integralRank;
+            var lowerValue = data[integralRank-1];
+            var upperValue = data[integralRank];
+            return (fractionalRank * (upperValue - lowerValue)) + lowerValue;
+        };
+
+        result.percentile25 = ntileFunc(25);
+        result.median = ntileFunc(50);
+        result.percentile75 = ntileFunc(75);
+        result.percentile99 = ntileFunc(99);
+
+        // Compute the mean and variance using a
+        // numerically stable algorithm.
+        var sqsum = 0;
+        result.mean = data[0];
+        result.sum = result.mean * result.count;
+        for (var i = 1;  i < data.length;  ++i) {
+            var x = data[i];
+            var delta = x - result.mean;
+            var sweep = i + 1.0;
+            result.mean += delta / sweep;
+            sqsum += delta * delta * (i / sweep);
+            result.sum += x;
+        }
+        result.variance = sqsum / result.count;
+        result.sdev = Math.sqrt(result.variance);
+
+        return result;
+    }
+};

data/lib/rails/generators/ripple/js/templates/js/iso8601.js

@@ -0,0 +1,76 @@
+// Written by Paul Sowden, 2005
+// http://delete.me.uk/2005/03/iso8601.html
+// Released under the Academic Free License
+
+Date.prototype.setISO8601 = function (string) {
+    var regexp = "([0-9]{4})(-([0-9]{2})(-([0-9]{2})" +
+        "(T([0-9]{2}):([0-9]{2})(:([0-9]{2})(\.([0-9]+))?)?" +
+        "(Z|(([-+])([0-9]{2}):([0-9]{2})))?)?)?)?";
+    var d = string.match(new RegExp(regexp));
+
+    var offset = 0;
+    var date = new Date(d[1], 0, 1);
+
+    if (d[3]) { date.setMonth(d[3] - 1); }
+    if (d[5]) { date.setDate(d[5]); }
+    if (d[7]) { date.setHours(d[7]); }
+    if (d[8]) { date.setMinutes(d[8]); }
+    if (d[10]) { date.setSeconds(d[10]); }
+    if (d[12]) { date.setMilliseconds(Number("0." + d[12]) * 1000); }
+    if (d[14]) {
+        offset = (Number(d[16]) * 60) + Number(d[17]);
+        offset *= ((d[15] == '-') ? 1 : -1);
+    }
+
+    offset -= date.getTimezoneOffset();
+    time = (Number(date) + (offset * 60 * 1000));
+    this.setTime(Number(time));
+}
+
+Date.prototype.iso8601 = function (format, offset) {
+    /* accepted values for the format [1-6]:
+     1 Year:
+       YYYY (eg 1997)
+     2 Year and month:
+       YYYY-MM (eg 1997-07)
+     3 Complete date:
+       YYYY-MM-DD (eg 1997-07-16)
+     4 Complete date plus hours and minutes:
+       YYYY-MM-DDThh:mmTZD (eg 1997-07-16T19:20+01:00)
+     5 Complete date plus hours, minutes and seconds:
+       YYYY-MM-DDThh:mm:ssTZD (eg 1997-07-16T19:20:30+01:00)
+     6 Complete date plus hours, minutes, seconds and a decimal
+       fraction of a second
+       YYYY-MM-DDThh:mm:ss.sTZD (eg 1997-07-16T19:20:30.45+01:00)
+    */
+    if (!format) { var format = 6; }
+    if (!offset) {
+        var offset = 'Z';
+        var date = this;
+    } else {
+        var d = offset.match(/([-+])([0-9]{2}):([0-9]{2})/);
+        var offsetnum = (Number(d[2]) * 60) + Number(d[3]);
+        offsetnum *= ((d[1] == '-') ? -1 : 1);
+        var date = new Date(Number(Number(this) + (offsetnum * 60000)));
+    }
+
+    var zeropad = function (num) { return ((num < 10) ? '0' : '') + num; }
+
+    var str = "";
+    str += date.getUTCFullYear();
+    if (format > 1) { str += "-" + zeropad(date.getUTCMonth() + 1); }
+    if (format > 2) { str += "-" + zeropad(date.getUTCDate()); }
+    if (format > 3) {
+        str += "T" + zeropad(date.getUTCHours()) +
+               ":" + zeropad(date.getUTCMinutes());
+    }
+    if (format > 5) {
+        var secs = Number(date.getUTCSeconds() + "." +
+                   ((date.getUTCMilliseconds() < 100) ? '0' : '') +
+                   zeropad(date.getUTCMilliseconds()));
+        str += ":" + zeropad(secs);
+    } else if (format > 4) { str += ":" + zeropad(date.getUTCSeconds()); }
+
+    if (format > 3) { str += offset; }
+    return str;
+}

data/lib/rails/generators/ripple/js/templates/js/ripple.js

@@ -0,0 +1,132 @@
+
+/*
+ * Namespace for Ripple's built-in MapReduce functions.
+ */
+var Ripple = {
+    /*
+     * Filter input values by simple equality test on passed "fields"
+     * argument. Returns bucket/key pairs for use in later map phases.
+     *
+     * Raw Phase Example:
+     *  {"map":{
+     *          "language":"javascript",
+     *          "name":"Ripple.filterByFields",
+     *          "arg":{"manufactured":true, "name":"widget"}
+     *          }}
+     *
+     * Ruby invocation example:
+     *   mr.map("Ripple.filterByFields",
+     *          :arg => {:manufactured => true, :name => "widget"})
+     *
+     */
+    filterByFields: function(value, keyData, fields){
+        var object = Riak.mapValuesJson(value)[0];
+        for(field in fields){
+            if(object[field] != fields[field])
+                return [];
+        }
+        return [[value.bucket, value.key]];
+    },
+    /*
+     * Filter input values by various conditions passed as the
+     * "conditions" argument. Returns bucket/key pairs for use in
+     * later map phases.
+     *
+     * Valid operators:
+     *   ==, eq      (equality)
+     *   !=, neq     (inequality)
+     *   <, lt       (less than)
+     *   =<, <=, lte (less than or equal)
+     *   >, gt       (greater than)
+     *   >=, =>, gte (greater than or equal)
+     *   ~=, match   (regular expression match)
+     *   between     (inclusive numeric range)
+     *   includes    (String or Array inclusion)
+     *
+     * Example:
+     *   {"map":{
+     *           "language":"javascript",
+     *           "name":"Ripple.filterByConditions",
+     *           "arg":{"tags":{"includes":"riak"}, "title":{"~=":"schema"}}
+     *          }}
+     *
+     * Ruby invocation example:
+     *   mr.map("Ripple.filterByConditions",
+     *          :arg => {:tags => {:includes => "riak"},
+     *                   :title => {"~=" => "schema"}})
+     */
+    filterByConditions: function(value, keyData, conditions){
+        var object = Riak.mapValuesJson(value)[0];
+        for(condition in conditions){
+            if(!Ripple.conditionMatch(condition, conditions[condition], object))
+                return [];
+        }
+        return [[value.bucket, value.key]];
+    },
+    /*
+     * Given a specific field and test, returns whether the object
+     * matches the condition specified by the test. Used internally by
+     * Ripple.filterByConditions map phases.
+     */
+    conditionMatch: function(field, test, object){
+        for(t in test){
+            switch(t){
+            case "==": case "eq":
+                if(object[field] != test[t])
+                    return false;
+                break;
+            case "!=": case "neq":
+                if(object[field] == test[t])
+                    return false;
+                break;
+            case "<":  case "lt":
+                if(object[field] >= test[t])
+                    return false;
+                break;
+            case "=<": case "<=": case "lte":
+                if(object[field] > test[t])
+                    return false;
+                break;
+            case ">":  case "gt":
+                if(object[field] <= test[t])
+                    return false;
+                break;
+            case ">=": case "=>": case "gte":
+                if(object[field] < test[t])
+                    return false;
+                break;
+            case "~=": case "match":
+                if(new RegExp(object[field],"i").test(test[t]))
+                    return false;
+                break;
+            case "between": // Inclusive on both ends
+                if(object[field] < test[t][0] || object[field] > test[t][1])
+                    return false;
+                break;
+            case "includes": // Only works with String, Array
+                if(object[field].indexOf(test[t]) == -1)
+                    return false;
+                break;
+            default:
+                ejsLog("Invalid condition for field " + field + ": " + t + " " + test[t], "ripple-error.log");
+                break;
+            }
+        }
+        return true;
+    },
+    /*
+     * Returns the mapped object without modification. Useful when
+     * preceded by map phases that do filtering or link phases.
+     */
+    mapIdentity: function(value, kd, arg){
+        return [value];
+    },
+    /*
+     * Returns the passed values without modification. Useful as an
+     * intermediary before reduce phases that require the entire
+     * result set to be present (limits).
+     */
+    reduceIdentity: function(values, arg){
+        return values;
+    }
+};

data/lib/rails/generators/ripple/model/model_generator.rb

@@ -0,0 +1,20 @@
+require 'rails/generators/ripple_generator'
+
+module Ripple
+  module Generators
+    class ModelGenerator < NamedBase
+      desc 'Creates a ripple model'
+      argument :attributes, :type => :array, :default => [], :banner => 'field:type field:type'
+      class_option :parent, :type => :string, :desc => "The parent class for the generated model"
+      class_option :embedded, :type => :boolean, :desc => "Make an embedded document model.", :default => false
+      class_option :embedded_in, :type => :string, :desc => "Specify the enclosing model for the embedded document. Implies --embedded."
+      check_class_collision
+
+      def create_model_file
+        template 'model.rb.erb', "app/models/#{file_path}.rb"
+      end
+
+      hook_for :test_framework
+    end
+  end
+end

data/lib/rails/generators/ripple/model/templates/model.rb.erb

@@ -0,0 +1,10 @@
+class <%= class_name %><%= " < #{options[:parent].classify}" if options[:parent] %>
+<% unless options[:parent] -%>
+  include Ripple::<%= "Embedded" if options[:embedded] || options[:embedded_in] %>Document
+  <% if options[:embedded_in] -%>embedded_in :<%= options[:embedded_in].underscore %><% end -%>
+<% end -%>
+
+<% attributes.reject{|attr| attr.reference?}.each do |attribute| -%>
+  property :<%= attribute.name %>, <%= attribute.type_class %>
+<% end -%>
+end

data/lib/rails/generators/ripple/observer/observer_generator.rb

@@ -0,0 +1,16 @@
+require 'rails/generators/ripple_generator'
+
+module Ripple
+  module Generators
+    class ObserverGenerator < NamedBase
+      desc 'Creates an observer for Ripple documents'
+      check_class_collision :suffix => "Observer"
+
+      def create_observer_file
+        template 'observer.rb.erb', File.join("app/models", class_path, "#{file_name}_observer.rb")
+      end
+
+      hook_for :test_framework
+    end
+  end
+end