livefyre 0.1.2 → 1.0.0

data/lib/livefyre/user.rb

@@ -1,162 +0,0 @@
-module Livefyre
-  # Public: Interface for dealing with Livefyre users by User ID.
-  class User
-    attr_accessor :id, :display_name
-
-    # Public: Create a new Livefyre User proxy.
-    #
-    # id           - [String] ID of the user to proxy
-    # client       - [Livefyre::Client] an instance of Livefyre::Client. If nil, the default client is used.
-    # display_name - [String] The display name for this user (optional)
-    def initialize(id, client = nil, display_name = nil, args = {})
-      @id = id
-      @client = client || Livefyre.client
-      @display_name = display_name
-      @options = args
-    end
-
-    # Public: Retrieve user information and recent comments for this user from Livefyre
-    #
-    # Returns [Hash] of profile data
-    # Raises [JSON::ParserError] if the returned data cannot be parsed
-    # Raises [APIException] if the API does not return a valid response
-    def profile
-      response = @client.get "/profile/#{id}/", {:actor_token => token}
-      if response.success?
-        begin
-          JSON.parse(response.body)["data"]
-        rescue JSON::ParserError => e
-          raise APIException.new("Parse error: #{e.message}")
-        end
-      else
-        raise APIException.new(result.body)
-      end
-    end
-
-    # Public: Setter for the client to associate with this user
-    def client=(client)
-      @client = client
-    end
-
-    # Internal - Fetch an internal Jabber-style ID for this user
-    #
-    # Returns [String] representation of this user
-    def jid
-      "#{id}@#{@client.host}"
-    end
-
-    # Public: Creates a signed JWT token for this user
-    #
-    # max_age - [Integer] Expiry time for this token in seconds (default: 86400)
-    #
-    # Returns [String] token
-    def token(max_age = 86400)
-      data = {
-        :domain => @client.host,
-        :user_id => id,
-        :expires => Time.now.to_i + max_age
-      }.tap do |opts|
-        opts[:display_name] = @display_name unless @display_name.nil?
-      end
-      JWT.encode(data, @client.key)
-    end
-
-    # Public: Update this user's profile on Livefyre
-    #
-    # data - [Hash] A hash of user data as defined by the Livefyre user profile schema
-    #
-    # Returns [Bool] true on success
-    # Raises [APIException] if the request failed
-    def push(data)
-      result = @client.post "/profiles/?actor_token=#{CGI.escape @client.system_token}&id=#{id}", {:data => data.to_json}
-      if result.success?
-        true
-      else
-        raise APIException.new(result.body)
-      end
-    end
-
-    # Public: Invoke Livefyre ping-to-pull to refresh this user's data
-    #
-    # Returns [Bool] true on success
-    # Raises [APIException] if the request failed
-    def refresh
-      result = @client.post "/api/v3_0/user/#{id}/refresh", {:lftoken => @client.system_token}
-      if result.success?
-        true
-      else
-        raise APIException.new(result.body)
-      end
-    end
-
-    # Public: Follow the given conversation
-    #
-    # conversation - [Conversation] to follow
-    # Returns [Boolean] true on success
-    # Raises [APIException] on failure
-    def follow_conversation(conversation)
-      conversation.follow_as self
-    end
-
-    # Public: Unfollow the given conversation
-    #
-    # conversation - [Conversation] to unfollow
-    # Returns [Boolean] true on success
-    # Raises [APIException] on failure
-    def unfollow_conversation(conversation)
-      conversation.unfollow_as self
-    end
-
-    # Public: Coerce a string or [User] into a user ID
-    #
-    # userish - [String/User/Int]A [User] or user ID
-    #
-    # Returns [String] User ID
-    # Raises Exception when value can't be coerced
-    def self.get_user_id(userish)
-      case userish
-      when String
-        userish.split("@", 2).first
-      when Fixnum
-        userish
-      when User
-        userish.id
-      else
-        raise "Invalid user ID"
-      end
-    end
-
-    # Public: Convenience method to refresh a user by ID
-    #
-    # id - A Livefyre user ID to refresh
-    #
-    # Returns [Bool] true on success
-    # Raises [APIException] if the request failed
-    def self.refresh(id)
-      new(id).refresh
-    end
-
-    # Public: Fetch a Livefyre::User from a user record or ID
-    #
-    # userish - [String/User/Int] A User or user ID
-    # client  - [Livefyre::Client] Client to bind to the User record
-    #
-    # Returns [User]
-    def self.get_user(userish, client)
-      case userish
-      when User
-        userish.client = client
-        userish
-      else
-        new get_user_id(userish), client
-      end
-    end
-
-    # Internal: Returns a cleaner string representation of this object
-    #
-    # Returns [String] representation of this class
-    def to_s
-      "#<#{self.class.name}:0x#{object_id.to_s(16).rjust(14, "0")} id='#{id}' display_name='#{display_name}'>"
-    end
-  end
-end

data/railties/railtie.rb

@@ -1,9 +0,0 @@
-module Livefyre
-  class Railtie < Rails::Railtie
-    initializer "livefyre.initializer" do
-      ActionController::Base.send :include, Livefyre::Controller
-      ActionView::Base.send :include, Livefyre::Helpers
-      ActiveRecord::Base.send :include, Livefyre::Model if defined?(ActiveRecord)
-    end
-  end
-end

data/spec/livefyre/client_spec.rb

@@ -1,104 +0,0 @@
-require 'spec_helper'
-
-describe Livefyre::Client do
-  it "should not initialize without a host" do
-    expect { Livefyre::Client.new(:key => "x", :system_token => "x") }.to raise_error Exception
-  end
-
-  it "should not initialize without a key" do
-    expect { Livefyre::Client.new(:host => "x", :system_token => "x") }.to raise_error Exception
-  end
-
-  it "should not initialize without a system token" do
-    expect { Livefyre::Client.new(:key => "x", :host => "x") }.to raise_error Exception
-  end
-
-  it "should initialize with a key, host, and system token" do
-    Livefyre::Client.new(:key => "x", :network => "x", :system_token => "x").should be_a Livefyre::Client
-  end
-
-  context "an instance" do
-    subject { Livefyre::Client.new(:key => "x", :host => "x", :system_token => "x") }
-
-    describe "#sign" do
-      before { @token = subject.sign({:foo => "bar"}) }
-
-      it "should return a string token" do
-        @token.should be_a String
-      end
-
-      it "should validate" do
-        subject.validate(@token).should be_a Hash
-      end
-
-      it "should decode" do
-        subject.validate(@token)["foo"].should == "bar"
-      end
-    end
-
-    describe "#user" do
-      before { @user = subject.user(1234, "foobar") }
-      it "should return a user" do
-        @user.should be_a Livefyre::User
-      end
-
-      it "should have its ID set" do
-        @user.id.should == 1234
-      end
-
-      it "should have a reference to this client" do
-        @user.instance_variable_get("@client").should == subject
-      end
-    end
-
-    describe "#set_user_role" do
-      context "with a valid role and scope" do
-        let(:client) { double "client" }
-
-        before do
-          subject.stub(:http_client).and_return(client)
-        end
-
-        it "should post an affiliation update for a domain" do
-          client.should_receive(:post).with("/api/v1.1/private/management/user/123@x/role/", {:affiliation=>"admin", :lftoken=>"x", :domain_wide=>1}).and_return( double(:success? => true) )
-          subject.set_user_role(123, "admin", "domain").should == true
-        end
-
-        context "when updating a site affiliation" do
-          it "should fail if no scope ID is passed" do
-            client.should_not_receive(:post)
-            expect { subject.set_user_role(123, "admin", "site") }.to raise_error Exception
-          end
-
-          it "should post an affiliation update for a site" do
-            client.should_receive(:post).with("/api/v1.1/private/management/user/123@x/role/", {:affiliation=>"admin", :lftoken=>"x", :site_id=>123}).and_return( double(:success? => true) )
-            subject.set_user_role(123, "admin", "site", 123).should == true
-          end
-        end
-
-        context "when updating a conversation affiliation" do
-          it "should fail if no scope ID is passed" do
-            client.should_not_receive(:post)
-            expect { subject.set_user_role(123, "admin", "conv") }.to raise_error Exception
-          end
-
-          it "should post an affiliation update for a site" do
-            client.should_receive(:post).with("/api/v1.1/private/management/user/123@x/role/", {:affiliation=>"admin", :lftoken=>"x", :conv_id=>123}).and_return( double(:success? => true) )
-            subject.set_user_role(123, "admin", "conv", 123).should == true
-          end
-        end
-
-        context "when it fails" do
-          it "should raise an exception" do
-            client.should_receive(:post).and_return( double(:success? => false, :body => "Failure due to zombie outbreak") )
-            expect { subject.set_user_role(123, "admin", "domain") }.to raise_error(Livefyre::APIException)
-          end
-        end
-      end
-    end
-
-    it "should have a valid string representation" do
-      subject.to_s.should match(/Livefyre::Client/)
-    end
-  end
-end

data/spec/livefyre/domain_spec.rb

@@ -1,294 +0,0 @@
-require 'spec_helper'
-
-describe Livefyre::Domain do
-  context "an instance" do
-    subject { Livefyre::Domain.new }
-
-    describe "#sites" do
-      context "on success" do
-        before do
-          client = double( :get => double(:success? => true, :body => [{:id => "foo.com"}].to_json), :system_token => "x" )
-          subject.stub(:client).and_return(client)
-        end
-
-        its(:sites) { should be_a Array }
-
-        its("sites.first") { should be_a Livefyre::Site }
-        its("sites.first.id") { should == "foo.com" }
-      end
-
-      context "on failure" do
-        before do
-          client = double( :get => double(:success? => false, :body => ""), :system_token => "x" )
-          subject.stub(:client).and_return(client)
-        end
-
-        it "should raise an exception" do
-          expect { subject.sites }.to raise_error(Livefyre::APIException)
-        end
-      end
-    end
-
-    describe "#users" do
-      context "on success" do
-        before do
-          client = double( :get => double(:success? => true, :body => [{:id => "foo"}].to_json), :system_token => "x" )
-          subject.stub(:client).and_return(client)
-        end
-
-        its(:users) { should be_a Array }
-
-        its("users.first") { should be_a Livefyre::User }
-        its("users.first.id") { should == "foo" }
-      end
-
-      context "on failure" do
-        before do
-          client = double( :get => double(:success? => false, :body => ""), :system_token => "x" )
-          subject.stub(:client).and_return(client)
-        end
-
-        it "should raise an exception" do
-          expect { subject.users }.to raise_error(Livefyre::APIException)
-        end
-      end
-    end
-
-    describe "#add_user" do
-      context "on success" do
-        before do
-          client = double( :post => double(:success? => true), :system_token => "x", :host => "some_host", :key => "some_key" )
-          subject.stub(:client).and_return(client)
-        end
-
-        it "should return true" do
-          subject.add_user({"id" => "valid ID"}).should be true
-        end
-      end
-
-      context "on failure" do
-        before do
-          client = double( :post => double(:success? => false, :body => ""), :system_token => "x" )
-          subject.stub(:client).and_return(client)
-        end
-
-        it "should raise an exception" do
-          expect { subject.add_user({"id" => "valid ID"}) }.to raise_error(Livefyre::APIException)
-        end
-
-        it "should raise an exception when passed an invalid ID" do
-          expect { subject.add_user({"bad_id" => "invalid ID"}) }.to raise_error("Invalid ID")
-        end
-      end
-    end
-
-    describe "#create_site" do
-      context "on success" do
-        before do
-          client = double( :post => double(:success? => true, :body => {"id" => "foo"}.to_json), :system_token => "x", :host => "some_host", :key => "some_key" )
-          subject.stub(:client).and_return(client)
-          @site = subject.create_site("some URL")
-        end
-
-        it "should return a Site" do
-          @site.should be_a Livefyre::Site
-        end
-
-        it "should be prepopulated with the values we just passed" do
-          @site.id.should == "foo"
-        end
-      end
-
-      context "on failure" do
-        before do
-          client = double( :post => double(:success? => false, :body => ""), :system_token => "x" )
-          subject.stub(:client).and_return(client)
-        end
-
-        it "should raise an exception" do
-          expect { subject.create_site("some_url") }.to raise_error(Livefyre::APIException)
-        end
-      end
-    end
-
-    describe "#owners" do
-      context "on success" do
-        before do
-          client = double( :get => double(:success? => true, :body => ["foo@bar"].to_json), :system_token => "x" )
-          client.should_receive(:user).with("foo").and_return( Livefyre.client.user("foo") )
-          subject.stub(:client).and_return(client)
-        end
-
-        its(:owners) { should be_a Array }
-
-        its("owners.first") { should be_a Livefyre::User }
-        its("owners.first.id") { should == "foo" }
-      end
-
-      context "on failure" do
-        before do
-          client = double( :get => double(:success? => false, :body => ""), :system_token => "x" )
-          subject.stub(:client).and_return(client)
-        end
-
-        it "should raise an exception" do
-          expect { subject.owners }.to raise_error(Livefyre::APIException)
-        end
-      end
-    end
-
-    describe "#add_owner" do
-      context "on success" do
-        before do
-          client = double( :post => double(:success? => true), :system_token => "x", :host => "some_host", :key => "some_key" )
-          subject.stub(:client).and_return(client)
-        end
-
-        it "should return true" do
-          subject.add_owner("some ID").should be true
-        end
-      end
-
-      context "on failure" do
-        before do
-          client = double( :post => double(:success? => false, :body => ""), :system_token => "x", :host => "some_host", :key => "some_key" )
-          subject.stub(:client).and_return(client)
-        end
-
-        it "should raise an exception" do
-          expect { subject.add_owner("some user ID") }.to raise_error(Livefyre::APIException)
-        end
-      end
-    end
-
-    describe "#remove_owner" do
-      context "on success" do
-        before do
-          client = double( :delete => double(:success? => true), :system_token => "x", :host => "some_host", :key => "some_key" )
-          subject.stub(:client).and_return(client)
-        end
-
-        it "should return true" do
-          subject.remove_owner("some ID").should be true
-        end
-      end
-
-      context "on failure" do
-        before do
-          client = double( :delete => double(:success? => false, :body => ""), :system_token => "x", :host => "some_host", :key => "some_key" )
-          subject.stub(:client).and_return(client)
-        end
-
-        it "should raise an exception" do
-          expect { subject.remove_owner("some user ID") }.to raise_error(Livefyre::APIException)
-        end
-      end
-    end
-
-
-    describe "#admins" do
-      context "on success" do
-        before do
-          client = double( :get => double(:success? => true, :body => ["foo@bar"].to_json), :system_token => "x" )
-          client.should_receive(:user).with("foo").and_return( Livefyre.client.user("foo") )
-          subject.stub(:client).and_return(client)
-        end
-
-        its(:admins) { should be_a Array }
-
-        its("admins.first") { should be_a Livefyre::User }
-        its("admins.first.id") { should == "foo" }
-      end
-
-      context "on failure" do
-        before do
-          client = double( :get => double(:success? => false, :body => ""), :system_token => "x" )
-          subject.stub(:client).and_return(client)
-        end
-
-        it "should raise an exception" do
-          expect { subject.admins }.to raise_error(Livefyre::APIException)
-        end
-      end
-    end
-
-    describe "#add_admin" do
-      context "on success" do
-        before do
-          client = double( :post => double(:success? => true), :system_token => "x", :host => "some_host", :key => "some_key" )
-          subject.stub(:client).and_return(client)
-        end
-
-        it "should return true" do
-          subject.add_admin("some ID").should be true
-        end
-      end
-
-      context "on failure" do
-        before do
-          client = double( :post => double(:success? => false, :body => ""), :system_token => "x", :host => "some_host", :key => "some_key" )
-          subject.stub(:client).and_return(client)
-        end
-
-        it "should raise an exception" do
-          expect { subject.add_admin("some user ID") }.to raise_error(Livefyre::APIException)
-        end
-      end
-    end
-
-    describe "#remove_admin" do
-      context "on success" do
-        before do
-          client = double( :delete => double(:success? => true), :system_token => "x", :host => "some_host", :key => "some_key" )
-          subject.stub(:client).and_return(client)
-        end
-
-        it "should return true" do
-          subject.remove_admin("some ID").should be true
-        end
-      end
-
-      context "on failure" do
-        before do
-          client = double( :delete => double(:success? => false, :body => ""), :system_token => "x", :host => "some_host", :key => "some_key" )
-          subject.stub(:client).and_return(client)
-        end
-
-        it "should raise an exception" do
-          expect { subject.remove_admin("some user ID") }.to raise_error(Livefyre::APIException)
-        end
-      end
-    end
-
-    describe "#set_pull_url" do
-      context "when it succeeds" do
-        before do
-          response = double(:success? => true)
-          client = double(:post => response, :system_token => "x")
-          subject.stub(:client).and_return(client)
-          @response = subject.set_pull_url 'http://foo.bar/{id}/'
-        end
-
-        it "should return true" do
-          @response.should == true
-        end
-      end
-
-      context "when it fails" do
-        before do
-          response = double(:success? => false, :body => "failure")
-          client = double(:post => response, :system_token => "x")
-          subject.stub(:client).and_return(client)
-        end
-
-        it "should raise an exception" do
-          expect { subject.set_pull_url 'http://foo.bar/{id}/' }.to raise_error(Livefyre::APIException)
-        end
-      end
-    end
-
-    it "should have a valid string representation" do
-      subject.to_s.should match(/Livefyre::Domain.*host='#{subject.client.host}'/)
-    end
-  end
-end

data/spec/livefyre/livefyre_spec.rb

@@ -1,30 +0,0 @@
-require 'spec_helper'
-
-describe Livefyre do
-  context "the default client" do
-    it "should raise an exception if the configuration is not set" do
-      c = Livefyre.config
-      Livefyre.config = nil
-      lambda { Livefyre.client }.should raise_exception(Exception)
-      Livefyre.config = c
-    end
-
-    context "when a configuration is set" do
-      before {
-        Livefyre.config = {:host => "foo.bar", :key => "foo", :system_token => "123"}
-      }
-
-      it "should get a Livefyre::Client" do
-        Livefyre.client.should be_a(Livefyre::Client)
-      end
-
-      it 'should get the same client instance across multiple calls' do
-        Livefyre.client.should eql(Livefyre.client)
-      end
-
-      it 'should fetch the config' do
-        Livefyre.config.should == {:host => "foo.bar", :key => "foo", :system_token => "123"}
-      end
-    end
-  end
-end

data/spec/livefyre/model_spec.rb

@@ -1,96 +0,0 @@
-require 'spec_helper'
-
-if defined? Livefyre::Model
-  class BaseUser
-    include Livefyre::Model
-    attr_accessor :id
-    attr_accessor :email
-
-    def email=(email)
-      @email = email
-      @email_changed = true
-    end
-
-    def email_changed?
-      @email_changed
-    end
-
-    def save
-      self.class.instance_variable_get("@callbacks").each do |callback|
-        send callback
-      end
-    end
-
-    def self.after_save(callback)
-      @callbacks ||= []
-      @callbacks.push callback
-    end
-  end
-
-  class UserWithBlock < BaseUser
-    attr_accessor :foo
-    livefyre_user :update_on => [:email] do |o, id|
-      o.foo = 1
-    end
-  end
-
-  class UserWithoutBlock < BaseUser
-    livefyre_user :update_on => [:email] 
-  end
-
-  class UserWithCustomId < BaseUser
-    livefyre_user :id => :custom_id, :update_on => [:email]
-
-    def custom_id
-      "foobar"
-    end
-  end
-
-  describe Livefyre::Model do
-    context "when saving" do
-      it "should not do anything if the watched fields haven't changed" do
-        u = UserWithoutBlock.new
-        u.should_not_receive(:refresh_livefyre)
-        u.save
-      end
-
-      it "should call refresh when fields have changed" do
-        u = UserWithoutBlock.new
-        u.email = "new@email.com"
-        u.should_receive(:refresh_livefyre)
-        u.save
-      end
-
-      context "an instance that is set to call a block" do
-        let(:user) { UserWithBlock.new }
-
-        it "should invoke the passed block when refresh_livefyre is called" do
-          Livefyre::User.should_not_receive(:refresh)
-          user.email = "new@email.com"
-          user.save
-          user.foo.should == 1
-        end
-      end
-
-      context "an instance that is not set to defer" do
-        let(:user) { UserWithoutBlock.new }
-
-        it "should invoke Livefyre::Model::RequestPull when refresh_livefyre is called" do
-          Livefyre::User.should_receive(:refresh)
-          user.email = "new@email.com"
-          user.save
-        end
-      end
-
-      context "an instance with a custom ID" do
-        let(:user) { UserWithCustomId.new }
-
-        it "should invoke Livefyre::Model::RequestPull when refresh_livefyre is called" do
-          Livefyre::User.should_receive(:refresh)
-          user.email = "new@email.com"
-          user.save
-        end
-      end
-    end
-  end
-end