convenient_service 0.16.0 → 0.18.0

data/lib/convenient_service/common/plugins.rb

@@ -9,11 +9,13 @@ require_relative "plugins/caches_constructor_arguments"
 require_relative "plugins/caches_return_value"
 require_relative "plugins/can_be_copied"
 require_relative "plugins/can_have_user_provided_entity"
+require_relative "plugins/ensures_negated_j_send_result"
 require_relative "plugins/has_callbacks"
 require_relative "plugins/has_around_callbacks"
 require_relative "plugins/has_constructor"
 require_relative "plugins/has_constructor_without_initialize"
 require_relative "plugins/has_internals"
+require_relative "plugins/has_instance_proxy"
 require_relative "plugins/has_j_send_result_duck_short_syntax"
 
 require_relative "plugins/aliases"

data/lib/convenient_service/core/concern/class_methods.rb

@@ -70,6 +70,7 @@ module ConvenientService
 
         ##
         # @see https://thoughtbot.com/blog/always-define-respond-to-missing-when-overriding
+        # @see https://blog.marc-andre.ca/2010/11/15/methodmissing-politely
         # @see https://stackoverflow.com/a/3304683/12201472
         #
         # @param method_name [Symbol, String]
@@ -112,12 +113,16 @@ module ConvenientService
         #
         #   TODO: Include `method` into trigger metadata.
         #
+        #   IMPORTANT: Ruby 2.7 and Ruby 3.0+ invoke this `method_missing` differently, check the following files/links:
+        #   - `lib/convenient_service/core/entities/config/entities/method_middlewares/entities/caller/commands/define_method_middlewares_caller.rb`
+        #   - https://gist.github.com/marian13/9c25041f835564e945d978839097d419
+        #
         def method_missing(method, *args, **kwargs, &block)
           commit_config!(trigger: Constants::Triggers::CLASS_METHOD_MISSING)
 
-          return super unless Utils::Module.class_method_defined?(self, method, public: true, protected: false, private: false)
+          return ::ConvenientService.reraise { super } unless Utils::Module.class_method_defined?(self, method, public: true, protected: false, private: false)
 
-          return super if middlewares(method, scope: :class).defined_without_super_method?
+          return ::ConvenientService.reraise { super } if middlewares(method, scope: :class).defined_without_super_method?
 
           ConvenientService.logger.debug { "[Core] Committed config for `#{self}` | Triggered by `method_missing` | Method: `.#{method}`" }
 

data/lib/convenient_service/core/concern/instance_methods.rb

@@ -17,6 +17,7 @@ module ConvenientService
 
         ##
         # @see https://thoughtbot.com/blog/always-define-respond-to-missing-when-overriding
+        # @see https://blog.marc-andre.ca/2010/11/15/methodmissing-politely
         # @see https://stackoverflow.com/a/3304683/12201472
         #
         # @param method_name [Symbol, String]
@@ -59,12 +60,16 @@ module ConvenientService
         #
         #   TODO: Include `method` into trigger metadata.
         #
+        #   IMPORTANT: Ruby 2.7 and Ruby 3.0+ invoke this `method_missing` differently, check the following files/links:
+        #   - `lib/convenient_service/core/entities/config/entities/method_middlewares/entities/caller/commands/define_method_middlewares_caller.rb`
+        #   - https://gist.github.com/marian13/9c25041f835564e945d978839097d419
+        #
         def method_missing(method, *args, **kwargs, &block)
           self.class.commit_config!(trigger: Constants::Triggers::INSTANCE_METHOD_MISSING)
 
-          return super unless Utils::Module.instance_method_defined?(self.class, method, public: true, protected: false, private: false)
+          return ::ConvenientService.reraise { super } unless Utils::Module.instance_method_defined?(self.class, method, public: true, protected: false, private: false)
 
-          return super if self.class.middlewares(method, scope: :instance).defined_without_super_method?
+          return ::ConvenientService.reraise { super } if self.class.middlewares(method, scope: :instance).defined_without_super_method?
 
           ConvenientService.logger.debug { "[Core] Committed config for `#{self.class}` | Triggered by `method_missing` | Method: `##{method}`" }
 

data/lib/convenient_service/core/entities/config/commands/track_method_missing_commit_trigger.rb

@@ -35,7 +35,7 @@ module ConvenientService
               return unless method_missing_trigger_valid?
               return if method_missing_commits_counter_incremented?
 
-              raise Exceptions::TooManyCommitsFromMethodMissing.new(config: config)
+              ::ConvenientService.raise Exceptions::TooManyCommitsFromMethodMissing.new(config: config)
             end
 
             ##

data/lib/convenient_service/core/entities/config/entities/method_middlewares/entities/caller/commands/define_method_middlewares_caller.rb

@@ -90,9 +90,9 @@ module ConvenientService
                     #     prefix = "#{prefix}"
                     #
                     #   NOTE: Check the following link in order to get an idea why two versions of `define_method_middlewares_caller` exist.
-                    #   https://gist.github.com/marian13/9c25041f835564e945d978839097d419
+                    #   - https://gist.github.com/marian13/9c25041f835564e945d978839097d419
                     #
-                    if ::RUBY_VERSION >= "3.0"
+                    if Dependencies.ruby.version >= 3.0
                       def define_method_middlewares_caller
                         <<~RUBY.tap { |code| methods_middlewares_callers.module_eval(code, __FILE__, __LINE__ + 1) }
                           def #{method}(*args, **kwargs, &block)

data/lib/convenient_service/core/entities/config/entities/method_middlewares/entities/middlewares/base/commands/create_observable_middleware.rb

@@ -39,6 +39,9 @@ module ConvenientService
                           # @param other [Object] Can be any type.
                           # @return [Boolean, nil]
                           #
+                          # @internal
+                          #   TODO: Try `self.middleware == other.middleware if self < ::ConvenientService::Core::Entities::Config::Entities::MethodMiddlewares::Entities::Middlewares::Base`.
+                          #
                           define_singleton_method(:==) { |other| self.middleware == other.middleware if other.respond_to?(:middleware) }
 
                           ##

data/lib/convenient_service/core/entities/config/exceptions.rb

@@ -10,14 +10,14 @@ module ConvenientService
             # @param config [ConvenientService::Core::Entities::Config]
             # @return [void]
             #
-            def initialize(config:)
+            def initialize_with_kwargs(config:)
               message = <<~TEXT
                 Config for `#{config.klass}` is already committed. Only uncommitted configs can be modified.
 
                 Did you accidentally call `concerns(&configuration_block)` or `middlewares(method, scope: scope, &configuration_block)` after using any plugin, after calling `commit_config!`?
               TEXT
 
-              super(message)
+              initialize(message)
             end
           end
 
@@ -30,7 +30,9 @@ module ConvenientService
             #   TODO: Create a troubleshooting page with possible reasons (preliminary RSpec mocks etc).
             #   Append a link to it to the error message.
             #
-            def initialize(config:)
+            #   TODO: Add a note of the most common scenario when this issue appears - when the RSpec stub is used before auto config commitment. For example, with `delegate_to`.
+            #
+            def initialize_with_kwargs(config:)
               message = <<~TEXT
                 `#{config.klass}` config is committed too many times from `method_missing`.
 
@@ -54,7 +56,7 @@ module ConvenientService
                   end
               TEXT
 
-              super(message)
+              initialize(message)
             end
           end
         end

data/lib/convenient_service/core/entities/config.rb

@@ -142,6 +142,9 @@ module ConvenientService
         # @internal
         #   IMPORTANT: `commit!` MUST be thread safe.
         #
+        #   NOTE: Inspired by `Response#commit!` and others.
+        #   - https://github.com/rails/rails/blob/36c1591bcb5e0ee3084759c7f42a706fe5bb7ca7/actionpack/lib/action_controller/metal/live.rb#L307
+        #
         def commit!(trigger: Constants::Triggers::USER)
           (committed? ? false : concerns.include!)
             .tap { Commands::TrackMethodMissingCommitTrigger.call(config: self, trigger: trigger) }
@@ -162,7 +165,7 @@ module ConvenientService
         def assert_not_committed!
           return unless committed?
 
-          raise Exceptions::ConfigIsCommitted.new(config: self)
+          ::ConvenientService.raise Exceptions::ConfigIsCommitted.new(config: self)
         end
       end
     end

data/lib/convenient_service/dependencies/extractions/active_support_backtrace_cleaner/backtrace_cleaner.rb

@@ -7,15 +7,17 @@ module ConvenientService
       # @internal
       #   NOTE:
       #     Copied from `rails/rails` without any logic modification.
-      #     Version: v7.0.4.3.
+      #     Version: v7.1.2.
       #     Wrapped in a namespace `ConvenientService::Dependencies::Extractions::ActiveSupportBacktraceCleaner`.
       #
-      #   - https://api.rubyonrails.org/v7.0.4.3/classes/ActiveSupport/BacktraceCleaner.html
-      #   - https://github.com/rails/rails/blob/v7.0.4.3/activesupport/lib/active_support/backtrace_cleaner.rb
+      #   - https://api.rubyonrails.org/v7.1.2/classes/ActiveSupport/BacktraceCleaner.html
+      #   - https://github.com/rails/rails/blob/v7.1.2/activesupport/lib/active_support/backtrace_cleaner.rb
       #   - https://github.com/marian13/rails/blob/main/activesupport/lib/active_support/backtrace_cleaner.rb
       #   - https://github.com/rails/rails
       #
       module ActiveSupportBacktraceCleaner
+        # = Backtrace Cleaner
+        #
         # Backtraces often include many lines that are not relevant for the context
         # under review. This makes it hard to find the signal amongst the backtrace
         # noise, and adds debugging time. With a BacktraceCleaner, filters and
@@ -34,7 +36,7 @@ module ConvenientService
         #   bc.add_silencer { |line| /puma|rubygems/.match?(line) } # skip any lines from puma or rubygems
         #   bc.clean(exception.backtrace) # perform the cleanup
         #
-        # To reconfigure an existing BacktraceCleaner (like the default one in Rails)
+        # To reconfigure an existing BacktraceCleaner (like the default one in \Rails)
         # and show as much data as possible, you can always call
         # BacktraceCleaner#remove_silencers!, which will restore the
         # backtrace to a pristine state. If you need to reconfigure an existing
@@ -67,11 +69,29 @@ module ConvenientService
           end
           alias :filter :clean
 
+          # Returns the frame with all filters applied.
+          # returns +nil+ if the frame was silenced.
+          def clean_frame(frame, kind = :silent)
+            frame = frame.to_s
+            @filters.each do |f|
+              frame = f.call(frame.to_s)
+            end
+
+            case kind
+            when :silent
+              frame unless @silencers.any? { |s| s.call(frame) }
+            when :noise
+              frame if @silencers.any? { |s| s.call(frame) }
+            else
+              frame
+            end
+          end
+
           # Adds a filter from the block provided. Each line in the backtrace will be
           # mapped against this filter.
           #
           #   # Will turn "/my/rails/root/app/models/person.rb" into "/app/models/person.rb"
-          #   backtrace_cleaner.add_filter { |line| line.gsub(Rails.root, '') }
+          #   backtrace_cleaner.add_filter { |line| line.gsub(Rails.root.to_s, '') }
           def add_filter(&block)
             @filters << block
           end
@@ -121,7 +141,7 @@ module ConvenientService
 
             def filter_backtrace(backtrace)
               @filters.each do |f|
-                backtrace = backtrace.map { |line| f.call(line) }
+                backtrace = backtrace.map { |line| f.call(line.to_s) }
               end
 
               backtrace
@@ -129,7 +149,7 @@ module ConvenientService
 
             def silence(backtrace)
               @silencers.each do |s|
-                backtrace = backtrace.reject { |line| s.call(line) }
+                backtrace = backtrace.reject { |line| s.call(line.to_s) }
               end
 
               backtrace
@@ -138,7 +158,7 @@ module ConvenientService
             def noise(backtrace)
               backtrace.select do |line|
                 @silencers.any? do |s|
-                  s.call(line)
+                  s.call(line.to_s)
                 end
               end
             end

data/lib/convenient_service/dependencies/extractions/active_support_backtrace_cleaner.rb

@@ -4,11 +4,11 @@
 # @internal
 #   NOTE:
 #     Copied from `rails/rails` without any logic modification.
-#     Version: v7.0.4.3.
+#     Version: v7.1.2.
 #     Wrapped in a namespace `ConvenientService::Dependencies::Extractions::ActiveSupportBacktraceCleaner`.
 #
-#   - https://api.rubyonrails.org/v7.0.4.3/classes/ActiveSupport/BacktraceCleaner.html
-#   - https://github.com/rails/rails/blob/v7.0.4.3/activesupport/lib/active_support/backtrace_cleaner.rb
+#   - https://api.rubyonrails.org/v7.1.2/classes/ActiveSupport/BacktraceCleaner.html
+#   - https://github.com/rails/rails/blob/v7.1.2/activesupport/lib/active_support/backtrace_cleaner.rb
 #   - https://github.com/marian13/rails/blob/main/activesupport/lib/active_support/backtrace_cleaner.rb
 #   - https://github.com/rails/rails
 #

data/lib/convenient_service/dependencies/extractions/b.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ##
 # Works in a similar way as `p`, but for `byebug`.
 # @see https://ruby-doc.org/core-2.7.0/Kernel.html#method-i-p

data/lib/convenient_service/dependencies/extractions/ce.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+##
+# @note `ce` is short for `catch_exception`.
+#
+# @example
+#   ce { some_code }
+#   e = ce { some_code }
+#
+def ce
+  yield
+
+  nil
+rescue => exception
+  exception
+end

data/lib/convenient_service/dependencies/extractions.rb

@@ -7,4 +7,5 @@
 #   https://github.com/marian13/convenient_service/wiki/Docs:-Dependencies
 #
 require_relative "extractions/active_support_concern"
+require_relative "extractions/active_support_backtrace_cleaner"
 require_relative "extractions/ruby_middleware"

data/lib/convenient_service/dependencies.rb

@@ -135,7 +135,7 @@ module ConvenientService
       # @return [Boolean]
       # @note Expected to be called from app entry points like `initializers` in Rails.
       #
-      # @see https://marian13.github.io/convenient_service_docs/troubleshooting/i18n_translate_wrong_number_of_arguments
+      # @see https://userdocs.convenientservice.org/troubleshooting/i18n_translate_wrong_number_of_arguments
       #
       def require_has_j_send_result_params_validations_using_active_model_validations
         ##
@@ -175,13 +175,20 @@ module ConvenientService
       end
 
       ##
-      # @api public
+      # @api private
       #
       # @return [Boolean]
       # @note Expected to be called from app entry points like `initializers` in Rails.
       #
-      def require_cleans_exception_backtrace
-        require_relative "dependencies/extractions/active_support_backtrace_cleaner"
+      def require_wraps_result_in_db_transaction
+        ##
+        # - https://edgeguides.rubyonrails.org/active_record_basics.html
+        # - https://api.rubyonrails.org/classes/ActiveRecord.html
+        # - https://github.com/rails/rails/tree/main/activerecord
+        #
+        require "active_record"
+
+        require_relative "service/plugins/wraps_result_in_db_transaction"
       end
 
       ##
@@ -244,6 +251,11 @@ module ConvenientService
         require_relative "dependencies/extractions/byebug_syntax_highlighting" unless ruby.jruby?
 
         require_relative "dependencies/extractions/b" unless ruby.jruby?
+
+        ##
+        #
+        #
+        require_relative "dependencies/extractions/ce"
       end
 
       ##
@@ -331,6 +343,7 @@ module ConvenientService
         require_relative ::File.join("examples", "standard", version, "factorial")
         require_relative ::File.join("examples", "standard", version, "gemfile")
         require_relative ::File.join("examples", "standard", version, "request_params")
+        require_relative ::File.join("examples", "standard", version, "comprehensive_suite") if version.empty?
       end
 
       ##

data/lib/convenient_service/exception.rb

@@ -1,16 +1,104 @@
 # frozen_string_literal: true
 
-##
-# Base class for all `ConvenientService` exceptions.
-# Can be used as a catch-all solution, for example:
-#
-#   begin
-#     any_service.result
-#   rescue ConvenientService::Exception => exception
-#     puts exception.message
-#   end
-#
 module ConvenientService
+  ##
+  # Base class for all `ConvenientService` exceptions.
+  #
+  # @example Can be used as a catch-all solution.
+  #
+  #   begin
+  #     any_service.result
+  #   rescue ConvenientService::Exception => exception
+  #     puts exception.message
+  #   end
+  #
   class Exception < ::StandardError
+    class << self
+      ##
+      # Creates `ConvenientService` exception instance.
+      # In contract to `StandardError.new`, may accept `kwargs`.
+      # In such a case the descendant must implement `initialize_with_kwargs` to specify the logic of how to generate a `message`.
+      # Without arguments behavior is also changed, it calls `initialize_without_arguments` instead of immediately setting `nil` as `message`.
+      #
+      # @note `initialize_with_kwargs` or `initialize_without_arguments` must call `initialize(message)`, otherwise exception instance won't be properly set up.
+      #
+      # @overload new
+      #   Calls `initialize_without_arguments` under the hood to generate the exception message.
+      #
+      #   @api private
+      #
+      #   @return [ConvenientService::Exception]
+      #
+      #   @example Usage.
+      #     module Exceptions
+      #       class Foo < ::ConvenientService::Exception
+      #         def initialize_without_arguments
+      #           # message = ...
+      #           initialize(message)
+      #         end
+      #       end
+      #     end
+      #
+      #     ::ConvenientService.raise Foo.new
+      #
+      # @overload new(message)
+      #   Calls `initialize(message)` under the hood to set the exception message.
+      #
+      #   @api private
+      #
+      #   @param message [String]
+      #
+      #   @return [ConvenientService::Exception]
+      #
+      #   @example Usage.
+      #     module Exceptions
+      #       class Foo < ::ConvenientService::Exception
+      #       end
+      #     end
+      #
+      #     ::ConvenientService.raise Foo.new("some message")
+      #
+      # @overload new(**kwargs)
+      #   Calls `initialize_with_kwargs(**kwargs)` under the hood to generate the exception message.
+      #
+      #   @api private
+      #
+      #   @param kwargs [Hash{Symbol => Object}]
+      #   @return [ConvenientService::Exception]
+      #
+      #   @example Usage.
+      #     module Exceptions
+      #       class Foo < ::ConvenientService::Exception
+      #         def initialize_with_kwargs(**kwargs)
+      #           # message = ...
+      #           initialize(message)
+      #         end
+      #       end
+      #     end
+      #
+      #     ::ConvenientService.raise Foo.new(foo: :bar, baz: :qux)
+      #
+      def new(message = nil, **kwargs)
+        if message
+          super(message)
+        elsif kwargs.any?
+          allocate.tap { |exception| exception.initialize_with_kwargs(**kwargs) }
+        else
+          allocate.tap(&:initialize_without_arguments)
+        end
+      end
+    end
+
+    ##
+    # @internal
+    #   NOTE: Two exceptions are equal when their classes, messages, and backtraces are equal.
+    #   - https://blog.arkency.com/2015/01/ruby-exceptions-equality
+    #
+    #   TODO: Compare skipping backtraces? Why?
+    #
+    # def ==(other)
+    #   # ...
+    # end
+    ##
   end
 end

data/lib/convenient_service/feature/configs/standard.rb

@@ -14,6 +14,14 @@ module ConvenientService
 
           concerns do
             use ConvenientService::Plugins::Feature::CanHaveEntries::Concern
+
+            use ConvenientService::Plugins::Common::HasInstanceProxy::Concern
+          end
+
+          middlewares :new, scope: :class do
+            use ConvenientService::Plugins::Common::NormalizesEnv::Middleware
+
+            use ConvenientService::Plugins::Common::HasInstanceProxy::Middleware
           end
         end
       end

data/lib/convenient_service/feature/plugins/can_have_entries/commands/define_entries.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ConvenientService
+  module Feature
+    module Plugins
+      module CanHaveEntries
+        module Commands
+          class DefineEntries < Support::Command
+            ##
+            # @!attribute [r] feature_class
+            #   @return [Class]
+            #
+            attr_reader :feature_class
+
+            ##
+            # @!attribute [r] names
+            #   @return [Array<String, Symbol>]
+            #
+            attr_reader :names
+
+            ##
+            # @!attribute [r] body
+            #   @return [Proc, nil]
+            #
+            attr_reader :body
+
+            ##
+            # @param feature_class [Class]
+            # @param names [Array<String, Symbol>]
+            # @param body [Proc, nil]
+            #
+            def initialize(feature_class:, names:, body:)
+              @feature_class = feature_class
+              @names = names
+              @body = body
+            end
+
+            ##
+            # @return [Array<String, Symbol>]
+            #
+            def call
+              names.map { |name| Commands::DefineEntry.call(feature_class: feature_class, name: name, body: body) }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/convenient_service/feature/plugins/can_have_entries/commands/define_entry.rb

@@ -20,14 +20,14 @@ module ConvenientService
 
             ##
             # @!attribute [r] body
-            #   @return [Proc]
+            #   @return [Proc, nil]
             #
             attr_reader :body
 
             ##
             # @param feature_class [Class]
             # @param name [String, Symbol]
-            # @param body [Proc]
+            # @param body [Proc, nil]
             #
             def initialize(feature_class:, name:, body:)
               @feature_class = feature_class
@@ -44,13 +44,27 @@ module ConvenientService
               # That is why `feature_class.class_exec` wrapper is required.
               #
               feature_class.class_exec(name) do |name|
-                define_singleton_method(name) { |*args, **kwargs, &block| new.public_send(name, *args, **kwargs, &block) }
+                define_singleton_method(name) { |*args, **kwargs, &block| new.entry(name, *args, **kwargs, &block) }
               end
 
               if body
                 feature_class.define_method(name, &body)
               else
-                feature_class.define_method(name) { raise ::ConvenientService::Feature::Plugins::CanHaveEntries::Exceptions::NotDefinedEntryMethod.new(name: __method__, feature: self) }
+                feature_class.define_method(name) { |*args, **kwargs, &block| ::ConvenientService.raise ::ConvenientService::Feature::Plugins::CanHaveEntries::Exceptions::NotDefinedEntryMethod.new(name: __method__, feature: self) }
+              end
+
+              ##
+              # NOTE: Just `feature_class.instance_proxy_class.define_method` does NOT create a closure for `name`.
+              # That is why `feature_class.instance_proxy_class.class_exec` wrapper is required.
+              #
+              feature_class.instance_proxy_class.class_exec(name) do |name|
+                define_method(name) do |*args, **kwargs, &block|
+                  instance_proxy_target.entry(name, *args, **kwargs, &block)
+                end
+              end
+
+              feature_class.instance_proxy_class.define_method(:entry) do |*args, **kwargs, &block|
+                instance_proxy_target.entry(*args, **kwargs, &block)
               end
 
               name

data/lib/convenient_service/feature/plugins/can_have_entries/commands.rb

@@ -1,3 +1,4 @@
 # frozen_string_literal: true
 
+require_relative "commands/define_entries"
 require_relative "commands/define_entry"

data/lib/convenient_service/feature/plugins/can_have_entries/concern.rb

@@ -7,14 +7,23 @@ module ConvenientService
         module Concern
           include Support::Concern
 
+          instance_methods do
+            ##
+            # @return [Object] Can be any type.
+            #
+            def entry(...)
+              public_send(...)
+            end
+          end
+
           class_methods do
             ##
-            # @param name [String, Symbol]
+            # @param names [Array<String, Symbol>]
             # @param body [Proc, nil]
-            # @return [String, Symbol]
+            # @return [Array<String, Symbol>]
             #
-            def entry(name, &body)
-              Commands::DefineEntry.call(feature_class: self, name: name, body: body)
+            def entry(*names, &body)
+              Commands::DefineEntries.call(feature_class: self, names: names, body: body)
             end
           end
         end

data/lib/convenient_service/feature/plugins/can_have_entries/exceptions.rb

@@ -6,18 +6,28 @@ module ConvenientService
       module CanHaveEntries
         module Exceptions
           class NotDefinedEntryMethod < ::ConvenientService::Exception
-            def initialize(name:, feature:)
+            def initialize_with_kwargs(name:, feature:)
               message = <<~TEXT
                 Entry for `#{name}` is registered inside `#{feature.class}` feature, but its corresponding method is NOT defined.
 
-                Did you forget to define it? For example:
+                Did you forget to define it? For example, using method form:
 
                 class #{feature.class}
                   entry :#{name}
 
                   # ...
 
-                  def #{name}
+                  def #{name}(...)
+                    # ...
+                  end
+
+                  # ...
+                end
+
+                Or using block form:
+
+                class #{feature.class}
+                  entry :#{name} do |*args, **kwargs, &block|
                     # ...
                   end
 
@@ -25,7 +35,7 @@ module ConvenientService
                 end
               TEXT
 
-              super(message)
+              initialize(message)
             end
           end
         end