pinup 0.1.0

data/lib/pinup/commands/open.rb

@@ -0,0 +1,25 @@
+require 'launchy'
+
+module Pinup
+  class Open
+    def self.open_pins(options = {})
+      unread   = options[:unread]      unless options[:unread].nil?
+      untagged = options[:untagged]    unless options[:untagged].nil?
+      count    = options[:number].to_i unless options[:number].nil?
+      delete   = options[:delete]      unless options[:delete].nil?
+
+      items        = Pinup::Queries.list_items
+      filtered     = Pinup::Queries.filter_items(items, unread, untagged, count)
+      items_string = Pinup::Queries.item_string(filtered)
+      urls         = items_string.split(/\n/)
+
+      urls.each do |url|
+        Launchy.open(url)
+      end
+
+      if delete
+        Pinup::Queries.delete_items(urls)
+      end
+    end
+  end
+end

data/lib/pinup/queries.rb

@@ -0,0 +1,116 @@
+require 'net/https'
+require 'uri'
+require 'json'
+
+module Pinup
+  class Queries
+    def self.list_items
+      token = Pinup::Settings.get_token
+      if token.nil?
+        return nil
+      end
+
+      parameters = JSON_PARAMS.dup
+      parameters[:auth_token] = token
+
+      response = list_query(parameters)
+      if response.code != '200'
+        puts "Error getting bookmarks: #{ response.body }"
+        return nil
+      else
+        return response.body
+      end
+    end
+
+    def self.filter_items(response, unread, untagged, count)
+      begin
+        json = JSON.parse(response)
+      rescue JSON::ParserError => e
+        puts "Failed to parse JSON: #{ e }"
+        exit
+      end
+
+      count     = 20 if count < 1
+      new_items = []
+
+      json.each do |item|
+        bookmark = Bookmark.new(item)
+
+        if unread && untagged
+          if bookmark.unread || bookmark.untagged
+            new_items << bookmark
+          end
+        elsif unread
+          if bookmark.unread && !bookmark.untagged
+            new_items << bookmark
+          end
+        elsif untagged
+          if bookmark.untagged && !bookmark.unread
+            new_items << bookmark
+          end
+        else
+          if !bookmark.unread && !bookmark.untagged
+            new_items << bookmark
+          end
+        end
+
+        if new_items.count >= count
+          break
+        end
+      end
+
+      return new_items
+    end
+
+    def self.delete_items(urls)
+      token = Pinup::Settings.get_token
+      if token.nil?
+        return nil
+      end
+
+      parameters = JSON_PARAMS.dup
+      parameters[:auth_token] = token
+
+      urls.each do |url|
+        url_params = parameters.dup
+        url_params[:url] = url
+        delete_query(url_params)
+      end
+    end
+
+    def self.item_string(items)
+      item_output = ""
+      items.each do |item|
+        item_output << "#{ item.href }\n"
+      end
+
+      return item_output
+    end
+
+    private
+      
+      def self.list_query(parameters)
+        uri = URI.parse("#{ API_URL }/posts/all")
+        uri.query = URI.encode_www_form(parameters)
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        request = Net::HTTP::Get.new(uri.request_uri)
+        http.request(request)
+      end
+
+      def self.delete_query(parameters)
+        uri = URI.parse("#{ API_URL }/posts/delete")
+        uri.query = URI.encode_www_form(parameters)
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        request = Net::HTTP::Get.new(uri.request_uri)
+        http.request(request)
+      end
+  end
+end

data/lib/pinup/settings.rb

@@ -0,0 +1,89 @@
+require 'yaml'
+require 'netrc'
+require 'colored'
+
+module Pinup
+  class Settings
+    def self.write_settings(settings)
+      File.open(SETTINGS, 'w') do |f|
+        f.write(settings.to_yaml)
+      end
+    end
+
+    def self.read_settings
+      if !File.exists? SETTINGS
+        return nil
+      end
+
+      settings = YAML::load_file(SETTINGS)
+      if !settings || settings.empty?
+        return nil
+      end
+
+      return settings
+    end
+
+    def self.save_token(options = {})
+      path  = DEFAULT_NETRC
+      token = options[:token]
+
+      if token.nil?
+        puts 'Attempted to save empty token'.red
+        return nil
+      end
+
+      if options[:path]
+        path = options[:path]
+      end
+
+      token_split = token.split(/:/)
+      if token_split.count != 2
+        puts "Invalid token #{ token_split.join(':') }".red
+        return nil
+      end
+
+      username = token_split.first
+      password = token_split.last
+      
+      netrc = Netrc.read(path)
+      netrc.new_item_prefix = "\n# This Entry was added automatically\n"
+      netrc[PINBOARD_URL] = username, password
+      netrc.save
+
+      return true
+    end
+
+    def self.get_token
+      path = DEFAULT_NETRC
+
+      settings = read_settings
+      if settings
+        path = settings[:path]
+      end
+
+      netrc = Netrc.read(path)
+      username, password = netrc[PINBOARD_URL]
+      token = token(username, password)
+      if token.nil?
+        puts "There are no credentials in #{ path }".red
+        return nil
+      end
+
+      return token
+    end
+
+    def self.clear_settings
+      if File.exists? SETTINGS
+        File.delete(SETTINGS)
+      end
+    end
+
+    def self.token(username, password)
+      if username.nil? || password.nil? || username.empty? || password.empty?
+        return nil
+      end
+
+      "#{ username }:#{ password }"
+    end
+  end
+end

data/lib/pinup/version.rb

@@ -0,0 +1,8 @@
+module Pinup
+  VERSION       = '0.1.0'
+  SETTINGS      = File.expand_path('~/.pinup')
+  PINBOARD_URL  = 'pinboard.in'
+  API_URL       = 'https://api.pinboard.in/v1'
+  JSON_PARAMS   = { format: 'json' }
+  DEFAULT_NETRC = File.expand_path('~/.netrc')
+end

data/pinup.gemspec

@@ -0,0 +1,24 @@
+require File.join([File.dirname(__FILE__),'lib','pinup','version.rb'])
+spec = Gem::Specification.new do |s| 
+  s.name                  = 'pinup'
+  s.version               = Pinup::VERSION
+  s.author                = 'Keith Smiley'
+  s.email                 = 'keithbsmiley@gmail.com'
+  s.homepage              = 'http://keith.so/'
+  s.required_ruby_version = '>= 1.9.3'
+  s.summary               = 'Digest your Pinboard bookmarks in bulk'
+  s.description           = 'Allows you to open and delete your Pinboard bookmarks in bulk'
+  s.license               = 'MIT'
+
+  s.files                 = `git ls-files`.split($/)
+  s.executables           = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files            = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths         = ['lib']
+
+  s.add_dependency('colored', '~> 1.2')
+  s.add_dependency('netrc', '~> 0.7.7')
+  s.add_dependency('launchy', '~> 2.3.0')
+  s.add_development_dependency('rake')
+  s.add_development_dependency('rspec', '~> 2.13.0')
+  s.add_runtime_dependency('gli','2.5.6')
+end

data/spec/integration/authorize_spec.rb

@@ -0,0 +1,42 @@
+require_relative '../spec_helper'
+
+describe Pinup::Authorize do
+  before do
+    @netrc_path = File.expand_path('~/foobar')
+  end
+
+  describe 'authorize_netrc' do
+    describe 'an empty netrc' do
+      it 'should return nil' do
+        expect(Pinup::Authorize.authorize_netrc({ path: @netrc_path })).to be_nil
+      end
+    end
+
+    describe 'a valid netrc' do
+      it 'should return true' do
+        # This will only pass if your default netrc has a valid username and password (token)
+        expect(Pinup::Authorize.authorize_netrc).to be_true
+      end
+    end
+  end
+
+  describe 'authorize_credentials' do
+    describe 'invalid credentials' do
+      it 'should return nil' do
+        expect(Pinup::Authorize.authorize_credentials({ username: 'foo', password: 'bar' })).to be_nil
+      end
+    end
+
+    describe 'valid credentials' do
+      # Note: this will only work if you set up netrc's for this testing
+      it 'should return true' do
+        netrc = Netrc.read
+        username, password = netrc['test.pinboard.in']
+        expect(username).not_to be_nil
+        expect(password).not_to be_nil
+        result = Pinup::Authorize.authorize_credentials({ username: username, password: password })
+        expect(result).to be_true
+      end
+    end
+  end
+end

data/spec/integration/bookmark_spec.rb

@@ -0,0 +1,97 @@
+require_relative '../spec_helper'
+
+describe Bookmark do
+  describe 'attributes' do
+    before do
+      options = { 'href' => 'http://github.com', 'toread' => 'yes', 'tags' => '' }
+      @bookmark = Bookmark.new(options)
+    end
+
+    it 'should respond to the correct attributes' do
+      expect(@bookmark).to respond_to(:href)
+      expect(@bookmark).to respond_to(:unread)
+      expect(@bookmark).to respond_to(:untagged)
+      expect(@bookmark).not_to respond_to(:foobar)
+    end
+  end
+
+  describe 'initialize' do
+    describe 'unread without tags' do
+      before do
+        options = { 'href' => 'http://github.com', 'toread' => 'yes', 'tags' => '' }
+        @bookmark = Bookmark.new(options)
+      end
+
+      it 'have the correct attributes' do
+        expect(@bookmark).not_to be_nil
+        result = @bookmark.href == 'http://github.com'
+        expect(result).to be_true
+        expect(@bookmark.unread).to be_true
+        expect(@bookmark.untagged).to be_true
+      end
+    end
+
+    describe 'read with tags' do
+      before do
+        options = { 'href' => 'http://google.com', 'toread' => 'no', 'tags' => 'foo' }
+        @bookmark = Bookmark.new(options)
+      end
+
+      it 'have the correct attributes' do
+        expect(@bookmark).not_to be_nil
+        result = @bookmark.href == 'http://google.com'
+        expect(result).to be_true
+        expect(@bookmark.unread).to be_false
+        expect(@bookmark.untagged).to be_false
+      end
+    end
+  end
+
+  describe 'is_unread' do
+    it 'should return true only when toread is "yes"' do
+      expect(Bookmark.is_unread('yes')).to be_true
+    end
+
+    it 'should return false otherwise' do
+      expect(Bookmark.is_unread('false')).to be_false
+      expect(Bookmark.is_unread('no')).to be_false
+      expect(Bookmark.is_unread('foo')).to be_false
+    end
+  end
+
+
+  describe 'is_untagged' do
+    it 'should return true if there is nothing in the tag field' do
+      expect(Bookmark.is_untagged('   ')).to be_true
+      expect(Bookmark.is_untagged("\n \t \r")).to be_true
+    end
+
+    it 'should return false if there is something in the tag field' do
+      expect(Bookmark.is_untagged('foo')).to be_false
+      expect(Bookmark.is_untagged('foo bar')).to be_false
+    end
+  end
+
+  describe 'to_s' do
+    before do
+      options = { 'href' => 'http://google.com', 'toread' => 'no', 'tags' => 'foo' }
+      @bookmark = Bookmark.new(options)
+      @response = @bookmark.to_s
+    end
+
+    it 'should contain the URL' do
+      result = @response.include? 'google.com'
+      expect(result).to be_true
+    end
+
+    it 'should contain unread settings' do
+      result = @response.include? 'Unread: false'
+      expect(result).to be_true
+    end
+
+    it 'should contain the URL' do
+      result = @response.include? 'Untagged: false'
+      expect(result).to be_true
+    end
+  end
+end

data/spec/integration/queries_spec.rb

@@ -0,0 +1,132 @@
+require_relative '../spec_helper'
+
+describe Pinup::Queries do
+  describe 'list_items' do
+    before do
+      items  = Pinup::Queries.list_items
+      @posts = JSON.parse(items)
+    end
+
+    it 'shoud return some number of items' do
+      result = @posts.count > 0
+      expect(result).to be_true
+    end
+  end
+
+  describe 'filter_items' do
+    describe 'read/unread items' do
+      describe 'unread items' do
+        before do
+          items     = Pinup::Queries.list_items
+          @filtered = Pinup::Queries.filter_items(items, true, false, 20)
+        end
+
+        it 'should return only unread items' do
+          @filtered.each do |item|
+            expect(item.unread).to be_true
+            expect(item.untagged).to be_false
+          end
+        end
+      end
+
+      describe 'read items' do
+        before do
+          items = Pinup::Queries.list_items
+          @filtered = Pinup::Queries.filter_items(items, false, false, 20)
+        end
+
+        it 'should return only read items' do
+          @filtered.each do |item|
+            expect(item.unread).to be_false
+            expect(item.untagged).to be_false
+          end
+        end
+      end
+    end
+
+    describe 'untagged/tagged items' do
+      describe 'untagged items' do
+        before do
+          items     = Pinup::Queries.list_items
+          @filtered = Pinup::Queries.filter_items(items, false, true, 20)
+        end
+
+        it 'should return only untagged items' do
+          @filtered.each do |item|
+            expect(item.unread).to be_false
+            expect(item.untagged).to be_true
+          end
+        end
+      end
+
+      describe 'tagged items' do
+        before do
+          items     = Pinup::Queries.list_items
+          @filtered = Pinup::Queries.filter_items(items, false, false, 20)
+        end
+
+        it 'should return only untagged items' do
+          result = @filtered.count > 0
+          expect(result).to be_true
+          @filtered.each do |item|
+            expect(item.unread).to be_false
+            expect(item.untagged).to be_false
+          end
+        end
+      end
+    end
+
+    # Note these will only work if the default pinboard account unread & untagged items
+    describe 'number of items' do
+      describe 'an invalid number' do
+        describe 'zero items' do
+          before do
+            items = Pinup::Queries.list_items
+            @filtered = Pinup::Queries.filter_items(items, false, false, 0)
+          end
+
+          it 'should return the default number of items' do
+            expect(@filtered.count).to equal(20)
+          end
+        end
+
+        describe 'negative items' do
+          before do
+            items = Pinup::Queries.list_items
+            @filtered = Pinup::Queries.filter_items(items, false, false, -9)
+          end
+
+          it 'should return the default number of items' do
+            expect(@filtered.count).to equal(20)
+          end
+        end
+      end
+
+      describe 'some number of unread items' do
+        before do
+          items = Pinup::Queries.list_items
+          @filtered = Pinup::Queries.filter_items(items, false, false, 14)
+        end
+
+        it 'should return the correct number of items' do
+          expect(@filtered.count).to equal(14)
+        end
+      end
+    end
+  end
+
+  describe 'item_string' do
+    before do
+      @item     = Bookmark.new({ "href" => "http://google.com" })
+      @item2    = Bookmark.new({ "href" => "http://github.com" })
+      @urls     = [ @item, @item2 ]
+      @response = Pinup::Queries.item_string(@urls)
+      @string   = "http://google.com\nhttp://github.com\n"
+    end
+
+    it 'should return a correctly formatted string' do
+      result = @response == @string
+      expect(result).to be_true
+    end
+  end
+end