adva_cms 0.0.1

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

@@ -0,0 +1,23 @@
+class HasFilterArticle < ActiveRecord::Base
+  self.table_name = 'has_filter_articles'
+  acts_as_taggable
+
+  has_filter :tagged, :categorized,
+             :text  => { :attributes => [:title, :body, :excerpt] },
+             :state => { :states => [:published, :unpublished] }
+
+  has_many :categories, :through => :categorizations, :class_name => 'HasFilterCategory'
+  has_many :categorizations, :class_name => 'HasFilterCategorization', :dependent => :destroy
+
+  scope :published, -> { where(published: true) }
+  scope :approved, -> { where(approved: true) }
+end
+
+class HasFilterCategorization < ActiveRecord::Base
+  belongs_to :article, :class_name => 'HasFilterArticle'
+  belongs_to :category, :class_name => 'HasFilterCategory'
+end
+
+class HasFilterCategory < ActiveRecord::Base
+end
+

data/vendor/gems/has_filter/test/templates/has_filter/test/index.html.erb

@@ -0,0 +1,5 @@
+<form action="has_filter">
+	<%= filter_for(HasFilterArticle) %>
+	<%= filter_for(HasFilterArticle) %>
+	<input type="submit" value="submit">
+</form>

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

@@ -0,0 +1,66 @@
+# require File.expand_path(File.dirname(__FILE__) + '/../../../../test/test_helper')
+# Rails.backtrace_cleaner.remove_silencers!
+
+unless defined?(Rails)
+  $: << File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+  require 'rubygems'
+  require 'action_controller'
+  require 'active_record'
+  require 'active_support'
+  require 'active_support/test_case'
+  require 'action_view'
+  require 'mocha'
+
+  require 'has_filter'
+  require 'has_filter/active_record/act_macro'
+  ActiveRecord::Base.send :extend, HasFilter::ActiveRecord::ActMacro
+
+  $: << File.expand_path(File.dirname(__FILE__) + '/../../simple_taggable/lib')
+  require 'simple_taggable'
+end
+
+class Test::Unit::TestCase
+  include ActionController::Assertions::SelectorAssertions
+
+  def assert_html(html, *args, &block)
+    assert_select(HTML::Document.new(html).root, *args, &block)
+  end
+end
+
+require File.dirname(__FILE__) + '/db/setup'
+require File.dirname(__FILE__) + '/models'
+require File.dirname(__FILE__) + '/fixtures'
+
+module HasFilter
+  class TestController < ActionController::Base
+    include HasFilter
+    helper_method :filter_for
+    def index
+      prepend_view_path File.dirname(__FILE__) + '/templates'
+    end
+  end
+  
+  module TestHelper
+    def text_filter
+      Filter::Text.new(:attribute => :body)
+    end
+
+    def categorized_filter
+      Filter::Categorized.new
+    end
+
+    def tagged_filter
+      Filter::Tagged.new
+    end
+
+    def state_filter
+      Filter::State.new(:state, :states => [:published, :unpublished])
+    end
+  end
+end
+
+ActionController::Routing::Routes.draw do |map| 
+  map.connect 'has_filter', :controller => 'has_filter/test', :action => 'index'
+end
+

data/vendor/gems/simple_taggable/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/vendor/gems/simple_taggable/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in simple_taggable.gemspec
+gemspec

data/vendor/gems/simple_taggable/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Micah Geisel
+
+MIT License
+
+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/vendor/gems/simple_taggable/README

@@ -0,0 +1,24 @@
+Setup
+=====
+
+Add column "cached_tag_list" to your model. Example migration:
+
+  def self.up
+    add_column :tickets, :cached_tag_list, :string
+  end
+
+Create table "taggings" and "tags". Example migration:
+
+  create_table "taggings", :force => true do |t|
+    t.integer  "tag_id"
+    t.integer  "taggable_id"
+    t.string   "taggable_type"
+    t.datetime "created_at"
+  end
+
+  add_index "taggings", ["tag_id"], :name => "index_taggings_on_tag_id"
+  add_index "taggings", ["taggable_id", "taggable_type"], :name => "index_taggings_on_taggable_id_and_taggable_type"
+
+  create_table "tags", :force => true do |t|
+    t.string "name"
+  end

data/vendor/gems/simple_taggable/README.md

@@ -0,0 +1,29 @@
+# SimpleTaggable
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'simple_taggable'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install simple_taggable
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/vendor/gems/simple_taggable/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/vendor/gems/simple_taggable/lib/simple_taggable.rb

@@ -0,0 +1,153 @@
+require "simple_taggable/version"
+
+require 'tag_list'
+require 'tag'
+require 'tagging'
+
+module SimpleTaggable
+end
+
+module ActiveRecord
+  module Acts
+    module Taggable
+      module ActMacro
+        def acts_as_taggable(options = {})
+          return if acts_as_taggable?
+
+          include ActiveRecord::Acts::Taggable::InstanceMethods
+          extend ActiveRecord::Acts::Taggable::ClassMethods
+
+          has_many :taggings, -> { includes(:tag) }, as: :taggable, dependent: :destroy
+          has_many :tags, :through => :taggings
+
+          before_save :cache_tag_list
+          after_save :save_tags
+
+          alias_method_chain :reload, :tag_list
+        end
+
+        def acts_as_taggable?
+          included_modules.include?(ActiveRecord::Acts::Taggable::InstanceMethods)
+        end
+      end
+
+      module ClassMethods
+        def tag_counts(*args)
+          options = args.extract_options!
+          options.assert_valid_keys :conditions, :at_least, :at_most, :order, :limit
+
+          conditions = ["taggings.taggable_type = '#{base_class.name}'"]
+          conditions << options.delete(:conditions) if options[:conditions]
+          conditions << type_condition unless descends_from_active_record?
+
+          joins = []
+          joins << "INNER JOIN taggings ON tags.id = taggings.tag_id"
+          joins << "INNER JOIN #{table_name} ON #{table_name}.id = taggings.taggable_id"
+
+          at_least  = sanitize_sql(['COUNT(*) >= ?', options.delete(:at_least)]) if options.key?(:at_least)
+          at_most   = sanitize_sql(['COUNT(*) <= ?', options.delete(:at_most)]) if options.key?(:at_most)
+          having    = [at_least, at_most].compact.join(' AND ')
+
+          group_by  = "tags.id, tags.name HAVING count(*) > 0"
+          group_by << " AND #{having}" unless having.blank?
+
+          options.merge! :select     => "tags.*, COUNT(*) AS count",
+                         :conditions => conditions.compact.join(' AND '),
+                         :joins      => joins.compact.join(' '),
+                         :group      => group_by
+
+          Tag.select(options[:select])
+            .where(options[:conditions])
+            .joins(options[:joins])
+            .group(options[:group])
+            .order(options[:order])
+            .limit(options[:limit])
+        end
+
+        def tagged *tags
+          options = tags.extract_options!
+          tags = TagList.from(tags)
+          except = TagList.from(options[:except]) if options[:except]
+
+          conditions = Array(options[:conditions])
+          conditions << tags_condition(tags)
+          conditions << except_condition(except)  if options[:except]
+          conditions << match_all_condition(tags) if options.delete(:match_all)
+
+          select("DISTINCT #{table_name}.*")
+            .joins("INNER JOIN taggings
+                     ON taggings.taggable_id = #{table_name}.id AND
+                        taggings.taggable_type = '#{base_class.name}' " +
+                   "INNER JOIN tags ON tags.id = taggings.tag_id")
+            .where(conditions.join(" AND "))
+        end
+
+        def tags_condition(tags)
+          # FIXME how to directly return an empty array from a named scope?
+          tags.empty? ? '0 = 1' : '(' + tags.map { |t| sanitize_sql(['tags.name LIKE ?', t]) } * ' OR ' + ')'
+        end
+
+        def match_all_condition(tags)
+          %((SELECT COUNT(*) FROM taggings INNER JOIN tags ON taggings.tag_id = tags.id
+             WHERE taggings.taggable_type = '#{base_class.name}' AND
+                   taggable_id = #{table_name}.id AND #{tags_condition(tags)}) = #{tags.size})
+        end
+
+        def except_condition(tags)
+          %(#{table_name}.id NOT IN
+             (SELECT taggings.taggable_id FROM taggings
+              INNER JOIN tags ON taggings.tag_id = tags.id
+              WHERE #{tags_condition(tags)} AND taggings.taggable_type = '#{base_class.name}') )
+        end
+      end
+
+      module InstanceMethods
+        def tag_list_add *args
+          tag_list
+          @tag_list.add *args
+        end
+
+        def tag_list
+          @tag_list ||= cached_tag_list.nil? ? TagList.new(*tags.map(&:name)) : TagList.from(cached_tag_list)
+          @tag_list.to_s
+        end
+
+        def tag_list=(value)
+          @tag_list = TagList.from(value)
+        end
+
+        def tag_counts(options = {})
+          self.class.tag_counts(options).where(self.class.send(:tags_condition, tag_list))
+        end
+
+        protected
+
+        def cache_tag_list
+          self.cached_tag_list = tag_list.to_s
+        end
+
+        def reload_with_tag_list(*args)
+          @tag_list = nil
+          reload_without_tag_list(*args)
+        end
+
+        def save_tags
+          return unless @tag_list
+
+          new_tag_names = @tag_list - tags.map(&:name)
+          old_tags = tags.reject { |tag| @tag_list.include?(tag.name) }
+
+          self.class.transaction do
+            unless old_tags.empty?
+              taggings.where(tag_id: old_tags).each(&:destroy)
+              taggings.reset
+            end
+            new_tag_names.each { |name| tags << Tag.find_or_create_by_name(name) }
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send :extend, ActiveRecord::Acts::Taggable::ActMacro

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

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

data/vendor/gems/simple_taggable/lib/tag.rb

@@ -0,0 +1,31 @@
+class Tag < ActiveRecord::Base
+  has_many :taggings
+  has_many :taggables, :through => :taggings, :source_type => "Content"
+
+  validates_presence_of :name
+  validates_uniqueness_of :name
+
+  cattr_accessor :destroy_unused
+  self.destroy_unused = true
+  
+  class << self
+    def find_or_create_by_name(name)
+      where(["name LIKE ?", name]).first || create(name: name)
+    end
+  end
+
+  def count
+    read_attribute(:count).to_i
+  end
+
+  def ==(object)
+    super || (object.is_a?(Tag) && name == object.name)
+  end
+
+  def to_s
+    name
+  end
+  alias :to_param :to_s
+end
+
+

data/vendor/gems/simple_taggable/lib/tag_list.rb

@@ -0,0 +1,90 @@
+class TagList < Array
+  cattr_accessor :delimiter
+  self.delimiter = ' '
+  
+  attr_reader :owner
+  
+  def initialize(*names)
+    add(*names)
+  end
+  
+  # Add tags to the tag_list. Duplicate or blank tags will be ignored.
+  #
+  #   tag_list.add("Fun", "Happy")
+  # 
+  # Use the <tt>:parse</tt> option to add an unparsed tag string.
+  #
+  #   tag_list.add("Fun, Happy", :parse => true)
+  def add(*names)
+    extract_and_apply_options!(names)
+    concat(names)
+    clean!
+    self
+  end
+  
+  # Remove specific tags from the tag_list.
+  # 
+  #   tag_list.remove("Sad", "Lonely")
+  #
+  # Like #add, the <tt>:parse</tt> option can be used to remove multiple tags in a string.
+  # 
+  #   tag_list.remove("Sad, Lonely", :parse => true)
+  def remove(*names)
+    extract_and_apply_options!(names)
+    delete_if { |name| names.include?(name) }
+    self
+  end
+  
+  # Transform the tag_list into a tag string suitable for edting in a form.
+  # The tags are joined with <tt>TagList.delimiter</tt> and quoted if necessary.
+  #
+  #   tag_list = TagList.new("Round", "Square,Cube")
+  #   tag_list.to_s # 'Round, "Square,Cube"'
+  def to_s
+    clean!
+    
+    map do |name|
+      name.include?(delimiter) ? "\"#{name}\"" : name
+    end.join(delimiter.ends_with?(" ") ? delimiter : "#{delimiter} ")
+  end
+  
+ private
+  # Remove whitespace, duplicates, and blanks.
+  def clean!
+    reject!(&:blank?)
+    map!(&:strip)
+    uniq!
+  end
+  
+  def extract_and_apply_options!(args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+    options.assert_valid_keys :parse
+    
+    if options[:parse]
+      args.map! { |a| self.class.from(a) }
+    end
+    
+    args.flatten!
+  end
+  
+  class << self
+    # Returns a new TagList using the given tag string.
+    # 
+    #   tag_list = TagList.from("One , Two,  Three")
+    #   tag_list # ["One", "Two", "Three"]
+    def from(*strings)
+      strings = strings.flatten
+      new.tap do |tag_list|
+        strings.each do |string|
+          string = string.to_s.dup
+      
+          # Parse the quoted tags
+          string.gsub!(/"(.*?)"\s*#{delimiter}?\s*/) { tag_list << $1; "" }
+          string.gsub!(/'(.*?)'\s*#{delimiter}?\s*/) { tag_list << $1; "" }
+      
+          tag_list.add(string.split(delimiter))
+        end
+      end
+    end
+  end
+end