lita-dig 0.5.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 49a68c5ef90d059f8330b32b210471a0fced8cd9
+  data.tar.gz: 5909f6811c41e5ce6497fe48d3dcd29145620d6f
+SHA512:
+  metadata.gz: a552459801353610b19dcaa2fd70267b9ce49ff803b84bacb37dc15560caaaa4a7b969c7bb6056990bedd41dfb44abc45d1b7a868aa8bc0aeecd9b6e9f91e386
+  data.tar.gz: 2b491766d1b93dd543af735caefb4515486284dfe082dbf4e82a55198adb40a81ac879d80267491c400c8e88cdf580ad87220fa487d38ddd1bec26937c596d5a

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rubocop.yml

@@ -0,0 +1,16 @@
+ClassLength:
+  Max: 200
+
+CyclomaticComplexity:
+  Max: 75
+
+Documentation:
+  Exclude:
+    - lib/lita/handlers/dig.rb
+
+FileName:
+  Exclude:
+    - lib/lita-dig.rb
+
+MethodLength:
+  Max: 200

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 2.0.0
+script: bundle exec rake
+before_install:
+  - gem update --system
+services:
+  - redis-server

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2014 Eric Sigler
+
+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

@@ -0,0 +1,39 @@
+# lita-dig
+
+[![Build Status](https://img.shields.io/travis/esigler/lita-dig/master.svg)](https://travis-ci.org/esigler/lita-dig)
+[![MIT License](https://img.shields.io/badge/license-MIT-brightgreen.svg)](https://tldrlegal.com/license/mit-license)
+[![RubyGems :: RMuh Gem Version](http://img.shields.io/gem/v/lita-dig.svg)](https://rubygems.org/gems/lita-dig)
+[![Coveralls Coverage](https://img.shields.io/coveralls/esigler/lita-dig/master.svg)](https://coveralls.io/r/esigler/lita-dig)
+[![Code Climate](https://img.shields.io/codeclimate/github/esigler/lita-dig.svg)](https://codeclimate.com/github/esigler/lita-dig)
+[![Gemnasium](https://img.shields.io/gemnasium/esigler/lita-dig.svg)](https://gemnasium.com/esigler/lita-dig)
+
+DNS record lookup [handler](https://github.com/jimmycuadra/lita).
+
+## Installation
+
+Add lita-dig to your Lita instance's Gemfile:
+
+``` ruby
+gem "lita-dig"
+```
+
+## Configuration
+
+None
+
+## Usage
+
+Examples:
+
+```
+dig example.com              - Lookup the A record for example.com using the default resolver
+dig example.com MX           - Lookup the MX record for example.com using the default resolver
+dig @8.8.8.8 example.com     - Lookup the A record for example.com using 8.8.8.8 as a resolver
+dig @8.8.8.8 example.com NS  - Lookup the NS record for example.com using 8.8.8.8 as a resolver
+```
+
+The majority of DNS record types (including "any") are supported.
+
+## License
+
+[MIT](http://opensource.org/licenses/MIT)

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+Rubocop::RakeTask.new(:rubocop)
+
+task default: [:spec, :rubocop]

data/lib/lita-dig.rb

@@ -0,0 +1,9 @@
+require 'lita'
+
+Lita.load_locales Dir[File.expand_path(
+  File.join('..', '..', 'locales', '*.yml'), __FILE__
+)]
+
+require 'net/dns'
+
+require 'lita/handlers/dig'

data/lib/lita/handlers/dig.rb

@@ -0,0 +1,197 @@
+module Lita
+  module Handlers
+    class Dig < Handler
+      route(
+        /^dig\s(\S+)$/,
+        :resolve,
+        command: true,
+        help: {
+          t('help.resolve.syntax') => t('help.resolve.desc')
+        }
+      )
+
+      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+)$/,
+        :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]
+        response.reply(format_lookup(lookup(name, 'a')))
+      end
+
+      def resolve_type(response)
+        name = response.matches[0][0]
+        type = response.matches[0][1]
+        response.reply(format_lookup(lookup(name, type)))
+      end
+
+      def resolve_svr(response)
+        resolver = response.matches[0][0]
+        name     = response.matches[0][1]
+        response.reply(format_lookup(lookup(name, 'a', resolver)))
+      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)))
+      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
+
+        resolver = Net::DNS::Resolver.new
+        resolver.nameservers = server unless server.nil?
+
+        begin
+          resolver.query(argument, type)
+        rescue
+          t('error.unable_to_resolve', argument: argument)
+        end
+      end
+
+      def format_lookup(lookup)
+        lookup.to_s
+      end
+    end
+
+    Lita.register_handler(Dig)
+  end
+end

data/lita-dig.gemspec

@@ -0,0 +1,26 @@
+Gem::Specification.new do |spec|
+  spec.name          = 'lita-dig'
+  spec.version       = '0.5.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.homepage      = 'https://github.com/esigler/lita-dig'
+  spec.license       = 'MIT'
+  spec.metadata      = { 'lita_plugin_type' => 'handler' }
+
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'lita', '>= 3.1'
+  spec.add_runtime_dependency 'net-dns'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '>= 3.0.0.beta2'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency 'rubocop'
+end

data/locales/en.yml

@@ -0,0 +1,21 @@
+en:
+  lita:
+    handlers:
+      dig:
+        error:
+          not_implemented: Not implemented yet
+          unknown_type: Unknown record type
+          unable_to_resolve: "Unable to resolve %{argument}"
+        help:
+          resolve:
+            syntax: dig <name>
+            desc: Lookup the A record for <name> using the default resolver
+          resolve_type:
+            syntax: dig <name> <type>
+            desc: Lookup the <type> record for <name> using the default resolver
+          resolve_svr:
+            syntax: dig @<server> <name>
+            desc: Lookup the A record for <name> using <server> as a resolver
+          resolve_svr_type:
+            syntax: dig @<server> <record> <type>
+            desc: Lookup the <type> record for <name> using <server> as a resolver

data/spec/lita/handlers/dig_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+describe Lita::Handlers::Dig, lita_handler: true do
+  let(:resolve) do
+    client = double
+    allow(client).to receive(:nameservers=) { '' }
+    expect(client).to receive(:query) { 'Generic A response example.com' }
+    client
+  end
+
+  let(:resolve_mx) do
+    client = double
+    allow(client).to receive(:nameservers=) { '' }
+    expect(client).to receive(:query) { 'Generic MX response example.com' }
+    client
+  end
+
+  let(:resolve_unknown) do
+    client = double
+    allow(client).to receive(:nameservers=) { '' }
+    expect(client).to receive(:query) { 'Unknown domain example.com' }
+    client
+  end
+
+  let(:resolve_noresponse) do
+    client = double
+    allow(client).to receive(:nameservers=) { '' }
+    expect(client).to receive(:query).and_throw(:NoResponseError)
+    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) }
+
+  describe '#resolve' do
+    it 'shows a record if the domain exists' do
+      expect(Net::DNS::Resolver).to receive(:new) { resolve }
+      send_command('dig example.com')
+      expect(replies.last).to eq('Generic A response example.com')
+    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')
+      expect(replies.last).to eq('Unknown domain example.com')
+    end
+
+    it 'shows an error if the request fails' do
+      expect(Net::DNS::Resolver).to receive(:new) { resolve_noresponse }
+      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')
+      expect(replies.last).to eq('Generic MX response example.com')
+    end
+
+    it 'resolves a lowercase record with a particular type' do
+      expect(Net::DNS::Resolver).to receive(:new) { resolve_mx }
+      send_command('dig example.com mx')
+      expect(replies.last).to eq('Generic MX response example.com')
+    end
+
+    %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).each do |type|
+      it 'resolves a record with a particular type' do
+        expect(Net::DNS::Resolver).to receive(:new) { resolve }
+        send_command("dig example.com #{type}")
+        expect(replies.last).to eq('Generic A response example.com')
+      end
+    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 MX')
+      expect(replies.last).to eq('Unknown domain example.com')
+    end
+
+    it 'shows a warning if the type does not exist' do
+      send_command('dig example.com omg')
+      expect(replies.last).to eq('Unknown record type')
+    end
+
+    it 'shows an error if the request fails' do
+      expect(Net::DNS::Resolver).to receive(:new) { resolve_noresponse }
+      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')
+      expect(replies.last).to eq('Generic A response example.com')
+    end
+
+    it 'shows a warning if the domain does not exist' do
+      expect(Net::DNS::Resolver).to receive(:new) { resolve_unknown }
+      send_command('dig @8.8.8.8 example.com')
+      expect(replies.last).to eq('Unknown domain example.com')
+    end
+
+    it 'shows an error if the request fails' do
+      expect(Net::DNS::Resolver).to receive(:new) { resolve_noresponse }
+      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')
+      expect(replies.last).to eq('Generic MX response example.com')
+    end
+
+    it 'resolves a lowercase 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')
+      expect(replies.last).to eq('Generic MX response example.com')
+    end
+
+    it 'shows a warning if the domain does not exist' do
+      expect(Net::DNS::Resolver).to receive(:new) { resolve_unknown }
+      send_command('dig @8.8.8.8 example.com MX')
+      expect(replies.last).to eq('Unknown domain example.com')
+    end
+
+    it 'shows an error if the request fails' do
+      expect(Net::DNS::Resolver).to receive(:new) { resolve_noresponse }
+      send_command('dig @8.8.8.8 example.com MX')
+      expect(replies.last).to eq('Unable to resolve example.com')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'simplecov'
+require 'coveralls'
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start { add_filter '/spec/' }
+
+require 'lita-dig'
+require 'lita/rspec'

metadata

@@ -0,0 +1,172 @@
+--- !ruby/object:Gem::Specification
+name: lita-dig
+version: !ruby/object:Gem::Version
+  version: 0.5.0
+platform: ruby
+authors:
+- Eric Sigler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lita
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: net-dns
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta2
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Lita handler for resolving DNS records
+email:
+- me@esigler.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/lita-dig.rb
+- lib/lita/handlers/dig.rb
+- lita-dig.gemspec
+- locales/en.yml
+- spec/lita/handlers/dig_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/esigler/lita-dig
+licenses:
+- MIT
+metadata:
+  lita_plugin_type: handler
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: A Lita handler for resolving DNS records
+test_files:
+- spec/lita/handlers/dig_spec.rb
+- spec/spec_helper.rb