radiant-rss_reader-extension 1.0.0

data/README.md

@@ -0,0 +1,81 @@
+# Radiant RSS Reader Extension
+
+This is a RadiantCMS extension (originally a behavior by Alessandro Preite Martinez) that adds some tags to fetch and display RSS feeds. It uses the'ruby-feedparser' module, and it is able to cache the raw feed data and to only fetch the new feed if it has been modified (using the If-Modified-Since HTTP header).
+
+## Installation
+
+Add `gem "radiant-rss_reader-extension", "~> 1.0.0"` to your Gemfile and run `bundle install`
+
+
+## Usage
+
+Use it in your page like this (just an example):
+
+    <dl>
+     <r:feed:items url="http://www.somefeed.com/rss" limit="5">
+      <dt><r:feed:link /> - by <r:feed:creator />, <r:feed:date format="%b %d"/></dt>
+      <dd><r:feed:content /></dd>
+     </r:feed:items>
+    </dl>
+    
+You can also order by some feed entry attribute other than the date:
+
+    <ul>
+
+      <r:feed:items
+          url="http://feeds.boingboing.net/boingboing/iBag" 
+          order="creator ASC">
+
+        <li><r:feed:link /></li>
+
+      </r:feed:items>
+
+    </ul>
+    
+And you can do headers to mark off sections:
+
+    <ul>
+
+      <r:feed:items
+          url="http://feeds.boingboing.net/boingboing/iBag" 
+          order="creator ASC">
+
+        <r:feed:header for="creator">
+          <h2><r:feed:creator /></h2>
+        </r:feed:header>
+
+        <li><r:feed:link /></li>
+
+      </r:feed:items>
+
+    </ul>
+
+You can sort items and group headers by date, title, content, creator, or link (i.e. the URL of the item). There are more things you can do, which are documented in `rss_reader.rb`.
+
+## [Contributors](https://github.com/radiant/radiant-rss_reader-extension/graphs/contributors)
+
+#### Original Author:  
+* Alessandro Preite Martinez (ale@incal.net)
+
+#### Port to Extension:
+
+* BJ Clark (bjclark@scidept.com, http://www.scidept.com/)
+* Loren Johnson (loren@fn-group.com, http://www.fn-group.com)
+
+#### Update to new Extension Architecture, Gemify:
+
+* Andrew vonderLuft (avonderluft@avlux.net, https://avlux.net)
+
+#### Modifications:
+
+* James MacAulay (jmacaulay@gmail.com, http://jmacaulay.net/)
+* Michael Hale (mikehale@gmail.com, http://michaelahale.com/)
+* Bryan Liles (iam@smartic.us, http://smartic.us/)
+
+## [History](https://github.com/radiant/radiant-rss_reader-extension/commits/master)
+
+## License
+
+Creative Commons Attribution-Share Alike 2.5 License
+
+

data/Rakefile

@@ -0,0 +1,110 @@
+# 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 'rdoc/task'
+require 'rake/testtask'
+require 'bundler/gem_tasks'
+
+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 'cucumber'
+require 'cucumber/rake/task'
+
+# 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, :features]
+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
+
+task :features => 'spec:integration'
+
+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
+  
+  desc "Run the Cucumber features"
+  Cucumber::Rake::Task.new(:integration) do |t|
+    t.fork = true
+    t.cucumber_opts = ['--format', (ENV['CUCUMBER_FORMAT'] || 'pretty')]
+    # t.feature_pattern = "#{extension_root}/features/**/*.feature"
+    t.profile = "default"
+  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 rss_reader extension.'
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'RssReaderExtension'
+  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/config/initializers/radiant_config.rb

@@ -0,0 +1,3 @@
+Radiant.config do |config|
+  # config.define "setting.name", :default => 'value', :select_from => ['foo', 'bar']
+end

data/config/locales/en.yml

@@ -0,0 +1,3 @@
+---
+en:
+  rss reader: RSS Reader

data/config/routes.rb

@@ -0,0 +1,5 @@
+ActionController::Routing::Routes.draw do |map|
+  # map.namespace :admin, :member => { :remove => :get } do |admin|
+  #   admin.resources :rss_reader
+  # end
+end

data/cucumber.yml

@@ -0,0 +1 @@
+default: --format progress features --tags ~@proposed,~@in_progress

data/features/support/env.rb

@@ -0,0 +1,11 @@
+# Sets up the Rails environment for Cucumber
+ENV["RAILS_ENV"] = "test"
+# Extension root
+extension_env = File.expand_path(File.dirname(__FILE__) + '/../../../../../config/environment')
+require extension_env+'.rb'
+
+Dir.glob(File.join(RADIANT_ROOT, "features", "**", "*.rb")).each {|step| require step unless step =~ /datasets_loader\.rb$/}
+ 
+Cucumber::Rails::World.class_eval do
+  dataset :rss_reader
+end

data/features/support/paths.rb

@@ -0,0 +1,22 @@
+module NavigationHelpers
+  
+  # Extend the standard PathMatchers with your own paths
+  # to be used in your features.
+  # 
+  # The keys and values here may be used in your standard web steps
+  # Using:
+  #
+  #   When I go to the "rss_reader" admin page
+  # 
+  # would direct the request to the path you provide in the value:
+  # 
+  #   admin_rss_reader_path
+  # 
+  PathMatchers = {} unless defined?(PathMatchers)
+  PathMatchers.merge!({
+    # /rss_reader/i => 'admin_rss_reader_path'
+  })
+  
+end
+
+World(NavigationHelpers)

data/lib/radiant-rss_reader-extension.rb

@@ -0,0 +1,8 @@
+module RadiantRssReaderExtension
+  VERSION     = "1.0.0"
+  SUMMARY     = "RSS Reader for Radiant CMS"
+  DESCRIPTION = "This extension uses the ruby-feedparser gem to read external RSS feeds, cache them, and easily display them in your pages."
+  URL         = "https://github.com/radiant/radiant-rss_reader-extension"
+  AUTHORS     = ["Andrew vonderLuft","Loren Johnson"]
+  EMAIL       = ["avonderluft@avlux.net","loren@hellovenado.com"]
+end

data/lib/rss_reader.rb

@@ -0,0 +1,190 @@
+require 'uri'
+require 'net/http'
+require 'net/https'
+require 'feedparser/feedparser'
+
+module RssReader
+  include Radiant::Taggable
+  
+  def fetch_rss(uri, cache_time)
+    c = File.join(ActionController::Base.page_cache_directory, uri.tr(':/','_'))
+    if (cached_feed = feed_for(IO.read(c)) rescue nil)
+      return cached_feed if File.mtime(c) > (Time.now - cache_time)
+      since = File.mtime(c).httpdate
+    else
+      since = "1970-01-01 00:00:00"
+    end
+    u = URI::parse(uri)
+    begin
+      http = Net::HTTP.new(u.host, u.port)
+      http.use_ssl = true if u.port == 443
+      answer = http.get("#{u.request_uri}", {"If-Modified-Since" => since, 'User-Agent' => "RadiantCMS rss_reader Extension #{RadiantRssReaderExtension::VERSION}"} )
+      feed = feed_for(answer.body)
+    rescue
+      return cached_feed
+    end
+    case answer.code
+    when '304'
+      return cached_feed
+    when '200'
+      File.open(c,'w+') { |fp| fp << answer.body }
+      return feed
+    else
+      raise StandardError, "#{answer.code} #{answer.message}"
+    end
+  end
+  
+  def feed_for(str)
+    FeedParser::Feed.new(str)
+  end
+
+  def cache?
+    false
+  end
+
+    tag "feed" do |tag|
+      tag.expand
+    end
+
+
+ desc %{
+    Iterates through items in an rss feed provided as an absolute url to the @url@ attribute.
+    
+    Optional attributes:
+
+    * @cache_time@: length of time to cache the feed before seeing if it's been updated
+    * @order@:      works just like SQL 'ORDER BY' clauses, e.g. order='creator date desc' orders first by creator ascending, then date descending
+    * @limit@:      only return the first x items (after any ordering)
+    
+    *Usage:*
+
+    <pre><code><r:find:items url="http://somefeed.com/rss" [cache_time="3600"] [order="creator date desc"] [limit="5"]>...</r:feed:items></code></pre>
+    }
+    tag "feed:items" do |tag|
+      attr = tag.attr.symbolize_keys
+      result = []
+      begin
+        items = fetch_rss(attr[:url], attr[:cache_time].to_i || 900).items
+      rescue
+        return "<!-- RssReader error: #{$!} -->"
+      end
+      if attr[:order]
+        (tokens = attr[:order].split.map {|t| t.downcase}.reverse).each_index do |i|
+          t = tokens[i]
+          if ['title','link','content','date','creator'].include? t
+            items.sort! {|x,y| (tokens[i-1] == 'desc') ? (y.send(t) <=> x.send(t)) : (x.send(t) <=> y.send(t)) }
+          end
+        end
+      end
+      if attr[:limit]
+        items = items.slice(0,attr[:limit].to_i)
+      end
+      items.each_index do |i|
+      	tag.locals.item = items[i]
+      	tag.locals.last_item = items[i-1] if i > 0
+        result << tag.expand
+      end
+      result
+    end
+
+ desc %{
+    Used when the @feed:items@ tag uses the @order@ attribute. Will enter this block each time the value of the @for@ attribute is different from the previous feed item. Note: Using "date" as the @for@ attribute group by day
+    
+    *Usage:*
+
+    <pre><code><r:feed:header for="{creator|title|link|content|date}">...</r:feed:header></code></pre>
+    }    
+
+    tag "feed:header" do |tag|
+      attr = tag.attr.symbolize_keys
+      grouping = attr[:for] || 'date'
+      unless tag.locals.last_item
+        tag.expand
+      else
+        if ['title','link','content','creator'].include? grouping
+          tag.expand if tag.locals.item.send(grouping) != tag.locals.last_item.send(grouping)
+        elsif grouping == 'date'
+          tag.expand if tag.locals.item.send(grouping).strftime("%j%Y") != tag.locals.last_item.send(grouping).strftime("%j%Y")
+        end
+      end
+    end
+    
+    tag "feed:title" do |tag|
+      tag.locals.item.title
+    end
+
+    tag "feed:link" do |tag|
+      options = tag.attr.dup
+      attributes = options.inject('') { |s, (k, v)| s << %{#{k.downcase}="#{v}" } }.strip
+      attributes = " #{attributes}" unless attributes.empty?
+      href = tag.locals.item.link
+      text = tag.double? ? tag.expand : tag.locals.item.title
+      %{<a href="#{href}"#{attributes}>#{text}</a>}
+    end
+    
+    tag "feed:uri" do |tag|
+      tag.locals.item.link
+    end
+
+ desc %{
+    Display the contents of the rss feed item
+
+    Optional attributes:
+
+    * @max_length@: no-nonsense truncation
+    * @no_p@:       takes out just the enclosing paragraph tags that FeedParser puts in
+    * @no_html@:    takes out *all* html
+    
+    *Usage:*
+
+    <pre><code><r:feed:content  [max_length="140"] [no_p="true"] [no_html="true"]/></code></pre>
+    }   
+
+    tag "feed:content" do |tag|
+      attr = tag.attr.symbolize_keys
+      result = tag.locals.item.content
+      if attr[:max_length]
+        l = tag.locals.item.content.size()
+      	maxl = attr[:max_length].to_i
+      	if l > maxl
+      	  result = tag.locals.item.content[0..maxl] + ' ...'
+      	end
+      end
+      if result
+        result = result.gsub(/\A<p>(.*)<\/p>\z/m,'\1') if attr[:no_p]
+        result = result.gsub(/<[^>]+>/, '') if attr[:no_html]
+      end
+      result
+    end
+
+ desc %{
+    Display the date of the rss feed item
+
+    Optional attributes:
+
+    * @format@: Default is "%A, %B %d, %Y" can be changed to "%b %d"
+    
+    *Usage:*
+
+    <pre><code><r:feed:date  [format="%b %d"]/></code></pre>
+    } 
+    tag "feed:date" do |tag|
+      format = (tag.attr['format'] || '%A, %B %d, %Y') 
+      if date = tag.locals.item.date
+        date.strftime(format)
+      end
+    end
+
+ desc %{
+    Display the creator of the rss feed item
+    
+    *Usage:*
+
+    <pre><code><r:feed:creator/></code></pre>
+    } 
+    tag "feed:creator" do |tag|
+      tag.locals.item.creator
+    end
+
+end
+  

data/lib/tasks/rss_reader_extension_tasks.rake

@@ -0,0 +1,47 @@
+namespace :radiant do
+  namespace :extensions do
+    namespace :rss_reader do
+      
+      desc "Runs the migration of the Rss Reader extension"
+      task :migrate => :environment do
+        require 'radiant/extension_migrator'
+        if ENV["VERSION"]
+          RssReaderExtension.migrator.migrate(ENV["VERSION"].to_i)
+          Rake::Task['db:schema:dump'].invoke
+        else
+          RssReaderExtension.migrator.migrate
+          Rake::Task['db:schema:dump'].invoke
+        end
+      end
+      
+      desc "Copies public assets of the Rss Reader to the instance public/ directory."
+      task :update => :environment do
+        is_svn_or_dir = proc {|path| path =~ /\.svn/ || File.directory?(path) }
+        puts "Copying assets from RssReaderExtension"
+        Dir[RssReaderExtension.root + "/public/**/*"].reject(&is_svn_or_dir).each do |file|
+          path = file.sub(RssReaderExtension.root, '')
+          directory = File.dirname(path)
+          mkdir_p RAILS_ROOT + directory, :verbose => false
+          cp file, RAILS_ROOT + path, :verbose => false
+        end
+      end  
+      
+      desc "Syncs all available translations for this ext to the English ext master"
+      task :sync => :environment do
+        # The main translation root, basically where English is kept
+        language_root = RssReaderExtension.root + "/config/locales"
+        words = TranslationSupport.get_translation_keys(language_root)
+        
+        Dir["#{language_root}/*.yml"].each do |filename|
+          next if filename.match('_available_tags')
+          basename = File.basename(filename, '.yml')
+          puts "Syncing #{basename}"
+          (comments, other) = TranslationSupport.read_file(filename, basename)
+          words.each { |k,v| other[k] ||= words[k] }  # Initializing hash variable as empty if it does not exist
+          other.delete_if { |k,v| !words[k] }         # Remove if not defined in en.yml
+          TranslationSupport.write_file(filename, basename, comments, other)
+        end
+      end
+    end
+  end
+end

data/radiant-rss_reader-extension.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "radiant-rss_reader-extension"
+
+Gem::Specification.new do |s|
+  s.name        = "radiant-rss_reader-extension"
+  s.version     = RadiantRssReaderExtension::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = RadiantRssReaderExtension::AUTHORS
+  s.email       = RadiantRssReaderExtension::EMAIL
+  s.homepage    = RadiantRssReaderExtension::URL
+  s.summary     = RadiantRssReaderExtension::SUMMARY
+  s.description = RadiantRssReaderExtension::DESCRIPTION
+
+  # Define gem dependencies here.
+  # Don't include a dependency on radiant itself: it causes problems when radiant is in vendor/radiant.
+  s.add_dependency "ruby-feedparser", "0.7.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"]
+end

data/rss_reader_extension.rb

@@ -0,0 +1,13 @@
+require "radiant-rss_reader-extension"
+
+class RssReaderExtension < Radiant::Extension
+  version     RadiantRssReaderExtension::VERSION
+  description RadiantRssReaderExtension::DESCRIPTION
+  url         RadiantRssReaderExtension::URL
+
+  def activate
+    cache_dir = ActionController::Base.page_cache_directory
+    Dir.mkdir(cache_dir) unless File.exist?(cache_dir)
+    Page.send :include, RssReader
+  end
+end

data/spec/spec.opts

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

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+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"
+
+Dataset::Resolver.default << (File.dirname(__FILE__) + "/datasets")
+# Include any datasets from loaded extensions
+Radiant::Extension.descendants.each do |extension|
+  if File.directory?(extension.root + "/spec/datasets")
+    Dataset::Resolver.default << (extension.root + "/spec/datasets")
+  end
+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 = RAILS_ROOT + '/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

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification 
+name: radiant-rss_reader-extension
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: 
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Andrew vonderLuft
+- Loren Johnson
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2014-07-31 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  type: :runtime
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        - 7
+        - 0
+        version: 0.7.0
+  version_requirements: *id001
+  prerelease: false
+  name: ruby-feedparser
+description: This extension uses the ruby-feedparser gem to read external RSS feeds, cache them, and easily display them in your pages.
+email: 
+- avonderluft@avlux.net
+- loren@hellovenado.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- config/initializers/radiant_config.rb
+- config/locales/en.yml
+- config/routes.rb
+- cucumber.yml
+- features/support/env.rb
+- features/support/paths.rb
+- lib/radiant-rss_reader-extension.rb
+- lib/rss_reader.rb
+- lib/tasks/rss_reader_extension_tasks.rake
+- radiant-rss_reader-extension.gemspec
+- Rakefile
+- README.md
+- rss_reader_extension.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+homepage: https://github.com/radiant/radiant-rss_reader-extension
+licenses: []
+
+post_install_message: 
+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: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: RSS Reader for Radiant CMS
+test_files: 
+- spec/spec.opts
+- spec/spec_helper.rb
+- features/support/env.rb
+- features/support/paths.rb