what3words 2.2.0 → 3.1.0

data/lib/what3words/api.rb

@@ -1,194 +1,248 @@
-# encoding: utf-8
+# frozen_string_literal: true
 
 require 'rest-client'
+require 'json'
+require File.expand_path('../version', __FILE__)
+require 'what3words/version'
 
 module What3Words
-  # Document the responsibility of the class
-  #
-  class API # rubocop:disable Metrics/ClassLength
+  # What3Words v3 API wrapper
+  class API
     class Error < RuntimeError; end
     class ResponseError < Error; end
     class WordError < Error; end
 
-    REGEX_3_WORD_ADDRESS = /^\p{L}+\.\p{L}+\.\p{L}+$/u
-    REGEX_STRICT = /^\p{L}{3,}+\.\p{L}{3,}+\.\p{L}{3,}+$/u
-
-    BASE_URL = 'https://api.what3words.com/v2/'.freeze
+    REGEX_3_WORD_ADDRESS = /^\/{0,3}(?:[^0-9`~!@#$%^&*()+\-_=\[\{\]}\\|'<,.>?\/\";:£§º©®\s]{1,}[.\uFF61\u3002\uFF65\u30FB\uFE12\u17D4\u0964\u1362\u3002][^0-9`~!@#$%^&*()+\-_=\[\{\]}\\|'<,.>?\/\";:£§º©®\s]{1,}[.\uFF61\u3002\uFF65\u30FB\uFE12\u17D4\u0964\u1362\u3002][^0-9`~!@#$%^&*()+\-_=\[\{\]}\\|'<,.>?\/\";:£§º©®\s]{1,}|'<,.>?\/\";:£§º©®\s]+[.\uFF61\u3002\uFF65\u30FB\uFE12\u17D4\u0964\u1362\u3002][^0-9`~!@#$%^&*()+\-_=\[\{\]}\\|'<,.>?\/\";:£§º©®\s]+|[^0-9`~!@#$%^&*()+\-_=\[\{\]}\\|'<,.>?\/\";:£§º©®\s]+([\u0020\u00A0][^0-9`~!@#$%^&*()+\-_=\[\{\]}\\|'<,.>?\/\";:£§º©®\s]+){1,3}[.\uFF61\u3002\uFF65\u30FB\uFE12\u17D4\u0964\u1362\u3002][^0-9`~!@#$%^&*()+\-_=\[\{\]}\\|'<,.>?\/\";:£§º©®\s]+([\u0020\u00A0][^0-9`~!@#$%^&*()+\-_=\[\{\]}\\|'<,.>?\/\";:£§º©®\s]+){1,3}[.\uFF61\u3002\uFF65\u30FB\uFE12\u17D4\u0964\u1362\u3002][^0-9`~!@#$%^&*()+\-_=\[\{\]}\\|'<,.>?\/\";:£§º©®\s]+([\u0020\u00A0][^0-9`~!@#$%^&*()+\-_=\[\{\]}\\|'<,.>?\/\";:£§º©®\s]+){1,3})$/u.freeze
+    BASE_URL = 'https://api.what3words.com/v3/'
 
     ENDPOINTS = {
-      forward: 'forward',
-      reverse: 'reverse',
-      languages: 'languages',
+      convert_to_coordinates: 'convert-to-coordinates',
+      convert_to_3wa: 'convert-to-3wa',
+      available_languages: 'available-languages',
       autosuggest: 'autosuggest',
-      standardblend: 'standardblend',
-      autosuggest_ml: 'autosuggest-ml',
-      standardblend_ml: 'standardblend-ml',
-      grid: 'grid'
+      grid_section: 'grid-section'
     }.freeze
 
+    WRAPPER_VERSION = What3Words::VERSION
+
     def initialize(params)
       @key = params.fetch(:key)
     end
 
     attr_reader :key
 
-    def forward(words, params = {})
-      words_string = get_words_string words
-      request_params = assemble_forward_request_params(words_string, params)
-      response = request! :forward, request_params
-      response
-    end
-
-    def reverse(position, params = {})
-      request_params = assemble_reverse_request_params(position, params)
-      response = request! :reverse, request_params
-      response
-    end
-
-    def grid(bbox, params = {})
+    def convert_to_coordinates(words, params = {})
+      """
+      Take a 3 word address and turn it into a pair of coordinates.
+
+      Params
+      ------
+      :param string words: A 3 word address as a string
+      :param string format: Return data format type; can be one of json (the default), geojson
+      :rtype: Hash
+      """
+      words_string = get_words_string(words)
+      request_params = assemble_convert_to_coordinates_request_params(words_string, params)
+      request!(:convert_to_coordinates, request_params)
+    end
+
+    def convert_to_3wa(position, params = {})
+      """
+      Take latitude and longitude coordinates and turn them into a 3 word address.
+
+      Params
+      ------
+      :param array position: The coordinates of the location to convert to 3 word address
+      :param string format: Return data format type; can be one of json (the default), geojson
+      :param string language: A supported 3 word address language as an ISO 639-1 2 letter code.
+      :rtype: Hash
+      """
+      request_params = assemble_convert_to_3wa_request_params(position, params)
+      request!(:convert_to_3wa, request_params)
+    end
+
+    def grid_section(bbox, params = {})
+      """
+      Returns a section of the 3m x 3m what3words grid for a given area.
+
+      Params
+      ------
+      :param string bbox: Bounding box, specified by the northeast and southwest corner coordinates,
+      :param string format: Return data format type; can be one of json (the default), geojson
+      :rtype: Hash
+      """
       request_params = assemble_grid_request_params(bbox, params)
-      response = request! :grid, request_params
-      response
+      request!(:grid_section, request_params)
     end
 
-    def languages
-      request_params = assemble_common_request_params({})
-      response = request! :languages, request_params
-      response
-    end
+    def available_languages
+      """
+      Retrieve a list of available 3 word languages.
 
-    def autosuggest(addr, lang, focus = {}, clip = {}, params = {})
-      request_params = assemble_autosuggest_request_params(addr, lang, focus,
-                                                           clip, params)
-      response = request! :autosuggest, request_params
-      response
+      :rtype: Hash
+      """
+      request_params = assemble_common_request_params({})
+      request!(:available_languages, request_params)
+    end
+
+    def autosuggest(input, params = {})
+      """
+      Returns a list of 3 word addresses based on user input and other parameters.
+
+      Params
+      ------
+      :param string input: The full or partial 3 word address to obtain suggestions for.
+      :param int n_results: The number of AutoSuggest results to return.
+      :param array focus: A location, specified as a latitude,longitude used to refine the results.
+      :param int n_focus_results: Specifies the number of results (must be <= n_results) within the results set which will have a focus.
+      :param string clip_to_country: Restricts autosuggest to only return results inside the countries specified by comma-separated list of uppercase ISO 3166-1 alpha-2 country codes.
+      :param array clip_to_bounding_box: Restrict autosuggest results to a bounding box, specified by coordinates.
+      :param array clip_to_circle: Restrict autosuggest results to a circle, specified by the center of the circle, latitude and longitude, and a distance in kilometres which represents the radius.
+      :param array clip_to_polygon: Restrict autosuggest results to a polygon, specified by a list of coordinates.
+      :param string input_type: For power users, used to specify voice input mode. Can be text (default), vocon-hybrid, nmdp-asr or generic-voice.
+      :param string prefer_land: Makes autosuggest prefer results on land to those in the sea.
+      :param string language: A supported 3 word address language as an ISO 639-1 2 letter code.
+      :rtype: Hash
+      """
+      request_params = assemble_autosuggest_request_params(input, params)
+      request!(:autosuggest, request_params)
+    end
+
+    def isPossible3wa(text)
+      """
+      Determines if the string passed in is the form of a three word address.
+      This does not validate whether it is a real address as it returns true for x.x.x
+
+      Params
+      ------
+      :param string text: text to check
+      :rtype: Boolean
+      """
+      regex_match = REGEX_3_WORD_ADDRESS
+      !(text.match(regex_match).nil?)
+    end
+
+    def findPossible3wa(text)
+      """
+      Searches the string passed in for all substrings in the form of a three word address.
+      This does not validate whether it is a real address as it will return x.x.x as a result
+
+      Params
+      ------
+      :param string text: text to check
+      :rtype: Array
+      """
+      regex_search = /[^0-9`~!@#$%^&*()+\-_=\[\{\]}\\|'<,.>?\/\";:£§º©®\s]{1,}[.\uFF61\u3002\uFF65\u30FB\uFE12\u17D4\u0964\u1362\u3002][^0-9`~!@#$%^&*()+\-_=\[\{\]}\\|'<,.>?\/\";:£§º©®\s]{1,}[.\uFF61\u3002\uFF65\u30FB\uFE12\u17D4\u0964\u1362\u3002][^0-9`~!@#$%^&*()+\-_=\[\{\]}\\|'<,.>?\/\";:£§º©®\s]{1,}/
+      text.scan(regex_search)
+    end
+
+    def didYouMean(text)
+      """
+      Determines if the string passed in is almost in the form of a three word address.
+      This will return True for values such as 'filled-count-soap' and 'filled count soap'
+
+      Params
+      ------
+      :param string text: text to check
+      :rtype: Boolean
+      """
+      regex_match = /^\/?[^0-9`~!@#$%^&*()+\-_=\[\{\]}\\|'<,.>?\/\";:£§º©®\s]{1,}[.\uFF61\u3002\uFF65\u30FB\uFE12\u17D4\u0964\u1362\u3002 ,\\\-\/+'&\\:;|\u3000]{1,2}[^0-9`~!@#$%^&*()+\-_=\[\{\]}\\|'<,.>?\/\";:£§º©®\s]{1,}[.\uFF61\u3002\uFF65\u30FB\uFE12\u17D4\u0964\u1362\u3002 ,\\\-\/+'&\\:;|\u3000]{1,2}[^0-9`~!@#$%^&*()+\-_=\[\{\]}\\|'<,.>?\/\";:£§º©®\s]{1,}$/
+      !(text.match(regex_match).nil?)
+    end
+    
+    def isValid3wa(text)
+      """
+      Determines if the string passed in is a real three word address. It calls the API
+      to verify it refers to an actual place on earth.
+
+      Params
+      ------
+      :param String text: text to check
+
+      :rtype: Boolean
+      """
+      if isPossible3wa(text)
+        result = autosuggest(text, 'n-results': 1)
+        if result[:suggestions] && result[:suggestions].length > 0
+          return result[:suggestions][0][:words] == text
+        end
+      end
+      false
     end
 
-    def autosuggest_ml(addr, lang, focus = {}, clip = {}, params = {})
-      request_params = assemble_autosuggest_request_params(addr, lang, focus,
-                                                           clip, params)
-      response = request! :autosuggest_ml, request_params
-      response
-    end
+    private
 
-    def standardblend(addr, lang, focus = {}, params = {})
-      request_params = assemble_standardblend_request_params(addr, lang, focus,
-                                                             params)
-      response = request! :standardblend, request_params
-      response
-    end
+    def request!(endpoint_name, params)
+      headers = { "X-W3W-Wrapper": "what3words-Ruby/#{WRAPPER_VERSION}" }
+      response = RestClient.get(endpoint(endpoint_name), params: params, headers: headers)
+      parsed_response = JSON.parse(response.body)
 
-    def standardblend_ml(addr, lang, focus = {}, params = {})
-      request_params = assemble_standardblend_request_params(addr, lang, focus,
-                                                             params)
-      response = request! :standardblend_ml, request_params
-      response
-    end
+      raise ResponseError, "#{parsed_response['code']}: #{parsed_response['message']}" if parsed_response['error'].to_s.strip != ''
 
-    def assemble_common_request_params(params)
-      h = { key: key }
-      h[:lang] = params[:lang] if params[:lang]
-      h[:format] = params[:format] if params[:format]
-      h[:display] = params[:display] if params[:display]
-      h
+      deep_symbolize_keys(parsed_response)
+    rescue RestClient::ExceptionWithResponse => e
+      handle_rest_client_error(e)
     end
-    private :assemble_common_request_params
 
-    def assemble_forward_request_params(words_string, params)
-      h = { addr: words_string }
-      h.merge(assemble_common_request_params(params))
+    def handle_rest_client_error(error)
+      parsed_response = JSON.parse(error.response)
+      raise ResponseError, "#{parsed_response['code']}: #{parsed_response['message']}" if parsed_response['error']
+      raise error
     end
-    private :assemble_forward_request_params
 
-    def assemble_grid_request_params(bbox, params)
-      h = { bbox: bbox }
-      h.merge(assemble_common_request_params(params))
-    end
-    private :assemble_grid_request_params
-
-    def assemble_reverse_request_params(position, params)
-      h = { coords: position.join(',') }
-      h.merge(assemble_common_request_params(params))
+    def get_words_string(words)
+      words_string = words.is_a?(Array) ? words.join('.') : words.to_s
+      check_words(words_string)
+      words_string
     end
-    private :assemble_reverse_request_params
 
-    def assemble_autosuggest_request_params(addr, lang, focus, clip, params)
-      h = { addr: addr }
-      h[:lang] = lang
-      h[:focus] = focus.join(',') if focus.respond_to? :join
-      h[:clip] = clip if clip.respond_to? :to_str
-      h.merge(assemble_common_request_params(params))
+    def check_words(words)
+      raise WordError, "#{words} is not a valid 3 word address" unless REGEX_3_WORD_ADDRESS.match?(words)
     end
-    private :assemble_autosuggest_request_params
 
-    def assemble_standardblend_request_params(addr, lang, focus, params)
-      h = { addr: addr }
-      h[:lang] = lang
-      h[:focus] = focus.join(',') if focus.respond_to? :join
-      h.merge(assemble_common_request_params(params))
+    def assemble_common_request_params(params)
+      { key: key }.merge(params.slice(:language, :format))
     end
-    private :assemble_standardblend_request_params
 
-    def request!(endpoint_name, params)
-      # puts endpoint_name.inspect
-      # puts params.inspect
-      begin
-        response = RestClient.get endpoint(endpoint_name), params: params
-      rescue => e
-        response = e.response
-      end
-      # puts '#{response.to_str}'
-      # puts 'Response status: #{response.code}'
-      response = JSON.parse(response.body)
-      if response['code'].to_s.strip != ''
-        raise ResponseError, "#{response['code']}: #{response['message']}"
-      end
-      deep_symbolize_keys(response)
+    def assemble_convert_to_coordinates_request_params(words_string, params)
+      { words: words_string }.merge(assemble_common_request_params(params))
     end
-    private :request!
 
-    def get_words_string(words)
-      if words.respond_to? :to_str
-        w = words
-      elsif words.respond_to? :join
-        w = words.join('.')
-      else
-        raise Error, "Cannot get words string for #{words.inspect}"
-      end
-      check_words w
+    def assemble_convert_to_3wa_request_params(position, params)
+      { coordinates: position.join(',') }.merge(assemble_common_request_params(params))
     end
-    private :get_words_string
 
-    def check_words(words)
-      unless REGEX_3_WORD_ADDRESS.match(words)
-        raise WordError, "#{words} is not a valid 3 word address"
-      end
-      words
-    end
-    private :check_words
-
-    def deep_symbolize_keys(i)
-      if i.is_a? Hash
-        ni = {}
-        # rubocop:disable Metrics/LineLength
-        i.each { |k, v| ni[k.respond_to?(:to_sym) ? k.to_sym : k] = deep_symbolize_keys(v) }
-        # rubocop:enable Metrics/LineLength
-      elsif i.is_a? Array
-        ni = i.map(&method(:deep_symbolize_keys))
+    def assemble_grid_request_params(bbox, params)
+      { 'bounding-box': bbox }.merge(assemble_common_request_params(params))
+    end
+
+    def assemble_autosuggest_request_params(input, params)
+      result = { input: input }
+      result[:'n-results'] = params[:'n-results'].to_i if params[:'n-results']
+      result[:focus] = params[:focus].join(',') if params[:focus].respond_to?(:join)
+      result[:'n-focus-results'] = params[:'n-focus-results'].to_i if params[:'n-focus-results']
+      result[:'clip-to-country'] = params[:'clip-to-country'] if params[:'clip-to-country'].respond_to?(:to_str)
+      result[:'clip-to-bounding-box'] = params[:'clip-to-bounding-box'].join(',') if params[:'clip-to-bounding-box'].respond_to?(:join)
+      result[:'clip-to-circle'] = params[:'clip-to-circle'].join(',') if params[:'clip-to-circle'].respond_to?(:join)
+      result[:'clip-to-polygon'] = params[:'clip-to-polygon'].join(',') if params[:'clip-to-polygon'].respond_to?(:join)
+      result[:'input-type'] = params[:'input-type'] if params[:'input-type'].respond_to?(:to_str)
+      result[:'prefer-land'] = params[:'prefer-land'] if params[:'prefer-land']
+      result.merge(assemble_common_request_params(params))
+    end
+
+    def deep_symbolize_keys(value)
+      case value
+      when Hash
+        value.transform_keys(&:to_sym).transform_values { |v| deep_symbolize_keys(v) }
+      when Array
+        value.map { |v| deep_symbolize_keys(v) }
       else
-        ni = i
+        value
       end
-
-      ni
-    end
-
-    def base_url
-      BASE_URL
     end
-    private :base_url
 
     def endpoint(name)
-      base_url + ENDPOINTS.fetch(name)
+      BASE_URL + ENDPOINTS.fetch(name)
     end
   end
 end

data/lib/what3words/version.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+# What3Words v3 API wrapper
 module What3Words
-  VERSION = '2.2.0'.freeze
+  VERSION = '3.1.0' unless defined?(::What3Words::VERSION)
 end

data/lib/what3words.rb

@@ -1,4 +1,6 @@
-module What3Words #:nodoc: don't document this
+# frozen_string_literal: true
+
+module What3Words # :nodoc: don't document this
 end
 
 require 'what3words/api'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: what3words
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 3.1.0
 platform: ruby
 authors:
 - what3words
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-03 00:00:00.000000000 Z
+date: 2024-07-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rest-client
@@ -73,79 +73,67 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.4'
 - !ruby/object:Gem::Dependency
-  name: webmock
+  name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 0.48.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: 0.48.1
 - !ruby/object:Gem::Dependency
-  name: rubocop
+  name: webmock
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.48.1
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.48.1
-description: 
+        version: '3.0'
+description: A Ruby wrapper for the what3words API
 email:
 - development@what3words.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".editorconfig"
-- ".gitignore"
-- ".travis.yml"
-- Gemfile
-- LICENSE.txt
 - README.md
-- Rakefile
 - lib/what3words.rb
 - lib/what3words/api.rb
 - lib/what3words/version.rb
-- spec/config.sample.yaml
-- spec/lib/what3words/what3words_api_spec.rb
-- spec/spec_helper.rb
-- what3words.gemspec
-homepage: http://rubygems.org/gems/what3words
+homepage: https://github.com/what3words/w3w-ruby-wrapper
 licenses:
 - MIT
-metadata: {}
+metadata:
+  documentation_uri: https://www.rubydoc.info/gems/what3words
+  source_code_uri: https://github.com/what3words/w3w-ruby-wrapper
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - "~>"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 3.0.3.1
 signing_key: 
 specification_version: 4
-summary: what3words API wrapper in Ruby
-test_files:
-- spec/config.sample.yaml
-- spec/lib/what3words/what3words_api_spec.rb
-- spec/spec_helper.rb
+summary: Ruby wrapper for the what3words API
+test_files: []

data/.editorconfig

@@ -1,17 +0,0 @@
-# EditorConfig is awesome: http://EditorConfig.org
-
-# top-most EditorConfig file
-root = true
-
-# Unix-style newlines with a newline ending every file
-[*]
-end_of_line = lf
-insert_final_newline = true
-trim_trailing_whitespace = true
-
-# Set default charset
-charset = utf-8
-
-# Indentation
-indent_style = space
-indent_size = 2

data/.gitignore

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

data/.travis.yml

@@ -1,7 +0,0 @@
-language: ruby
-rvm:
-- 2.4
-script: rake rubocop spec
-notifications:
-  slack:
-    secure: DvejcrOH6RdAdrGEPLUrnia9cES8iCHVlVSFAMwx2vaR/I3T9bfUiHnb3VHfiqx4cvDL+9wT3opG0sZkUCFJGqzA3E//VObKNXjwUFCUptFG68qgR7LZ3vDatWlUqU+32gWeYaHM3FpNP2E/IARjphaiF3jRUZbronqVzJZN2MbMsUYBeGq7v0AaLkgbxVgOWtBnMVcBPOnarEJqHyJlqQ2unYnIy+GNoOFtPMPNZobYTf0zxrycldYpP937yT4CTsY3I7RxuEtnY2sPYW+eFBESGLg6EfnjeOruROY+b9cSHIh1Qzr7Oup6a+oQ3+vCvLbYsGpEO04RTeTTtOGc7aRlUylmvuFPi7qQwOTZ+4KD5aIBh4p7bQiPfvAeqDU4pVJxPHHZirgjFpUpAvofj48SvDgwX9cFyAhAlDZ9qBOctmhphW9KNkcAW4MY421AdVAjFWwc5CU8G5oPdKcyWam3ZB3nHwKgZm6LLAcZgbG0rjZT+iPeQBvTKH3kPx7E1CkxZNkEralHJ3l+bDwY3GdzsgcMpT3bWNl3pLszFzgXljDScMU8my1+xjDQINEnI3TCJA4MhKkzYkRgfrEBkgPb2SiF7qnhbyMzSFbCU4jsM1MLQZolNG9EsjsxJLuL4YTC2wKOHajViUUeaCNIcNU5UXBQuit93RyMu7RrLRM=

data/Gemfile

@@ -1,2 +0,0 @@
-source 'https://rubygems.org'
-gemspec

data/LICENSE.txt

@@ -1,22 +0,0 @@
-Copyright (c) 2016, 2017 What3Words Limited
-
-MIT License
-
-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/Rakefile

@@ -1,12 +0,0 @@
-require 'bundler/gem_tasks'
-
-begin
-  require 'rubocop/rake_task'
-  RuboCop::RakeTask.new(:rubocop) do |t|
-    t.options = ['--display-cop-names']
-  end
-  require 'rspec/core/rake_task'
-  RSpec::Core::RakeTask.new(:spec)
-rescue LoadError => e
-  print e
-end

data/spec/config.sample.yaml

@@ -1 +0,0 @@
-# config.sample.yaml