appmap 0.49.0 → 0.51.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '02814a0f9d0927d19c2d341a22d8f8ec66b83bc022833a09a7777ce81ec4edfc'
-  data.tar.gz: 11b2786d88e360fc78e046675ae799e7106625dd02b4a3070c3835bfe8feea05
+  metadata.gz: 5de4c6db2c2be91ba2d0c844ef4fbed14ea1b65b10abde9ef99ccbe50cd96639
+  data.tar.gz: 7b51407f7b49e3aa492b85fa439a55f593e0a2b772796bba0ccbd18bb4188149
 SHA512:
-  metadata.gz: c852ae464d52f9f29ef9222fa1627f99b4f5baf1907b1cd54cbfb969ff2323cb19e0d5b53bad1356518ec21a07243ea71237ad831a62ffe825a2601cca1a5cf7
-  data.tar.gz: 49c5ba0d0c20d8bee6e4c768544ab6abe0f0f0d71a1a59bc04fcf867e93bc743eda4cc94f7505c0a1194c07e95e2b8e7f875a42b16aa3da2a21068a61ba42a10
+  metadata.gz: 13662be867000e4239ed4f8587d0108d0af04b63d7727d51c3f9fa16b7284e233a590ffad301375d97d6155289c17c267eb0b8003899b8489f5afa11fd296d70
+  data.tar.gz: 228adedfd313b54d6b6b4f03c143d94366c8815d0daac8793d70f2e8da909712504f371f5c13f43a22d647828e4d8bb83f1dfb5c023149f8380816b8df0a8819

data/CHANGELOG.md

@@ -1,3 +1,48 @@
+## [0.51.3](https://github.com/applandinc/appmap-ruby/compare/v0.51.2...v0.51.3) (2021-06-22)
+
+
+### Bug Fixes
+
+* Remove outdate lore, command, and algorithm code ([d899989](https://github.com/applandinc/appmap-ruby/commit/d8999896c611c16f51a092f5f7afb3d7203d7e72))
+
+## [0.51.2](https://github.com/applandinc/appmap-ruby/compare/v0.51.1...v0.51.2) (2021-06-22)
+
+
+### Bug Fixes
+
+* Be less verbose when logging config messages ([fba2fd0](https://github.com/applandinc/appmap-ruby/commit/fba2fd01dbb7b1830194b49285654d6657d1c786))
+* Method objects must support eql? and hash to ensure they are unique in a Set ([f4d5b11](https://github.com/applandinc/appmap-ruby/commit/f4d5b11db90aa50bdd1f768e039927833e83c30f))
+* Require rails, then appmap/railtie ([07967a1](https://github.com/applandinc/appmap-ruby/commit/07967a14609891544a7dd874c648b7ef5a505f21))
+* Use a hybrid strategy to auto-requiring appmap modules ([6fb09b8](https://github.com/applandinc/appmap-ruby/commit/6fb09b8c0bd55b1e29967d459ce1e2bd5b1ba9fe))
+
+## [0.51.1](https://github.com/applandinc/appmap-ruby/compare/v0.51.0...v0.51.1) (2021-06-21)
+
+
+### Bug Fixes
+
+* Add missing require 'yaml' ([1187a02](https://github.com/applandinc/appmap-ruby/commit/1187a023243caaab8cd48de5cbbddefa361636ad))
+
+# [0.51.0](https://github.com/applandinc/appmap-ruby/compare/v0.50.0...v0.51.0) (2021-06-21)
+
+
+### Features
+
+* Provide default appmap.yml settings ([7fa8159](https://github.com/applandinc/appmap-ruby/commit/7fa8159b5020e35f13379017b44906d671e62e64))
+
+# [0.50.0](https://github.com/applandinc/appmap-ruby/compare/v0.49.0...v0.50.0) (2021-06-17)
+
+
+### Bug Fixes
+
+* Remove appmap configuration in test cases which now occurs automatically ([7391c4c](https://github.com/applandinc/appmap-ruby/commit/7391c4c36ed80f98a6b82ccd43f05de488e7cd2f))
+
+
+### Features
+
+* Direct minitest and rspec startup messages to the Rails log, when available ([15f6444](https://github.com/applandinc/appmap-ruby/commit/15f6444b0fad3ce7d9e91273b6a1116e470c2a89))
+* Enroll railtie, rspec, and minitest helpers automatically ([1709374](https://github.com/applandinc/appmap-ruby/commit/1709374ee7b5183482c55cf4c7386266fa517262))
+* railtie enrolls the app in remote recording ([3a1f8aa](https://github.com/applandinc/appmap-ruby/commit/3a1f8aac1d83c4df04b5da55ed33d418235e348b))
+
 # [0.49.0](https://github.com/applandinc/appmap-ruby/compare/v0.48.2...v0.49.0) (2021-06-16)
 
 

data/appmap.gemspec

@@ -22,6 +22,9 @@ Gem::Specification.new do |spec|
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
   spec.files         = `git ls-files --no-deleted`.split("
 ")
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+
   spec.extensions << "ext/appmap/extconf.rb"
 
   spec.require_paths = ['lib']

data/exe/appmap-agent-setup

@@ -0,0 +1,47 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'gli'
+
+require 'appmap'
+
+class App
+  extend GLI::App
+
+  program_desc 'CLI tool to be used by IDEs for AppMap setup and configuration'
+
+  version AppMap::VERSION
+
+  subcommand_option_handling :normal
+  arguments :strict
+  preserve_argv true
+
+  desc 'AppMap configuration file name'
+  default_value ENV['APPMAP_CONFIG'] || AppMap::DEFAULT_CONFIG_FILE_PATH
+  arg_name 'filename'
+  flag %i[c config]
+
+  desc 'Creates base configuration file for the current project'
+  command :init do |c|
+    c.action do
+      require 'appmap/command/init'
+      AppMap::Command::Init.new(@config_file).perform
+    end
+  end
+
+  pre do |global, _, _, _|
+    @config_file = global[:config]
+    @config = interpret_config_option(@config_file) if File.exist?(@config_file)
+    true
+  end
+
+  class << self
+    protected
+
+    def interpret_config_option(fname)
+      AppMap::Config.load_from_file fname
+    end
+  end
+end
+
+exit App.run(ARGV)

data/lib/appmap.rb

@@ -27,7 +27,7 @@ module AppMap
     # Gets the configuration. If there is no configuration, the default
     # configuration is initialized.
     def configuration
-      @configuration ||= initialize
+      @configuration ||= initialize_configuration
     end
 
     # Sets the configuration. This is only expected to happen once per
@@ -38,19 +38,34 @@ module AppMap
       @configuration = config
     end
 
-    # Configures AppMap for recording. Default behavior is to configure from "appmap.yml".
+    def default_config_file_path
+      ENV['APPMAP_CONFIG_FILE'] || 'appmap.yml'
+    end
+
+    # Configures AppMap for recording. Default behavior is to configure from
+    # APPMAP_CONFIG_FILE, or 'appmap.yml'. If no config file is available, a
+    # configuration will be automatically generated and used - and the user is prompted
+    # to create the config file.
+    #
     # This method also activates the code hooks which record function calls as trace events.
     # Call this function before the program code is loaded by the Ruby VM, otherwise
     # the load events won't be seen and the hooks won't activate.
-    def initialize(config_file_path = 'appmap.yml')
-      raise "AppMap configuration file #{config_file_path} does not exist" unless ::File.exists?(config_file_path)
-      warn "Configuring AppMap from path #{config_file_path}"
+    def initialize_configuration(config_file_path = default_config_file_path)
+      startup_message "Configuring AppMap from path #{config_file_path}"
       Config.load_from_file(config_file_path).tap do |configuration|
         self.configuration = configuration
         Hook.new(configuration).enable
       end
     end
 
+    def info(msg)
+      if defined?(::Rails) && defined?(::Rails.logger)
+        ::Rails.logger.info msg
+      else
+        warn msg
+      end
+    end
+
     # Used to start tracing, stop tracing, and record events.
     def tracing
       @tracing ||= Trace::Tracing.new
@@ -94,8 +109,60 @@ module AppMap
       @metadata ||= Metadata.detect.freeze
       @metadata.deep_dup
     end
+
+    def startup_message(msg)
+      if defined?(::Rails) && defined?(::Rails.logger) && ::Rails.logger
+        ::Rails.logger.debug msg
+      elsif ENV['DEBUG'] == 'true'
+        warn msg
+      end
+    end
   end
 end
 
-require 'appmap/railtie' if defined?(::Rails::Railtie)
-AppMap.initialize if ENV['APPMAP'] == 'true'
+lambda do
+  Initializer = Struct.new(:class_name, :module_name, :gem_module_name)
+
+  INITIALIZERS = {
+    'Rails::Railtie' => Initializer.new('AppMap::Railtie', 'appmap/railtie', 'railtie'),
+    'RSpec' => Initializer.new('AppMap::RSpec', 'appmap/rspec', 'rspec-core'),
+    'Minitest::Unit::TestCase' => Initializer.new('AppMap::Minitest', 'appmap/minitest', 'minitest')
+  }
+
+  TracePoint.new(:class) do |tp|
+    cls_name = tp.self.name
+    initializers = INITIALIZERS.delete(cls_name)
+    if initializers
+      initializers = [ initializers ] unless initializers.is_a?(Array)
+      next if Object.const_defined?(initializers.first.class_name)
+
+      gem_module_name = initializers.first.gem_module_name
+
+      AppMap.startup_message AppMap::Util.color(<<~LOAD_MSG, :magenta)
+      When 'appmap' was loaded, '#{gem_module_name}' had not been loaded yet. Now '#{gem_module_name}' has
+      just been loaded, so the following AppMap modules will be automatically required:
+
+      #{initializers.map(&:module_name).join("\n")}
+
+      To suppress this message, ensure '#{gem_module_name}' appears before 'appmap' in your Gemfile.
+      LOAD_MSG
+      initializers.each do |init|
+        require init.module_name
+      end
+    end
+  end.enable
+
+  if defined?(::Rails::Railtie)
+    require 'appmap/railtie'
+  end
+  
+  if defined?(::RSpec)
+    require 'appmap/rspec'
+  end
+  
+  if defined?(::Minitest)
+    require 'appmap/minitest'
+  end
+end.call
+
+AppMap.initialize_configuration if ENV['APPMAP'] == 'true'

data/lib/appmap/command/init.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'appmap/service/guesser'
+require 'appmap/util'
+
+module AppMap
+  module Command
+    InitStruct = Struct.new(:config_file)
+
+    class Init < InitStruct
+      def perform
+        if File.exist?(config_file)
+          puts AppMap::Util.color(%(The AppMap config file #{config_file} already exists.), :magenta)
+          return
+        end
+
+        ensure_directory_exists
+
+        config = {
+          'name' => Service::Guesser.guess_name,
+          'packages' => Service::Guesser.guess_paths.map { |path| { 'path' => path } }
+        }
+        content = YAML.dump(config).gsub("---\n", '')
+
+        File.write(config_file, content)
+        puts AppMap::Util.color(
+          %(The following AppMap config file #{config_file} has been created:),
+          :green
+        )
+        puts content
+      end
+
+      private
+
+      def ensure_directory_exists
+        dirname = File.dirname(config_file)
+        FileUtils.mkdir_p(dirname) unless File.directory?(dirname)
+      end
+    end
+  end
+end

data/lib/appmap/config.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
+require 'yaml'
 require 'appmap/handler/net_http'
 require 'appmap/handler/rails/template'
+require 'appmap/service/guesser'
 
 module AppMap
   class Config
@@ -223,10 +225,14 @@ 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, :packages, :exclude, :hooked_methods, :builtin_hooks
+    attr_reader :name, :appmap_dir, :packages, :exclude, :hooked_methods, :builtin_hooks
 
-    def initialize(name, packages, exclude: [], functions: [])
+    def initialize(name,
+      packages: [],
+      exclude: [],
+      functions: [])
       @name = name
+      @appmap_dir = AppMap::DEFAULT_APPMAP_DIR
       @packages = packages
       @hook_paths = Set.new(packages.map(&:path))
       @exclude = exclude
@@ -253,38 +259,98 @@ module AppMap
     class << self
       # Loads configuration data from a file, specified by the file name.
       def load_from_file(config_file_name)
-        require 'yaml'
-        load YAML.safe_load(::File.read(config_file_name))
+        logo = lambda do
+          Util.color(<<~LOGO, :magenta)
+             ___             __  ___
+            / _ | ___  ___  /  |/  /__ ____
+           / __ |/ _ \\/ _ \\/ /|_/ / _ `/ _ \\
+          /_/ |_/ .__/ .__/_/  /_/\\_,_/ .__/
+               /_/  /_/              /_/
+          LOGO
+        end
+
+        config_present = true if File.exists?(config_file_name)
+
+        config_data = if config_present
+          YAML.safe_load(::File.read(config_file_name))
+        else
+          warn logo.()
+          warn ''
+          warn Util.color(%Q|NOTICE: The AppMap config file #{config_file_name} was not found!|, :magenta, bold: true)
+          warn ''
+          warn Util.color(<<~MISSING_FILE_MSG, :magenta)
+          AppMap uses this file to customize its behavior. For example, you can use
+          the 'packages' setting to indicate which local file paths and dependency
+          gems you want to include in the AppMap. Since you haven't provided specific
+          settings, the appmap gem will try and guess some reasonable defaults.
+          To suppress this message, create the file:
+          
+          #{Pathname.new(config_file_name).expand_path}
+          
+          Here are the default settings that will be used in the meantime. You can
+          copy and paste this example to start your appmap.yml.
+          MISSING_FILE_MSG
+          {}
+        end
+        load(config_data).tap do |config|
+          config_yaml = {
+            'name' => config.name,
+            'packages' => config.packages.select{|p| p.path}.map do |pkg|
+              { 'path' => pkg.path }
+            end,
+            'exclude' => []
+          }.compact
+          unless config_present
+            warn Util.color(YAML.dump(config_yaml), :magenta)
+            warn logo.()
+          end
+        end
       end
 
       # Loads configuration from a Hash.
       def load(config_data)
-        functions = (config_data['functions'] || []).map do |function_data|
-          package = function_data['package']
-          cls = function_data['class']
-          functions = function_data['function'] || function_data['functions']
-          raise 'AppMap class configuration should specify package, class and function(s)' unless package && cls && functions
-          functions = Array(functions).map(&:to_sym)
-          labels = function_data['label'] || function_data['labels']
-          labels = Array(labels).map(&:to_s) if labels
-          Function.new(package, cls, labels, functions)
+        name = config_data['name'] || Service::Guesser.guess_name
+        config_params = {
+          exclude: config_data['exclude']
+        }.compact
+
+        if config_data['functions']
+          config_params[:functions] = config_data['functions'].map do |function_data|
+            package = function_data['package']
+            cls = function_data['class']
+            functions = function_data['function'] || function_data['functions']
+            raise %q(AppMap config 'function' element should specify 'package', 'class' and 'function' or 'functions') unless package && cls && functions
+
+            functions = Array(functions).map(&:to_sym)
+            labels = function_data['label'] || function_data['labels']
+            labels = Array(labels).map(&:to_s) if labels
+            Function.new(package, cls, labels, functions)
+          end
         end
-        packages = (config_data['packages'] || []).map do |package|
-          gem = package['gem']
-          path = package['path']
-          raise 'AppMap package configuration should specify gem or path, not both' if gem && path
-
-          if gem
-            shallow = package['shallow']
-            # shallow is true by default for gems
-            shallow = true if shallow.nil?
-            Package.build_from_gem(gem, exclude: package['exclude'] || [], shallow: shallow)
+
+        config_params[:packages] = \
+          if config_data['packages']
+            config_data['packages'].map do |package|
+              gem = package['gem']
+              path = package['path']
+              raise %q(AppMap config 'package' element should specify 'gem' or 'path', not both) if gem && path
+
+              if gem
+                shallow = package['shallow']
+                # shallow is true by default for gems
+                shallow = true if shallow.nil?
+                Package.build_from_gem(gem, exclude: package['exclude'] || [], shallow: shallow)
+              else
+                Package.build_from_path(path, exclude: package['exclude'] || [], shallow: package['shallow'])
+              end
+            end.compact
           else
-            Package.build_from_path(path, exclude: package['exclude'] || [], shallow: package['shallow'])
+            Array(Service::Guesser.guess_paths).map do |path|
+              Package.build_from_path(path)
+            end
           end
-        end.compact
-        exclude = config_data['exclude'] || []
-        Config.new config_data['name'], packages, exclude: exclude, functions: functions
+
+        Config.new name, config_params
       end
     end
 
@@ -294,7 +360,7 @@ module AppMap
         packages: packages.map(&:to_h),
         functions: @functions.map(&:to_h),
         exclude: exclude
-      }
+      }.compact
     end
 
     # Determines if methods defined in a file path should possibly be hooked.

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

@@ -14,16 +14,30 @@ module AppMap
         # The class name is generated from the template path. The package name is
         # 'app/views', and the method name is 'render'. The source location of the method
         # is, of course, the path to the view template.
-        TemplateMethod = Struct.new(:path) do
-          private_instance_methods :path
+        class TemplateMethod
           attr_reader :class_name
- 
+
+          attr_reader :path
+          private_instance_methods :path
+
           def initialize(path)
-            super
+            @path = path
 
             @class_name = path.parameterize.underscore
           end
-  
+
+          def id
+            [ package, path, name ]
+          end
+
+          def hash
+            id.hash
+          end
+
+          def eql?(other)
+            other.is_a?(TemplateMethod) && id.eql?(other.id)
+          end
+
           def package
             'app/views'
           end