nelumba 0.0.13

data/lib/nelumba/atom/source.rb

@@ -0,0 +1,179 @@
+require 'nelumba/person'
+require 'nelumba/category'
+require 'nelumba/generator'
+
+require 'nelumba/atom/generator'
+require 'nelumba/atom/category'
+require 'nelumba/atom/person'
+require 'nelumba/atom/link'
+
+module Nelumba
+  require 'atom'
+
+  module Atom
+    # This class represents an OStatus Feed object.
+    class Source < ::Atom::Source
+      require 'open-uri'
+
+      include ::Atom::SimpleExtensions
+
+      # The XML namespace that identifies the conforming specification.
+      ACTIVITY_NAMESPACE = 'http://activitystrea.ms/spec/1.0/'
+
+      # The XML namespace the specifies this content.
+      POCO_NAMESPACE = 'http://portablecontacts.net/spec/1.0'
+
+      namespace ::Atom::NAMESPACE
+
+      add_extension_namespace :poco, POCO_NAMESPACE
+      add_extension_namespace :activity, ACTIVITY_NAMESPACE
+      element :id, :rights, :icon, :logo
+      element :generator, :class => Nelumba::Atom::Generator
+      element :title, :class => ::Atom::Content
+      element :subtitle, :class => ::Atom::Content
+      element :published, :class => Time, :content_only => true
+      element :updated, :class => Time, :content_only => true
+      elements :links, :class => ::Atom::Link
+      elements :authors, :class => Nelumba::Atom::Author
+      elements :contributors, :class => Nelumba::Atom::Person
+      elements :categories, :class => Nelumba::Atom::Category
+
+      # Creates an Atom generator for the given Nelumba::Feed.
+      def self.from_canonical(obj)
+        hash = obj.to_hash
+        hash.delete :items
+        hash.delete :author
+        hash.delete :total_items
+        hash.delete :display_name
+        hash.delete :content
+        hash.delete :summary
+
+        hash.delete :text
+        hash.delete :html
+
+        # Ensure that the generator is encoded.
+        if hash[:generator]
+          hash[:generator] = Nelumba::Atom::Generator.from_canonical(hash[:generator])
+        end
+
+        hash[:links] ||= []
+
+        if hash[:salmon_url]
+          hash[:links] << ::Atom::Link.new(:rel => "salmon", :href => hash[:salmon_url])
+        end
+        hash.delete :salmon_url
+
+        if hash[:url]
+          hash[:links] << ::Atom::Link.new(:rel => "self", :href => hash[:url])
+        end
+        hash.delete :url
+
+        hash[:hubs].each {|h|
+          hash[:links] << ::Atom::Link.new(:rel => "hub", :href => h)
+        }
+        hash.delete :hubs
+
+        hash[:authors].map! {|a|
+          Nelumba::Atom::Author.from_canonical(a)
+        }
+
+        hash[:contributors].map! {|a|
+          Nelumba::Atom::Person.from_canonical(a)
+        }
+
+        hash[:categories].map! {|c|
+          Nelumba::Atom::Category.from_canonical(c)
+        }
+
+        # title/subtitle content type
+        node = XML::Node.new("title")
+        node['type'] = hash[:title_type] if hash[:title_type]
+        node << hash[:title]
+
+        xml = XML::Reader.string(node.to_s)
+        xml.read
+        hash[:title] = ::Atom::Content.parse(xml)
+        hash.delete :title_type
+
+        hash[:id] = hash[:uid]
+        hash.delete :uid
+
+        if hash[:subtitle]
+          node = XML::Node.new("subtitle")
+          node['type'] = hash[:subtitle_type] if hash[:subtitle_type]
+          node << hash[:subtitle]
+
+          xml = XML::Reader.string(node.to_s)
+          xml.read
+          hash[:subtitle] = ::Atom::Content.parse(xml)
+        else
+          hash.delete :subtitle
+        end
+        hash.delete :subtitle_type
+
+        self.new(hash)
+      end
+
+      def to_canonical
+        generator = nil
+        generator = self.generator.to_canonical if self.generator
+
+        salmon_url = nil
+        if self.link('salmon').any?
+          salmon_url = self.link('salmon').first.href
+        end
+
+        url = self.url
+
+        categories = self.categories.map(&:to_canonical)
+
+        Nelumba::Feed.new(:title         => self.title,
+                        :title_type    => self.title ? self.title.type : nil,
+                        :subtitle      => self.subtitle,
+                        :subtitle_type => self.subtitle ? self.subtitle.type : nil,
+                        :id            => self.id,
+                        :url           => url,
+                        :categories    => categories,
+                        :icon          => self.icon,
+                        :logo          => self.logo,
+                        :rights        => self.rights,
+                        :published     => self.published,
+                        :updated       => self.updated,
+                        :authors       => self.authors.map(&:to_canonical),
+                        :contributors  => self.contributors.map(&:to_canonical),
+                        :hubs          => self.hubs,
+                        :salmon_url    => salmon_url,
+                        :generator     => generator)
+      end
+
+      # Returns an array of ::Atom::Link instances for all link tags
+      # that have a rel equal to that given by attribute.
+      #
+      # For example:
+      #   link(:hub).first.href -- Gets the first link tag with rel="hub" and
+      #                            returns the contents of the href attribute.
+      #
+      def link(attribute)
+        links.find_all { |l| l.rel == attribute.to_s }
+      end
+
+      # Returns an array of URLs for each hub link tag.
+      def hubs
+        link('hub').map { |link| link.href }
+      end
+
+      # Returns a string of the url for this feed.
+      def url
+        if links.alternate
+          links.alternate.href
+        elsif links.self
+          links.self.href
+        else
+          links.map.each do |l|
+            l.href
+          end.compact.first
+        end
+      end
+    end
+  end
+end

data/lib/nelumba/atom/thread.rb

@@ -0,0 +1,60 @@
+module Nelumba
+  module Atom
+    # This will parse the Thread Atom extension
+    class Thread
+      require 'xml/libxml'
+      require 'atom/xml/parser.rb'
+
+      include ::Atom::Xml::Parseable
+      attribute :ref, :type, :source
+      uri_attribute :href
+
+      def initialize(o)
+        case o
+        when XML::Reader
+          if current_node_is?(o, 'in-reply-to')
+            parse(o, :once => true)
+          else
+            raise ArgumentError, "Thread created with node other than thr:in-reply-to: #{o.name}"
+          end
+        when Hash
+          [:href, :ref, :type, :source].each do |attr|
+            self.send("#{attr}=", o[attr])
+          end
+        else
+          raise ArgumentError, "Don't know how to handle #{o}"
+        end
+      end
+
+      def length=(v)
+        @length = v.to_i
+      end
+
+      def to_s
+        self.href
+      end
+
+      def ==(o)
+        o.respond_to?(:href) && o.href == self.href
+      end
+
+      def self.from_canonical(obj)
+        self.new(obj.to_hash)
+      end
+
+      def to_canonical
+        Nelumba::Activity.new(:url => self.href,
+                            :id  => self.ref)
+      end
+
+      def info
+        {
+          :ref    => self.ref,
+          :type   => self.type,
+          :source => self.source,
+          :href   => self.href
+        }
+      end
+    end
+  end
+end

data/lib/nelumba/audio.rb

@@ -0,0 +1,39 @@
+module Nelumba
+  class Audio
+    include Nelumba::Object
+
+    # A fragment of HTML markup that, when embedded within another HTML page,
+    # provides an interactive user-interface for viewing or listening to the
+    # audio stream.
+    attr_reader :embed_code
+
+    # A MediaLink to the audio content itself.
+    attr_reader :stream
+
+    # Creates a new Audio activity object.
+    def initialize(options = {})
+      super options
+
+      @embed_code = options[:embed_code]
+      @stream     = options[:stream]
+    end
+
+    # Returns a hash of all relevant fields.
+    def to_hash
+      {
+        :embed_code => @embed_code,
+        :stream     => @stream
+      }.merge(super)
+    end
+
+    # Returns a hash of all relevant fields with JSON activity streams
+    # conventions.
+    def to_json_hash
+      {
+        :objectType => "audio",
+        :embedCode  => @embed_code,
+        :stream     => @stream
+      }.merge(super)
+    end
+  end
+end

data/lib/nelumba/badge.rb

@@ -0,0 +1,11 @@
+module Nelumba
+  class Badge
+    include Nelumba::Object
+
+    def to_json_hash
+      {
+        :objectType => "badge"
+      }.merge(super)
+    end
+  end
+end

data/lib/nelumba/binary.rb

@@ -0,0 +1,52 @@
+module Nelumba
+  class Binary
+    include Nelumba::Object
+
+    attr_reader :data
+    attr_reader :length
+
+    attr_reader :md5
+    attr_reader :compression
+
+    attr_reader :file_url
+    attr_reader :mime_type
+
+    def initialize(options = {}, &blk)
+      init(options, &blk)
+    end
+
+    def init(options = {}, &blk)
+      super(options, &blk)
+
+      @data        = options[:data]
+      @compression = options[:compression]
+      @md5         = options[:md5]
+      @file_url    = options[:file_url]
+      @mime_type   = options[:mime_type]
+      @length      = options[:length]
+    end
+
+    def to_hash
+      {
+        :data        => @data,
+        :compression => @compression,
+        :md5         => @md5,
+        :file_url    => @file_url,
+        :mime_type   => @mime_type,
+        :length      => @length
+      }.merge(super)
+    end
+
+    def to_json_hash
+      {
+        :objectType  => "binary",
+        :data        => @data,
+        :compression => @compression,
+        :md5         => @md5,
+        :fileUrl     => @file_url,
+        :mimeType    => @mime_type,
+        :length      => @length
+      }.merge(super)
+    end
+  end
+end

data/lib/nelumba/bookmark.rb

@@ -0,0 +1,30 @@
+module Nelumba
+  class Bookmark
+    include Nelumba::Object
+
+    attr_reader :target_url
+
+    def initialize(options = {}, &blk)
+      init(options, &blk)
+    end
+
+    def init(options = {}, &blk)
+      super(options, &blk)
+
+      @target_url = options[:target_url]
+    end
+
+    def to_hash
+      {
+        :target_url => @target_url
+      }.merge(super)
+    end
+
+    def to_json_hash
+      {
+        :objectType => "bookmark",
+        :targetUrl  => @target_url
+      }.merge(super)
+    end
+  end
+end

data/lib/nelumba/category.rb

@@ -0,0 +1,49 @@
+module Nelumba
+  # This element conveys information about a category associated with an entry
+  # or feed. There is no defined meaning to the content according to the Atom
+  # specification.
+  class Category
+    # Holds the base URI for relative URIs contained in scheme.
+    attr_reader :base
+
+    # Holds the language of term and label, when it exists. The language
+    # should be specified as RFC 3066 as either 2 or 3 letter codes.
+    # For example: 'en' for English or more specifically 'en-us'
+    attr_reader :lang
+
+    # Holds the optional scheme used for categorization.
+    attr_reader :scheme
+
+    # Holds the string identifying the category to which the entry or
+    # feed belongs.
+    attr_reader :term
+
+    # Holds the string that provides a human-readable label for display in
+    # end-user applications. The content of this field is language sensitive.
+    attr_reader :label
+
+    # Create a Category to apply to a feed or entry.
+    def initialize(options = {})
+      init(options)
+    end
+
+    def init(options = {})
+      @base = options[:base]
+      @lang = options[:lang]
+      @scheme = options[:scheme]
+      @term = options[:term]
+      @label = options[:label]
+    end
+
+    # Yields a Hash that represents this category.
+    def to_hash
+      {
+        :base => @base,
+        :lang => @lang,
+        :scheme => @scheme,
+        :term => @term,
+        :label => @label
+      }
+    end
+  end
+end

data/lib/nelumba/collection.rb

@@ -0,0 +1,34 @@
+module Nelumba
+  class Collection
+    include Nelumba::Object
+
+    attr_reader :items
+    attr_reader :total_items
+
+    def initialize(options = {}, &blk)
+      init(options, &blk)
+    end
+
+    def init(options = {}, &blk)
+      super(options, &blk)
+
+      @items       = options[:items] || []
+      @total_items = options[:total_items] || @items.count
+    end
+
+    def to_hash
+      {
+        :items       => (self.items || []).dup,
+        :total_items => self.total_items || self.items.count
+      }.merge(super)
+    end
+
+    def to_json_hash
+      {
+        :objectType => "collection",
+        :items      => (self.items || []).dup,
+        :totalItems => self.total_items || self.items.count
+      }.merge(super)
+    end
+  end
+end