adva_cms 0.0.1

data/vendor/gems/has_filter/lib/has_filter/filter.rb

@@ -0,0 +1,17 @@
+require_dependency 'has_filter/filter/base'
+require_dependency 'has_filter/filter/categorized'
+require_dependency 'has_filter/filter/chain'
+require_dependency 'has_filter/filter/set'
+require_dependency 'has_filter/filter/state'
+require_dependency 'has_filter/filter/tagged'
+require_dependency 'has_filter/filter/text'
+
+module HasFilter
+  module Filter
+		class << self
+		  def build(type, *args)
+	      HasFilter::Filter.const_get(type.to_s.classify).build(*args)
+	    end
+	  end
+	end
+end

data/vendor/gems/has_filter/lib/has_filter/filter/base.rb

@@ -0,0 +1,67 @@
+module HasFilter
+  module Filter
+  	class Base
+  		class_attribute :scopes, :priority
+		  attr_accessor :set, :options
+		  delegate :view, :to => :set
+  		
+  		class << self
+  		  def build(*args)
+  	      [new(*args)]
+  	    end
+  	  end
+  		
+  		def initialize(options = {})
+  			@options = options
+  		end
+  	  
+  	  def attribute
+  	    @options[:attribute] if @options
+	    end
+	    
+	    def matches?(name)
+	      type == name
+      end
+  		
+  		def select(selected)
+  		  @selected = selected
+		  end
+		  
+		  def selected
+		    @selected ||= {}
+	    end
+		  
+		  def selected?
+        set.selected?(type)
+	    end
+		
+  		def type
+  		  @type ||= self.class.name.demodulize.underscore.to_sym
+  	  end
+	    
+	    def to_field_set_tag(options = {})
+        view.capture do
+    		  options.reverse_merge! :id => "filter_#{type}_#{set.index}", :class => "filter filter_#{attribute || type}"
+  	      options[:class] += ' selected' if selected?
+          view.field_set_tag(nil, options.slice(:id, :class, :label)) do
+            to_form_fields(options).join("\n")
+          end
+        end
+      end
+  	  
+      def filter_select_option
+        [I18n.t(type, :scope => :'has_filter.filters', :default => type.to_s.gsub('_', ' ')), type]
+      end
+
+      protected
+
+      def form_field_name(*keys)
+        "filters[]" + keys.map { |key| "[#{key}]" }.join
+      end
+    
+      def form_field_id(*keys)
+        "filter" + keys.map { |key| "_#{key}" }.join + "_#{set.index}"
+      end
+  	end
+	end
+end

data/vendor/gems/has_filter/lib/has_filter/filter/categorized.rb

@@ -0,0 +1,24 @@
+module HasFilter
+  module Filter
+  	class Categorized < Base
+  	  self.priority = 4
+  		self.scopes = [:categories]
+		
+  		def to_form_fields(options = {})
+  		  options[:categories].blank? ? [] : [categories_select_tag(options)]
+  		end
+		
+  		def scope(target)
+  		  target.categorized(*selected)
+  		end
+		
+  		protected
+  		
+  		  def categories_select_tag(options = {})
+  		    categories = options[:categories].map { |c| [c.title, c.id] }
+  		    options = view.options_for_select(categories, selected)
+  		    view.select_tag(form_field_name(:categorized, nil), options, :id => form_field_id(:categorized, :id))
+		    end
+  	end
+	end
+end

data/vendor/gems/has_filter/lib/has_filter/filter/chain.rb

@@ -0,0 +1,45 @@
+# A filter chain is a collection of filter sets. A filter set hold individual 
+# filters of which only one can be active/selected at a time.
+
+module HasFilter
+  module Filter
+    class Chain < Array
+      class << self
+        def build(owner, *args)
+          new owner, Set.build(*args)
+        end
+      end
+      
+      attr_reader :owner, :view
+      
+      def initialize(owner, *sets)
+        @owner = owner
+        concat sets.each { |set| set.chain = self }
+      end
+      
+      def select(params)
+        params ||= []
+        adjust_size(params)
+        each { |set| set.select(params[set.index]) }
+        self
+      end
+      
+      def scope(target = nil)
+        inject(target || owner) { |target, set| set.scope(target) }
+      end
+		  
+  		def to_form_fields(view, options = {})
+  		  @view = view
+        map { |set| set.to_field_set_tag(options) }
+  		end
+  		
+  		protected
+  		  
+  		  def adjust_size(params)
+  		    size = [params.size, 1].max
+  		    replace (1..size).map { first.dup }
+  		    each_with_index { |set, index| set.index = index }
+        end
+    end
+  end
+end

data/vendor/gems/has_filter/lib/has_filter/filter/set.rb

@@ -0,0 +1,80 @@
+module HasFilter
+  module Filter
+    class Set < Array
+      attr_accessor :chain, :index, :selected
+      delegate :view, :to => :chain
+      
+      class << self
+        def build(filters)
+          new filters.map { |filter|
+            case filter
+            when Hash
+              filter.map { |type, args| Filter.build(type, args) }
+            when Symbol
+              Filter.build(filter)
+            end
+          }.flatten
+        end
+      end
+      
+      def initialize(filters)
+        concat filters.each { |f| f.set = self }
+        sort!
+      end
+  	  
+  	  def initialize_copy(orig)
+  	    super
+  	    replace orig.map { |f| f.dup }.each { |f| f.set = self }
+	    end
+  		
+  		def sort!
+        head = self.reject { |f| !f.is_a?(Text) }
+        replace head + (self - head).sort { |a, b| a.priority <=> b.priority }
+		  end
+	    
+      def select(params)
+        params ||= { :selected => first.attribute || first.type }
+        @selected = params[:selected].to_sym
+        find_filter(selected).select(params[selected]) if @selected
+      end
+      
+      def selected?(name)
+        selected == name
+      end
+      
+      def first?
+        index == 0
+      end
+
+      def scope(target)
+        selected ? find_filter(selected).scope(target) : target
+      end
+		  
+  		def to_field_set_tag(options = {})
+        view.capture do
+          view.field_set_tag(nil, :class => 'set') do
+            tag = filter_select_tag(view) + "\n"
+            tag << map { |filter| filter.to_field_set_tag(options.dup) }.join("\n")
+            tag << view.content_tag(:span, :class => 'controls') do
+              view.content_tag(:a, '+', :href => '#', :class => 'filter_add') + 
+              view.content_tag(:a, '-', :href => '#', :class => 'filter_remove')
+            end
+            tag
+    		  end
+  		  end
+  		end
+  		
+  		protected
+    
+      def find_filter(type)
+        # FIXME ask the filter instead: filter.matches?(type) or something
+        detect { |filter| filter.matches?(type) }
+      end
+    
+      def filter_select_tag(view)
+        options = view.options_for_select(map(&:filter_select_option), selected)
+        view.select_tag :'filters[][selected]', options, :id => "selected_filter_#{index}", :class => 'selected_filter'
+      end
+    end
+  end
+end

data/vendor/gems/has_filter/lib/has_filter/filter/state.rb

@@ -0,0 +1,25 @@
+module HasFilter
+  module Filter
+  	class State < Base
+  	  self.priority = 3
+  		self.scopes = [:state]
+
+  		def to_form_fields(options = {})
+  			@options[:states].map { |state| state_tag(state) }
+  		end
+
+  		def scope(target)
+	      # FIXME assert that state is a valid state!
+  		  selected.inject(target) { |target, state| target.send(state) }
+  		end
+
+  		protected
+
+  		  def state_tag(state)
+  		    id = form_field_id(:state, state)
+  		    view.check_box_tag(form_field_name(:state, nil), state, selected.include?(state), :id => id) +
+  		    view.label_tag(id, I18n.t(state, :scope => :'has_filter.states', :default => state.to_s))
+		    end
+  	end
+	end
+end

data/vendor/gems/has_filter/lib/has_filter/filter/tagged.rb

@@ -0,0 +1,22 @@
+module HasFilter
+  module Filter
+  	class Tagged < Base
+  	  self.priority = 2
+  		self.scopes = [:tagged]
+		
+  		def to_form_fields(options = {})
+  		  [query_tag]
+  		end
+		
+  		def scope(target)
+  		  target.tagged(selected)
+  		end
+		
+  		protected
+  		
+  		  def query_tag
+  		    view.text_field_tag(form_field_name(:tagged), selected, :id => form_field_id(:tagged, :query))
+		    end
+  	end
+	end
+end

data/vendor/gems/has_filter/lib/has_filter/filter/text.rb

@@ -0,0 +1,55 @@
+module HasFilter
+  module Filter
+  	class Text < Base
+  	  self.priority = 1
+  		self.scopes = [:contains, :starts_with, :ends_with, :is]
+		
+  		class << self
+  		  def build(args)
+  	      Array(args[:attributes]).map { |attribute| new(:attribute => attribute) }
+  	    end
+  	  end
+	    
+	    def matches?(name)
+	      attribute == name
+      end
+		  
+		  def selected?
+        set.selected?(attribute)
+	    end
+  	  
+  	  def to_field_set_tag(options = {})
+  	    options[:id] = "filter_#{attribute}_#{set.index}"
+  	    super
+	    end
+  		
+  		def to_form_fields(options = {})
+  		  [scopes_select_tag, query_input_tag]
+  		end
+		
+  		def scope(target)
+	      # FIXME assert that scope is contained in self.scopes
+  	    scope, query = selected.values_at(:scope, :query)
+  	    query.blank? ? target : target.send(scope, attribute, query)
+  		end
+  		
+      def filter_select_option
+        [I18n.t(attribute, :scope => :'has_filter.filters', :default => attribute.to_s.gsub('_', ' ')), attribute]
+      end
+
+  		protected
+  		
+      def scopes_select_tag
+        options = self.class.scopes.map do |scope| 
+          [I18n.t(scope, :scope => :'has_filter.scopes', :default => scope.to_s.gsub('_', ' ')), scope]
+        end
+        options = view.options_for_select(options, selected[:scope].try(:to_sym))
+        view.select_tag(form_field_name(attribute, :scope), options, :id => form_field_id(attribute, :scope))
+      end
+    
+      def query_input_tag
+        view.text_field_tag(form_field_name(attribute, :query), selected[:query], :id => form_field_id(attribute, :query))
+      end
+  	end
+	end
+end

data/vendor/gems/has_filter/lib/has_filter/version.rb

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

data/vendor/gems/has_filter/test/db/setup.rb

@@ -0,0 +1,45 @@
+begin
+  ActiveRecord::Base.connection 
+rescue ActiveRecord::ConnectionNotEstablished => e
+
+  dir_name = File.dirname(__FILE__)
+  log_file = "#{dir_name}/../log/test.log"
+  db_file  = "#{dir_name}/test.sqlite3.db"
+  
+  FileUtils.rm(db_file) if File.exists?(db_file)
+  FileUtils.mkdir_p(File.dirname(log_file)) unless File.exists?(File.dirname(log_file))
+
+  ActiveRecord::Base.logger = Logger.new log_file
+  ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :dbfile => db_file
+end
+
+ActiveRecord::Migration.verbose = false
+ActiveRecord::Schema.define(:version => 20090126133510) do
+  create_table "has_filter_articles", :force => true do |t|
+    t.string  :title
+    t.string  :body
+    t.integer :published
+    t.integer :approved
+    t.string  :cached_tag_list
+  end unless ActiveRecord::Base.connection.table_exists?('has_filter_articles')
+
+  create_table "has_filter_categories", :force => true do |t|
+    t.string  :title
+  end unless ActiveRecord::Base.connection.table_exists?('has_filter_categories')
+
+  create_table "has_filter_categorizations", :force => true do |t|
+    t.integer :category_id
+    t.integer :has_filter_article_id
+  end unless ActiveRecord::Base.connection.table_exists?('has_filter_categorizations')
+  
+  create_table :tags, :force => true do |t|
+    t.column :name, :string
+  end unless ActiveRecord::Base.connection.table_exists?('tags')
+
+  create_table :taggings, :force => true do |t|
+    t.column :tag_id, :integer
+    t.column :taggable_id, :integer
+    t.column :taggable_type, :string
+    t.column :created_at, :datetime
+  end unless ActiveRecord::Base.connection.table_exists?('taggings')
+end

data/vendor/gems/has_filter/test/fixtures.rb

@@ -0,0 +1,15 @@
+HasFilterArticle.destroy_all
+HasFilterCategory.destroy_all
+HasFilterCategorization.destroy_all
+
+first  = HasFilterArticle.create! :title => 'first',  :body => 'first',  :published => 1, :approved => 0, :tag_list => 'foo bar baz'
+second = HasFilterArticle.create! :title => 'second', :body => 'second', :published => 1, :approved => 1, :tag_list => 'foo bar'
+third  = HasFilterArticle.create! :title => 'third',  :body => 'third',  :published => 0, :approved => 0, :tag_list => 'foo'
+third  = HasFilterArticle.create! :title => 'UPCASE',  :body => 'UPCASE',  :published => 0, :approved => 0, :tag_list => 'upcase'
+
+foo = HasFilterCategory.create! :title => 'has_filter foo'
+bar = HasFilterCategory.create! :title => 'has_filter bar'
+
+first.categories  << foo << bar
+second.categories << foo
+

data/vendor/gems/has_filter/test/has_filter/filter_chain_test.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+module HasFilter
+  class FilterChainTest < ActiveSupport::TestCase
+    include HasFilter
+    include HasFilter::TestHelper
+    
+    def setup
+      @chain = HasFilterArticle.filter_chain
+    end
+
+    test 'builds a filter chain with an initial set' do
+      assert_equal 'Set', @chain.first.class.name.demodulize
+    end
+    
+    test 'properly duplicates instances when adjusting its size' do
+      @chain.send :adjust_size, 2
+      first, second = *@chain[0, 2]
+      assert_not_equal first.object_id, second.object_id 
+      assert_not_equal first.first.object_id, second.first.object_id 
+      assert_equal first.object_id, first.first.set.object_id 
+      assert_equal second.object_id, second.first.set.object_id 
+    end
+  end
+  
+  class FilterSetTest < ActiveSupport::TestCase
+    def setup
+      @chain = HasFilterArticle.filter_chain
+    end
+
+    test 'set has a text filter for each attribute' do
+      set = HasFilterArticle.filter_chain.first
+      assert_equal %w(body excerpt title), set[0..2].map(&:attribute).map(&:to_s).sort
+    end
+    
+    test 'sorts text filters to the top, not changing their order, followed by the rest ordered by priority' do
+      expected = ['Text', 'Text', 'Text', 'Tagged', 'State', 'Categorized']
+      assert_equal expected, @chain.first.map{ |filter| filter.class.name.demodulize }
+    end
+  end
+end