nelumba 0.0.13

data/lib/nelumba/service.rb

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

data/lib/nelumba/subscription.rb

@@ -0,0 +1,117 @@
+module Nelumba
+  class Subscription
+    require 'net/http'
+    require 'uri'
+    require 'base64'
+    require 'hmac-sha1'
+
+    # The url that should be used to handle subscription handshakes.
+    attr_reader :callback_url
+
+    # The url of the feed one wishes to subscribe to.
+    attr_reader :topic_url
+
+    # The hub this subscription is made with.
+    attr_reader :hub
+
+    # Creates a representation of a subscription.
+    #
+    # options:
+    #   :callback_url => The url that should be used to handle subscription
+    #                    handshakes.
+    #   :topic_url    => The url of the feed one wishes to subscribe to.
+    #   :secret       => A secret that will be passed to the callback to better
+    #                    verify that communication is not replayed. Default:
+    #                    A secure random hex.
+    #   :hubs         => A list of hubs to negotiate the subscription with.
+    #                    Default: attempts to discover the hubs when it
+    #                    subscribes for the first time.
+    #   :hub          => The hub we have a subscription with already.
+    def initialize(options = {})
+      @tokens = []
+
+      secret = options[:secret] || SecureRandom.hex(32)
+      @secret = secret.to_s
+
+      @callback_url = options[:callback_url]
+      @topic_url    = options[:topic_url]
+      @tokens << options[:token] if options[:token]
+
+      @hubs = options[:hubs] || []
+
+      @hub  = options[:hub]
+    end
+
+    # Actively searches for hubs by talking to publisher directly
+    def discover_hubs_for_topic
+      @hubs = Nelumba.feed_from_url(self.topic_url).hubs
+    end
+
+    # Subscribe to the topic through the given hub.
+    def subscribe
+      return unless self.hub.nil?
+
+      # Discover hubs if none exist
+      @hubs = discover_hubs_for_topic(self.topic_url) if self.hubs.empty?
+      @hub = self.hubs.first
+      change_subscription(:subscribe, token)
+
+      # TODO: Check response, if failed, try a different hub
+    end
+
+    # Unsubscribe to the topic.
+    def unsubscribe
+      return if self.hub.nil?
+
+      change_subscription(:unsubscribe)
+    end
+
+    # Change our subscription to this topic at a hub.
+    # mode:    Either :subscribe or :unsubscribe
+    # hub_url: The url of the hub to negotiate with
+    # token:   A token to verify the response from the hub.
+    def change_subscription(mode)
+      token ||= SecureRandom.hex(32)
+      @tokens << token.to_s
+
+      # TODO: Set up HTTPS foo
+      res = Net::HTTP.post_form(URI.parse(self.hub),
+                                {
+                                  'hub.mode' => mode.to_s,
+                                  'hub.callback' => @callback_url,
+                                  'hub.verify' => 'async',
+                                  'hub.verify_token' => token,
+                                  'hub.lease_seconds' => '',
+                                  'hub.secret' => @secret,
+                                  'hub.topic' => @topic_url
+                                })
+    end
+
+    # Verify that a subscription response is valid.
+    def verify_subscription(token)
+      # Is there a token?
+      result = @tokens.include?(token)
+
+      # Ensure we cannot reuse the token
+      @tokens.delete(token)
+
+      result
+    end
+
+    # Determines if the given body matches the signature.
+    def verify_content(body, signature)
+      hmac = HMAC::SHA1.hexdigest(@secret, body)
+      check = "sha1=" + hmac
+      check == signature
+    end
+
+    # Gives the content of a challenge response given the challenge
+    # body.
+    def challenge_response(challenge_code)
+      {
+        :body => challenge_code,
+        :status => 200
+      }
+    end
+  end
+end

data/lib/nelumba/version.rb

@@ -0,0 +1,3 @@
+module Nelumba
+  VERSION = "0.0.13"
+end

data/lib/nelumba/video.rb

@@ -0,0 +1,43 @@
+module Nelumba
+  class Video
+    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
+    # video stream.
+    attr_reader :embed_code
+
+    # A MediaLink to the video content itself.
+    attr_reader :stream
+
+    # Creates a new Video activity object.
+    def initialize(options = {}, &blk)
+      init(options, &blk)
+    end
+
+    def init(options = {}, &blk)
+      super(options, &blk)
+
+      @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 => "video",
+        :embedCode  => @embed_code,
+        :stream     => @stream
+      }.merge(super)
+    end
+  end
+end

data/nelumba.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "nelumba/version"
+
+Gem::Specification.new do |s|
+  s.name        = "nelumba"
+  s.version     = Nelumba::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Hackers of the Severed Hand']
+  s.email       = ['hotsh@xomb.org']
+  s.homepage    = "http://github.com/hotsh/nelumba"
+  s.summary     = %q{Generalized federated system backend for social networks with ActivityStreams/OStatus/pump.io.}
+  s.description = %q{This gem allows easier implementation and utilization of distributed, federated social networks.}
+
+  s.add_dependency "ratom"
+  s.add_dependency "ruby-hmac"
+  s.add_dependency "rsa"
+  s.add_dependency "time-lord"
+  s.add_dependency "nokogiri"
+
+  s.add_development_dependency "rspec", "~> 2.10.0"
+  s.add_development_dependency "rake", "~> 0.9.2"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/activity_spec.rb

@@ -0,0 +1,116 @@
+require_relative 'helper'
+require_relative '../lib/nelumba/activity.rb'
+
+describe Nelumba::Activity do
+  describe "#initialize" do
+    it "should store an object" do
+      Nelumba::Activity.new(:object => "object").object.must_equal "object"
+    end
+
+    it "should store an type" do
+      Nelumba::Activity.new(:type => :audio).type.must_equal :audio
+    end
+
+    it "should store a verb" do
+      Nelumba::Activity.new(:verb => :follow).verb.must_equal :follow
+    end
+
+    it "should store a target" do
+      Nelumba::Activity.new(:target => "target").target.must_equal "target"
+    end
+
+    it "should store an actor" do
+      actor = mock('author')
+      Nelumba::Activity.new(:actor => actor).actor.must_equal actor
+    end
+
+    it "should store the published date" do
+      time = mock('date')
+      Nelumba::Activity.new(:published => time).published.must_equal time
+    end
+
+    it "should store the updated date" do
+      time = mock('date')
+      Nelumba::Activity.new(:updated => time).updated.must_equal time
+    end
+
+    it "should store a source feed" do
+      feed = mock('feed')
+      Nelumba::Activity.new(:source => feed).source.must_equal feed
+    end
+
+    it "should store a url" do
+      Nelumba::Activity.new(:url => "url").url.must_equal "url"
+    end
+
+    it "should store an id" do
+      Nelumba::Activity.new(:uid => "id").uid.must_equal "id"
+    end
+
+    it "should store an array of threads" do
+      thread = mock('entry')
+      Nelumba::Activity.new(:in_reply_to => [thread]).in_reply_to.must_equal [thread]
+    end
+
+    it "should store an array of threads when only given one entry" do
+      thread = mock('entry')
+      Nelumba::Activity.new(:in_reply_to => thread).in_reply_to.must_equal [thread]
+    end
+
+    it "should store an empty array of threads by default" do
+      Nelumba::Activity.new.in_reply_to.must_equal []
+    end
+
+    it "should store an array of replies" do
+      thread = mock('entry')
+      Nelumba::Activity.new(:replies => [thread]).replies.must_equal [thread]
+    end
+
+    it "should store an empty array of replies by default" do
+      Nelumba::Activity.new.replies.must_equal []
+    end
+
+    it "should store an array of shares" do
+      thread = mock('entry')
+      Nelumba::Activity.new(:shares => [thread]).shares.must_equal [thread]
+    end
+
+    it "should store an empty array of shares by default" do
+      Nelumba::Activity.new.shares.must_equal []
+    end
+
+    it "should store an array of mentions" do
+      thread = mock('entry')
+      Nelumba::Activity.new(:mentions => [thread]).mentions.must_equal [thread]
+    end
+
+    it "should store an empty array of mentions by default" do
+      Nelumba::Activity.new.mentions.must_equal []
+    end
+
+    it "should store an array of likes" do
+      thread = mock('entry')
+      Nelumba::Activity.new(:likes => [thread]).likes.must_equal [thread]
+    end
+
+    it "should store an empty array of likes by default" do
+      Nelumba::Activity.new.likes.must_equal []
+    end
+
+    it "should store an empty hash of interactions by default" do
+      Nelumba::Activity.new.interactions.must_equal({})
+    end
+  end
+
+  describe "#interaction_count" do
+    it "should pull values out of interactions" do
+      Nelumba::Activity.new(:interactions => {:share => {:count => 3}})
+                     .interaction_count(:share).must_equal 3
+    end
+
+    it "should defautl a value of 0 when verb isn't found" do
+      Nelumba::Activity.new(:interactions => {:share => {:count => 3}})
+                     .interaction_count(:like).must_equal 0
+    end
+  end
+end

data/spec/application_spec.rb

@@ -0,0 +1,136 @@
+require_relative 'helper'
+require_relative '../lib/nelumba/application.rb'
+
+describe Nelumba::Application do
+  describe "#initialize" do
+    it "should store an author" do
+      author = mock('author')
+      Nelumba::Application.new(:author => author).author.must_equal author
+    end
+
+    it "should store content" do
+      Nelumba::Application.new(:content => "txt").content.must_equal "txt"
+    end
+
+    it "should store the published date" do
+      time = mock('date')
+      Nelumba::Application.new(:published => time).published.must_equal time
+    end
+
+    it "should store the updated date" do
+      time = mock('date')
+      Nelumba::Application.new(:updated => time).updated.must_equal time
+    end
+
+    it "should store a display name" do
+      Nelumba::Application.new(:display_name => "url")
+                        .display_name.must_equal "url"
+    end
+
+    it "should store a summary" do
+      Nelumba::Application.new(:summary => "url").summary.must_equal "url"
+    end
+
+    it "should store a url" do
+      Nelumba::Application.new(:url => "url").url.must_equal "url"
+    end
+
+    it "should store an id" do
+      Nelumba::Application.new(:uid => "id").uid.must_equal "id"
+    end
+  end
+
+  describe "#to_hash" do
+    it "should contain the content" do
+      Nelumba::Application.new(:content => "Hello")
+                        .to_hash[:content].must_equal "Hello"
+    end
+
+    it "should contain the author" do
+      author = mock('Nelumba::Person')
+      Nelumba::Application.new(:author => author).to_hash[:author].must_equal author
+    end
+
+    it "should contain the uid" do
+      Nelumba::Application.new(:uid => "Hello").to_hash[:uid].must_equal "Hello"
+    end
+
+    it "should contain the url" do
+      Nelumba::Application.new(:url => "Hello").to_hash[:url].must_equal "Hello"
+    end
+
+    it "should contain the summary" do
+      Nelumba::Application.new(:summary=> "Hello")
+                 .to_hash[:summary].must_equal "Hello"
+    end
+
+    it "should contain the display name" do
+      Nelumba::Application.new(:display_name => "Hello")
+                 .to_hash[:display_name].must_equal "Hello"
+    end
+
+    it "should contain the published date" do
+      date = mock('Time')
+      Nelumba::Application.new(:published => date).to_hash[:published].must_equal date
+    end
+
+    it "should contain the updated date" do
+      date = mock('Time')
+      Nelumba::Application.new(:updated => date).to_hash[:updated].must_equal date
+    end
+  end
+
+  describe "#to_json" do
+    before do
+      author = Nelumba::Person.new :display_name => "wilkie"
+      @note = Nelumba::Application.new :content      => "Hello",
+                                     :author       => author,
+                                     :uid          => "id",
+                                     :url          => "url",
+                                     :title        => "title",
+                                     :summary      => "foo",
+                                     :display_name => "meh",
+                                     :published    => Time.now,
+                                     :updated      => Time.now
+
+      @json = @note.to_json
+      @data = JSON.parse(@json)
+    end
+
+    it "should contain the embedded json for the author" do
+      @data["author"].must_equal JSON.parse(@note.author.to_json)
+    end
+
+    it "should contain a 'application' objectType" do
+      @data["objectType"].must_equal "application"
+    end
+
+    it "should contain the id" do
+      @data["id"].must_equal @note.uid
+    end
+
+    it "should contain the content" do
+      @data["content"].must_equal @note.content
+    end
+
+    it "should contain the url" do
+      @data["url"].must_equal @note.url
+    end
+
+    it "should contain the summary" do
+      @data["summary"].must_equal @note.summary
+    end
+
+    it "should contain the display name" do
+      @data["displayName"].must_equal @note.display_name
+    end
+
+    it "should contain the published date as rfc3339" do
+      @data["published"].must_equal @note.published.to_date.rfc3339 + 'Z'
+    end
+
+    it "should contain the updated date as rfc3339" do
+      @data["updated"].must_equal @note.updated.to_date.rfc3339 + 'Z'
+    end
+  end
+end