mime_actor 0.6.3.alpha → 0.6.4.alpha

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5221de8b1d1149a88de730ab8e6c6c764a22e7067b9e57b6265ce801c671ce3f
-  data.tar.gz: e98f9d6f3e5a8aa04f16cf77921edad0b4a61893ddb3c019157885079462fcde
+  metadata.gz: 42ba1c04632b3b7ec4c1f1d9c1ab60571eac9e4c44272601d28dccbb45b535d0
+  data.tar.gz: 4d0ccbdba192617231ae0405580921e337412d3de9f63106ff772d33ab0d4208
 SHA512:
-  metadata.gz: 9f6ce7e70ab30a4be726f346beb517c8036c95a1d516c3012d9ed62723a14c130d4af05cdf3695244f5fcb56d33f83cf719369ead9d05eabeba89e5335de1f3a
-  data.tar.gz: 90e8ca69ac9ff99e9813c1dac19bc0826893f106968bb6c6684201a84523b13ab9df225fd597daf96379825080f9164ecfb19a6f7b48c8eabf217e5411654530
+  metadata.gz: e8fa8dc7c8d8438a1dff0a7bed147f0603000e7491b2e3e8a70173acd9d71f65628390cc7778d50de084940aaafd56684a347b59da5a872ce485361398d0743d
+  data.tar.gz: 3c87a2ce45ec35aa56786e4fd625a3b689a27aba728d7207c5b3c0cf893afb936c5f944d0408d5ca0149267f46902c7c27ff65845397c9ddccfff12d55233a48

data/COMPARE.md

@@ -1,6 +1,57 @@
 ## Comparison in Rails
 
-### MIME Rendering
+When some actions render more than a single MIME type with error handling sfor different MIME type.
+```rb
+class EventsController < ActionController::Base
+  def show
+    respond_to do |format|
+      format.html { render "show" }
+      format.json { render_event_json }
+      format.pdf { render_event_pdf }
+    end
+  end
+
+  def create
+    respond_to do |format|
+      format.html do
+        create_event ? redirect_to "/events/#{@event.id}" : render "create"
+      end
+      format.json do
+        create_event!
+        render_event_json
+      rescue StandardError => error
+        render status: :bad_request, json: { error: error.message }
+      end
+    end
+  end
+
+  def update
+    # this will be executed regardless of the requested format.
+    # e.g. requesting for xml will execute #update_event but responded with :not_acceptable http status
+    success = update_event
+
+    respond_to do |format|
+      format.html { success ? redirect_to "/events/#{@event.id}" : render "update" }
+      format.json { render_event_json }
+    end
+  end
+
+  def render_event_json
+    render json: @event
+  rescue StandardError => e
+    render json: { error: e.message }
+  end
+
+  def render_event_pdf
+    # ...
+    # render pdf view or call pdf library with options
+  rescue StandardError
+    # render error page / redirect to 404 page
+  end
+end
+```
+
+### With MIME Action
 
 #### before
 ```rb
@@ -22,103 +73,104 @@ end
 #### after
 ```rb
 class EventsController < ActionController::Base
-    include MimeActor::Action
+  include MimeActor::Action
 
-    before_action only: :index { @events = Event.all }
+  before_act -> { @events = Event.all }, action: :index
 
-    # dynamically defines the action method according to on: argument
-    respond_act_to :html, :json, on: :index 
+  # dynamically defines the action method according to on: argument
+  respond_act_to :html, :json, on: :index
 
-    def index_html
-        @event_categories = EventCategory.all
-        
-        # render html using @events and @event_categories
-        render :index
-    end
+  def index_html
+      @event_categories = EventCategory.all
+      
+      # render html using @events and @event_categories
+      render :index
+  end
 
-    def index_json
-        # render json using #as_json
-        render json: @events
-    end
+  def index_json
+      # render json using #as_json
+      render json: @events
+  end
 end
 ```
 
-### MIME Rescuing
+### With MIME Rescue
 
 #### before
 ```rb
 class EventsController < ActionController::Base
-    # AbstractController::Callbacks here to load model with params
-    before_action only: [:show, :update] { @event = Event.find(params.require(:event_id)) }
-
-    rescue_from ActiveRecord::RecordNotFound do |ex|
-        case action_name.to_s
-        when "show"
-            respond_to do |format|
-                format.html { redirect_to events_path } # redirect to index
-                format.json { render status: :bad_request, json: { error: ex.message } }
-            end
-        when "update"
-            respond_to do |format|
-                format.html { render :edit }
-                format.json { render status: :bad_request, json: { error: ex.message } }
-            end
-        else
-            raise ex # re-raise since we are not handling it
-        end
+  before_action :load_event, action: %i[show update]
+
+  rescue_from ActiveRecord::RecordNotFound do |ex|
+    case action_name.to_s
+    when "show"
+      respond_to do |format|
+        format.html { redirect_to events_path } # redirect to index
+        format.json { render status: :bad_request, json: { error: ex.message } }
+      end
+    when "update"
+      respond_to do |format|
+        format.html { render :edit }
+        format.json { render status: :bad_request, json: { error: ex.message } }
+      end
+    else
+      raise ex # re-raise since we are not handling it
     end
+  end
 
-    def show
-        respond_to do |format|
-            format.html { render :show } # render html using @event
-            format.json { render json: @event } # render json using #as_json
-        end
+  def show
+    respond_to do |format|
+      format.html { render :show } # render html using @event
+      format.json { render json: @event } # render json using #as_json
     end
+  end
 
-    def update
-        # ...
-        respond_to do |format|
-            format.html { redirect_to event_path(@event.id)  } # redirect to show upon sucessful update
-            format.json { render json: @event } # render json using #as_json
-        end
+  def update
+    # ...
+    respond_to do |format|
+      format.html { redirect_to event_path(@event.id) } # redirect to show upon sucessful update
+      format.json { render json: @event } # render json using #as_json
     end
+  end
+
+  private
+
+  def load_event
+    @event = Event.find(params.require(:event_id))
+  end
 end
 ```
 #### after
 ```rb
 class EventsController < ActionController::Base
-    include MimeActor::Action
+  include MimeActor::Action
 
-    # AbstractController::Callbacks here to load model with params
-    before_action only: [:show, :update] { @event = Event.find(params.require(:event_id)) }
+  before_act :load_event, action: %i[show update]
 
-    respond_act_to :html, :json, on: [:show, :update]
+  respond_act_to :html, on: %i[show update]
+  respond_act_to :json, on: %i[show update], with: -> { render json: @event } # render json using #as_json
 
-    rescue_act_from ActiveRecord::RecordNotFound, format: :json do |ex|
-        render status: :bad_request, json: { error: ex.message }
-    end
+  rescue_act_from ActiveRecord::RecordNotFound, format: :json, with: :handle_json_error
 
-    rescue_act_from ActiveRecord::RecordNotFound, format: :html, action: :show do |ex|
-        redirect_to events_path
-    end
+  rescue_act_from ActiveRecord::RecordNotFound, format: :html, action: :show do
+    redirect_to events_path
+  end
 
-    def show_html
-        render :show # render html using @event
-    end
+  private
+  
+  def show_html
+    render :show # render html using @event
+  end
 
-    def update_html
-        redirect_to event_path(@event.id) # redirect to show upon sucessful update
-    rescue ActiveRecord::RecordNotFound
-        render :edit
-    end
+  def update_html
+    # ...
+    redirect_to event_path(@event.id) # redirect to show upon sucessful update
+  rescue ActiveRecord::RecordNotFound
+    render :edit
+  end
 
-    def show_json
-        render json: @event # render json using #as_json
-    end
-
-    def update_json
-        # ...
-        render json: @event # render json using #as_json
-    end
+  def handle_json_error(error)
+    render status: :bad_request, json: { error: error.message }
+  end
 end
 ```

data/README.md

@@ -1,64 +1,77 @@
-# mime_actor
+# Mime Actor
 
 [![Version][rubygems_badge]][rubygems]
 [![CI][ci_badge]][ci_workflows]
 [![Coverage][coverage_badge]][coverage]
 [![Maintainability][maintainability_badge]][maintainability]
 
-Action Render + Rescue handlers for different MIME types in Rails
+Action processing with Callback + Rescue handlers for different MIME types in Rails.
+
+In most of the Rails apps, a single `ActionController` is only responsible for rendering a single MIME type. That is usually done by calling `ActionController#respond_to` for each action in the controller.
+
+```rb
+class EventsController < ActionController::Base
+  def index
+    @events = Event.all
+    respond_to :json
+  end
+
+  def show
+    respond_to do |format|
+      format.json { render json: @event }
+    end
+  end
+end
+```
+
+However, it can be a litte bit messy when some actions render more than a single MIME type with error handling for different MIME type. See [comparison][doc_comparison] to understand more.
 
 ## Usage
 
-MimeActor allows you to do something like below:
+**Mime Actor** allows you to do something like:
 ```rb
 class EventsController < ActionController::Base
-    # AbstractController::Callbacks here to load model with params
-    before_action only: :index { @events = Event.all }
-    before_action only: [:show, :update] { @event = Event.find(params.require(:event_id)) }
+  include MimeActor::Action
 
-    respond_act_to :html, :json, on: :index
-    respond_act_to :html, :json, on: [:show, :update]
+  before_act -> { @events = Event.all }, action: :index
+  before_act :load_event, action: %i[show update]
+  before_act -> { @event_categories = EventCategory.all }, action: :show, format: :html
 
-    rescue_act_from ActiveRecord::RecordNotFound, format: :json do |ex|
-        render status: :bad_request, json: { error: "Resouce not found" }
-    end
+  respond_act_to :html, :json, on: :update
+  respond_act_to :html, on: %i[index show], with: :render_html
+  respond_act_to :json, on: %i[index show], with: -> { render json: { action: action_name } }
 
-    rescue_act_from ActiveRecord::RecordNotFound, format: :html, action: :show do |ex|
-        redirect_to events_path
-    end
+  rescue_act_from ActiveRecord::RecordNotFound, format: :json, with: :handle_json_error
+  rescue_act_from ActiveRecord::RecordNotFound, format: :html, action: :show, with: -> { redirect_to "/events" }
 
-    def index_html
-        @event_categories = EventCategory.all
-        render :index # render html using @events and @event_categories
-    end
+  private
 
-    def index_json
-        render json: @events # render json using #as_json
-    end
+  def update_html
+    # ...
+    redirect_to "/events/#{@event.id}" # redirect to show upon sucessful update
+  rescue ActiveRecord::RecordNotFound
+    render html: :edit
+  end
 
-    def show_html
-        render :show # render html using @event
-    end
+  def update_json
+    # ...
+    render json: @event # render with #to_json
+  end
 
-    def update_html
-        redirect_to event_path(@event.id) # redirect to show upon sucessful update
-    rescue ActiveRecord::RecordNotFound
-        render :edit
-    end
+  def render_html
+    render html: action_name
+  end
 
-    def show_json
-        render json: @event # render json using #as_json
-    end
+  def load_event
+    @event = Event.find(params.require(:event_id))
+  end
 
-    def update_json
-        # ...
-        render json: @event # render json using #as_json
-    end
+  def handle_json_error(error)
+    render status: :bad_request, json: { error: error.message }
+  end
 end
 ```
 
-Seems useful? See the [Comparison][doc_comparison] on how it can improve your existing code
-
 ## Features
 
 - Action customisation for [ActionController][doc_action_controller] per MIME type

data/lib/mime_actor/action.rb

@@ -2,12 +2,12 @@
 
 # :markup: markdown
 
-require "mime_actor/callbacks"
 require "mime_actor/logging"
 require "mime_actor/scene"
 require "mime_actor/stage"
 
 require "active_support/concern"
+require "active_support/core_ext/module/attribute_accessors"
 require "active_support/core_ext/object/blank"
 require "active_support/lazy_load_hooks"
 require "abstract_controller/rendering"
@@ -18,7 +18,7 @@ module MimeActor
   #
   # `Action` is the recommended `Module` to be included in the `ActionController`.
   #
-  # Provides intuitive way of `action` rendering for a specific MIME type with rescue handlers.
+  # Provides intuitive way of `action` processing for a specific MIME type with callback + rescue handlers.
   #
   module Action
     extend ActiveSupport::Concern
@@ -26,17 +26,19 @@ module MimeActor
     include AbstractController::Rendering # required by MimeResponds
     include ActionController::MimeResponds
 
-    include Callbacks
     include Scene
     include Stage
     include Logging
 
+    included do
+      mattr_accessor :actor_delegator, instance_writer: false, default: ->(action, format) { "#{action}_#{format}" }
+    end
+
     # The core logic where rendering logics are collected as `Proc` and passed over to `ActionController::MimeResponds`
     #
-    # @param action the `action` of the controller
-    #
     # @example process `create` action
-    #   start_scene(:create)
+    #   # it uses AbstractController#action_name to process
+    #   start_scene
     #
     #   # it is equivalent to the following if `create` action is configured with `html` and `json` formats
     #   def create
@@ -46,21 +48,19 @@ module MimeActor
     #     end
     #   end
     #
-    def start_scene(action)
+    def start_scene
+      action = action_name.to_sym
       formats = acting_scenes.fetch(action, {})
 
       if formats.empty?
-        logger.warn { "format is empty for action: #{action.inspect}" }
+        logger.warn { "format is empty for action: #{action_name.inspect}" }
         return
       end
 
       respond_to do |collector|
         formats.each do |format, actor|
-          dispatch = lambda do
-            run_act_callbacks(format) do
-              cue_actor(actor.presence || "#{action}_#{format}", action:, format:)
-            end
-          end
+          callable = actor.presence || actor_delegator.call(action, format)
+          dispatch = -> { cue_actor(callable, format:) }
           collector.public_send(format, &dispatch)
         end
       end

data/lib/mime_actor/deprecator.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+require "active_support/deprecation"
+
+module MimeActor
+  def self.deprecator
+    @deprecator ||= ActiveSupport::Deprecation.new("0.7.0", "MimeActor")
+  end
+end
+
+[
+  [MimeActor::Rescue::ClassMethods, { rescue_actor: "use #rescue_actor instance method" }],
+  [MimeActor::Scene::ClassMethods, { act_on_format: :respond_act_to }],
+  [MimeActor::Stage::ClassMethods, { actor?: "no longer supported, use Object#respond_to?" }],
+  [MimeActor::Stage::ClassMethods, { dispatch_cue: "no longer support anonymous proc with rescue" }],
+  [MimeActor::Stage::ClassMethods, { dispatch_act: "no longer support anonymous proc with rescue" }]
+].each do |klazz, *args|
+  MimeActor.deprecator.deprecate_methods(klazz, *args)
+end

data/lib/mime_actor/dispatcher.rb

@@ -16,7 +16,7 @@ module MimeActor
       end
 
       def call(target)
-        raise MimeActor::ActorNotFound, method_name unless target.respond_to?(method_name)
+        raise MimeActor::ActorNotFound, method_name unless target.respond_to?(method_name, true)
 
         method_call = target.method(method_name)
         filtered_args = method_call.arity.negative? ? args : args.take(method_call.arity)

data/lib/mime_actor/railtie.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module MimeActor
+  class Railtie < Rails::Railtie
+    initializer "mime_actor.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:mime_actor] = MimeActor.deprecator
+    end
+  end
+end

data/lib/mime_actor/rescue.rb

@@ -47,9 +47,9 @@ module MimeActor
       #
       def rescue_act_from(*klazzes, action: nil, format: nil, with: nil, &block)
         raise ArgumentError, "error filter is required" if klazzes.empty?
-        raise ArgumentError, "provide either the with: argument or a block" unless with.present? ^ block_given?
+        raise ArgumentError, "provide either with: or a block" unless with.present? ^ block_given?
 
-        validate!(:with, with) if with.present?
+        validate!(:callable, with) if with.present?
         with = block if block_given?
 
         validate!(:action_or_actions, action) if action.present?

data/lib/mime_actor/scene.rb

@@ -84,9 +84,9 @@ module MimeActor
       def respond_act_to(*formats, on: nil, with: nil, &block)
         validate!(:formats, formats)
 
-        raise ArgumentError, "provide either the with: argument or a block" if with.present? && block_given?
+        raise ArgumentError, "provide either with: or a block" if with.present? && block_given?
 
-        validate!(:with, with) if with.present?
+        validate!(:callable, with) if with.present?
         with = block if block_given?
 
         raise ArgumentError, "action is required" unless (actions = on).present?
@@ -116,11 +116,11 @@ module MimeActor
       def define_scene(action)
         module_eval(
           # def index
-          #   self.respond_to?(:start_scene) && self.start_scene(:index)
+          #   self.respond_to?(:start_scene) && self.start_scene
           # end
           <<-RUBY, __FILE__, __LINE__ + 1
             def #{action}
-              self.respond_to?(:start_scene) && self.start_scene(:#{action})
+              self.respond_to?(:start_scene) && self.start_scene
             end
           RUBY
         )

data/lib/mime_actor/stage.rb

@@ -2,6 +2,7 @@
 
 # :markup: markdown
 
+require "mime_actor/callbacks"
 require "mime_actor/dispatcher"
 require "mime_actor/logging"
 require "mime_actor/rescue"
@@ -17,6 +18,7 @@ module MimeActor
   module Stage
     extend ActiveSupport::Concern
 
+    include Callbacks
     include Rescue
     include Logging
 
@@ -76,21 +78,21 @@ module MimeActor
     # @param actor either a method name or a Proc to evaluate
     # @param args arguments to be passed when calling the actor
     #
-    def cue_actor(actor, *args, action:, format:)
+    def cue_actor(actor, *args, format:)
       dispatcher = MimeActor::Dispatcher.build(actor, *args)
       raise TypeError, "invalid actor, got: #{actor.inspect}" unless dispatcher
 
-      result = dispatcher.call(self)
-      if block_given?
-        yield result
-      else
-        result
+      self.class.validate!(:format, format)
+
+      run_act_callbacks(format) do
+        result = dispatcher.call(self)
+        block_given? ? yield(result) : result
       end
     rescue MimeActor::ActorNotFound => e
       logger.error { "actor error, cause: #{e.inspect}" } unless raise_on_actor_error
       raise e if raise_on_actor_error
     rescue StandardError => e
-      rescued = rescue_actor(e, action:, format:)
+      rescued = rescue_actor(e, action: action_name.to_sym, format: format)
       rescued || raise
     end
   end

data/lib/mime_actor/validator.rb

@@ -96,13 +96,13 @@ module MimeActor
         TypeError.new("#{unchecked.inspect} must be a Class/Module or a String referencing a Class/Module")
       end
 
-      # Validate `with` must be a Symbol or Proc
+      # Validate `callable` must be a Symbol or Proc
       #
-      # @param unchecked the `with` to be validated
-      def validate_with(unchecked)
+      # @param unchecked the `callable` to be validated
+      def validate_callable(unchecked)
         return if unchecked.is_a?(Proc) || unchecked.is_a?(Symbol)
 
-        TypeError.new("with handler must be a Symbol or Proc, got: #{unchecked.inspect}")
+        TypeError.new("#{unchecked.inspect} must be a Symbol or Proc")
       end
     end
   end

data/lib/mime_actor/version.rb

@@ -14,7 +14,7 @@ module MimeActor
   module VERSION
     MAJOR = 0
     MINOR = 6
-    BUILD = 3
+    BUILD = 4
     PRE   = "alpha"
 
     STRING = [MAJOR, MINOR, BUILD, PRE].compact.join(".")

data/lib/mime_actor.rb

@@ -6,30 +6,21 @@
 require "mime_actor/version"
 require "mime_actor/errors"
 
-require "active_support/dependencies/autoload"
-require "active_support/deprecation"
+# load mime_actor components
+require "mime_actor/action"
+require "mime_actor/callbacks"
+require "mime_actor/logging"
+require "mime_actor/rescue"
+require "mime_actor/scene"
+require "mime_actor/stage"
+require "mime_actor/validator"
 
-module MimeActor
-  extend ActiveSupport::Autoload
+require "mime_actor/deprecator"
 
-  autoload :Action
-  autoload :Scene
-  autoload :Stage
-  autoload :Rescue
-  autoload :Validator
-  autoload :Logging
-
-  def self.deprecator
-    @deprecator ||= ActiveSupport::Deprecation.new("0.7.0", "MimeActor")
-  end
-
-  [
-    [MimeActor::Rescue::ClassMethods, { rescue_actor: "use #rescue_actor instance method" }],
-    [MimeActor::Scene::ClassMethods, { act_on_format: :respond_act_to }],
-    [MimeActor::Stage::ClassMethods, { actor?: "no longer supported, use Object#respond_to?" }],
-    [MimeActor::Stage::ClassMethods, { dispatch_cue: "no longer support anonymous proc with rescue" }],
-    [MimeActor::Stage::ClassMethods, { dispatch_act: "no longer support anonymous proc with rescue" }]
-  ].each do |klazz, *args|
-    deprecator.deprecate_methods(klazz, *args)
-  end
+begin
+  require "rails"
+rescue LoadError
+  # noop
 end
+
+require "mime_actor/railtie" if defined?(Rails::Railtie)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mime_actor
 version: !ruby/object:Gem::Version
-  version: 0.6.3.alpha
+  version: 0.6.4.alpha
 platform: ruby
 authors:
 - Ryan Chang
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-07-23 00:00:00.000000000 Z
+date: 2024-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -59,22 +59,17 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".hound.yml"
-- ".rspec"
-- ".rubocop.yml"
-- ".ruby-version"
-- ".yardopts"
 - COMPARE.md
 - LICENSE
 - README.md
-- Rakefile
-- codecov.yml
 - lib/mime_actor.rb
 - lib/mime_actor/action.rb
 - lib/mime_actor/callbacks.rb
+- lib/mime_actor/deprecator.rb
 - lib/mime_actor/dispatcher.rb
 - lib/mime_actor/errors.rb
 - lib/mime_actor/logging.rb
+- lib/mime_actor/railtie.rb
 - lib/mime_actor/rescue.rb
 - lib/mime_actor/scene.rb
 - lib/mime_actor/stage.rb
@@ -108,5 +103,6 @@ requirements: []
 rubygems_version: 3.5.9
 signing_key: 
 specification_version: 4
-summary: Action Render + Rescue handlers for different MIME types in Rails
+summary: Action processing with Callback + Rescue handlers for different MIME types
+  in Rails
 test_files: []

data/.hound.yml

@@ -1,2 +0,0 @@
-rubocop:
-  enabled: false

data/.rspec

@@ -1 +0,0 @@
---require spec_helper

data/.rubocop.yml

@@ -1,66 +0,0 @@
-require:
-  - rubocop-rake
-  - rubocop-rspec
-
-AllCops:
-  TargetRubyVersion: 3.1
-  NewCops: enable
-  Exclude:
-    - bin/*
-    - vendor/**/*
-
-Style/Documentation:
-  Enabled: false
-
-Style/BlockComments:
-  Exclude:
-    - spec/*_helper.rb
-
-Style/RegexpLiteral:
-  EnforcedStyle: percent_r
-
-Metrics/AbcSize:
-  Enabled: false
-  
-Metrics/BlockLength:
-  AllowedMethods:
-    - class_methods
-
-Metrics/CyclomaticComplexity:
-  Enabled: false
-
-Metrics/PerceivedComplexity:
-  Enabled: false
-
-Metrics/MethodLength:
-  CountAsOne: ['array', 'heredoc', 'method_call']
-  Max: 15
-
-Style/StringLiterals:
-  EnforcedStyle: double_quotes
-
-Style/StringLiteralsInInterpolation:
-  EnforcedStyle: double_quotes
-
-Style/HashSyntax:
-  EnforcedShorthandSyntax: consistent
-
-Layout/FirstHashElementIndentation:
-  EnforcedStyle: consistent
-
-Layout/HashAlignment:
-  EnforcedHashRocketStyle: table
-  EnforcedColonStyle: table
-
-RSpec/MultipleExpectations:
-  Max: 6
-
-RSpec/ExampleLength:
-  CountAsOne: ['array', 'heredoc', 'method_call']
-  Max: 10
-
-RSpec/MultipleMemoizedHelpers:
-  Max: 10
-
-RSpec/NestedGroups:
-  Max: 5

data/.ruby-version

@@ -1 +0,0 @@
-3.3.1

data/.yardopts

@@ -1,2 +0,0 @@
---markup markdown
-lib/**/*.rb

data/Rakefile

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require "bundler/gem_tasks"
-
-require "rubocop/rake_task"
-RuboCop::RakeTask.new
-
-require "rspec/core/rake_task"
-RSpec::Core::RakeTask.new(:spec)

data/codecov.yml

@@ -1,18 +0,0 @@
-codecov:
-  notify:
-    wait_for_ci: false
-  require_ci_to_pass: false
-
-coverage:
-  status:
-    project:
-      default:
-        target: 99%
-        threshold: 1%
-    patch:
-      default:
-        target: 99%
-        threshold: 1%
-
-comment:
-  require_changes: true