dict_client 0.0.1

data/dict_client.gemspec

@@ -0,0 +1,20 @@
+Gem::Specification.new do |s|
+  s.name          = 'dict_client'
+  s.version       = '0.0.1'
+  s.homepage      = 'https://github.com/leikind/dict_client'
+  s.date          = '2013-07-25'
+  s.summary       = 'A simple client side DICT library and executable'
+  s.description   = 'The Dictionary Server Protocol (DICT) is a TCP transaction based '  +
+                  'query/response protocol that allows a client to access dictionary ' +
+                  'definitions from a set of natural language dictionary databases. '  +
+                  'See RFC 2229 for details. http://tools.ietf.org/html/rfc2229'
+  s.authors       = ['Dave Pearson', 'Yuri Leikind']
+  s.email         = 'yuri.leikind@gmail.com'
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec'
+
+end

data/lib/dict_client.rb

@@ -0,0 +1,59 @@
+# encoding: UTF-8
+require 'socket'
+
+module DictClient
+
+  DEFAULT_HOST = 'dict.mova.org'
+
+  DEFAULT_PORT = 2628
+
+  EOL = "\r\n"
+
+  # End of data marker
+  EOD = '.' + EOL
+
+  # The special database names.
+  DB_FIRST = '!'
+  DB_ALL   = '*'
+
+  # Match strategies.
+  MATCH_DEFAULT = '.'
+  MATCH_EXACT   = 'exact'
+  MATCH_PREFIX  = 'prefix'
+
+  RESPONSE_DATABASES_FOLLOW    = 110
+  RESPONSE_STRATEGIES_FOLLOW   = 111
+  RESPONSE_INFO_FOLLOWS        = 112
+  RESPONSE_HELP_FOLLOWS        = 113
+  RESPONSE_SERVER_INFO_FOLLOWS = 114
+  RESPONSE_DEFINITIONS_FOLLOW  = 150
+  RESPONSE_DEFINITION_FOLLOWS  = 151
+  RESPONSE_MATCHES_FOLLOW      = 152
+  RESPONSE_CONNECTED           = 220
+  RESPONSE_OK                  = 250
+  RESPONSE_NO_MATCH            = 552
+  RESPONSE_NO_DATABASES        = 554
+  RESPONSE_NO_STRATEGIES       = 555
+
+  CLIENT_NAME = 'client github.com/leikind/dict_client'
+
+  class DictError < RuntimeError
+  end
+
+  def self.reply_code(text, default = nil)
+
+    if text =~ /^\d{3} /
+      text.to_i
+    elsif default
+      default
+    else
+      raise DictError.new, "Invalid reply from host \"#{text}\"."
+    end
+
+  end
+
+end
+
+require 'dict_client/readers.rb'
+require 'dict_client/responses.rb'
+require 'dict_client/client.rb'

data/lib/dict_client/client.rb

@@ -0,0 +1,117 @@
+# encoding: UTF-8
+module DictClient
+
+  class Client
+
+    def initialize(host = DEFAULT_HOST, port = DEFAULT_PORT)
+      @host, @port = host, port
+    end
+
+    def connected?
+      ! @conn.nil?
+    end
+
+    def connect
+
+      @conn = tcp_open @host, @port
+
+      @banner = @conn.readline
+
+      unless DictClient.reply_code(@banner) == RESPONSE_CONNECTED
+        raise DictError.new, "Connection refused \"#{@banner}\"."
+      end
+
+      # announce ourselves to the server.
+      send_command CLIENT_NAME
+
+      unless DictClient.reply_code(reply = @conn.readline()) == RESPONSE_OK
+        raise DictError.new, "Client announcement failed \"#{reply}\""
+      end
+
+      if block_given?
+        yield self
+      else
+        self
+      end
+
+    end
+
+    def disconnect
+      if connected?
+        send_command 'quit'
+        @conn.close
+        @conn = nil
+      end
+    end
+
+    def banner
+      check_connection
+      @banner
+    end
+
+    def databases
+      request_response "show db", DictionariesTcpReader.new, Dictionaries
+    end
+
+    def strategies
+      request_response "show strat", StrategiesTcpReader.new, Strategies
+    end
+
+    def server
+      request_response "show server", ServerInfoTcpReader.new, ServerInfo
+    end
+
+    def help
+      request_response "help", ServerHelpTcpReader.new, ServerHelp
+    end
+
+    def info database
+      request_response %!show info "#{database}"!, DictionaryInfoTcpReader.new, DictionaryInfo
+    end
+
+    def match(word, strategy = MATCH_DEFAULT, database = DB_ALL)
+      request_response %!match #{database} #{strategy} "#{word}"!, MatchTcpReader.new, WordMatch
+    end
+
+    def define(word, database = DB_ALL)
+      request_response %!define #{database} "#{word}"!, WordDefinitionsTcpReader.new, WordDefinitions
+    end
+
+
+    private
+
+    def tcp_open host, port
+      TCPSocket.open(host, port)
+    end
+
+    def request_response(command, reader, response_class)
+
+      send_command command
+
+      if DictClient.reply_code(reply = @conn.readline) == reader.good_response_code
+        response_class.new(reader.read_from(@conn))
+      elsif reader.bad_response_code && DictClient.reply_code(reply) == reader.bad_response_code
+        EmptyResponse.new
+      else
+        raise DictError.new, reply
+      end
+    end
+
+
+    def check_connection
+      unless connected?
+        raise DictError.new, 'Not connected.'
+      end
+    end
+
+    def send_command command
+      check_connection
+      # STDERR.puts command
+      @conn.write command + EOL
+    end
+
+  end
+
+
+end
+

data/lib/dict_client/readers.rb

@@ -0,0 +1,85 @@
+# encoding: UTF-8
+module DictClient
+
+  class SimpleTcpReader
+
+    def read_from socket
+
+      [].tap do |lines|
+        while DictClient.reply_code(reply = socket.readline(), 0) != RESPONSE_OK
+          lines.push reply.force_encoding('UTF-8') unless reply == EOD
+        end
+      end
+
+    end
+
+    def good_response_code
+      nil
+    end
+
+    def bad_response_code
+      nil
+    end
+  end
+
+  class  DictionariesTcpReader < SimpleTcpReader
+    def good_response_code
+      ::DictClient::RESPONSE_DATABASES_FOLLOW
+    end
+
+    def bad_response_code
+      ::DictClient::RESPONSE_NO_DATABASES
+    end
+  end
+
+  class StrategiesTcpReader  < SimpleTcpReader
+    def good_response_code
+      ::DictClient::RESPONSE_STRATEGIES_FOLLOW
+    end
+
+    def bad_response_code
+      ::DictClient::RESPONSE_NO_STRATEGIES
+    end
+  end
+
+  class ServerHelpTcpReader  < SimpleTcpReader
+    def good_response_code
+      ::DictClient::RESPONSE_HELP_FOLLOWS
+    end
+  end
+
+  class ServerInfoTcpReader  < SimpleTcpReader
+    def good_response_code
+      ::DictClient::RESPONSE_SERVER_INFO_FOLLOWS
+    end
+  end
+
+  class DictionaryInfoTcpReader  < SimpleTcpReader
+    def good_response_code
+      ::DictClient::RESPONSE_INFO_FOLLOWS
+    end
+  end
+
+  class MatchTcpReader  < SimpleTcpReader
+    def good_response_code
+      ::DictClient::RESPONSE_MATCHES_FOLLOW
+    end
+
+    def bad_response_code
+      ::DictClient::RESPONSE_NO_MATCH
+    end
+
+  end
+
+  class WordDefinitionsTcpReader  < SimpleTcpReader
+
+    def good_response_code
+      ::DictClient::RESPONSE_DEFINITIONS_FOLLOW
+    end
+
+    def bad_response_code
+      ::DictClient::RESPONSE_NO_MATCH
+    end
+
+  end
+end

data/lib/dict_client/responses.rb

@@ -0,0 +1,157 @@
+# encoding: UTF-8
+module DictClient
+
+  class EmptyResponse
+    def to_s
+      'none'
+    end
+  end
+
+  class SimpleResponse
+
+    def initialize lines
+      lines.each do |line|
+        process_line line
+      end
+    end
+
+    def to_s
+      @response
+    end
+
+    private
+
+    def process_line line
+      @response ||= ''
+
+      @response << line
+    end
+  end
+
+  ServerInfo      = SimpleResponse
+  ServerHelp      = SimpleResponse
+  DictionaryInfo  = SimpleResponse
+
+  module Formattable
+    def longest list
+      list.max{|a,b| a.length <=> b.length }.length
+    end
+
+    def print_formatted list, max_key, max_value
+      list.to_a.map do |k, v|
+        sprintf "%#{max_key}s  %-#{max_value}s", k, v
+      end.join("\n")
+    end
+  end
+
+  class KeyValueResponse < SimpleResponse
+
+    include Formattable
+
+    def to_h
+      @table
+    end
+
+    def to_s
+      max_value = longest @table.values
+      max_key =   longest @table.keys
+
+      print_formatted @table, max_key, max_value
+
+    end
+
+    private
+
+    def process_line line
+      @table ||= {}
+
+      if line =~ /^([^\s]+)\s+"(.+?)"/
+        @table[$1] = $2
+      end
+    end
+
+  end
+
+
+  Dictionaries = KeyValueResponse
+
+  Strategies   = KeyValueResponse
+
+  class WordMatch < SimpleResponse
+
+    include Formattable
+
+    attr_reader :matches
+
+    def to_s
+      max_key   = longest @matches.map{|tuple| tuple[0] }
+      max_value = longest @matches.map{|tuple| tuple[1] }
+
+      print_formatted @matches, max_key, max_value
+    end
+
+    def count
+      @matches.size
+    end
+
+    private
+
+    def process_line line
+      @matches ||= []
+
+      if line =~ /^([^\s]+)\s+"([^"]+)"/
+        @matches << [$1, $2]
+      end
+    end
+
+  end
+
+  class WordDefinitions < SimpleResponse
+
+    attr_reader :definitions
+
+    def initialize lines
+      @definitions = []
+      super(lines)
+    end
+
+    class WordDefinition < Struct.new(:word, :dictionary_name, :dictionary_description, :definition)
+
+      BAR = ('-' * 76) + "\n"
+
+      def to_s(n = nil)
+        (n.nil? ? '' : "#{n}) ") +
+        "#{dictionary_name} (#{dictionary_description}): #{word}\n" +
+        BAR + definition + BAR
+      end
+    end
+
+
+    def to_s
+      @definitions.each_with_index.to_a.map{|definition, idx| definition.to_s(idx+1)}.join
+    end
+
+    def count
+      @definitions.size
+    end
+
+    private
+
+    def process_line line
+      if line =~ /^#{RESPONSE_DEFINITION_FOLLOWS}\s+"([^\s+]+)"\s+([^\s+]+)\s+"(.+?)"/
+        word, dictionary_name, dictionary_description = $1, $2, $3
+
+        @current_definition = WordDefinition.new(word, dictionary_name, dictionary_description, '')
+        @definitions << @current_definition
+
+      else
+        if @current_definition
+          @current_definition.definition << line
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/client_spec.rb

@@ -0,0 +1,60 @@
+# encoding: UTF-8
+require 'spec_helper.rb'
+
+describe DictClient::Client do
+
+  let!(:dictd){}
+
+  subject do
+    DictClient::Client.new.tap do |client|
+      def client.tcp_open(h,p)
+        MockedDictdServerSocket.new.tap{|m| @mock = m}
+      end
+
+      def client.mock
+        @mock
+      end
+    end
+  end
+
+  it 'connects' do
+    subject.connect.should == subject
+  end
+
+
+  it 'client command has been sent' do
+    subject.connect
+    subject.mock.incoming_commands[0].should match(/^client /)
+  end
+
+  context 'disconnected' do
+
+    before do
+      subject.connect
+      subject.disconnect
+    end
+
+    its(:connected?){ should be_false }
+
+    it 'client command has been sent' do
+      subject.mock.incoming_commands[1].should match(/^quit\r\n/)
+    end
+
+  end
+
+
+  context 'inside a session' do
+    before do
+      subject.connect
+    end
+
+    after do
+      subject.disconnect
+    end
+
+
+    its(:connected?){ should be_true }
+
+  end
+
+end