e9_tags 0.0.8

data/.gitignore

@@ -0,0 +1,4 @@
+pkg/*
+*.gem
+.bundle
+*.swp

data/Gemfile

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

data/README.rdoc

@@ -0,0 +1,61 @@
+== E9Tags
+
+An extension to ActsAsTaggableOn[http://github.com/mbleigh/acts-as-taggable-on] which "improves" on custom tagging, or at least makes it more dynamic. Additionally it 
+provides some autocomplete rack apps and the corresponding javascript.
+
+== Installation
+
+1.  E9Tags requires jquery and jquery-ui for the autocompletion and tag-adding form, be sure they're loaded in your 
+    pages where the tags form will be rendered.
+
+2.  E9Tags extends ActsAsTaggableOn and requires it.  Run it's generator if you have not.
+
+3.  Run the E9Tags install script to copy over the required JS
+
+        rails g e9_tags:install
+
+4.  Then make sure it is loaded, how you do that doesn't matter, e.g.
+
+        <%= javascript_include_tag 'e9_tags' %>
+
+5.  Create an initializer for that sets up the taggable models and their controllers.  This gives the models the tag
+    associations and methods and prepares their controller to handle the otherwise unexpected tag params.
+
+        require 'e9_tags'
+        require 'contacts_controller'
+        require 'contact'
+
+        E9Tags.controllers << ContactsController
+        E9Tags.models << Contact
+
+    OR
+
+    You can just include the modules in your classes yourself.  The first way really exists for the case where the
+    classes you wish to extend are part of another plugin/gem.
+
+        # in contact.rb
+        include E9Tags:Model
+
+        # in contacts_controller.rb
+        include E9Tags::Controller
+
+6.  Render the tags form partial in whatever model forms require it.  
+
+        = render 'e9_tags/form', :f => f
+
+    If you pass a context, it will be locked and no longer possible to change/add the contexts on the form (and as 
+    a side effect, the tags autocompletion will be restricted to that context).
+
+        = render 'e9_tags/form', :f => f, :context => :users
+
+    Finally if you pass a 2nd arg to :context you can set a tag context to be "private" (default is false).  In this
+    case the tag context will be locked as private (typically suffixed with *), meaning that the tags will not be
+    publicly searchable/visible.  This is useful for organizational tags tags, say if you wanted to arbitrarily
+    group records, or create a custom search based on a tag context.
+
+        = render 'e9_tags/form', :f => f, :context => [:users, true]
+
+    NOTE: The form and javascript are intended to work out of the box, but the certainly aren't going to look pretty.
+    If you do intend to use the forms, you'll no doubt need to style them.
+    
+    

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/app/views/e9_tags/_form.html.haml

@@ -0,0 +1,31 @@
+<!--BEGIN e9_tags_js-->
+:javascript
+  var tag_template = "#{escape_javascript(tag_template(f.object).html_safe)}";
+<!--END e9_tags_js-->
+
+%fieldset.tags
+  %legend= label_tag 'add-tag-fld', t(:tags_name, :scope => :e9_tags)
+  #tag-fields
+    - if local_assigns[:context]
+      = hidden_field_tag 'tag-context', humanize_context(*local_assigns[:context])
+    - else
+      .field
+        = label_tag 'tag-context', t(:tag_context_name, :scope => :e9_tags).singularize
+        = text_field_tag 'tag-context', nil
+    .field
+      = label_tag 'add-tag-fld', t(:tags_name, :scope => :e9_tags).singularize
+      = text_field_tag 'add-tag-fld', nil
+    .actions
+      %button#add-tag-btn= t(:add_tag_link, :scope => :e9_tags)
+      -# NOTE this escaping bit doesn't work without a tooltips plugin (browser does not render HTML in default title tooltips)
+      - t = raw t(:tag_instructions, :scope => :e9_tags).gsub('"', '&quot;')
+      <button title="#{t}" rel="tooltip">?</button>
+
+  #tag-contexts{:class => local_assigns[:context] ? 'locked-context' : nil }
+    - f.object.tagging_contexts(:show_all => true).each do |context|
+      - h_context = humanize_context(context)
+      %div{:id => "#{context}-context-list", :class => 'context-list'}
+        %span.context-header= h_context unless local_assigns[:context]
+        %ul
+          - f.object.tag_list_on(context).each do |tag_word|
+            = tag_template(f.object, tag_word, h_context, context)

data/app/views/e9_tags/_tag_list.html.haml

@@ -0,0 +1,3 @@
+.tag-list
+  %span.heading #{ e9_t(:tags_name) }:
+  = tag_list(taggable)

data/app/views/e9_tags/_tag_list_with_context.html.haml

@@ -0,0 +1,2 @@
+.tag-list-with-context
+  = tag_list_with_context(taggable, local_assigns[:highlight])

data/app/views/e9_tags/_template.html.haml

@@ -0,0 +1,5 @@
+%li
+  %span.admin-tag
+    %span= tag
+    = link_to t(:remove_tag), 'javascript:;', :class => 'delete-tag', :title => t(:delete_tag_link_instructions, :scope => :e9_tags)
+  = hidden_field_tag "#{class_name}[#{u_context}_tag_list][]", tag, :id => "#{class_name}_#{u_context}_tag_list"

data/config/locales/en.yml

@@ -0,0 +1,10 @@
+en:
+  e9_tags:
+    tags_name: Tags
+    add_tag_link: Add
+    delete_tag: Delete
+    tag_context_name: Context
+    tag_context_visible: "Tags created with this context will be searchable and visible on their tagged content."
+    tag_context_hidden: "Tags created with this context will be unsearchable and will not be visible on their tagged content."
+    tag_instructions: "<p>Tags are words or phrases that describe or classify the content on this page.</p><p>Context allows you to contextualize each tag you enter. For a tag of \"coca cola\" you might give it a context of \"brand\", or you could give it a context of \"soda\".</p><p>Enter a tag, click Add. Repeat to add more.</p><p>Tags suffixed with a * are not publically visible or searchable, making them suitable for organizational purposes.</p>"
+    delete_tag_link_instructions: Click to remove this tag

data/config/routes.rb

@@ -0,0 +1,6 @@
+Rails.application.routes.draw do
+  # TODO fix the fact that we route to apps, then the apps themselves check those paths
+  get '/js/tags' => E9Tags::Rack::TagsJs
+  get '/autocomplete/tags' => E9Tags::Rack::TagAutoCompleter
+  get '/autocomplete/tag-contexts' => E9Tags::Rack::TagContextAutoCompleter
+end

data/e9_tags.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "e9_tags/version"
+
+Gem::Specification.new do |s|
+  s.name        = "e9_tags"
+  s.version     = E9Tags::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Travis Cox"]
+  s.email       = ["travis@e9digital.com"]
+  s.homepage    = "http://github.com/e9digital/e9_tags"
+  s.summary     = %q{Extension to ActsAsTaggableOn used in e9 Rails 3 projects}
+  s.description = File.open('README.rdoc').read rescue nil
+
+  s.rubyforge_project = "e9_tags"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency("rails", "~> 3.0.0")
+  s.add_dependency("acts-as-taggable-on", "~> 2.0.6")
+end

data/lib/e9_tags/controller.rb

@@ -0,0 +1,21 @@
+module E9Tags
+  module Controller
+    extend ActiveSupport::Concern
+
+    included do
+      prepend_before_filter :extract_tag_lists_from_params, :only => [:create, :update]
+    end
+    
+    def extract_tag_lists_from_params 
+      params[resource_instance_name] ||= {}
+
+      list_keys = params[resource_instance_name].keys.select {|k| k.to_s =~ /_tag_list$/ }
+      tags = params[resource_instance_name].slice(*list_keys)
+
+      params[resource_instance_name].except!(*list_keys)
+      params[resource_instance_name][:tag_lists] = tags
+    end
+
+    protected :extract_tag_lists_from_params
+  end
+end

data/lib/e9_tags/helper.rb

@@ -0,0 +1,63 @@
+module E9Tags
+  module Helper
+    def tag_template(object, tag = "__TAG__", context = "__CONTEXT__", u_context = "__UCONTEXT__")
+      render('e9_tags/template', {
+        :tag        => tag,
+        :context    => context,
+        :u_context  => u_context,
+        :class_name => object.class.name.underscore
+      })
+    end
+
+    def humanize_context(*context_and_is_private)
+      context, is_private = context_and_is_private
+
+      context = E9Tags.unescape_context(context)
+
+      if is_private && context !~ /#{E9Tags::PRIVATE_TAG_SUFFIX_REGEX}$/
+        context << E9Tags::PRIVATE_TAG_SUFFIX 
+      end
+
+      context
+    end
+
+    def tag_list(resource, highlighted_tag = nil, options = {})
+      _tag_list(resource.tags(options), highlighted_tag) if resource.respond_to?(:tags)
+    end
+
+    def tag_list_with_context(resource, highlighted_tag = nil, options = {})
+      if resource.respond_to?(:tagging_contexts)
+
+        # by default, we don't want to show all tags
+        options[:show_all] = false if options.blank?
+
+        content_tag(:div, :class => 'tag-lists') do
+          ''.html_safe.tap do |html|
+            resource.tagging_contexts(options).each do |context|
+              str = ''.html_safe
+              str.safe_concat content_tag(:div, "#{humanize_context(E9Tags.unescape_context(context))}:", :class => 'heading')
+              str.safe_concat _tag_list(resource.tag_list_on(context), highlighted_tag)
+
+              html.safe_concat content_tag(:div, str.html_safe, :class => 'tag-context-list')
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+    # NOTE this subroutine is kinda useless, should be rewritten to handle both tag list types
+    def _tag_list(tags, highlighted_tag = nil)
+      content_tag(:div, :class => 'tag-list') do
+        tags.each_with_index.map do |tag, index|
+          css_class = index == tags.length - 1 ? 'last' : nil
+          link_class = 'tag'
+          link_class << ' highlight' if highlighted_tag && highlighted_tag == tag
+          link_class << ' last' if index == tags.length - 1
+          link_to(tag, searches_path(:query => tag), :class => link_class)
+        end.join(', ').html_safe
+      end
+    end
+  end
+end

data/lib/e9_tags/model.rb

@@ -0,0 +1,151 @@
+module E9Tags
+  module Model
+    extend ActiveSupport::Concern
+
+    #
+    # It should be noted that our usage of tag contexts is apparently 
+    # incongruent with acts_as_taggable_on's intentions.  It goes to lengths 
+    # to write class methods for each context with the apparent intention that 
+    # these be used separately, whereas we needed contexts to be more dynamic 
+    # (all contexts but "tags" are user defined).
+    #
+    # The gem provides custom contexts but they're not very well supported
+    # and somewhat broken (see #tagging_contexts below).
+    #
+    # Because of the way AATO expects contexts to be used, it makes some
+    # assumptions, and writes a bunch of helper methods to the class for each.
+    # These are useless to us really and only serve to add some confusion to
+    # the scope.  E.g. for acts_as_taggable_on :tags (the default), the 
+    # following methods are created:
+    #
+    # tag_taggings (has_many)
+    # tags (has_many)
+    # tags_list
+    # tags_list=
+    # all_tags_list
+    #
+    # It's important to note that these methods all only deal with the "tags"
+    # context and won't return any tag which does not have it.
+    #
+    # The actual associations on the taggable record are "taggings" and 
+    # "base_tags", which ignores context, returning all tags.
+    #
+
+    def has_tags?
+      !base_tags.empty?
+    end
+
+    # Override ActsAsTaggableOn's broken handling of tagging_contexts.
+    #
+    # This method by default reads:
+    #
+    # def tagging_contexts
+    #   custom_contexts + self.class.tag_types.map(&:to_s)
+    # end
+    #
+    # ...where custom_contexts is an non-persistent instance variable
+    # on the record and tag_types are the tagging contexts defined
+    # on the class itself, e.g. acts_as_taggable_on :some_context.
+    #
+    # This means that proper custom contexts aren't reflected in 
+    # tagging_contexts on retrieved records. 
+    #
+    # For this reason we override/monkeypatch a few methods
+    # after including acts_as_taggable, making them more useful.  The concept
+    # of "hidden" tags is also added, with the default "tagging_contexts" association
+    # overridden to return only "visible" tags.  "Hidden" tags are denoted
+    # by having a context ending in __H__, a contrivance created in the javascript
+    # that handles adding/reading tags.  
+    #
+    # Additionally contexts are further escaped by subsituting dashes and spaces with
+    # __D__ and __S__, respectively.  This allows for those character in custom contexts,
+    # which is otherwise impossible due to the way that AATO caches contexts on the
+    # taggable object by dynamically writing context-named instance variables.
+    #
+
+    #
+    # this won't take unless the record is saved successfully
+    #
+    def clear_all_tags
+      tagging_contexts.each {|context| set_tag_list_on(context, '') }
+    end
+
+    def tag_lists=(hash)
+      self.clear_all_tags
+      hash.each do |context, tags|
+        c = context.to_s.sub(/_tag_list$/, '')
+        c = E9Tags.escape_context(c)
+
+        self.set_tag_list_on(c, tags)
+      end
+    end
+
+    module DelayedClassMethods
+      def tagged_with(tags, options = {})
+        retv = super
+
+        # for whatever reason, tagged_with by default returns an empty Hash (??) if there are no results
+        return where("1=0") if retv.blank?
+
+        # if :show_all is true, just return super with no modification
+        #
+        if !options[:show_all] && retv.joins_values.present? && retv.to_sql =~ /JOIN taggings (\S+)/
+          #
+          # otherwise we'll show hidden OR visible tags based on whether :show_hidden was passed
+          #
+          retv = retv.where(
+            %Q[#{$1}.context #{options[:show_hidden] ? '' : ' NOT '} like '%__H__']
+          )
+        end
+
+        retv
+      end
+    end
+
+    included do
+      acts_as_taggable
+
+      extend DelayedClassMethods
+
+      # TODO Tagged_with unfortunately does not handle context-only searches.  Rewriting it to do so would save this unnecessary subquery
+      scope :tagged_with_context, lambda {|context|
+        where(:id => select(Arel::Distinct.new(arel_table[:id])).joins(:taggings).where(Tagging.arel_table[:context].eq(E9Tags.escape_context(context))).map(&:id))
+      }
+
+      def filtered_taggings(*args)
+        options = args.extract_options!
+
+        retv = taggings(*args << options.slice!(:show_all, :show_hidden))
+
+        if !options[:show_all]
+          retv = retv.where(
+            %Q[taggings.context #{options[:show_hidden] ? '' : ' NOT '} like '%__H__']
+          )
+        end
+
+        retv
+      end
+
+      def tags(options = {})
+        filtered_taggings(options).map {|tagging| tagging.tag.name if tagging }.compact.uniq
+      end
+
+      #
+      # rewrite tagging_contexts as mentioned above
+      #
+      # NOTE unlike tags & taggings, tagging_contexts returns all contexts
+      #      This is crucial because AATO uses tagging_contexts internally
+      #      and it needs to behave like the default method
+      #
+      def tagging_contexts(options = {})
+
+        # NOTE this takes options but it only affects taggings.
+        #      if there are custom_contexts that are hidden they will
+        #      be returned
+        options[:show_all] = true if options.blank?
+
+        (custom_contexts + filtered_taggings(options).map(&:context) + self.class.tag_types.map(&:to_s)).uniq
+      end
+    end
+  end
+end

data/lib/e9_tags/rack/tag_auto_completer.rb

@@ -0,0 +1,39 @@
+module E9Tags::Rack
+  class TagAutoCompleter
+    DEFAULT_LIMIT = 10
+
+    def self.call(env)
+      if env["PATH_INFO"] =~ /^\/autocomplete\/tags/
+        terms = []
+        @params = Rack::Request.new(env).params
+        
+        if @term = @params['term']
+          tags, taggings = ::Tag.arel_table, ::Tagging.arel_table
+
+          relation = tags.join(taggings).on(tags[:id].eq(taggings[:tag_id])).
+                     where(tags[:name].matches("#{@term}%")).
+                     group(tags[:id]).
+                     take(@params['limit'] ? @params['limit'].to_i : DEFAULT_LIMIT).
+                     project(tags[:name], tags[:name].count.as('count')).
+                     #having('count > 0'). # having count > 0 is unnecessary because of the join type
+                     order('name ASC')
+
+          if @context = @params['context']
+            relation = relation.where(taggings[:context].matches(E9Tags.escape_context(@context))) 
+          end
+
+          # NOTE this select is stolen from Arel::SelectManager's deprecated to_a method, but since Arel has been re-written
+          #      (and even before that) it'd probably be smarter here to avoid arel tables and just use AR and to_json
+          #   
+          terms = ::ActiveRecord::Base.connection.send(:select, relation.to_sql, 'Tag Autocomplete').map do |row| 
+            { :label => "#{row['name']} - #{row['count']}", :value => row['name'], :count => row['count'] }
+          end
+        end
+
+        [200, {"Content-Type" => "application/json", "Cache-Control" => "max-age=3600, must-revalidate"}, [terms.to_json]]
+      else
+        [404, {"Content-Type" => "text/html", "X-Cascade" => "pass"}, ["Not Found"]]
+      end
+    end
+  end
+end

data/lib/e9_tags/rack/tag_context_auto_completer.rb

@@ -0,0 +1,36 @@
+module E9Tags::Rack
+  class TagContextAutoCompleter
+    DEFAULT_LIMIT = 10
+
+    def self.call(env)
+      if env["PATH_INFO"] =~ /^\/autocomplete\/tag\-contexts/
+        terms = []
+
+        if @term = Rack::Request.new(env).params['term']
+
+          taggings = ::Tagging.arel_table
+
+          relation = taggings.
+                     group(taggings[:context]).
+                     where(taggings[:context].matches("#{@term}%")).
+                     project(taggings[:context], taggings[:context].count.as('count')).
+                     take(DEFAULT_LIMIT).
+                     order('context ASC')
+
+          # NOTE this select is stolen from Arel::SelectManager's deprecated to_a method, but since Arel has been re-written
+          #      (and even before that) it'd probably be smarter here to avoid arel tables and just use AR and to_json
+          #   
+          terms = ::ActiveRecord::Base.send(:select, relation.to_sql, 'Tag Context Autocomplete').map do |row| 
+            unescaped_context = E9Tags.unescape_context(row['context'])
+
+            { :label => "#{unescaped_context} - #{row['count']}", :value => unescaped_context, :count => row['count'] }
+          end
+        end
+
+        [200, {"Content-Type" => "application/json", "Cache-Control" => "max-age=3600, must-revalidate"}, [terms.to_json]]
+      else
+        [404, {"Content-Type" => "text/html", "X-Cascade" => "pass"}, ["Not Found"]]
+      end
+    end
+  end
+end

data/lib/e9_tags/rack/tags_js.rb

@@ -0,0 +1,14 @@
+module E9Tags::Rack
+  class TagsJs
+    def self.call(env)
+      if env["PATH_INFO"] =~ /^\/js\/tags/
+        tags = ::Tagging.joins(:tag).order('tags.name').group_by(&:context).to_json
+        js   = "window.e9=window.e9||{};window.e9.tags=#{tags};"
+
+        [200, {"Content-Type" => "text/javascript", "Cache-Control" => "max-age=3600, must-revalidate"}, [js]]
+      else
+        [404, {"Content-Type" => "text/html", "X-Cascade" => "pass"}, ["Not Found"]]
+      end
+    end
+  end
+end

data/lib/e9_tags/rails_extensions.rb

@@ -0,0 +1,7 @@
+require 'active_support/ordered_hash'
+
+module ActiveSupport
+  class OrderedHash
+    alias :zero? :blank?
+  end
+end

data/lib/e9_tags/tagging_extension.rb

@@ -0,0 +1,41 @@
+module E9Tags
+  module TaggingExtension
+    extend ActiveSupport::Concern
+  
+    included do
+      alias :content :taggable
+
+      delegate :name, :to => :tag
+
+      scope :hidden, lambda {
+        where(arel_table[:contexts].matches('%__H__').not)
+      }
+
+      scope :excluding_tags, lambda {|*tags|
+        joins(:tag).where(Tag.arel_table[:name].in(tags.flatten).not)
+      }
+       
+      scope :including_tags, lambda {|*tags|
+        joins(:tag).where(Tag.arel_table[:name].in(tags.flatten))
+      }
+
+      def as_json(options = {})
+        tag.try(:name)
+      end
+    end
+
+    module ClassMethods
+      def contexts(options = {})
+        scope = arel_table.project(:context)
+
+        if !options[:show_all]
+          condition = arel_table[:context].matches('%__H__')
+          condition = condition.not unless options[:show_hidden]
+          scope = scope.where(condition)
+        end
+
+        scope.map {|row| row.tuple.first }.uniq
+      end
+    end
+  end
+end

data/lib/e9_tags/version.rb

@@ -0,0 +1,3 @@
+module E9Tags
+  VERSION = "0.0.8"
+end

data/lib/e9_tags.rb

@@ -0,0 +1,80 @@
+require 'rails'
+require 'acts-as-taggable-on'
+require 'e9_tags/tagging_extension'
+require 'e9_tags/rails_extensions'
+
+module E9Tags
+  autoload :Controller, 'e9_tags/controller'
+  autoload :Model,      'e9_tags/model'
+  autoload :Helper,     'e9_tags/helper'
+
+  module Rack
+    autoload :TagAutoCompleter,         'e9_tags/rack/tag_auto_completer'
+    autoload :TagContextAutoCompleter,  'e9_tags/rack/tag_context_auto_completer'
+    autoload :TagsJs,                   'e9_tags/rack/tags_js'
+  end
+
+  #
+  # Controllers that are prepared to handle taggable models
+  #
+  mattr_accessor :controllers
+  @@controllers = []
+
+  #
+  # Models that are taggable
+  #
+  mattr_accessor :models
+  @@models = []
+
+  ESCAPED_DASH             = '__d__'
+  ESCAPED_DASH_REGEX       = Regexp.new(Regexp.escape(ESCAPED_DASH), true)
+
+  ESCAPED_SPACE            = '__s__'
+  ESCAPED_SPACE_REGEX      = Regexp.new(Regexp.escape(ESCAPED_SPACE), true)
+
+  ESCAPED_PRIVATE          = '__h__'
+  ESCAPED_PRIVATE_REGEX    = Regexp.new(Regexp.escape(ESCAPED_PRIVATE), true)
+
+  PRIVATE_TAG_SUFFIX       = '*'
+  PRIVATE_TAG_SUFFIX_REGEX = Regexp.new(Regexp.escape(PRIVATE_TAG_SUFFIX), true)
+
+  def E9Tags.escape_context(context)
+    context.to_s.strip.
+            downcase.
+            gsub(/\s+/, ESCAPED_SPACE).
+            gsub(/-/, ESCAPED_DASH).
+            sub(PRIVATE_TAG_SUFFIX_REGEX, ESCAPED_PRIVATE)
+  end
+
+  def E9Tags.unescape_context(context)
+    context.to_s.strip.
+            gsub(ESCAPED_SPACE_REGEX, ' ').
+            gsub(ESCAPED_DASH_REGEX, '-').
+            sub(ESCAPED_PRIVATE_REGEX, PRIVATE_TAG_SUFFIX).
+            downcase.
+            titleize
+  end
+
+  def E9Tags.setup!
+    ActsAsTaggableOn::Tagging.send(:include, E9Tags::TaggingExtension)
+
+    E9Tags.models.each {|m| m.send(:include, E9Tags::Model) }
+    E9Tags.controllers.each {|m| m.send(:include, E9Tags::Controller) }
+  end
+
+  class Engine < ::Rails::Engine
+    config.e9_tags = E9Tags
+
+    config.to_prepare { E9Tags.setup! }
+
+    initializer 'e9_tags.include_helper' do
+      ActiveSupport.on_load(:action_view) do
+        include E9Tags::Helper
+      end
+    end
+  end
+end
+
+# Alias ActsAsTaggableOn classes
+Tag     = ActsAsTaggableOn::Tag
+Tagging = ActsAsTaggableOn::Tagging

data/lib/generators/e9_tags/install_generator.rb

@@ -0,0 +1,13 @@
+require 'rails/generators/base'
+
+module E9Tags
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path('../templates', __FILE__)
+
+      def install_javascript
+        copy_file 'e9_tags.js', 'public/javascripts/e9_tags.js'
+      end
+    end
+  end
+end

data/lib/generators/e9_tags/templates/e9_tags.js

@@ -0,0 +1,211 @@
+jQuery(function($) {
+  var
+  $tag_context = $('#tag-context'), 
+  tcv          = $.trim($tag_context.val()),
+
+  /*
+   * If tag-context is blank, default it to Tags. This is important also in that
+   * if the tag-context is pre-set, it will considered hidden and not used as
+   * a label in the form.
+   */
+  default_context_value = tcv.length ? tcv : "Tags",
+
+  /* 
+   * tag contexts in acts-as-taggable-on must be legal instance variable names.  
+   * Replace spaces with __S__ and dashes with __D__ to solve the issue.  As a side effect
+   * it safe to always use the escaped context names as dom ids
+   */
+  escape_context = function(context) {
+    return $.trim(context)
+            .toLowerCase()
+            .replace(/\s+/g, '__s__')
+            .replace(/-/, '__d__')
+            .replace(/\*/, '__h__');
+  },
+
+  unescape_context = function(context) {
+    return $.trim(context)
+            .replace(/__s__/g, ' ')
+            .replace(/__d__/g, '-')
+            .replace(/__h__/g, '*')
+            .toLowerCase()
+            .replace(/(^|\s)([a-z])/g, function(match, m1, m2) { return m1 + m2.toUpperCase(); });
+  };
+
+  // hide empty context-lists
+  $('.context-list ul').each(function(ele) {
+    var ct = $(this).find('li').length;
+    if(ct == 0) $(this).parent().hide();
+  });
+
+  var context_cache = {};
+  var has_clicked_context = false;
+
+  $tag_context
+    /*
+     * initial setting of context and context blur use this:
+     * set context value to default value if context is blank
+     */
+    .blur(function() {
+      $(this).val(function(i, cVal) {
+        return $.trim(cVal).length ? cVal : default_context_value
+      });
+    })
+
+    /*
+     * focus does the reverse and set's the value to blank if
+     * the context is the default context
+     */
+    .focus(function() {
+      $(this).val(function(i, cVal) {
+        return cVal == default_context_value ? "" : cVal;
+      });
+    })
+
+    .autocomplete({
+      delay: 350,
+      source: function(request, response) {
+        var request_str = "term=" + request.term;
+        //if (context_cache.term == request.term && context_cache.content) {
+          //response(context_cache.content);
+          //return;
+        //}
+        //if (new RegExp(context_cache.term).test(request.term) && context_cache.content && context_cache.content.length < 13) {
+          //response($.ui.autocomplete.filter(context_cache.content, request.term));
+          //return;
+        //}
+        $.ajax({
+          url: "/autocomplete/tag-contexts",
+          dataType: "json",
+          data: request_str,
+          success: function(data) {
+            context_cache.term    = request.term;
+            context_cache.content = data;
+            response(data);
+          }
+        });
+      },
+      focus: function(evt, ui) {
+        $("#tag-context").val(ui.item.label);
+        return false;
+      }
+    })
+
+    // blur on load (set to default if blank)
+    .blur()
+  ;
+
+  var $addtf = $("#add-tag-fld"), cache = {};
+
+  $addtf.autocomplete({
+    delay: 350,
+    source: function(request, response) {
+      var request_str = "term=" + request.term;
+      var context = $("#tag-context-select").val() || $("#tag-context").val();
+
+      if (context != undefined && context != '') {
+        request_str += "&context=" + context;
+      }
+
+      // TODO Caching tag autocomplete with context
+      //if (cache.term == request.term && cache.content) {
+        //response(cache.content);
+        //return;
+      //}
+      //if (new RegExp(cache.term).test(request.term) && cache.content && cache.content.length < 13) {
+        //response($.ui.autocomplete.filter(cache.content, request.term));
+        //return;
+      //}
+      
+      $.ajax({
+        url: "/autocomplete/tags",
+        dataType: "json",
+        data: request_str,
+        success: function(data) {
+          //cache.term = request.term;
+          //cache.content = data;
+          response(data);
+        }
+      });
+    },
+    focus: function(evt, ui) {
+      $addtf.val(ui.item.label);
+      return false;
+    }
+  });
+
+  // some variation of this one is probably better as it leaves a blank field in the form?
+  $(".admin-tag").live("click", function(e) {
+    e.preventDefault();
+    var $li = $(this).closest('li');
+    if (!$li.siblings().length) $li.closest('.context-list').hide();
+    $li.remove();
+  });
+
+  $("#tag-context-select").change(function(e) {
+    $addtf.autocomplete('search');
+  });
+
+  $("#add-tag-btn").click(function(evt) {
+    evt.preventDefault();
+
+    if (!$.trim($addtf.val()).length) return;
+
+    var 
+    $tcf = $("#tag-context"),
+    regex = /^[a-zA-Z][a-zA-Z0-9- ]*\*?$/,
+    message = " must begin with a letter and contain only letters, numbers, spaces, and hyphens",
+    tag,
+    context,
+    u_context;
+
+    tag = $addtf.val();
+    if (!tag.match(regex)) {
+      alert("Tags" + message);
+      return;
+    } 
+
+    context = $.trim($tcf.val());
+    if (!context.match(regex)) {
+      alert("Tag contexts" + message);
+      return;
+    } 
+
+    context   = unescape_context(context);
+    u_context = escape_context(context);
+
+    var list = $("#"+u_context+"-context-list ul");
+    if(list.length == 0) {
+      var 
+      html = '<div id="'+ u_context +'-context-list" class="context-list">';
+
+      // if the tag context value was not preset then we use the humanized
+      // context value as a label for the separate context lists
+      if (!tcv.length) {
+        html += '<span>'+context+'</span>';
+      }
+
+      html += '<ul></ul></div>';
+
+      $('#tag-contexts').append(html);
+    } 
+
+    list = $("#"+u_context+"-context-list ul");
+
+    if ($.trim(list.find("input[value='"+tag+"']").val()).length) {
+      alert("That label exists for this content.  You can't create a duplicate record.");
+      return;
+    }
+
+    var ele = tag_template;
+        ele = ele.replace(/__TAG__/g, tag);
+        ele = ele.replace(/__CONTEXT__/g, context);
+        ele = ele.replace(/__UCONTEXT__/g, u_context);
+
+    list.append(ele).parent().show();
+
+    $addtf.val('');
+    $tcf.val('').blur();
+  });
+
+});

metadata

@@ -0,0 +1,178 @@
+--- !ruby/object:Gem::Specification 
+name: e9_tags
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 8
+  version: 0.0.8
+platform: ruby
+authors: 
+- Travis Cox
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-04-15 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rails
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: acts-as-taggable-on
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        - 6
+        version: 2.0.6
+  type: :runtime
+  version_requirements: *id002
+description: |
+  == E9Tags
+  
+  An extension to ActsAsTaggableOn[http://github.com/mbleigh/acts-as-taggable-on] which "improves" on custom tagging, or at least makes it more dynamic. Additionally it 
+  provides some autocomplete rack apps and the corresponding javascript.
+  
+  == Installation
+  
+  1.  E9Tags requires jquery and jquery-ui for the autocompletion and tag-adding form, be sure they're loaded in your 
+      pages where the tags form will be rendered.
+  
+  2.  E9Tags extends ActsAsTaggableOn and requires it.  Run it's generator if you have not.
+  
+  3.  Run the E9Tags install script to copy over the required JS
+  
+          rails g e9_tags:install
+  
+  4.  Then make sure it is loaded, how you do that doesn't matter, e.g.
+  
+          <%= javascript_include_tag 'e9_tags' %>
+  
+  5.  Create an initializer for that sets up the taggable models and their controllers.  This gives the models the tag
+      associations and methods and prepares their controller to handle the otherwise unexpected tag params.
+  
+          require 'e9_tags'
+          require 'contacts_controller'
+          require 'contact'
+  
+          E9Tags.controllers << ContactsController
+          E9Tags.models << Contact
+  
+      OR
+  
+      You can just include the modules in your classes yourself.  The first way really exists for the case where the
+      classes you wish to extend are part of another plugin/gem.
+  
+          # in contact.rb
+          include E9Tags:Model
+  
+          # in contacts_controller.rb
+          include E9Tags::Controller
+  
+  6.  Render the tags form partial in whatever model forms require it.  
+  
+          = render 'e9_tags/form', :f => f
+  
+      If you pass a context, it will be locked and no longer possible to change/add the contexts on the form (and as 
+      a side effect, the tags autocompletion will be restricted to that context).
+  
+          = render 'e9_tags/form', :f => f, :context => :users
+  
+      Finally if you pass a 2nd arg to :context you can set a tag context to be "private" (default is false).  In this
+      case the tag context will be locked as private (typically suffixed with *), meaning that the tags will not be
+      publicly searchable/visible.  This is useful for organizational tags tags, say if you wanted to arbitrarily
+      group records, or create a custom search based on a tag context.
+  
+          = render 'e9_tags/form', :f => f, :context => [:users, true]
+  
+      NOTE: The form and javascript are intended to work out of the box, but the certainly aren't going to look pretty.
+      If you do intend to use the forms, you'll no doubt need to style them.
+      
+      
+
+email: 
+- travis@e9digital.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
+- app/views/e9_tags/_form.html.haml
+- app/views/e9_tags/_tag_list.html.haml
+- app/views/e9_tags/_tag_list_with_context.html.haml
+- app/views/e9_tags/_template.html.haml
+- config/locales/en.yml
+- config/routes.rb
+- e9_tags.gemspec
+- lib/e9_tags.rb
+- lib/e9_tags/controller.rb
+- lib/e9_tags/helper.rb
+- lib/e9_tags/model.rb
+- lib/e9_tags/rack/tag_auto_completer.rb
+- lib/e9_tags/rack/tag_context_auto_completer.rb
+- lib/e9_tags/rack/tags_js.rb
+- lib/e9_tags/rails_extensions.rb
+- lib/e9_tags/tagging_extension.rb
+- lib/e9_tags/version.rb
+- lib/generators/e9_tags/install_generator.rb
+- lib/generators/e9_tags/templates/e9_tags.js
+has_rdoc: true
+homepage: http://github.com/e9digital/e9_tags
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: e9_tags
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Extension to ActsAsTaggableOn used in e9 Rails 3 projects
+test_files: []
+