appmap 0.53.0 → 0.54.4

data/lib/appmap/config.rb

@@ -5,6 +5,7 @@ require 'appmap/util'
 require 'appmap/handler/net_http'
 require 'appmap/handler/rails/template'
 require 'appmap/service/guesser'
+require 'appmap/swagger/configuration'
 
 module AppMap
   class Config
@@ -81,8 +82,8 @@ module AppMap
           package_name: package_name,
           gem: gem,
           handler_class: handler_class.name,
-          exclude: exclude.blank? ? nil : exclude,
-          labels: labels.blank? ? nil : labels,
+          exclude: Util.blank?(exclude) ? nil : exclude,
+          labels: Util.blank?(labels) ? nil : labels,
           shallow: shallow
         }.compact
       end
@@ -226,15 +227,17 @@ module AppMap
       'JSON::Ext::Generator::State' => TargetMethods.new(:generate, Package.build_from_path('json', package_name: 'json', labels: %w[format.json.generate])),
     }.freeze
 
-    attr_reader :name, :appmap_dir, :packages, :exclude, :hooked_methods, :builtin_hooks
+    attr_reader :name, :appmap_dir, :packages, :exclude, :swagger_config, :hooked_methods, :builtin_hooks
 
     def initialize(name,
       packages: [],
+      swagger_config: Swagger::Configuration.new,
       exclude: [],
       functions: [])
       @name = name
       @appmap_dir = AppMap::DEFAULT_APPMAP_DIR
       @packages = packages
+      @swagger_config = swagger_config
       @hook_paths = Set.new(packages.map(&:path))
       @exclude = exclude
       @builtin_hooks = BUILTIN_HOOKS
@@ -351,6 +354,11 @@ module AppMap
             end
           end
 
+        if config_data['swagger']
+          swagger_config = Swagger::Configuration.load(config_data['swagger'])
+          config_params[:swagger_config] = swagger_config
+        end
+
         Config.new name, config_params
       end
     end

data/lib/appmap/handler/net_http.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'appmap/event'
+require 'appmap/util'
 
 module AppMap
   module Handler
@@ -38,7 +39,7 @@ module AppMap
             headers: headers
           }.compact
 
-          unless params.blank?
+          unless Util.blank?(params)
             h[:message] = params.keys.map do |key|
               val = params[key]
               {
@@ -81,7 +82,7 @@ module AppMap
         def request_headers(request)
           {}.tap do |headers|
             request.each_header do |k,v|
-              key = [ 'HTTP', k.underscore.upcase ].join('_')
+              key = [ 'HTTP', Util.underscore(k).upcase ].join('_')
               headers[key] = v
             end
           end

data/lib/appmap/handler/rails/request_handler.rb

@@ -2,6 +2,7 @@
 
 require 'appmap/event'
 require 'appmap/hook'
+require 'appmap/util'
 
 module AppMap
   module Handler
@@ -40,7 +41,7 @@ module AppMap
                 headers: headers,
               }.compact
 
-              unless params.blank?
+              unless Util.blank?(params)
                 h[:message] = params.keys.map do |key|
                   val = params[key]
                   {

data/lib/appmap/handler/rails/template.rb

@@ -146,7 +146,8 @@ module AppMap
         class RenderHandler
           class << self
             def handle_call(defined_class, hook_method, receiver, args)
-              context, options = args
+              # context, options
+              _, options = args
 
               warn "Renderer: #{options}" if LOG
 

data/lib/appmap/hook.rb

@@ -37,8 +37,6 @@ module AppMap
     def initialize(config)
       @config = config
       @trace_enabled = []
-      # Paths that are known to be non-tracing
-      @notrace_paths = Set.new
     end
 
     # Observe class loading and hook all methods which match the config.
@@ -47,6 +45,11 @@ module AppMap
 
       hook_builtins
 
+      # Paths that are known to be non-tracing.
+      @notrace_paths = Set.new
+      # Locations that have already been visited.
+      @trace_locations = Set.new
+
       @trace_end = TracePoint.new(:end, &method(:trace_end))
       @trace_end.enable(&block)
     end
@@ -100,7 +103,8 @@ module AppMap
 
     def trace_end(trace_point)
       location = trace_location(trace_point)
-      warn "Class or module ends at location #{trace_location(trace_point)}" if Hook::LOG || Hook::LOG_HOOK
+      warn "Class or module ends at location #{location}" if Hook::LOG || Hook::LOG_HOOK
+      return unless @trace_locations.add?(location)
 
       path = trace_point.path
       enabled = !@notrace_paths.member?(path) && config.path_enabled?(path)

data/lib/appmap/hook/method.rb

@@ -18,6 +18,8 @@ module AppMap
       TIME_NOW = Time.method(:now)
       private_constant :TIME_NOW
 
+      ARRAY_OF_EMPTY_HASH = [{}.freeze].freeze
+
       def initialize(hook_package, hook_class, hook_method)
         @hook_package = hook_package
         @hook_class = hook_class
@@ -45,42 +47,48 @@ module AppMap
         after_hook = self.method(:after_hook)
         with_disabled_hook = self.method(:with_disabled_hook)
 
-        hook_method_def = nil
-        hook_class.instance_eval do 
-          hook_method_def = Proc.new do |*args, &block|
-            instance_method = hook_method.bind(self).to_proc
-            call_instance_method = -> { instance_method.call(*args, &block) }
+        hook_method_def = Proc.new do |*args, &block|
+          instance_method = hook_method.bind(self).to_proc
+          call_instance_method = -> {
+            # https://github.com/applandinc/appmap-ruby/issues/153
+            if Util.ruby_minor_version >= 2.7 && args == ARRAY_OF_EMPTY_HASH && hook_method.arity == 1
+              instance_method.call({}, &block)
+            else
+              instance_method.call(*args, &block)
+            end
+          }
 
-            # We may not have gotten the class for the method during
-            # initialization (e.g. for a singleton method on an embedded
-            # struct), so make sure we have it now.
-            defined_class, = Hook.qualify_method_name(hook_method) unless defined_class
+          # We may not have gotten the class for the method during
+          # initialization (e.g. for a singleton method on an embedded
+          # struct), so make sure we have it now.
+          defined_class, = Hook.qualify_method_name(hook_method) unless defined_class
 
-            reentrant = Thread.current[HOOK_DISABLE_KEY]
-            disabled_by_shallow_flag = \
-              -> { hook_package&.shallow? && AppMap.tracing.last_package_for_current_thread == hook_package }
+          reentrant = Thread.current[HOOK_DISABLE_KEY]
+          disabled_by_shallow_flag = \
+            -> { hook_package&.shallow? && AppMap.tracing.last_package_for_current_thread == hook_package }
 
-            enabled = true if AppMap.tracing.enabled? && !reentrant && !disabled_by_shallow_flag.call
+          enabled = true if AppMap.tracing.enabled? && !reentrant && !disabled_by_shallow_flag.call
 
-            return call_instance_method.call unless enabled
+          return call_instance_method.call unless enabled
 
-            call_event, start_time = with_disabled_hook.call do
-              before_hook.call(self, defined_class, args)
-            end
-            return_value = nil
-            exception = nil
-            begin
-              return_value = call_instance_method.call
-            rescue
-              exception = $ERROR_INFO
-              raise
-            ensure
-              with_disabled_hook.call do
-                after_hook.call(self, call_event, start_time, return_value, exception) if call_event
-              end
+          call_event, start_time = with_disabled_hook.call do
+            before_hook.call(self, defined_class, args)
+          end
+          return_value = nil
+          exception = nil
+          begin
+            return_value = call_instance_method.call
+          rescue
+            exception = $ERROR_INFO
+            raise
+          ensure
+            with_disabled_hook.call do
+              after_hook.call(self, call_event, start_time, return_value, exception) if call_event
             end
           end
         end
+        hook_method_def = hook_method_def.ruby2_keywords if hook_method_def.respond_to?(:ruby2_keywords)
+
         hook_class.define_method_with_arity(hook_method.name, hook_method.arity, hook_method_def)
       end
 

data/lib/appmap/metadata.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'appmap/util'
+
 module AppMap
   module Metadata
     class << self
@@ -40,9 +42,9 @@ module AppMap
         git_sha = `git rev-parse HEAD`.strip
         git_status = `git status -s`.split("\n").map(&:strip)
         git_last_annotated_tag = `git describe --abbrev=0 2>/dev/null`.strip
-        git_last_annotated_tag = nil if git_last_annotated_tag.blank?
+        git_last_annotated_tag = nil if Util.blank?(git_last_annotated_tag)
         git_last_tag = `git describe --abbrev=0 --tags 2>/dev/null`.strip
-        git_last_tag = nil if git_last_tag.blank?
+        git_last_tag = nil if Util.blank?(git_last_tag)
         git_commits_since_last_annotated_tag = `git describe`.strip =~ /-(\d+)-(\w+)$/[1] rescue 0 if git_last_annotated_tag
         git_commits_since_last_tag = `git describe --tags`.strip =~ /-(\d+)-(\w+)$/[1] rescue 0 if git_last_tag
 

data/lib/appmap/minitest.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'appmap/util'
+require 'active_support'
+require 'active_support/core_ext'
 
 module AppMap
   # Integration of AppMap with Minitest. When enabled with APPMAP=true, the AppMap tracer will

data/lib/appmap/railtie.rb

@@ -5,8 +5,8 @@ module AppMap
   class Railtie < ::Rails::Railtie
     initializer 'appmap.remote_recording' do
       require 'appmap/middleware/remote_recording'
-      Rails.application.config.middleware.insert_after \
-        Rails::Rack::Logger,
+      Rails.application.config.middleware.insert_before \
+        ActionDispatch::Executor,
         AppMap::Middleware::RemoteRecording
     end
 

data/lib/appmap/rspec.rb

@@ -62,8 +62,10 @@ module AppMap
         example_group_parent = \
           if example_group.respond_to?(:module_parent)
             example_group.module_parent
-          else
+          elsif example_group.respond_to?(:parent)
             example_group.parent
+          elsif example_group.respond_to?(:parent_groups)
+            example_group.parent_groups.first
           end
 
         example_group_parent != example_group ? ScopeExampleGroup.new(example_group_parent) : nil
@@ -109,13 +111,13 @@ module AppMap
 
         description = []
         scope = ScopeExample.new(example)
-
         while scope
           description << scope.description
           scope = scope.parent
         end
 
-        description.reject!(&:nil?).reject!(&:blank?)
+        description.reject!(&:nil?)
+        description.reject!(&Util.method(:blank?))
         default_description = description.last
         description.reverse!
 

data/lib/appmap/swagger.rb

@@ -0,0 +1,2 @@
+require 'appmap/swagger/configuration'
+require 'appmap/swagger/rake_tasks'

data/lib/appmap/swagger/configuration.rb

@@ -0,0 +1,70 @@
+require 'yaml'
+
+module AppMap
+  module Swagger
+    class Configuration
+      DEFAULT_VERSION = '1.0'
+      DEFAULT_OUTPUT_DIR = 'swagger'
+      DEFAULT_DESCRIPTION = 'Generate Swagger from AppMaps'
+
+      attr_accessor :project_version,
+        :output_dir,
+        :description
+      attr_writer :project_name, :template
+
+      class << self
+        def load(config_data)
+          Configuration.new.tap do |config|
+            config_data.each do |k,v|
+              config.send "#{k}=", v
+            end
+          end
+        end
+      end
+
+      def initialize
+        @project_name = nil
+        @project_version = DEFAULT_VERSION
+        @output_dir = DEFAULT_OUTPUT_DIR
+        @description = DEFAULT_DESCRIPTION
+      end
+
+      def project_name
+        @project_name || default_project_name
+      end
+
+      def template
+        @template || default_template
+      end
+
+      def default_template
+        YAML.load <<~TEMPLATE
+          openapi: 3.0.1
+          info:
+            title: #{project_name}
+            version: #{project_version}
+          paths:
+          components:
+          servers:
+          - url: http://{defaultHost}
+            variables:
+              defaultHost:
+                default: localhost:3000
+          TEMPLATE
+      end
+
+      def default_project_name
+        # https://www.rubydoc.info/docs/rails/Module#module_parent_name-instance_method
+        module_parent_name = ->(cls) { cls.name =~ /::[^:]+\Z/ ? $`.freeze : nil }
+
+        # Lazy-evaluate this so that Rails.application will be defined.
+        # If this code runs too early in the lifecycle, Rails.application is nil.
+        if defined?(::Rails)
+          [module_parent_name.(::Rails.application.class).humanize.titleize, "API"].join(" ")
+        else
+          "MyProject API"
+        end
+      end
+    end
+  end
+end

data/lib/appmap/swagger/markdown_descriptions.rb

@@ -0,0 +1,43 @@
+require 'rdoc'
+require 'reverse_markdown'
+
+module AppMap
+  module Swagger
+    # Transform description fields into Markdown.
+    class MarkdownDescriptions
+      def initialize(swagger_yaml)
+        @swagger_yaml = swagger_yaml
+      end
+
+      def converter
+        method(:rdoc_to_markdown)
+      end
+
+      def perform
+        to_markdown = lambda do |obj|
+          return obj.each(&to_markdown) if obj.is_a?(Array)
+          return unless obj.is_a?(Hash)
+
+          description = obj['description']
+          obj['description'] = converter.(description) if description
+
+          obj.reject { |k,v| k == 'properties' }.each_value(&to_markdown)
+
+          obj
+        end
+
+        to_markdown.(Util.deep_dup(@swagger_yaml))
+      end
+
+      protected
+
+      def rdoc_to_markdown(comment)
+        # Strip tags
+        comment = comment.split("\n").reject { |line| line =~ /^\s*@/ }.join("\n")
+        converter = ::RDoc::Markup::ToHtml.new(::RDoc::Options.new)
+        html = converter.convert(comment).strip
+        ::ReverseMarkdown.convert(html).strip
+      end
+    end
+  end
+end

data/lib/appmap/swagger/rake_tasks.rb

@@ -0,0 +1,43 @@
+require 'rake'
+require 'yaml'
+require 'appmap/node_cli'
+require 'appmap/swagger/markdown_descriptions'
+require 'appmap/swagger/stable'
+
+module AppMap
+  module Swagger
+    module RakeTasks
+      extend self
+      extend Rake::DSL
+
+      def configuration
+        AppMap.configuration
+      end
+
+      def define_tasks
+        generate_swagger = lambda do |t, args|
+          appmap_js = AppMap::NodeCLI.new(verbose: Rake.verbose == true)
+
+          FileUtils.mkdir_p configuration.swagger_config.output_dir
+
+          cmd = %w[swagger]
+  
+          swagger_raw, = appmap_js.command(cmd)
+
+          gen_swagger = YAML.load(swagger_raw)
+          gen_swagger_full = AppMap::Swagger::MarkdownDescriptions.new(gen_swagger).perform
+          gen_swagger_stable = AppMap::Swagger::Stable.new(gen_swagger).perform
+  
+          swagger = configuration.swagger_config.template.merge(gen_swagger_full)
+          File.write File.join(configuration.swagger_config.output_dir, 'openapi.yaml'), YAML.dump(swagger)
+  
+          swagger = configuration.swagger_config.template.merge(gen_swagger_stable)
+          File.write File.join(configuration.swagger_config.output_dir, 'openapi_stable.yaml'), YAML.dump(swagger)  
+        end
+
+        desc configuration.swagger_config.description
+        task :swagger, &generate_swagger
+      end
+    end
+  end
+end