adva 0.1.4 → 0.2.0

data/vendor/gems/has_filter/app/assets/stylesheets/has_filter/filter.scss

@@ -1,100 +0,0 @@
-#filters {
-  min-width: 320px;
-  position: relative;
-  padding-top: 15px;
-}
-#filters .set {
-  position: relative;
-	white-space: nowrap;
-	padding: 0;
-	margin-bottom: 2px;
-	background-color: #e8e8e8;
-}
-#filters .set fieldset {
-  display: none;
-  vertical-align: middle;
-  padding: 0;
-}
-#filters .selected_filter, 
-#filters .set .selected {
-  display: inline-block;
-}
-#filters .set select {
-  vertical-align: middle;
-}
-#filters .set input[type=text] {
-  width: 50px;
-  padding: 1px 5px 2px 5px;
-  font-size: 0.9em;
-  vertical-align: middle;
-}
-#filters .set input[type=checkbox] {
-  vertical-align: middle;
-}
-#filters .set label {
-  display: inline;
-  margin: -2px 0 2px 0;
-  font-weight: normal;
-  font-size: 0.85em;
-  vertical-align: baseline;
-}
-#filters .set .controls {
-  display: inline-block;
-  position: absolute;
-  right: 4px;
-  top: 3px;
-  width: 36px;
-  height: 18px;
-}
-#filters .set .controls a {
-  display: inline-block;
-  float: right;
-  overflow: hidden;
-  width: 18px;
-  height: 18px;
-  outline: 0px;
-  text-indent: 18px;
-}
-#filters .set .controls a.filter_add {
-  background: image_url("has_filter/filter_add.png") left top;
-}
-#filters .set .controls a.filter_remove {
-  background: image_url("has_filter/filter_remove.png") left top;
-}
-#filters .set:first-child .controls a.filter_remove {
-  display: none;
-  text-indent: 20px;
-}
-#filters .set .controls a.filter_add {
-/*  margin-right: 4px;*/
-}
-#filters .set .controls a.filter_remove {
-/*  margin-left: -4px;*/
-}
-#filters div.submit {
-  height: 18px;
-	padding: 0;
-  padding-left: 16px;
-	margin-right: 2px;
-  background: image_url("has_filter/filter_button_left.png") repeat-x left top;
-  vertical-align: top;
-}
-
-#filters div.submit button {
-	display: block;
-	float: right;
-  padding: 0px 16px 0px 0px;
-	margin-right: -2px;
-	border: 0;
-  background: image_url("has_filter/filter_button_right.png") repeat-x right top;
-  font-size: 11px;
-	height: 20px;
-  color: #555;
-  outline: none;
-	text-decoration: none;
-}
-
-#filters div.submit button:hover {
-  color: #333;
-  cursor: pointer;
-}

data/vendor/gems/has_filter/app/helpers/filter_helper.rb

@@ -1,3 +0,0 @@
-module FilterHelper
-  include HasFilter::Helper
-end

data/vendor/gems/has_filter/has_filter.gemspec

@@ -1,17 +0,0 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path('../lib/has_filter/version', __FILE__)
-
-Gem::Specification.new do |gem|
-  gem.authors       = ["Micah Geisel"]
-  gem.email         = ["micah@botandrose.com"]
-  gem.description   = %q{TODO: Write a gem description}
-  gem.summary       = %q{TODO: Write a gem summary}
-  gem.homepage      = ""
-
-  gem.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.name          = "has_filter"
-  gem.require_paths = ["lib"]
-  gem.version       = HasFilter::VERSION
-end

data/vendor/gems/has_filter/init.rb

@@ -1,3 +0,0 @@
-# register_javascript_expansion :admin => %w( has_filter/jquery.filter )
-# register_stylesheet_expansion :admin => %w( has_filter/filter )
-# register_stylesheet_expansion :admin_alternate => %w( has_filter/alternate/filter )

data/vendor/gems/has_filter/lib/has_filter/active_record/act_macro.rb

@@ -1,102 +0,0 @@
-# Heavily inspired by Noel Rappin's "More Named Scope Awesomeness"
-# http://www.pathf.com/blogs/2008/06/more-named-scope-awesomeness/
-
-module HasFilter
-  # # raised when filter_by is called with an attribute that has not been
-  # # whitelisted for being filtered
-  # class IllegalAttributeAccessError < ActiveRecordError
-  #   attr_reader :attribute
-  #   def initialize(attribute)
-  #     @attribute = attribute
-  #     super "Tried to filter by #{attribute.inspect}. This attribute has not been whitelisted for filtering."
-  #   end
-  # end
-
-  module ActiveRecord
-    module ActMacro
-      def has_filter(*filters)
-        return if has_filter?
-        include InstanceMethods
-        extend ClassMethods
-
-        class_attribute :filter_chain
-        self.filter_chain = ::HasFilter::Filter::Chain.build(self, filters)
-
-        scopes = { # FIXME make these extensible
-          :is                  => ["=" ],
-          :is_not              => ["<>"],
-          :contains            => ["LIKE",     "%%%s%"],
-          :does_not_contain    => ["NOT LIKE", "%%%s%"],
-          :starts_with         => ["LIKE",     "%s%"  ],
-          :does_not_start_with => ["NOT LIKE", "%s%"  ],
-          :ends_with           => ["LIKE",     "%%%s" ],
-          :does_not_end_with   => ["NOT LIKE", "%%%s" ] }
-          # FIXME add these
-          # created_before, created_after
-          # updated_before, updated_after
-
-        scopes.each do |name, scope|
-          scope name, lambda { |column, value| filter_scope(column, Array(value), *scope) }
-        end
-
-        scope :contains_all, contains_all_scope
-        scope :categorized, categorized_scope
-      end
-
-      def filtered(filters)
-        scope = scope(:find).blank? ? self : scoped(scope(:find))
-        filter_chain.select(filters).scope(scope)
-      end
-
-      def has_filter?
-        included_modules.include? HasFilter::ActiveRecord::InstanceMethods
-      end
-    end
-
-    module ClassMethods
-      protected
-        def contains_all_scope
-          lambda { |column, values|
-            values = values.split(' ') if values.is_a?(String)
-            values.map! { |value| "%#{value}%" }
-            { :conditions => [(["#{column} LIKE ?"] * values.size).join(' AND '), *values] }
-          }
-        end
-
-        def categorized_scope
-          lambda { |*ids|
-            { :select => "#{table_name}.*, COUNT(*) AS count",
-              :joins => { :categorizations => :category },
-              :conditions => ["#{reflect_on_association(:categories).table_name}.id IN(?)", ids],
-              :group => "#{table_name}.id HAVING count >= #{ids.size}" }
-          }
-        end
-
-        def filter_scope(column, values, operator, format = nil)
-          query = (["#{column} #{operator} ?"] * values.size)
-          # FIXME why did we have .map($:downcase) here ?
-          values = values.map{ |value| format ? format % value : value } # .map(&:downcase)
-          scope = { :conditions => [query.join(' OR '), *values] }
-          translated?(column) ? merge_globalization_scope(scope) : scope
-        end
-
-        def translated?(column)
-          # FIXME really should be in globalize
-          respond_to?(:globalize_options) && globalize_options[:translated_attributes].include?(column.to_sym)
-        end
-        
-        def merge_globalization_scope(scope)
-          if scope.has_key?(:conditions)
-            scope[:conditions][0] += " AND current = ?"
-            scope[:conditions] << true
-            scope.merge!(:joins => :globalize_translations, :group => "#{self.table_name}.id")
-          else
-            scope.merge!(:joins => :globalize_translations, :group => "#{self.table_name}.id", :conditions => ['current = ?', true])
-          end
-        end
-    end
-
-    module InstanceMethods
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,45 +0,0 @@
-# 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

@@ -1,80 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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/filter.rb

@@ -1,17 +0,0 @@
-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/version.rb

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

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

@@ -1,22 +0,0 @@
-require "has_filter/version"
-require 'has_filter/filter'
-require 'has_filter/active_record/act_macro'
-
-module HasFilter
-  module Helper
-    def filter_for(klass, options = {})
-      form_tag(options.delete(:url) || request.path, :method => :get, :id => 'filters', :class => 'filters') do
-        klass.filter_chain.to_form_fields(self, options).join(raw("\n")) + 
-        content_tag(:div, :class => 'submit') do
-          content_tag(:button, I18n.t(:'filter.submit.value', :default => 'Apply'))
-        end
-      end
-    end
-  end
-
-  class Engine < Rails::Engine
-  end
-end
-
-ActiveRecord::Base.send :extend, HasFilter::ActiveRecord::ActMacro
-ActionController::Base.send :helper, HasFilter::Helper

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

@@ -1,45 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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
-