radiant-twitter-extension 2.0.0.rc1

data/HELP_admin.md

@@ -0,0 +1,19 @@
+You can have updates to your site automatically send details to your 
+Twitter account. All you'll need to do is provide your account information 
+in the Radiant::Config settings.
+
+The required keys are `twitter.password`, `twitter.username` and `twitter.url_host`.
+
+The `username` and `password` are the same for your login details of your Twitter
+account. The `url_host` will be used when generating links back to your site, this 
+should be your domain name.
+
+On the edit screen of each page, you can select the option to notify Twitter
+of all of the updates to the children of that page. You can create a blog page,
+for example, and have each new post linked in your Twitter account.
+
+_Built with version `0.6.6` of the `twitter` gem._
+
+To get latest tweet(s):
+
+<r:twitter:message [ max="10" ] /> 

data/README.md

@@ -0,0 +1,104 @@
+# Twitter
+
+An extension to Radiant that will automatically tweet the publication of new pages in selected parts of your site, and which provides a set of radius tags that allow you to feature twitter feeds of different kinds on your site.
+
+## Installation
+
+	sudo gem install radiant-twitter-extension
+
+add this to your environment.rb
+
+	config.gem 'radiant-twitter-extension', :version => '~> 2.0.0.rc1'
+
+and then:
+
+	rake radiant:extensions:update_all
+	rake radiant:extensions:twitter:migrate
+	
+You can also vendor the extension in the old-fashioned way:
+
+	git submodule add git://github.com/radiant/radiant-twitter-extension.git vendor/extensions/twitter
+	rake radiant:extensions:twitter:update
+	rake radiant:extensions:twitter:migrate
+
+## Status
+
+Nearly stable. I've just made some quite sweeping changes to bring this up to date, so small bugs are likely. Please file issues.
+
+## Configuration
+
+You can present twitter searches and feeds without authenticating, but if you want to post automatically to twitter you need to provide login information. The extension adds a 'twitter' block to the main radiant configuration interface: enter your screen name and password. Future versions may integrate with Twitter as an application but for now all we need is the ability to tweet.
+
+## Tweet on publication
+
+To post a tweet every time you publish a blog entry, check the 'Notify Twitter of newly published child pages?' box on the parent blog page. The tweet will contain the title of the page and its url.
+
+## Display a twitter feed
+
+If radiant is configured to tweet for you, all you need is this radius tag:
+
+	<r:twitter:tweets [max="10"] />
+	
+If it's not configured, or you want to display another user:
+
+	<r:twitter:tweets user="screen_name" />
+
+To display a hashtag, or any other search:
+
+	<r:twitter:tweets search="#radiant" />
+
+To display tweets from someone's list:
+
+	<r:twitter:tweets user="screen_name" list="list_name" />
+
+The default presentation of tweets is exactly as [suggested by Twitter](https://dev.twitter.com/terms/display-guidelines) and if you include their widget script and the provided css it should all just work. If you want to present tweets differently, a range of more detailed radius tags is available. This is a slightly more compact format:
+
+	<r:twitter:tweets user="screen_name" />
+	  <li class="tweet">
+	    <r:tweet:avatar class="avatar" />
+		<r:tweet:user:screen_name />
+		<span class="block">
+		  <r:tweet:text />
+		</span>
+		<span class="hidden">
+		  <r:tweet:reply_link />
+		  <r:tweet:retweet_link />
+		</span>
+	  </li>
+	</r:twitter:tweets>
+		
+## Scripts and styles 
+
+The quick way to format tweets nicely is to include the supplied sass in your site stylesheet. If you're using radiant's built-in stylesheet manager and working in Sass, you can keep everything in one file (and selectively override it) by including this line near the top:
+
+	@import 'twitter.sass'
+	
+You can also link to `/stylesheets/twitter.css` in the usual way.
+
+The links created by radius tags here are all compatible with twitter's widgeting. To enable basic intent-based popups, just include this line in the head or at the foot of your layout:
+
+	<script type="text/javascript" src="http://platform.twitter.com/widgets.js"></script>
+
+## Todo
+
+* More gratifying twitter integration of admin
+* Page field to edit tweet text before publication
+* URL-shortener
+
+## Copyright and license
+
+Originally created by Sean Cribbs and now the work of many hands, including:
+
+* Jim Gay
+* Edmund Haselwanter
+* Anna Billstrom
+* William Ross
+
+Currently maintained by Will at spanner.org. Issues and comments on github, please:
+
+	https://github.com/radiant/radiant-twitter-extension/issues
+
+Released under the same terms as Rails and/or Radiant.
+
+
+

data/Rakefile

@@ -0,0 +1,120 @@
+# I think this is the one that should be moved to the extension Rakefile template
+
+# In rails 1.2, plugins aren't available in the path until they're loaded.
+# Check to see if the rspec plugin is installed first and require
+# it if it is.  If not, use the gem version.
+
+# Determine where the RSpec plugin is by loading the boot
+unless defined? RADIANT_ROOT
+  ENV["RAILS_ENV"] = "test"
+  case
+  when ENV["RADIANT_ENV_FILE"]
+    require File.dirname(ENV["RADIANT_ENV_FILE"]) + "/boot"
+  when File.dirname(__FILE__) =~ %r{vendor/radiant/vendor/extensions}
+    require "#{File.expand_path(File.dirname(__FILE__) + "/../../../../../")}/config/boot"
+  else
+    require "#{File.expand_path(File.dirname(__FILE__) + "/../../../")}/config/boot"
+  end
+end
+
+require 'rake'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+rspec_base = File.expand_path(RADIANT_ROOT + '/vendor/plugins/rspec/lib')
+$LOAD_PATH.unshift(rspec_base) if File.exist?(rspec_base)
+require 'spec/rake/spectask'
+# require 'spec/translator'
+
+# Cleanup the RADIANT_ROOT constant so specs will load the environment
+Object.send(:remove_const, :RADIANT_ROOT)
+
+extension_root = File.expand_path(File.dirname(__FILE__))
+
+task :default => :spec
+task :stats => "spec:statsetup"
+
+desc "Run all specs in spec directory"
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts = ['--options', "\"#{extension_root}/spec/spec.opts\""]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+namespace :spec do
+  desc "Run all specs in spec directory with RCov"
+  Spec::Rake::SpecTask.new(:rcov) do |t|
+    t.spec_opts = ['--options', "\"#{extension_root}/spec/spec.opts\""]
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.rcov = true
+    t.rcov_opts = ['--exclude', 'spec', '--rails']
+  end
+  
+  desc "Print Specdoc for all specs"
+  Spec::Rake::SpecTask.new(:doc) do |t|
+    t.spec_opts = ["--format", "specdoc", "--dry-run"]
+    t.spec_files = FileList['spec/**/*_spec.rb']
+  end
+
+  [:models, :controllers, :views, :helpers].each do |sub|
+    desc "Run the specs under spec/#{sub}"
+    Spec::Rake::SpecTask.new(sub) do |t|
+      t.spec_opts = ['--options', "\"#{extension_root}/spec/spec.opts\""]
+      t.spec_files = FileList["spec/#{sub}/**/*_spec.rb"]
+    end
+  end
+  
+  # Hopefully no one has written their extensions in pre-0.9 style
+  # desc "Translate specs from pre-0.9 to 0.9 style"
+  # task :translate do
+  #   translator = ::Spec::Translator.new
+  #   dir = RAILS_ROOT + '/spec'
+  #   translator.translate(dir, dir)
+  # end
+
+  # Setup specs for stats
+  task :statsetup do
+    require 'code_statistics'
+    ::STATS_DIRECTORIES << %w(Model\ specs spec/models)
+    ::STATS_DIRECTORIES << %w(View\ specs spec/views)
+    ::STATS_DIRECTORIES << %w(Controller\ specs spec/controllers)
+    ::STATS_DIRECTORIES << %w(Helper\ specs spec/views)
+    ::CodeStatistics::TEST_TYPES << "Model specs"
+    ::CodeStatistics::TEST_TYPES << "View specs"
+    ::CodeStatistics::TEST_TYPES << "Controller specs"
+    ::CodeStatistics::TEST_TYPES << "Helper specs"
+    ::STATS_DIRECTORIES.delete_if {|a| a[0] =~ /test/}
+  end
+
+  namespace :db do
+    namespace :fixtures do
+      desc "Load fixtures (from spec/fixtures) into the current environment's database.  Load specific fixtures using FIXTURES=x,y"
+      task :load => :environment do
+        require 'active_record/fixtures'
+        ActiveRecord::Base.establish_connection(RAILS_ENV.to_sym)
+        (ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/) : Dir.glob(File.join(RAILS_ROOT, 'spec', 'fixtures', '*.{yml,csv}'))).each do |fixture_file|
+          Fixtures.create_fixtures('spec/fixtures', File.basename(fixture_file, '.*'))
+        end
+      end
+    end
+  end
+end
+
+desc 'Generate documentation for the twitter extension.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'TwitterExtension'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+# For extensions that are in transition
+desc 'Test the twitter extension.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+# Load any custom rakefiles for extension
+Dir[File.dirname(__FILE__) + '/tasks/*.rake'].sort.each { |f| require f }

data/app/views/admin/configuration/_twitter_edit.html.haml

@@ -0,0 +1,6 @@
+%fieldset
+  %h4= t('twitter_extension.twitter')
+  %p= edit_config 'twitter.username'
+  %p= edit_config 'twitter.password'
+  %p= edit_config 'twitter.token'
+  %p= edit_config 'twitter.secret'

data/app/views/admin/configuration/_twitter_show.html.haml

@@ -0,0 +1,5 @@
+%h4= t('twitter_extension.twitter')
+%p.ruled= show_config 'twitter.username'
+%p.ruled= show_config 'twitter.password'
+%p.ruled= show_config 'twitter.token'
+%p.ruled= show_config 'twitter.secret'

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

@@ -0,0 +1,9 @@
+%tr
+  %th.label
+    Twitter
+  %td
+    - fields_for @page do |pf|
+      = pf.check_box :notify_twitter_of_children
+      = pf.label :notify_twitter_of_children
+    - if @page.twitter_id
+      = link_to "[#{@page.twitter_id}]", "http://twitter.com/#{Radiant::Config['twitter.username']}/status/#{@page.twitter_id}"

data/config/initializers/radiant_config.rb

@@ -0,0 +1,8 @@
+Radiant.config do |config|
+  config.namespace 'twitter' do |twit|
+    twit.define 'username', :default => '', :allow_blank => true
+    twit.define 'password', :default => '', :allow_blank => true
+    twit.define 'token', :default => '', :allow_blank => true
+    twit.define 'secret', :default => '', :allow_blank => true
+  end
+end

data/config/locales/en.yml

@@ -0,0 +1,20 @@
+en:
+  activerecord:
+    attributes:
+      page:
+        notify_twitter_of_children: "Notify Twitter of newly published child pages?"
+  config:
+    twitter:
+        username: "Username (for tweets)"
+        password: "Password (for tweets)"
+        token: "Application token"
+        secret: "Application secret"
+  date:
+    formats:
+      twitter: "%m %B"
+  twitter_extension:
+    favorite: "Favorite"
+    reply: "Reply"
+    retweet: "Retweet"
+    twitter: "Twitter"
+  

data/db/migrate/001_add_twitter_notification_fields.rb

@@ -0,0 +1,11 @@
+class AddTwitterNotificationFields < ActiveRecord::Migration
+  def self.up
+    add_column :pages, :notify_twitter_of_children, :boolean, :default => false
+    add_column :pages, :twitter_id, :string
+  end
+  
+  def self.down
+    remove_column :pages, :notify_twitter_of_children
+    remove_column :pages, :twitter_id
+  end
+end

data/lib/radiant-twitter-extension.rb

@@ -0,0 +1,8 @@
+module RadiantTwitterExtension
+  VERSION = '2.0.0.rc1'
+  SUMMARY = %q{Twitter posting and radius tags for twitter feeds.}
+  DESCRIPTION = %q{Posts notification of pages to Twitter and provides radiius tags to display the results of twitter searches.}
+  URL = "http://github.com/ehaselwanter/radiant-twitter-extension"
+  AUTHORS = ["Sean Cribbs", "Edmund Haselwanter", "Jim Gay", "William Ross"]
+  EMAIL = ["radiant@radiantcms.org"]
+end

data/lib/tasks/twitter_extension_tasks.rake

@@ -0,0 +1,28 @@
+namespace :radiant do
+  namespace :extensions do
+    namespace :twitter do
+      
+      desc "Runs the migration of the Twitter extension"
+      task :migrate => :environment do
+        require 'radiant/extension_migrator'
+        if ENV["VERSION"]
+          TwitterExtension.migrator.migrate(ENV["VERSION"].to_i)
+        else
+          TwitterExtension.migrator.migrate
+        end
+      end
+      
+      desc "Copies public assets of the Twitter to the instance public/ directory."
+      task :update => :environment do
+        is_svn_or_dir = proc {|path| path =~ /\.svn/ || File.directory?(path) }
+        puts "Copying assets from TwitterExtension"
+        Dir[TwitterExtension.root + "/public/**/*"].reject(&is_svn_or_dir).each do |file|
+          path = file.sub(TwitterExtension.root, '')
+          directory = File.dirname(path)
+          mkdir_p RAILS_ROOT + directory
+          cp file, RAILS_ROOT + path
+        end
+      end  
+    end
+  end
+end

data/lib/twitter_notification.rb

@@ -0,0 +1,43 @@
+require 'twitter'
+module TwitterNotification
+  def self.included(base)
+    base.class_eval {
+      after_save :notify_twitter
+    }
+  end
+  
+  def notify_twitter
+    if parent
+      if published? && Radiant.configured? && parent.notify_twitter_of_children? && !self.twitter_id
+        title_length = 138 - absolute_url.length
+        message_title = title.length > title_length ? (title[0..title_length-4] + "...") : title
+        message = "#{message_title}: #{absolute_url}"
+        begin
+          httpauth = Twitter::HTTPAuth.new(Radiant.config['twitter.username'], Radiant.config['twitter.password'])
+          client = Twitter::Base.new(httpauth)
+          status = client.update(message, :source => "radianttwitternotifier")
+          # Don't trigger save callbacks
+          self.class.update_all({:twitter_id => status.id}, :id => self.id)
+        rescue Twitter::Error => e
+          logger.error "Twitter Notification failure: #{e.inspect}"
+        end
+      end
+    end
+    true
+  end
+
+  def absolute_url
+    if host = Radiant.config['site.host']
+      if host =~ /^http/
+        "#{host}#{self.url}"
+      else
+        "http://#{host}#{self.url}"
+      end
+    end
+  end
+
+  def Radiant.configured?
+    !%w(twitter.username twitter.password site.host).any? {|k| Radiant.config[k].blank? }
+  end
+
+end

data/lib/twitter_tags.rb

@@ -0,0 +1,406 @@
+require 'twitter'
+
+module TwitterTags
+  include ActionView::Helpers::DateHelper
+  include Radiant::Taggable
+  class TagError < StandardError; end
+
+  tag 'twitter' do |tag|
+    tag.expand
+  end
+
+  desc %{
+    Retrieve a list of tweets. The minimal default is to return the ten most recent tweets of the 
+    Radiant.configured twitter user (that is, the person as whom radiant is set up to tweet).
+    For that, you can use just a single tag:
+    
+    <pre><code><r:twitter:tweets /></code></pre>
+    
+    or control the presentation of tweets in a more detailed way:
+    
+    <r:twitter:tweets:each><r:tweet:user:screen_name /> : <r:tweet:text /></r:twitter:tweets:each>
+    
+    You can also specify a search in various ways. 
+    
+    * Supply a `max` attribute to change the number of tweets displayed. Default is 10.
+    * Supply a `user` attribute to display tweets from a different username
+    * Supply a `list` attribute to display tweets from the named list (see also r:twitter:list for a shortcut)
+    * Supply a `search` attribute to show tweets containing that text (see also r:twitter:search for a shortcut)
+      You don't need to %escape the search string. 
+      In a search query the user and list parameters will be ignored.
+    
+    <pre><code>
+      <r:twitter:tweets user="spanner_org" max="2" />
+      <r:twitter:tweets search="#radiant" />
+    </code></pre>
+    
+  }
+  tag 'twitter:tweets' do |tag|  
+    tag.locals.tweets = fetch_and_cache_tweets(tag.attr.slice('user', 'max', 'search', 'list').symbolize_keys)
+    tag.double? ? tag.expand : tag.render('twitter:messages')
+  end
+  
+  tag 'twitter:tweets:each' do |tag|
+    tag.locals.tweets ||= fetch_and_cache_tweets(tag.attr.slice('user', 'max', 'search', 'list').symbolize_keys)
+    tag.render('_tweets_list', tag.attr.dup, &tag.block)
+  end
+
+  desc %{
+    Fetches and loops through tweets matching the supplied search string. You don't need to %escape the search string.
+
+    <pre><code>
+      <r:twitter:search for="#radiant"><r:tweets:each>...</r:tweets:each></r:twitter:search>
+      <r:twitter:search for="rails cms" max="1">...</r:twitter:search>
+      <r:twitter:search for="somethinbg" max="20">...</r:twitter:search>
+    </code></pre>
+    
+    Short form also works:
+    
+    <pre><code><r:twitter:search for="#radiant" /></code></pre>
+
+    and you can go stright into a loop:
+    
+    <pre><code><r:twitter:search:each for="#radiant">...</r:twitter:search:each></code></pre>    
+  }
+  tag 'twitter:search' do |tag|
+    tag.locals.tweets = fetch_and_cache_tweets(:search => tag.attr['for']) if tag.attr.any?
+    tag.double? ? tag.expand : tag.render('twitter:messages')
+  end
+
+  tag 'twitter:search:each' do |tag|
+    tag.locals.tweets ||= fetch_and_cache_tweets(:search => tag.attr['for'])
+    tag.render('_tweets_list', tag.attr.dup, &tag.block)
+  end
+
+  desc %{
+    Fetches tweets from the specified list belonging to the specified (or default) user.
+
+    <pre><code><r:twitter:list list="listname" [user="username"] [max="10"]  /></code></pre>
+    
+    Short form also works:
+    
+    <pre><code><r:twitter:list list="radiant" /></code></pre>
+    
+    and you can go stright into a loop:
+    
+    <pre><code><r:twitter:list:each list="radiant">...</r:twitter:list:each></code></pre>    
+  }
+  tag 'twitter:list' do |tag|
+    tag.locals.tweets = fetch_and_cache_tweets(:user => tag.attr['user'], :max => tag.attr['max'], :list => tag.attr['list']) if tag.attr.any?
+    tag.double? ? tag.expand : tag.render('twitter:messages')
+  end
+  
+  tag 'twitter:list:each' do |tag|
+    tag.locals.tweets ||= fetch_and_cache_tweets(:user => tag.attr['user'], :max => tag.attr['max'], :list => tag.attr['list'])
+    tag.render('_tweets_list', tag.attr.dup, &tag.block)
+  end
+
+  desc %{
+    Returns the number of tweets.
+  }
+  tag 'tweets:length' do |tag|
+    tag.render('_tweets_length', tag.attr.dup, &tag.block)
+  end
+  tag 'twitter:list:length' do |tag|
+    tag.render('_tweets_length', tag.attr.dup, &tag.block)
+  end
+  tag 'twitter:search:length' do |tag|
+    tag.render('_tweets_length', tag.attr.dup, &tag.block)
+  end
+
+  desc %{
+    Loops through the current list of tweets.
+  }
+  tag 'tweets:each' do |tag|
+    tag.render('_tweets_list', tag.attr.dup, &tag.block)
+  end
+
+  # these are just for drying out: they can't be called directly.
+
+  tag '_tweets_list' do |tag|
+    raise TagError, "tweet_list utility tag called without a list of tweets to list" unless tag.locals.tweets
+    out = ""
+    tag.locals.tweets.each do |tweet|
+      tag.locals.tweet = tweet
+      if tag.double? 
+        out << tag.expand
+      else 
+        out << tag.render('tweet:message')
+      end
+    end
+    out
+  end
+  
+  tag '_tweets_length' do |tag|
+    raise TagError, "_tweets_length utility tag called without a list of tweets to length" unless tag.locals.tweets
+    tag.locals.tweets.length
+  end
+
+  desc %{
+    Usage:
+
+    This is a shortcut that displays messages from a twitter user's timeline. 
+    The username can be specified with a 'user' parameter, or we will default to the Radiant.configured twitter user.
+    The number of messages is determined by the 'max' parameter, which must be 10 or less. Default is 5.
+
+    <pre><code><r:twitter:messages max="10" /></code></pre>
+  }
+  tag 'twitter:messages' do |tag|
+    out = ""
+    tag.locals.tweets ||= fetch_and_cache_tweets(:user => tag.attr['user'], :max => tag.attr['max'])
+    tag.locals.tweets.each do |tweet|
+      tag.locals.tweet = tweet
+      out << tag.render('tweet:message')
+    end
+    out
+  end
+  
+  deprecated_tag 'twitter:message', :substitute => 'twitter:messages'
+
+  tag 'tweet' do |tag|
+    tag.expand if tag.locals.tweet
+  end
+  
+  desc %{
+    Shortcut to display a single tweet in the standard way suggested by https://dev.twitter.com/terms/display-guidelines.
+    
+    Note that for this to work you will probably want to include the twitter intents javascript in your page, and you may
+    also want to include the supplied `twitter.sass` in your site stylesheets.
+  }
+  tag 'tweet:message' do |tag|
+    if tweet = tag.locals.tweet
+      text = replace_links(tweet.text)
+      screen_name = tweet.from_user || tweet.user.screen_name   # search returns a different data structure
+      date = tag.render('tweet:date', tag.attr.dup.merge('format' => "%d %B"))
+      %{
+        <p class="twitter">
+          <a class="twitter_avatar" href="http://twitter.com/#{screen_name}">#{tag.render("tweet:avatar")}</a> 
+          <span class="tweet">
+            <a class="twitter_user" href="http://twitter.com/#{screen_name}">#{screen_name}</a> 
+            <span class="twitter_name">#{tag.render('tweet:user:name')}</span>
+            <span class="twitter_text">#{text}</span>
+            <span class="twitter_links">
+              #{tag.render('tweet:permalink')}
+              #{tag.render('tweet:reply_link')}
+              #{tag.render('tweet:retweet_link')}
+              #{tag.render('tweet:favorite_link')}
+            </span>
+          </span>
+        </p>
+      }
+    end
+  end
+
+  [:coordinates, :in_reply_to_screen_name, :truncated, :in_reply_to_user_id, :in_reply_to_status_id, 
+    :source, :place, :geo, :favorited, :contributors, :id].each do |method|
+    desc %{
+      Renders the @#{method.to_s}@ attribute of the tweet
+      <pre><code><r:tweet:#{method.to_s}/></code></pre>
+    }
+    tag "tweet:#{method.to_s}" do |tag|
+      tag.locals.tweet.send(method) if tag.locals.tweet.respond_to? method
+    end
+
+    desc %{
+      expands if the property has a value
+      <pre><code><r:tweet:if_#{method.to_s}/></code></pre>
+    }
+    tag "tweet:if_#{method.to_s}" do |tag|
+      value = tag.locals.tweet.send(method) if tag.locals.tweet.respond_to? method
+      tag.expand if !value.nil? && !value.empty?
+    end
+
+    desc %{
+      expands if the property has no value
+      <pre><code><r:tweet:unless_#{method.to_s}/></code></pre>
+    }
+    tag "tweet:unless_#{method.to_s}" do |tag|
+      value = tag.locals.tweet.send(method) if tag.locals.tweet.respond_to? method
+      tag.expand if value.nil? || value.empty?
+    end
+  end
+
+  [:date, :created_at].each do |method|
+    desc %{
+      renders the  created_at timestamp of the tweet
+      <pre><code><r:tweet:#{method.to_s} [format="%c"]/></code></pre>
+    }
+    tag "tweet:#{method.to_s}" do |tag|
+      format = tag.attr['format'] || "%c"
+      date = DateTime.parse(tag.locals.tweet.created_at)
+      I18n.l date, :format => format
+    end
+  end
+
+  tag 'tweet:user' do |tag|
+    unless tag.locals.twitterer = tag.locals.tweet.user
+      tag.locals.twitterer = fetch_twitter_user(tag.locals.tweet.from_user)
+    end
+    raise TagError, "twitter user could not be found" unless tag.locals.twitterer
+    tag.expand
+  end
+
+  [:time_zone, :description, :lang, :profile_link_color, :profile_background_image_url, :profile_sidebar_fill_color, :following, 
+    :profile_background_tile, :created_at, :statuses_count,:profile_sidebar_border_color,:profile_use_background_image,:followers_count,
+    :contributors_enabled,:notifications,:friends_count,:protected,:url,:profile_image_url,:geo_enabled,:profile_background_color,
+    :name,:favourites_count,:location,:screen_name, :id,:verified,:utc_offset,:profile_text_color].each do |method|
+    desc %{
+      Renders the @#{method.to_s}@ attribute of the tweeting user
+      <pre><code><r:tweet:user:#{method.to_s}/></code></pre>
+    }
+    tag "tweet:user:#{method.to_s}" do |tag|
+      tag.locals.twitterer.send(method)
+    end
+
+    desc %{
+      expands if @#{method.to_s}@ attribute of the tweeting user has a value
+      <pre><code><r:tweet:user:if_#{method.to_s}/></code></pre>
+    }
+    tag "tweet:user:if_#{method.to_s}" do |tag|
+      value = tag.locals.twitterer.send(method) rescue nil
+      tag.expand unless value.nil? || value.empty?
+    end
+
+    desc %{
+      expands if @#{method.to_s}@ attribute of the tweeting user has no value
+      <pre><code><r:tweet:user:unless_#{method.to_s}/></code></pre>
+    }
+    tag "tweet:user:unless_#{method.to_s}" do |tag|
+      value = tag.locals.twitterer.send(method) rescue nil
+      tag.expand if value.nil? || value.empty?
+    end
+  end
+  
+  desc %{
+    Renders an avatar image for the tweeter of the current tweet.
+  }
+  tag 'tweet:avatar' do |tag|
+    url = tag.locals.tweet.profile_image_url || tag.render('tweet:user:profile_image_url')
+    %{<img src="#{url}" class="twitter_avatar" />}
+  end
+
+  desc %{
+    Renders the text for the current tweet.
+  }
+  tag 'tweet:text' do |tag|
+    tweet = tag.locals.tweet
+    replace_links(tweet.text)
+  end
+
+  desc %{
+    Renders the created ago string for the tweet e.g. Created 7 days...
+  }
+  tag 'tweet:created_ago' do |tag|
+    tweet = tag.locals.tweet
+    time_ago_in_words tweet.created_at
+  end
+
+  desc %{
+    Renders a permalink to this tweet with its date as the default link text.
+  }
+  tag 'tweet:permalink' do |tag|
+    cssclass = tag.attr['class'] || 'twitter_permalink'
+    text = tag.double? ? tag.expand : I18n.l(tag.locals.tweet.created_at, :twitter)
+    %{<a class="#{cssclass}" href="http://twitter.com/#!/#{screen_name}/status/#{tweet.id_str}">#{text}</a>}
+  end
+
+  desc %{
+    Renders a 'Reply' link that can be left as it is or hooked up by the twitter javascript.
+  }
+  tag 'tweet:reply_link' do |tag|
+    cssclass = tag.attr['class'] || 'twitter_reply'
+    text = tag.double? ? tag.expand : I18n.t('twitter_extension.reply')
+    %{<a class="#{cssclass}" href="http://twitter.com/intent/tweet?in_reply_to=#{tag.locals.tweet.id_str}">#{text}</a>}
+  end
+
+  desc %{
+    Renders a 'Retweet' link that can be left as it is or hooked up by the twitter javascript.
+  }
+  tag 'tweet:retweet_link' do |tag|
+    cssclass = tag.attr['class'] || 'twitter_retweet'
+    text = tag.double? ? tag.expand : I18n.t('twitter_extension.retweet')
+    %{<a class="#{cssclass}" href="http://twitter.com/intent/retweet?tweet_id=#{tag.locals.tweet.id_str}">#{text}</a>}
+  end
+
+  desc %{
+    Renders a 'Favorite' link that can be left as it is or hooked up by the twitter javascript.
+  }
+  tag 'tweet:favorite_link' do |tag|
+    cssclass = tag.attr['class'] || 'twitter_favorite'
+    text = tag.double? ? tag.expand : I18n.t('twitter_extension.favorite')
+    %{<a class="#{cssclass}" href="http://twitter.com/intent/favorite?tweet_id=#{tag.locals.tweet.id_str}">#{text}</a>}
+  end
+
+private
+
+  # Retained for compatibility
+  #
+  def twitter_status(max = 1)
+    max = 1 if (max > 10) or (max < 1)
+    fetch_and_cache_tweets(:max => max)
+  end
+  
+  # General-purpose tweet-fetcher using Rails::Cache to provide a calm-enhancing gap between similar
+  # requests. Set Radiant.config['twitter.expires_in'] to change the gap from 5 minutes.
+  # Always returns an array of tweet hashes (mashes, really).
+  # :max, :user, :list and :search options are used to determine the call we make (and the cache key).
+  # :page and :per_page options are passed through to the search call but not the user or list calls.
+  # other options are passed through (to non-search calls) unchanged.
+  #
+  def fetch_and_cache_tweets(options = {})
+    max = options.delete(:max) || 10
+    user = options.delete(:username) || Radiant.config['twitter.username']
+    list = options.delete(:list) || Radiant.config['twitter.listname']
+    search = options.delete(:search)
+    options[:count] ||= max
+    cache_key = ['twitter', list, user, max, search].compact.join('_')
+    begin
+      tweets = Rails.cache.fetch(cache_key,:expires_in => twitter_cache_duration) do
+        if search
+          Twitter::Search.new.containing(search).page(options[:page] || 1).per_page(options[:per_page] || 10).fetch
+        elsif list
+          twitter_client.list_timeline(user, list, options)
+        else
+          twitter_client.user_timeline(user, options)
+        end
+      end
+      
+    rescue Twitter::Error => e
+      logger.error "Unable to fetch timeline: #{e.inspect}"
+    end
+
+    tweets || []
+  end
+  
+  def fetch_twitter_user(screen_name)
+    cache_key = "twitter_user_#{screen_name}"
+    begin
+      twitter_user = Rails.cache.fetch(cache_key,:expires_in => twitter_cache_duration) do
+        twitter_client.user(screen_name)
+      end
+    rescue Twitter::Error => e
+      logger.error "Unable to fetch user '#{screen_name}': #{e.inspect}"
+    end
+  end
+
+  # these operations don't require authentication
+  #
+  def twitter_client
+    @twitter_client ||= Twitter::Client.new
+  end
+
+  # Turns http
+  #
+  def replace_links(text)
+    text = text.gsub(/(https?:\/\/\S*)/, '<a class="twitter_link" href="\1">\1</a>')
+    text = text.gsub(/@(\w*)/, '@<a class="twitter_link" href="http://twitter.com/\1">\1</a>')
+    text = text.gsub(/#(\w*)/, '<a class="twitter_link" href="http://twitter.com/search/#\1">#\1</a>')
+  end
+
+  # The interval between twitter api calls with the same parameters is set by the
+  # `twitter.expires_in` config entry and defaults to 5 minutes.
+  #
+  def twitter_cache_duration
+    @twitter_expires_in ||= (Radiant::Config["twitter.expires_in"] || 5).to_i.minutes
+  end
+end

data/public/stylesheets/sass/twitter.sass

@@ -0,0 +1,46 @@
+p.twitter
+  a.twitter_avatar
+    float: left
+    margin-right: 0.8em
+    img
+      margin-top: 0.8em
+  span.tweet
+    display: block
+    overflow: hidden
+    a.twitter_user
+      font-size: 150%
+      font-weight: normal
+    span.twitter_name
+      color: #b2b2b2
+    span.twitter_text
+      display: block
+    span.twitter_links
+      display: block
+      font-size: 80%
+      a
+        padding-left: 18px
+        height: 16px
+        color: #b2b2b2
+        background:
+          position: top left
+          repeat: no-repeat
+          image: url(/images/twitter/sprite.png)
+        &:hover
+          color: #666666
+      a.twitter_permalink
+      a.twitter_reply
+        background-position: 0 -16px
+        &:hover
+          background-position: 0 -32px
+      a.twitter_favourite
+        background-position: 0 -48px
+        &:hover
+          background-position: 0 -64px
+      a.twitter_retweet
+        background-position: 0 -96px
+        &:hover
+          background-position: 0 -112px
+      a.twitter_favorite
+        background-position: 0 -80px
+        &:hover
+          background-position: 0 -112px

data/radiant-twitter-extension.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "radiant-twitter-extension"
+
+Gem::Specification.new do |s|
+  s.name        = "radiant-twitter-extension"
+  s.version     = RadiantTwitterExtension::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = RadiantTwitterExtension::AUTHORS
+  s.email       = RadiantTwitterExtension::EMAIL
+  s.homepage    = RadiantTwitterExtension::URL
+  s.summary     = RadiantTwitterExtension::SUMMARY
+  s.description = RadiantTwitterExtension::DESCRIPTION
+
+  s.add_dependency 'twitter', "~> 1.6.0"
+
+  ignores = if File.exist?('.gitignore')
+    File.read('.gitignore').split("\n").inject([]) {|a,p| a + Dir[p] }
+  else
+    []
+  end
+  s.files         = Dir['**/*'] - ignores
+  s.test_files    = Dir['test/**/*','spec/**/*','features/**/*'] - ignores
+  # s.executables   = Dir['bin/*'] - ignores
+  s.require_paths = ["lib"]
+
+  s.post_install_message = %{
+  Add this to your radiant project with:
+    config.gem 'radiant-twitter-extension', :version => '~>#{RadiantTwitterExtension::VERSION}'
+  }
+end

data/spec/lib/twitter_tags_spec.rb

@@ -0,0 +1,114 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe 'TwitterTags' do
+  dataset :pages
+
+  before do
+    Radiant.config['twitter.username'] = 'testy'
+    Radiant.config['twitter.password'] = 'secret'
+    
+    @client = mock("HTTPAuth (client)").as_null_object
+    
+    # I've been getting odd failures with mock tweets
+    # when they're passed into a radius context
+    
+    @tweets = (1..10).collect do |i|
+      OpenStruct.new.tap do |tweet|
+        tweet.text = "tweet #{i}"
+        tweet.created_at = DateTime.new(2010, 2, i+1).to_s
+        tweet.source = "<a href=\"http://www.atebits.com/\" rel=\"nofollow\">Tweetie</a>"
+      end
+    end
+  end
+
+  describe '<r:twitter> The main context' do
+    it 'should give no output' do
+      tag = %{<r:twitter />}
+      pages(:home).should render(tag).as('')
+    end
+  end
+
+  describe '<r:twitter:tweets> Collect the users recent tweets' do
+    before(:each) do
+      Twitter::Client.stub!(:new).and_return(@client)
+      @client.stub!(:user_timeline).and_return(@tweets)
+    end
+
+    it 'should give no output' do
+      tag = %{<r:twitter><r:tweets></r:tweets></r:twitter>}
+      pages(:home).should render(tag).as('')
+    end
+
+    it 'should report the correct number of tweets' do
+      tag = %{<r:twitter><r:tweets:length /></r:twitter>}
+      pages(:home).should render(tag).as("10")
+    end
+
+    it 'should return the tweet text and replace links' do
+      tag = %{<r:twitter><r:tweets:each><r:tweet:text /></r:tweets:each></r:twitter>}
+      expected = @tweets.map(&:text).join('')
+      pages(:home).should render(tag).as(expected)
+    end
+  
+    it 'should return the created at timestamp' do
+      tag = %{<r:twitter><r:tweets:each><r:tweet:created_at format="%d %B" /></r:tweets:each></r:twitter>}
+      expected = (1..10).map{|i| "#{'%02d' % (i+1)} February"}.join('')
+      pages(:home).should render(tag).as(expected)
+    end
+  
+    it 'should return the created ago string' do
+      tag = %{<r:twitter><r:tweets:each><r:tweet:created_ago /></r:tweets:each></r:twitter>}
+      Time.stub!(:now).and_return(Time.parse("Feb 12 2010"))
+      expected = '10 days9 days8 days7 days6 days5 days4 days3 days2 days1 day'
+      pages(:home).should render(tag).as(expected)
+    end
+  
+    it 'should return the source' do
+      tag = %{<r:twitter><r:tweets:each><r:tweet:source /></r:tweets:each></r:twitter>}
+      expected = @tweets.map(&:source).join('')
+      pages(:home).should render(tag).as(expected)
+    end
+  end
+  
+  describe '<r:twitter:list list="list"> Collect the users list tweets' do
+    before(:each) do
+      Twitter::Client.stub!(:new).and_return(@client)
+      @client.stub!(:list_timeline).and_return(@tweets)
+    end
+  
+    it 'should give no output' do
+      tag = %{<r:twitter><r:list list="list"></r:list></r:twitter>}
+      pages(:home).should render(tag).as('')
+    end
+  
+    it 'should report the correct number of tweets (default 10)' do
+      tag = %{<r:twitter><r:list list="list"><r:length /></r:list></r:twitter>}
+      pages(:home).should render(tag).as("10")
+    end
+  
+    it 'should return the tweet text and replace links' do
+      tag = %{<r:twitter><r:list list="list"><r:each><r:tweet:text /></r:each></r:list></r:twitter>}
+      expected = @tweets.map(&:text).join('')
+      pages(:home).should render(tag).as(expected)
+    end
+  
+    it 'should return the created at timestamp' do
+      tag = %{<r:twitter><r:list list="list"><r:each><r:tweet:created_at format="%d %B" /></r:each></r:list></r:twitter>}
+      expected = (1..10).map{|i| "#{'%02d' % (i+1)} February"}.join('')
+      pages(:home).should render(tag).as(expected)
+    end
+  
+    it 'should return the created ago string' do
+      tag = %{<r:twitter><r:list list="list"><r:each><r:tweet:created_ago /></r:each></r:list></r:twitter>}
+      Time.stub!(:now).and_return(Time.parse("Feb 12 2010"))
+      expected = '10 days9 days8 days7 days6 days5 days4 days3 days2 days1 day'
+      pages(:home).should render(tag).as(expected)
+    end
+  
+    it 'should return the source' do
+      tag = %{<r:twitter><r:list list="list"><r:each><r:tweet:source /></r:each></r:list></r:twitter>}
+      expected = @tweets.map(&:source).join('')
+      pages(:home).should render(tag).as(expected)
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,6 @@
+--colour
+--format
+progress
+--loadby
+mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+unless defined? RADIANT_ROOT
+  ENV["RAILS_ENV"] = "test"
+  case
+  when ENV["RADIANT_ENV_FILE"]
+    require ENV["RADIANT_ENV_FILE"]
+  when File.dirname(__FILE__) =~ %r{vendor/radiant/vendor/extensions}
+    require "#{File.expand_path(File.dirname(__FILE__) + "/../../../../../../")}/config/environment"
+  else
+    require "#{File.expand_path(File.dirname(__FILE__) + "/../../../../")}/config/environment"
+  end
+end
+require "#{RADIANT_ROOT}/spec/spec_helper"
+
+if File.directory?(File.dirname(__FILE__) + "/scenarios")
+  Scenario.load_paths.unshift File.dirname(__FILE__) + "/scenarios"
+end
+if File.directory?(File.dirname(__FILE__) + "/matchers")
+  Dir[File.dirname(__FILE__) + "/matchers/*.rb"].each {|file| require file }
+end
+
+Spec::Runner.configure do |config|
+  # config.use_transactional_fixtures = true
+  # config.use_instantiated_fixtures  = false
+  config.fixture_path = File.dirname(__FILE__) + '/spec/fixtures'
+
+  # You can declare fixtures for each behaviour like this:
+  #   describe "...." do
+  #     fixtures :table_a, :table_b
+  #
+  # Alternatively, if you prefer to declare them only once, you can
+  # do so here, like so ...
+  #
+  #   config.global_fixtures = :table_a, :table_b
+  #
+  # If you declare global fixtures, be aware that they will be declared
+  # for all of your examples, even those that don't use them.
+end

data/twitter_extension.rb

@@ -0,0 +1,18 @@
+class TwitterExtension < Radiant::Extension
+  version RadiantTwitterExtension::VERSION
+  description RadiantTwitterExtension::DESCRIPTION
+  url RadiantTwitterExtension::URL
+  
+  extension_config do |config|
+    config.gem "twitter", :version => "~> 1.6.0"
+  end
+  
+  def activate
+    Page.send :include, TwitterNotification             # tweet page title upon publication
+    Page.send :include, TwitterTags                     # radius tags to display twitter search results
+    
+    admin.pages.edit.add :extended_metadata, "twitter"  # toggle twitter-posting at parent level
+    admin.configuration.show.add :config, 'admin/configuration/twitter_show', :after => 'defaults'
+    admin.configuration.edit.add :form,   'admin/configuration/twitter_edit', :after => 'edit_defaults' 
+  end
+end

data/vendor/plugins/filestore_expires_in-plugin/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 [name of plugin creator]
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/vendor/plugins/filestore_expires_in-plugin/README.md

@@ -0,0 +1,56 @@
+Filestore Cache Expires_in Plugin
+============================
+
+Adds a :expires_in option to Rails filestore caching, in line with memcached store. Providing a very easy way to add high capacity caching to a site.
+
+Model observers and sweepers are still useable as well, of course.
+
+Filestore caching is a much easier method of caching to implement quickly than memcached, since it just involves writing the cache data to files in the tmp/ directory (also making it good for shared hosting environments).
+
+Installation
+------
+
+1) Install plugin
+
+    ./script/plugin install git://github.com/adamsalter/filestore_expires_in-plugin.git
+
+2) Enable :file_store caching
+
+config/environments/production.rb:
+
+    config.action_controller.perform_caching = true
+    config.cache_store = :file_store, "#{RAILS_ROOT}/tmp/cache"
+
+Useage
+------
+
+On controller classes:
+
+    class MyController < ApplicationController
+      caches_action :show, {:if => etc.}, {:expires_in => 1.day}
+    end
+
+In controller methods:
+
+    unless read_fragment({:controller => 'mycontroller', etc.}, {:expires_in => 1.day})
+      #code here
+    end
+
+In views:
+
+    cache({:controller => 'mycontroller', etc.}, {:expires_in => 1.day}) do
+      #fragment here
+    end
+
+In models:
+
+    cache_key = "models/my_model/%s?%s-%s-%s" % ["model_method_name", self.value, page, limit]
+    
+    result = Rails.cache.fetch(cache_key, :expires_in => 1.day) do
+      # result data to be cached
+    end
+
+
+Copyright (c) 2009 Adam @ [Codebright.net][cb], released under the MIT license
+
+[cb]:http://codebright.net

data/vendor/plugins/filestore_expires_in-plugin/init.rb

@@ -0,0 +1,3 @@
+# Include hook code here
+
+require 'active_support/cache/file_store_extras'

data/vendor/plugins/filestore_expires_in-plugin/lib/active_support/cache/file_store_extras.rb

@@ -0,0 +1,26 @@
+
+module ActiveSupport
+  module Cache
+    class FileStore < Store
+       def read(name, options = nil)
+         super
+        file_name = real_file_path(name)
+        expires = expires_in(options)
+
+        if exist_without_instrument?(file_name, expires)
+          File.open(file_name, 'rb') { |f| Marshal.load(f) }
+        end
+       end
+
+       def exist?(name, options = nil)
+         super
+        File.exist?(real_file_path(name))
+        exist_without_instrument?(real_file_path(name), expires_in(options))
+       end
+
+       def exist_without_instrument?(file_name, expires)
+          File.exist?(file_name) && (expires <= 0 || Time.now - File.mtime(file_name) < expires)
+       end
+    end
+  end    
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification 
+name: radiant-twitter-extension
+version: !ruby/object:Gem::Version 
+  hash: 15424087
+  prerelease: 6
+  segments: 
+  - 2
+  - 0
+  - 0
+  - rc
+  - 1
+  version: 2.0.0.rc1
+platform: ruby
+authors: 
+- Sean Cribbs
+- Edmund Haselwanter
+- Jim Gay
+- William Ross
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-28 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: twitter
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 1
+        - 6
+        - 0
+        version: 1.6.0
+  type: :runtime
+  version_requirements: *id001
+description: Posts notification of pages to Twitter and provides radiius tags to display the results of twitter searches.
+email: 
+- radiant@radiantcms.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- app/views/admin/configuration/_twitter_edit.html.haml
+- app/views/admin/configuration/_twitter_show.html.haml
+- app/views/admin/pages/_twitter.html.haml
+- config/initializers/radiant_config.rb
+- config/locales/en.yml
+- db/migrate/001_add_twitter_notification_fields.rb
+- HELP_admin.md
+- lib/radiant-twitter-extension.rb
+- lib/tasks/twitter_extension_tasks.rake
+- lib/twitter_notification.rb
+- lib/twitter_tags.rb
+- public/images/twitter/bird.png
+- public/images/twitter/sprite.png
+- public/stylesheets/sass/twitter.sass
+- radiant-twitter-extension.gemspec
+- Rakefile
+- README.md
+- spec/lib/twitter_tags_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+- twitter_extension.rb
+- vendor/plugins/filestore_expires_in-plugin/init.rb
+- vendor/plugins/filestore_expires_in-plugin/lib/active_support/cache/file_store_extras.rb
+- vendor/plugins/filestore_expires_in-plugin/MIT-LICENSE
+- vendor/plugins/filestore_expires_in-plugin/README.md
+has_rdoc: true
+homepage: http://github.com/ehaselwanter/radiant-twitter-extension
+licenses: []
+
+post_install_message: "\n  Add this to your radiant project with:\n    config.gem 'radiant-twitter-extension', :version => '~>2.0.0.rc1'\n  "
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      hash: 25
+      segments: 
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.3
+signing_key: 
+specification_version: 3
+summary: Twitter posting and radius tags for twitter feeds.
+test_files: 
+- spec/lib/twitter_tags_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb