urban_dictionary 0.0.2 → 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MmQ5NjJjOTM5OTBmYWRkMjI0Nzc5ODE5ZGNlZGZiYTljZTNmZjFjZA==
+  data.tar.gz: !binary |-
+    MzQxMDhhNDMxZmNlM2U1ZWUyNjI4OGNmMWEwMjkwOWRlYzQxMjhhZg==
+SHA512:
+  metadata.gz: !binary |-
+    NGRmMWY0Y2MwMWM2NWMyYmMwMjI3NTU2ZDcyNjJjOWJkNGI2NDFlZjNlOGVl
+    MGI1ODIyZTAyN2FhODNkYjIyODhiNGQ5NWEzMmI0OTNlZGQ3Yzg4ZDA5Mzg2
+    Y2M3ZjQ4ZDY2ZjZlNDhjNDE4NWEyOWI2YTU0MjI2OWJkMjI2M2Y=
+  data.tar.gz: !binary |-
+    MjZlMWZhMjA2OWMzY2NhZGI0YzFlZGRmNmIwNTA4YzNlZDQyNTFjMzAxODY0
+    NmZiNmJkOWU5MWI0ZDgxNjFmNTQxNzFiYTRjMTM1NDQzZTg5MTYyZDRhNzdl
+    MWVjZTM5ZjVmMmM3NDExOGRmMGY3MzM5ZjRkOTA2YjBhYTZhNmQ=

data/.gitignore

@@ -1,2 +1,3 @@
 *.gem
+Gemfile.lock
 pkg/*

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+rvm:
+  - 2.3.0
+  - 2.2.4
+  - 2.1.8
+  - 2.0.0
+  - 1.9.3
+  - jruby-19mode # JRuby in 1.9 mode
+  - rbx-3.14
+before_install:
+  - gem install bundler

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Changelog
+
+## 1.0.0 - 2016-02-15
+- Fixed broken parsing of Urban Dictionary's new layout
+- Fixed bug where undefined words are displayed as the shrug emoticon (`¯\_(ツ)_/¯`)
+- Added support for --format=json to output JSON
+- Added MIT License

data/Gemfile

@@ -1,4 +1,4 @@
-source "http://rubygems.org"
+source "https://rubygems.org"
 
 # Specify your gem's dependencies in urban_dictionary.gemspec
 gemspec

data/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Ryan Greenberg
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -2,6 +2,8 @@
 
 `urban_dictionary` is a Ruby gem to access word definitions and examples from [Urban Dictionary](http://www.urbandictionary.com/). It also provides a command-line tool for getting definitions.
 
+[![Build Status](https://travis-ci.org/ryangreenberg/urban_dictionary.svg?branch=master)](https://travis-ci.org/ryangreenberg/urban_dictionary)
+
 ## Installation ##
 
 Run `gem install urban_dictionary`.
@@ -35,9 +37,21 @@ You can use the `--random` flag to get the definition of random word:
 
     > urban_dictionary --random
 
+Specify the output format with `--format`. The default is `plain`; `json` is also supported.
+
+    > urban_dictionary --format=json one hundred | jq .
+    {
+      "word": "one hundred",
+      "entries": [
+        {
+          "definition": "keepin it real to the fullest and super tight.",
+          "example": "end of the convo\rLuke: aight man, peace\rQ: kool homie, keep it one hundred (100)"
+        },
+        ...
+    }
+
 ## Tests ##
 
 Run examples with:
 
     rspec
-

data/Rakefile

@@ -1 +1,5 @@
 require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+task :default => :spec

data/bin/urban_dictionary

@@ -1,38 +1,5 @@
 #!/usr/bin/env ruby -KU
-require 'urban_dictionary'
-require 'optparse'
+require_relative '../lib/urban_dictionary'
 
-options = {}
-option_parser = OptionParser.new do |opts|
-  opts.banner = "Usage: urban_dictionary <word or phrase>"
-  opts.version = UrbanDictionary::VERSION
-
-  opts.on("-r", "--random", "Define a random word") do |r|
-    options[:random] = r
-  end
-end
-option_parser.parse(ARGV)
-
-if ARGV.empty? && !options[:random]
-  puts option_parser.help
-  exit(0)
-end
-
-word = if options[:random]
-  UrbanDictionary.random_word
-else
-  UrbanDictionary.define(ARGV.join(" "))
-end
-
-output = []
-output << word
-output << '-' * word.size
-output << ''
-word.entries.each_with_index do |entry, i|
-  output << "#{i + 1}. #{entry.definition}"
-  output << ""
-  output << "Example: #{entry.example}"
-  output << ""
-  output << ""
-end
-puts output.join("\n")
+config = UrbanDictionary::CLI::Config.new(:args => ARGV)
+UrbanDictionary::CLI.new(config).run

data/lib/urban_dictionary/cli.rb

@@ -0,0 +1,106 @@
+require 'optparse'
+
+module UrbanDictionary
+  class CLI
+    class Config
+      # Constructor accepts an option hash with the following properties:
+      PROPERTIES = [
+        :args,       # ARGV input from the user (required)
+        :stdout,     # IO object for writing to stdout (optional)
+        :stderr,     # IO object for writing to stderr (optional)
+        :dictionary, # Word-lookup object that implements .random_word and .define (optional)
+      ]
+
+      attr_reader *PROPERTIES
+
+      def initialize(options)
+        required(:args, options)
+        optional(:stdout, options, STDOUT)
+        optional(:stderr, options, STDERR)
+        optional(:dictionary, options, UrbanDictionary)
+      end
+
+      def update(property, value)
+        if PROPERTIES.include?(property)
+          set(property, value)
+        else
+          raise ArgumentError, "#{property} is not a valid property (#{PROPERTIES.inspect})."
+        end
+      end
+
+      private
+
+      def required(property, hsh)
+        unless hsh.include?(property)
+          raise ArgumentError, "#{hsh.inspect} does not include required property #{property}"
+        end
+        set(property, hsh[property])
+      end
+
+      def optional(property, hsh, default)
+        value = hsh.include?(property) ? hsh[property] : default
+        set(property, value)
+      end
+
+      def set(property, value)
+        instance_variable_set("@#{property}", value)
+      end
+    end
+
+    DEFAULT_FORMAT = :plain
+
+    attr_reader :options
+
+    def initialize(config)
+      @args = config.args
+      @stdout = config.stdout
+      @stderr = config.stderr
+      @dictionary = config.dictionary
+      @options = {}
+    end
+
+    def option_parser
+      @option_parser ||= OptionParser.new do |opts|
+        opts.banner = "Usage: urban_dictionary <word or phrase>"
+        opts.version = UrbanDictionary::VERSION
+
+        opts.on("-r", "--random", "Define a random word") do |r|
+          options[:random] = r
+        end
+
+        options[:format] = DEFAULT_FORMAT
+        opts.on("-f", "--format=FORMAT", "Output format (plain, json)") do |f|
+          format = f.downcase.to_sym
+          unless UrbanDictionary::Formatter.registered.include?(format)
+            raise OptionParser::InvalidOption, "#{f} is not a valid format"
+          end
+          options[:format] = format
+        end
+      end
+    end
+
+    def run
+      options[:remaining] = option_parser.parse(@args)
+
+      if options[:remaining].empty? && !options[:random]
+        @stdout.puts option_parser.help
+        return
+      end
+
+      term = options[:remaining].join(" ")
+      word = if options[:random]
+        @dictionary.random_word
+      else
+        @dictionary.define(term)
+      end
+
+      if word.nil?
+        @stderr.puts "No definition found for '#{term}'"
+        exit(1)
+      end
+
+      formatter = UrbanDictionary::Formatter.for(options[:format])
+      @stdout.puts(formatter.format(word))
+    end
+  end
+end

data/lib/urban_dictionary/entry.rb

@@ -10,5 +10,9 @@ module UrbanDictionary
     def to_s
       "#{definition}\n#{example}"
     end
+
+    def inspect
+      "<#{self.class} @definition=#{definition.inspect}, @example=#{example.inspect}>"
+    end
   end
 end

data/lib/urban_dictionary/formatters.rb

@@ -0,0 +1,58 @@
+require 'multi_json'
+
+module UrbanDictionary
+  class Formatter
+    def self.register(name, klass)
+      @formatters ||= {}
+      if @formatters.include?(name)
+        raise RuntimeError, "Formatter #{@formatters[name]} already registered for '#{name}'"
+      else
+        @formatters[name] = klass
+      end
+    end
+
+    def self.for(name)
+      @formatters[name]
+    end
+
+    def self.registered
+      @formatters.keys.map()
+    end
+
+    def self.format(word)
+      raise NotImplementedError, "#format has not been implemented by #{self}"
+    end
+  end
+
+  class PlainFormatter < Formatter
+    def self.format(word)
+      output = []
+      output << word
+      output << '-' * word.size
+      output << ''
+      word.entries.each_with_index do |entry, i|
+        output << "#{i + 1}. #{entry.definition}"
+        output << ""
+        output << "Example: #{entry.example}"
+        output << ""
+        output << ""
+      end
+      output.join("\n")
+    end
+  end
+
+  class JsonFormatter < Formatter
+    def self.format(word)
+      hsh = {
+        :word => word.word,
+        :entries => word.entries.map do |entry|
+          {
+            :definition => entry.definition,
+            :example => entry.example
+          }
+        end
+      }
+      MultiJson.dump(hsh)
+    end
+  end
+end

data/lib/urban_dictionary/version.rb

@@ -1,3 +1,3 @@
 module UrbanDictionary
-  VERSION = "0.0.2"
+  VERSION = "1.0.0"
 end

data/lib/urban_dictionary/word.rb

@@ -1,3 +1,5 @@
+# encoding: UTF-8
+
 require 'nokogiri'
 require 'open-uri'
 
@@ -5,20 +7,36 @@ module UrbanDictionary
   class Word
     attr_reader :word, :entries
 
-    # Can raise SocketError if unable to connect to specified URL
+      # Can raise SocketError if unable to connect to specified URL
     def self.from_url(url)
-      html = open(url).read
-      doc = Nokogiri::HTML(html)
+      html = open(url) {|f| f.read }
+      from_html(html)
+    end
+
+    def self.from_html(html)
+      doc = Nokogiri.HTML(html)
+      words = doc.css('.word')
+      return nil if words.empty?
+
+      word = words.first.content.strip
+      definitions = doc.css('div.meaning').map {|d| d.content.strip }
+      examples = doc.css('.example').map {|e| e.content.strip }
+      entries = definitions.zip(examples).map {|d,e| Entry.new(d, e) }
 
-      if doc.css('.word').any?
-        word = doc.css('.word').first.content.strip
-        definitions = doc.css('.definition').map{|d| d.content.strip }
-        examples = doc.css('.example').map{|e| e.content.strip }
-        entries = definitions.zip(examples).map{|d,e| Entry.new(d, e)}
+      defined_word?(word, definitions) ? Word.new(word, entries) : nil
+    end
 
-        Word.new(word, entries)
-      end
+    # Currently when a word has no definition the result page returns the
+    # shrug emoticon (¯\_(ツ)_/¯) and the text "There aren't any definitions
+    # for [word] yet."
+    def self.defined_word?(word, definitions)
+      undefined_word = (
+        definitions.size == 1 &&
+        definitions[0] =~ /^There aren't any definitions for/
+      )
+      !undefined_word
     end
+    private_class_method :defined_word?
 
     def initialize(word, entries)
       @word = word
@@ -29,9 +47,14 @@ module UrbanDictionary
       @word
     end
 
+    def inspect
+      "<#{self.class} @word=#{word.inspect}, @entries=#{entries.inspect}>"
+    end
+
     def size
       @word.size
     end
     alias :length :size
   end
-end
+end
+

data/lib/urban_dictionary.rb

@@ -1,9 +1,11 @@
 require 'uri'
 require 'net/http'
 
-require 'urban_dictionary/version'
-require 'urban_dictionary/word'
-require 'urban_dictionary/entry'
+require_relative 'urban_dictionary/version'
+require_relative 'urban_dictionary/cli'
+require_relative 'urban_dictionary/entry'
+require_relative 'urban_dictionary/formatters'
+require_relative 'urban_dictionary/word'
 
 module UrbanDictionary
   DEFINE_URL = 'http://www.urbandictionary.com/define.php'
@@ -16,10 +18,13 @@ module UrbanDictionary
   def self.random_word
     url = URI.parse(RANDOM_URL)
     req = Net::HTTP::Get.new(url.path)
-    rsp = Net::HTTP.start(url.host, url.port) {|http|
+    rsp = Net::HTTP.start(url.host, url.port) do |http|
       http.request(req)
-    }
+    end
 
-    define(rsp['location'])
+    Word.from_url(rsp['location'])
   end
-end
+end
+
+UrbanDictionary::Formatter.register(:json, UrbanDictionary::JsonFormatter)
+UrbanDictionary::Formatter.register(:plain, UrbanDictionary::PlainFormatter)

data/spec/html/add_html_example.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+# Save a given URL as a test case in the spec/html directory
+
+require 'nokogiri'
+require 'open-uri'
+require 'uri'
+require 'cgi'
+require 'time'
+
+USAGE = "Usage: #{$PROGRAM_NAME} url"
+
+url = ARGV[0]
+abort USAGE unless url
+
+html = open(url) {|f| f.read }
+file_name = begin
+  uri = URI.parse(url)
+  params = CGI.parse(uri.query || "")
+  base_name = if params.include?('term')
+    params['term'][0]
+  else
+    "#{uri.host}#{uri.path}"
+  end
+
+  %|#{base_name.downcase.gsub(/[^a-z0-9]/i, '_')}_#{Time.now.strftime("%Y-%m-%d")}.html|
+end
+file_path = File.join(File.expand_path('..', __FILE__), file_name)
+
+doc = Nokogiri.HTML(html)
+
+# Remove script tags and SVG elements to cut down on size
+doc.css('script,g').remove
+
+File.open(file_path, 'w') { |f| f << doc.to_html }