tent-client 0.0.1 → 0.2.1

data/lib/tent-client/post.rb

@@ -1,66 +1,127 @@
 class TentClient
   class Post
-    MULTIPART_TYPE = 'multipart/form-data'.freeze
-    MULTIPART_BOUNDARY = "-----------TentAttachment".freeze
+    attr_reader :client, :request_method
+    def initialize(client, options = {})
+      @client, @request_method = client, options.delete(:request_method)
+    end
+
+    def head
+      self.class.new(client, :request_method => :head)
+    end
+
+    def get(entity, post_id, params = {}, &block)
+      new_block = proc do |request|
+        request.headers['Accept'] = POST_MEDIA_TYPE
+        yield(request) if block_given?
+      end
+
+      client.http.send(request_method || :get, :post, { :entity => entity, :post => post_id }.merge(params), &new_block)
+    end
 
-    def initialize(client)
-      @client = client
+    def get_attachment(entity, post_id, attachment_name, params = {}, &block)
+      client.http.send(request_method || :get, :post_attachment, { :entity => entity, :post => post_id, :name => attachment_name }.merge(params), &block)
     end
 
-    def count(params={})
-      @client.http.get('posts/count', params)
+    def delete(entity, post_id, params = {}, &block)
+      client.http.delete(:post, { :entity => entity, :post => post_id }.merge(params), &block)
     end
 
-    def list(params = {})
-      @client.http.get('posts', params)
+    def list(params = {}, &block)
+      client.http.send(request_method || :get, :posts_feed, params, &block)
     end
 
-    def create(post, options={})
-      if options[:attachments]
-        multipart_post(post, options, options.delete(:attachments))
+    def create(data, params = {}, options = {}, &block)
+      if (Array === (attachments = options.delete(:attachments))) && attachments.any?
+        parts = multipart_parts(data, attachments)
+        client.http.multipart_request(:post, :new_post, params, parts, &block)
       else
-        @client.http.post(options[:url] || 'posts', post)
+        client.http.post(:new_post, params, data, &block)
       end
     end
 
-    def get(id)
-      @client.http.get("posts/#{id}")
+    def update(entity, post_id, data, params = {}, options = {}, &block)
+      params = { :entity => entity, :post => post_id }.merge(params)
+      if (Array === (attachments = options.delete(:attachments))) && attachments.any?
+        parts = multipart_parts(data, attachments, options)
+        client.http.multipart_request(:put, :post, params, parts, &block)
+      else
+        new_block = proc do |request|
+          if options.delete(:import)
+            request.options['tent.import'] = true
+          elsif options.delete(:notification)
+            request.options['tent.notification'] = true
+          end
+          yield(request) if block_given?
+        end
+
+        client.http.put(:post, params, data, &new_block)
+      end
     end
 
-    def delete(id)
-      @client.http.delete("posts/#{id}")
+    def mentions(entity, post_id, params = {}, options = {}, &block)
+      # TODO: handle options[:page] => :first || :last || page-id
+
+      params = { :entity => entity, :post => post_id }.merge(params)
+
+      new_block = proc do |request|
+        request.headers['Accept'] = POST_MENTIONS_CONTENT_TYPE
+        yield(request) if block_given?
+      end
+
+      client.http.send(request_method || :get, :post, params, &new_block)
     end
 
-    def attachment
-      PostAttachment.new(@client)
+    def versions(entity, post_id, params = {}, options = {}, &block)
+      # TODO: handle options[:page] => :first || :last || page-id
+
+      params = { :entity => entity, :post => post_id }.merge(params)
+
+      new_block = proc do |request|
+        request.headers['Accept'] = POST_VERSIONS_CONTENT_TYPE
+        yield(request) if block_given?
+      end
+
+      client.http.send(request_method || :get, :post, params, &new_block)
     end
 
-    private
+    def children(entity, post_id, params = {}, options = {}, &block)
+      # TODO: handle options[:page] => :first || :last || page-id
+
+      params = { :entity => entity, :post => post_id }.merge(params)
+
+      new_block = proc do |request|
+        request.headers['Accept'] = POST_CHILDREN_CONTENT_TYPE
+        yield(request) if block_given?
+      end
 
-    def multipart_post(post, options, attachments)
-      post_body = { :category => 'post', :filename => 'post.json', :type => MEDIA_TYPE, :data => post.to_json }
-      body = multipart_body(attachments.unshift(post_body))
-      @client.http.post(options[:url] || 'posts', body, 'Content-Type' => "#{MULTIPART_TYPE};boundary=#{MULTIPART_BOUNDARY}")
+      client.http.send(request_method || :get, :post, params, &new_block)
     end
 
-    def multipart_body(attachments)
-      parts = attachments.inject({}) { |h,a|
-        (h[a[:category]] ||= []) << a; h
-      }.inject([]) { |a,(category,attachments)|
-        if attachments.size > 1
-          a += attachments.each_with_index.map { |attachment,i|
-            Faraday::Parts::FilePart.new(MULTIPART_BOUNDARY, "#{category}[#{i}]", attachment_io(attachment))
-          }
-        else
-          a << Faraday::Parts::FilePart.new(MULTIPART_BOUNDARY, category, attachment_io(attachments.first))
-        end
+    private
+
+    def multipart_parts(data, attachments, options = {})
+      [data_as_attachment(data, options)] + attachments.map { |a|
+        a[:filename] = a.delete(:name) || a.delete('name')
+        a[:headers] = a[:headers] || {}
         a
-      } << Faraday::Parts::EpiloguePart.new(MULTIPART_BOUNDARY)
-      Faraday::CompositeReadIO.new(parts)
+      }
     end
 
-    def attachment_io(attachment)
-      Faraday::UploadIO.new(attachment[:file] || StringIO.new(attachment[:data]), attachment[:type], attachment[:filename])
+    def data_as_attachment(data, options = {})
+      content_type = POST_CONTENT_TYPE % (data[:type] || data['type'])
+
+      if options[:import]
+        content_type << %(; rel="https://tent.io/rels/import")
+      elsif options[:notification]
+        content_type << %(; rel="https://tent.io/rels/notification")
+      end
+
+      {
+        :category => 'post',
+        :filename => 'post.json',
+        :content_type => content_type,
+        :data => Yajl::Encoder.encode(data)
+      }
     end
   end
 end

data/lib/tent-client/tent_type.rb

@@ -0,0 +1,77 @@
+require 'uri'
+
+class TentClient
+  class TentType
+    ALL = 'all'.freeze
+
+    attr_accessor :base, :version, :fragment
+    def initialize(uri = nil)
+      @version = 0
+      parse_uri(uri) if uri
+    end
+
+    def all?
+      base == ALL
+    end
+
+    def has_fragment?
+      !!@fragment_separator
+    end
+
+    def fragment=(new_fragment)
+      return if all?
+
+      @fragment_separator = "#"
+      @fragment = new_fragment
+      @fragment = decode_fragment(@fragment) if @fragment
+      @fragment
+    end
+
+    def to_s(options = {})
+      return base if all?
+
+      options[:encode_fragment] = true unless options.has_key?(:encode_fragment)
+      if (!has_fragment? && options[:fragment] != true) || options[:fragment] == false
+        "#{base}/v#{version}"
+      else
+        "#{base}/v#{version}##{options[:encode_fragment] ? encode_fragment(fragment) : fragment}"
+      end
+    end
+
+    def ==(other)
+      unless TentType === other
+        if String === other
+          other = TentType.new(other)
+        else
+          return false
+        end
+      end
+
+      base == other.base && version == other.version && has_fragment? == other.has_fragment? && fragment == other.fragment
+    end
+
+    private
+
+    def parse_uri(uri)
+      if uri == ALL
+        @base = uri
+      elsif m = %r{\A(.+?)/v(.+?)(#(.+)?)?\Z}.match(uri.to_s)
+        m, @base, @version, @fragment_separator, @fragment = m.to_a
+        @fragment = decode_fragment(@fragment) if @fragment
+        @version = @version
+      end
+    end
+
+    def decode_fragment(fragment)
+      return unless fragment
+      f, *r = URI.decode(fragment).split('#')
+      ([f] + r.map { |_f| decode_fragment(_f) }).join('#')
+    end
+
+    def encode_fragment(fragment)
+      return unless fragment
+      parts = fragment.split('#')
+      parts.reverse.inject(nil) { |m, _p| URI.encode("#{_p}#{m ? '#' + m : ''}") }
+    end
+  end
+end

data/lib/tent-client/version.rb

@@ -1,3 +1,3 @@
 class TentClient
-  VERSION = '0.0.1'
+  VERSION = "0.2.1"
 end

data/spec/cycle_http_spec.rb

@@ -0,0 +1,213 @@
+require 'spec_helper'
+require 'tent-client/cycle_http'
+
+describe TentClient::CycleHTTP do
+
+  let(:http_stubs) { Faraday::Adapter::Test::Stubs.new }
+  let(:server_urls) { %w(http://example.org/tent http://foo.example.com/tent http://baz.example.com/tent) }
+  let(:entity_uri) { server_urls.first }
+  let(:server_meta) {
+    {
+      "content" => {
+        "entity" => entity_uri,
+        "previous_entities" => [],
+        "servers" => server_urls.each_with_index.map { |server_url, index|
+          {
+            "version" => "0.3",
+            "urls" => {
+              "oauth_auth" => "#{server_url}/oauth/authorize",
+              "oauth_token" => "#{server_url}/oauth/token",
+              "posts_feed" => "#{server_url}/posts",
+              "new_post" => "#{server_url}/posts",
+              "post" => "#{server_url}/posts/{entity}/{post}",
+              "post_attachment" => "#{server_url}/posts/{entity}/{post}/attachments/{name}?version={version}",
+              "batch" => "#{server_url}/batch",
+              "server_info" => "#{server_url}/server"
+            },
+            "preference" => index
+          }
+        }
+      }
+    }
+  }
+  let(:client_options) {
+    {
+      :server_meta => server_meta
+    }
+  }
+  let(:client) { TentClient.new(entity_uri, client_options) }
+
+  def expect_server(env, url)
+    expect(env[:url].to_s).to match(url)
+  end
+
+  it 'proxies http verbs to Faraday' do
+    cycle_http = described_class.new(client) do |f|
+      f.adapter :test, http_stubs
+    end
+
+    post_entity = 'https://randomentity.example.org/xyz'
+    post_id = 'someid'
+    %w{ head get put patch post delete options }.each { |verb|
+      http_stubs.send(verb, "/tent/posts/#{URI.encode_www_form_component(post_entity)}/#{post_id}") { |env|
+        expect_server(env, server_urls.first)
+        [200, {}, '']
+      }
+
+      expect(cycle_http).to respond_to(verb)
+      cycle_http.send(verb, :post, :entity => post_entity, :post => post_id)
+    }
+
+    http_stubs.verify_stubbed_calls
+  end
+
+  it 'builds multipart requests' do
+    cycle_http = described_class.new(client) do |f|
+      f.adapter :net_http
+    end
+
+    http_stubs = []
+    body = "--#{TentClient::MULTIPART_BOUNDARY}\r\nContent-Disposition: form-data; name=\"photos[0]\"; filename=\"foo.png\"\r\nContent-Length: 17\r\nContent-Type: image/png\r\nContent-Transfer-Encoding: binary\r\n\r\nFake photo data 1\r\n--#{TentClient::MULTIPART_BOUNDARY}\r\nContent-Disposition: form-data; name=\"photos[1]\"; filename=\"bar.png\"\r\nContent-Length: 17\r\nContent-Type: image/png\r\nContent-Transfer-Encoding: binary\r\n\r\nFake photo data 2\r\n--#{TentClient::MULTIPART_BOUNDARY}\r\nContent-Disposition: form-data; name=\"documentation\"; filename=\"README.txt\"\r\nContent-Length: 17\r\nContent-Type: text/plain\r\nContent-Transfer-Encoding: binary\r\n\r\nSome instructions\r\n--#{TentClient::MULTIPART_BOUNDARY}--\r\n\r\n"
+
+    %w{ put patch post }.each { |verb|
+      http_stubs << stub_request(verb.to_sym, "#{server_urls.first}/posts").with(
+        :header => {
+          'Content-Type' => "#{TentClient::MULTIPART_CONTENT_TYPE};boundary=#{TentClient::MULTIPART_BOUNDARY}",
+          'Content-Length' => body.length
+        }
+      ).with { |request|
+        request.body.to_s.split(%r{-+#{TentClient::MULTIPART_BOUNDARY}-*\r\n}).sort == body.split(%r{-+#{TentClient::MULTIPART_BOUNDARY}-*\r\n}).sort
+      }
+
+      expect(cycle_http).to respond_to(:multipart_request)
+      cycle_http.multipart_request(verb, :new_post, {}, [
+        {
+          :filename => 'foo.png',
+          :content_type => 'image/png',
+          :data => 'Fake photo data 1',
+          :category => 'photos'
+        },
+        {
+          :filename => 'bar.png',
+          :content_type => 'image/png',
+          :data => 'Fake photo data 2',
+          :category => 'photos'
+        },
+        {
+          :filename => 'README.txt',
+          :content_type => 'text/plain',
+          :data => 'Some instructions',
+          :category => 'documentation'
+        }
+      ])
+    }
+
+    http_stubs.each do |stub|
+      expect(stub).to have_been_requested
+    end
+  end
+
+  it 'builds multipart requests with custom headers' do
+    cycle_http = described_class.new(client) do |f|
+      f.adapter :net_http
+    end
+
+    http_stubs = []
+    body = "--#{TentClient::MULTIPART_BOUNDARY}\r\nContent-Disposition: form-data; name=\"photos\"; filename=\"foo.png\"\r\nContent-Length: 17\r\nContent-Type: image/vnd.foo.bar.v0+png\r\nContent-Transfer-Encoding: binary\r\nFoo: Bar\r\n\r\nFake photo data 1\r\n--#{TentClient::MULTIPART_BOUNDARY}--\r\n\r\n"
+
+    %w{ put patch post }.each { |verb|
+      http_stubs << stub_request(verb.to_sym, "#{server_urls.first}/posts").with(
+        :body => body,
+        :header => {
+          'Content-Type' => "#{TentClient::MULTIPART_CONTENT_TYPE};boundary=#{TentClient::MULTIPART_BOUNDARY}",
+          'Content-Length' => body.length
+        }
+      )
+
+      expect(cycle_http).to respond_to(:multipart_request)
+      cycle_http.multipart_request(verb, :new_post, {}, [
+        {
+          :filename => 'foo.png',
+          :content_type => 'image/png',
+          :data => 'Fake photo data 1',
+          :category => 'photos',
+          :headers => {
+            'Content-Type' => "image/vnd.foo.bar.v0+png",
+            'Foo' => 'Bar'
+          }
+        }
+      ])
+    }
+
+    http_stubs.each do |stub|
+      expect(stub).to have_been_requested
+    end
+  end
+
+  it 'retries http with next server url' do
+    http_stubs.get('/tent/posts') { |env|
+      expect_server(env, server_urls.first)
+      [500, {}, '']
+    }
+
+    http_stubs.get('/tent/posts') { |env|
+      expect_server(env, server_urls[1])
+      [300, {}, '']
+    }
+
+    http_stubs.get('/tent/posts') { |env|
+      expect_server(env, server_urls.last)
+      [200, {}, '']
+    }
+
+    cycle_http = described_class.new(client) do |f|
+      f.adapter :test, http_stubs
+    end
+
+    res = cycle_http.get(:new_post)
+
+    http_stubs.verify_stubbed_calls
+
+    expect(res.env[:tent_server]).to_not be_nil
+  end
+
+  it 'returns response when on last server url' do
+    http_stubs.get('/tent/posts') { |env|
+      expect_server(env, server_urls.first)
+      raise Faraday::Error::TimeoutError.new("")
+    }
+
+    http_stubs.get('/tent/posts') { |env|
+      expect_server(env, server_urls[1])
+      raise Faraday::Error::ConnectionFailed.new("")
+    }
+
+    http_stubs.get('/tent/posts') { |env|
+      expect_server(env, server_urls.last)
+      [300, {}, '']
+    }
+
+    http_stubs.get('/tent/posts') { |env|
+      raise StandardError, 'expected stub not be called bus was'
+    }
+
+    cycle_http = described_class.new(client) do |f|
+      f.adapter :test, http_stubs
+    end
+
+    cycle_http.get(:new_post)
+  end
+
+  it 'encodes flat params' do
+    http_stubs.get('/tent/posts') { |env|
+      expect(env[:url].query).to match("color=red")
+      expect(env[:url].query).to match("color=blue")
+    }
+
+    cycle_http = described_class.new(client) do |f|
+      f.adapter :test, http_stubs
+    end
+
+    cycle_http.get(:new_post, :color => ['red', 'blue'])
+  end
+end