tapioca 0.5.0 → 0.5.4

data/lib/tapioca/compilers/dynamic_mixin_compiler.rb

@@ -0,0 +1,198 @@
+# typed: strict
+# frozen_string_literal: true
+
+class DynamicMixinCompiler
+  extend T::Sig
+  include Tapioca::Reflection
+
+  sig { returns(T::Array[Module]) }
+  attr_reader :dynamic_extends, :dynamic_includes
+
+  sig { returns(T::Array[Symbol]) }
+  attr_reader :class_attribute_readers, :class_attribute_writers, :class_attribute_predicates
+
+  sig { returns(T::Array[Symbol]) }
+  attr_reader :instance_attribute_readers, :instance_attribute_writers, :instance_attribute_predicates
+
+  sig { params(constant: Module).void }
+  def initialize(constant)
+    @constant = constant
+    mixins_from_modules = {}.compare_by_identity
+    class_attribute_readers = T.let([], T::Array[Symbol])
+    class_attribute_writers = T.let([], T::Array[Symbol])
+    class_attribute_predicates = T.let([], T::Array[Symbol])
+
+    instance_attribute_readers = T.let([], T::Array[Symbol])
+    instance_attribute_writers = T.let([], T::Array[Symbol])
+    instance_attribute_predicates = T.let([], T::Array[Symbol])
+
+    Class.new do
+      # Override the `self.include` method
+      define_singleton_method(:include) do |mod|
+        # Take a snapshot of the list of singleton class ancestors
+        # before the actual include
+        before = singleton_class.ancestors
+        # Call the actual `include` method with the supplied module
+        super(mod).tap do
+          # Take a snapshot of the list of singleton class ancestors
+          # after the actual include
+          after = singleton_class.ancestors
+          # The difference is the modules that are added to the list
+          # of ancestors of the singleton class. Those are all the
+          # modules that were `extend`ed due to the `include` call.
+          #
+          # We record those modules on our lookup table keyed by
+          # the included module with the values being all the modules
+          # that that module pulls into the singleton class.
+          #
+          # We need to reverse the order, since the extend order should
+          # be the inverse of the ancestor order. That is, earlier
+          # extended modules would be later in the ancestor chain.
+          mixins_from_modules[mod] = (after - before).reverse!
+        end
+      rescue Exception # rubocop:disable Lint/RescueException
+        # this is a best effort, bail if we can't perform this
+      end
+
+      define_singleton_method(:class_attribute) do |*attrs, **kwargs|
+        class_attribute_readers.concat(attrs)
+        class_attribute_writers.concat(attrs)
+
+        instance_predicate = kwargs.fetch(:instance_predicate, true)
+        instance_accessor = kwargs.fetch(:instance_accessor, true)
+        instance_reader = kwargs.fetch(:instance_reader, instance_accessor)
+        instance_writer = kwargs.fetch(:instance_writer, instance_accessor)
+
+        if instance_reader
+          instance_attribute_readers.concat(attrs)
+        end
+
+        if instance_writer
+          instance_attribute_writers.concat(attrs)
+        end
+
+        if instance_predicate
+          class_attribute_predicates.concat(attrs)
+
+          if instance_reader
+            instance_attribute_predicates.concat(attrs)
+          end
+        end
+
+        super(*attrs, **kwargs) if defined?(super)
+      end
+
+      # rubocop:disable Style/MissingRespondToMissing
+      T::Sig::WithoutRuntime.sig { params(symbol: Symbol, args: T.untyped).returns(T.untyped) }
+      def method_missing(symbol, *args)
+        # We need this here so that we can handle any random instance
+        # method calls on the fake including class that may be done by
+        # the included module during the `self.included` hook.
+      end
+
+      class << self
+        extend T::Sig
+
+        T::Sig::WithoutRuntime.sig { params(symbol: Symbol, args: T.untyped).returns(T.untyped) }
+        def method_missing(symbol, *args)
+          # Similarly, we need this here so that we can handle any
+          # random class method calls on the fake including class
+          # that may be done by the included module during the
+          # `self.included` hook.
+        end
+      end
+      # rubocop:enable Style/MissingRespondToMissing
+    end.include(constant)
+
+    # The value that corresponds to the original included constant
+    # is the list of all dynamically extended modules because of that
+    # constant. We grab that value by deleting the key for the original
+    # constant.
+    @dynamic_extends = T.let(mixins_from_modules.delete(constant) || [], T::Array[Module])
+
+    # Since we deleted the original constant from the list of keys, all
+    # the keys that remain are the ones that are dynamically included modules
+    # during the include of the original constant.
+    @dynamic_includes = T.let(mixins_from_modules.keys, T::Array[Module])
+
+    @class_attribute_readers = T.let(class_attribute_readers, T::Array[Symbol])
+    @class_attribute_writers = T.let(class_attribute_writers, T::Array[Symbol])
+    @class_attribute_predicates = T.let(class_attribute_predicates, T::Array[Symbol])
+
+    @instance_attribute_readers = T.let(instance_attribute_readers, T::Array[Symbol])
+    @instance_attribute_writers = T.let(instance_attribute_writers, T::Array[Symbol])
+    @instance_attribute_predicates = T.let(instance_attribute_predicates, T::Array[Symbol])
+  end
+
+  sig { returns(T::Boolean) }
+  def empty_attributes?
+    @class_attribute_readers.empty? && @class_attribute_writers.empty?
+  end
+
+  sig { params(tree: RBI::Tree).void }
+  def compile_class_attributes(tree)
+    return if empty_attributes?
+
+    # Create a synthetic module to hold the generated class methods
+    tree << RBI::Module.new("GeneratedClassMethods") do |mod|
+      class_attribute_readers.each do |attribute|
+        mod << RBI::Method.new(attribute.to_s)
+      end
+
+      class_attribute_writers.each do |attribute|
+        mod << RBI::Method.new("#{attribute}=") do |method|
+          method << RBI::Param.new("value")
+        end
+      end
+
+      class_attribute_predicates.each do |attribute|
+        mod << RBI::Method.new("#{attribute}?")
+      end
+    end
+
+    # Create a synthetic module to hold the generated instance methods
+    tree << RBI::Module.new("GeneratedInstanceMethods") do |mod|
+      instance_attribute_readers.each do |attribute|
+        mod << RBI::Method.new(attribute.to_s)
+      end
+
+      instance_attribute_writers.each do |attribute|
+        mod << RBI::Method.new("#{attribute}=") do |method|
+          method << RBI::Param.new("value")
+        end
+      end
+
+      instance_attribute_predicates.each do |attribute|
+        mod << RBI::Method.new("#{attribute}?")
+      end
+    end
+
+    # Add a mixes_in_class_methods and include for the generated modules
+    tree << RBI::MixesInClassMethods.new("GeneratedClassMethods")
+    tree << RBI::Include.new("GeneratedInstanceMethods")
+  end
+
+  sig { params(tree: RBI::Tree).returns([T::Array[Module], T::Array[Module]]) }
+  def compile_mixes_in_class_methods(tree)
+    includes = dynamic_includes.select { |mod| (name = name_of(mod)) && !name.start_with?("T::") }
+    includes.each do |mod|
+      qname = qualified_name_of(mod)
+      tree << RBI::Include.new(T.must(qname))
+    end
+
+    # If we can generate multiple mixes_in_class_methods, then we want to use all dynamic extends that are not the
+    # constant itself
+    mixed_in_class_methods = dynamic_extends.select { |mod| mod != @constant }
+    return [[], []] if mixed_in_class_methods.empty?
+
+    mixed_in_class_methods.each do |mod|
+      qualified_name = qualified_name_of(mod)
+      next if qualified_name.nil? || qualified_name.empty?
+      tree << RBI::MixesInClassMethods.new(qualified_name)
+    end
+
+    [mixed_in_class_methods, includes]
+  rescue
+    [[], []] # silence errors
+  end
+end

data/lib/tapioca/compilers/sorbet.rb

@@ -18,7 +18,6 @@ module Tapioca
       EXE_PATH_ENV_VAR = "TAPIOCA_SORBET_EXE"
 
       FEATURE_REQUIREMENTS = T.let({
-        mixes_in_class_methods_multiple_args: Gem::Requirement.new("> 0.5.6200"),
       }.freeze, T::Hash[Symbol, Gem::Requirement])
 
       class << self

data/lib/tapioca/compilers/symbol_table/symbol_generator.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: strict
 # frozen_string_literal: true
 
 require "pathname"
@@ -10,36 +10,47 @@ module Tapioca
         extend(T::Sig)
         include(Reflection)
 
-        IGNORED_SYMBOLS = ["YAML", "MiniTest", "Mutex"]
-
-        attr_reader(:gem, :indent)
-
-        sig { params(gem: Gemfile::GemSpec, indent: Integer).void }
-        def initialize(gem, indent = 0)
+        IGNORED_SYMBOLS = T.let(["YAML", "MiniTest", "Mutex"], T::Array[String])
+        IGNORED_COMMENTS = T.let([
+          ":doc:",
+          ":nodoc:",
+          "typed:",
+          "frozen_string_literal:",
+          "encoding:",
+          "warn_indent:",
+          "shareable_constant_value:",
+          "rubocop:",
+        ], T::Array[String])
+
+        sig { returns(Gemfile::GemSpec) }
+        attr_reader :gem
+
+        sig { returns(Integer) }
+        attr_reader :indent
+
+        sig { params(gem: Gemfile::GemSpec, indent: Integer, include_doc: T::Boolean).void }
+        def initialize(gem, indent = 0, include_doc = false)
           @gem = gem
           @indent = indent
-          @seen = Set.new
-          @alias_namespace ||= Set.new
+          @seen = T.let(Set.new, T::Set[String])
+          @alias_namespace = T.let(Set.new, T::Set[String])
           @symbol_queue = T.let(symbols.sort.dup, T::Array[String])
-        end
-
-        sig { returns(String) }
-        def generate
-          rbi = RBI::Tree.new
+          @symbols = T.let(nil, T.nilable(T::Set[String]))
+          @include_doc = include_doc
 
-          generate_from_symbol(rbi, T.must(@symbol_queue.shift)) until @symbol_queue.empty?
+          gem.parse_yard_docs if include_doc
+        end
 
-          rbi.nest_singleton_methods!
-          rbi.nest_non_public_methods!
-          rbi.group_nodes!
-          rbi.sort_nodes!
-          rbi.string
+        sig { params(rbi: RBI::File).void }
+        def generate(rbi)
+          generate_from_symbol(rbi.root, T.must(@symbol_queue.shift)) until @symbol_queue.empty?
         end
 
         private
 
+        sig { params(name: T.nilable(String)).void }
         def add_to_symbol_queue(name)
-          @symbol_queue << name unless symbols.include?(name) || symbol_ignored?(name)
+          @symbol_queue << name unless name.nil? || symbols.include?(name) || symbol_ignored?(name)
         end
 
         sig { returns(T::Set[String]) }
@@ -154,28 +165,33 @@ module Tapioca
             name_of(klass)
           end
 
+          comments = documentation_comments(name)
+
           if klass_name == "T::Private::Types::TypeAlias"
-            tree << RBI::Const.new(name, "T.type_alias { #{T.unsafe(value).aliased_type} }")
+            constant = RBI::Const.new(name, "T.type_alias { #{T.unsafe(value).aliased_type} }", comments: comments)
+            tree << constant
             return
           end
 
           return if klass_name&.start_with?("T::Types::", "T::Private::")
 
           type_name = klass_name || "T.untyped"
+          constant = RBI::Const.new(name, "T.let(T.unsafe(nil), #{type_name})", comments: comments)
 
-          tree << RBI::Const.new(name, "T.let(T.unsafe(nil), #{type_name})")
+          tree << constant
         end
 
         sig { params(tree: RBI::Tree, name: String, constant: Module).void }
         def compile_module(tree, name, constant)
           return unless defined_in_gem?(constant, strict: false)
 
+          comments = documentation_comments(name)
           scope =
             if constant.is_a?(Class)
               superclass = compile_superclass(constant)
-              RBI::Class.new(name, superclass_name: superclass)
+              RBI::Class.new(name, superclass_name: superclass, comments: comments)
             else
-              RBI::Module.new(name)
+              RBI::Module.new(name, comments: comments)
             end
 
           compile_body(scope, name, constant)
@@ -193,9 +209,22 @@ module Tapioca
           compile_methods(tree, name, constant)
           compile_module_helpers(tree, constant)
           compile_mixins(tree, constant)
-          compile_mixes_in_class_methods(tree, constant)
           compile_props(tree, constant)
           compile_enums(tree, constant)
+          compile_dynamic_mixins(tree, constant)
+        end
+
+        sig { params(tree: RBI::Tree, constant: Module).void }
+        def compile_dynamic_mixins(tree, constant)
+          return if constant.is_a?(Class)
+
+          mixin_compiler = DynamicMixinCompiler.new(constant)
+          mixin_compiler.compile_class_attributes(tree)
+          dynamic_extends, dynamic_includes = mixin_compiler.compile_mixes_in_class_methods(tree)
+
+          (dynamic_includes + dynamic_extends).each do |mod|
+            add_to_symbol_queue(name_of(mod))
+          end
         end
 
         sig { params(tree: RBI::Tree, constant: Module).void }
@@ -391,130 +420,6 @@ module Tapioca
             end
         end
 
-        sig { params(constant: Module).returns([T::Array[Module], T::Array[Module]]) }
-        def collect_dynamic_mixins_of(constant)
-          mixins_from_modules = {}.compare_by_identity
-
-          Class.new do
-            # Override the `self.include` method
-            define_singleton_method(:include) do |mod|
-              # Take a snapshot of the list of singleton class ancestors
-              # before the actual include
-              before = singleton_class.ancestors
-              # Call the actual `include` method with the supplied module
-              include_result = super(mod)
-              # Take a snapshot of the list of singleton class ancestors
-              # after the actual include
-              after = singleton_class.ancestors
-              # The difference is the modules that are added to the list
-              # of ancestors of the singleton class. Those are all the
-              # modules that were `extend`ed due to the `include` call.
-              #
-              # We record those modules on our lookup table keyed by
-              # the included module with the values being all the modules
-              # that that module pulls into the singleton class.
-              #
-              # We need to reverse the order, since the extend order should
-              # be the inverse of the ancestor order. That is, earlier
-              # extended modules would be later in the ancestor chain.
-              mixins_from_modules[mod] = (after - before).reverse!
-
-              include_result
-            rescue Exception # rubocop:disable Lint/RescueException
-              # this is a best effort, bail if we can't perform this
-            end
-
-            # rubocop:disable Style/MissingRespondToMissing
-            def method_missing(symbol, *args)
-              # We need this here so that we can handle any random instance
-              # method calls on the fake including class that may be done by
-              # the included module during the `self.included` hook.
-            end
-
-            class << self
-              def method_missing(symbol, *args)
-                # Similarly, we need this here so that we can handle any
-                # random class method calls on the fake including class
-                # that may be done by the included module during the
-                # `self.included` hook.
-              end
-            end
-            # rubocop:enable Style/MissingRespondToMissing
-          end.include(constant)
-
-          [
-            # The value that corresponds to the original included constant
-            # is the list of all dynamically extended modules because of that
-            # constant. We grab that value by deleting the key for the original
-            # constant.
-            T.must(mixins_from_modules.delete(constant)),
-            # Since we deleted the original constant from the list of keys, all
-            # the keys that remain are the ones that are dynamically included modules
-            # during the include of the original constant.
-            mixins_from_modules.keys,
-          ]
-        end
-
-        sig { params(constant: Module, dynamic_extends: T::Array[Module]).returns(T::Array[Module]) }
-        def collect_mixed_in_class_methods(constant, dynamic_extends)
-          if Tapioca::Compilers::Sorbet.supports?(:mixes_in_class_methods_multiple_args)
-            # If we can generate multiple mixes_in_class_methods, then
-            # we want to use all dynamic extends that are not the constant itself
-            return dynamic_extends.select { |mod| mod != constant }
-          end
-
-          # For older Sorbet version, we do an explicit check for an AS::Concern
-          # related ClassMethods module.
-          ancestors = singleton_class_of(constant).ancestors
-          extends_as_concern = ancestors.any? do |mod|
-            qualified_name_of(mod) == "::ActiveSupport::Concern"
-          end
-          class_methods_module = resolve_constant("#{name_of(constant)}::ClassMethods")
-
-          mixed_in_module = if extends_as_concern && Module === class_methods_module
-            # If this module is a concern and the ClassMethods module exists
-            # then, we prefer to generate a mixes_in_class_methods call for
-            # that module only, since we only have a single shot.
-            class_methods_module
-          else
-            # Otherwise, we use the first dynamic extend module that is not
-            # the constant itself. We don't have a better heuristic in the
-            # absence of being able to supply multiple arguments.
-            dynamic_extends.find { |mod| mod != constant }
-          end
-
-          Array(mixed_in_module)
-        end
-
-        sig { params(tree: RBI::Tree, constant: Module).void }
-        def compile_mixes_in_class_methods(tree, constant)
-          return if constant.is_a?(Class)
-
-          dynamic_extends, dynamic_includes = collect_dynamic_mixins_of(constant)
-
-          dynamic_includes
-            .select { |mod| (name = name_of(mod)) && !name.start_with?("T::") }
-            .map do |mod|
-              add_to_symbol_queue(name_of(mod))
-
-              qname = qualified_name_of(mod)
-              tree << RBI::Include.new(T.must(qname))
-            end
-
-          mixed_in_class_methods = collect_mixed_in_class_methods(constant, dynamic_extends)
-          return if mixed_in_class_methods.empty?
-
-          mixed_in_class_methods.each do |mod|
-            add_to_symbol_queue(name_of(mod))
-
-            qualified_name = qualified_name_of(mod)
-            next if qualified_name.nil? || qualified_name.empty?
-            tree << RBI::MixesInClassMethods.new(qualified_name)
-          end
-        rescue
-          nil # silence errors
-        end
-
         sig { params(tree: RBI::Tree, name: String, constant: Module).void }
         def compile_methods(tree, name, constant)
           compile_method(
@@ -630,7 +535,15 @@ module Tapioca
             [type, name]
           end
 
-          rbi_method = RBI::Method.new(method_name, is_singleton: constant.singleton_class?, visibility: visibility)
+          separator = constant.singleton_class? ? "." : "#"
+          comments = documentation_comments("#{symbol_name}#{separator}#{method_name}")
+          rbi_method = RBI::Method.new(
+            method_name,
+            is_singleton: constant.singleton_class?,
+            visibility: visibility,
+            comments: comments
+          )
+
           rbi_method.sigs << compile_signature(signature, sanitized_parameters) if signature
 
           sanitized_parameters.each do |type, name|
@@ -710,8 +623,10 @@ module Tapioca
           SymbolLoader.ignore_symbol?(symbol_name)
         end
 
-        SPECIAL_METHOD_NAMES = ["!", "~", "+@", "**", "-@", "*", "/", "%", "+", "-", "<<", ">>", "&", "|", "^", "<",
-                                "<=", "=>", ">", ">=", "==", "===", "!=", "=~", "!~", "<=>", "[]", "[]=", "`"]
+        SPECIAL_METHOD_NAMES = T.let([
+          "!", "~", "+@", "**", "-@", "*", "/", "%", "+", "-", "<<", ">>", "&", "|", "^",
+          "<", "<=", "=>", ">", ">=", "==", "===", "!=", "=~", "!~", "<=>", "[]", "[]=", "`"
+        ], T::Array[String])
 
         sig { params(name: String).returns(T::Boolean) }
         def valid_method_name?(name)
@@ -770,6 +685,7 @@ module Tapioca
           @seen.include?(name)
         end
 
+        sig { params(constant: Module).returns(T.nilable(UnboundMethod)) }
         def initialize_method_for(constant)
           constant.instance_method(:initialize)
         rescue
@@ -840,6 +756,21 @@ module Tapioca
 
           name_of(target)
         end
+
+        sig { params(name: String).returns(T::Array[RBI::Comment]) }
+        def documentation_comments(name)
+          return [] unless @include_doc
+
+          yard_docs = YARD::Registry.at(name)
+          return [] unless yard_docs
+
+          docstring = yard_docs.docstring
+          return [] if /(copyright|license)/i.match?(docstring)
+
+          docstring.lines
+            .reject { |line| IGNORED_COMMENTS.any? { |comment| line.include?(comment) } }
+            .map! { |line| RBI::Comment.new(line) }
+        end
       end
     end
   end

data/lib/tapioca/compilers/symbol_table_compiler.rb

@@ -6,17 +6,11 @@ module Tapioca
     class SymbolTableCompiler
       extend(T::Sig)
 
-      sig do
-        params(
-          gem: Gemfile::GemSpec,
-          indent: Integer
-        ).returns(String)
-      end
-      def compile(
-        gem,
-        indent = 0
-      )
-        Tapioca::Compilers::SymbolTable::SymbolGenerator.new(gem, indent).generate
+      sig { params(gem: Gemfile::GemSpec, rbi: RBI::File, indent: Integer, include_docs: T::Boolean).void }
+      def compile(gem, rbi, indent = 0, include_docs = false)
+        Tapioca::Compilers::SymbolTable::SymbolGenerator
+          .new(gem, indent, include_docs)
+          .generate(rbi)
       end
     end
   end

data/lib/tapioca/config.rb

@@ -14,6 +14,7 @@ module Tapioca
     const(:todos_path, String)
     const(:generators, T::Array[String])
     const(:file_header, T::Boolean, default: true)
+    const(:doc, T::Boolean, default: false)
 
     sig { returns(Pathname) }
     def outpath

data/lib/tapioca/config_builder.rb

@@ -67,6 +67,7 @@ module Tapioca
       "todos_path" => Config::DEFAULT_TODOSPATH,
       "generators" => [],
       "file_header" => true,
+      "doc" => false,
     }.freeze, T::Hash[String, T.untyped])
   end
 end

data/lib/tapioca/gemfile.rb

@@ -2,6 +2,8 @@
 # frozen_string_literal: true
 
 require "bundler"
+require "logger"
+require "yard-sorbet"
 
 module Tapioca
   class Gemfile
@@ -9,10 +11,7 @@ module Tapioca
 
     Spec = T.type_alias do
       T.any(
-        T.all(
-          ::Bundler::StubSpecification,
-          ::Bundler::RemoteSpecification
-        ),
+        ::Bundler::StubSpecification,
         ::Gem::Specification
       )
     end
@@ -116,7 +115,9 @@ module Tapioca
       sig { returns(T::Array[Pathname]) }
       def files
         if default_gem?
-          @spec.files.map do |file|
+          # `Bundler::RemoteSpecification` delegates missing methods to
+          # `Gem::Specification`, so `files` actually always exists on spec.
+          T.unsafe(@spec).files.map do |file|
             ruby_lib_dir.join(file)
           end
         else
@@ -145,6 +146,11 @@ module Tapioca
         end
       end
 
+      sig { void }
+      def parse_yard_docs
+        files.each { |path| YARD.parse(path.to_s, [], Logger::Severity::FATAL) }
+      end
+
       private
 
       sig { returns(T::Boolean) }

data/lib/tapioca/generators/base.rb

@@ -0,0 +1,61 @@
+# typed: strict
+# frozen_string_literal: true
+
+# TODO: Remove me when logging logic has been abstracted.
+require "thor"
+
+module Tapioca
+  module Generators
+    class Base
+      extend T::Sig
+      extend T::Helpers
+
+      class FileWriter < Thor
+        include Thor::Actions
+      end
+
+      # TODO: Remove me when logging logic has been abstracted
+      include Thor::Base
+
+      abstract!
+
+      sig { params(default_command: String, file_writer: Thor::Actions).void }
+      def initialize(default_command:, file_writer: FileWriter.new)
+        @file_writer = file_writer
+        @default_command = default_command
+      end
+
+      sig { abstract.void }
+      def generate; end
+
+      private
+
+      # TODO: Remove me when logging logic has been abstracted
+      sig { params(message: String, color: T.any(Symbol, T::Array[Symbol])).void }
+      def say_error(message = "", *color)
+        force_new_line = (message.to_s !~ /( |\t)\Z/)
+        # NOTE: This is a hack. We're no longer subclassing from Thor::Shell::Color
+        # so we no longer have access to the prepare_message call.
+        # We should update this to remove this.
+        buffer = shell.send(:prepare_message, *T.unsafe([message, *T.unsafe(color)]))
+        buffer << "\n" if force_new_line && !message.to_s.end_with?("\n")
+
+        $stderr.print(buffer)
+        $stderr.flush
+      end
+
+      sig do
+        params(
+          path: T.any(String, Pathname),
+          content: String,
+          force: T::Boolean,
+          skip: T::Boolean,
+          verbose: T::Boolean
+        ).void
+      end
+      def create_file(path, content, force: true, skip: false, verbose: true)
+        @file_writer.create_file(path, force: force, skip: skip, verbose: verbose) { content }
+      end
+    end
+  end
+end