lita-dig 0.6.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dd450053b2cc6687b35f8e825832b880c97f2d68
-  data.tar.gz: 2a15a7d2abca1bb1f5bc984f16ce7b539846c8fc
+  metadata.gz: 5de3a41ed27249f73a9315e60d701d2f807387c5
+  data.tar.gz: 76aa3b30845a86948f8f13dcba372b63600a9917
 SHA512:
-  metadata.gz: 993da854a9d85a80f8e4d22b23060d0aa385372e8d2b0ecc44ac5537499f6ec01cb0516948754274b68b62515e90c0031c54a339a62b6f23287a5c594c7c3ed1
-  data.tar.gz: bb1486f720ac3c07c34e13d232f87b52f9fbfa06f53046437c6f82d5af22a65d987d67a63f0f93e87eba1466b259a617e316a12ed6759b45f2260fb293a03e83
+  metadata.gz: 5d446145c9446119a844048ecc48dd16573a6085ef2f9ea0fe754fc11461cd8f70a6b9e27e32ea66f9ec5fed0b9694c1fa4ce883587ce2fe91848d58e49fb10a
+  data.tar.gz: 902402a6643c66864c223572432deb1acb63b395f3fc7d08eb0c127f168debdc07efb57a0957a726e88f06a1f6ede8a4d085c65c7e3c9820cd9fba47a0e9bbc7

data/.gitignore

@@ -1,5 +1,6 @@
 *.gem
 *.rbc
+*.swp
 .bundle
 .config
 .yardoc

data/.rubocop.yml

@@ -1,9 +1,3 @@
-ClassLength:
-  Max: 200
-
-CyclomaticComplexity:
-  Max: 75
-
 Documentation:
   Exclude:
     - lib/lita/handlers/dig.rb
@@ -11,6 +5,3 @@ Documentation:
 FileName:
   Exclude:
     - lib/lita-dig.rb
-
-MethodLength:
-  Max: 200

data/Gemfile

@@ -1,3 +1,3 @@
-source "https://rubygems.org"
+source 'https://rubygems.org'
 
 gemspec

data/Rakefile

@@ -3,6 +3,6 @@ require 'rspec/core/rake_task'
 require 'rubocop/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
-Rubocop::RakeTask.new(:rubocop)
+RuboCop::RakeTask.new(:rubocop)
 
 task default: [:spec, :rubocop]

data/lib/lita/handlers/dig.rb

@@ -1,8 +1,19 @@
 module Lita
   module Handlers
     class Dig < Handler
+      DNS_TYPES = %w(a ns md cname soa mb mg mr null wks ptr hinfo minfo
+                     mx txt rp afsdb x25 isdn rt nsap nsapptr sig key px
+                     gpos aaaa loc nxt eid nimloc srv atma naptr kx cert
+                     dname opt ds sshfp rrsig nsec dnskey uinfo uid gid
+                     unspec tkey tsig ixfr axfr mailb maila any)
+
       route(
-        /^dig\s(\S+)(\s\+short)?$/,
+        /^dig
+          (?:\s\@)?(?<resolver>\S+)?
+          \s(?<record>\S+)
+          (?<type>\s\w+)?
+          (?<short>\s\+short)?$
+        /x,
         :resolve,
         command: true,
         help: {
@@ -10,182 +21,20 @@ module Lita
         }
       )
 
-      route(
-        /^dig\s(?!\@)(\S+)\s(\S+)$/,
-        :resolve_type,
-        command: true,
-        help: {
-          t('help.resolve_type.syntax') => t('help.resolve_type.desc')
-        }
-      )
-
-      route(
-        /^dig\s\@(\S+)\s(\S+)(\s\+short)?$/,
-        :resolve_svr,
-        command: true,
-        help: {
-          t('help.resolve_svr.syntax') => t('help.resolve_svr.desc')
-        }
-      )
-
-      route(
-        /^dig\s\@(\S+)\s(\S+)\s(\S+)$/,
-        :resolve_svr_type,
-        command: true,
-        help: {
-          t('help.resolve_svr_type.syntax') => t('help.resolve_svr_type.desc')
-        }
-      )
-
       def resolve(response)
-        name = response.matches[0][0]
-        if response.matches[0][1] == ' +short'
-          response.reply(format_lookup_short(lookup(name, 'a')))
-        else
-          response.reply(format_lookup(lookup(name, 'a')))
-        end
-      end
-
-      def resolve_type(response)
-        name = response.matches[0][0]
-        type = response.matches[0][1]
-        response.reply(format_lookup(lookup(name, type))) \
-          unless type == '+short'
-      end
-
-      def resolve_svr(response)
-        resolver = response.matches[0][0]
-        name     = response.matches[0][1]
-        if response.matches[0][2] == ' +short'
-          response.reply(format_lookup_short(lookup(name, 'a', resolver)))
-        else
-          response.reply(format_lookup(lookup(name, 'a', resolver)))
-        end
-      end
-
-      def resolve_svr_type(response)
-        resolver = response.matches[0][0]
-        name     = response.matches[0][1]
-        type     = response.matches[0][2]
-        response.reply(format_lookup(lookup(name, type, resolver))) \
-          unless type == '+short'
+        resolver = response.match_data['resolver'] || '8.8.8.8'
+        record   = response.match_data['record']
+        type     = (response.match_data['type'] || 'a').strip
+        short    = response.match_data['short']
+        result   = lookup(record, type, resolver)
+        response.reply(format_lookup(result, short))
       end
 
       private
 
       def lookup(argument, type, server = nil)
-        case type
-        when 'a', 'A'
-          type = Net::DNS::A
-        when 'ns', 'NS'
-          type = Net::DNS::NS
-        when 'md', 'MD'
-          type = Net::DNS::MD
-        when 'cname', 'CNAME'
-          type = Net::DNS::CNAME
-        when 'soa', 'SOA'
-          type = Net::DNS::SOA
-        when 'mb', 'MB'
-          type = Net::DNS::MB
-        when 'mg', 'MG'
-          type = Net::DNS::MG
-        when 'mr', 'MR'
-          type = Net::DNS::MR
-        when 'null', 'NULL'
-          type = Net::DNS::NULL
-        when 'wks', 'WKS'
-          type = Net::DNS::WKS
-        when 'ptr', 'PTR'
-          type = Net::DNS::PTR
-        when 'hinfo', 'HINFO'
-          type = Net::DNS::HINFO
-        when 'minfo', 'MINFO'
-          type = Net::DNS::MINFO
-        when 'mx', 'MX'
-          type = Net::DNS::MX
-        when 'txt', 'TXT'
-          type = Net::DNS::TXT
-        when 'rp', 'RP'
-          type = Net::DNS::RP
-        when 'afsdb', 'AFSDB'
-          type = Net::DNS::AFSDB
-        when 'x25', 'X25'
-          type = Net::DNS::X25
-        when 'isdn', 'ISDN'
-          type = Net::DNS::ISDN
-        when 'rt', 'RT'
-          type = Net::DNS::RT
-        when 'nsap', 'NSAP'
-          type = Net::DNS::NSAP
-        when 'nsapptr', 'NSAPPTR'
-          type = Net::DNS::NSAPPTR
-        when 'sig', 'SIG'
-          type = Net::DNS::SIG
-        when 'key', 'KEY'
-          type = Net::DNS::KEY
-        when 'px', 'PX'
-          type = Net::DNS::PX
-        when 'gpos', 'GPOS'
-          type = Net::DNS::GPOS
-        when 'aaaa', 'AAAA'
-          type = Net::DNS::AAAA
-        when 'loc', 'LOC'
-          type = Net::DNS::LOC
-        when 'nxt', 'NXT'
-          type = Net::DNS::NXT
-        when 'eid', 'EID'
-          type = Net::DNS::EID
-        when 'nimloc', 'NIMLOC'
-          type = Net::DNS::NIMLOC
-        when 'srv', 'SRV'
-          type = Net::DNS::SRV
-        when 'atma', 'ATMA'
-          type = Net::DNS::ATMA
-        when 'naptr', 'NAPTR'
-          type = Net::DNS::NAPTR
-        when 'kx', 'KX'
-          type = Net::DNS::KX
-        when 'cert', 'CERT'
-          type = Net::DNS::CERT
-        when 'dname', 'DNAME'
-          type = Net::DNS::DNAME
-        when 'opt', 'OPT'
-          type = Net::DNS::OPT
-        when 'ds', 'DS'
-          type = Net::DNS::DS
-        when 'sshfp', 'SSHFP'
-          type = Net::DNS::SSHFP
-        when 'rrsig', 'RRSIG'
-          type = Net::DNS::RRSIG
-        when 'nsec', 'NSEC'
-          type = Net::DNS::NSEC
-        when 'dnskey', 'DNSKEY'
-          type = Net::DNS::DNSKEY
-        when 'uinfo', 'UINFO'
-          type = Net::DNS::UINFO
-        when 'uid', 'UID'
-          type = Net::DNS::UID
-        when 'gid', 'GID'
-          type = Net::DNS::GID
-        when 'unspec', 'UNSPEC'
-          type = Net::DNS::UNSPEC
-        when 'tkey', 'TKEY'
-          type = Net::DNS::TKEY
-        when 'tsig', 'TSIG'
-          type = Net::DNS::TSIG
-        when 'ixfr', 'IXFR'
-          type = Net::DNS::IXFR
-        when 'axfr', 'AXFR'
-          type = Net::DNS::AXFR
-        when 'mailb', 'MAILB'
-          type = Net::DNS::MAILB
-        when 'maila', 'MAILA'
-          type = Net::DNS::MAILA
-        when 'any', 'ANY'
-          type = Net::DNS::ANY
-        else
-          return t('error.unknown_type')
-        end
+        return t('error.unknown_type') unless DNS_TYPES.include?(type.downcase)
+        type = Object.const_get('Net::DNS::' + type.upcase)
 
         resolver = Net::DNS::Resolver.new
         resolver.nameservers = server unless server.nil?
@@ -197,14 +46,14 @@ module Lita
         end
       end
 
-      def format_lookup(lookup)
-        lookup.to_s
-      end
-
-      def format_lookup_short(lookup)
+      def format_lookup(lookup, compact = false)
         result = ''
-        lookup.each_address do |ip|
-          result += "#{ip}\n"
+        if compact
+          lookup.each_address do |ip|
+            result += "#{ip}\n"
+          end
+        else
+          result = lookup.to_s
         end
         result
       end

data/lita-dig.gemspec

@@ -1,10 +1,10 @@
 Gem::Specification.new do |spec|
   spec.name          = 'lita-dig'
-  spec.version       = '0.6.0'
+  spec.version       = '1.0.0'
   spec.authors       = ['Eric Sigler']
   spec.email         = ['me@esigler.com']
-  spec.description   = %q(A Lita handler for resolving DNS records)
-  spec.summary       = %q(A Lita handler for resolving DNS records)
+  spec.description   = 'A Lita handler for resolving DNS records'
+  spec.summary       = 'A Lita handler for resolving DNS records'
   spec.homepage      = 'https://github.com/esigler/lita-dig'
   spec.license       = 'MIT'
   spec.metadata      = { 'lita_plugin_type' => 'handler' }
@@ -14,7 +14,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
   spec.require_paths = ['lib']
 
-  spec.add_runtime_dependency 'lita', '>= 3.1'
+  spec.add_runtime_dependency 'lita', '>= 4.0'
   spec.add_runtime_dependency 'net-dns'
 
   spec.add_development_dependency 'bundler', '~> 1.3'

data/locales/en.yml

@@ -8,14 +8,7 @@ en:
           unable_to_resolve: "Unable to resolve %{argument}"
         help:
           resolve:
-            syntax: dig <name> [+short]
-            desc: Lookup the A record for <name> using the default resolver [optionally just IP addressses]
-          resolve_type:
-            syntax: dig <name> <type>
-            desc: Lookup the <type> record for <name> using the default resolver
-          resolve_svr:
-            syntax: dig @<server> <name> [+short]
-            desc: Lookup the A record for <name> using <server> as a resolver [optionally just IP addressses]
-          resolve_svr_type:
-            syntax: dig @<server> <record> <type>
-            desc: Lookup the <type> record for <name> using <server> as a resolver
+            syntax: dig [@<server>] <name> [<type>] [+short]
+            desc: |
+                  "Lookup the <type> record for <name> using <server> as a resolver.
+                  <type> defaults to A, and <server> defaults to 8.8.8.8"

data/spec/lita/handlers/dig_spec.rb

@@ -29,12 +29,23 @@ describe Lita::Handlers::Dig, lita_handler: true do
     client
   end
 
-  it { routes_command('dig example.com').to(:resolve) }
-  it { routes_command('dig example.com MX').to(:resolve_type) }
-  it { routes_command('dig @8.8.8.8 example.com').to(:resolve_svr) }
-  it { routes_command('dig @8.8.8.8 example.com MX').to(:resolve_svr_type) }
-  it { routes_command('dig example.com +short').to(:resolve) }
-  it { routes_command('dig @8.8.8.8 example.com +short').to(:resolve_svr) }
+  let(:resolve_short) do
+    list = double
+    allow(list).to receive(:each_address).and_yield('1.2.3.4')
+    client = double
+    allow(client).to receive(:nameservers=) { '' }
+    expect(client).to receive(:query) { list }
+    client
+  end
+
+  it do
+    is_expected.to route_command('dig example.com').to(:resolve)
+    is_expected.to route_command('dig example.com MX').to(:resolve)
+    is_expected.to route_command('dig @8.8.8.8 example.com').to(:resolve)
+    is_expected.to route_command('dig @8.8.8.8 example.com MX').to(:resolve)
+    is_expected.to route_command('dig example.com +short').to(:resolve)
+    is_expected.to route_command('dig @8.8.8.8 example.com +short').to(:resolve)
+  end
 
   describe '#resolve' do
     it 'shows a record if the domain exists' do
@@ -43,6 +54,12 @@ describe Lita::Handlers::Dig, lita_handler: true do
       expect(replies.last).to eq('Generic A response example.com')
     end
 
+    it 'shows a short record if the domain exists' do
+      expect(Net::DNS::Resolver).to receive(:new) { resolve_short }
+      send_command('dig example.com +short')
+      expect(replies.last).to eq("1.2.3.4\n")
+    end
+
     it 'shows a warning if the domain does not exist' do
       expect(Net::DNS::Resolver).to receive(:new) { resolve_unknown }
       send_command('dig example.com')
@@ -54,9 +71,7 @@ describe Lita::Handlers::Dig, lita_handler: true do
       send_command('dig example.com')
       expect(replies.last).to eq('Unable to resolve example.com')
     end
-  end
 
-  describe '#resolve_type' do
     it 'resolves a uppercase record with a particular type' do
       expect(Net::DNS::Resolver).to receive(:new) { resolve_mx }
       send_command('dig example.com MX')
@@ -96,9 +111,7 @@ describe Lita::Handlers::Dig, lita_handler: true do
       send_command('dig example.com MX')
       expect(replies.last).to eq('Unable to resolve example.com')
     end
-  end
 
-  describe '#resolve_svr' do
     it 'shows a record if the domain exists' do
       expect(Net::DNS::Resolver).to receive(:new) { resolve }
       send_command('dig @8.8.8.8 example.com')
@@ -116,9 +129,7 @@ describe Lita::Handlers::Dig, lita_handler: true do
       send_command('dig @8.8.8.8 example.com')
       expect(replies.last).to eq('Unable to resolve example.com')
     end
-  end
 
-  describe '#resolve_type' do
     it 'resolves a uppercase record with a particular type' do
       expect(Net::DNS::Resolver).to receive(:new) { resolve_mx }
       send_command('dig @8.8.8.8 example.com MX')

data/spec/spec_helper.rb

@@ -8,3 +8,5 @@ SimpleCov.start { add_filter '/spec/' }
 
 require 'lita-dig'
 require 'lita/rspec'
+
+Lita.version_3_compatibility_mode = false

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lita-dig
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Eric Sigler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-13 00:00:00.000000000 Z
+date: 2014-12-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lita
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '4.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: net-dns
   requirement: !ruby/object:Gem::Requirement
@@ -163,7 +163,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.1
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A Lita handler for resolving DNS records