namelessjon-feed_me 0.0.2

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Jonas Nicklas
+
+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/README

@@ -0,0 +1,23 @@
+Feed Me
+=======
+
+Feed Me is a simple parser for RSS2 and Atom feed, adding other feed formats should be trivial. Feed Me is pretty minimal and basically only does translation/cleanup from different feed formats to a consistent API. It is designed to be minimal.
+
+Feed Me is built on the excellent Hpricot parser written by _why the lucky stiff.
+
+Use it like this:
+
+    file = File.read('some_feed.atom')
+    
+    feed = FeedMe.parse(file)
+    
+    feed.title
+    feed.author.name
+    feed.entries.each do |entry|
+      entry.title
+      entry.content
+    end
+
+Check out the specs or lib/feed_me/consts.rb for the complete API.
+
+DISCLAIMER: This is very much alpha software, use at your own risk!

data/Rakefile

@@ -0,0 +1,76 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'spec/rake/spectask'
+
+file_list = FileList['spec/*_spec.rb']
+
+namespace :spec do
+  desc "Run all examples with RCov"
+  Spec::Rake::SpecTask.new('rcov') do |t|
+    t.spec_files = file_list
+    t.rcov = true
+    t.rcov_dir = "doc/coverage"
+    t.rcov_opts = ['--exclude', 'spec']
+  end
+  
+  desc "Generate an html report"
+  Spec::Rake::SpecTask.new('report') do |t|
+    t.spec_files = file_list
+    t.rcov_opts = ['--exclude', 'spec']
+    t.spec_opts = ["--format", "html:doc/reports/specs.html"]
+    t.fail_on_error = false
+  end
+
+end
+
+desc 'Default: run specs.'
+task :default => 'spec:rcov'
+
+PLUGIN = "feed_me"
+NAME = "feed_me"
+VERSION = "0.0.2"
+AUTHOR = ["Jonas Nicklas", "Jonathan Stott"]
+EMAIL = "jonas.nicklas@gmail.com"
+HOMEPAGE = "http://github.com/jnicklas/feed_me"
+SUMMARY = "Nice and simple RSS and atom feed parsing built on hpricot"
+
+spec = Gem::Specification.new do |s|
+  s.name = NAME
+  s.platform = Gem::Platform::RUBY
+  s.version = VERSION
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "LICENSE", 'TODO']
+  s.summary = SUMMARY
+  s.description = s.summary
+  s.authors = AUTHOR
+  s.email = EMAIL
+  s.homepage = HOMEPAGE
+  s.require_path = 'lib'
+  s.autorequire = PLUGIN
+  s.add_dependency('hpricot')
+  s.files = %w(LICENSE README Rakefile TODO) + Dir.glob("{lib,specs}/**/*")
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new(spec)
+rescue
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install namelessjon-jeweler -s http://gems.github.com"
+end
+
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end
+
+task :install => [:package] do
+  sh %{sudo gem install pkg/#{NAME}-#{VERSION}}
+end
+
+namespace :jruby do
+
+  desc "Run :package and install the resulting .gem with jruby"
+  task :install => :package do
+    sh %{#{SUDO} jruby -S gem install pkg/#{NAME}-#{Merb::VERSION}.gem --no-rdoc --no-ri}
+  end
+  
+end

data/TODO

@@ -0,0 +1,5 @@
+TODO:
+Fix LICENSE with your name
+Fix Rakefile with your name and contact info
+Add your code to lib/feed_me.rb
+Add your Merb rake tasks to lib/feed_me/merbtasks.rb

data/lib/feed_me/abstract_parser.rb

@@ -0,0 +1,114 @@
+class FeedMe::AbstractParser
+
+  class << self
+
+    attr_accessor :properties, :root_nodes
+
+    def build(xml, format, *args)
+      # in a world with activesupport this would have been written as
+      #   format_parser = (format.to_s.camelize + self.to_s).constantize
+      camelized_format = format.to_s.split('_').map{ |w| w.capitalize }.join('')
+      bare_class = self.to_s.split('::').last
+
+      begin
+        format_parser = FeedMe.const_get(camelized_format + bare_class)
+      rescue NameError
+      end
+
+      if format_parser.is_a?(Class) and format_parser.ancestors.include?(self)
+        return format_parser.new(xml, format, *args)
+      else
+        return self.new(xml, format, *args)
+      end
+
+    end
+
+  end
+
+  def initialize(xml, format)
+    self.xml = xml
+    self.format = format
+    self.properties = self.class.properties[self.format]
+
+    append_methods
+  end
+
+  def to_hash
+    hash = {}
+    self.properties.each do |method, p|
+      hash[method] = self.send(method)
+    end
+    return hash
+  end
+
+  attr_accessor :xml, :format, :properties
+
+  alias_method :root_node, :xml
+
+  protected
+
+  def fetch_rss_person(selector)
+    item = fetch(selector)
+    if(item)
+      email, name = item.split(/\s+/, 2)
+      name = name.match( /\((.*?)\)/ ).to_a[1] if name # strip parentheses
+    else
+      name, email = nil
+    end
+    FeedMe::SimpleStruct.new(:email => email, :name => name, :uri => nil)
+  end
+
+  def append_methods
+    self.properties.each do |method, p|
+      unless respond_to?(method)
+        block = get_proc_for_property(method, p)
+        # meta programming magic
+        (class << self; self; end).module_eval do
+          define_method method, &block
+        end
+      end
+    end
+  end
+
+  def get_proc_for_property(method, p)
+    if p.class == Array
+      return caching_proc(method, &proc { fetch("/#{p[0]}", root_node, p[1].to_sym) })
+    elsif p.class == Hash
+      return caching_proc(method, &proc { FeedMe::FeedStruct.new(root_node, p) })
+    elsif p != :undefined
+      return caching_proc(method, &proc { fetch("/#{p}", root_node) })
+    else
+      return proc { nil }
+    end
+  end
+
+  def caching_proc(name, &block)
+    proc do
+      ivar = instance_variable_get("@#{name}")
+      unless ivar
+        result = yield
+        instance_variable_set("@#{name}", result)
+        return result
+      end
+    end
+  end
+
+  def fetch(selector, search_in = xml, method = :inner_html)
+    item = search_in.at(selector)
+
+    self.try("extract_" + method.to_s, item) if item
+  end
+
+  def extract_inner_html(item)
+    item.inner_html
+  end
+
+  def extract_href(item)
+    item[:href]
+  end
+
+  def extract_time(item)
+    Time.parse(item.inner_html).utc
+  end
+
+end

data/lib/feed_me/consts.rb

@@ -0,0 +1,68 @@
+module FeedMe
+
+  ROOT_NODES = {
+    :atom => "//feed[@xmlns='http://www.w3.org/2005/Atom']",
+    :rss2 => "//rss[@version=2.0]/channel"
+  }
+
+  FEED_PROPERTIES = {
+    :atom => {
+      :title => :title,
+      :updated_at => [:updated, :time],
+      :feed_id => :id,
+      :url => ["link[@rel=alternate]", :href],
+      :href => ["link[@rel=self]", :href],
+      :description => :subtitle,
+      :generator => :generator,
+      :author => {
+        :email => 'author/email',
+        :name => 'author/name',
+        :uri => 'author/uri'
+      },
+      :entries => :special
+    },
+    :rss2 => {
+      :title => :title,
+      :updated_at => [:lastBuildDate, :time],
+      :feed_id => :undefined,
+      :url => :link,
+      :href => :undefined,
+      :description => :description,
+      :generator => :generator,
+      :author => :special,
+      :entries => :special
+    }
+  }
+
+  ITEM_PROPERTIES = {
+    :atom => {
+      :title => :title,
+      :updated_at => [:updated, :time],
+      :item_id => :id,
+      :url => ["link[@rel=alternate]", :href],
+      :content => :content,
+      :author => {
+        :email => 'author/email',
+        :name => 'author/name',
+        :uri => 'author/uri'
+      }
+    },
+    :rss2 => {
+      :title => :title,
+      :updated_at => [:pubDate, :time],
+      :item_id => :guid,
+      :url => :link,
+      :content => :description,
+      :author => :special
+    }
+  }
+
+  AUTHOR_PROPERTIES = {
+    :atom => {
+      :name => :name,
+      :uri => :uri,
+      :email => :email
+    }
+  }
+
+end

data/lib/feed_me/feed_parser.rb

@@ -0,0 +1,57 @@
+module FeedMe
+
+  class FeedParser < AbstractParser
+
+    self.properties = FEED_PROPERTIES
+
+    class << self
+
+      def open(file)
+        self.parse(Kernel.open(file).read)
+      end
+
+      # parses the passed feed and identifeis what kind of feed it is
+      # then returns a parser object
+      def parse(feed)
+        xml = Hpricot.XML(feed)
+
+        root_node, format = self.identify(xml)
+        self.build(root_node, format)
+      end
+
+      protected
+
+      def identify(xml)
+        FeedMe::ROOT_NODES.each do |f, s|
+          item = xml.at(s)
+          return item, f if item
+        end
+      end
+
+    end
+  end
+
+  class AtomFeedParser < FeedParser
+    self.properties = FEED_PROPERTIES
+
+    def entries
+      xml.search('entry').map do |el|
+        ItemParser.build(el, self.format, self)
+      end
+    end
+  end
+
+  class Rss2FeedParser < FeedParser
+    self.properties = FEED_PROPERTIES
+
+    def entries
+      xml.search('item').map do |el|
+        ItemParser.build(el, self.format, self)
+      end
+    end
+
+    def author
+      fetch_rss_person("managingEditor")
+    end
+  end
+end

data/lib/feed_me/feed_struct.rb

@@ -0,0 +1,13 @@
+module FeedMe
+
+  class FeedStruct < AbstractParser
+
+    def initialize(xml, properties)
+      self.xml = xml
+      self.properties = properties
+      append_methods
+    end
+
+  end
+
+end

data/lib/feed_me/item_parser.rb

@@ -0,0 +1,25 @@
+module FeedMe
+
+  class ItemParser < AbstractParser
+
+    self.properties = ITEM_PROPERTIES
+
+    attr_accessor :feed
+
+    def initialize(xml, format, feed)
+      super(xml, format)
+      self.feed = feed
+    end
+
+  end
+
+  class Rss2ItemParser < ItemParser
+
+    self.properties = ITEM_PROPERTIES
+
+    def author
+      fetch_rss_person("author")
+    end
+
+  end
+end

data/lib/feed_me/merbtasks.rb

@@ -0,0 +1,6 @@
+namespace :feed_me do
+  desc "Do something for feed_me"
+  task :default do
+    puts "feed_me doesn't do anything"
+  end
+end

data/lib/feed_me/simple_struct.rb

@@ -0,0 +1,15 @@
+module FeedMe
+
+  class SimpleStruct
+
+    def initialize(hash = {})
+      (class << self; self; end).module_eval do
+        hash.each do |method, result|
+          define_method( method ) { result }
+        end
+      end
+    end
+
+  end
+
+end

data/lib/feed_me.rb

@@ -0,0 +1,34 @@
+# make sure we're running inside Merb
+if defined?(Merb::Plugins)
+  dependency 'hpricot'
+else
+  require 'rubygems'
+  require 'hpricot'
+end
+require 'time'
+
+unless nil.respond_to? :try
+  # the ultimate duck
+  class Object
+    def try(method, *args)
+      self.send(method, *args)
+    rescue NoMethodError
+      nil
+    end
+  end
+end
+
+module FeedMe
+  def self.parse(feed)
+    FeedMe::FeedParser.parse(feed)
+  end
+
+  def self.open(file)
+    FeedMe::FeedParser.parse(file)
+  end
+end
+
+['consts', 'abstract_parser', 'feed_struct', 'simple_struct',
+  'feed_parser', 'item_parser'].each do |f|
+  require File.join(File.dirname(__FILE__), 'feed_me', f)
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: namelessjon-feed_me
+version: !ruby/object:Gem::Version 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Jonas Nicklas
+- Jonathan Stott
+autorequire: feed_me
+bindir: bin
+cert_chain: []
+
+date: 2008-11-16 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hpricot
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Nice and simple RSS and atom feed parsing built on hpricot
+email: jonas.nicklas@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+- TODO
+files: 
+- LICENSE
+- README
+- Rakefile
+- TODO
+- lib/feed_me
+- lib/feed_me/abstract_parser.rb
+- lib/feed_me/consts.rb
+- lib/feed_me/feed_parser.rb
+- lib/feed_me/feed_struct.rb
+- lib/feed_me/item_parser.rb
+- lib/feed_me/merbtasks.rb
+- lib/feed_me/simple_struct.rb
+- lib/feed_me.rb
+has_rdoc: true
+homepage: http://github.com/jnicklas/feed_me
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Nice and simple RSS and atom feed parsing built on hpricot
+test_files: []
+