cullender 0.0.1

data/lib/cullender/version.rb

@@ -0,0 +1,3 @@
+module Cullender
+  VERSION = "0.0.1"
+end

data/lib/generators/cullender/cullender_generator.rb

@@ -0,0 +1,66 @@
+require 'generators/cullender/orm_helpers'
+
+module Cullender
+	module Generators
+		class CullenderGenerator < Rails::Generators::NamedBase
+			include Rails::Generators::Migration
+			include Cullender::Generators::OrmHelpers			
+			source_root File.expand_path('../templates', __FILE__)
+
+			argument :attributes, :type => :array, :default => [], :banner => "field:type field:type"
+			desc "Generates a model with the given NAME (if one does not exist) with cullender " <<
+           "configuration plus a migration file and cullender routes."
+			
+			class_option :routes, :desc => "Generate routes", :type => :boolean, :default => true           
+
+
+			def add_cullender_routes
+				cullender_route  = "cullender_for :#{plural_name}"
+				cullender_route << %Q(, :class_name => "#{class_name}") if class_name.include?("::")
+				cullender_route << %Q(, :skip => :all) unless options.routes?
+				route cullender_route
+			end
+
+
+			def copy_cullender_rules_migration
+				migration_template "cullender_migration.rb", "db/migrate/create_cullender_tables"
+			end
+
+			# def copy_cullender_migration
+			# 	if (behavior == :invoke && model_exists?) || (behavior == :revoke && migration_exists?(table_name))
+			# 		migration_template "migration_existing.rb", "db/migrate/add_cullender_to_#{table_name}"
+			# 	else
+			# 		migration_template "migration.rb", "db/migrate/create_cullender_for_#{table_name}"
+			# 	end
+			# end			
+
+			# def inject_cullender_content
+			# 	content = model_contents + <<CONTENT
+			# 	# Setup accessible (or protected) attributes for your model
+			# 	attr_accessible :email, :password, :password_confirmation, :remember_me
+			# 	CONTENT
+
+			# 	class_path = if namespaced?
+			# 		class_name.to_s.split("::")
+			# 	else
+			# 		[class_name]
+			# 	end
+
+			# 	indent_depth = class_path.size - 1
+			# 	content = content.split("\n").map { |line| "  " * indent_depth + line } .join("\n") << "\n"
+
+			# 	inject_into_class(model_path, class_path.last, content) if model_exists?
+			# end
+
+
+			def migration_data
+<<RUBY
+		t.string :name
+		t.boolean :enabled
+		t.text :triggers				
+RUBY
+			end
+
+		end
+	end
+end

data/lib/generators/cullender/install_generator.rb

@@ -0,0 +1,18 @@
+module Cullender
+	module Generators
+		class InstallGenerator < Rails::Generators::Base
+			source_root File.expand_path('../templates', __FILE__)
+
+			desc "Creates a Cullender initializer and copy locale files to your application."
+
+
+			def create_initializer_file
+				template "cullender.rb", "config/initializers/cullender.rb"
+			end
+
+			def copy_locale
+				copy_file "../../../../config/locales/en.yml", "config/locales/cullender.en.yml"
+			end
+		end
+	end
+end

data/lib/generators/cullender/orm_helpers.rb

@@ -0,0 +1,32 @@
+module Cullender
+  module Generators
+    module OrmHelpers
+      def model_contents
+<<-CONTENT
+  # Include default devise modules. Others available are:
+  # :token_authenticatable, :confirmable,
+  # :lockable, :timeoutable and :omniauthable
+  devise :database_authenticatable, :registerable,
+         :recoverable, :rememberable, :trackable, :validatable
+
+CONTENT
+      end
+
+      def model_exists?
+        File.exists?(File.join(destination_root, model_path))
+      end
+      
+      def migration_exists?(table_name)
+        Dir.glob("#{File.join(destination_root, migration_path)}/[0-9]*_*.rb").grep(/\d+_add_devise_to_#{table_name}.rb$/).first
+      end
+      
+      def migration_path
+        @migration_path ||= File.join("db", "migrate")
+      end
+
+      def model_path
+        @model_path ||= File.join("app", "models", "#{file_path}.rb")
+      end
+    end
+  end
+end

data/lib/generators/cullender/templates/cullender.rb

@@ -0,0 +1,3 @@
+Cullender.setup do |config|
+
+end

data/lib/generators/cullender/templates/cullender_migration.rb

@@ -0,0 +1,13 @@
+class CreateCullenderTables < ActiveRecord::Migration
+  def change
+    create_table :rules do |t|
+<%= migration_data -%>
+
+<% attributes.each do |attribute| -%>
+      t.<%= attribute.type %> :<%= attribute.name %>
+<% end -%>
+
+      t.timestamps
+    end
+  end
+end

data/lib/tasks/cullender_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :cullender do
+#   # Task goes here
+# end

data/spec/controllers/cullender/rules_controller_spec.rb

@@ -0,0 +1,180 @@
+require 'spec_helper'
+
+# This spec was generated by rspec-rails when you ran the scaffold generator.
+# It demonstrates how one might use RSpec to specify the controller code that
+# was generated by Rails when you ran the scaffold generator.
+#
+# It assumes that the implementation code is generated by the rails scaffold
+# generator.  If you are using any extension libraries to generate different
+# controller code, this generated spec may or may not pass.
+#
+# It only uses APIs available in rails and/or rspec-rails.  There are a number
+# of tools you can use to make these specs even more expressive, but we're
+# sticking to rails and rspec-rails APIs to keep things simple and stable.
+#
+# Compared to earlier versions of this generator, there is very limited use of
+# stubs and message expectations in this spec.  Stubs are only used when there
+# is no simpler way to get a handle on the object needed for the example.
+# Message expectations are only used when there is no simpler way to specify
+# that an instance is receiving a specific message.
+
+describe Cullender::RulesController do
+  before(:each) do
+    @request.env["cullender.mapping"] = Cullender.mappings[:event]
+    Cullender::Rule.reset_callbacks(:create)
+  end
+  # This should return the minimal set of attributes required to create a valid
+  # Rule. As you add validations to Rule, be sure to
+  # update the return value of this method accordingly.
+  def valid_attributes
+    {name: "MyRule"}
+  end
+  
+  # This should return the minimal set of values that should be in the session
+  # in order to pass any filters (e.g. authentication) defined in
+  # RulesController. Be sure to keep this updated too.
+  def valid_session
+    {}
+  end
+
+  describe "GET index" do
+    before(:each) do
+      @rule = Cullender::Rule.create(valid_attributes)
+      get :index, {:use_route => :cullender}, valid_session
+    end
+        
+    it "assigns all rules as @rules" do
+      assigns(:rules).should eq([@rule])
+    end
+    
+  end
+
+
+  describe "GET new" do
+    it "assigns a new rule as @rule" do
+      get :new, {:use_route => :cullender}, valid_session
+      assigns(:rule).should be_a_new(Cullender::Rule)
+    end
+  end
+
+  describe "GET show" do
+    it "assigns the requested rule as @rule" do
+      rule = Cullender::Rule.create(valid_attributes)
+      get :show, {:id => rule.to_param, :use_route => :cullender}, valid_session
+      assigns(:rule).should eq(rule)
+    end
+  end
+
+  describe "POST create" do
+    context "with valid params" do
+      it "creates a new Rule" do
+        expect {
+          post :create, {:rule => valid_attributes, :use_route => :cullender}, valid_session
+        }.to change(Cullender::Rule, :count).by(1)
+      end
+
+      it "assigns a newly created rule as @rule" do
+        post :create, {:rule => valid_attributes, :use_route => :cullender}, valid_session
+        assigns(:rule).should be_a(Cullender::Rule)
+        assigns(:rule).should be_persisted
+      end
+
+      it "redirects to the rules_url" do
+        post :create, {:rule => valid_attributes, :use_route => :cullender}, valid_session
+        response.should redirect_to({"controller"=>controller.params[:controller], "action"=>"index", :use_route => :cullender})
+      end
+    end
+
+    context "with invalid params" do
+      it "assigns a newly created but unsaved rule as @rule" do
+        # Trigger the behavior that occurs when invalid params are submitted
+        Cullender::Rule.any_instance.stub(:save).and_return(false)
+        post :create, {:rule => {:name => "asd"}, :use_route => :cullender}, valid_session
+        assigns(:rule).should be_a_new(Cullender::Rule)
+      end
+
+      it "re-renders the 'new' template" do
+        # Trigger the behavior that occurs when invalid params are submitted
+        Cullender::Rule.any_instance.stub(:save).and_return(false)
+        post :create, {:rule => {:name => "asd"}, :use_route => :cullender}, valid_session
+        response.should render_template("new")
+      end
+    end
+  end
+
+  describe "PUT update" do
+    before(:each) do
+      controller.stub(:clean_ids).and_return(nil)
+      Cullender::Rule.reset_callbacks(:update)
+    end
+    context "with valid params" do
+      it "updates the requested rule" do
+        rule = Cullender::Rule.create(valid_attributes)
+        # Assuming there are no other rules in the database, this
+        # specifies that the Rule created on the previous line
+        # receives the :update_attributes message with whatever params are
+        # submitted in the request.
+        
+        Cullender::Rule.any_instance.should_receive(:update_attributes).with({'name' => 'New Name'})
+        put :update, {:id => rule.to_param, :rule => {'name' => 'New Name'}, :use_route => :cullender}, valid_session
+      end
+
+      it "assigns the requested rule as @rule" do
+        rule = Cullender::Rule.create(valid_attributes)
+        put :update, {:id => rule.to_param, :rule => valid_attributes, :use_route => :cullender}, valid_session
+        assigns(:rule).should eq(rule)
+      end
+
+      it "redirects to the rules page" do
+        rule = Cullender::Rule.create(valid_attributes)
+        put :update, {:id => rule.to_param, :rule => valid_attributes, :use_route => :cullender}, valid_session
+        response.should redirect_to({"controller"=>controller.params[:controller], "action"=>"index", :use_route => :cullender})
+      end
+    end
+
+    context "with invalid params" do
+      it "assigns the rule as @rule" do
+        rule = Cullender::Rule.create(valid_attributes)
+        # Trigger the behavior that occurs when invalid params are submitted
+        Cullender::Rule.any_instance.stub(:save).and_return(false)
+        put :update, {:id => rule.to_param, :rule => {:name => "asd"}, :use_route => :cullender}, valid_session
+        assigns(:rule).should eq(rule)
+      end
+
+      it "re-renders the 'show' template" do
+        rule = Cullender::Rule.create(valid_attributes)
+        # Trigger the behavior that occurs when invalid params are submitted
+        Cullender::Rule.any_instance.stub(:save).and_return(false)
+        put :update, {:id => rule.to_param, :rule => {:name => "asd"}, :use_route => :cullender}, valid_session
+        response.should render_template("show")
+      end
+    end
+  end
+  
+  describe "DELETE destroy" do
+    before(:each)do
+      @factory = Cullender::Rule.create(valid_attributes)
+      Cullender::Rule.reset_callbacks(:destroy)
+    end
+    it "destroys the requested model" do
+      expect {
+        delete :destroy, {:id => @factory.to_param, :use_route => :cullender}, valid_session
+      }.to change(@factory.class, :count).by(-1)
+    end
+
+    it "redirects to the index url" do
+      delete :destroy, {:id => @factory.to_param, :use_route => :cullender}, valid_session
+      if defined?(@redirect)
+        response.should redirect_to(@redirect)
+      else
+        response.should redirect_to({"controller"=>controller.params[:controller], "action"=>"index", :use_route => :cullender})
+      end
+    end
+
+    it "returns a flash message that says that the model has been destroyed" do
+      delete :destroy, {:id => @factory.to_param, :use_route => :cullender}, valid_session
+      controller.flash[:notice].should eql("Rule was successfully destroyed.")
+    end
+  end
+
+end

data/spec/cullender/controllers/filter_logic_spec.rb

@@ -0,0 +1,233 @@
+require 'spec_helper'
+
+describe "Cullender::Controllers::FilterLogic" do
+
+  before(:each) do
+    @object = Object.new
+    @object.extend(Cullender::Controllers::FilterLogic)
+  end
+
+
+        def add_or_filter(key, params, field, should_raise = false)
+          if params.present? && params.has_key?(key)
+            if should_raise
+              params[key] = {1 => params[key], 2 => add_operator(field)}
+            else
+              idx = params[key].keys.last.to_i + 1
+              params[key].deep_merge!({idx => add_operator(field)})
+            end
+          else
+            if should_raise
+              params[key] = add_operator(field)
+            else
+              params[key] = add_operator(field)
+            end
+          end
+        end
+  describe "#add_or_filter" do
+    context "with filter(s) defined" do
+      context "OR with the base" do
+        context "with only one group" do
+          before(:each) do
+            @hash = {"f" => {"some_field" => {"o" => nil}}}
+            @object.add_or_filter("f", @hash, "new_field", true)
+          end        
+          it "moves the existing group to a higher level" do
+            @hash["f"].should have_key(1)
+            @hash["f"][1].should have_key("some_field")
+          end
+          it "adds the filter to a new group" do
+            @hash["f"].should have_key(2)
+            @hash["f"][2].should have_key("new_field")
+          end
+        end
+        context "with many groups" do
+          before(:each) do
+            @hash = {"f" => {1 => {"some_field1" => {"o" => nil}}, 2 => {"some_field2" => {"o" => nil}}}}
+            @object.add_or_filter("f", @hash, "new_field", true)
+          end
+          it "moves the existing group to a higher level" do
+            @hash["f"].should have_key(1)
+            @hash["f"][1][1].should have_key("some_field1")
+            @hash["f"][1][2].should have_key("some_field2")
+          end
+          it "adds the filter to a new group" do
+            @hash["f"].should have_key(2)
+            @hash["f"][2].should have_key("new_field")
+          end
+        end
+      end
+      context "OR with other groups at the same level" do
+        before(:each) do
+          @hash = {"f" => {1 => {"some_field1" => {"o" => nil}}, 2 => {"some_field2" => {"o" => nil}}}}
+          @object.add_or_filter("f", @hash, "new_field", false)
+        end
+        it "keeps the existing group at the higher level" do
+          @hash["f"].should have_key(1)
+          @hash["f"][1].should have_key("some_field1")
+          @hash["f"][2].should have_key("some_field2")
+        end
+        it "adds the filter to as a new group" do
+          @hash["f"].should have_key(3)
+          @hash["f"][3].should have_key("new_field")
+        end   
+      end
+    end
+    context "with filter(s) undefined" do
+      before(:each) do
+        @hash = {}
+        @object.add_or_filter("f", @hash, "my_field")        
+      end
+      it "creates a new filter hash with the field" do
+        @hash.should have_key("f")
+        @hash["f"].should have_key("my_field")
+      end
+    end
+  end
+  
+  # def add_and_filter(params, field)
+  #   if params.has_key?("f")
+  #     params["f"].deep_merge!(add_operator(field))
+  #   else
+  #     params["f"] = add_operator(field)
+  #   end
+  # end
+  describe "#add_and_filter" do
+    context "with existing filter(s)" do
+      context "that are deeply nested" do
+        before(:each) do
+          @params = { "f" => {1 => {"field1" => {"o" => nil}, "field2" => {"o" => nil}}, 2 => {1 => {"field3" => {"o" => nil}}}, "field4" => {"o" => nil}}}
+        end
+        it "adds a new field with 1 deep if the key doesn't exist" do
+          @object.add_and_filter("f", @params, { 1 => "field3"})
+          @params["f"][1].should have(3).keys
+          @params["f"][1].should have_key("field3")
+        end
+        it "adds a new field with 2 deep if the key doesn't exist" do
+          @object.add_and_filter( "f", @params, {2 => {1 => "field2"}})
+          @params["f"][2][1].should have(2).keys
+          @params["f"][2][1].should have_key("field2")
+        end
+        it "doesn't add a new field if the key already exists" do
+          @object.add_and_filter("f", @params, { 1 => "field2"})
+          @params["f"][1].should have(2).keys
+        end
+      end
+      context "that are not nested" do
+        before(:each) do
+          @params = { "f" => {"field1" => {"o" => nil}, "field2" => {"o" => nil}}}
+        end
+        it "adds a new field if the key doesn't exist" do
+          @object.add_and_filter("f", @params, "field3")
+          @params["f"].should have(3).keys
+          @params["f"].should have_key("field3")
+        end
+      end
+    end
+    context "without existing filter(s)" do
+      before(:each) do
+        @hash = {}
+        @object.add_and_filter("f", @hash, "my_field")        
+      end
+      it "creates a new filter hash with the field" do
+        @hash.should have_key("f")
+        @hash["f"].should have_key("my_field")
+      end
+    end    
+  end
+  
+  describe "#remove_and_filter" do
+    context "with a filter present" do
+      it "deletes the part of hash specified by a string" do
+        params = {"f" => {"field" => {"o" => nil}}}
+        params["f"].should_receive(:delete).with("field")
+        @object.remove_and_filter("f", params, "field")
+      end
+      it "deletes the part of hash specified by a hash" do
+        params = {"f" => { 1 => {"field" => {"o" => nil}}}}
+        params["f"].should_receive(:deep_delete).with({1 => {"field" => nil}})
+        @object.remove_and_filter("f", params, {1 => {"field" => nil}})
+      end
+    end
+    context "without a filter present" do
+      it "does nothing" do
+        params = {"f" => {"field" => {"o" => nil}}}
+        params.stub(:has_key?).with("f").and_return(false)
+        params["f"].should_not_receive(:deep_delete)
+        @object.remove_and_filter("f", params, "field")
+      end
+    end
+  end
+  
+
+  describe "#add_operator" do
+    it "returns a hash with an operator indexed by the specified string" do
+      @object.add_operator("index").should eql({"index" => {"o" => nil}})
+    end
+    it "returns a hash with an operator indexed by the specified hash" do
+      @object.add_operator({0 => "index"}).should eql({0 => {"index" => {"o" => nil}}})
+    end
+  end
+  
+  describe "#apply_filter_actions" do
+    context "add OR" do
+      context "with no params" do
+        it "raise new field", :current => true do
+          params = {"or"=>{"raise_field"=>"name", "raise"=>"OR"}}
+          flag = @object.apply_filter_actions("triggers", {"name" => "dsafdasg"}, params)
+          flag.should be_true
+        end
+      end
+      context "with 'field' present" do
+        before(:each) do          
+          @params = {"or" => {"field" => "myfield", "commit" => "OR"}}
+        end
+        it "adds an or filter" do
+          @object.should_receive(:add_or_filter).with("name", {"name" => {}}, "myfield", false)
+          @object.apply_filter_actions("name", {"name" => {}}, @params)
+        end
+      end
+      context "without 'field' present" do
+        before(:each) do
+          @params = {"or" => {"field" => nil, "commit" => "OR"}}
+        end
+        it "does not add an or filter" do
+          @object.should_not_receive(:add_or_filter)
+          @object.apply_filter_actions("name", {"name" => {}}, @params)
+        end
+      end
+    end
+    context "add AND" do
+      context "with 'field' present" do
+        context "with 'field' present" do
+          before(:each) do
+            @params = {"and" => {"field" => "myfield", "commit" => "AND"}}
+          end
+          it "adds an or filter" do
+            @object.should_receive(:add_and_filter).with("name", {"name" => {}}, "myfield")
+            @object.apply_filter_actions("name", {"name" => {}}, @params)
+          end
+        end
+        context "without 'field' present" do
+          before(:each) do
+            @params = {"and" => {"field" => nil, "commit" => "OR"}}
+          end
+          it "does not add an or filter" do
+            @object.should_not_receive(:add_and_filter)
+            @object.apply_filter_actions("name", {"name" => {}}, @params)
+          end
+        end
+      end
+    end
+    context "remove" do
+      before(:each) do
+        @params = {"remove" => "myfield"}
+      end
+      it "adds an or filter" do
+        @object.should_receive(:remove_and_filter).with("name", {"name" => {}}, "myfield")
+        @object.apply_filter_actions("name", {"name" => {}}, @params)
+      end
+    end
+  end
+
+end