appmap 0.23.0 → 0.25.0

data/lib/appmap/inspect.rb

@@ -1,91 +0,0 @@
-require 'appmap/inspect/inspector'
-require 'appmap/inspect/parser'
-
-module AppMap
-  # Inspect identifies features from a Ruby file.
-  module Inspect
-    class << self
-      # Detect features from a source code repository. The manner in which the features are detected in the
-      # code is defined and tuned by a path configuration object. The path configuration tells the
-      # feature detector what it should do when it encounters code that may be a "sub-feature",
-      # for example a public instance method of a class.
-      #
-      # rubocop:disable Metrics/AbcSize
-      # rubocop:disable Metrics/MethodLength
-      # @appmap
-      def detect_features(config_spec)
-        child_features = -> { config_spec.children.map(&Inspect.method(:detect_features)).flatten.compact }
-        parse_file = -> { inspect_file(config_spec.mode, file_path: config_spec.path) }
-
-        feature_builders = Hash.new { |_, key| raise "Unable to build features for #{key.inspect}" }
-        feature_builders[AppMap::Config::Directory] = child_features
-        feature_builders[AppMap::Config::File] = parse_file
-        feature_builders[AppMap::Config::PackageDir] = lambda {
-          AppMap::Feature::Package.new(config_spec.package_name, config_spec.path, {}).tap do |package|
-            child_features.call.each do |child|
-              package.add_child(child)
-            end
-          end
-        }
-        feature_builders[AppMap::Config::NamedFunction] = lambda {
-          # Loads named functions by finding the requested gem, finding the file within the gem,
-          # parsing that file, and then inspecting the module/class scope for the requested method.
-          # We can't 'require' the specified code, because if we do that, it can change the
-          # behavior of the program.
-
-          gem = Gem.loaded_specs[config_spec.gem_name]
-          return [] unless gem
-
-          gem_dir = gem.gem_dir
-          file_path = File.join(gem_dir, config_spec.file_path)
-
-          parse_nodes, comments = Parser.new(file_path: file_path).parse
-          features = ImplicitInspector.new(file_path, parse_nodes, comments).inspect_file
-
-          class_names = config_spec.class_names.dup
-          until class_names.empty?
-            class_name = class_names.shift
-            feature = features.find { |f| f.to_h[:type] == 'class' && f.name == class_name }
-            raise "#{class_name.inspect} not found" unless feature
-
-            features = feature.children
-          end
-
-          function = features.find { |f| f.to_h[:type] == 'function' && f.name == config_spec.method_name && f.static == config_spec.static }
-
-          # If the configuration specifier has an id, use it as the handler id.
-          # This is how we can associate custom handler logic with the named function.
-          function.handler_id = config_spec.id.to_s if config_spec.id
-
-          AppMap::Feature::Package.new(config_spec.gem_name, "#{gem_dir}:0", {}).tap do |pkg|
-            parent = pkg
-            class_names = config_spec.class_names.dup
-            until class_names.empty?
-              class_name = class_names.shift
-              cls = AppMap::Feature::Cls.new(class_name, "#{gem_dir}:0", {})
-              parent.children << cls
-              parent = cls
-            end
-            parent.children << function
-          end
-        }
-
-        feature_builders[config_spec.class].call
-      end
-      # rubocop:enable Metrics/AbcSize
-      # rubocop:enable Metrics/MethodLength
-
-      # Inspect a specific file for features.
-      #
-      # @appmap
-      def inspect_file(strategy, file_path: nil)
-        parse_nodes, comments = Parser.new(file_path: file_path).parse
-        inspector_class = {
-          implicit: ImplicitInspector,
-          explicit: ExplicitInspector
-        }[strategy] or raise "Invalid strategy : #{strategy.inspect}"
-        inspector_class.new(file_path, parse_nodes, comments).inspect_file
-      end
-    end
-  end
-end

data/lib/appmap/inspect/inspector.rb

@@ -1,99 +0,0 @@
-module AppMap
-  module Inspect
-    # Inspector is an abstract class for extracting features from a Ruby program.
-    class Inspector
-      attr_reader :file_path, :parse_nodes, :comments
-
-      def initialize(file_path, parse_nodes, comments)
-        @file_path = file_path
-        @parse_nodes = parse_nodes
-        @comments = comments
-      end
-    end
-
-    # ImplicitInspector extracts features from a Ruby program, creating a feature for each public class and method.
-    class ImplicitInspector < Inspector
-      def inspect_file
-        features = []
-        features_by_ast_node = {}
-        parse_nodes.select(&:public?).each do |parse_node|
-          feature = parse_node.to_feature({})
-          features_by_ast_node[parse_node.node] = feature
-          if feature
-            if (enclosing_type_node = parse_node.enclosing_type_node) &&
-               (parent_feature = features_by_ast_node[enclosing_type_node])
-              parent_feature.add_child(feature)
-            else
-              features << feature
-            end
-          end
-        end
-
-        features.keep_if(&:valid?)
-        features
-      end
-    end
-
-    # ExplicitInspector extracts features from a Ruby program, requiring the use of @appmap annotations to mark each
-    # relevant class and method.
-    class ExplicitInspector < Inspector
-      def inspect_file
-        nodes_by_line = parse_nodes.each_with_object({}) { |node, h| h[node.node.loc.line] = node }
-
-        features_by_ast_node = {}
-        features = []
-
-        comments.select { |c| c.text.index('@appmap') }.each do |c|
-          c.text.split("\n").select { |l| l.index('@appmap') }.each do |feature|
-            tokens = feature.split
-            tokens.delete_if { |t| %w[# @appmap].member?(t) }
-            attributes = tokens.inject({}) do |memo, token|
-              key, value = token.split('=')
-              memo.tap do |attrs|
-                attrs[key.to_sym] = value
-              end
-            end
-
-            parse_node = nodes_by_line[c.location.last_line + 1]
-            if parse_node
-              feature = parse_node.to_feature(attributes)
-              features_by_ast_node[parse_node.node] = feature
-              if feature
-                if (enclosing_type_node = parse_node.enclosing_type_node) &&
-                   (parent_feature = features_by_ast_node[enclosing_type_node])
-                  parent_feature.add_child(feature)
-                else
-                  features << feature
-                end
-
-                # At this point there's a parse_node and an associated feature.
-                # If the feature is a class which has the option 'include=public_methods',
-                # scan the rest of the class body for public methods and create features
-                # for them.
-
-                if parse_node.type == :class && feature.include_option.member?('public_methods')
-                  begin_node = parse_node.node.children.find { |n| n.respond_to?(:type) && n.type == :begin }
-                  if begin_node
-                    public_methods = begin_node
-                                     .children
-                                     .select { |n| n.respond_to?(:type) && n.type == :def }
-                                     .map { |n| ParseNode.from_node(n, file_path, parse_node.ancestors + [ parse_node.node, begin_node ]) }
-                                     .select(&:public?)
-                    public_methods.map { |m| m.to_feature([]) }.compact.each do |f|
-                      feature.add_child(f)
-                    end
-                  end
-                end
-              end
-            else
-              warn "No parse node found at #{file_path}:#{c.location.last_line + 1}"
-            end
-          end
-        end
-
-        features.keep_if(&:valid?)
-        features
-      end
-    end
-  end
-end

data/lib/appmap/inspect/parse_node.rb

@@ -1,170 +0,0 @@
-require 'appmap/feature'
-require 'forwardable'
-
-module AppMap
-  module Inspect
-    # ParseNodeStruct wraps a generic AST parse node.
-    ParseNodeStruct = Struct.new(:node, :file_path, :ancestors) do
-    end
-
-    # ParseNode wraps a generic AST parse node.
-    class ParseNode < ParseNodeStruct
-      extend Forwardable
-
-      def_delegators :node, :type, :location
-
-      class << self
-        # Build a ParseNode from an AST node.
-        def from_node(node, file_path, ancestors)
-          case node.type
-          when :class, :module
-            ClassParseNode.new(node, file_path, ancestors.dup)
-          when :def
-            InstanceMethodParseNode.new(node, file_path, ancestors.dup)
-          when :defs
-            StaticMethodParseNode.new(node, file_path, ancestors.dup) \
-              if StaticMethodParseNode.static?(node)
-          end
-        end
-      end
-
-      def public?
-        preceding_send = preceding_sibling_nodes
-                         .reverse
-                         .select { |n| n.respond_to?(:type) && n.type == :send }
-                         .find { |n| %i[public protected private].member?(n.children[1]) }
-        preceding_send.nil? || preceding_send.children[1] == :public
-      end
-
-      # Gets the AST node of the module or class which encloses this node.
-      def enclosing_type_node
-        ancestors.reverse.find do |a|
-          %i[class module].include?(a.type)
-        end
-      end
-
-      def parent_node
-        ancestors[-1]
-      end
-
-      def preceding_sibling_nodes
-        return [] unless parent_node
-        index_of_this_node = parent_node.children.index { |c| c == node }
-        parent_node.children[0...index_of_this_node]
-      end
-
-      protected
-
-      def extract_class_name(node)
-        node.children[0].children[1].to_s
-      end
-
-      def extract_module_name(node)
-        node.children[0].children[1].to_s
-      end
-    end
-
-    # A Ruby class.
-    class ClassParseNode < ParseNode
-      def to_feature(attributes)
-        AppMap::Feature::Cls.new(extract_class_name(node), "#{file_path}:#{location.line}", attributes)
-      end
-    end
-
-    # Abstract representation of a method.
-    class MethodParseNode < ParseNode
-      def to_feature(attributes)
-        AppMap::Feature::Function.new(name, "#{file_path}:#{location.line}", attributes).tap do |a|
-          a.static = static?
-          a.class_name = class_name
-        end
-      end
-
-      def enclosing_names
-        ancestors.select do |a|
-          %i[class module].include?(a.type)
-        end.map do |a|
-          send("extract_#{a.type}_name", a)
-        end
-      end
-    end
-
-    # A method defines as a :def AST node.
-    class InstanceMethodParseNode < MethodParseNode
-      def name
-        node.children[0].to_s
-      end
-
-      # class_name should be inferred from the enclosing type.
-      def class_name
-        enclosing_names.join('::')
-      end
-
-      # An instance method defined in an sclass is a static method.
-      #
-      # TODO: Well, not strictly true. A singleton class can be defined on a class or
-      # on an instance. In fact, to Ruby a class method is really just an instance method
-      # on a class. So, this needs fixing to try and determine if the singleton class is
-      # defined on an instance or on a class. This may actually be hard (impossible?) to do
-      # from static parsing.
-      def static?
-        result = ancestors[-1].type == :sclass ||
-          (ancestors[-1].type == :begin && ancestors[-2] && ancestors[-2].type == :sclass)
-        !!result
-      end
-    end
-
-    # A method defines as a :defs AST node.
-    # For example:
-    #
-    # class Main
-    #   def Main.main_func; end
-    #   def explain
-    #     some_func.tap do |s|
-    #       def s.inspect; self; end
-    #     end
-    #   end
-    # end
-    class StaticMethodParseNode < MethodParseNode
-      class << self
-        def static?(node)
-          %i[self const].member?(node.children[0].type)
-        end
-      end
-
-      def name
-        node.children[1].to_s
-      end
-
-      # class_name is specified as `nil` if it should be inferred from the
-      # enclosing type.
-      def class_name
-        case (defs_type = node.children[0].type)
-        when :self
-          class_name_from_enclosing_type
-        when :const
-          class_name_from_declaration
-        else
-          raise "Unrecognized 'defs' method type : #{defs_type.inspect}"
-        end
-      end
-
-      def static?
-        true
-      end
-
-      protected
-
-      def class_name_from_enclosing_type
-        enclosing_names.join('::')
-      end
-
-      def class_name_from_declaration
-        ancestor_names = enclosing_names
-        ancestor_names.pop
-        ancestor_names << node.children[0].children[1]
-        ancestor_names.join('::')
-      end
-    end
-  end
-end

data/lib/appmap/inspect/parser.rb

@@ -1,15 +0,0 @@
-require 'appmap/parser'
-require 'appmap/inspect/parse_node'
-
-module AppMap
-  module Inspect
-    # Parser processes a Ruby into a list of parse nodes and a list of comments.
-    class Parser < ::AppMap::Parser
-      protected
-
-      def build_parse_node(node, file_path, ancestors)
-        ParseNode.from_node(node, file_path, ancestors)
-      end
-    end
-  end
-end

data/lib/appmap/parser.rb

@@ -1,60 +0,0 @@
-require 'parser/current'
-require 'set'
-
-module AppMap
-  class Parser
-    def initialize(file_path: nil, code: nil)
-      @file_path = file_path
-      @code = code
-    end
-
-    def to_s
-      "Parse code #{file_path.inspect}"
-    end
-
-    # Parse the contents of a file into a list of features.
-    def parse
-      parse_tree, comments = parse_code_and_comments
-      parse_nodes = build_parse_nodes parse_tree
-      [ parse_nodes, comments ]
-    end
-
-    protected
-
-    def file_path
-      @file_path || '<inline>'
-    end
-
-    def code
-      @code ||= File.read(file_path)
-    end
-
-    def parse_code_and_comments
-      ::Parser::CurrentRuby.parse_with_comments(code)
-    rescue ::Parser::SyntaxError, EncodingError
-      warn "Unable to parse #{file_path.inspect} : #{$!.message}"
-      [ [], [] ]
-    end
-
-    # rubocop:disable Metrics/MethodLength
-    def build_parse_nodes(parse_tree)
-      parse_nodes = []
-      visit_methods = lambda do |node, ancestors|
-        return unless node.respond_to?(:type)
-
-        parse_node = build_parse_node(node, file_path, ancestors)
-        parse_nodes << parse_node if parse_node
-
-        ancestors << node
-        node.children.each do |child|
-          visit_methods.call(child, ancestors)
-        end
-        ancestors.pop
-      end
-      visit_methods.call(parse_tree, [])
-      parse_nodes
-    end
-  end
-  # rubocop:enable Metrics/MethodLength
-end
-

data/lib/appmap/rspec/parse_node.rb

@@ -1,41 +0,0 @@
-require 'forwardable'
-
-module AppMap
-  module RSpec
-    # ParseNodeStruct wraps a generic AST parse node.
-    ParseNodeStruct = Struct.new(:node, :file_path, :ancestors) do
-    end
-
-    # ParseNode wraps a generic AST parse node.
-    class ParseNode < ParseNodeStruct
-      extend Forwardable
-
-      def_delegators :node, :type, :location
-
-      class << self
-        # Build a ParseNode from an AST node.
-        def from_node(node, file_path, ancestors)
-          case node.type
-          when :block
-            BlockParseNode.new(node, file_path, ancestors.dup)
-          end
-        end
-      end
-    end
-
-    # A Ruby block.
-    class BlockParseNode < ParseNode
-      def to_s
-        "RSpec block at #{file_path} #{first_line}:#{last_line}"
-      end
-
-      def first_line
-        node.location.first_line
-      end
-
-      def last_line
-        node.location.last_line
-      end
-    end
-  end
-end