ud 0.1.0 → 0.1.1

data/bin/ud

@@ -1,12 +1,36 @@
 #! /usr/bin/env ruby
 # -*- coding: UTF-8 -*-
 
+require 'trollop'
 require 'ud'
 
-if ARGV.size == 1
-    q = UD.query(ARGV[0])
-    UD.format_results(q)
-else
-    puts "Usage:\n\tud <word>"
+opts = Trollop.options do
+  version "ud #{UD.version}"
+  banner <<-EOS
+UD is a command-line tool to scrape definitions from the Urban Dictionary.
+
+Usage:
+    ud [options] <word(s)>
+where [options] are:
+EOS
+
+  opt :ratio, 'Filter by upvotes/downvotes ratio', :type => :float, :default => 0.0
+  opt :count, 'Limit the number of definitions', :type => :int, :default => 10, :short => '-n'
+  opt :color, 'Use colorized output', :default => true
+  opt :up, 'Shortcut for \'-r 2\''
+
+end
+
+Trollop.die :ratio, 'must be non-negative' if opts[:ratio] < 0
+Trollop.die :count, 'must be non-negative' if opts[:count] < 0
+
+opts[:ratio] = 2 if opts[:up]
+
+if ARGV.empty?
+  puts 'Error: No word provided. Use -h or --help to see the help.'
+  exit 1
 end
 
+q = UD.query(ARGV.join(' '), opts)
+puts UD.format_results(q, opts[:color])
+

data/lib/ud.rb

@@ -6,90 +6,137 @@ require 'json'
 require 'open-uri'
 require 'nokogiri'
 
-module UD
+require File.dirname(__FILE__) + '/ud/formatting'
 
-    # Get the search URL to query for a given term
-    def UD.search_url(term)
-        param = URI.encode_www_form('term' => term)
-        "http://www.urbandictionary.com/define.php?#{param}"
-    end
+# This module provide some methods to scrape definitions from the Urban
+# Dictionary website.
+module UD
 
-    # Get the thumbs (up/down) for a list of definitions (ids)
-    def UD.thumbs(ids)
+  # The current version of the module
+  def UD.version
+    '0.1.1'
+  end
 
-        param = URI.encode_www_form('ids' => ids.join(','))
-        json = open "http://api.urbandictionary.com/v0/uncacheable?#{param}"
+  # Get the search URL to query for a given term.
+  # [term] the term to search for. It must be a string, spaces are allowed
+  def UD.search_url(term='')
+    param = URI.encode_www_form('term' => term)
+    "http://www.urbandictionary.com/define.php?#{param}"
+  end
 
-        response = JSON.parse(json.read)
-        thumbs   = {}
+  # Get the thumbs (up/down) for a list of definitions' ids.
+  # This is an helper for internal usage.
+  def UD.thumbs(ids)
 
-        response['thumbs'].each do |t|
+    param = URI.encode_www_form('ids' => ids.join(','))
+    json = open "http://api.urbandictionary.com/v0/uncacheable?#{param}"
 
-            thumbs[t['defid']] = {
-                :up   => t['thumbs_up'],
-                :down => t['thumbs_down']
-            }
+    response = JSON.parse(json.read)
+    thumbs   = {}
 
-        end
+    response['thumbs'].each do |t|
 
-        thumbs
-    end
+      thumbs[t['defid']] = {
+        :up   => t['thumbs_up'],
+        :down => t['thumbs_down']
+      }
 
-    # Get the text of an element
-    def UD.text(el)
-        el.text.strip.gsub(/\r/, "\n")
-    rescue
-        ''
     end
 
-    # Query the website and return a list of definitions for the provided term.
-    # This list may be empty if there's no results. It only scraps the first
-    # page of results, since it's generally sufficient.
-    def UD.query(term)
-        url = search_url(term)
-        doc = Nokogiri::HTML(open(url))
+    thumbs
+  end
 
-        return [] unless doc.css('#not_defined_yet').empty?
+  # Get the text of an element. This is an helper for internal usage.
+  def UD.text(el)
+    el.text.strip.gsub(/\r/, "\n")
+  rescue
+    ''
+  end
 
-        words = doc.css('.word[data-defid]')
-        ids   = words.map { |w| w.attr('data-defid') }
+  # Query the website and return a list of definitions for the provided term.
+  # This list may be empty if there's no result. It only scraps the first
+  # page of results.
+  # [term] the term to search for
+  # [opts] options. This is used by the command-line tool. +:count+ is the
+  # maximum number of results to return, +:ratio+ is the minimum
+  # upvotes/downvotes ratio. Other options may be added in the future.
+  def UD.query(term, *opts)
 
-        thumbs = thumbs(ids)
+    opts = {:count => 10, :ratio => 0.0}.merge(opts[0] || {})
 
-        ids.map do |id|
+    return [] if opts[:count] <= 0
 
-            word = text doc.css(".word[data-defid=\"#{id}\"] > span").first
-            body = doc.css("#entry_#{id}")
-            t    = thumbs[id.to_i] || {}
+    url = search_url(term)
+    doc = Nokogiri::HTML(open(url))
 
-            {
-                :id => id,
-                :word => word,
-                :definition => text(body.css('.definition')),
-                :example => text(body.css('.example')),
-                :upvotes => t[:up],
-                :downvotes => t[:down]
+    return [] unless doc.css('#not_defined_yet').empty?
 
-            }
+    words = doc.css('.word[data-defid]')
+    ids   = words.take(opts[:count]).map { |w| w.attr('data-defid') }
 
-        end
+    thumbs = thumbs(ids)
 
+    if opts[:ratio] > 0
+      ids.delete_if do |id|
+        t = thumbs[id.to_i] || {:up => 1, :down => 1}
+        (t[:up] / t[:down].to_f) < opts[:ratio]
+      end
     end
 
-    # Format results for output, and print them
-    def UD.format_results(results)
+    ids.map do |id|
 
-        results.each do |r|
+      word = text doc.css(".word[data-defid=\"#{id}\"] > span").first
+      body = doc.css("#entry_#{id}")
+      t    = thumbs[id.to_i] || {}
 
-            puts "* #{r[:word]} (#{r[:upvotes]}/#{r[:downvotes]}):"
-            puts ''
-            puts " \t#{r[:definition].gsub(/\n/, "\n\t")}\n"
-            puts ' Example:'
-            puts " \t#{r[:example].gsub(/\n/, "\n\t")}"
-            puts "\n\n"
+      {
+        :id => id,
+        :word => word,
+        :definition => text(body.css('.definition')),
+        :example => text(body.css('.example')),
+        :upvotes => t[:up],
+        :downvotes => t[:down]
 
-        end
+      }
 
     end
 
+  end
+
+  # Format results for output
+  # [results] this must be an array of results, as returned by +UD.query+.
+  def UD.format_results(results, color=true)
+    require 'colored' if color
+
+    t = '   ' # 4-spaces tab
+
+    results.map do |r|
+
+      word  = r[:word]
+      upvotes = r[:upvotes]
+      downvotes = r[:downvotes]
+
+      if (color)
+        word      = word.bold
+        upvotes   = upvotes.to_s.green
+        downvotes = downvotes.to_s.red
+      end
+
+      votes = "#{upvotes}/#{downvotes}"
+      definition = UD::Formatting.fit(r[:definition], 75).map {|l| t+l}.join("\n")
+      example = UD::Formatting.fit(r[:example], 75).map {|l| t+l}.join("\n")
+
+      s = ''
+
+      s << "* #{word} (#{votes}):\n"
+      s << "\n"
+      s << definition
+      s << "\n\n Example:\n"
+      s << example
+      s << "\n\n"
+
+    end.join("\n")
+
+  end
+
 end

data/lib/ud/formatting.rb

@@ -0,0 +1,15 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+
+module UD
+  module Formatting
+
+    # Fit a text in a given width (number of chars). It returns
+    # a list of lines of text.
+    def self.fit(txt, width=79)
+      # from http://stackoverflow.com/a/7567210/735926
+      txt.split("\n").map{|l| l.scan(/(.{1,#{width}})(?:\s|$)/m) }.flatten
+    end
+
+  end
+end

data/tests/formatting_tests.rb

@@ -0,0 +1,73 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+
+class FakeHTMLElement
+
+  attr_reader :text
+
+  def initialize(txt='')
+    @text = txt
+  end
+end
+
+class UD_Formatting_test < Test::Unit::TestCase
+
+  # == UD#text == #
+
+  def test_text_empty
+    el = FakeHTMLElement.new
+    assert_equal('', UD.text(el))
+  end
+
+  def test_text_trailing_spaces
+    el = FakeHTMLElement.new('foo    ')
+    assert_equal('foo', UD.text(el))
+
+    el = FakeHTMLElement.new(" bar \n")
+    assert_equal('bar', UD.text(el))
+  end
+
+  def test_text_newline
+    el = FakeHTMLElement.new("a\rb")
+    assert_equal("a\nb", UD.text(el))
+
+    el = FakeHTMLElement.new("a\nb")
+    assert_equal("a\nb", UD.text(el))
+  end
+
+  def test_text_invalid_element
+    assert_equal('', UD.text(nil))
+    assert_equal('', UD.text(true))
+    assert_equal('', UD.text('foo'))
+  end
+
+  # == UD#format_results == #
+
+  def test_format_results_empty_list
+    assert_equal('', UD.format_results([]))
+  end
+
+  def test_format_results_one_element
+    res = {
+      :word => 'XYZ',
+      :upvotes => 42,
+      :downvotes => 78,
+      :definition => 'xyz',
+      :example => 'zyx'
+    }
+
+    output = UD.format_results([res], false).strip
+    expected = <<EOS
+* XYZ (42/78):
+
+   xyz
+
+ Example:
+   zyx
+EOS
+
+    assert_equal(expected.strip, output)
+
+  end
+
+end

data/tests/query_tests.rb

@@ -0,0 +1,111 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+
+require File.dirname(__FILE__) + '/fake_responses'
+
+class UD_Formatting_test < Test::Unit::TestCase
+
+  ROOT_URL = 'http://www.urbandictionary.com'
+
+  # == UD#search_url == #
+
+  def test_search_url_empty_term
+    assert_equal(
+      "#{ROOT_URL}/define.php?term=",
+      UD.search_url())
+      assert_equal(
+        "#{ROOT_URL}/define.php?term=",
+        UD.search_url(''))
+  end
+
+  def test_search_url_spaces_in_term
+    assert_equal(
+      "#{ROOT_URL}/define.php?term=a+b",
+      UD.search_url('a b'))
+  end
+
+  def test_search_url_encode_special_chars
+    assert_equal(
+      "#{ROOT_URL}/define.php?term=%3D",
+      UD.search_url('='))
+  end
+
+  def test_search_url
+    assert_equal(
+      "#{ROOT_URL}/define.php?term=foo",
+      UD.search_url('foo'))
+  end
+
+  # == UD#thumbs == #
+
+  def test_thumbs_no_ids
+    assert_equal({}, UD.thumbs([]))
+  end
+
+  def test_thumbs_one_id
+    assert_equal({42 =>{:up => 2, :down => 1}}, UD.thumbs([42]))
+  end
+
+  # == UD#query == #
+
+  def test_query_no_results
+    assert_equal([], UD.query('nothing'))
+  end
+
+  def test_query_two_results
+
+    expected = [
+      {
+        :id => '1',
+        :word => 'foo',
+        :definition => 'A',
+        :example => 'AA',
+        :upvotes => 1,
+        :downvotes => 1
+
+      },
+      {
+        :id => '2',
+        :word => 'bar',
+        :definition => 'B',
+        :example => 'BB',
+        :upvotes => 2,
+        :downvotes => 1
+      }
+    ]
+
+    assert_equal(expected, UD.query('two'))
+  end
+
+  def test_query_count
+    expected = [
+      {
+        :id => '1',
+        :word => 'foo',
+        :definition => 'A',
+        :example => 'AA',
+        :upvotes => 1,
+        :downvotes => 1
+      }
+    ]
+
+    assert_equal(expected, UD.query('two', :count => 1))
+  end
+
+  def test_query_ratio
+    expected = [
+      {
+        :id => '2',
+        :word => 'bar',
+        :definition => 'B',
+        :example => 'BB',
+        :upvotes => 2,
+        :downvotes => 1
+      }
+    ]
+
+    assert_equal(expected, UD.query('two', :ratio => 1.5))
+  end
+
+end
+

data/tests/tests.rb

@@ -0,0 +1,28 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+
+require 'test/unit'
+require 'simplecov'
+
+test_dir = File.expand_path( File.dirname(__FILE__) )
+
+SimpleCov.start { add_filter '/tests/' } if ENV['COVERAGE']
+
+require 'ud'
+
+for t in Dir.glob( File.join( test_dir,  '*_tests.rb' ) )
+  require t
+end
+
+class UDTests < Test::Unit::TestCase
+
+  # == UD#version == #
+
+  def test_ud_version
+    assert(UD.version =~ /^\d+\.\d+\.\d+/)
+  end
+
+end
+
+
+exit Test::Unit::AutoRunner.run

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ud
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,136 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-03 00:00:00.000000000 Z
-dependencies: []
+date: 2013-06-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.9
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.8.0
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: colored
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fakeweb
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Get words' definitions from Urban Dictionary on the command-line.
 email: batifon@yahoo.fr
 executables:
@@ -19,6 +147,10 @@ extensions: []
 extra_rdoc_files: []
 files:
 - lib/ud.rb
+- lib/ud/formatting.rb
+- tests/tests.rb
+- tests/query_tests.rb
+- tests/formatting_tests.rb
 - bin/ud
 homepage: https://github.com/bfontaine/ud
 licenses:
@@ -45,4 +177,7 @@ rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Urban Dictionary unofficial scrapper
-test_files: []
+test_files:
+- tests/tests.rb
+- tests/query_tests.rb
+- tests/formatting_tests.rb