hootenanny 0.0.1 → 0.1.0

data/lib/hootenanny/feed/json_feed.rb

@@ -0,0 +1,48 @@
+require 'json'
+require 'hootenanny/feed'
+require 'hootenanny/feed/json_feed_item'
+
+module  Hootenanny
+class   Feed
+class   JSONFeed < ::Hootenanny::Feed
+
+  def items
+    @items ||= content.fetch('items', []).map { |i| Hootenanny::Feed::JSONFeedItem.new i }
+  end
+
+  def content_type
+    'application/json'
+  end
+
+  def to_s
+    @to_s ||= -> do
+      content['items'] = items.map(&:content)
+
+      JSON.dump(content)
+    end.call
+  end
+
+  def content
+    @content
+  end
+
+  def content=(content)
+    @content = coerce_content(content)
+  rescue JSON::ParserError => e
+    raise Hootenanny::Feed::ParseError.wrap(e)
+  end
+
+  private
+
+  def coerce_content(content)
+    if content.is_a? String
+      JSON.parse(content)
+    elsif content.is_a? Hash
+      content.inject({}) { |hash, pair| hash[pair[0].to_s] = pair[1]; hash }
+    else
+      raise JSON::ParserError.new("Do not know how to parse '#{content}'")
+    end
+  end
+end
+end
+end

data/lib/hootenanny/feed/json_feed_item.rb

@@ -0,0 +1,8 @@
+require 'hootenanny/feed/feed_item'
+
+module  Hootenanny
+class   Feed
+class   JSONFeedItem < ::Hootenanny::Feed::FeedItem
+end
+end
+end

data/lib/hootenanny/feed/null_feed.rb

@@ -0,0 +1,27 @@
+module  Hootenanny
+class   Feed
+class   NullFeed < ::Hootenanny::Feed
+
+  def items
+    []
+  end
+
+  def content_type
+    ''
+  end
+
+  def -(other)
+    other
+  end
+
+  def +(other)
+    other
+  end
+
+  protected
+
+  def content=(content)
+  end
+end
+end
+end

data/lib/hootenanny/feed/rss_feed.rb

@@ -0,0 +1,52 @@
+require 'rss'
+require 'hootenanny/feed'
+require 'hootenanny/feed/rss_feed_item'
+
+module  Hootenanny
+class   Feed
+class   RSSFeed < ::Hootenanny::Feed
+
+  def items
+    @items ||= content.items.map { |i| Hootenanny::Feed::RSSFeedItem.new i }
+  end
+
+  def content_type
+    'application/rss+xml'
+  end
+
+  def to_s
+    @to_s ||= -> do
+      item_string   = items.map { |item| item.content.to_s }.join('')
+
+      feed_string = content.to_s
+      feed_string.gsub!(%r{<item>.*</item>}m, item_string)
+
+      feed_string
+    end.call
+  end
+
+  def content
+    @content
+  end
+
+  def content=(content)
+    @content = coerce_content(content)
+  rescue RSS::Error => e
+    raise Hootenanny::Feed::ParseError.wrap(e)
+  end
+
+  private
+
+  def coerce_content(content)
+    if content.is_a? String
+      RSS::Parser.parse(content) ||
+      RSS::Rss.new('2.0')
+    elsif content.is_a? RSS::Rss
+      content
+    else
+      raise RSS::Error.new("Do not know how to parse '#{content}'")
+    end
+  end
+end
+end
+end

data/lib/hootenanny/feed/rss_feed_item.rb

@@ -0,0 +1,8 @@
+require 'hootenanny/feed/feed_item'
+
+module  Hootenanny
+class   Feed
+class   RSSFeedItem < ::Hootenanny::Feed::FeedItem
+end
+end
+end

data/lib/hootenanny/feed_store.rb

@@ -0,0 +1,30 @@
+require 'active_support/inflector'
+require 'hootenanny/feed_store/file_feed_store'
+require 'hootenanny/feed_store/web_feed_store'
+
+module  Hootenanny
+class   FeedStore
+
+  def self.fetch(url, options = {})
+    storage_type = options.fetch(:location, :web)
+    feed_store   = infer(type: storage_type)
+
+    feed_store.fetch(url)
+  end
+
+  def self.infer(options = {})
+    storage_type  = options.fetch(:type)
+    storage_class = from_type(storage_type)
+
+    storage_class.new(options)
+  rescue KeyError => e
+    raise Hootenanny::FeedStore::InferenceError.wrap(e)
+  end
+
+  def self.from_type(type)
+    "Hootenanny::FeedStore::#{type.to_s.camelize}FeedStore".constantize
+  rescue NameError
+    raise Hootenanny::FeedStore::UnknownStorageTypeError
+  end
+end
+end

data/lib/hootenanny/feed_store/file_feed_store.rb

@@ -0,0 +1,55 @@
+require 'faraday'
+require 'hootenanny/uri'
+require 'hootenanny/feed'
+require 'hootenanny/feed/file'
+
+module  Hootenanny
+class   FeedStore
+class   FileFeedStore
+  def initialize(options = {})
+    self.feed_file = options.fetch(:location)
+  end
+
+  def fetch(options = {})
+    self.url  = options.fetch(:url)
+    feed_file = self.feed_file << options[:path] << url_file_glob
+
+    Hootenanny::Feed.infer(feed_file.read,
+                           type: feed_file.type)
+  end
+
+  def store(options = {})
+    self.url  = options.fetch(:url)
+    feed      = options.fetch(:feed)
+    feed_type = feed.type
+
+    feed_file = self.feed_file << options[:path] << "#{url}.#{feed_type}"
+
+    feed_file.write(feed)
+  end
+
+  protected
+
+  attr_reader :feed_file,
+              :url
+
+  private
+
+  def url_file_glob
+    if @url.nil? || @url.to_s == ''
+      '*.*'
+    else
+      "#{@url}.*"
+    end
+  end
+
+  def url=(other_url)
+    @url = Hootenanny::URI.parse(other_url.to_s).to_digest
+  end
+
+  def feed_file=(location)
+    @feed_file = Hootenanny::Feed::File.new(location)
+  end
+end
+end
+end

data/lib/hootenanny/feed_store/web_feed_store.rb

@@ -0,0 +1,42 @@
+require 'faraday'
+require 'hootenanny/feed'
+
+module  Hootenanny
+class   FeedStore
+class   WebFeedStore
+  CONTENT_TYPE_MAPPINGS = {
+    'application/rss+xml'  => 'RSS',
+    'application/atom+xml' => 'Atom',
+    'application/json'     => 'JSON',
+  }
+
+  def initialize(options = {})
+  end
+
+  def fetch(options = {})
+    self.url = options.fetch(:url)
+
+    Hootenanny::Feed.infer(content,
+                           type: feed_serialization_type)
+  end
+
+  protected
+
+  attr_accessor :url
+
+  private
+
+  def content
+    response.body
+  end
+
+  def feed_serialization_type
+    CONTENT_TYPE_MAPPINGS.fetch(response.env[:response_headers][:content_type])
+  end
+
+  def response
+    @response ||= Faraday.get(url.to_s)
+  end
+end
+end
+end

data/lib/hootenanny/hub.rb

@@ -1,41 +1,135 @@
-require 'hootenanny/subscription'
+require 'hootenanny/request'
+require 'hootenanny/correspondent'
+require 'hootenanny/publish_notification'
+require 'hootenanny/publish_notification_expiration_policy'
 
+###
+# Public: The class that provides the interface for all of the PubSubHubbub
+# server functionaliity.
+#
+# ## Subscribing to a Feed ##
+#
+# In order to subscribe to a topic URI, the subscription request must be passed
+# in.  This object contains all of the information necessary to actually apply
+# the subscription between the subscriber URI and the topic URI.
+#
+# ```ruby
+# request = Hootenanny::Hub.request(request_attribute_hash)
+#
+# Hootenanny::Hub.subscribe(request)
+# ```
+#
+# ## Generating a Request ##
+#
+# Before an action may be taken, the proper request must be generated from all
+# of the disparate information.  Once generated, it can be passed to other
+# methods on the class to perform that action.
+#
+# `:type` and `:action` are required options for all requests, other requests
+# may have additional required options, depending on the `:type` passed in.  For
+# example, a subscription request requires a `:callback` and an `:action`.
+#
+# ```ruby
+# Hootenanny::Hub.request(type:     :subscription,
+#                         action:   :create,
+#                         callback: 'http://example.com/callback',
+#                         topic:    'http://example.org/topic')
+# ```
+#
+# ## Notifying of a Content Update
+#
+# In order to remove the need for the hub to have to poll each of its
+# publishers, each publisher can create a notification on the hub so that the
+# hub can handle disseminating that information to its various subscribers.
+#
+# ```ruby
+# Hootenanny::Hub.notify_of_publication(url: 'http://mytopic')
+# ```
+#
 module  Hootenanny
 class   Hub
 
   ###
-  # Public: Subscribes the given callback to the given topic.  Whenever the
-  # given topic is updated, the hub will send all updates to the given callback
-  # URL.
+  # Public: Subscribes a subscriber to a topic based on the information defined
+  # in a subscription request.
   #
   # This method is idempotent.  If a subscription already exists, it will be
   # reused and sent back without notifying the user of that fact.
   #
-  # callback - A String or URI representing the callback URI which should be
-  #            sent updates to the given topic.  Whenever changes are discovered
-  #            to the topic URL's feed (see below), those changes will be sent
-  #            to this callback URI.
-  # options  - A Hash of options
+  # If the subscription does not already exist, it will be verified against the
+  # callback URL.  If all is ok, a subscription will be created, if not, an
+  # error with details will be returned.
   #
-  #            :to - The topic which should be subscribed to.  This should be
-  #                  a String or URI representing the URI which will deliver the
-  #                  activities for a given topic/item/resource.
+  # request - Any object which responds to #apply.  Typically this should be
+  #           a Hootenanny::Request::Subscription.
   #
-  #                  For example if I have a site which handles blogs, I may
-  #                  expose a feed for all of the activity on the blog at:
+  # Returns an indeterminate object (based on the request passed in) but is
+  #   typically a Hootenanny::Subscription.
+  # Raises Hootenanny::SubscriptionAssignmentError with a message describing the
+  #   problem
+  #
+  def self.subscribe(request)
+    request.apply
+  end
+
+  ###
+  # Public: Notifies the hub that topic has had its content updated since the
+  # last time the content was pulled.
   #
-  #                  http://www.example.com/activities/blog/123
+  # This method is idempotent.  If a notification already exists, it will be
+  # reused and sent back without notifying the user of that fact.
   #
-  # Returns a Hootenanny::Subscription
-  # Raises Hootenanny::SubscriptionAssignmentError with a message describing the
+  # If all is ok, a notification will be created, if not, an error with details
+  # will be returned.
+  #
+  # request - Any object which responds to #apply.  Typically this should be
+  #           a Hootenanny::Request::PublishNotification.
+  #
+  # Returns an indeterminate object (based on the request passed in) but is
+  #   typically a Hootenanny::PublishNotification.
+  # Raises Hootenanny::PublishNotificationError with a message describing the
   #   problem
   #
-  def self.subscribe(callback, options = {})
-    callback = callback.dup
-    topic    = options.fetch(:to).dup
+  def self.notify_of_publication(request)
+    request.apply
+  end
+
+  def self.broadcast
+    Hootenanny::PublishNotification.each_unprocessed do |notification|
+      if Hootenanny::Correspondent.broadcast(notification.topic)
+        notification.process
+      else
+        Hootenanny::PublishNotificationExpirationPolicy.apply notification
+      end
+    end
+  end
 
-    Hootenanny::Subscription.assign(subscriber: callback,
-                                    to:         topic)
+  ###
+  # Public: Generates a request of varying types which can be used to perform
+  # actions such as subscribing to a topic.
+  #
+  # This method has zero side-effects and is only utilized to prepare a request.
+  #
+  # options - A Hash of options which can vary based on the type of request that
+  #           is being... requested.
+  #
+  #           :type     - The type of request (eg: :subscription)
+  #           :action   - The action to be performed when the request is
+  #                       applied. This can vary based on the type of request
+  #                       being created.
+  #           :callback - Used for :subscription requests.  Is a URI which
+  #                       should be notified when the topic that it is
+  #                       interested in, is updated.
+  #           :topic    - Used for :subscription requests.  Is a URI which
+  #                       represents all of the items which the subscriber is
+  #                       interested in.
+  #
+  # Returns an indeterminate object (based on the type of request that is
+  #   generated, but all of them will inherit from Hootenanny::Request
+  # Raises a Hootenanny::Request::BuildError if any problems are encountered
+  #
+  def self.request(options = {})
+    Hootenanny::Request.build(options)
   end
 end
 end

data/lib/hootenanny/publish_notification_expiration_policy.rb

@@ -0,0 +1,17 @@
+require 'hootenanny/configuration'
+
+module  Hootenanny
+class   PublishNotificationExpirationPolicy
+  def self.apply(notification)
+    if notification.updated_at < expiration_threshold
+      notification.expire
+    end
+  end
+
+  private
+
+  def self.expiration_threshold
+    Hootenanny.config.default_publish_notification_expiration_threshold
+  end
+end
+end