delicious 1.0.0

data/lib/delicious/bundles/methods/set.rb

@@ -0,0 +1,27 @@
+require 'active_support/concern'
+
+module Delicious
+  module Bundles
+    module Methods
+
+      module Set
+        extend ActiveSupport::Concern
+
+        # Update bundle tags
+        #
+        # @param name [String] Bundle name
+        # @param tags [Array<String>] List of new tags for given bundle
+        # @raise [Delicious::Error] in case of error
+        # @return [Bundle]
+        def set(name, tags)
+          fail Delicious::Error, "Bundle name can't be blank" if name.nil?
+          fail Delicious::Error, 'Please specify at least 1 tag' unless (tags || []).any?
+          response = @client.connection.post '/v1/tags/bundles/set', bundle: name, tags: tags.join(',')
+          fail Delicious::Error, response.body['result'] unless 'ok' == response.body['result']
+          Bundle.build_persisted @client, name: name, tags: tags
+        end
+      end
+
+    end
+  end
+end

data/lib/delicious/client.rb

@@ -0,0 +1,57 @@
+require 'faraday'
+require 'faraday_middleware'
+require 'multi_xml'
+require 'delicious/version'
+
+module Delicious
+  class Client
+    attr_accessor :access_token
+
+    # Initializes and configures Delicious client. The only requires configuration option
+    # for now is `access_token`. Example:
+    #
+    # ```ruby
+    # client = Delicious::Client.new do |client|
+    #   client.access_token = 'my-access-token'
+    # end
+    # ```
+    def initialize(&block)
+      yield(self) if block_given?
+    end
+
+    # @return [Bookmarks::Api]
+    def bookmarks
+      @bookmarks ||= Bookmarks::Api.new(self)
+    end
+
+    # @return [Bundles::Api]
+    def bundles
+      @bundles ||= Bundles::Api.new(self)
+    end
+
+    # @return [Tags::Api]
+    def tags
+      @tags ||= Tags::Api.new(self)
+    end
+
+    # @return [Faraday::Connection]
+    def connection
+      Faraday.new(url: api_endpoint, headers: headers) do |c|
+        c.request  :url_encoded
+        c.response :xml, content_type: /\bxml$/
+        c.adapter  Faraday.default_adapter
+      end
+    end
+
+    private
+
+    def api_endpoint
+      'https://previous.delicious.com'.freeze
+    end
+
+    def headers
+      { authorization: "Bearer #{access_token}",
+        user_agent:    "delicious-ruby #{Delicious.version}" }.freeze
+    end
+  end
+end

data/lib/delicious/error.rb

@@ -0,0 +1,6 @@
+module Delicious
+
+  class Error < StandardError
+  end
+
+end

data/lib/delicious/post.rb

@@ -0,0 +1,42 @@
+require 'active_model'
+
+module Delicious
+  class Post
+    include ActiveModel::Model
+    include ActiveModel::Validations
+    include ApiModel
+
+    attr_accessor :url, :description, :extended, :tags, :dt, :shared
+
+    validates :url, presence: true
+    validates :description, presence: true
+
+    def tags=(t)
+      @tags = if t.respond_to?(:to_str)
+                t.split(',')
+              else
+                t || []
+              end
+    end
+
+    def shared
+      @shared ||= false
+    end
+
+    # Deletes this bookmark
+    #
+    # @raise [Delicious::Error] if bookmark was not saved yet
+    # @return [Boolean] `true` upon successful deletion, `false` otherwise
+    def delete
+      if persisted? && @delicious_client
+        @delicious_client.bookmarks.delete url: url
+      else
+        fail 'Bookmark was not saved yet'
+      end
+    end
+
+    def to_s
+      %Q(Delicious::Post(url: "#{url}", description: "#{description}", tags: #{tags}, extended: "#{extended}", dt: "#{dt}", shared: #{shared}))
+    end
+  end
+end

data/lib/delicious/tag.rb

@@ -0,0 +1,26 @@
+require 'active_model'
+
+module Delicious
+  class Tag
+    include ActiveModel::Model
+    include ApiModel
+
+    attr_accessor :name, :count
+
+    # Deletes this tag
+    #
+    # @raise [Delicious::Error] if tag was not saved yet
+    # @return [Boolean] `true` upon successful deletion, `false` otherwise
+    def delete
+      if persisted? && @delicious_client
+        @delicious_client.tags.delete(name)
+      else
+        fail Delicious::Error, 'Tag was not saved yet'
+      end
+    end
+
+    def to_s
+      %Q(Tag(name: "#{name}", count: #{count}))
+    end
+  end
+end

data/lib/delicious/tags/api.rb

@@ -0,0 +1,15 @@
+module Delicious
+  module Tags
+
+    class Api
+      include Methods::All
+      include Methods::Delete
+      include Methods::Rename
+      
+      def initialize(client)
+        @client = client
+      end
+    end
+
+  end
+end

data/lib/delicious/tags/methods/all.rb

@@ -0,0 +1,24 @@
+require 'active_support/concern'
+
+module Delicious
+  module Tags
+    module Methods
+
+      module All
+        extend ActiveSupport::Concern
+
+        # Get all tags
+        #
+        # @return [Array<Tag>] List of tags
+        def all
+          response = @client.connection.get '/v1/tags/get'
+          fail Delicious::Error, 'Error getting tags' unless response.body['tags']
+          response.body['tags']['tag'].map do |attrs|
+            Tag.build_persisted @client, name: attrs['tag'], count: attrs['count'].to_i
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/delicious/tags/methods/delete.rb

@@ -0,0 +1,23 @@
+require 'active_support/concern'
+
+module Delicious
+  module Tags
+    module Methods
+
+      module Delete
+        extend ActiveSupport::Concern
+
+        # Deletes tag
+        #
+        # @param tag [String] Tag name
+        # @return [Boolean] `true` on successful deletion
+        def delete(tag)
+          response = @client.connection.post '/v1/tags/delete', tag: tag
+          code = response.body['result']['code']
+          'done' == code
+        end
+      end
+
+    end
+  end
+end

data/lib/delicious/tags/methods/rename.rb

@@ -0,0 +1,24 @@
+require 'active_support/concern'
+
+module Delicious
+  module Tags
+    module Methods
+
+      module Rename
+        extend ActiveSupport::Concern
+
+        # Renames tag
+        #
+        # @param old_name [String] Old tag name
+        # @param new_name [String] New tag name
+        # @return [Boolean] `true` on successful rename
+        def rename(old_name, new_name)
+          response = @client.connection.post '/v1/tags/rename', 'old' => old_name, 'new' => new_name
+          code = response.body['result']['code']
+          'done' == code
+        end
+      end
+
+    end
+  end
+end

data/lib/delicious/version.rb

@@ -0,0 +1,5 @@
+module Delicious
+  def self.version
+    '1.0.0'
+  end
+end

data/spec/delicious/bookmarks/methods/all_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+describe Delicious::Bookmarks::Methods::All do
+  let(:client) do
+    Delicious::Client.new do |config|
+      config.access_token = 'my-access-token'
+    end
+  end
+
+  describe '#all' do
+    let(:result)   { :success }
+    let(:method)   { :get }
+    let(:endpoint) { %r{https:\/\/previous\.delicious\.com\/v1\/posts\/all\?(.+)} }
+    let(:action)   { client.bookmarks.all.to_a }
+    let(:success_body) do
+      <<-EOT
+  <?xml version="1.0" encoding="UTF-8"?>
+  <posts tag="" total="748" user="slurmdrinker">
+    <post description="Angular Classy" extended="" hash="ee7e657f5f5998fbc136e5910080bd85" href="http://davej.github.io/angular-classy/" private="no" shared="yes" tag="angularjs,javascript,controller,angular,angular.js,library" time="2014-04-30T18:12:46Z"/>
+    <post description="Postgresql Array and Hstore Column Reference - Application Development - HoneyCo" extended="" hash="598b527aa58ce750807b9b02308dde07" href="http://tastehoneyco.com/blog/postgresql-array-and-hstore-column-reference/?utm_source=rubyweekly&amp;utm_medium=email/" private="no" shared="yes" tag="postgresql,rails,ruby,postgres,hstore,arrays" time="2014-04-20T18:00:21Z"/>
+  </posts>
+  EOT
+    end
+    let(:failure_body) { '<?xml version="1.0" encoding="UTF-8"?><result code="no bookmarks"/>' }
+
+    before do
+      body = result == :failure ? failure_body : success_body
+      @request = stub_request(method, endpoint)
+        .to_return body: body, headers: {'Content-Type' => 'text/xml; charset=UTF-8'}
+    end
+
+    it_behaves_like 'api action'
+
+    it 'sends /v1/posts/all request' do
+      action
+      expect(WebMock).to have_requested(:get, endpoint)
+    end
+
+    describe 'no bookmarks' do
+      let(:result) { :failure }
+
+      it 'returns empty array' do
+        expect(action).to eq []
+      end
+    end
+
+    describe 'limit / offset' do
+      it 'allows to limit count of results' do
+        client.bookmarks.all.limit(10).to_a
+        expect(WebMock).to have_requested(:get, endpoint).with(query: hash_including({ 'results' => '10' }))
+      end
+
+      it 'allows to start results with given offset' do
+        client.bookmarks.all.offset(10).to_a
+        expect(WebMock).to have_requested(:get, endpoint).with(query: hash_including({ 'start' => '10' }))
+      end
+
+      it 'allows to specify limit and offset at the same time' do
+        client.bookmarks.all.offset(10).limit(15).to_a
+        expect(WebMock).to have_requested(:get, endpoint).with(query: hash_including({ 'start' => '10', 'results' => '15' }))
+      end
+    end
+
+    describe 'filtering' do
+      it 'by tag' do
+        client.bookmarks.all.tag('angular').to_a
+        expect(WebMock).to have_requested(:get, endpoint).with(query: hash_including({ 'tag' => 'angular' }))
+      end
+
+      context 'by date' do
+        it 'accepts Time instances' do
+          from = Time.parse '2013-11-12T10:23:00Z'
+          to = Time.parse '2013-11-13T12:10:00Z'
+          client.bookmarks.all.from(from).to(to).to_a
+          expect(WebMock).to have_requested(:get, endpoint)
+            .with(query: hash_including({ 'fromdt' => '2013-11-12T10:23:00Z',
+                                          'todt'   => '2013-11-13T12:10:00Z' }))
+        end
+
+        it 'accepts strings' do
+          from = '2013/11/12 10:23:00'
+          to = '2013/11/13 12:10:00'
+          client.bookmarks.all.from(from).to(to).to_a
+          expect(WebMock).to have_requested(:get, endpoint)
+            .with(query: hash_including({ 'fromdt' => '2013-11-12T10:23:00Z',
+                                          'todt'   => '2013-11-13T12:10:00Z' }))
+        end
+      end
+    end
+
+    describe 'result' do
+      it 'has 2 items' do
+        expect(action.count).to eq 2
+      end
+
+      describe 'first' do
+        it 'is an instance of Delicious::Post' do
+          expect(action.first).to be_an_instance_of Delicious::Post
+        end
+
+        it 'has attributes set' do
+          post = action.first
+          expect(post.description).to eq 'Angular Classy'
+          expect(post.tags).to eq %w(angularjs javascript controller angular angular.js library)
+          expect(post.shared).to eq true
+          expect(post.dt).to eq '2014-04-30T18:12:46Z'
+        end
+
+        it 'is persisted' do
+          post = action.first
+          expect(post).to be_persisted
+        end
+
+        it 'can be deleted' do
+          post = action.first
+          expect(client.bookmarks).to receive(:delete).with(url: post.url)
+          post.delete
+        end
+      end
+    end
+  end
+end

data/spec/delicious/bookmarks/methods/create_spec.rb

@@ -0,0 +1,120 @@
+require 'spec_helper'
+
+describe Delicious::Bookmarks::Methods::Create do
+  let(:client) do
+    Delicious::Client.new do |config|
+      config.access_token = 'my-access-token'
+    end
+  end
+
+  describe '#create' do
+    let(:result) { :success }
+
+    let(:success_body) { '<?xml version="1.0" encoding="UTF-8"?><result code="done"/>' }
+    let(:failure_body) { '<?xml version="1.0" encoding="UTF-8"?><result code="error adding link"/>' }
+
+    let(:method)   { :post }
+    let(:endpoint) { 'https://previous.delicious.com/v1/posts/add' }
+
+    let(:tags) { 'tag1, tag2' }
+    let(:dt)   { '2014-05-04T22:01:00Z' }
+    let(:attrs) do
+      { url:         'http://example.com/cool-blog-post',
+        description: 'Cool post, eh?',
+        extended:    'Extended info',
+        tags:        tags,
+        dt:          dt,
+        replace:     'no',
+        shared:      'no'
+      }
+    end
+    let(:action) { client.bookmarks.create attrs }
+
+    before do
+      body = result == :failure ? failure_body : success_body
+      @request = stub_request(method, endpoint)
+        .to_return body: body, headers: {'Content-Type' => 'text/xml; charset=UTF-8'}
+    end
+
+    context 'valid attributes given' do
+      it_behaves_like 'api action'
+
+      context 'params' do
+        it 'sends url=http://example.com/cool-blog-post' do
+          action
+          expect(WebMock).to have_requested(:post, endpoint).with { |r| assert_param(r, 'url', 'http://example.com/cool-blog-post') }
+        end
+
+        it 'sends description=Cool post, eh?' do
+          action
+          expect(WebMock).to have_requested(:post, endpoint).with { |r| assert_param(r, 'description', 'Cool post, eh?') }
+        end
+
+        describe 'tags' do
+          context 'comma-separated string' do
+            let(:tags) { 'tag1,tag2' }
+
+            it 'sends tags=tag1, tag2' do
+              action
+              expect(WebMock).to have_requested(:post, endpoint).with { |r| assert_param(r, 'tags', 'tag1,tag2') }
+            end
+          end
+
+          context 'array of tags' do
+            let(:tags) { %w(tag1 tag2) }
+
+            it 'sends tags=tag1, tag2' do
+              action
+              expect(WebMock).to have_requested(:post, endpoint).with { |r| assert_param(r, 'tags', 'tag1,tag2') }
+            end
+          end
+        end
+      end
+
+      describe 'result' do
+        subject { action }
+
+        context 'success' do
+          let(:result) { :success }
+
+          it { should be_an_instance_of Delicious::Post }
+          it 'has url' do
+            expect(subject.url).to eq 'http://example.com/cool-blog-post'
+          end
+          it 'returns not persisted Post object' do
+            expect(subject).to be_persisted
+          end
+        end
+
+        context 'failure' do
+          let(:result) { :failure }
+
+          it 'throws an error' do
+            expect { subject }.to raise_error
+          end
+        end
+      end
+    end
+
+    context 'invalid attributes given' do
+      let(:attrs) do
+        { description: 'Cool site' }
+      end
+
+      it 'does not sends request' do
+        action
+        expect(WebMock).not_to have_requested(:post, endpoint)
+      end
+
+      it 'returns invalid Post object' do
+        p = action
+        expect(p).not_to be_valid
+      end
+
+      it 'returns not persisted Post object' do
+        p = action
+        expect(p).not_to be_persisted
+      end
+    end
+  end
+end