verbalize 2.0.1 → 2.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 28277ada3b560d5fd8ed11a9b568dd03f8c0156a
-  data.tar.gz: 9ff1315685ffa11c9a997a15a07206fe0e21f112
+SHA256:
+  metadata.gz: b4ab48694dce4b9810ed7289498ee4ff0533919ed08041d5abfa4dda1a3800a7
+  data.tar.gz: e2a160824182fef4e702a65b27116505f492cf5f02022bfe928198bb822b2aae
 SHA512:
-  metadata.gz: e4049ff78ca84f4e44f34c6525089edb96b74206ca6318f3b84c78779dd303863a612f0be86059e9e6bd1d8fce2f364a62e3d65b6269575ee13cd1dc7bbd44b9
-  data.tar.gz: a6528d2fa2ec1dc97d9524f6feb75426a249cc6a8bd2b656d7491d2bb5698512ec9718c836f16b33c0bc85d65aba5551a6d135170e2e1ebfb5fdf37c86770948
+  metadata.gz: a533db1a4cc25d45a4c5474a96671d3f172f1e84e7c6bf574f2d281caebbce7967d61f96106a9582cdb3915d4d24c6d4ae33b39577734723b65e0ea4ffcab8d0
+  data.tar.gz: 9068fc27d208da171b89f173eec3af2d78b3a3d90bdc589ec737cf97a978c9044b22a7cc4a8b57237149562169859f819bfce672a65a94978ecaa227a216d907

data/.github/dependabot.yml

@@ -0,0 +1,8 @@
+version: 2
+updates:
+- package-ecosystem: bundler
+  directory: "/"
+  schedule:
+    interval: daily
+    time: "11:00"
+  open-pull-requests-limit: 10

data/.github/workflows/tests.yml

@@ -0,0 +1,25 @@
+name: Tests
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        ruby-version: ['2.6', '2.7', '3.0']
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+      uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby-version }}
+        bundler-cache: true
+    - name: Run tests
+      run: bundle exec rspec

data/CHANGELOG.md

@@ -0,0 +1,91 @@
+# Change Log
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](http://keepachangelog.com/)
+and this project adheres to [Semantic Versioning](http://semver.org/).
+
+## 2.3.1 - 2021-06-02
+### Added
+- release documentation
+- ruby 2.7 compatibility to remove deprecation warnings
+
+## 2.3.0 - 2019-09-23
+### Added
+- you can now specify `validates :key { |value| ... }` on actions to run validation on the input
+  *before* running the `call` block.
+
+## 2.2.0 - 2017-08-19
+### Added
+- changelog started
+- You can now specify default values for optional inputs in the `input` call.
+  Use a regular value to load it once, at load-time, and a lambda to lazily load
+  the value each time the action is called.
+### Changed
+- privatize Action.input. Now that we have Action.inputs, we want to avoid calling Action.input (no s) outside of the action itself
+
+## 2.1.1 - 2017-02-21
+### Fixed
+- ensure Verbalize::Action.optional_input always returns an array
+
+## 2.1.0 - 2017-02-21
+### Added
+- introspect Action input using Action.inputs, Action.required_inputs, and Action.optional_inputs
+
+## 2.0.2 - 2017-2-21 [YANKED]
+- new functionality was added, so minor version should have been increased instead of patch
+
+## 2.0.1 - 2016-12-16
+### Changed
+- internal refactoring
+
+## 2.0.0 - 2016-02-14
+### Added
+- execution of action routed through Action#perform to better support stubbing
+- 100% test coverage!!!
+### Changed
+- calling Failure#value now raises an error, use Failure#failure instead? Did this happen in 1.3?
+### Removed
+- removes action implementation methods other than #call/#call!
+
+## 1.4.1 - 2016-12-14
+### Added
+- Failure#failure added to replace Failure#value
+### Changed
+- Result split into Success/Failure
+### Deprecated
+- stop including Verbalize itself, use Verbalize::Action instead
+- stop using action implementation methods other than #call/#call!
+- stop using Failure#value, used Failure#failure instead
+
+## 1.4.0 [YANKED] - 2016-12-14
+### Fixed
+- error while uploading to ruby gems, yanked and released v1.4.1
+
+## 1.3.0 - 2016-11-09
+### Changed
+- better failure handling
+
+## 1.2.0 - 2016-11-07
+### Added
+- alias Result.success? to Result.succeeded?
+- alias Result.failure? to Result.failed?
+### Changed
+- Action now implements #to_ary instead of subclassing Array
+
+## 1.1.2 - 2016-11-07 [YANKED]
+- new functionality was added, so minor version should have been increased instead of patch
+
+## 1.1.1 - 2016-08-25
+### Changed
+- internal refactoring
+
+## 1.0.1 - 2016-08-10
+### Fixed
+- Use send to call Action#call so that Action#call can be privatized
+
+## 1.0.0 - 2016-08-09
+### Added
+- optional input
+
+## 0.1.0 - 2016-08-07
+- initial release

data/Dockerfile

@@ -0,0 +1,45 @@
+ARG BUNDLER_VERSION=2.0.2
+ARG RUBY_VERSION=2.7.1
+ARG APP_ROOT=/gem
+
+#######################################
+###           Builder
+FROM ruby:${RUBY_VERSION}-alpine AS build-env
+
+ARG APP_ROOT
+
+ENV BUNDLE_APP_CONFIG="$APP_ROOT/.bundle"
+ARG PACKAGES="curl tzdata less git"
+RUN mkdir $APP_ROOT
+WORKDIR $APP_ROOT
+
+RUN apk update \
+    && apk upgrade \
+    && apk add --update --no-cache $PACKAGES
+
+#######################################
+###           Development
+FROM build-env AS development
+
+ARG BUNDLER_VERSION
+ARG APP_ROOT
+ENV BUNDLE_APP_CONFIG="$APP_ROOT/.bundle"
+
+WORKDIR $APP_ROOT
+
+RUN apk add --update --no-cache \
+  build-base \
+  git \
+  tzdata \
+  less
+
+RUN gem install bundler:$BUNDLER_VERSION
+
+COPY . $APP_ROOT
+
+RUN bundle install -j4 --retry 3 \
+  && rm -rf /usr/local/bundle/cache/*.gem \
+  && find /usr/local/bundle/gems/ -name "*.c" -delete \
+  && find /usr/local/bundle/gems/ -name "*.o" -delete
+
+

data/README.md

@@ -53,6 +53,35 @@ Add.call # => [:ok, 42]
 Add.call(a: 660, b: 6) # => [:ok, 666]
 ```
 
+## Default Values
+
+```ruby
+# You can define defaults via key/value pairs, as so:
+class Add
+  include Verbalize::Action
+  # note that these values are evaluated at load-time as they are not wrapped
+  # in lambdas.
+  input optional: [a: 35, b: 7]
+  def call; a + b; end
+end
+
+# default values can be lazily loaded by passing in a lambda, e.g.:
+
+class Tomorrow
+  include Verbalize::Action
+  input optional: [as_of: -> { Time.now }]
+  def call
+    as_of + 1
+  end
+end
+
+start_time = Tomorrow.call!
+sleep(1)
+end_time = Tomorrow.call!
+end_time - start_time # ~1s; the default is executed each call.
+```
+
+
 ```ruby
 class Divide
   include Verbalize::Action
@@ -69,6 +98,52 @@ result = Divide.call(a: 1, b: 0) # => [:error, 'You can’t divide by 0']
 result.failed? # => true
 ```
 
+### Reflection
+```ruby
+class Add
+  include Verbalize::Action
+
+  input :a, :b, optional: [:c, :d]
+
+  def call
+    a + b + c + d
+  end
+
+  private
+
+  def c
+    @c ||= 0
+  end
+
+  def d
+    @d ||= 0
+  end
+end
+
+Add.required_inputs # [:a, :b]
+Add.optional_inputs # [:c, :d]
+Add.inputs # [:a, :b, :c, :d]
+```
+
+## Validation
+```ruby
+class FloatAdd
+  include Verbalize::Action
+
+  input :a, :b
+  validate(:a) { |a| a.is_a?(Float) }
+  validate(:b) { |b| b.is_a?(Float) && b > 10.0 }
+
+  def call
+    a + b
+  end
+end
+
+FloatAdd.call!(a: 1, b: 1) # fails with  Input "a" failed validation!
+FloatAdd.call!(a: 1.0, b: 1.0) # fails with Input "b" failed validation!
+FloatAdd.call!(a: 1.0, b: 12.0) # 13.0
+```
+
 ## Comparison/Benchmark
 ```ruby
 require 'verbalize'
@@ -132,21 +207,21 @@ end
 
 ```
 Warming up --------------------------------------
-                Ruby    53.203k i/100ms
-           Verbalize    27.518k i/100ms
-          Actionizer     4.933k i/100ms
-          Interactor     4.166k i/100ms
+                Ruby    63.091k i/100ms
+           Verbalize    40.521k i/100ms
+          Actionizer     5.226k i/100ms
+          Interactor     4.874k i/100ms
 Calculating -------------------------------------
-                Ruby    544.025k (±13.7%) i/s -      2.660M in   5.011207s
-           Verbalize    278.738k (± 8.0%) i/s -      1.403M in   5.074676s
-          Actionizer     49.571k (± 7.0%) i/s -    246.650k in   5.006194s
-          Interactor     45.896k (± 7.1%) i/s -    229.130k in   5.018389s
+                Ruby    751.604k (± 3.0%) i/s -      3.785M in   5.041472s
+           Verbalize    457.598k (± 6.1%) i/s -      2.310M in   5.072488s
+          Actionizer     54.874k (± 3.5%) i/s -    276.978k in   5.054541s
+          Interactor     52.294k (± 3.2%) i/s -    263.196k in   5.038365s
 
 Comparison:
-                Ruby:   544025.0 i/s
-           Verbalize:   278737.9 i/s - 1.95x  slower
-          Actionizer:    49571.1 i/s - 10.97x  slower
-          Interactor:    45896.1 i/s - 11.85x  slower
+                Ruby:   751604.0 i/s
+           Verbalize:   457597.9 i/s - 1.64x  slower
+          Actionizer:    54873.6 i/s - 13.70x  slower
+          Interactor:    52293.6 i/s - 14.37x  slower
 
 ```
 
@@ -155,15 +230,15 @@ Comparison:
 ### Happy Path
 
 When testing positive cases of a `Verbalize::Action`, it is recommended to test using the `call!` class method and
-assert on the result.  This implicitly ensures a successful result, and your tests will fail with a bang! if 
+assert on the result.  This implicitly ensures a successful result, and your tests will fail with a bang! if
 something goes wrong:
 
 ```ruby
 class MyAction
   include Verbalize::Action
-  
+
   input :a
-  
+
   def call
     fail!('#{a} is greater than than 100!') if a >= 100
     a + 1
@@ -178,28 +253,28 @@ end
 
 ### Sad Path
 
-When testing negative cases of a `Verbalize::Action`, it is recommended to test using the `call` non-bang 
+When testing negative cases of a `Verbalize::Action`, it is recommended to test using the `call` non-bang
 class method which will return a `Verbalize::Failure` on failure.
 
-Use of `call!` here is not advised as it will result in an exception being thrown. Set assertions on both 
+Use of `call!` here is not advised as it will result in an exception being thrown. Set assertions on both
 the failure outcome and value:
 
 ```ruby
 class MyAction
   include Verbalize::Action
-  
+
   input :a
-  
+
   def call
     fail!('#{a} is greater than 100!') if a >= 100
     a + 1
   end
 end
-  
+
 # rspec:
 it 'fails when the input is out of bounds' do
   result = MyAction.call(a: 1000)
-  
+
   expect(result).to be_failed
   expect(result.failure).to eq '1000 is greater than 100!'
 end
@@ -208,11 +283,11 @@ end
 ### Stubbing Responses
 
 When unit testing, it may be necessary to stub the responses of Verbalize actions.  To correctly stub responses,
-you should __always__ stub the `MyAction.perform` class method on the action class being stubbed per the 
+you should __always__ stub the `MyAction.perform` class method on the action class being stubbed per the
 instructions below.  __Never__ stub the `call` or `call!` methods directly.
 
 Stubbing `.perform` will enable `Verbalize` to wrap results correctly for references to either `call` or `call!`.
- 
+
 #### Stubbing Successful Responses
 
 To simulate a successful response of the `Verbalize::Action` being stubbed, you should stub the `MyAction.perform`
@@ -225,7 +300,7 @@ class Foo
   def self.multiply_by(multiple)
     result = MyAction.call(a: 1)
     raise "I couldn't do the thing!" if result.failure?
-    
+
     result.value * multiple
   end
 end
@@ -238,9 +313,9 @@ describe Foo do
       allow(MyAction).to receive(:perform)
         .with(a: 1)
         .and_return(123)
-      
+
       result = described_class.multiply_by(100)
-      
+
       expect(result).to eq 12300
     end
   end
@@ -266,7 +341,7 @@ describe Foo do
       allow(MyAction).to receive(:perform)
         .with(a: 1)
         .and_throw(::Verbalize::THROWN_SYMBOL, 'Y U NO!')
-      
+
       expect {
         described_class.multiply_by(100)
       }.to raise_error "I couldn't do the thing!"
@@ -297,6 +372,13 @@ After checking out the repo, run `bin/setup` to install dependencies. Then, run
 
 To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
+## Releasing
+
+- Update CHANGELOG.md, and lib/verbalize/version.rb, commit, and push
+- [Create a new release on github](https://github.com/taylorzr/verbalize/releases/new)
+- Build the gem version: `gem build verbalize.gemspec`
+- Push the gem version to rubygems: `gem push verbalize-<VERSION>.gem`
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/taylorzr/verbalize.
@@ -305,4 +387,3 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/taylor
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-

data/bin/console

@@ -6,9 +6,5 @@ require 'verbalize'
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
 
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require 'irb'
-IRB.start
+require 'pry'
+Pry.start

data/docker-compose.yml

@@ -0,0 +1,12 @@
+version: '3.7'
+
+services:
+  ruby:
+    build:
+      context: .
+      dockerfile: Dockerfile
+      target: development
+    command: bundle exec rspec
+    volumes:
+      - .:/gem
+

data/lib/verbalize/action.rb

@@ -11,13 +11,64 @@ module Verbalize
       throw(THROWN_SYMBOL, failure_value)
     end
 
+    def action_inputs
+      self.class.inputs.map { |i| [i, self.send(i)] }.to_h
+    end
+
     def self.included(target)
       target.extend ClassMethods
     end
 
+    private
+
+    def __setup(key, value)
+      is_valid = self.class.input_is_valid?(key, value)
+      local_error = self.class.pop_local_error
+      fail!(local_error) if !is_valid && local_error
+      fail! "Input '#{key}' failed validation!" unless is_valid
+
+      instance_variable_set(:"@#{key}", value)
+    end
+
     module ClassMethods
-      def input(*required_keywords, optional: [])
-        class_eval Build.call(required_keywords, Array(optional))
+      def required_inputs
+        @required_inputs || []
+      end
+
+      def optional_inputs
+        @optional_inputs || []
+      end
+
+      def default_inputs
+        (@defaults || {}).keys
+      end
+
+      def inputs
+        required_inputs + optional_inputs + default_inputs
+      end
+
+      def defaults
+        @defaults
+      end
+
+      def input_validations
+        @input_validations ||= {}
+      end
+
+      def input_is_valid?(input, value)
+        return true unless input_validations.include?(input.to_sym)
+
+        input_validations[input].call(value) == true
+      rescue => e
+        @local_error = e
+        false
+      end
+
+      def pop_local_error
+        return nil unless @local_error
+        @local_error
+      ensure
+        @local_error = nil
       end
 
       # Because call/call! are defined when Action.input is called, they would
@@ -30,35 +81,81 @@ module Verbalize
       def call!
         __proxied_call!
       end
+      alias_method :!, :call!
 
       private
 
-      def perform(*args)
-        new(*args).send(:call)
+      def input(*required_keywords, optional: [])
+        @required_inputs = required_keywords
+        optional = Array(optional)
+        @optional_inputs = optional.reject { |kw| kw.is_a?(Hash) }
+        assign_defaults(optional)
+
+        class_eval Build.call(required_inputs, optional_inputs, default_inputs)
       end
 
-      # We used __proxied_call/__proxied_call! for 2 reasons:
-      #   1. The declaration of call/call! needs to be explicit so that tools
-      #      like rspec-mocks can verify the actions keywords actually
-      #      exist when stubbing
-      #   2. Because #1, meta-programming a simple interface to these proxied
-      #      methods is much simpler than meta-programming the full methods
-      def __proxied_call(*args)
-        error = catch(:verbalize_error) do
-          value = perform(*args)
-          return Success.new(value)
-        end
+      def validate(keyword, &block)
+        raise Verbalize::Error, 'Missing block to validate against!' unless block_given?
+        input_validations[keyword.to_sym] = block
+      end
 
-        Failure.new(error)
+      def assign_defaults(optional)
+        @defaults = optional.select { |kw| kw.is_a?(Hash) }.reduce(&:merge)
+        @defaults = (@defaults || {})
+                    .map { |k, v| [k, v.respond_to?(:call) ? v : -> { v }] }
+                    .to_h
       end
 
-      def __proxied_call!(*args)
-        perform(*args)
-      rescue UncaughtThrowError => uncaught_throw_error
-        fail_value = uncaught_throw_error.value
-        error = Verbalize::Error.new("Unhandled fail! called with: #{fail_value.inspect}.")
-        error.set_backtrace(uncaught_throw_error.backtrace[2..-1])
-        raise error
+      if RUBY_VERSION < "2.7"
+        def perform(*args)
+          new(*args).send(:call)
+        end
+
+        def __proxied_call(*args)
+          error = catch(:verbalize_error) do
+            value = perform(*args)
+            return Success.new(value)
+          end
+
+          Failure.new(error)
+        end
+
+        def __proxied_call!(*args)
+          perform(*args)
+        rescue UncaughtThrowError => uncaught_throw_error
+          fail_value = uncaught_throw_error.value
+          error = Verbalize::Error.new("Unhandled fail! called with: #{fail_value.inspect}.")
+          error.set_backtrace(uncaught_throw_error.backtrace[2..-1])
+          raise error
+        end
+      else
+        def perform(**args)
+          new(**args).send(:call)
+        end
+
+        # We used __proxied_call/__proxied_call! for 2 reasons:
+        #   1. The declaration of call/call! needs to be explicit so that tools
+        #      like rspec-mocks can verify the actions keywords actually
+        #      exist when stubbing
+        #   2. Because #1, meta-programming a simple interface to these proxied
+        #      methods is much simpler than meta-programming the full methods
+        def __proxied_call(**args)
+          error = catch(:verbalize_error) do
+            value = perform(**args)
+            return Success.new(value)
+          end
+
+          Failure.new(error)
+        end
+
+        def __proxied_call!(**args)
+          perform(**args)
+        rescue UncaughtThrowError => uncaught_throw_error
+          fail_value = uncaught_throw_error.value
+          error = Verbalize::Error.new("Unhandled fail! called with: #{fail_value.inspect}.")
+          error.set_backtrace(uncaught_throw_error.backtrace[2..-1])
+          raise error
+        end
       end
     end
   end

data/lib/verbalize/build.rb

@@ -1,22 +1,28 @@
 module Verbalize
   class Build
-    def self.call(required_keywords = [], optional_keywords = [])
-      new(required_keywords, optional_keywords).call
+    def self.call(required_keywords = [], optional_keywords = [], default_keywords = [])
+      new(required_keywords, optional_keywords, default_keywords).call
     end
 
-    def initialize(required_keywords, optional_keywords)
+    def initialize(required_keywords, optional_keywords, default_keywords)
       @required_keywords = required_keywords
       @optional_keywords = optional_keywords
+      @default_keywords  = default_keywords
     end
 
     def call
+      # We have to re-alias `!` to `call!` here, otherwise it will be pointing
+      # to the original `call!` method
       <<-CODE
-def self.call(#{declaration_arguments_string})
-  __proxied_call(#{forwarding_arguments_string})
-end
+class << self
+  def call(#{declaration_arguments_string})
+    __proxied_call(#{forwarding_arguments_string})
+  end
 
-def self.call!(#{declaration_arguments_string})
-  __proxied_call!(#{forwarding_arguments_string})
+  def call!(#{declaration_arguments_string})
+    __proxied_call!(#{forwarding_arguments_string})
+  end
+  alias_method :!, :call!
 end
 
 def initialize(#{declaration_arguments_string})
@@ -29,18 +35,19 @@ attr_reader #{attribute_readers_string}
       CODE
     end
 
-    attr_reader :required_keywords, :optional_keywords
+    attr_reader :required_keywords, :optional_keywords, :default_keywords
 
     private
 
     def all_keywords
-      required_keywords + optional_keywords
+      required_keywords + optional_keywords + default_keywords
     end
 
     def declaration_arguments_string
-      required_segments = required_keywords.map { |keyword| "#{keyword}:" }
-      optional_segments = optional_keywords.map { |keyword| "#{keyword}: nil" }
-      (required_segments + optional_segments).join(', ')
+      required_segments  = required_keywords.map { |kw| "#{kw}:" }
+      optional_segments  = optional_keywords.map { |kw| "#{kw}: nil" }
+      default_segments   = default_keywords.map  { |kw| "#{kw}: self.defaults[:#{kw}].call" }
+      (required_segments + optional_segments + default_segments).join(', ')
     end
 
     def forwarding_arguments_string
@@ -48,7 +55,9 @@ attr_reader #{attribute_readers_string}
     end
 
     def initialize_body
-      all_keywords.map { |keyword| "@#{keyword} = #{keyword}" }.join("\n  ")
+      all_keywords.map do |keyword|
+        "__setup(:#{keyword}, #{keyword})"
+      end.join("\n  ")
     end
 
     def attribute_readers_string

data/lib/verbalize/version.rb

@@ -1,3 +1,3 @@
 module Verbalize
-  VERSION = '2.0.1'.freeze
+  VERSION = '2.3.1'.freeze
 end

data/verbalize.gemspec

@@ -21,9 +21,9 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_development_dependency 'bundler'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec'
   spec.add_development_dependency 'coveralls'
-  spec.add_development_dependency 'rubocop', '0.45'
+  spec.add_development_dependency 'rubocop'
   spec.add_development_dependency 'pry'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: verbalize
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.3.1
 platform: ruby
 authors:
 - Zach Taylor
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2016-12-16 00:00:00.000000000 Z
+date: 2021-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -28,16 +28,16 @@ dependencies:
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -70,16 +70,16 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.45'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.45'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -94,7 +94,7 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: 
+description:
 email:
 - taylorzr@gmail.com
 executables: []
@@ -102,17 +102,20 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".codeclimate.yml"
+- ".github/dependabot.yml"
+- ".github/workflows/tests.yml"
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
-- ".travis.yml"
+- CHANGELOG.md
+- Dockerfile
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
 - bin/console
 - bin/setup
-- circle.yml
+- docker-compose.yml
 - lib/verbalize.rb
 - lib/verbalize/action.rb
 - lib/verbalize/build.rb
@@ -126,7 +129,7 @@ homepage: https://github.com/taylorzr/verbalize
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -141,9 +144,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.8
-signing_key: 
+rubygems_version: 3.0.3
+signing_key:
 specification_version: 4
 summary: Verb based class pattern
 test_files: []

data/.travis.yml

@@ -1,4 +0,0 @@
-language: ruby
-rvm:
-  - 2.2.2
-before_install: gem install bundler -v 1.10.6

data/circle.yml

@@ -1,3 +0,0 @@
-machine:
-  ruby:
-    version: '2.2'