hello_sign 0.3.0 → 0.4.0

data/lib/hello_sign/account_proxy.rb

@@ -1,33 +0,0 @@
-require 'hello_sign/settings_proxy'
-
-module HelloSign
-  class AccountProxy
-    attr_reader :client
-    attr_writer :settings_proxy_source
-
-    def initialize(client)
-      @client = client
-    end
-
-    def create(credentials)
-      email    = credentials.fetch(:email)
-      password = credentials.fetch(:password)
-
-      client.post('/account/create',
-        :body => {:email_address => email, :password => password},
-        :auth_not_required => true
-      )
-    end
-
-    def settings
-      settings_proxy_source.new(client)
-    end
-
-    private
-
-    def settings_proxy_source
-      @settings_proxy_source || SettingsProxy
-    end
-
-  end
-end

data/lib/hello_sign/reusable_form_proxy.rb

@@ -1,43 +0,0 @@
-module HelloSign
-  class ReusableFormProxy
-    attr_reader :client
-
-    def initialize(client)
-      @client = client
-    end
-
-    def list(params = {})
-      params = {:page => 1}.merge(params)
-      client.get('/reusable_form/list', :params => params)
-    end
-
-    def show(form_id)
-      client.get("/reusable_form/#{form_id}")
-    end
-
-    def grant_access(form_id, params = {})
-      body = if email = params[:email]
-        {:email_address => email}
-      elsif account_id = params[:account_id]
-        {:account_id => account_id}
-      else
-        raise ArgumentError, 'An email address or account ID must be provided.'
-      end
-
-      client.post("/reusable_form/add_user/#{form_id}", :body => body)
-    end
-
-    def revoke_access(form_id, params = {})
-      body = if email = params[:email]
-        {:email_address => email}
-      elsif account_id = params[:account_id]
-        {:account_id => account_id}
-      else
-        raise ArgumentError, 'An email address or account ID must be provided.'
-      end
-
-      client.post("/reusable_form/remove_user/#{form_id}", :body => body)
-    end
-
-  end
-end

data/lib/hello_sign/settings_proxy.rb

@@ -1,20 +0,0 @@
-require 'hello_sign/client'
-
-module HelloSign
-  class SettingsProxy
-    attr_reader :client
-
-    def initialize(client)
-      @client = client
-    end
-
-    def show
-      client.get('/account')
-    end
-
-    def update(attributes)
-      client.post('/account', :body => attributes)
-    end
-
-  end
-end

data/lib/hello_sign/signature_request_proxy.rb

@@ -1,60 +0,0 @@
-require 'hello_sign/parameters/signature_request'
-require 'hello_sign/parameters/reusable_form_signature_request'
-
-module HelloSign
-  class SignatureRequestProxy
-    attr_reader :client
-    attr_writer :request_parameters, :reusable_form_request_parameters
-
-    def initialize(client)
-      @client = client
-    end
-
-    def send(params = {})
-      if form_id = params[:form]
-        reusable_form_request_parameters.reusable_form_id = form_id
-        yield reusable_form_request_parameters
-        client.post(
-          '/signature_request/send_with_reusable_form',
-          :body => reusable_form_request_parameters.formatted
-        )
-      else
-        yield request_parameters
-        client.post('/signature_request/send', :body => request_parameters.formatted)
-      end
-    end
-
-    def status(request_id)
-      client.get("/signature_request/#{request_id}")
-    end
-
-    def list(params = {})
-      params = {:page => 1}.merge(params)
-      client.get('/signature_request/list', :params => params)
-    end
-
-    def remind(request_id, parameters = {})
-      email = parameters.fetch(:email)
-      client.post("/signature_request/remind/#{request_id}", :body => {:email_address => email})
-    end
-
-    def cancel(request_id)
-      client.post("/signature_request/cancel/#{request_id}")
-    end
-
-    def final_copy(request_id)
-      client.get("/signature_request/final_copy/#{request_id}")
-    end
-
-    private
-
-    def request_parameters
-      @request_parameters ||= Parameters::SignatureRequest.new
-    end
-
-    def reusable_form_request_parameters
-      @reusable_form_request_parameters ||= Parameters::ReusableFormSignatureRequest.new
-    end
-
-  end
-end

data/lib/hello_sign/team_proxy.rb

@@ -1,47 +0,0 @@
-module HelloSign
-  class TeamProxy
-    attr_reader :client
-
-    def initialize(client)
-      @client = client
-    end
-
-    def create(params)
-      name = params.fetch(:name)
-      client.post('/team/create', :body => {:name => name})
-    end
-
-    def show
-      client.get('/team')
-    end
-
-    def update(attributes)
-      client.post('/team', :body => attributes)
-    end
-
-    def destroy
-      client.post('/team/destroy')
-    end
-
-    def add_member(params)
-      client.post("/team/add_member", :body => body_by_identifier(params))
-    end
-
-    def remove_member(params)
-      client.post("/team/remove_member", :body => body_by_identifier(params))
-    end
-
-    private
-
-    def body_by_identifier(params)
-      if email = params[:email]
-        {:email_address => email}
-      elsif account_id = params[:account_id]
-        {:account_id => account_id}
-      else
-        raise ArgumentError, 'An email address or account ID must be provided.'
-      end
-    end
-
-  end
-end

data/spec/unit/signature_request_proxy_spec.rb

@@ -1,126 +0,0 @@
-require 'helper'
-require 'hello_sign/signature_request_proxy'
-
-describe HelloSign::SignatureRequestProxy do
-  let(:client)       { double('client') }
-  let(:request_id)   { 'request_id' }
-  let(:api_response) { double('API response') }
-  subject(:sr_proxy) { HelloSign::SignatureRequestProxy.new(client) }
-
-  describe "#client" do
-    it "returns the client" do
-      expect(sr_proxy.client).to be client
-    end
-  end
-
-  describe "#send" do
-    let(:formatted_request_body) { double('formatted request body') }
-    let(:request_parameters)     { double('request parameters') }
-
-    context "when a reusable form is not specified" do
-      before do
-        sr_proxy.request_parameters = request_parameters
-        request_parameters.stub(:formatted).and_return(formatted_request_body)
-        request_parameters.should_receive(:foo=).with('bar')
-        client.should_receive(:post)
-          .with('/signature_request/send', :body => formatted_request_body)
-          .and_return(api_response)
-      end
-
-      it "sends a signature request creation request and returns the result" do
-        expect(sr_proxy.send { |params| params.foo = 'bar' }).to eq api_response
-      end
-    end
-
-    context "when a reusable form is specified" do
-      before do
-        sr_proxy.reusable_form_request_parameters = request_parameters
-        request_parameters.stub(:formatted).and_return(formatted_request_body)
-        request_parameters.should_receive(:reusable_form_id=).with('form_id')
-        request_parameters.should_receive(:foo=).with('bar')
-        client.should_receive(:post)
-          .with('/signature_request/send_with_reusable_form', :body => formatted_request_body)
-          .and_return(api_response)
-      end
-
-      it "sends a signature request using a reusable form and returns the result" do
-        expect(sr_proxy.send(:form => 'form_id') { |params| params.foo = 'bar' }).to eq api_response
-      end
-    end
-  end
-
-  describe "#status" do
-    before { client.should_receive(:get).with('/signature_request/request_id').and_return(api_response) }
-
-    it "fetches the signature request status and returns the result" do
-      expect(sr_proxy.status(request_id)).to eq api_response
-    end
-  end
-
-  describe "#list" do
-    context "when called without options" do
-      before { client.should_receive(:get).with('/signature_request/list', :params => {:page => 1}).and_return(api_response) }
-
-      it "fetches the first page of signature requests and returns the result" do
-        expect(sr_proxy.list).to eq api_response
-      end
-    end
-
-    context "when called with a page number" do
-      before { client.should_receive(:get).with('/signature_request/list', :params => {:page => 10}).and_return(api_response) }
-
-      it "fetches a list of signature requests for the passed page number and returns the result" do
-        expect(sr_proxy.list(:page => 10)).to eq api_response
-      end
-    end
-  end
-
-  describe "#remind" do
-    let(:email) { 'john@johnson.com' }
-
-    before { client.stub(:post).and_return(api_response) }
-
-    context "when called with the proper parameters" do
-      it "sends a signature request reminder to the email address" do
-        client.should_receive(:post).with('/signature_request/remind/request_id', :body => {:email_address => email})
-        sr_proxy.remind(request_id, :email => email)
-      end
-
-      it "returns the API response" do
-        expect(sr_proxy.remind(request_id, :email => email)).to eq api_response
-      end
-    end
-
-    context "when called without proper parameters" do
-      it "raises an exception" do
-        expect { sr_proxy.remind(request_id) }.to raise_error
-      end
-    end
-  end
-
-  describe "#cancel" do
-    before { client.stub(:post).and_return(api_response) }
-
-    it "sends a signature request cancellation" do
-      client.should_receive(:post).with('/signature_request/cancel/request_id')
-      sr_proxy.cancel(request_id)
-    end
-
-    it "returns the API response" do
-      expect(sr_proxy.cancel(request_id)).to eq api_response
-    end
-  end
-
-  describe "#final_copy" do
-    before { client.stub(:get).and_return(api_response) }
-
-    it "sends a request to fetch a final copy of the signature request" do
-      client.should_receive(:get).with('/signature_request/final_copy/request_id')
-      sr_proxy.final_copy(request_id)
-    end
-
-    it "returns the API response" do
-      expect(sr_proxy.final_copy(request_id)).to eq api_response
-    end
-  end
-end