tincheck 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e28521acf6e657f3ab1d686db3846d7fdf756a9f
+  data.tar.gz: 0e30b296dc379f2de12352451d50913bc2480cd5
+SHA512:
+  metadata.gz: d6c12cda7b4bfaf7e1f829d157a96a934fc30bf2c9851622c45aadf37203a0083a90cdbb041a6478114e079bb04687df3a0242e67eb62430443a72ca3914d9d8
+  data.tar.gz: 34077a7189cb3ccace190768a33dd77af1adceb874f787f20cb7e6f4d578020664e50b94b2420b1822edb084045b018b3bdc3dda246799a22a97dc5b35ccb845

data/LICENSE.txt

@@ -0,0 +1,18 @@
+Copyright (c) 2019 Joshua Hansen
+
+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 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,95 @@
+# TINCheck
+
+## Overview
+
+This gem provides a simple interface for interacting with TINCheck's SOAP API. It doesn't use any SOAP library and the response object is a glorified hash that merges all the keys from the various Result elements.
+
+## Installation
+
+Pretty standard gem stuff.
+
+    $ gem install tincheck
+
+When using [Bundler](https://bundler.io) or requiring this library in general, it's important to note that this gem will attempt to load its XML add-ons by default if `Ox` or `Nokogiri` is already defined, it will use them in that order. Otherwise, it will use the default of `REXML`. The only consideration is that `REXML` will get required if neither optional library is already required.
+
+So, ensure you load your project's XML libs (if you're using them) first.
+
+## Configuration
+
+Generally, you'll just configure a username and password. Unfortunately, TINCheck doesn't have any sort of a sandbox. Happy testing.
+
+### `ENV`
+
+Prefix any configuration option with `tincheck_` and it will be automatically set:
+
+* `ENV['tincheck_password']`
+* `ENV['tincheck_proxy_url']`
+* `ENV['tincheck_username']`
+* `ENV['tincheck_xml_lib']`
+
+You can return the configuration set by the environment with `TINCheck.env_config` which might be useful in situations where you want multiple configurations modified from a default set by the environment.
+
+### With a Hash
+
+```ruby
+TINCheck.configure(
+  password: 'password',
+  username: 'user@example.com'
+)
+```
+
+### With a Block
+
+```ruby
+TINCheck.configure do
+  password 'password'
+  username 'user@example.com'
+end
+```
+
+## Making Requests
+
+Basic requests can be made using `TINCheck.request`. This will take the supplied hash, wrap it in a SOAP envelop and inject the proper credentials. You should probably never do this directly.
+
+TINCheck only supports for different services and this gem currently supports only two of those, each with its own method.
+
+### Check Service Status
+
+If you want to just make sure everything is working:
+
+```ruby
+response = TINCheck.status # => #<TINCheck::Response>
+```
+
+### Check a TIN and a Name
+
+```ruby
+response = TINCheck.tin_name(name: 'John Q Person', tin: '000000000') # => #<TINCheck::Response>
+response.name_and_tin_match? # => true
+response.death_record? # => false
+```
+
+## Contributing
+
+### Issue Guidelines
+
+GitHub issues are for bugs, not support. As of right now, there is no official support for this gem. You can try reaching out to the author, [Joshua Hansen](mailto:joshua@epicbanality.com?subject=TINCheck) if you're really stuck, but there's a pretty high chance that won't go anywhere at the moment or you'll get a response like this:
+
+> Hi. I'm super busy. It's nothing personal. Check the README first if you haven't already. If you don 't find your answer there, it's time to start reading the source. Have fun! Let me know if I screwed something up.
+
+### Pull Request Guidelines
+
+* Include tests with your PRs. (Wouldn't it be nice if I included some?)
+* Run `rubocop` to ensure your style fits with the rest of the project.
+
+### Code of Conduct
+
+Be nice. After all, this is free code. I have a day job.
+
+## License
+
+See [`LICENSE.txt`](LICENSE.txt).
+
+## What if I stop maintaining this?
+
+The codebase isn't huge. If you opt to rely on this code and I die/get bored/find enlightenment you should be able to maintain it. Sadly, that's the only guarantee at the moment!

data/lib/tincheck.rb

@@ -0,0 +1,33 @@
+# frozen-string-literal: true
+
+require 'tincheck/config'
+require 'tincheck/request'
+
+module TINCheck
+  class << self
+    attr_reader :default_config, :default_request
+
+    def configure(config = env_config, &blk)
+      @default_config = block_given? ? Config.build(&blk) : Config.with_obj(config)
+      @default_request = Request.new(@default_config)
+    end
+
+    def env_config
+      opts = Config::OPTS.each_with_object({}) do |k, h|
+        env_key = "tincheck_#{k}"
+        h[k] = ENV[env_key] if ENV.key?(env_key)
+      end
+      Config.new(opts)
+    end
+
+    def request(request_hash)
+      default_request.(request_hash)
+    end
+    alias call request
+
+    Request::SERVICES.keys.each do |k|
+      define_method(k) { |**kwargs| default_request.public_send(k, kwargs) }
+    end
+  end
+  configure
+end

data/lib/tincheck/config.rb

@@ -0,0 +1,91 @@
+# frozen-string-literal: true
+
+require 'net/http'
+require 'uri'
+
+module TINCheck
+  class Config
+    OPTS = %i[password proxy_url url username xml_lib].freeze
+    SERVICE_URI = URI.parse('https://www.tincheck.com/pvsws/pvsservice.asmx').freeze
+
+    class Builder
+      def self.call(&blk)
+        new.(&blk)
+      end
+
+      def initialize
+        @opts = {}
+      end
+
+      OPTS.each { |o| define_method(o) { |val| @opts[o] = val.to_s } }
+
+      def call(&blk)
+        instance_eval(&blk) if block_given?
+        Config.new(@opts)
+      end
+    end
+
+    class << self
+      def build(&blk)
+        Config::Builder.(&blk)
+      end
+
+      def with_obj(config)
+        config.is_a?(self) ? config : new(config)
+      end
+    end
+
+    attr_reader :proxy_uri
+
+    def initialize(**opts)
+      @opts = opts.each_with_object({}) do |(k, v), h|
+        OPTS.include?(k = k.to_sym) && h[k] = v.to_s
+      end
+      defaults!
+      load_xml_lib
+      proxy_uri!
+    end
+
+    def opts
+      @opts.dup
+    end
+
+    def proxy_args
+      @proxy_uri ? [@proxy_uri.host, @proxy_uri.port, @proxy_uri.user, @proxy_uri.password] : []
+    end
+
+    def with(**opts)
+      self.class.new(@opts.merge(opts))
+    end
+
+    (OPTS + [:uri]).each { |o| define_method(o) { @opts[o] } }
+
+    private
+
+    def default_uri(url)
+      url ? URI(url) : SERVICE_URI
+    end
+
+    def default_xml_lib
+      return 'Ox' if defined?(::Ox)
+      return 'Nokogiri' if defined?(::Nokogiri)
+      'REXML'
+    end
+
+    def defaults!
+      @opts[:xml_lib] ||= default_xml_lib
+      @opts[:password] ||= ENV['tincheck_password']
+      @opts[:username] ||= ENV['tincheck_username']
+      @opts[:uri] ||= default_uri(@opts[:url])
+    end
+
+    def load_xml_lib
+      require "tincheck/xml/#{@opts[:xml_lib].downcase}"
+    end
+
+    def proxy_uri!
+      return unless (url = @opts[:proxy_url] || ENV['HTTP_PROXY'] || ENV['http_proxy'])
+      @proxy_uri = URI(url)
+    end
+  end
+end

data/lib/tincheck/request.rb

@@ -0,0 +1,111 @@
+# frozen-string-literal: true
+
+require 'tincheck/response'
+require 'tincheck/xml'
+
+module TINCheck
+  class Request
+    SERVICES = {
+      list_match: 'ValidateListMatch',
+      status: 'ServiceStatus',
+      tin_name: 'ValidateTinName',
+      validate_all: 'ValidateTinNameAddressListMatch'
+    }.freeze
+
+    SERVICE_XMLNS = 'http://www.TinCheck.com/WebServices/PVSService/'.freeze
+
+    InvalidConfig = Class.new(StandardError)
+    ResponseError = Class.new(StandardError)
+
+    attr_reader :config, :http, :serializer
+
+    def initialize(config = TINCheck.default_config, http: nil, serializer: nil)
+      raise InvalidConfig, 'invalid or missing config' unless config.is_a?(Config)
+      @config = config
+      @http = http || _http
+      @parser = XML.parser_with(config.xml_lib)
+      @serializer = serializer || XML.serializer_with(config.xml_lib)
+    end
+
+    def call(request_hash)
+      r = post(serializer.(format_request(request_hash)))
+      Response.with_http_response(r, parser: @parser)
+    end
+
+    def post(xml)
+      http.dup.start { |h| h.request(post_request(xml)) }
+    end
+
+    def status(*)
+      call(SERVICES[:status] => {})
+    end
+
+    def tin_name(**kwargs)
+      require_arguments!(kwargs, :name, :tin)
+      call(SERVICES[:tin_name] => tin_name_arg(**kwargs))
+    end
+
+    private
+
+    def _http
+      Net::HTTP.new(config.uri.host, config.uri.port, *config.proxy_args).tap do |h|
+        h.use_ssl = true if config.uri.scheme == 'https'
+      end
+    end
+
+    def auth_args
+      raise InvalidConfig, 'no username or password specified in config' unless
+        config.username && config.password
+      {
+        'CurUser' => {
+          'UserLogin' => config.username,
+          'UserPassword' => config.password
+        }
+      }
+    end
+
+    def format_request(request_hash)
+      soap_envelop(inject_auth_args(request_hash))
+    end
+
+    def inject_auth_args(request_hash)
+      k, h = request_hash.first
+      return request_hash if h.key?('CurUser')
+      request_hash.merge(k => h.merge(auth_args))
+    end
+
+    def post_request(xml)
+      Net::HTTP::Post.new(config.uri.path).tap do |r|
+        r['Content-Type'] ||= 'text/xml; charset=UTF-8'
+        r.body = xml
+      end
+    end
+
+    def require_arguments!(kwargs, *keys)
+      keys.each { |k| raise ArgumentError, "missing keyword: #{k}" unless kwargs.key?(k) }
+      kwargs
+    end
+
+    def soap_envelop(request_hash)
+      {
+        'SOAP-ENV:Envelope' => {
+          'xmlns:SOAP-ENC' => 'http://schemas.xmlsoap.org/soap/encoding/',
+          'xmlns:SOAP-ENV' => 'http://schemas.xmlsoap.org/soap/envelope/',
+          'xmlns:xsd' => 'http://www.w3.org/2001/XMLSchema',
+          'xmlns:xsi' => 'http://www.w3.org/2001/XMLSchema-instance',
+          'SOAP-ENV:Body' => request_hash.merge('xmlns' => SERVICE_XMLNS)
+        }
+      }
+    end
+
+    def tin_name_arg(giin: nil, name:, tin: nil, **)
+      {
+        'TinName' => {
+          'TIN' => tin,
+          'LName' => name,
+          'GIIN' => giin
+        }
+      }
+    end
+  end
+end

data/lib/tincheck/response.rb

@@ -0,0 +1,67 @@
+# frozen-string-literal: true
+
+require 'tincheck/xml'
+
+module TINCheck
+  class Response
+    APIError = Class.new(RuntimeError)
+    ConfigError = Class.new(RuntimeError)
+    HTTPError = Class.new(RuntimeError)
+
+    include Enumerable
+
+    class << self
+      def with_http_response(http_response, parser:)
+        http_ok?(http_response)
+        new(http_response.body, parser: parser)
+      end
+
+      private
+
+      def http_error(http_response)
+        "server responded with #{http_response.code} instead of 200"
+      end
+
+      def http_ok?(http_response)
+        raise HTTPError, http_error(http_response) unless http_response.code == '200'
+      end
+    end
+
+    def initialize(xml, parser:)
+      @to_h = merge_results(parser.(xml).values)
+    end
+
+    def [](key)
+      @to_h[key]
+    end
+
+    def calls_remaining
+      self['CallsRemaining'] == 'No Limit' ? nil : self['CallsRemaining'].to_i
+    end
+
+    def death_record?
+      self['DMF_CODE'] == '1'
+    end
+
+    def each(*args, &blk)
+      @to_h.each(*args, &blk)
+    end
+
+    def merge_results(results)
+      results.reduce({}) { |h, rs| h.merge(rs) }
+    end
+
+    def name_and_tin_match?
+      %w[1 6 7 8].include?(self['TINNAME_CODE'])
+    end
+
+    def to_h
+      @to_h.dup
+    end
+    alias to_hash to_h
+
+    def watch_lists?
+      self['LISTSMATCH_CODE'] == '1'
+    end
+  end
+end

data/lib/tincheck/version.rb

@@ -0,0 +1,12 @@
+# frozen-string-literal: true
+
+module TINCheck
+  MAJOR = 0
+  MINOR = 1
+  TINY  = 0
+  VERSION = [MAJOR, MINOR, TINY].join('.').freeze
+
+  def self.version
+    VERSION
+  end
+end

data/lib/tincheck/xml.rb

@@ -0,0 +1,29 @@
+# frozen-string-literal: true
+
+require 'tincheck/xml/parser'
+require 'tincheck/xml/serializer'
+
+module TINCheck
+  module XML
+    class << self
+      def hash_or_array(obj)
+        case obj
+        when Hash
+          yield(obj)
+        when Array
+          obj.map { |o| yield(o) }
+        else
+          obj
+        end
+      end
+
+      def parser_with(name)
+        const_get(name)::Parser.new
+      end
+
+      def serializer_with(name, attributes: Serializer::ATTRIBUTES)
+        const_get(name)::Serializer.new(attributes: attributes)
+      end
+    end
+  end
+end

data/lib/tincheck/xml/nokogiri.rb

@@ -0,0 +1,45 @@
+# frozen-string-literal: true
+
+require 'nokogiri'
+require 'tincheck/xml'
+
+module TINCheck
+  module XML
+    module Nokogiri
+      class Parser
+        include XML::Parser
+
+        private
+
+        def root(xml)
+          ::Nokogiri::XML(xml) { |c| c.options = ::Nokogiri::XML::ParseOptions::NOBLANKS }
+        end
+
+        def value_with!(element)
+          element.elements.empty? ? text_or_nil(element.text) : hash_with(*element.elements)
+        end
+      end
+
+      class Serializer
+        include XML::Serializer
+
+        def call(hash)
+          ::Nokogiri::XML::Document.new.tap { |d| add_xml_elements!(d, hash) }.to_s
+        end
+
+        private
+
+        def attributes_or_elements!(parent, key, value)
+          return parent[key] = text_with(value) if attributes.include?(key)
+          e = ::Nokogiri::XML::Element.new(key, parent)
+          parent.add_child(e)
+          add_xml_elements!(e, value)
+        end
+
+        def insert_text!(element, text)
+          element.add_child(text_with(text))
+        end
+      end
+    end
+  end
+end

data/lib/tincheck/xml/ox.rb

@@ -0,0 +1,46 @@
+# frozen-string-literal: true
+
+require 'ox'
+require 'tincheck/xml'
+
+module TINCheck
+  module XML
+    module Ox
+      class Parser
+        include XML::Parser
+
+        private
+
+        def root(xml)
+          ::Ox.load(xml, symbolize_keys: false)
+        end
+
+        def value_with!(node)
+          return if node.nodes.empty?
+          node.text || hash_with(*node.nodes)
+        end
+      end
+
+      class Serializer
+        include XML::Serializer
+
+        def call(hash)
+          ::Ox.dump(add_xml_elements!(::Ox::Document.new(version: '1.0'), hash))
+        end
+
+        private
+
+        def attributes_or_elements!(parent, key, value)
+          return parent[key] = text_with(value) if attributes.include?(key)
+          e = ::Ox::Element.new(key)
+          parent << e
+          add_xml_elements!(e, value)
+        end
+
+        def insert_text!(node, text)
+          node << text_with(text)
+        end
+      end
+    end
+  end
+end

data/lib/tincheck/xml/parser.rb

@@ -0,0 +1,38 @@
+# frozen-string-literal: true
+
+module TINCheck
+  module XML
+    module Parser
+      def call(xml)
+        at_depth(3, hash_with(root(xml)))
+      end
+
+      private
+
+      def at_depth(num, hash)
+        return unless hash.is_a?(Hash)
+        nh = hash.values.first
+        num.zero? ? nh : at_depth(num - 1, nh)
+      end
+
+      def hash_with(*nodes)
+        nodes.each_with_object({}) do |n, h|
+          inject_or_merge!(h, n.name, value_with!(n))
+        end
+      end
+
+      def inject_or_merge!(hash, key, value)
+        if hash.key?(key)
+          cv = hash[key]
+          value = cv.is_a?(Array) ? cv.push(value) : [cv, value]
+        end
+        hash[key] = value
+      end
+
+      def text_or_nil(text)
+        return if !text || text.empty? || text[0] == "\n"
+        text
+      end
+    end
+  end
+end

data/lib/tincheck/xml/rexml.rb

@@ -0,0 +1,52 @@
+# frozen-string-literal: true
+
+require 'rexml/document'
+require 'tincheck/xml'
+
+module TINCheck
+  module XML
+    module REXML
+      class Parser
+        include XML::Parser
+
+        private
+
+        def attribute_hash(element)
+          element.attributes.each_with_object({}) { |(k, v), h| h[k] = v.to_s }
+        end
+
+        def root(xml)
+          ::REXML::Document.new(xml).root
+        end
+
+        def value_with!(element)
+          children = element.elements.to_a
+          return element.text if element.attributes.empty? && children.empty?
+          attribute_hash(element).merge(hash_with(*children))
+        end
+      end
+
+      class Serializer
+        include XML::Serializer
+
+        def call(hash)
+          ::REXML::Document.new(nil, attribute_quote: :quote).tap do |d|
+            d.add(::REXML::XMLDecl.new)
+            add_xml_elements!(d, hash)
+          end.to_s
+        end
+
+        private
+
+        def attributes_or_elements!(parent, key, value)
+          return parent.add_attribute(key, text_with(value)) if attributes.include?(key)
+          add_xml_elements!(::REXML::Element.new(key, parent, parent.context), value)
+        end
+
+        def insert_text!(element, text)
+          element.add_text(text_with(text))
+        end
+      end
+    end
+  end
+end

data/lib/tincheck/xml/serializer.rb

@@ -0,0 +1,47 @@
+# frozen-string-literal: true
+
+module TINCheck
+  module XML
+    module Serializer
+      ATTRIBUTES = %w[
+        xmlns
+        xmlns:SOAP-ENC
+        xmlns:SOAP-ENV
+        xmlns:xsd
+        xmlns:xsi
+      ].freeze
+
+      @@type_coercions = {}
+      def self.coerce(type, obj = nil, &blk)
+        raise TypeError, '`type` must be a `Class`' unless type.is_a?(Class)
+        obj ||= blk
+        raise TypeError, '`obj` must respond to `call`' unless obj.respond_to?(:call)
+        @@type_coercions[type] = obj
+      end
+
+      attr_reader :attributes
+
+      def initialize(attributes: ATTRIBUTES)
+        @attributes = attributes
+      end
+
+      private
+
+      def add_xml_elements!(parent, obj)
+        case obj
+        when Hash
+          obj.each { |k, v| attributes_or_elements!(parent, k, v) }
+        when Array
+          obj.each { |v| add_xml_elements!(parent, v) }
+        else
+          insert_text!(parent, obj)
+        end
+        parent
+      end
+
+      def text_with(obj)
+        (callable = @@type_coercions[obj.class]) ? callable.call(obj) : obj.to_s
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: tincheck
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Joshua
+- Hansen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-01-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: ox
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.56'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.56'
+description: A Ruby implementation of the TINCheck API
+email:
+- joshua@epicbanality.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/tincheck.rb
+- lib/tincheck/config.rb
+- lib/tincheck/request.rb
+- lib/tincheck/response.rb
+- lib/tincheck/version.rb
+- lib/tincheck/xml.rb
+- lib/tincheck/xml/nokogiri.rb
+- lib/tincheck/xml/ox.rb
+- lib/tincheck/xml/parser.rb
+- lib/tincheck/xml/rexml.rb
+- lib/tincheck/xml/serializer.rb
+homepage: https://github.com/binarypaladin/tincheck-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.4
+signing_key: 
+specification_version: 4
+summary: A Ruby implementation of the TINCheck API
+test_files: []