radiant-taginator-extension 2.0.beta1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZmNiN2ZmYzBiMjMxYTAzNDUyYTU2MzMzMjFlOWU3ODRkMDA5YzQ1NA==
+  data.tar.gz: !binary |-
+    YzkxYTk0Mzk1M2JlOWYyMTcyZTVkZDg4OTQ2YzE3NzIzYTAyODk2Nw==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    NTQ3OTI0NmJiZWVlMmM3ZDZlODY0NTIxNWI2YzM0OTI4NjkwZWNhZmNhMmZl
+    ZjlkZjhmMTNiNDRkNjhjOTVkNWQ5ODM0ZWZkN2E4NDY2MjhlOTVkZDNkOGU1
+    NTdlZmI2M2FlNDYwZmQyOGY2OGVhYzVmYTA0NmFmMjc1NzI0ZTU=
+  data.tar.gz: !binary |-
+    NjM1YjkzZDkyNWI2ZWQ4ODFmNGRiMjFmZmE0NmMzYzQ3MmE2ZTkyODA1YWQy
+    MmM1NjkzYTBjODRmNzRiOWYyOTI4NGUzNTQ4NmY1OGY3YmEzM2NlZjljZWYz
+    NTVjODIyZDIwYTA4NWMzNWNhYTc2Y2I1Y2E2NDE1ZGQ5Mzg2ZTk=

data/.gitignore

@@ -0,0 +1 @@
+radiant-*-extension-*.gem

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "vendor/plugins/acts-as-taggable-on"]
+	path = vendor/plugins/acts-as-taggable-on
+	url = https://github.com/mikz/acts-as-taggable-on.git

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rake', '~> 0.9'

data/Gemfile.lock

@@ -0,0 +1,79 @@
+PATH
+  remote: .
+  specs:
+    radiant-taginator-extension (2.0.beta1)
+      acts-as-taggable-on
+      radiant
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    RedCloth (4.2.9)
+    actionmailer (2.3.18)
+      actionpack (= 2.3.18)
+    actionpack (2.3.18)
+      activesupport (= 2.3.18)
+      rack (~> 1.1.0)
+    activerecord (2.3.18)
+      activesupport (= 2.3.18)
+    activeresource (2.3.18)
+      activesupport (= 2.3.18)
+    activesupport (2.3.18)
+    acts-as-taggable-on (2.1.1)
+      rails
+    acts_as_tree (0.1.1)
+    chunky_png (1.2.8)
+    compass (0.12.2)
+      chunky_png (~> 1.2)
+      fssm (>= 0.2.7)
+      sass (~> 3.1)
+    compass-rails (1.0.3)
+      compass (>= 0.12.2, < 0.14)
+    delocalize (0.2.6)
+    fssm (0.2.10)
+    haml (3.1.8)
+    highline (1.6.19)
+    json (1.8.0)
+    rack (1.1.6)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    radiant (1.1.4)
+      RedCloth (~> 4.2.0)
+      acts_as_tree (~> 0.1.1)
+      bundler (>= 1.0.0)
+      compass (~> 0.12.2)
+      compass-rails (~> 1.0.3)
+      delocalize (~> 0.2.3)
+      haml (~> 3.1.1)
+      highline (~> 1.6.10)
+      rack (~> 1.1.6)
+      rack-cache (~> 1.2)
+      radius (~> 0.7.3)
+      rails (~> 2.3.18)
+      rake (>= 0.8.7)
+      rdoc (>= 3.9.2)
+      stringex (~> 1.3.0)
+      tzinfo (~> 0.3.31)
+      will_paginate (~> 2.3.11)
+    radius (0.7.4)
+    rails (2.3.18)
+      actionmailer (= 2.3.18)
+      actionpack (= 2.3.18)
+      activerecord (= 2.3.18)
+      activeresource (= 2.3.18)
+      activesupport (= 2.3.18)
+      rake (>= 0.8.3)
+    rake (0.9.6)
+    rdoc (4.0.1)
+      json (~> 1.4)
+    sass (3.2.11)
+    stringex (1.3.3)
+    tzinfo (0.3.37)
+    will_paginate (2.3.16)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  radiant-taginator-extension!
+  rake (~> 0.9)

data/HELP.md

@@ -0,0 +1,50 @@
+The Tags extension provides a way for you to easily categorize your pages.
+
+== Results page
+
+	<r:search:empty>
+	  <h2>I couldn't find anything tagged with "<r:search:query/>".</h2>
+	</r:search:empty>
+
+	<r:search:results>
+	  <h2>Found the following pages that are tagged with "<em><r:search:query/></em>".</h2>
+
+	  <ul>
+	  <r:search:results:each>
+	    <li><r:link/> - <r:author/> - <r:date/></li>
+	  </r:search:results:each>
+	  </ul>
+	</r:search:results>
+
+
+== Tag cloud
+
+Use `<r:tag_cloud />` anywhere you like.
+I made a stab at building the 'perfect' tag cloud markup, as inspired by a post on 24ways.org;  http://24ways.org/2006/marking-up-a-tag-cloud
+
+== Tag list
+
+Use `<r:tag_list />` to get a list of tags for the current page. 
+Also works through children:each.
+
+== All tags
+
+Use `<r:all_tags />` to get a list of all tags. You may iterate through them with
+`<r:all_tags:each>` and access their associated pages with `<r:all_tags:each:pages:each>`
+
+== Collections
+
+You can grab a collection of pages with a certain tag like so;
+
+	<r:tagged with="sometag" [scope="/some/page"] [with_any="true"]>
+	  <r:link />
+	</r:tagged>
+
+Which would iterate over all the resulting pages, like you do with children:each.
+When you define scope, only this page and any of it's (grand)children will be used.
+Using scope="current_page" will use the page that is currently being rendered as scope. 
+You can also set limit, offset etc like with children:each.
+
+Using r:tagged in it's default setting searches for pages that have all of the given tags.
+Using r:tagged with the attribute 'with_any' set to 'true' will find pages that have any of
+the given tags.

data/HELP_admin.md

@@ -0,0 +1,30 @@
+The Tags extension allows you to configure the style of tagging between 2 options: 
+simple or complex strings.
+
+== Simple Tagging
+
+By default you may add tags to a page in a string such as "this that other". That string 
+will be parsed and turned into 3 separate tags.
+
+== Complex Tagging
+
+You may set `Radiant::Config['tags.complex_strings'] = true` to allow you to enter more 
+complex tags for your pages.
+
+When this setting is `true` the tags are delimited by a semi-colon, allowing you to enter 
+a string of tags such as "My Summer Vacation (2008); Entertainment/Nonsense; Miscellaneous 2.0". 
+The result of that string will return 3 tags: `My Summer Vacation (2008)`, 
+`Entertainment/Nonsense` and 'Miscellaneous 2.0'
+
+== Making the choice
+
+You'll need to restart the application server after changing this setting. Please keep in
+mind that any changes to this setting may affect any tags you currently have in the database.
+It is recommended that you choose either Simple or Complex, but that you do not switch 
+after creating your tags.
+
+== Tag Clouds
+
+Some styles are provided in tags.css for the <r:tag_cloud>. To use it, add this to your layout:
+  
+  <link rel="stylesheet" type="text/css" href="/stylesheets/tags.css" />

data/README

@@ -0,0 +1,38 @@
+= Tags extension
+
+Created by: Keith Bingman - keithbingman.com
+Revived by: Benny Degezelle - gorilla-webdesign.be
+New features by: Jim Gay - saturnflyer.com
+Rewrite by: Michal Cichra - blog.o2h.cz
+
+Version: 2.0.beta
+
+This extension enhances the page model with tagging capabilities, tagging as in "2.0" and tagclouds.
+
+== Requirements
+
+This extension depends on the acts-as-taggable-on plugin (included in vendor/plugins)
+
+== Installation
+
+1. Copy the extension to your vendor/extensions directory as you would any other extension.
+2. Run 'rake radiant:extensions:tags:install'
+3. Make a page to sit in '/t', and give it the "Tag Search" pagetype.
+	If you want to change this location, it's in Radiant::Config['tags.results_page_url'].
+
+Done!
+Here's a sample results page to get you started;
+	
+	<r:search:empty>
+	  <h2>I couldn't find anything tagged with "<r:search:query/>".</h2>
+	</r:search:empty>
+
+	<r:search:results>
+	  <h2>Found the following pages that are tagged with "<em><r:search:query/></em>".</h2>
+
+	  <ul>
+	  <r:search:results:each>
+	    <li><r:link/> - <r:author/> - <r:date/></li>
+	  </r:search:results:each>
+	  </ul>
+	</r:search:results>

data/Rakefile

@@ -0,0 +1,27 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require "bundler/gem_tasks"
+
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the tags extension.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the tags extension.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'TagsExtension'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+# Load any custom rakefiles for extension
+Dir[File.dirname(__FILE__) + '/tasks/*.rake'].sort.each { |f| require f }

data/app/models/tag_search_page.rb

@@ -0,0 +1,88 @@
+class TagSearchPage < Page
+
+  attr_accessor :requested_tag
+  #### Tags ####
+  desc %{    The namespace for all search tags.}
+  tag 'search' do |tag|
+    tag.expand
+  end
+
+  desc %{    Renders the passed query.}
+  tag 'search:query' do |tag|
+    requested_tag
+  end
+  
+  desc %{    Renders the contained block if no results were returned.}
+  tag 'search:empty' do |tag|
+    if found_tags.blank?
+      tag.expand
+    end
+  end
+  
+  desc %{    Renders the contained block if results were returned.}
+  tag 'search:results' do |tag|
+    unless found_tags.blank?
+      tag.expand
+    end
+  end
+
+  desc %{    <r:search:results:each [sort_by="id"] [order="asc"]/>
+    Renders the contained block for each result page.  The context
+    inside the tag refers to the found page. 
+    
+    Optionaly can pass <em>conditions</em>, <em>order</em> and such attributes.
+  }
+  tag 'search:results:each' do |tag|
+    # Ordering in Ruby because we already fetched our resultset before
+    tags = found_tags tag.attr.symbolize_keys
+    
+    returning String.new do |content|
+      tags.each do |page|
+        tag.locals.page = page
+        content << tag.expand
+      end
+    end
+  end
+  
+  desc %{    <r:truncate_and_strip [length="100"] />
+    Truncates and strips all HTML tags from the content of the contained block.  
+    Useful for displaying a snippet of a found page.  The optional `length' attribute
+    specifies how many characters to truncate to.}
+  tag 'truncate_and_strip' do |tag|
+    tag.attr['length'] ||= 100
+    length = tag.attr['length'].to_i
+    helper = ActionView::Base.new
+    helper.truncate(helper.strip_tags(tag.expand).gsub(/\s+/," "), length)
+  end
+  
+  #### "Behavior" methods ####
+  def cache?
+    true
+  end
+  
+  def found_tags(options = {:order => 'published_at DESC'})
+    return @found_tags if @found_tags
+    return []          if requested_tag.blank?
+    
+    options.reverse_merge! :state => 'published'
+    @found_tags = Page.tagged_with(requested_tag, options)
+  end
+  
+  def render
+    self.requested_tag = @request.parameters[:tag] unless requested_tag
+    self.title = "Tagged with #{requested_tag}" if requested_tag
+    
+    super
+  end
+
+  def find_by_url(url, live = true, clean = false)
+    url = clean_url(url).chop # chop off trailing slash added by clean_url
+    if url =~ /^#{self.url}(.*?)\/?$/
+      self.requested_tag = $1.gsub(/\b\+\b/, " ")
+      self
+    else
+      super
+    end
+  end
+  
+end

data/app/views/admin/help/_using_tags.html.haml

@@ -0,0 +1,4 @@
+%h4 Tags
+%p Tags that you list on your pages are ad-hoc categories and tags that you apply to your pages are as flexible as you want them to be. Rather than selecting a category for your page from a pre-defined list of categories, you can create whatever you need.
+%p Tags are delimited (separated) by a space, so if you want to tag a page with Totally Awesome as one tag, be sure to put it in quotes such as 'Totally Awesome', otherwise you'll create two tags: one called Totally and one called Awesome.
+%p These tags may be used by the site developers to provide a list of links (for example) to a group of pages with the same tag.

data/app/views/admin/pages/_tag_field.html.haml

@@ -0,0 +1,8 @@
+%tr
+  %th.label
+    %label{:for => "page_categories_list"}
+      Tags
+  %td.field
+    = f.text_field :category_list, :class => 'textbox'
+    - unless model.errors.on_base.nil?
+      %span.error= model.errors.on_base

data/config/routes.rb

@@ -0,0 +1,22 @@
+ActionController::Routing::Routes.draw do |map|
+  # FIME: it doesn't work with namespace admin and without :name_prefix and path_prefix (only on production). :(
+  #map.namespace(:admin) do |admin|
+    map.resources :galleries,
+      :name_prefix =>'admin_',
+      :path_prefix => 'admin',
+      :member     => {
+        :clear_thumbs => :get,
+        :reorder => :get, 
+        :update_order => :post
+      },
+      :collection => { 
+        :children => :get,
+        :reorder => :get, 
+        :update_order => :post 
+      } do |galleries|
+        galleries.resources :children,    :controller => 'galleries', :path_prefix => '/admin/galleries/:parent_id'
+        galleries.resources :items,       :controller => 'gallery_items', :member => { :move => :put }
+        galleries.resources :importings,  :controller => 'gallery_importings', :member => { :import => :put }
+        galleries.resources :keywords,    :controller => 'gallery_keywords', :only => [ :edit, :update, :destroy ]
+    end
+end

data/db/migrate/001_acts_as_taggable_on_migration.rb

@@ -0,0 +1,29 @@
+class ActsAsTaggableOnMigration < ActiveRecord::Migration
+  def self.up
+    create_table :tags do |t|
+      t.column :name, :string
+    end
+    
+    create_table :taggings do |t|
+      t.column :tag_id, :integer
+      t.column :taggable_id, :integer
+      t.column :tagger_id, :integer
+      t.column :tagger_type, :string
+      
+      # You should make sure that the column created is
+      # long enough to store the required class names.
+      t.column :taggable_type, :string
+      t.column :context, :string
+      
+      t.column :created_at, :datetime
+    end
+    
+    add_index :taggings, :tag_id
+    add_index :taggings, [:taggable_id, :taggable_type, :context]
+  end
+  
+  def self.down
+    drop_table :taggings
+    drop_table :tags
+  end
+end

data/db/migrate/002_acts_as_taggable_on_private_tags.rb

@@ -0,0 +1,13 @@
+class ActsAsTaggableOnPrivateTags < ActiveRecord::Migration
+  def self.up
+    change_table :tags do |t|
+      t.boolean :private, :null => false, :default => false
+    end
+    
+    add_index :tags, :private
+  end
+  
+  def self.down
+    remove_column :tags, :private
+  end
+end

data/lib/taginator.rb

@@ -0,0 +1,4 @@
+module Taginator
+  autoload :VERSION, 'taginator/version'
+  autoload :Tags, 'taginator/tags'
+end

data/lib/taginator/tags.rb

@@ -0,0 +1,324 @@
+module Taginator::Tags
+  include Radiant::Taggable
+  include ActionView::Helpers::TextHelper
+  
+  class TagError < StandardError; end
+  
+  desc %{
+    Expands if a <pre><r:tagged with="" /></pre> call would return items. Takes the same options as the 'tagged' tag.
+    The <pre><r:unless_tagged with="" /></pre> is also available.
+  }
+  tag 'if_tagged' do |tag|
+    if tag.attr[:with]
+      tag.locals.tagged_results = find_with_tag_options(tag)
+      tag.expand unless tag.locals.tagged_results.empty?
+    else
+      tag.expand unless tag.locals.page.tag_list.empty?
+    end
+  end
+  
+  tag 'unless_tagged' do |tag|
+    if tag.attr[:with]
+      tag.expand if find_with_tag_options(tag).empty?
+    else
+      tag.expand if tag.locals.page.tag_list.empty?
+    end
+  end
+  
+  desc %{
+    Find all pages with certain tags, within in an optional scope. Additionally, you may set with_any to true to select pages that have any of the listed tags (opposed to all listed tags which is the provided default).
+    
+    *Usage:*
+    <pre><code><r:tagged with="shoes diesel" [scope="/fashion/cult-update"] [with_any="true"] [offset="number"] [limit="number"] [by="attribute"] [order="asc|desc"]>...</r:tagged></code></pre>
+  }
+  tag 'tagged' do |tag|
+    tag.attr[:exclude_id] ||= tag.locals.page.id
+    tag.locals.tagged_results ||= find_with_tag_options(tag)
+
+    tag.locals.tagged_results.map do |page|
+      tag.locals.page = page
+      tag.expand
+    end
+  end
+  
+  desc %{
+    Find all pages related to the current page, based on all or any of the current page's tags. A scope attribute may be given to limit results to a certain site area.
+    
+    *Usage:*
+    <pre><code><r:related_by_tags [scope="/fashion/cult-update"] [offset="number"] [limit="number"] [by="attribute"] [order="asc|desc"]>...</r:related_by_tags></code></pre>
+  }
+  tag "related_by_tags" do |tag|
+    options = tag.attr.slice(:offset, :limit, :order).symbolize_keys
+    results = tag.locals.page.find_related_on_categories(options).to_a
+    return if results.size < 1
+    
+    if scope = tag.attr[:scope].presence
+      results.reject! {|page| not page.url.starts_with?(scope) }
+    end
+
+    results.map do |page|
+      tag.locals.page = page
+      tag.locals.first = results.first == page
+      tag.expand
+    end
+  end
+  
+  tag "if_has_related_by_tags" do |tag|
+    options = tag.attr.slice(:offset, :limit, :order).symbolize_keys
+    results = tag.locals.page.find_related_on_categories(options)
+    tag.expand if results.size > 0
+  end
+  
+  tag "related_by_tags:if_first" do |tag|
+    tag.expand if tag.locals.first
+  end
+  
+  desc %{
+    Render a Tag cloud
+    The results_page attribute will default to #{Radiant::Config['tags.results_page_url']}
+     * :start_at   - Restrict the tags to those created after a certain time
+     * :end_at     - Restrict the tags to those created before a certain time
+     * :conditions - A piece of SQL conditions to add to the query
+     * :limit      - The maximum number of tags to return
+     * :order      - A piece of SQL to order by. Eg 'tags.count desc' or 'taggings.created_at desc'
+     * :at_least   - Exclude tags with a frequency less than the given value
+     * :at_most    - Exclude tags with a frequency greater than the given value
+    *Usage:*
+    <pre><code><r:tag_cloud_list [limit="number"] [results_page="/some/url"] [scope="/some/url"]/></code></pre>
+  }
+  tag "tag_cloud" do |tag|
+    options = tag.attr.except(:scope, :results_page).symbolize_keys
+    tags = tag.locals.page.class.tag_counts_on(:categories, options)
+    
+    tags = filter_tags_to_url_scope(tags, tag.attr['scope']) unless tag.attr['scope'].nil?
+    
+    content_tag :ol, :class => :tag_cloud do
+      if tags.length > 0
+        build_tag_cloud(tags, %w(size1 size2 size3 size4 size5 size6 size7 size8 size9)) do |t, cloud_class, amount|
+          puts t, cloud_class, amount
+          content_tag :li, :class => cloud_class do 
+            content_tag(:span, pluralize(amount, 'page is', 'pages are') << ' tagged with ') +
+            link_to(t, results_page(tag) << t, :class => :tag)
+          end
+        end
+      else
+        return "<p>No tags found.</p>"
+      end
+    end
+  end
+ 
+  desc %{
+    Render a Tag list, more for 'categories'-ish usage, i.e.: Cats (2) Logs (1) ...
+    The results_page attribute will default to #{Radiant::Config['tags.results_page_url']}
+    
+    *Usage:*
+    <pre><code><r:tag_cloud_list [results_page="/some/url"] [scope="/some/url"]/></code></pre>
+  }
+  tag "tag_cloud_list" do |tag|
+    options = {}
+    tags = tag.locals.page.class.all_tag_counts(options).order('count desc')
+    tags = filter_tags_to_url_scope(tags, tag.attr[:scope]) unless tag.attr[:scope].nil?
+    
+    results_page = tag.attr[:results_page] || Radiant::Config['tags.results_page_url']
+
+    content_tag :ul, :class => :tag_list do
+      if tags.length > 0
+        build_tag_cloud(tags, %w(size1 size2 size3 size4 size5 size6 size7 size8 size9)) do |t, cloud_class, amount|
+          content_tag :li, :class => cloud_class do
+            link_to("#{t} (#{amount})", results_page(tag) << t, :class => :tag)
+          end
+        end
+      else
+        return "<p>No tags found.</p>"
+      end
+    end
+  end
+ 
+  desc "List the current page's tags"
+  tag "tag_list" do |tag|
+    tag.locals.page.tag_list.map{|t| link_to(t, results_page(tag) << t, :class => :tag)}.join(", ")
+  end
+  
+  desc "List the current page's tagsi as technorati tags. this should be included in the body of a post or in your rss feed"
+  tag "tag_list_technorati" do |tag|
+    tag.locals.page.tag_list.map{|t| link_to(t, 'http://technorati.com/tag/' << t, :rel => :tag)}.join(", ")
+  end
+  
+  tag "tags" do |tag|
+    tag.expand
+  end
+  
+  #desc "Iterates over the tags of the current page"
+  tag "tags:each" do |tag|
+    tag.locals.page.categories.map do |category|
+      tag.locals.category = category
+      tag.expand
+    end
+  end
+  
+  tag "tags:each:name" do |tag|
+    tag.locals.category.name
+  end
+  
+  tag "tags:each:link" do |tag|
+    name = tag.locals.category.name
+    link_to name, results_page(tag) << name, :class => 'tag'
+  end
+
+  #desc "Set the scope for all tags in the database"
+  tag "all_tags" do |tag|
+    tag.expand
+  end
+  
+  desc %{
+    Iterates through each tag and allows you to specify the order: by popularity or by name.
+    The default is by name. You may also limit the search; the default is 5 results.
+    
+    Usage: <pre><code><r:all_tags:each order="popularity" limit="5">...</r:all_tags:each></code></pre>
+  }
+  tag "all_tags:each" do |tag|
+    options = tag.attr.slice(:order, :limit).symbolize_keys
+    
+    if names = tag.attr[:names]
+      names = names.split(",").map{|t| t.strip } 
+      options[:conditions] = ["name IN (?)", names] if names.length > 0
+    end
+    
+    Page.all_tag_counts(options).map do |t|
+      tag.locals.tag = t
+      tag.expand
+    end
+  end
+  
+  desc "Renders the tag's name"
+  tag "all_tags:each:name" do |tag|
+    tag.locals.tag.name
+  end
+  
+  tag "all_tags:each:link" do |tag|
+    name = tag.locals.tag.name
+    link_to tag.expand.presence || name,
+            results_page(tag) << name,
+            tag.attr.reverse_merge(:class => 'tag')
+  end
+  
+  desc "Set the scope for the tag's pages"
+  tag "all_tags:each:pages" do |tag|
+    tag.expand
+  end
+  
+  desc "Iterates through each page"
+  tag "all_tags:each:pages:each" do |tag|
+    Page.tagged_with(tag.locals.tag.name, tag.attr.symbolize_keys).map do |page|
+      tag.locals.page = page
+      tag.expand
+    end
+  end
+  
+  private
+  
+  def build_tag_cloud(tag_cloud, style_list)
+    max, min = 0, 0
+    counts = tag_cloud.map(&:count)
+    min, max = counts.min, counts.max
+    
+    divisor = ((max - min) / style_list.size) + 1
+
+    tag_cloud.map do |tag|
+      yield tag.name, style_list[(tag.count - min) / divisor], tag.count
+    end
+  end
+
+  def tag_item_url(name)
+    "#{Radiant::Config['tags.results_page_url']}/#{name}"
+  end
+  
+  def find_with_tag_options(tag)
+    options = tagged_with_options(tag)
+    with_any = tag.attr[:with_any] || false
+    scope_attr = tag.attr[:scope] || '/'
+
+    raise TagError, "`tagged' tag must contain a `with' attribute." unless (tag.attr['with'] || tag.locals.page.class_name = TagSearchPage)
+    ttag = tag.attr['with'] || @request.parameters[:tag]
+    
+    scope = scope_attr == 'current_page' ? Page.find_by_url(@request.request_uri) : Page.find_by_url(scope_attr)
+    return "The scope attribute must be a valid url to an existing page." if scope.nil? || scope.class_name.eql?('FileNotFoundPage')
+
+    
+    page_ids = Page.tagged_with(ttag, options.merge(:any => with_any)).map do |page|
+        page.id if page.ancestors.include?(scope) || page == scope
+    end.compact
+    
+    Page.find_all_by_id page_ids, options
+  end
+  
+  def tagged_with_options(tag)
+    
+    options = {}
+    
+    [:limit, :offset].each do |symbol|
+      if number = tag.attr[symbol]
+        if number =~ /^\d{1,4}$/
+          options[symbol] = number.to_i
+        else
+          raise TagError.new("`#{symbol}' attribute of `each' tag must be a positive number between 1 and 4 digits")
+        end
+      end
+    end
+    
+    by = (tag.attr[:by] || 'published_at').strip
+    order = (tag.attr[:order] || 'desc').strip
+    order_string = ''
+    
+    if self.attributes.keys.include?(by)
+      order_string << by
+    else
+      raise TagError.new("`by' attribute of `each' tag must be set to a valid field name")
+    end
+    
+    if order =~ /^(asc|desc)$/i
+      order_string << " #{$1.upcase}"
+    else
+      raise TagError.new(%{`order' attribute of `each' tag must be set to either "asc" or "desc"})
+    end
+    
+    options[:order] = order_string
+    
+    status = (tag.attr[:status] || 'published').downcase
+    exclude = tag.attr[:exclude_id] ? "AND pages.id != #{tag.attr[:exclude_id]}" : ""
+    
+    unless status == 'all'
+      stat = Status[status]
+      unless stat.nil?
+        options[:conditions] = ["(virtual = ?) and (status_id = ?) #{exclude} and (published_at <= ?)", false, stat.id, Time.current]
+      else
+        raise TagError.new(%{`status' attribute of `each' tag must be set to a valid status})
+      end
+    else
+      options[:conditions] = ["virtual = ? #{exclude}", false]
+    end
+    
+    options
+  end
+
+  def filter_tags_to_url_scope(tags, scope)
+    tags.select{ |tag|
+      tag.taggings.any?{ |tagging|
+        tagging.taggable.url.starts_with? scope
+      }
+    }
+  end
+  
+  delegate :template, :to => :response
+#  delegate :link_to, :to => :template, :allow_nil => true
+  delegate :content_tag, :to => :template
+  
+  def link_to *args
+    args.second.gsub!(' ', '+') if args.second.respond_to?(:gsub)
+    template.send(:link_to, *args)
+  end
+  
+  def results_page(tag)
+    (tag.attr['results_page'] || Radiant::Config['tags.results_page_url']).dup << "/"
+  end
+end

data/lib/taginator/version.rb

@@ -0,0 +1,3 @@
+module Taginator
+  VERSION = "2.0.beta1"
+end

data/lib/tasks/tags_extension_tasks.rake

@@ -0,0 +1,32 @@
+namespace :radiant do
+  namespace :extensions do
+    namespace :tags do
+      
+      desc "Runs the migration and update tasks of the Tags extension"
+      task :install => [:environment, :migrate, :update]
+      
+      desc "Runs the migration of the Tags extension"
+      task :migrate => :environment do
+        require 'radiant/extension_migrator'
+        if ENV["VERSION"]
+          TagsExtension.migrator.migrate(ENV["VERSION"].to_i)
+        else
+          TagsExtension.migrator.migrate
+        end
+      end
+      
+      desc "Copy needed files to public dir"
+      task :update => :environment do
+        is_svn_or_dir = proc {|path| path =~ /\.svn/ || File.directory?(path) }
+        Dir[TagsExtension.root + "/public/**/*"].reject(&is_svn_or_dir).each do |file|
+          path = file.sub(TagsExtension.root, '')
+          directory = File.dirname(path)
+          puts "Copying #{path}..."
+          mkdir_p RAILS_ROOT + directory
+          cp file, RAILS_ROOT + path
+        end
+      end
+      
+    end
+  end
+end

data/public/stylesheets/tags.css

@@ -0,0 +1,11 @@
+ol.tag_cloud { list-style: none; }
+.tag_cloud li { display: inline; }
+/* hide the extra context from CSS-enabled browsers, but not screenreaders */
+.tag_cloud span { position: absolute; left: 0px; top: -500px; width: 1px; height: 1px; overflow: hidden; }
+
+.tag_cloud .size1 { font-size: 1em; }
+.tag_cloud .size2 { font-size: 1.3em; }
+.tag_cloud .size3 { font-size: 1.6em; }
+.tag_cloud .size4 { font-size: 1.9em; }
+.tag_cloud .size5 { font-size: 2.2em; }
+.tag_cloud .size6 { font-size: 2.5em; }

data/radiant-taginator-extension.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require 'taginator'
+
+Gem::Specification.new do |s|
+  s.name        = 'radiant-taginator-extension'
+  s.version     = Taginator::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["mikz"]
+  s.email       = ["mikz@o2h.cz"]
+  s.homepage    = 'http://github.com/mikz/radiant-taginator-extension'
+  s.summary     = "This extension enhances the page model with tagging capabilities, tagging as in \"2.0\" and tagclouds."
+  s.description = %q{Original extension - https://github.com/jomz/radiant-tags-extension}
+  s.require_paths = ['lib']
+
+  #s.rubyforge_project = "radiant_tools"
+  #s.add_dependency 'rack-rewrite', '~> 1.1.0'
+  #s.add_dependency 'radiant', '~> 0.9.0'
+  s.add_dependency 'acts-as-taggable-on'
+  s.add_dependency 'radiant'
+
+  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"]
+end

data/taginator_extension.rb

@@ -0,0 +1,43 @@
+require_dependency 'application_controller'
+
+class TaginatorExtension < Radiant::Extension
+  version Taginator::VERSION
+  description "This extension enhances the page model with tagging capabilities, tagging as in \"2.0\" and tagclouds."
+  url "http://github.com/mikz/radiant-taginator-extension"
+  
+  DEFAULT_RESULTS_URL = '/t'
+ 
+  def activate
+    config = Radiant::Config
+    if config.table_exists?
+      config['tags.results_page_url'] = config['tags.results_page_url'].presence || DEFAULT_RESULTS_URL
+      config['tags.complex_strings'] = config['tags.complex_strings'].presence || false
+    end
+    
+    Page.class_eval do
+      acts_as_taggable_on :categories
+
+      def category_names
+        categories.map &:name
+      end
+
+      alias :tag_list :category_list
+      alias :tag_list= :category_list=
+      
+    end
+    
+    TagSearchPage
+    Page.send :include, Taginator::Tags
+    admin.page.edit.add :extended_metadata, 'tag_field'
+
+    
+
+    # HELP
+    if admin.respond_to?(:help)
+      admin.help.index.add :page_details, 'using_tags', :after => 'breadcrumbs'
+    end
+  end
+  
+  def deactivate
+  end
+end

data/test/fixtures/meta_tags.yml

@@ -0,0 +1,12 @@
+lorem:
+  id: 1
+  name: lorem
+ipsum:
+  id: 2
+  name: ipsum
+dolor:
+  id: 3
+  name: dolor
+sit:
+  id: 4
+  name: sit

data/test/fixtures/page_parts.yml

@@ -0,0 +1,17 @@
+display_tags_part:
+  id: 1
+  page_id: 5
+  name: body
+  content: 
+    <h1>Results for <r:search:query /></h1>
+    <r:search:empty>
+      <h2>No pages tagged with "<r:search:query/>".</h2>
+    </r:search:empty>
+    <r:search:results>
+      <h2>These pages are tagged with "<r:search:query/>".</h2>
+      <ul>
+        <r:search:results:each order="desc" by="published_at">
+          <li><r:link/> door <r:author/> op <r:date/></li>
+        </r:search:results:each>
+      </ul>
+    </r:search:results>

data/test/fixtures/pages.yml

@@ -0,0 +1,43 @@
+# Read about fixtures at http://ar.rubyonrails.org/classes/Fixtures.html
+homepage:
+  id: 1
+  title: Ruby Home Page
+  breadcrumb: Home
+  slug: /
+  status_id: 100
+  parent_id:
+  published_at: 2006-01-30 08:41:07 
+documentation:
+  id: 2
+  title: Documentation
+  breadcrumb: Documentation
+  slug: documentation
+  status_id: 100
+  parent_id: 1
+  published_at: 2006-01-31 08:41:07 
+books:
+  id: 3
+  title: Books
+  breadcrumb: Books
+  slug: books
+  status_id: 100
+  parent_id: 2
+  published_at: 2006-01-30 08:41:07 
+textile:
+  id: 4
+  title: Textile
+  breadcrumb: Textile
+  slug: textile
+  status_id: 100
+  parent_id: 1
+  published_at: 2006-01-30 08:41:07
+
+tags_page:
+  id: 5
+  title: Tags Page
+  breadcrumb: tags
+  slug: tags
+  status_id: 100
+  parent_id: 1
+  class_name: TagSearchPage
+  published_at: 2006-01-30 08:41:07

data/test/fixtures/taggings.yml

@@ -0,0 +1,20 @@
+1:
+  meta_tag_id: 1
+  taggable_id: 1
+  taggable_type: Page
+2:
+  meta_tag_id: 2
+  taggable_id: 1
+  taggable_type: Page
+3:
+  meta_tag_id: 3
+  taggable_id: 1
+  taggable_type: Page
+4:
+  meta_tag_id: 1
+  taggable_id: 2
+  taggable_type: Page
+5:
+  meta_tag_id: 2
+  taggable_id: 2
+  taggable_type: Page

data/test/functional/tag_search_page_test.rb

@@ -0,0 +1,44 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TagSearchPageTest < ActiveSupport::TestCase
+  
+  fixtures :pages, :meta_tags, :taggings, :page_parts
+  
+  def setup
+    @page = pages(:tags_page)
+    @page.request = ActionController::TestRequest.new
+    @page.response = ActionController::TestResponse.new
+  end
+  
+  def test_title_gets_set_ok
+    @page.request.request_parameters = {:tag => "foo"}
+    @page.render
+    assert_equal "Tagged with foo", @page.title
+  end
+  
+  def test_no_title_means_no_title_change
+    @page.render
+    assert_equal "Tags Page", @page.title
+  end
+  
+  def test_page_should_show_posts_tagged_with_tag
+    @page.request.request_parameters = {:tag => "lorem"}
+    output = @page.render
+    assert_match /These pages are tagged with "lorem"/, output
+    assert_match /Ruby Home Page/, output
+    assert_match /Documentation/, output
+  end
+  
+  def test_resulting_pages_should_be_sorted
+    @page.request.request_parameters = {:tag => "lorem"}
+    output = @page.render
+    assert_match /Documentation.*Ruby Home Page/, output
+  end
+  
+  def test_unknown_tag_should_say_so
+    @page.request.request_parameters = {:tag => "foobarbar"}
+    output = @page.render
+    assert_match /No pages tagged with "foobarbar"/, output
+  end
+  
+end

data/test/functional/tags_extension_test.rb

@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class TagsExtensionTest < ActiveSupport::TestCase
+  
+  fixtures :pages, :meta_tags, :taggings
+  test_helper :render
+  
+  def setup
+    @page = pages(:documentation)
+  end
+  
+  def test_cloud_tag
+    assert_renders "<ol class=\"tag_cloud\"><li class=\"size2\"><span>1 page is tagged with </span><a href=\"?q=dolor\" class=\"tag\">dolor</a></li><li class=\"size3\"><span>2 pages are tagged with </span><a href=\"?q=ipsum\" class=\"tag\">ipsum</a></li><li class=\"size3\"><span>2 pages are tagged with </span><a href=\"?q=lorem\" class=\"tag\">lorem</a></li></ol>", "<r:tag_cloud />"
+  end
+  
+  def test_tag_list
+    assert_renders "<a href=\"?q=ipsum\" class=\"tag\">ipsum</a>, <a href=\"?q=lorem\" class=\"tag\">lorem</a>", "<r:tag_list />"
+  end
+end

data/test/helpers/render_test_helper.rb

@@ -0,0 +1,60 @@
+module RenderTestHelper
+  
+  def assert_renders(expected, input, url = nil, host = nil)
+    output = get_render_output(input, url, host)
+    message = "<#{expected.inspect}> expected but was <#{output.inspect}>"
+    assert_block(message) { expected == output }
+  end
+  
+  def assert_render_match(regexp, input, url = nil)
+    regexp = Regexp.new(regexp) if regexp.kind_of? String
+    output = get_render_output(input, url)
+    message = "<#{output.inspect}> expected to be =~ <#{regexp.inspect}>"
+    assert_block(message) { output =~ regexp }
+  end
+  
+  def assert_render_error(expected_error_message, input, url = nil)
+    output = get_render_output(input, url)
+    message = "expected error message <#{expected_error_message.inspect}> expected but none was thrown"
+    assert_block(message) { false }
+  rescue => e
+    message = "expected error message <#{expected_error_message.inspect}> but was <#{e.message.inspect}>"
+    assert_block(message) { expected_error_message === e.message }
+  end
+  
+  def assert_headers(expected_headers, url = nil)
+    setup_page(url)
+    headers = @page.headers
+    message = "<#{expected_headers.inspect}> expected but was <#{headers.inspect}>"
+    assert_block(message) { expected_headers == headers }
+  end
+  
+  def assert_page_renders(page_name, expected, message = nil)
+    page = pages(page_name)
+    output = page.render
+    message = "<#{expected.inspect}> expected, but was <#{output.inspect}>"
+    assert_block(message) { expected == output }
+  end
+  
+  def assert_snippet_renders(snippet_name, expected, message = nil)
+    snippet = snippets(snippet_name)
+    output = @page.render_snippet(snippet)
+    message = "<#{expected.inspect}> expected, but was <#{output.inspect}>"
+    assert_block(message) { expected == output }
+  end
+  
+  private
+  
+    def get_render_output(input, url, host = nil)
+      setup_page(url, host)
+      @page.send(:parse, input)
+    end
+    
+    def setup_page(url = nil, host = nil)
+      @page.request = ActionController::TestRequest.new
+      @page.request.request_uri = (url || @page.url)
+      @page.request.host = host || "testhost.tld"
+      @page.response = ActionController::TestResponse.new
+    end
+  
+end

data/test/test_helper.rb

@@ -0,0 +1,20 @@
+require 'test/unit'
+# Load the the environment
+unless defined? RADIANT_ROOT
+  ENV["RAILS_ENV"] = "test"
+  require "#{File.expand_path(File.dirname(__FILE__) + "/../../../../")}/config/environment"
+end
+require "#{RADIANT_ROOT}/test/test_helper"
+
+class ActiveSupport::TestCase
+  
+  # Include a helper to make testing Radius tags easier
+  test_helper :render
+  
+  # Add the fixture directory to the fixture path
+  self.fixture_path << File.dirname(__FILE__) + "/fixtures"
+  
+  fixtures :users, :pages
+  # Add more helper methods to be used by all extension tests here...
+  
+end

data/test/unit/page_taggability_test.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/../test_helper'
+
+class PageTaggabilityTest < ActiveSupport::TestCase
+  def setup
+    @page = Page.find 1
+  end
+  
+  def test_page_should_be_taggable
+    assert true, @page.respond_to?("tag_with")
+    assert_difference MetaTag, :count, 2 do
+      @page.tag_with 'lorem ipsum'
+    end
+  end
+  
+  def assert_difference(object, method = nil, difference = 1)
+    initial_value = object.send(method)
+    yield
+    assert_equal initial_value + difference, object.send(method), "#{object}##{method}"
+  end
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: radiant-taginator-extension
+version: !ruby/object:Gem::Version
+  version: 2.0.beta1
+platform: ruby
+authors:
+- mikz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: acts-as-taggable-on
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: radiant
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Original extension - https://github.com/jomz/radiant-tags-extension
+email:
+- mikz@o2h.cz
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .gitmodules
+- Gemfile
+- Gemfile.lock
+- HELP.md
+- HELP_admin.md
+- README
+- Rakefile
+- app/models/tag_search_page.rb
+- app/views/admin/help/_using_tags.html.haml
+- app/views/admin/pages/_tag_field.html.haml
+- config/routes.rb
+- db/migrate/001_acts_as_taggable_on_migration.rb
+- db/migrate/002_acts_as_taggable_on_private_tags.rb
+- lib/taginator.rb
+- lib/taginator/tags.rb
+- lib/taginator/version.rb
+- lib/tasks/tags_extension_tasks.rake
+- public/stylesheets/tags.css
+- radiant-taginator-extension.gemspec
+- taginator_extension.rb
+- test/fixtures/meta_tags.yml
+- test/fixtures/page_parts.yml
+- test/fixtures/pages.yml
+- test/fixtures/taggings.yml
+- test/functional/tag_search_page_test.rb
+- test/functional/tags_extension_test.rb
+- test/helpers/render_test_helper.rb
+- test/test_helper.rb
+- test/unit/page_taggability_test.rb
+homepage: http://github.com/mikz/radiant-taginator-extension
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.6
+signing_key: 
+specification_version: 4
+summary: This extension enhances the page model with tagging capabilities, tagging
+  as in "2.0" and tagclouds.
+test_files:
+- test/fixtures/meta_tags.yml
+- test/fixtures/page_parts.yml
+- test/fixtures/pages.yml
+- test/fixtures/taggings.yml
+- test/functional/tag_search_page_test.rb
+- test/functional/tags_extension_test.rb
+- test/helpers/render_test_helper.rb
+- test/test_helper.rb
+- test/unit/page_taggability_test.rb