ruby_pocket 0.1.1

data/lib/ruby_pocket/web_page.rb

@@ -0,0 +1,33 @@
+module RubyPocket
+  HttpError = Class.new RubyPocketError
+
+  class WebPage
+    class << self
+      alias :for :new
+    end
+
+    def initialize(url, scrapper = nil)
+      fetch_page url, scrapper
+    end
+
+    def title
+      @page.title
+    end
+
+    private
+
+    def fetch_page(url, scrapper)
+      @page = (scrapper || default_scrapper).get(url)
+    rescue SocketError => e
+      raise HttpError, 'Got a socket error'
+    rescue Mechanize::ResponseCodeError => e
+      raise HttpError, "#{e.response_code} response code"
+    end
+
+    def default_scrapper
+      require 'mechanize'
+
+      Mechanize.new
+    end
+  end
+end

data/lib/ruby_pocket.rb

@@ -0,0 +1,37 @@
+require 'etc'
+require 'ruby_pocket/version'
+require 'ruby_pocket/environment'
+
+module RubyPocket
+  RubyPocketError = Class.new StandardError
+
+  class << self
+    attr_accessor :environment
+
+    def environment=(environment)
+      @environment = Environment.new(environment)
+    end
+
+    def environment
+      self.environment = 'PRODUCTION' unless @environment
+      @environment
+    end
+
+    def setup_data_dir
+      return unless environment.production?
+      return if Dir.exist?(data_dir)
+
+      Dir.mkdir data_dir
+    end
+
+    def data_dir
+      @data_dir ||= File.join(home_dir, '.ruby_pocket')
+    end
+
+    private
+
+    def home_dir
+      Etc.getpwuid.dir
+    end
+  end
+end

data/test/ruby_pocket/cli/options_test.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+require 'ruby_pocket/cli/options'
+
+module RubyPocket
+  module Cli
+    class OptionsTest < DefaultTestCase
+      def test_has_an_action
+        options = Options.new
+        options.action = :add
+
+        assert_equal :add, options.action
+      end
+
+      def test_cant_assign_two_subsequent_actions
+        options = Options.new
+        options.action = :add
+
+        error = assert_raises(ArgumentError) do
+          options.action = :list
+        end
+
+        assert_match %r(list and add), error.message
+      end
+
+      def test_validate_fails_when_has_no_action
+        options = Options.new
+
+        error = assert_raises(ArgumentError) do
+          options.validate!
+        end
+
+        assert_match %r(supply an action), error.message
+      end
+
+      def test_validate_succeeds_when_has_an_action
+        options = Options.new
+        options.action = :add
+
+        assert_nil options.validate!
+      end
+
+      def test_has_a_values_hash
+        options = Options.new
+
+        assert_equal Hash.new, options.values
+      end
+    end
+  end
+end

data/test/ruby_pocket/favorite_creator_test.rb

@@ -0,0 +1,80 @@
+require 'test_helper'
+require 'minitest/mock'
+require 'ruby_pocket/favorite_creator'
+
+module RubyPocket
+  class FavoriteCreatorTest < DatabaseTestCase
+    def test_does_not_inject_a_persisted_favorite
+      persisted_favorite = Favorite.create url: 'http://www.rubytapas.com'
+      creator = build_favorite_creator({})
+
+      error = assert_raises StandardError do
+        creator.favorite = persisted_favorite
+      end
+
+      assert_match %r(new favorite), error.message
+    end
+
+    def test_when_no_name_present_in_values_fetches_web_page_from_url
+      url = 'http://www.rubytapas.com'
+
+      values = { name: nil, url: url }
+      favorite = Favorite.new
+      web_page = web_page_mock(url, page_title: 'Ruby Tapas')
+
+      creator = build_favorite_creator(values, favorite, web_page)
+      creator.save
+
+      assert web_page.verify
+    end
+
+    def test_when_no_name_present_in_values_fetches_name_from_web_pages_title
+      url = 'http://www.rubytapas.com'
+
+      values = { name: nil, url: url }
+      favorite = Favorite.new
+      web_page = web_page_mock(url, page_title: 'Ruby Tapas')
+
+      creator = build_favorite_creator(values, favorite, web_page)
+      creator.save
+
+      assert_equal 'Ruby Tapas', favorite.name
+    end
+
+    def test_does_not_save_favorite_when_values_are_invalid
+      favorite = Favorite.new
+      creator = build_favorite_creator({}, favorite)
+
+      error = assert_raises ValidationError do
+        assert_not creator.save
+      end
+
+      assert_equal 'url is not present', error.message
+    end
+
+    def test_saves_favorite_when_values_are_valid
+      favorite = Favorite.new
+      params = { name: 'RubyTapas', url: 'http://www.rubytapas.com' }
+      creator = build_favorite_creator(params, favorite)
+
+      assert creator.save
+      assert_not favorite.new?
+    end
+
+    private
+
+    def build_favorite_creator(values, favorite = nil, web_page = nil)
+      FavoriteCreator.new(values).tap do |creator|
+        creator.favorite = favorite if favorite
+        creator.web_page = web_page if web_page
+      end
+    end
+
+    def web_page_mock(url, page_title: 'Ruby Tapas')
+      contents = OpenStruct.new(title: page_title)
+
+      web_page_class = Minitest::Mock.new
+      web_page_class.expect :for, contents, [url]
+    end
+  end
+end

data/test/ruby_pocket/favorite_query_test.rb

@@ -0,0 +1,98 @@
+require 'test_helper'
+require 'support/favorite_factory'
+require 'ruby_pocket/favorite_query'
+
+module RubyPocket
+  class FavoriteQueryTest < DatabaseTestCase
+    include FavoriteFactory
+
+    def test_finds_all_favorites
+      ruby_flow = create_favorite(url: 'http://www.rubyflow.com')
+      ruby_tapas = create_favorite(url: 'http://www.rubytapas.com')
+
+      favorites = FavoriteQuery.new.all
+
+      assert_equal [ruby_flow, ruby_tapas], favorites
+    end
+
+    def test_when_no_tag_names_finds_all_favorites
+      ruby_flow = create_favorite(url: 'http://www.rubyflow.com')
+      ruby_tapas = create_favorite(url: 'http://www.rubytapas.com')
+
+      favorites = FavoriteQuery.new.where(tag_names: nil).all
+
+      assert_equal [ruby_flow, ruby_tapas], favorites
+    end
+
+    def test_finds_favorite_by_tag_name
+      create_favorite(
+        url: 'http://www.rubyflow.com',
+        tag_names: %w(ruby)
+      )
+      microservices = create_favorite(
+        url: 'http://martinfowler.com/microservices',
+        tag_names: %w(microservices)
+      )
+
+      favorites = FavoriteQuery
+        .new
+        .where(tag_names: %w[microservices])
+        .all
+
+      assert_equal [microservices], favorites
+    end
+
+    def test_finds_favorite_by_more_than_one_tag_name
+      create_favorite(
+        url: 'http://www.rubyflow.com',
+        tag_names: %w(ruby)
+      )
+      create_favorite(
+        url: 'http://railscasts.com',
+        tag_names: %w(screencasts)
+      )
+      ruby_tapas = create_favorite(
+        url: 'http://www.rubytapas.com',
+        tag_names: %w(ruby screencasts)
+      )
+
+      favorites = FavoriteQuery
+        .new
+        .where(tag_names: %w[ruby screencasts])
+        .all
+
+      assert_equal [ruby_tapas], favorites
+    end
+
+    def test_finds_favorite_by_more_than_one_tag_name_with_chained_syntax
+      create_favorite(
+        url: 'http://www.rubyflow.com',
+        tag_names: %w(ruby)
+      )
+      create_favorite(
+        url: 'http://railscasts.com',
+        tag_names: %w(screencasts)
+      )
+      ruby_tapas = create_favorite(
+        url: 'http://www.rubytapas.com',
+        tag_names: %w(ruby screencasts)
+      )
+
+      favorites = FavoriteQuery
+        .new
+        .where(tag_names: %w[ruby])
+        .where(tag_names: %w[screencasts])
+        .all
+
+      assert_equal [ruby_tapas], favorites
+    end
+
+    def test_fails_when_tag_name_does_not_exist
+      error = assert_raises ArgumentError do
+        FavoriteQuery.new.where(tag_names: %w[microservices]).all
+      end
+
+      assert_match %r(not found), error.message
+    end
+  end
+end

data/test/ruby_pocket/favorite_test.rb

@@ -0,0 +1,76 @@
+require 'test_helper'
+require 'support/favorite_factory'
+require 'ruby_pocket/favorite'
+
+module RubyPocket
+  class FavoriteTest < DatabaseTestCase
+    include FavoriteFactory
+
+    def test_persists_a_favorite
+      favorite = create_favorite
+
+      assert_not favorite.new?
+    end
+
+    def test_url_is_unique
+      create_favorite
+
+      error = assert_raises(Sequel::ValidationFailed) do
+        create_favorite
+      end
+
+      assert_match(/url is already taken/, error.message)
+    end
+
+    def test_name_is_trimmed
+      values = build_values(name: '  Ruby is Cool ')
+      favorite = create_favorite(values)
+
+      assert_equal 'Ruby is Cool', favorite.name
+    end
+
+    def test_favorite_is_persisted_correctly
+      values = build_values
+      favorite = create_favorite
+
+      assert_subset values, favorite.values
+    end
+
+    def test_persists_a_favorite_with_tags
+      values = build_values(tag_names: %w(ruby cool))
+      favorite = create_favorite(values)
+
+      assert_not favorite.new?
+      assert_equal %w(ruby cool), favorite.tags.map(&:name)
+    end
+
+    def test_persists_a_favorite_without_tags
+      favorite = create_favorite
+
+      assert_empty favorite.tags
+    end
+
+    def test_tags_with_equal_names_are_not_duplicated
+      ruby_flow_values = build_values(
+        url: 'http://www.rubyflow.com',
+        tag_names: %w(Ruby)
+      )
+      ruby_flow = create_favorite(ruby_flow_values)
+
+      ruby_tapas_values = build_values(
+        url: 'http://www.rubytapas.com',
+        tag_names: %w(ruby)
+      )
+      ruby_tapas = create_favorite(ruby_tapas_values)
+
+      assert_equal ruby_flow.tags, ruby_tapas.tags
+    end
+
+    def test_favorites_with_tags_are_deleted_without_errors
+      values = build_values(tag_names: %w(one two))
+      favorite = create_favorite(values)
+
+      assert favorite.destroy
+    end
+  end
+end

data/test/ruby_pocket/features/add_test.rb

@@ -0,0 +1,40 @@
+require 'test_helper'
+require 'ruby_pocket/favorite'
+
+module RubyPocket
+  module Cli
+    class AddTest < FeatureTestCase
+      def test_adds_a_favorite
+        url = 'http://www.rubytapas.com'
+        title = 'Ruby Tapas'
+
+        output = run_command_web_mocked("pocket -a #{url}", url, title)
+
+        assert_match %r(Ruby Tapas.+created), output.stdout
+        assert Favorite.find(name: 'Ruby Tapas')
+      end
+
+      def test_adds_a_favorite_with_name_and_tags
+        url = 'http://www.fancyname.com'
+
+        output = run_command("pocket -a #{url} -n 'Fancy Name' -t ruby")
+        added_favorite = Favorite.find(name: 'Fancy Name')
+
+        assert_match %r(Fancy Name.+created), output.stdout
+        assert added_favorite
+        assert_equal %w(ruby), added_favorite.tags.map(&:name)
+      end
+
+      private
+
+      def run_command_web_mocked(command, url, title)
+        run_command(
+          command,
+          MOCK_FEATURE: 'add',
+          WEB_MOCK_URL: url,
+          WEB_MOCK_PAGE_TITLE: title
+        )
+      end
+    end
+  end
+end

data/test/ruby_pocket/features/delete_test.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+require 'support/favorite_factory'
+require 'ruby_pocket/favorite'
+
+module RubyPocket
+  module Cli
+    class DeleteTest < FeatureTestCase
+      include FavoriteFactory
+
+      def test_deletes_one_favorite_by_id
+        favorite = create_favorite
+
+        output = run_command("pocket -d #{favorite.id}")
+
+        assert_match %r(#{favorite.name}.+deleted), output.stdout
+        assert_raises(Sequel::Error) { favorite.reload }
+      end
+
+      def test_deletes_two_favorites_by_id
+        favorite_one = create_favorite
+        favorite_two = create_favorite(
+          name: 'Ruby',
+          url: 'http://www.ruby-lang.org'
+        )
+
+        output = run_command("pocket -d #{favorite_one.id},#{favorite_two.id}")
+
+        assert_match %r(#{favorite_one.name}.+deleted), output.stdout
+        assert_match %r(#{favorite_two.name}.+deleted), output.stdout
+        assert_raises(Sequel::Error) { favorite_one.reload }
+        assert_raises(Sequel::Error) { favorite_two.reload }
+      end
+
+      def test_does_not_delete_favorite_when_not_found
+        favorite = create_favorite
+
+        output = run_command("pocket -d #{favorite.id},1000")
+
+        assert_match %r(#{favorite.name}.+deleted), output.stdout
+        assert_match %r(1000 not found), output.stdout
+        assert_raises(Sequel::Error) { favorite.reload }
+      end
+    end
+  end
+end

data/test/ruby_pocket/features/list_test.rb

@@ -0,0 +1,75 @@
+require 'test_helper'
+require 'support/favorite_factory'
+require 'ruby_pocket/favorite'
+
+module RubyPocket
+  module Cli
+    class ListTest < FeatureTestCase
+      include FavoriteFactory
+
+      def test_lists_available_favorites_with_id_name_and_tags
+        values = build_values(tag_names: %w(ruby))
+        favorite = create_favorite(values)
+
+        output = run_command('pocket -l')
+
+        assert_shows_favorite favorite, output
+      end
+
+      def test_shows_message_when_has_no_favorites
+        output = run_command('pocket -l')
+
+        assert_match %r(is empty), output.stdout
+      end
+
+      def test_searches_for_favorites_by_tags
+        values = {
+          name: 'Ruby Tapas',
+          url: 'http://www.rubytapas.com',
+          tag_names: %w(ruby)
+        }
+        ruby_tapas_favorite = create_favorite(values)
+
+        values = {
+          name: 'Martin Fowler - Microservices article',
+          url: 'http://martinfowler.com/articles/microservices.html',
+          tag_names: %w(microservices)
+        }
+        microservices_favorite = create_favorite(values)
+
+        output = run_command('pocket -l -t microservices')
+
+        assert_not_shows_favorite ruby_tapas_favorite, output
+        assert_shows_favorite microservices_favorite, output
+      end
+
+      def test_searches_for_favorites_by_more_than_one_tag
+        values = {
+          name: 'Ruby Tapas',
+          url: 'http://www.rubytapas.com',
+          tag_names: %w(ruby screencasts)
+        }
+        ruby_tapas_favorite = create_favorite(values)
+
+        values = {
+          name: 'Ruby Flow',
+          url: 'http://www.rubyflow.com',
+          tag_names: %w(ruby aggregator)
+        }
+        ruby_flow_favorite = create_favorite(values)
+
+        output = run_command('pocket -l -t ruby,screencasts')
+
+        assert_shows_favorite ruby_tapas_favorite, output
+        assert_not_shows_favorite ruby_flow_favorite, output
+      end
+
+      def test_shows_an_error_when_tag_not_found
+        output = run_command('pocket -l -t microservices')
+
+        assert_match %r(Tag.+not found), output.stderr
+        assert_empty output.stdout
+      end
+    end
+  end
+end

data/test/ruby_pocket/tag_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+require 'ruby_pocket/tag'
+
+module RubyPocket
+  class TagTest < DatabaseTestCase
+    def test_tag_name_is_unique
+      Tag.create name: 'ruby'
+
+      error = assert_raises Sequel::ValidationFailed do
+        Tag.create name: 'ruby'
+      end
+
+      assert_match 'name is already taken', error.message
+    end
+
+    def test_trims_white_space_from_tag_name
+      tag = Tag.create(name: ' Ruby  ')
+
+      assert_equal 'ruby', tag.name
+    end
+
+    def test_downcases_tag_name
+      tag = Tag.create(name: 'Ruby')
+
+      assert_equal 'ruby', tag.name
+    end
+
+    def test_puts_dashes_between_words_on_tag_name
+      tag = Tag.create(name: 'Precious Ruby')
+
+      assert_equal 'precious-ruby', tag.name
+    end
+
+    def test_replaces_non_letter_characters_with_dashes_on_tag_name
+      names = ['Precious_Ruby', 'Cool_!#>Precious%$#%%Ruby']
+      tags = names.map { |name| Tag.create(name: name) }
+
+      assert_equal %w(precious-ruby cool-precious-ruby), tags.map(&:name)
+    end
+
+    def test_normalizes_dashes_of_the_tag_name
+      tag = Tag.create(name: 'Precious__Ruby')
+
+      assert_equal 'precious-ruby', tag.name
+    end
+
+    def test_normalizes_spaces_between_words_of_tag_name
+      tag = Tag.create(name: 'Cool  Precious  Ruby')
+
+      assert_equal 'cool-precious-ruby', tag.name
+    end
+  end
+end

data/test/ruby_pocket/web_page_test.rb

@@ -0,0 +1,68 @@
+require 'test_helper'
+require 'support/webmock'
+require 'ruby_pocket/web_page'
+
+module RubyPocket
+  class WebPageTest < DefaultTestCase
+    def test_calls_the_scrapper_with_the_url
+      url = 'http://www.rubytapas.com'
+      scrapper = scrapper_mock(url)
+      WebPage.for(url, scrapper)
+
+      assert scrapper.verify
+    end
+
+    def test_fetches_the_title_from_the_web_page
+      url = 'http://www.rubytapas.com'
+      scrapper = scrapper_mock(url, 'Ruby Tapas')
+      web_page = WebPage.for(url, scrapper)
+
+      assert_equal 'Ruby Tapas', web_page.title
+    end
+
+    def test_throws_http_error_when_url_not_found
+      url = 'http://google.com/does_not_exist'
+      stub_request(:any, url).to_return status: 404
+
+      error = assert_raises(HttpError) do
+        WebPage.for url
+      end
+
+      assert_match %r(404), error.message
+    end
+
+    def test_throws_http_error_when_internal_server_error
+      url = 'http://throwmea500.com'
+      stub_request(:any, url).to_return status: 500
+
+      error = assert_raises(HttpError) do
+        WebPage.for url
+      end
+
+      assert_match %r(500), error.message
+    end
+
+    def test_throws_http_error_url_does_not_exist
+      url = 'http://inexistenturl.com'
+      stub_request(:any, url).to_raise SocketError
+
+      error = assert_raises(HttpError) do
+        WebPage.for url
+      end
+
+      assert_match %r(socket error), error.message
+    end
+
+    private
+
+    def scrapper_mock(url, title = nil)
+      title ||= 'Ruby Tapas'
+
+      page = OpenStruct.new(title: title)
+
+      scrapper = Minitest::Mock.new
+      scrapper.expect :get, page, [url]
+      scrapper
+    end
+  end
+end

data/test/support/add_feature_mocker.rb

@@ -0,0 +1,37 @@
+require_relative 'webmock'
+
+class AddFeatureMocker
+  include WebMock::API
+
+  def run
+    return unless url && page_title
+
+    stub_request(:any, url).to_return(
+      body: html_body,
+      status: 200,
+      headers: { 'Content-Type': 'text/html' }
+    )
+  end
+
+  def url
+    ENV['WEB_MOCK_URL']
+  end
+
+  def page_title
+    ENV['WEB_MOCK_PAGE_TITLE']
+  end
+
+  def html_body
+    <<-HTML
+    <!DOCTYPE html>
+    <html>
+      <head>
+        <title>#{page_title}</title>
+      </head>
+
+      <body>
+      </body>
+    </html>
+    HTML
+  end
+end