delicious 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 74e4142660e75f2be6e0d7bcd9380325bce9a431
+  data.tar.gz: 3dcecc74b8d2dde8cec29e100618b80068634e00
+SHA512:
+  metadata.gz: 9255873581070289605152cd08bc9eddc3a5279832f00fceb1f3d06eba16a42635fd0cefa8466c92814576ad3e8058a37c9a3398811b167209fb862ff111276b
+  data.tar.gz: 077a8f74f29452afc263b67aef2a88166fdc2592e112c0fc719928280a575dfcfcb899a1c190c4723eeacc0d2bf6946da758bfa5587976c765d6c54bae633540

data/delicious.gemspec

@@ -0,0 +1,28 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'delicious/version'
+
+Gem::Specification.new do |spec|
+  spec.add_dependency 'faraday'
+  spec.add_dependency 'faraday_middleware'
+  spec.add_dependency 'multi_xml'
+  spec.add_dependency 'activemodel'
+  spec.add_dependency 'activesupport'
+
+  spec.add_development_dependency 'bundler', '~> 1.0'
+
+  spec.authors = ['Andrey Chernih']
+  spec.description = 'Ruby wrapper for delicious.com API'
+  spec.email = %w(andrey.chernih@gmail.com)
+  spec.files = %w(delicious.gemspec)
+  spec.files += Dir.glob('lib/**/*.rb')
+  spec.files += Dir.glob('spec/**/*')
+  spec.homepage = 'http://github.com/andreychernih/delicious'
+  spec.licenses = ['Apache 2.0']
+  spec.name = 'delicious'
+  spec.require_paths = %w(lib)
+  spec.required_rubygems_version = '>= 1.3.5'
+  spec.summary = spec.description
+  spec.test_files = Dir.glob('spec/**/*')
+  spec.version = Delicious.version
+end

data/lib/delicious.rb

@@ -0,0 +1,39 @@
+module Delicious
+  autoload :Client,   'delicious/client'
+  autoload :ApiModel, 'delicious/api_model'
+  autoload :Post,     'delicious/post'
+  autoload :Bundle,   'delicious/bundle'
+  autoload :Tag,      'delicious/tag'
+  autoload :Error,    'delicious/error'
+
+  module Bookmarks
+    autoload :Api, 'delicious/bookmarks/api'
+
+    module Methods
+      autoload :All,    'delicious/bookmarks/methods/all'
+      autoload :Create, 'delicious/bookmarks/methods/create'
+      autoload :Delete, 'delicious/bookmarks/methods/delete'
+    end
+  end
+
+  module Bundles
+    autoload :Api, 'delicious/bundles/api'
+
+    module Methods
+      autoload :Find,   'delicious/bundles/methods/find'
+      autoload :All,    'delicious/bundles/methods/all'
+      autoload :Delete, 'delicious/bundles/methods/delete'
+      autoload :Set,    'delicious/bundles/methods/set'
+    end
+  end
+
+  module Tags
+    autoload :Api, 'delicious/tags/api'
+
+    module Methods
+      autoload :All,    'delicious/tags/methods/all'
+      autoload :Delete, 'delicious/tags/methods/delete'
+      autoload :Rename, 'delicious/tags/methods/rename'
+    end
+  end
+end

data/lib/delicious/api_model.rb

@@ -0,0 +1,26 @@
+require 'active_support/concern'
+
+module Delicious
+
+  module ApiModel
+    extend ActiveSupport::Concern
+
+    included do
+      attr_writer :persisted, :delicious_client
+    end
+
+    def persisted?
+      !!@persisted
+    end
+
+    module ClassMethods
+      def build_persisted(client, attrs)
+        obj = new attrs
+        obj.persisted = true
+        obj.delicious_client = client
+        obj
+      end
+    end
+  end
+
+end

data/lib/delicious/bookmarks/api.rb

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

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

@@ -0,0 +1,112 @@
+require 'active_support/concern'
+
+module Delicious
+  module Bookmarks
+    module Methods
+
+      module All
+        extend ActiveSupport::Concern
+
+        class Criteria
+          include Enumerable
+
+          def self.param(param)
+            method, query_param = param.is_a?(Hash) ? param.first : [param, param]
+            define_method method do |value|
+              params[query_param] = value
+              self
+            end
+          end
+
+          # @!method limit(count)
+          #   Sets the limit
+          #
+          #   @param count [Integer] How many bookmarks server should return at most
+          #   @return [Criteria]
+          param limit: :results
+          # @!method offset(count)
+          #   Sets the offset
+          #
+          #   @param count [Integer] How many bookmarks server should skip
+          #   @return [Criteria]
+          param offset: :start
+          # @!method tag(name)
+          #   Sets tag-based filtering
+          #
+          #   @param name [String] Name of the tag
+          #   @return [Criteria]
+          param :tag
+
+          def initialize(&block)
+            @fetch = block
+          end
+
+          # Sets starting date and time for which you want to get bookmarks
+          #
+          # @!macro [new] time_criteria
+          #   @param date [String,Time,DateTime] `String` time represenation or any object which responds to `strftime`
+          #   @return [Criteria]
+          def from(date)
+            params[:fromdt] = format_time(date)
+            self
+          end
+
+          # Sets ending date and time for which you want to get bookmarks
+          #
+          # @!macro time_criteria
+          def to(date)
+            params[:todt] = format_time(date)
+            self
+          end
+
+          # Fetches bookmarks from server filtering by current criteria
+          def each(&block)
+            @fetch.call(self).each(&block)
+          end
+
+          def params
+            @params ||= {}
+          end
+
+          private
+
+          def format_time(time)
+            time = Time.parse(time) if time.respond_to?(:to_str)
+            time.strftime "%FT%TZ"
+          end
+        end
+
+        # Returns all bookmarks associated with given access token. Results can be paginated:
+        #
+        # ```ruby
+        # client.all.offset(150).limit(50).to_a
+        # ```
+        #
+        # And filtered by date and tag:
+        #
+        # ```ruby
+        # client.all.tag('angular').from('2013/11/12 10:23:00').to('2013/11/13 12:10:00')
+        # ```
+        #
+        # @see Criteria
+        # @return [Criteria]
+        def all
+          Criteria.new do |criteria|
+            response = @client.connection.get '/v1/posts/all', criteria.params.merge(tag_separator: 'comma')
+            posts = response.body['posts'] ? response.body['posts']['post'] : []
+            posts.map do |post_attrs|
+              Delicious::Post.build_persisted @client,
+                url:         post_attrs['href'],
+                description: post_attrs['description'],
+                extended:    post_attrs['extended'],
+                tags:        post_attrs['tag'],
+                dt:          post_attrs['time'],
+                shared:      (post_attrs['shared'] == 'yes')
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/delicious/bookmarks/methods/create.rb

@@ -0,0 +1,57 @@
+require 'active_support/concern'
+
+module Delicious
+  module Bookmarks
+    module Methods
+
+      module Create
+        extend ActiveSupport::Concern
+
+        # Create new bookmark
+        #
+        # @example
+        #   client.bookmarks.create url: 'http://example.com',
+        #                           description: 'Example website',
+        #                           extended: 'Extended information',
+        #                           tags: %w(tag1 tag2),
+        #                           dt: '2014-04-15T10:20:00Z',
+        #                           shared: true,
+        #                           replace: false
+        #
+        # @param attrs [Hash] Bookmark attributes
+        # @return [Post]
+        def create(attrs)
+          post = Delicious::Post.new url:         attrs[:url],
+                                     description: attrs[:description],
+                                     extended:    attrs[:extended],
+                                     tags:        attrs[:tags],
+                                     dt:          attrs[:dt],
+                                     shared:      attrs[:shared]
+
+          if post.valid?
+            response = @client.connection.post '/v1/posts/add', post_attrs(post, attrs[:replace])
+            code = response.body['result']['code']
+            fail Delicious::Error, code unless 'done' == code
+            post.persisted = true
+            post.delicious_client = @client
+          end
+
+          post
+        end
+
+        private
+
+        def post_attrs(post, replace = false)
+          { url:         post.url,
+            description: post.description,
+            extended:    post.extended,
+            tags:        post.tags.join(','),
+            dt:          post.dt,
+            shared:      post.shared ? 'yes' : 'no',
+            replace:     replace ? 'yes' : 'no' }
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'active_support/concern'
+
+module Delicious
+  module Bookmarks
+    module Methods
+
+      module Delete
+        extend ActiveSupport::Concern
+
+        # Deletes bookmark with given URL
+        #
+        # @param url [String] Bookmark URL
+        # @return [Boolean] `true` on successful deletion, `false` otherwise
+        def delete(url)
+          response = @client.connection.post '/v1/posts/delete', url: url
+          code = response.body['result']['code']
+          'done' == code
+        end
+      end
+
+    end
+  end
+end

data/lib/delicious/bundle.rb

@@ -0,0 +1,43 @@
+require 'active_model'
+
+module Delicious
+  class Bundle
+    include ActiveModel::Model
+    include ActiveModel::Validations
+    include ApiModel
+
+    attr_accessor :name, :tags
+
+    validates :name, presence: true
+    validates :tags, presence: true
+
+    # Deletes this bundle
+    #
+    # @raise [Delicious::Error] if bundle was not saved yet
+    # @return [Boolean] `true` upon successful deletion, `false` otherwise
+    def delete
+      if persisted? && @delicious_client
+        @delicious_client.bundles.delete bundle: name
+      else
+        fail Delicious::Error, 'Bundle was not saved yet'
+      end
+    end
+
+    # Creates or updates bundle
+    #
+    # @raise [Delicious::Error] if bundle is not associated with Delicious::Client or save failed
+    # @return [Boolean] `true` when saved
+    def save
+      if @delicious_client
+        @delicious_client.bundles.set name, tags
+        true
+      else
+        fail 'Bundle was not saved yet'
+      end
+    end
+
+    def to_s
+      %Q(Delicious::Bundle(name: "#{name}", tags: #{tags}))
+    end
+  end
+end

data/lib/delicious/bundles/api.rb

@@ -0,0 +1,20 @@
+module Delicious
+  module Bundles
+
+    class Api
+      include Methods::Find
+      include Methods::All
+      include Methods::Delete
+      include Methods::Set
+
+      def self.model_attrs(attrs)
+        { name: attrs['name'], tags: attrs['tags'].split(' ') }
+      end
+
+      def initialize(client)
+        @client = client
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'active_support/concern'
+
+module Delicious
+  module Bundles
+    module Methods
+
+      module All
+        extend ActiveSupport::Concern
+
+        # Get all user bundles
+        #
+        # @return [Array<Bundle>] List of bundles
+        def all
+          response = @client.connection.get '/v1/tags/bundles/all'
+          response.body['bundles']['bundle'].map do |attrs|
+            Bundle.build_persisted @client, self.class.model_attrs(attrs)
+          end
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+require 'active_support/concern'
+
+module Delicious
+  module Bundles
+    module Methods
+
+      module Delete
+        extend ActiveSupport::Concern
+
+        # Delete bundle with given name
+        #
+        # @param name [String] Bundle name
+        # @return [Boolean] `true` upon a successful deletion, `false` otherwise
+        def delete(name)
+          response = @client.connection.post '/v1/tags/bundles/delete', bundle: name
+          code = response.body['result']['code']
+          'done' == code
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'active_support/concern'
+
+module Delicious
+  module Bundles
+    module Methods
+
+      module Find
+        extend ActiveSupport::Concern
+
+        # Find a bundle with given name
+        #
+        # @param name [String] Bundle name
+        # @return [Bundle, nil] Found bundle or `nil` if it was not found
+        def find(name)
+          response = @client.connection.get '/v1/tags/bundles/all', bundle: name
+          bundle = response.body['bundles']['bundle']
+          Bundle.build_persisted @client, self.class.model_attrs(bundle)
+        rescue Faraday::ParsingError => e
+          # it's ridiculous, but delicious returns invalid XML response when bundle is missing
+          nil
+        end
+      end
+
+    end
+  end
+end