appmap_depends 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b1b9b4ea40ab4a29c1a948d170192055e2968066202355029e700f4fc2b81ab7
+  data.tar.gz: 6391eccbb15cca43cd41f6bb3f379559186117122388aefd50b7bd5396b135a9
+SHA512:
+  metadata.gz: 2c9f085dc5e91d28da82048ff7b91f630caebc8281f126352e03aaedda2303ab8db2d86f5b8e83ac9d5c58e522745ebdcebd59f3fef7a2c76163ff03c5670cce
+  data.tar.gz: 68595be48e354a7bcaaa26731347a1e4593f84fa8418c564ee301ae9b4570a5973d3cdf54772a277f5032cc0917c865739bfbe1dbff3d763031e820be9f9e86e

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+Gemfile.lock
+.byebug_history

data/.travis.yml

@@ -0,0 +1,6 @@
+---
+language: ruby
+cache: bundler
+rvm:
+  - 2.6.6
+before_install: gem install bundler -v 2.1.4

data/CHANGELOG.md

@@ -0,0 +1,4 @@
+# v0.2.0
+
+* Switch to the monorepo version of `@appland/cli`.
+* Remove the `appmap/depends/task` package. Show the user how to define the Rake tasks with the task body provided by `AppMap::Depends` functions. 

data/Gemfile

@@ -0,0 +1,7 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in appmap_depends.gemspec
+gemspec
+
+gem "rake", "~> 12.0"
+gem "minitest", "~> 5.0"

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2021 Kevin Gilpin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,159 @@
+# `appmap_depends`
+
+This gem provides Rake tasks called `depends:modified` and `depends:diff`. These Rake tasks automatically compute a list of test cases that need to be re-run based on which source files have been modified. They use [AppMap](https://github.com/applandinc/appmap-ruby) data files, which contain information about test case dependencies on source files, to perform this feat.
+
+`appmap_depends` depends on an NPM package called [@appland/cli](https://www.npmjs.com/package/@appland/cli), which does most of the heavy lifting of processing AppMap data.
+
+# How it works
+
+The Rake tasks `depends:modified` and `depends:diff` require Node.js and the NPM package `@appland/cli`.
+
+Each task looks at which source files have been locally modified. The difference between `depends:modified` and `depends:diff` is what source files are considered modified; this difference is described in detail in the next section. The Rake task then scans the AppMaps to figure out which ones are out-of-date with respect to the source files. This is possible since each AppMap contains a `classMap`, which lists all the source files that are included in the recording. Each AppMap has a `source_location` field, which identifies the test case file that was run to generate the AppMap. `depends` prints the list of test case files to standard out.
+
+The `depends:modified` task looks at which source files have been locally modified. This task is used in local development. Run it as you work with the code.
+
+The `depends:diff` task looks at source files that are modified relative to a base `git` branch. This task is used in CI. Run it before running the full test suite, so that the tests which are most likely to fail will be run first. If any of the tests in this batch fail, fail the build until the developer fixes the tests, then run the full test suite.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+group :development, :test do
+  gem 'appmap_depends'
+end
+```
+
+And then execute:
+
+```sh-session
+$ bundle install
+```
+
+# Usage
+
+## Defining the Rake tasks
+
+You need to define the Rake tasks. In Rails, this is done by creating a file like `lib/tasks/appmap.rake`.
+
+In the file, check if `appmap_depends` is loaded, and then configure the Rake tasks.
+
+```ruby
+namespace :appmap do
+  def depends_tasks
+    namespace :depends do
+      task :modified do
+        @appmap_modified_files = AppMap::Depends.modified
+        AppMap::Depends.report_list 'Out of date', @appmap_modified_files
+      end
+
+      task :diff do
+        @appmap_modified_files = AppMap::Depends.diff(base: BASE_BRANCH)
+        AppMap::Depends.report_list 'Out of date', @appmap_modified_files
+      end
+
+      task :test_file_report do
+        @appmap_test_file_report = AppMap::Depends.inspect_test_files
+        @appmap_test_file_report.report
+      end
+
+      def run_minitest(test_files)
+        raise "RAILS_ENV must be 'test'" unless Rails.env.test?
+        $LOAD_PATH << 'test'
+        test_files.each do |test_file|
+          load test_file
+        end
+        $ARGV.replace []
+        Minitest.autorun
+      end
+
+      run_rspec(test_files)
+        system({ 'RAILS_ENV' => 'test', 'APPMAP' => 'true' }, "bundle exec rspec --format Fuubar #{test_files.map(&:shellescape).join(' ')}")
+      end
+
+      task :update_appmaps do
+        @appmap_test_file_report.clean_appmaps
+
+        @appmap_modified_files += @appmap_test_file_report.modified_files
+
+        if @appmap_modified_files.blank?
+          warn 'AppMaps are up to date'
+          next
+        end
+
+        AppMap::Depends.run_tests(@appmap_modified_files) do |test_files|
+          warn 'To generate AppMaps, uncomment run_minitest or run_rspec as appropriate for your project'
+          # run_minitest(test_files)
+          # run_rspec(test_files)
+        end
+      end
+    end
+
+    desc 'Bring AppMaps up to date with local file modifications, and updated derived data such as Swagger files'
+    task :modified => [ :'depends:modified', :'depends:test_file_report', :'depends:update_appmaps', :swagger ]
+
+    desc 'Bring AppMaps up to date with file modifications relative to the base branch'
+    task :diff, [ :base ] => [ :'depends:diff', :'depends:update_appmaps', :swagger, :'swagger:uptodate' ]
+  end
+end
+
+if %w[test development].member?(Rails.env)
+  depends_tasks
+
+  desc 'Bring AppMaps up to date with local file modifications, and updated derived data such as Swagger files'
+  task :appmap => :'appmap:depends:modified'
+end
+```
+
+## Running in CI
+
+In the CI environment, run the `appmap:depends:diff` task to compute the list of changed test files, and then
+run those tests directly using the test command.
+
+### RSpec
+
+This is easy with RSpec, just pipe the modified files to the `rspec` command:
+
+```sh-session
+$ bundle exec rake appmap:depends:diff | tee /dev/tty | xargs env APPMAP=true bundle exec rspec
+```
+
+### Minitest
+
+Minitest doesn't have a "run the tests" command that's analagous to `rspec`. You can define a Rask task which computes the changed test files and then uses the
+Rake task `Rails::TestUnit::Runner` to run the tests.
+
+```ruby
+namespace :appmap
+  if %w[test development].member?(Rails.env)
+    desc 'Run minitest tests that are modified relative to the base branch'
+    task :'test:diff' => :'test:prepare' do
+        task = AppMap::Depends::DiffTask.new
+        # This line is only needed if the base is not 'remotes/origin/main' or 'remotes/origin/master'
+        task.base = BASE_BRANCH
+        files = task.files
+        if Rake.verbose == true
+          warn 'Out of date tests:'
+          warn files.join(' ')
+        end
+        $: << "test"
+        Rails::TestUnit::Runner.rake_run(files)
+    end
+  end
+end
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/applandinc/appmap_depends-ruby.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/appmap_depends.gemspec

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'appmap/depends/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "appmap_depends"
+  spec.version       = AppMap::Depends::VERSION
+  spec.authors       = ['Kevin Gilpin']
+  spec.email         = ['kgilpin@gmail.com']
+
+  spec.summary       = %q{Provides Rake tasks to compute code dependencies based on AppMap data}
+  spec.homepage      = 'https://github.com/applandinc/appmap_depends-ruby'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.3.0')
+
+  # 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         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'rake'
+  spec.add_dependency 'activesupport'
+
+  spec.add_development_dependency 'minitest'
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "appmap_depends"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/appmap/depends/api.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module AppMap
+  module Depends
+    extend self
+
+    def modified(appmap_dir: DEFAULT_APPMAP_DIR, base_dir: nil)
+      depends = AppMap::Depends::AppMapJSDepends.new(appmap_dir)
+      depends.base_dir = base_dir if base_dir
+      test_files = depends.depends
+
+      Set.new prune_directory_prefix(test_files)
+    end
+
+    def diff(appmap_dir: DEFAULT_APPMAP_DIR, base_dir: nil, base_branches: DEFAULT_BASE_BRANCHES, base: nil, head: nil)
+      diff = AppMap::Depends::GitDiff.new(base_branches: base_branches, base: base, head: head)
+      modified_files = diff.modified_files
+
+      depends = AppMap::Depends::AppMapJSDepends.new(appmap_dir)
+      depends.base_dir = base_dir if base_dir
+      test_files = depends.depends(modified_files)
+
+      Set.new prune_directory_prefix(test_files)
+    end
+
+    def inspect_test_files(appmap_dir = DEFAULT_APPMAP_DIR, test_file_patterns = DEFAULT_TEST_FILE_PATTERNS)
+      inspector = AppMap::Depends::TestFileInspector.new(appmap_dir, test_file_patterns)
+      inspector.report
+    end
+
+    def report_list(title, files)
+      warn [ title, files.to_a.sort.join(' ') ].join(': ') unless files.empty?
+    end
+
+    def run_tests(test_files, appmap_dir: DEFAULT_APPMAP_DIR, &block)
+      test_files = test_files.to_a.sort
+      warn "Running tests: #{test_files.join(' ')}"
+
+      yield test_files
+
+      system(%(./node_modules/@appland/cli/src/cli.js index --appmap-dir #{appmap_dir.shellescape}))  
+    end
+
+    protected
+
+    def prune_directory_prefix(files)
+      Util.normalize_path(files)
+    end
+  end
+end

data/lib/appmap/depends/appmap_js.rb

@@ -0,0 +1,49 @@
+APPMAP_JS = './node_modules/@appland/appmap/src/cli.js'
+
+module AppMap
+  module Depends
+    # Utilities for invoking the +@appland/appmap+ CLI.
+    module AppMapJS
+      APPMAP_JS = './node_modules/@appland/cli/src/cli.js'
+
+      def detect_nodejs
+        do_fail('node', 'please install NodeJS') unless system('node --version 2>&1 > /dev/null')
+        true
+      end
+
+      def detect_appmap_js
+        do_fail(APPMAP_JS, 'please install @appland/cli from NPM') unless File.exists?(APPMAP_JS)
+        true
+      end
+
+      def index_appmaps(appmap_dir)
+        appmap_js_command [ 'index', '--appmap-dir', appmap_dir ]
+        true
+      end
+
+      def do_fail(command, msg)
+        command = command.join(' ') if command.is_a?(Array)
+        warn [ command, msg ].join('; ') if Depends.verbose
+        raise CommandError.new(command, msg)
+      end
+
+      def appmap_js_command(command, options = {})
+        command.unshift << '--verbose' if Depends.verbose
+        command.unshift APPMAP_JS
+
+        warn command.join(' ') if Depends.verbose
+        stdout, stderr, status = Open3.capture3({ 'NODE_OPTIONS' => '--trace-warnings' }, *command, options)
+        stdout_msg = stdout.split("\n").map {|line| "stdout: #{line}"}.join("\n") unless stdout.blank?
+        stderr_msg = stderr.split("\n").map {|line| "stderr: #{line}"}.join("\n") unless stderr.blank?
+        if Depends.verbose
+          warn stdout_msg if stdout_msg
+          warn stderr_msg if stderr_msg
+        end
+        unless status.exitstatus == 0
+          raise CommandError.new(command, [ stdout_msg, stderr_msg ].compact.join("\n"))
+        end
+        [ stdout, stderr ]
+      end
+    end
+  end
+end

data/lib/appmap/depends/appmap_js_depends.rb

@@ -0,0 +1,49 @@
+require 'shellwords'
+require 'appmap/depends/appmap_js'
+
+module AppMap
+  module Depends
+    # +Command+ wraps the Node +depends+ command.
+    class AppMapJSDepends
+      include AppMapJS
+
+      # Directory to scan for AppMaps.
+      attr_accessor :appmap_dir
+      # Directory name to prefix to the list of modified files which is provided to +depends+.
+      attr_accessor :base_dir
+
+      def initialize(appmap_dir)
+        @appmap_dir = appmap_dir
+        @base_dir = false
+      end
+
+      # Ensures that all dependencies are available.
+      def validate
+        detect_nodejs
+        detect_appmap_js
+      end
+
+      # Returns the source_location field of every AppMap that is "out of date" with respect to one of the
+      # +modified_files+.
+      def depends(modified_files = nil)
+        validate
+
+        index_appmaps(appmap_dir)
+
+        cmd = %w[depends --field source_location]
+        cmd += [ '--appmap-dir', appmap_dir ] if appmap_dir
+        cmd += [ '--base-dir', base_dir ] if base_dir
+
+        options = {}
+        if modified_files
+          cmd << '--stdin-files'
+          options[:stdin_data] = modified_files.map(&:shellescape).join("\n")
+          warn "Checking modified files: #{modified_files.join(' ')}" if Depends.verbose
+        end
+
+        stdout, = appmap_js_command cmd, options
+        stdout.split("\n")
+      end
+    end
+  end
+end

data/lib/appmap/depends/command_error.rb

@@ -0,0 +1,15 @@
+module AppMap
+  module Depends
+    # Raised when a system / shell command fails.
+    class CommandError < StandardError
+      attr_reader :command, :msg
+
+      def initialize(command, msg = nil)
+        super [ "Command failed: #{command}", msg ].compact.join('; ')
+
+        @command = command
+        @msg = msg
+      end
+    end
+  end
+end

data/lib/appmap/depends/git_diff.rb

@@ -0,0 +1,53 @@
+module AppMap
+  module Depends
+    class GitDiff
+      attr_reader :head, :base_branches
+
+      def initialize(base_branches: [], base: nil, head: nil)
+        @base_branches = base_branches
+        @base = base
+        @head = head
+      end
+
+      def base=(base)
+        @base = base
+      end
+
+      def base
+        return @base if @base
+
+        git_exists = -> { system('git --version 2>&1 > /dev/null') }
+        detect_branch = ->(branch) { `git branch -a`.split("\n").map(&:strip).member?(branch) }
+        detect_base = lambda do
+          return nil unless git_exists.()
+
+          @base_branches.find(&detect_branch)
+        end
+        @base = detect_base.()
+        raise "Unable to detect base branch. Specify it explicitly as a task argument." unless @base
+        @base
+      end
+
+      def modified_files
+        warn "Using base #{base.inspect}" if Depends.verbose
+        warn "Using head #{head.inspect}" if head && Depends.verbose
+
+        branches = [ head, base ].compact
+        diff_cmd = [ 'git', 'diff', '--name-only', branches.join('..') ]
+
+        if Depends.verbose
+          warn diff_cmd.join(' ')
+          warn "Files modified #{head ? 'in ' + head : 'locally'} compared to #{base}:"
+        end
+
+        stdout, stderr, status = Open3.capture3(*diff_cmd)
+        if status.exitstatus != 0
+          warn stdout
+          warn stderr
+          raise CommandError.new(diff_cmd)
+        end
+        stdout.split("\n")
+      end
+    end
+  end
+end

data/lib/appmap/depends/test_file_inspector.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module AppMap
+  module Depends
+    class TestFileInspector
+      TestReport = Struct.new(:metadata_files, :added, :removed, :changed, :failed) do
+        private_methods :metadata_files
+
+        def to_s
+          report = []
+          report << "Added test files   : #{added.to_a.join(' ')}" unless added.empty?
+          report << "Removed test files : #{removed.to_a.join(' ')}" unless removed.empty?
+          report << "Changed test files : #{changed.to_a.join(' ')}" unless changed.empty?
+          report << "Failed test files  : #{failed.to_a.join(' ')}" unless failed.empty?
+          report.compact.join("\n")
+        end
+
+        def report
+          warn to_s unless empty?
+        end
+
+        def empty?
+          [ added, removed, changed, failed ].all?(&:empty?)
+        end
+
+        def modified_files
+          added + changed + failed
+        end
+
+        # Delete AppMaps which depend on test cases that have been deleted.
+        def clean_appmaps
+          return if removed.empty?
+
+          delete_appmap = lambda do |appmap_path|
+            FileUtils.rm_rf(appmap_path)
+            appmap_file_path = [ appmap_path, 'appmap.json' ].join('.')
+            File.unlink(appmap_file_path) if File.exists?(appmap_file_path)
+          end
+
+          count = metadata_files.each_with_object(0) do |metadata_file, count|
+            metadata = JSON.parse(File.read(metadata_file))
+            source_location = Util.normalize_path(metadata['source_location'])
+            appmap_path = File.join(metadata_file.split('/')[0...-1])
+    
+            if removed.member?(source_location)
+              delete_appmap.(appmap_path)
+              count += 1
+            end
+          end
+          count
+        end
+      end
+
+      attr_reader :test_dir
+      attr_reader :test_file_patterns
+
+      def initialize(test_dir, test_file_patterns)
+        @test_dir = test_dir
+        @test_file_patterns = test_file_patterns
+      end
+
+      def report
+        metadata_files = Dir.glob(File.join(test_dir, '**', 'metadata.json'))
+        source_locations = Set.new
+        changed_test_files = Set.new
+        failed_test_files = Set.new
+        metadata_files.each do |metadata_file|
+          metadata = JSON.parse(File.read(metadata_file))
+          appmap_path = File.join(metadata_file.split('/')[0...-1])
+  
+          appmap_mtime = File.read(File.join(appmap_path, 'mtime')).to_i
+          source_location = Util.normalize_path(metadata['source_location'])
+          test_status = metadata['test_status']
+          source_location_mtime = (File.stat(source_location).mtime.to_f * 1000).to_i rescue nil
+  
+          raise "Metadata #{metadata_file} does not contain source_location" unless source_location
+          raise "Metadata #{metadata_file} does not contain test_status" unless test_status
+  
+          source_locations << source_location
+          if source_location_mtime
+            changed_test_files << source_location if source_location_mtime > appmap_mtime
+            failed_test_files << source_location unless test_status == 'succeeded'
+          end
+        end
+  
+        test_files = Set.new(test_file_patterns.map(&Dir.method(:glob)).flatten)
+        new_test_files = test_files - source_locations
+        obsolete_test_files = source_locations - test_files
+    
+        TestReport.new(metadata_files, new_test_files, obsolete_test_files, changed_test_files, failed_test_files)
+      end
+    end
+  end
+end

data/lib/appmap/depends/util.rb

@@ -0,0 +1,24 @@
+module AppMap
+  module Depends
+    module Util
+      extend self
+
+      def normalize_path(path, pwd: Dir.pwd)
+        normalize_path_fn(pwd).(path)
+      end
+
+      def normalize_paths(paths, pwd: Dir.pwd)
+        paths.map(&normalize_path_fn(pwd))
+      end
+
+      private
+
+      def normalize_path_fn(pwd)
+        lambda do |path|
+          path = path[pwd.length + 1..-1] if path.index(pwd) == 0
+          path.split(':')[0]
+        end  
+      end
+    end
+  end
+end

data/lib/appmap/depends/version.rb

@@ -0,0 +1,5 @@
+module AppMap
+  module Depends
+    VERSION = "0.2.0"
+  end
+end

data/lib/appmap_depends.rb

@@ -0,0 +1,37 @@
+require 'appmap/depends/version'
+
+module AppMap
+  module Depends
+    # Default directory to scan for appmap.s
+    DEFAULT_APPMAP_DIR = File.join('tmp', 'appmap')
+    # Default file to write Rake task results.
+    DEFAULT_OUTPUT_FILE = File.join('tmp', 'appmap_depends.txt')
+    # Default base branches which will be checked for existance.
+    DEFAULT_BASE_BRANCHES = %w[remotes/origin/main remotes/origin/master].freeze
+    # Default pattern to enumerate test cases.
+    DEFAULT_TEST_FILE_PATTERNS = [ 'spec/**/*_spec.rb', 'test/**/*_test.rb' ].freeze
+
+    def self.verbose(arg = nil)
+      @verbose = arg if arg
+      @verbose
+    end
+  end
+end
+
+def rake_defined?
+  require 'rake'
+  true
+rescue LoadError
+  false
+end
+
+require 'appmap/depends/util'
+require 'appmap/depends/command_error'
+require 'appmap/depends/git_diff'
+require 'appmap/depends/appmap_js_depends'
+require 'appmap/depends/test_file_inspector'
+require 'appmap/depends/api'
+
+if rake_defined?
+  AppMap::Depends.verbose(Rake.verbose == true)
+end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: appmap_depends
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Kevin Gilpin
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-05-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+- kgilpin@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- appmap_depends.gemspec
+- bin/console
+- bin/setup
+- lib/appmap/depends/api.rb
+- lib/appmap/depends/appmap_js.rb
+- lib/appmap/depends/appmap_js_depends.rb
+- lib/appmap/depends/command_error.rb
+- lib/appmap/depends/git_diff.rb
+- lib/appmap/depends/test_file_inspector.rb
+- lib/appmap/depends/util.rb
+- lib/appmap/depends/version.rb
+- lib/appmap_depends.rb
+homepage: https://github.com/applandinc/appmap_depends-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key:
+specification_version: 4
+summary: Provides Rake tasks to compute code dependencies based on AppMap data
+test_files: []