cullender 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 84cd07f131f0613540f841cfd74fd0d99080ecf5
+  data.tar.gz: b6c36dd6ba6f2bf5d51a5682c1f0a2ff2b263760
+SHA512:
+  metadata.gz: 60085f0fc2e0fc7bd4400f4928c14b861b5dde3b3beb38d26c39c3e8900aa4de1a3fbf53a439798376142b4692322429e2d432c9e8641aa62a0aef07d9f1bf48
+  data.tar.gz: be7c775c08cf93465cf4fa2cd8f43618bd6030d670a0acf14b005331b4c76d7abadf210f8b6a9bc24c5080985d6a7acef97d48326d1047cf3a9e3c76876db764

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,3 @@
+= Cullender
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,34 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Cullender'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("../spec/dummy/Rakefile", __FILE__)
+load 'rails/tasks/engine.rake'
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'spec'
+  t.pattern = 'spec/**/*_spec.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/app/assets/javascripts/cullender/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// WARNING: THE FIRST BLANK LINE MARKS THE END OF WHAT'S TO BE PROCESSED, ANY BLANK LINE SHOULD
+// GO AFTER THE REQUIRES BELOW.
+//
+//= require_tree .

data/app/assets/javascripts/cullender/rules.js

@@ -0,0 +1,46 @@
+// # Place all the behaviors and hooks related to the matching controller here.
+// # All this logic will automatically be available in application.js.
+// # You can use CoffeeScript in this file: http://jashkenas.github.com/coffee-script/
+// # check if there are any rules that have already been applied
+// # if rules have been defined then check if the user is ok if we remove remove them from the form
+// 
+// jQuery ->
+//   columns = $('#or_raise_field').html()	
+//   table = $('#rule_table_id :selected').text()
+//   escaped_table = table.replace(/([ #;&,.+*~\':"!^$[\]()=>|\/@])/g, '\\$1')
+//   options = $(columns).filter("optgroup[label=#{escaped_table}]").html()
+//   $('#triggers').hide() unless options
+//   $('#rule_table_id').change ->
+//     table = $('#rule_table_id :selected').text()
+//     escaped_table = table.replace(/([ #;&,.+*~\':"!^$[\]()=>|\/@])/g, '\\$1')
+//     options = $(columns).filter("optgroup[label=#{escaped_table}]").html()
+//     if options
+//       $('.column_select_field').html(options)
+//       $('#triggers').show()      
+//     else
+//       $('.column_select_field').empty()
+//       $('#triggers').hide()
+
+
+// jQuery(function() {
+// 	var columns;
+// 	columns = $('#or_raise_field').html();
+// 	populate_rule_column_options();
+// 	$('#rule_table_id').change(populate_rule_column_options);
+
+// 	function populate_rule_column_options(){
+// 		var escaped_table, options, table;
+// 		table = $('#rule_table_id :selected').text();
+// 		escaped_table = table.replace(/([ #;&,.+*~\':"!^$[\]()=>|\/@])/g, '\\$1');
+// 		options = $(columns).filter("optgroup[label=" + escaped_table + "]").html();
+// 		if (options) {
+// 			$('.column_select_field').html(options);
+// 			return $('#triggers').show();
+// 		} else {
+// 			$('.column_select_field').empty();
+// 			return $('#triggers').hide();
+// 		}
+// 	}
+// });
+
+// TODO javascript without rails ujs

data/app/assets/stylesheets/cullender/application.css

@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require_self
+ *= require_tree .
+ */

data/app/assets/stylesheets/cullender/rules.css.scss

@@ -0,0 +1,15 @@
+// Place all the styles related to the rules controller here.
+// They will automatically be included in application.css.
+// You can use Sass (SCSS) here: http://sass-lang.com/
+#rules {
+	table{
+		td{
+			vertical-align:middle;
+		}
+		.action{
+			i{
+				margin-right:5px;
+			}
+		}
+	}
+}

data/app/controllers/cullender/rules_controller.rb

@@ -0,0 +1,68 @@
+module Cullender
+  class RulesController < CullenderController
+    before_action :set_rule, only: [:show, :edit, :update, :destroy]
+    include Controllers::FilterLogic
+    
+    # TODO should route without resource. ie not event/rules just /rules
+    # GET /rules
+    def index
+      @rules = Cullender::Rule.all
+    end
+
+    # GET /rules/1
+    def show
+      params.deep_merge!({"rule" => {"triggers" => @rule.triggers}})
+    end
+
+    # GET /rules/new
+    def new
+      @rule = Cullender::Rule.new(name: params[:name])
+    end
+
+    # POST /rules
+    def create
+      flag = apply_filter_actions("triggers", params[:rule], params)
+      @rule = Cullender::Rule.new(rule_params)
+      respond_to do |format|
+        if flag
+            format.html {redirect_to send("new_#{resource_name}_rule_url".to_sym,params[:rule])}
+            format.js { render "create"}
+        else
+          if @rule.save
+            format.html {redirect_to send("#{resource_name}_rules_url".to_sym), notice: 'Rule was successfully created.'}
+            format.js {redirect_to send("#{resource_name}_rules_url".to_sym), notice: 'Rule was successfully created.'}
+          else
+            format.html {render action: 'new'}
+            format.js {render action: 'new'}
+          end
+        end
+      end
+    end
+
+    # PATCH/PUT /rules/1
+    def update
+      if !apply_filter_actions("triggers", params[:rule], params) && @rule.update_attributes(rule_params)
+        redirect_to send("#{resource_name}_rules_url".to_sym), notice: 'Rule was successfully updated.'
+      else
+        render action: 'show'
+      end
+    end
+
+    # DELETE /rules/1
+    def destroy
+      @rule.destroy
+      redirect_to send("#{resource_name}_rules_url".to_sym), notice: 'Rule was successfully destroyed.'
+    end
+
+    private
+      # Use callbacks to share common setup or constraints between actions.
+      def set_rule
+        @rule = Cullender::Rule.find(params[:id])
+      end
+
+      # Never trust parameters from the scary internet, only allow the white list through.
+      def rule_params
+        params.require(:rule).permit!#(:name, :triggers => {})
+      end
+  end
+end

data/app/controllers/cullender_controller.rb

@@ -0,0 +1,105 @@
+# All Cullender controllers are inherited from here.
+class CullenderController < Cullender.parent_controller.constantize
+  include Cullender::Controllers::ScopedViews
+
+  helpers = %w(resource scope_name resource_name
+               resource_class resource_params cullender_mapping)
+  hide_action *helpers
+  helper_method *helpers
+
+  prepend_before_filter :assert_is_cullender_resource!
+  respond_to *Mime::SET.map(&:to_sym) if mimes_for_respond_to.empty?
+
+  # Gets the actual resource stored in the instance variable
+  def resource
+    instance_variable_get(:"@#{resource_name}")
+  end
+
+  # Proxy to cullender map name
+  def resource_name
+    cullender_mapping.name
+  end
+  alias :scope_name :resource_name
+
+  # Proxy to cullender map class
+  def resource_class
+    cullender_mapping.to
+  end
+
+  def resource_params
+    params[resource_name]
+  end
+
+  # Attempt to find the mapped route for cullender based on request path
+  def cullender_mapping
+    @cullender_mapping ||= request.env["cullender.mapping"]
+  end
+
+  # Override prefixes to consider the scoped view.
+  # Notice we need to check for the request due to a bug in
+  # Action Controller tests that forces _prefixes to be
+  # loaded before even having a request object.
+  def _prefixes #:nodoc:
+    @_prefixes ||= if self.class.scoped_views? && request && cullender_mapping
+      super.unshift("#{cullender_mapping.scoped_path}/#{controller_name}")
+    else
+      super
+    end
+  end
+
+  hide_action :_prefixes
+
+  protected
+
+  # Checks whether it's a cullender mapped resource or not.
+  def assert_is_cullender_resource! #:nodoc:
+    unknown_action! <<-MESSAGE unless cullender_mapping
+Could not find cullender mapping for path #{request.fullpath.inspect}.
+This may happen for two reasons:
+
+1) You forgot to wrap your route inside the scope block. For example:
+
+  cullender_scope :user do
+    match "/some/route" => "some_cullender_controller"
+  end
+
+2) You are testing a Cullender controller bypassing the router.
+   If so, you can explicitly tell Cullender which mapping to use:
+
+   @request.env["cullender.mapping"] = Cullender.mappings[:user]
+
+MESSAGE
+  end
+
+  # Returns real navigational formats which are supported by Rails
+  def navigational_formats
+    @navigational_formats ||= Cullender.navigational_formats.select { |format| Mime::EXTENSION_LOOKUP[format.to_s] }
+  end
+
+  def unknown_action!(msg)
+    logger.debug "[Cullender] #{msg}" if logger
+    raise AbstractController::ActionNotFound, msg
+  end
+
+  # Sets the resource creating an instance variable
+  def resource=(new_resource)
+    instance_variable_set(:"@#{resource_name}", new_resource)
+  end
+
+  # Build a cullender resource.
+  # Assignment bypasses attribute protection when :unsafe option is passed
+  def build_resource(hash = nil, options = {})
+    hash ||= resource_params || {}
+
+    if options[:unsafe]
+      self.resource = resource_class.new.tap do |resource|
+        hash.each do |key, value|
+          setter = :"#{key}="
+          resource.send(setter, value) if resource.respond_to?(setter)
+        end
+      end
+    else
+      self.resource = resource_class.new(hash)
+    end
+  end
+end

data/app/helpers/cullender/rules_helper.rb

@@ -0,0 +1,136 @@
+module Cullender
+  module RulesHelper
+
+
+	  def render_property_tree(name,  mapping, hash, options = {}, hierarchy = [], &block)
+	    options.merge!(:class => "group level_#{hierarchy.length}")
+	    last_key =  hash.keys.last
+	    html = content_tag :div, options do
+	    hash.each do |field, value|
+	      if value.keys.include?("o")
+	      	property_options = mapping.has_key?(field) ? mapping[field] : {}
+	        block.call property_item(name, field, property_options, value, hierarchy), last_key == field ? 1 : -1, hierarchy
+	      else
+	        hierarchy.push(field)
+	        block.call render_property_tree(name, mapping, value, {}, hierarchy, &block), last_key == field ? 0 : -1, hierarchy
+	      end
+	    end
+	    end if hash.present?
+	    hierarchy.pop
+	    html
+	  end
+
+	  def extract_field_type(options)
+	  	options.has_key?(:type) && Cullender::Rule::FIELD_TYPE_MAP.has_key?(options[:type]) ? Cullender::Rule::FIELD_TYPE_MAP[options[:type]] : "text_field" 
+	  end
+
+		# type = Event.property_types.has_key?(field) ? Event.property_types[field] : "string" #Event::FIELDTYPE_MAP[column.datatype]
+	  def property_item(name, field, options, value_hash = {}, hierarchy = [])
+	  	fieldtype = extract_field_type(options)
+		prefix = nested_property_prefix(hierarchy, name)
+		operator = value_hash['o'] || nil
+		value = value_hash['v'] || nil
+		content_tag :div, :class => "item #{field.to_s.parameterize}" do
+			submit_tag("-", :name => "remove#{nested_property_prefix(hierarchy, "")}[#{field}]", :class => 'btn') +
+			label_tag(field, field, {:for => "#{prefix}[#{field}][v]"}) +
+			select_tag( "#{prefix}[#{field}][o]", options_for_select(Cullender::Rule::OPERATORS[fieldtype], operator), :class => "operator") +
+			property_value_field(field, fieldtype, value, options, prefix)
+		end
+	  end
+
+	  def link_to_filter(attribute, value, options = {})
+	    copy_of_params = deep_clone(params)
+	    copy_of_params.deep_merge!({:filter => {attribute.to_sym => {"v" => value}}})
+	    link_to_unless( params.has_key?(:filter) && params[:filter].has_key?(attribute), value, copy_of_params, options)
+	  end
+	  
+	  def link_to_remove_filter(attribute, value, options = {})
+	    condition = params.has_key?(:filter) && params[:filter].has_key?(attribute.to_s) && params[:filter][attribute.to_s]['v'].to_s == value.to_s
+	    copy_of_params = deep_clone(params)  
+	    copy_of_params[:filter].delete(attribute)
+	    link_to( text_with_close_btn("#{attribute}=#{value}"), copy_of_params, options)
+	  end
+
+	  def remove_filter_link(attribute, value, count, options = {})
+	    copy_of_params = deep_clone(params)
+	    if params.has_key?(:filter) && params[:filter].has_key?(attribute.to_s) && params[:filter][attribute.to_s]['v'].to_s == value.to_s
+	      copy_of_params[:filter].delete(attribute.to_s)
+	      link_to "remove", copy_of_params, options
+	    else
+	      content_tag(:span, count, options)
+	    end
+	  end
+
+	  def cullender_collection_or_select(collection, hierarchy = [], options = {})
+	    is_base = options.delete(:base)
+		prefix = nested_property_prefix(hierarchy)
+		content_tag :div, :class => "add_group" do
+			select_tag( "or[#{"raise_" if is_base}field]#{prefix}", options_for_select(collection), :class => "column_select_field") + 
+			submit_tag("OR", :name => "or#{is_base ? "[raise]" : "[commit]"}#{prefix}", :class => 'btn')
+		end
+	  end
+
+
+	  def cullender_collection_and_select(collection, hierarchy = [], options = {})
+		prefix = nested_property_prefix(hierarchy)
+		content_tag :div, :class => "add_filter" do
+			select_tag( "and[field]#{prefix}", options_for_select(collection), :class => "column_select_field") + 
+			submit_tag("AND", :name => "and[commit]#{prefix}", :class => 'btn')
+		end
+	  end
+
+	  def extract_triggers(params)
+	  	if params.has_key?("triggers")
+	  		params["triggers"]
+	  	elsif params.has_key?("rule") && params["rule"].has_key?("triggers")
+			params["rule"]["triggers"]
+	  	end
+	  end
+
+
+	def property_value_field(field, type, value = nil, options = {}, prefix = '')
+		default = options.delete(:default)
+		case type
+		when "number_field", "range_field", "text_field", "check_box"
+			send("#{type}_tag".to_sym, "#{prefix}[#{field}][v]", value, {:class => "value"} )
+		when "select"
+			select_tag("#{prefix}[#{field}][v]", options_for_select({}, value), {:class => "value"}) 
+		when "datetime"
+			select_datetime set_datetime(value, default), {:class => "value", :prefix => "#{prefix}[#{field}][v]"}
+		when "date"
+			select_date set_date(value, default), {:class => "value", :prefix => "#{prefix}[#{field}][v]"}
+		else #this includes Event::TEXT and any other field type
+			text_field_tag "#{prefix}[#{field}][v]", value, {:class => "value"}
+		end
+	end
+
+
+		def filter_to_s(key, value)
+			"#{key} #{Rule::FILTER_MAP[value["o"]]} #{value["v"]}" if value.has_key?("o") && value.has_key?("v")
+		end
+
+		# nest is an array of values of the hierarchy
+		def nested_property_prefix(hierarchy, prefix = nil)
+			"#{prefix}#{hierarchy.inject("") {|result, item| result += "[#{item}]"}}"
+		end
+
+	    def formatted_triggers(hash)
+			ands = []
+			ors = []
+			hash.each do |key, value|
+				if value.keys.include?("o")
+					ands << filter_to_s(key, value)
+				else
+					ors << formatted_triggers(value)
+				end
+			end if hash.present?
+			ors.empty? ? "("+ ands.join(" AND ") + ")" : "(" + ors.join(" OR ") + ")"
+		end
+
+		private
+
+		  def deep_clone(obj)
+		    Marshal.load(Marshal.dump(obj))
+		  end
+  end
+end