appmap 0.31.0

data/Rakefile

@@ -0,0 +1,132 @@
+require 'appmap/version'
+GEM_VERSION = AppMap::VERSION
+
+require 'rake/testtask'
+require 'rdoc/task'
+
+require 'open3'
+
+namespace 'gem' do
+  require 'bundler/gem_tasks'
+end
+
+RUBY_VERSIONS=%w[2.5 2.6]
+FIXTURE_APPS=%w[rack_users_app rails_users_app rails4_users_app]
+
+def run_cmd(*cmd)
+  $stderr.puts "Running: #{cmd}"
+  out,s = Open3.capture2e(*cmd)
+  unless s.success?
+    $stderr.puts <<-END
+      Command failed:
+      <<< Output:
+      #{out}
+      >>> End of output
+    END
+    raise 'Docker build failed'
+  end
+end
+  
+def build_base_image(ruby_version)
+  run_cmd "docker build" \
+         " --build-arg RUBY_VERSION=#{ruby_version} --build-arg GEM_VERSION=#{GEM_VERSION}" \
+         " -t appmap:#{GEM_VERSION} -f Dockerfile.appmap ."
+end
+  
+def build_app_image(app, ruby_version)
+  Dir.chdir "spec/fixtures/#{app}" do
+    run_cmd( {"RUBY_VERSION" => ruby_version, "GEM_VERSION" => GEM_VERSION},
+      " docker-compose build" \
+      " --build-arg RUBY_VERSION=#{ruby_version}" \
+      " --build-arg GEM_VERSION=#{GEM_VERSION}")
+  end
+end
+
+namespace :build do
+  namespace :base do
+    RUBY_VERSIONS.each do |ruby_version|
+      desc ruby_version
+      task ruby_version => ["gem:build"] do
+        build_base_image(ruby_version)
+      end.tap do |t|
+        desc "Build all images"
+        task all: t
+      end
+    end
+  end
+
+  namespace :fixtures do
+    RUBY_VERSIONS.each do |ruby_version|
+      namespace ruby_version do
+        desc "build:fixtures:#{ruby_version}"
+        FIXTURE_APPS.each do |app|
+          desc app
+          task app => ["base:#{ruby_version}"] do
+            build_app_image(app, ruby_version)
+          end.tap do |t|
+            desc "Build all fixture images for #{ruby_version}"
+            task all: t
+          end
+        end
+      end
+
+      desc "Build all fixture images"
+      task all: ["#{ruby_version}:all"]
+    end
+  end
+
+  task all: ["fixtures:all"]
+end
+
+def run_specs(ruby_version, task_args)
+  require 'rspec/core/rake_task'
+  require 'climate_control'
+  # Define an rspec rake task for the specified Ruby version. It's hidden (i.e. doesn't have a
+  # description), because it's not intended to be invoked directly
+  RSpec::Core::RakeTask.new("rspec_#{ruby_version}", [:specs]) do |task, args|
+    task.exclude_pattern = 'spec/fixtures/**/*_spec.rb'
+    if args.count > 0
+      # There doesn't appear to be a value for +pattern+ that will
+      # cause it to be ignored. Setting it to '' or +nil+ causes an
+      # empty argument to get passed to rspec, which confuses it.
+      task.pattern = 'never match this'
+      task.rspec_opts = args.to_a.join(' ')
+    end
+  end
+
+  # Set up the environment, then execute the rspec task we
+  # created above.
+  ClimateControl.modify(RUBY_VERSION: ruby_version) do
+    Rake::Task["rspec_#{ruby_version}"].execute(task_args)
+  end
+end
+
+namespace :spec do
+  RUBY_VERSIONS.each do |ruby_version|
+    desc ruby_version
+    task ruby_version, [:specs] => ["build:fixtures:#{ruby_version}:all"] do |_, task_args|
+      run_specs(ruby_version, task_args)
+    end.tap do|t|
+      desc "Run all specs"
+      task :all, [:specs] => t
+    end
+  end
+end
+
+Rake::RDocTask.new do |rd|
+  rd.main = 'README.rdoc'
+  rd.rdoc_files.include(%w[README.rdoc lib/**/*.rb exe/**/*])
+  rd.title = 'AppMap'
+end
+
+Rake::TestTask.new(:minitest) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/*_test.rb']
+end
+
+task spec: "spec:all"
+
+task test: %i[spec:all minitest]
+
+task default: :test

data/appmap.gemspec

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'appmap/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'appmap'
+  spec.version       = AppMap::VERSION
+  spec.authors       = ['Kevin Gilpin']
+  spec.email         = ['kgilpin@gmail.com']
+
+  spec.summary       = %q{Record the operation of a Ruby program, using the AppLand 'AppMap' format.}
+  spec.homepage      = AppMap::URL
+  spec.license       = 'MIT'
+
+  # Specify which files should be added to the gem when it is released.
+  # 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.require_paths = ['lib']
+
+  spec.add_dependency 'activesupport'
+  spec.add_dependency 'faraday'
+  spec.add_dependency 'gli'
+  spec.add_dependency 'parser'
+
+  spec.add_development_dependency 'bundler', '~> 1.16'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency 'rake', '>= 12.3.3'
+  spec.add_development_dependency 'rdoc'
+  spec.add_development_dependency 'rubocop'
+
+  # Testing
+  spec.add_development_dependency 'climate_control'
+  spec.add_development_dependency 'diffy'
+  spec.add_development_dependency 'launchy'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'selenium-webdriver'
+  spec.add_development_dependency 'webdrivers', '~> 4.0'
+end

data/appmap.yml

@@ -0,0 +1,8 @@
+name: AppMap Rubygem
+packages:
+  - path: lib/appmap
+    exclude:
+      - server
+      - trace
+
+  - path: examples

data/examples/install.rb

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.join(__dir__)
+require 'fileutils'
+
+module Command
+  def run_command command
+    `#{command}`.tap do |_|
+      raise "Command failed: #{command}" unless $? == 0
+    end
+  end
+end
+
+class InProjectDirectory
+  attr_reader :project_dir
+
+  def initialize
+    @project_dir = File.expand_path('../tmp/install', __dir__)
+  end
+
+  def perform(&block)
+    FileUtils.rm_rf project_dir
+    FileUtils.mkdir_p project_dir
+    Dir.chdir project_dir, &block
+  end
+end
+
+class InstallExampleCode
+  def perform
+    FileUtils.cp_r File.join(__dir__, 'mock_webapp'), '.'
+  end
+end
+
+class InExampleDirectory
+  def perform(&block)
+    Dir.chdir 'mock_webapp', &block
+  end
+end
+
+class InstallAppmapGem
+  include Command
+
+  def perform
+    run_command 'bundle --local > /dev/null'
+  end
+end
+
+class InspectExampleProject
+  include Command
+
+  def perform
+    FileUtils.mkdir_p '.appmap'
+    run_command "bundle exec #{File.expand_path('../exe/appmap', __dir__)} inspect -o appmap.json"
+  end
+end
+
+class PrintInventory
+  def initialize(inventory)
+    @inventory = inventory
+  end
+
+  def perform
+    puts @inventory
+  end
+end
+
+InProjectDirectory.new.perform do
+  InstallExampleCode.new.perform
+  InExampleDirectory.new.perform do
+    InstallAppmapGem.new.perform
+
+    inventory = InspectExampleProject.new.perform
+    PrintInventory.new(inventory).perform
+  end
+end
+

data/examples/mock_webapp/Gemfile

@@ -0,0 +1 @@
+gem 'appmap', git: '../..', branch: `git rev-parse --abbrev-ref HEAD`.strip

data/examples/mock_webapp/appmap.yml

@@ -0,0 +1,2 @@
+packages:
+  - path: lib

data/examples/mock_webapp/exe/mock_webapp_request

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.join(__dir__, '..', 'lib')
+
+require 'json'
+require 'mock_webapp/user'
+require 'mock_webapp/request'
+require 'mock_webapp/controller'
+
+include MockWebapp
+
+puts JSON.pretty_generate Controller.instance.process(Request.new(id: 'alice'))

data/examples/mock_webapp/lib/mock_webapp/controller.rb

@@ -0,0 +1,23 @@
+module MockWebapp
+  # Mock controller.
+  # @appmap
+  class Controller
+    @controller = nil
+
+    class << self
+      # Singleton factory method.
+      #
+      # @appmap
+      def instance
+        @controller ||= Controller.new
+      end
+    end
+
+    # @appmap
+    def process(request)
+      id = request.params[:id]
+      user = User.find(id)
+      user.to_h
+    end
+  end
+end

data/examples/mock_webapp/lib/mock_webapp/request.rb

@@ -0,0 +1,12 @@
+module MockWebapp
+  RequestStruct = Struct.new(:params)
+
+  # Mock request.
+  # @appmap
+  class Request < RequestStruct
+    # @appmap
+    def initialize(*args)
+      super
+    end
+  end
+end

data/examples/mock_webapp/lib/mock_webapp/user.rb

@@ -0,0 +1,18 @@
+module MockWebapp
+  UserStruct = Struct.new(:login)
+
+  # Mock model object.
+  # @appmap
+  class User < UserStruct
+    USERS = {
+      'alice' => User.new('alice')
+    }.freeze
+
+    class << self
+      # @appmap
+      def find(id)
+        USERS[id] || raise("No such user #{id}")
+      end
+    end
+  end
+end

data/exe/appmap

@@ -0,0 +1,154 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'gli'
+
+ENV['APPMAP_INITIALIZE'] = 'false'
+
+require 'appmap'
+require 'appmap/version'
+
+# AppMap CLI.
+module AppMap
+  class App
+    extend GLI::App
+
+    program_desc 'AppMap client'
+
+    version AppMap::VERSION
+
+    subcommand_option_handling :normal
+    arguments :strict
+    preserve_argv true
+
+    class << self
+      protected
+
+      def default_appmap_file
+        ENV['APPMAP_FILE'] || 'appmap.json'
+      end
+
+      def output_file_flag(c, default_value: nil)
+        c.desc 'Name of the output file'
+        c.long_desc <<~DESC
+        Use a single dash '-' for stdout.
+        DESC
+        c.default_value default_value if default_value
+        c.arg_name 'filename'
+        c.flag %i[o output]
+      end
+    end
+
+    desc 'AppMap configuration file name'
+    default_value ENV['APPMAP_CONFIG'] || 'appmap.yml'
+    arg_name 'filename'
+    flag %i[c config]
+
+    desc 'Record the execution of a program and generate an AppMap.'
+    arg_name 'program'
+    command :record do |c|
+      output_file_flag(c, default_value: default_appmap_file)
+
+      c.action do |_, _, args|
+        # My subcommand name
+        ARGV.shift
+
+        # Consume the :output option, if provided
+        if %w[-o --output].find { |arg_name| ARGV[0] == arg_name.to_s }
+          ARGV.shift
+          ARGV.shift
+        end
+
+        # Name of the program to execute. GLI will ensure that it's present.
+        program = args.shift or help_now!("'program' argument is required")
+
+        # Also pop the program name from ARGV, because the command will use raw ARGV
+        # to load the extra arguments into this Ruby process.
+        ARGV.shift
+
+        require 'appmap/command/record'
+        AppMap::Command::Record.new(@config, program).perform do |version, metadata, class_map, events|
+          @output_file.write JSON.generate(version: version,
+                                           metadata: metadata,
+                                           classMap: class_map,
+                                           events: events)
+        end
+      end
+    end
+
+    desc 'Calculate and print statistics of scenario files.'
+    arg_name 'filename'
+    command :stats do |c|
+      output_file_flag(c, default_value: '-')
+
+      c.desc 'Display format for the result (text | json)'
+      c.default_value 'text'
+      c.flag %i[f format]
+
+      c.desc 'Maximum number of lines to display for each stat'
+      c.flag %i[l limit]
+
+      c.action do |_, options, args|
+        require 'appmap/command/stats'
+
+        limit = options[:limit].to_i if options[:limit]
+
+        # Name of the file to analyze. GLI will ensure that it's present.
+        filenames = args
+        help_now!("'filename' argument is required") if filenames.empty?
+
+        require 'appmap/algorithm/stats'
+        result = filenames.inject(::AppMap::Algorithm::Stats::Result.new([], [])) do |stats_result, filename|
+          appmap = begin
+            JSON.parse(File.read(filename))
+          rescue JSON::ParserError
+            STDERR.puts "#{filename} is not valid JSON : #{$!}"
+            nil
+          end
+          stats_result.tap do
+            if appmap
+              limit = options[:limit].to_i if options[:limit]
+              stats_for_file = AppMap::Command::Stats.new(appmap).perform(limit: limit)
+              stats_result.merge!(stats_for_file)
+            end
+          end
+        end
+
+        result.sort!
+        result.limit!(limit) if limit
+
+        display = case options[:format]
+        when 'json'
+          JSON.pretty_generate(result.as_json)
+        else
+          result.as_text
+        end
+        @output_file.write display
+      end
+    end
+
+    pre do |global, _, options, _|
+      @config = interpret_config_option(global[:config])
+      @output_file = interpret_output_file_option(options[:output])
+
+      true
+    end
+
+    class << self
+      protected
+
+      def interpret_config_option(fname)
+        AppMap.initialize fname
+      end
+
+      def interpret_output_file_option(file_name)
+        Hash.new { |_, fname| -> { File.new(fname, 'w') } }.tap do |open_output_file|
+          open_output_file[nil] = -> { nil }
+          open_output_file['-'] = -> { $stdout }
+        end[file_name].call
+      end
+    end
+  end
+end
+
+exit AppMap::App.run(ARGV)