marbu 0.1.0

data/lib/marbu/models/mrf/base.rb

@@ -0,0 +1,133 @@
+module Marbu
+  module Models
+    class Base
+      attr_accessor :keys, :values
+      attr_reader :code
+
+      def initialize(ext_options = {})
+        # keep_if weeds out nil arguments
+        options         = default_options.merge( ext_options.keep_if{|k,v| v} )
+        
+        @keys           = options[:keys].map{ |k| Key.new(k) }
+        @values         = options[:values].map{ |v| Value.new(v) }
+        self.code       = options[:code]
+      end
+
+      def default_options
+        {
+          :keys             => [],
+          :values           => [],
+          :code             => Code.new
+        }
+      end
+
+      def code=(code)
+        if( code.is_a?(Code) )
+          @code = code
+        elsif( code.is_a?(Hash) )
+          @code = Code.new(code)
+        else
+          raise Exception.new("Don't know this Code type: #{code.class}")
+        end
+      end
+
+      def serializable_hash
+        {
+          :keys       => keys.collect(&:serializable_hash),
+          :values     => values.collect(&:serializable_hash),
+          :code       => code.serializable_hash
+        }.delete_if{|k,v|v.blank?}
+      end
+
+      def add_key(name, function = nil)
+        add(:key, name, function)
+      end
+
+      def add_value(name, function = nil)
+        add(:value, name, function)
+      end
+
+      def present?
+        @keys.present? || code.present?
+      end
+
+      def blank?
+        !present?
+      end
+
+      private
+        def add(type, name, function)
+          function = Misc::DOCUMENT_OFFSET + name.to_s unless function
+          case type
+            when :key     then @keys << Key.new({:name => name, :function => function})
+            when :value   then @values << Value.new({:name => name, :function => function})
+          end
+        end
+    end
+
+    class KeyValueBase
+      attr_accessor :name, :function
+
+      def initialize(params)
+        #params.keys.each do |k|
+        #  send("#{k}=".to_sym, params[k]) if respond_to?(k)
+        #end
+
+        self.name       = params[:name]
+        self.function   = params[:function]
+      end
+
+      def name=(name)
+        @name = name.to_s
+      end
+
+      def serializable_hash
+        # don't return nil values in hash
+        {
+            :name       => @name,
+            :function   => @function
+        }.keep_if{|k,v| v}
+      end
+
+      def present?
+        name.present? && function.present?
+      end
+
+      def blank?
+        !present?
+      end
+    end
+
+    class Key < KeyValueBase
+      attr_reader :exchangeable
+
+      def initialize( ext_options = {} )
+        options             = default_options.merge( ext_options.delete_if{|k,v|v.nil?} )
+
+        self.exchangeable   = options.delete(:exchangeable)
+        super(options)
+      end
+
+      def default_options
+        {
+          :exchangeable        => true
+        }
+      end
+
+      def exchangeable=(e)
+        # make sure it's a boolean
+        if( !!e == e )
+          @exchangeable = e
+        else
+          raise Exception.new("Hey, I need a boolean!")
+        end
+
+        return self
+      end
+
+    end
+
+    class Value < KeyValueBase
+    end
+  end
+end

data/lib/marbu/models/mrf/code.rb

@@ -0,0 +1,32 @@
+module Marbu
+  module Models
+    class Code
+      attr_accessor :text, :type
+
+      JS            = "JS"
+
+      def initialize( ext_params = {} )
+        params              = default_params.merge( ext_params.keep_if{|k,v|v} )
+        @text               = params[:text]
+        @type               = params[:type]
+      end
+
+      def default_params
+        {
+          :type       => JS
+        }
+      end
+
+      def serializable_hash
+        {
+          :text       => text,
+          :type       => type
+        }.delete_if{|k,v|v.blank?}
+      end
+
+      def present?
+        text.present?
+      end
+    end
+  end
+end

data/lib/marbu/models/mrf/finalize.rb

@@ -0,0 +1,9 @@
+# -*- encoding: utf-8 -*-
+
+module Marbu
+  module Models
+    class Finalize < Base
+
+    end
+  end
+end

data/lib/marbu/models/mrf/map.rb

@@ -0,0 +1,7 @@
+module Marbu
+  module Models
+    class Map < Base
+
+    end
+  end
+end

data/lib/marbu/models/mrf/map_reduce_finalize.rb

@@ -0,0 +1,107 @@
+# -*- encoding: utf-8 -*-
+
+require 'mongoid'
+
+module Marbu
+  module Models
+    # represents one complete MapReduce-Model
+    # this model can be stored in a database and read again
+    # the builder will use MapReduce-Models to build actual mapreduce code
+    class MapReduceFinalize
+      include Mongoid::Fields::Serializable
+      attr_reader :map, :reduce, :finalize, :query, :misc
+
+      def initialize(ext_params = {})
+        # TODO: deep copy necessary why?
+        params = default_params.merge( Marshal.load(Marshal.dump(ext_params)) )
+
+        self.map                = params[:map]
+        self.reduce             = params[:reduce]
+        self.finalize           = params[:finalize]
+        self.query              = params[:query]
+        self.misc               = params[:misc]
+      end
+
+      def default_params
+        {
+          :map                => Map.new,
+          :reduce             => Reduce.new,
+          :finalize           => Finalize.new,
+          :query              => Query.new,
+          :misc               => Misc.new
+        }
+      end
+
+      def map=(map)
+        @map = general_setter(map, Marbu::Models::Map)
+      end
+
+      def reduce=(reduce)
+        @reduce = general_setter(reduce, Marbu::Models::Reduce)
+      end
+
+      def finalize=(finalize)
+        @finalize = general_setter(finalize, Marbu::Models::Finalize)
+      end
+
+      def query=(query)
+        @query = general_setter(query, Marbu::Models::Query)
+      end
+
+      def misc=(misc)
+        @misc = general_setter(misc, Marbu::Models::Misc)
+      end
+
+      def serializable_hash
+        {
+          :map                        => map.serializable_hash,
+          :reduce                     => reduce.serializable_hash,
+          :finalize                   => finalize.serializable_hash,
+          :query                      => query.serializable_hash,
+          :misc                       => misc.serializable_hash
+        }.delete_if{|k,v|v.blank?}
+      end
+
+      # return true if we have a map and a reduce function defined
+      def mapreduce?
+        !(map.nil? && reduce.nil?)
+      end
+
+      def query_only?
+        force_query || (!mapreduce? && !query.nil?)
+      end
+
+      def eql?(other)
+        serializable_hash == other.serializable_hash
+      end
+
+      def ==(other)
+        eql?(other)
+      end
+
+      # TODO: please remove after Mongoid gets non-intrusive de/serialization
+      def serialize(object)
+        object.serializable_hash
+      end
+
+      def deserialize(object)
+        MapReduceFinalize.new(object.symbolize_keys_rec)
+      end
+
+      private
+        def general_setter(var, klass)
+          if( var.is_a?(klass) )
+            ret_val = var
+          elsif( var.is_a?( ::Hash ) )
+            ret_val = klass.new(var)
+          elsif( var.nil? )
+            ret_val = klass.new
+          else
+            raise Exception.new("Unsupported var type: #{var.class}")
+          end
+
+          return ret_val
+        end
+    end
+  end
+end

data/lib/marbu/models/mrf/misc.rb

@@ -0,0 +1,65 @@
+module Marbu
+  module Models
+    class Misc
+      attr_accessor :database, :input_collection, :output_collection, :output_operation
+      # if filter_data is true, a query will be created depending on the filter parameters in filter_model
+      # if filter_data is false, no query will generated
+      # this is necessary for multiple sequentiell map_reduces: some will work on already filtered data (so no filter needed)
+      # while others will grab data from other collections which need to be filtered first
+      attr_reader :filter_data
+      attr_accessor :value, :document_offset
+
+      VALUE = :value
+      DOCUMENT_OFFSET = VALUE.to_s + "."
+
+      def initialize( ext_params = {} )
+        params              = default_params.merge( ext_params.delete_if{|k,v|v.blank?} )
+
+        self.database           = params[:database]
+        self.input_collection   = params[:input_collection]
+        self.output_collection  = params[:output_collection]
+        self.output_operation   = params[:output_operation]
+        self.filter_data        = params[:filter_data]
+      end
+
+      def default_params
+        {
+          :value              => VALUE,
+          :document_offset    => DOCUMENT_OFFSET,
+          :filter_data        => false,
+          :output_operation   => "replace"
+        }
+      end
+
+      def filter_data=(fd)
+        if( !!fd == fd )
+          @filter_data = fd
+        else
+          raise Exception.new("Need a boolean value!")
+        end
+      end
+
+      def present?
+        database.present? || input_collection.present? || output_collection.present?
+      end
+
+      def blank?
+        !present?
+      end
+
+      def serializable_hash
+        {
+          :database           => database,
+          :input_collection   => input_collection,
+          :output_collection  => output_collection,
+          :output_operation   => output_operation,
+          :filter_data        => filter_data
+        }.delete_if{|k,v|v.blank?}
+      end
+
+      def collection
+        Marbu.connection.db(database).collection(input_collection)
+      end
+    end
+  end
+end

data/lib/marbu/models/mrf/mrf.rb

@@ -0,0 +1,8 @@
+require 'marbu/models/mrf/base'
+require 'marbu/models/mrf/map'
+require 'marbu/models/mrf/reduce'
+require 'marbu/models/mrf/finalize'
+require 'marbu/models/mrf/query'
+require 'marbu/models/mrf/misc'
+require 'marbu/models/mrf/code'
+require 'marbu/models/mrf/map_reduce_finalize'

data/lib/marbu/models/mrf/query.rb

@@ -0,0 +1,39 @@
+# -*- encoding: utf-8 -*-
+
+module Marbu
+  module Models
+    class Query
+      DEFAULT_DATE_FIELDS = [:created_at]
+
+      attr_accessor :condition, :datetime_fields
+
+
+      def initialize( ext_params = {} )
+        params                  = default_params.merge( ext_params.keep_if{|k,v|v} )
+        @condition              = params[:condition]
+        @datetime_fields        = params[:datetime_fields]
+      end
+
+      def default_params
+        {
+          :datetime_fields      => DEFAULT_DATE_FIELDS
+        }
+      end
+
+      def present?
+        condition.present? || !datetime_fields.eql?(DEFAULT_DATE_FIELDS)
+      end
+
+      def blank?
+        !present?
+      end
+
+      def serializable_hash
+        {
+          :condition              => condition,
+          :datetime_fields        => datetime_fields
+        }.delete_if{|k,v|v.blank?}
+      end
+    end
+  end
+end

data/lib/marbu/models/mrf/reduce.rb

@@ -0,0 +1,7 @@
+module Marbu
+  module Models
+    class Reduce < Base
+
+    end
+  end
+end

data/lib/marbu/server/public/css/style.css

@@ -0,0 +1,149 @@
+body {
+  padding:  0;
+  margin:   0;
+}
+
+.clearfix:after {
+	content: ".";
+	display: block;
+	clear: both;
+	visibility: hidden;
+	line-height: 0;
+	height: 0;
+}
+
+.clearfix {
+	display: inline-block;
+}
+
+html[xmlns] .clearfix {
+	display: block;
+}
+
+* html .clearfix {
+	height: 1%;
+}
+
+
+
+
+/* builder */
+.builder .col {
+  display:  block;
+}
+
+.builder .row {
+  display:  block;
+  margin:   0 0 15px 0;
+  border:   1px dotted #777;
+  position: relative;
+  background: #ddd;
+  border-radius:  10px;
+}
+
+.builder .row.submit {
+  text-align: center;
+  padding:     20px 0 0 0;
+  border:       none;
+  border-radius:  0;
+  background:   none;
+}
+
+.builder .col legend {
+  font-weight:  bold;
+}
+
+.builder .col label {
+  font-size:  0.8em;
+  color:      #333;
+}
+
+.builder .col .pair {
+/*  float:        left;*/
+/*  margin-right: 2%;*/
+/*  width:        45%;*/
+    margin:   0 auto 15px auto;
+    padding:  5px 10px 5px 5px;
+    float:    left;
+    width:    40%;
+}
+
+.builder .col .pair > a:last-child {
+  display:  none;
+}
+
+.builder .col .pair:last-child {
+  margin-right: 0;
+  margin-bottom:  0;
+}
+
+.builder .col .add-remove-element:first-child .pair:first-child > a:last-child {
+  display:  block;
+}
+
+
+.add-remove {
+  clear:  both;
+  margin: 0 0 20px 0;
+}
+
+
+.add-remove a.remove {
+  background:       url('/images/remove.png') 0 0 no-repeat;
+  width:            20px;
+  height:           20px;
+  padding:          0;
+  text-indent:      -9999em;
+  top:              5px;
+  right:            5px;
+  display:          block;
+  position:         absolute;
+}
+
+#container .pulldown {
+  margin:   0 .5em 40px .5em;
+}
+
+a[data-type="pulldown"] {
+  text-align: left;
+}
+
+#sample_data .ui-content .ui-btn,
+#sample_data .ui-content .ui-collapsible {
+  cursor: pointer;
+  display: block;
+  margin: 0.5em 5px;
+  padding: 0;
+  position: relative;
+  text-align: left;
+}
+
+#sample_data .ui-content .ui-btn.tablink {
+  display:  inline-block;
+}
+
+#sample_data .ui-collapsible-heading {
+  margin: 0;
+}
+
+#sample_data .ui-collapsible-content {
+  padding-left:   30px;
+}
+
+#sample_data a .example {
+  font-weight:  normal;
+  margin-left:  10px;
+  font-size:    .7em;
+}
+
+#sample_data .tree {
+  display:  none;
+}
+
+#sample_data #sample_data_param_1 {
+  display:  block;
+}
+
+.add_remove_button_wrapper > * {
+  float:  left;
+}