adva 0.0.1 → 0.1.0

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

@@ -0,0 +1,104 @@
+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
+
+  # Add additional tags to effectively make the tag list plurality-insensitive.
+  #
+  #   tag_list = TagList.new("One", "Twos")
+  #   tag_list.cover_pluralities!
+  #   tag_list.to_s # "One, Ones, Two, Twos"
+  def cover_pluralities!
+    clean!
+    new_tag_list = inject([]) do |tag_list, name|
+      tag_list << name.singularize
+      tag_list << name.pluralize
+      tag_list
+    end
+    replace new_tag_list
+  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!(&:downcase)
+  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; "" }
+      
+          tag_list.add(string.split(delimiter))
+        end
+      end
+    end
+  end
+end

data/vendor/gems/simple_taggable/simple_taggable.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/simple_taggable/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Micah Geisel"]
+  gem.email         = ["micah@botandrose.com"]
+  gem.description   = %q{simple implementation of acts_as_taggable}
+  gem.summary       = %q{simple implementation of acts_as_taggable}
+  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          = "simple_taggable"
+  gem.require_paths = ["lib"]
+  gem.version       = SimpleTaggable::VERSION
+
+  gem.add_dependency "activerecord"
+end

data/vendor/gems/simple_taggable/test/simple_taggable_test.rb

@@ -0,0 +1,253 @@
+require_relative './test_helper'
+require 'simple_taggable'
+
+require "magazine"
+require "photo"
+require "post"
+require "subscription"
+require "magazine"
+require "user"
+
+require "byebug"
+
+class SimpleTaggableTest < ActiveSupport::TestCase
+  fixtures :tags, :taggings, :photos, :posts, :subscriptions, :magazines, :users
+  
+  test 'tag_counts on class' do
+    assert_tag_counts Photo.tag_counts, :great => 2, :sucks => 1, :crazy_animal => 1, :animal => 3, :nature => 3
+    assert_tag_counts Post.tag_counts, :great => 2, :sucks => 2, :nature => 7
+  end
+
+  test 'tag_counts on instance' do
+    assert_tag_counts @small_dog.tag_counts, :great => 2, :nature => 3, :animal => 3
+  end
+
+  test 'tag_counts with frequency' do
+    assert_tag_counts Photo.tag_counts(:at_least => 2), :great => 2, :animal => 3, :nature => 3
+    assert_tag_counts Photo.tag_counts(:at_most => 1), :sucks => 1, :crazy_animal => 1
+  end
+  
+  test 'tag_counts with frequency and condition' do
+    counts = Photo.tag_counts(:at_least => 2, :conditions => "tags.name LIKE '%n%'")
+    assert_tag_counts counts, :animal => 3, :nature => 3
+  end
+  
+  test 'tag_counts with order and limit' do
+    assert_equal [@nature, @great], Post.tag_counts(:order => 'count DESC, name', :limit => 2)
+  end
+  
+  # test 'tag_counts on association' do
+  #   assert_tag_counts @john.posts.tag_counts, :great => 1, :nature => 5, :sucks => 1
+  #   assert_tag_counts @jane.posts.tag_counts, :great => 1, :nature => 2, :sucks => 1
+  #     
+  #   assert_tag_counts @john.photos.tag_counts, :great => 1, :sucks => 1, :crazy_animal => 1, :animal => 3, :nature => 1
+  #   assert_tag_counts @jane.photos.tag_counts, :nature => 2, :great => 1
+  # end
+
+  # test 'tag_counts on association with options' do
+  #   assert_equal [], @john.posts.tag_counts(:conditions => '1 = 0')
+  #   assert_tag_counts @john.posts.tag_counts(:at_most => 2), :great => 1, :sucks => 1
+  # end
+
+  test 'tag_counts on has_many :through' do
+    assert_tag_counts @john.magazines.tag_counts, :great => 1
+  end
+
+  test 'has tags and taggings' do
+    assert @small_dog.respond_to? :tags
+    assert @small_dog.respond_to? :taggings
+  end
+  
+  test '#tag_list' do
+    assert_equal %w(Animal Nature Great), TagList.from(@small_dog.tag_list)
+  end
+  
+  test '#tagged finds records tagged with the given tags' do
+    assert_equal [@big_dog, @small_dog, @bad_cat], Photo.tagged('Animal')
+    assert_equal [@bad_cat], Photo.tagged('"Crazy animal"')
+    assert_equal [@ground, @rain], Post.tagged('sucks')
+  end
+  
+  test '#tagged does not find records tagged with nothing or blank tags' do
+    assert_equal [], Photo.tagged("")
+    assert_equal [], Photo.tagged([])
+  end
+  
+  test '#tagged does not find records tagged with non existant tags' do
+    assert_equal [], Post.tagged('doesnotexist')
+    assert_equal [], Photo.tagged(['doesnotexist'])
+    assert_equal [], Photo.tagged([Tag.new(:name => 'unsaved tag')])
+  end
+  
+  test '#tagged finds records tagged with at least one of the given tags' do
+    assert_equal [@big_dog, @small_dog, @bad_cat, @flower], Photo.tagged('Animal', 'Great')
+  end
+  
+  test '#tagged finds records tagged with all of the given tags when :match_all option was set' do
+    assert_equal [@small_dog], Photo.tagged('Animal', 'Great', :match_all => true)
+  end
+  
+  test '#tagged using match_all and include' do
+    assert_nothing_raised do
+      Photo.tagged('Great', :include => :tags)
+      Photo.tagged("Great", :include => { :taggings => :tag })
+    end
+  
+    assert_equal [@small_dog], Photo.tagged(['Great', 'Animal'], :match_all => true, :include => :tags)
+    assert_no_queries { @small_dog.tags }
+  end
+  
+  test '#tagged using conditions' do
+    assert_equal [], Photo.tagged('Great Nature', :conditions => '1 = 0')
+  end
+  
+  test '#tagged using :except option' do
+    assert_equal [@sky, @flower], Photo.tagged('Nature', :except => 'Animal')
+  end
+
+  test '#tagged is plurality-insensitive' do
+    assert_equal [@bad_cat], Photo.tagged('suck')
+    assert_equal [@big_dog, @small_dog, @bad_cat], Photo.tagged('animals')
+  end
+  
+  test '#tagged with association scope' do
+    assert_equal [@sky, @flower], @jane.photos.tagged('Nature')
+    assert_equal [@small_dog], @john.photos.tagged('Nature')
+    assert_equal [], @john.photos.tagged('Nature', :except => 'Animal')
+    assert_equal [], @john.photos.tagged('Nature Bad', :match_all => true)
+  end
+  
+  test '#save_tags saves new tags' do
+    @small_dog.tag_list_add('New')
+    @small_dog.save
+    assert Tag.find_by_name('New')
+    assert_equal %w(Animal Nature Great New), TagList.from(@small_dog.reload.tag_list)
+  end
+  
+  test '#save_tags removes old tags' do
+    @small_dog.tag_list_remove('Great')
+    @small_dog.save
+    assert_equal %w(Animal Nature), TagList.from(@small_dog.reload.tag_list)
+  end
+
+  test '#save_tags deduplicates tags' do
+    tag = Tag.create!(name: "OMG")
+    assert_difference "Tagging.count", 1 do
+      Photo.create! tags: [tag, tag]
+    end
+  end
+  
+  test 'unused tags are deleted by default' do
+    skip
+    assert_difference('Tag.count', -1) do 
+      @bad_cat.tag_list_remove('Crazy Animal')
+      @bad_cat.save!
+    end
+  end
+  
+  test 'unused tags are not deleted when Tag.destroy_unused is set to false' do
+    Tag.destroy_unused = false
+    assert_difference('Tag.count', 0) do 
+      @big_dog.tag_list_remove('Animal')
+      @big_dog.save!
+    end
+  end
+  
+  test '#tag_list reader returns a tag list' do
+    assert_equivalent ['Sucks', 'Crazy Animal', 'Animal'], TagList.from(@bad_cat.tag_list)
+  end
+  
+  test 'adding new tags via #tag_list writer' do
+    assert_equivalent %w(Nature), TagList.from(@sky.tag_list)
+    @sky.update_attributes!(:tag_list => "#{@sky.tag_list} One Two")
+    assert_equivalent %w(Nature One Two), TagList.from(@sky.tag_list)
+  end
+  
+  test 'removing tags via #tag_list writer' do
+    assert_equivalent %w(Nature), TagList.from(@sky.tag_list)
+    @sky.update_attributes!(:tag_list => "")
+    assert_equivalent [], TagList.from(@sky.tag_list)
+  end
+  
+  test 'tag_list reader on a new record' do
+    photo = Post.new(:text => 'Test')
+    assert photo.tag_list.blank?
+    photo.tag_list = "One, Two"
+    assert_equal "One, Two", photo.tag_list.to_s
+  end
+  
+  test 'tag_list writer clears tag_list with nil' do
+    photo = @small_dog
+    assert !photo.tag_list.blank?
+    assert photo.update_attributes(:tag_list => nil)
+    assert photo.tag_list.blank?
+    assert photo.reload.tag_list.blank?
+  end
+  
+  test 'tag_list writer clears tag_list with a string containing only spaces' do
+    photo = @small_dog
+    assert !photo.tag_list.blank?
+    assert photo.update_attributes(:tag_list => '  ')
+    assert photo.tag_list.blank?
+    assert photo.reload.tag_list.blank?
+  end
+  
+  test 'tag_list is reset on reload' do
+    photo = @small_dog
+    assert !photo.tag_list.blank?
+    photo.tag_list = nil
+    assert photo.tag_list.blank?
+    assert !photo.reload.tag_list.blank?
+  end
+  
+  test 'changing the case of tags via #tag_list writer' do
+    @small_dog.update_attributes!(:tag_list => @small_dog.tag_list.to_s.upcase)
+    assert_equal 'ANIMAL NATURE GREAT', @small_dog.reload.tag_list.to_s
+  end
+  
+  test 'case insensivity' do
+    assert_difference "Tag.count", 1 do
+      Photo.create!(:title => "Foo", :tag_list => "baz")
+      Photo.create!(:title => "Bar", :tag_list => "Baz")
+      Photo.create!(:title => "Bar", :tag_list => "BAZ")
+    end
+  
+    assert_equal Photo.tagged("baz").to_a, Photo.tagged("BAZ").to_a
+  end
+
+  test 'more case insensitivity' do
+    photo = Photo.create!(tag_list: 'foo Foo')
+    assert_equal 1, photo.tags.count
+  end
+
+  test 'even more case insensitivity' do
+    photo = Photo.create!(tag_list: 'foo Foo')
+    assert_difference "photo.tags.count", 0 do
+      photo.save
+    end
+  end
+  
+  test "tagged scope works with sti" do
+    photo = SpecialPhoto.create!(:title => "Foo", :tag_list => "STI")
+    assert_equal [photo], SpecialPhoto.tagged("STI")
+    assert Photo.tagged("STI").map(&:id).include?(photo.id)
+  end
+  
+  test 'caches the tag_list before save' do
+    assert @small_dog.cached_tag_list.nil?
+    @small_dog.save!
+    assert_equal 'Animal Nature Great', @small_dog.cached_tag_list
+  
+    @small_dog.update_attributes(:tag_list => 'Foo')
+    assert_equal 'Foo', @small_dog.cached_tag_list
+    assert_equal 'Foo', @small_dog.reload.cached_tag_list
+  end
+  
+  test 'cached_tag_list used' do
+    @small_dog.save!
+    @small_dog.reload
+    assert_no_queries do
+      assert_equal %w(Animal Nature Great), TagList.from(@small_dog.tag_list)
+    end
+  end
+end

data/vendor/gems/simple_taggable/test/tag_list_test.rb

@@ -0,0 +1,123 @@
+require_relative './test_helper'
+require 'tag_list'
+
+class TagListTest < ActiveSupport::TestCase
+  teardown do
+    TagList.delimiter = ' '
+  end
+
+  test "#from leaves arguments unchanged" do
+    tags = '"One  ", Two'
+    original = tags.dup
+    TagList.from(tags)
+    assert_equal tags, original
+  end
+
+  test "#from with a single tag name" do
+    assert_equal %w(Fun), TagList.from("Fun")
+  end
+
+  test "#from with a single quoted tag name" do
+    assert_equal %w('Fun'), TagList.from("'Fun'")
+  end
+
+  test "#from with a double quoted tag name" do
+    assert_equal %w(Fun), TagList.from('"Fun"')
+  end
+
+  test "#from with a single blank tag name" do
+    assert_equal [], TagList.from(nil)
+    assert_equal [], TagList.from("")
+  end
+
+  test "#from with tags contained in quoted tags" do
+    assert_equal ['foo bar', 'bar'], TagList.from('"foo bar" bar')
+  end
+
+  test "#from with a single quoted tag name that includes a comma (with comma delimiter)" do
+    TagList.delimiter = ','
+    assert_equal ["'with," "comma'"], TagList.from("'with, comma'")
+  end
+
+  test "#from with a double quoted tag name that includes a comma (with comma delimiter)" do
+    TagList.delimiter = ','
+    assert_equal ["'with", "comma'"], TagList.from("'with, comma'").to_a
+  end
+
+  test "#from does not delineate spaces (with comma delimiter)" do
+    TagList.delimiter = ','
+    assert_equivalent ['A B', 'C'], TagList.from('A B, C')
+  end
+
+  test "#from with multiple tags" do
+    assert_equivalent %w(Alpha Beta Delta Gamma), TagList.from("Alpha Beta Delta Gamma")
+  end
+
+  test "#from with multiple tags with quotes and multiple spaces" do
+    assert_equivalent %w(Alpha Beta Delta Gamma), TagList.from('Alpha  "Beta"  Gamma   "Delta"')
+  end
+
+  test "#from with multiple tags with single quotes" do
+    assert_equivalent ["'A", "B'", "C"], TagList.from("'A B' C")
+  end
+
+  test "#from with multiple tags with double quotes" do
+    assert_equivalent ['A B', 'C'], TagList.from('"A B" C')
+  end
+
+  test "#from with multiple tags with quotes and commas (with comma delimiter)" do
+    TagList.delimiter = ','
+    assert_equivalent ['Alpha, Beta', 'Delta', 'Gamma, something'], TagList.from('"Alpha, Beta", Delta, "Gamma, something"')
+  end
+
+  test "#from removes leading/trailing whitespace from tag names" do
+    assert_equivalent %w(Alpha Beta), TagList.from('" Alpha   " "Beta  "')
+    assert_equivalent %w(Alpha Beta), TagList.from('  Alpha  Beta ')
+  end
+
+  test "#from removes duplicate tags" do
+    assert_equal %w(One), TagList.from("One One")
+  end
+
+  test "#to_s (with comma delimiter)" do
+    TagList.delimiter = ','
+    assert_equal "Question, Crazy Animal", TagList.new("Question", "Crazy Animal").to_s
+  end
+
+  test "#to_s (with space delimiter)" do
+    assert_equal '"Crazy Animal" Question', TagList.new("Crazy Animal", "Question").to_s
+  end
+
+  test "#add" do
+    tag_list = TagList.new("One")
+    assert_equal %w(One), tag_list
+
+    assert_equal %w(One Two), tag_list.add("Two")
+    assert_equal %w(One Two Three), tag_list.add(["Three"])
+  end
+
+  test "#remove" do
+    tag_list = TagList.new("One", "Two")
+    assert_equal %w(Two), tag_list.remove("One")
+    assert_equal %w(), tag_list.remove(["Two"])
+  end
+
+  test "#new with parsing" do
+    assert_equal %w(One Two), TagList.new("One Two", :parse => true)
+  end
+
+  test "#add with parsing" do
+    assert_equal %w(One Two), TagList.new.add("One Two", :parse => true)
+  end
+
+  test "#remove with parsing" do
+    tag_list = TagList.from("Three Four Five")
+    assert_equal %w(Four), tag_list.remove("Three Five", :parse => true)
+  end
+
+  test "#cover_pluralities!" do
+    tag_list = TagList.from("Ones Two")
+    assert_equal %w(One Ones Two Twos), tag_list.cover_pluralities!
+  end
+end
+

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

@@ -0,0 +1,59 @@
+module TableBuilder
+  class Tag
+    class << self
+      attr_accessor :level, :tag_name
+    end
+
+    def level
+      self.class.level
+    end
+
+    def tag_name
+      self.class.tag_name
+    end
+
+    include ActionView::Helpers::TagHelper
+
+    attr_reader :options, :parent
+
+    def initialize(parent = nil, options = {})
+      @parent = parent
+      @options = options
+    end
+    
+    def collection_class
+      table.collection_class
+    end
+    
+    def collection_name
+      table.collection_name
+    end
+    
+    def table
+      is_a?(Table) ? self : parent.try(:table)
+    end
+    
+    def head?
+      is_a?(Head) || !!parent.try(:head?)
+    end
+
+    def render(content = nil)
+      content = '' if content.nil?
+      yield(content) if content.empty? && block_given?
+      content = content.html_safe
+      content_tag(tag_name, content, options)
+    end
+    
+    def add_class(klass)
+      add_class!(options, klass)
+    end
+    
+    protected
+      def add_class!(options, klass)
+        unless klass.blank?
+          options[:class] ||= ''
+          options[:class] = options[:class].split(' ').push(klass).join(' ')
+        end
+      end
+  end
+end