trains 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5edc43c1d03aa434cb4166f79b9687574ac14a04548a8e2e8fc7f47b005573e0
-  data.tar.gz: ebee4c7048d82d644e4c08de0cd9a828b2f6784747558a3ec041b0feadbc043d
+  metadata.gz: 7edd36bbbc3349d7b32a1719cb5e80038953853e18d5d927ab2e713b621f356f
+  data.tar.gz: 97c661e09da45575d54fca505ab1a967b941c0bca806e29a1155739ca387f1a4
 SHA512:
-  metadata.gz: 7511a1b15fc8b908cee1ccacd6096d651169ee7ce5ab4eeb6b153c905b8bd949f3899fd20080b4b0f577f2c9d90260ac8e7d85940680fb7c0c74cf24386fa110
-  data.tar.gz: f7607d015b516c24c33e74f0473c120a25070bd146411deda8be54cbbe66e945a9ed68f56dd3122cd3c6694dae5bf3b220a836f0584f64f19aab711ba871aa54
+  metadata.gz: f560a4e5f4adf6fb45238f4deb1fcc3bb4dbcbf8a7a5b5dec7c74ff27224dd6a7afa00fe4702c1fa939626f8200a88b5d0383615967a3cd46af0d64cb6ae4b17
+  data.tar.gz: e3ae6062e8aea943fdb3d030c962edfdb23b631d60f33d17a1a9a041ad05fdb78424d427668dd76e015aa22564a0d2e18ee2dba2c9138445a9870040cfb75209

data/.deepsource.toml

@@ -2,6 +2,3 @@ version = 1
 
 [[analyzers]]
 name = "ruby"
-
-[[transformers]]
-name = "rubocop"

data/Gemfile.lock

@@ -1,12 +1,3 @@
-PATH
-  remote: .
-  specs:
-    trains (0.0.1)
-      activesupport (~> 7.0)
-      parallel (~> 1.22)
-      rubocop-ast (~> 1.16)
-      zeitwerk (~> 2.5)
-
 GEM
   remote: https://rubygems.org/
   specs:
@@ -54,6 +45,7 @@ GEM
     zeitwerk (2.5.4)
 
 PLATFORMS
+  x86_64-darwin-21
   x86_64-linux
 
 DEPENDENCIES
@@ -63,7 +55,6 @@ DEPENDENCIES
   rspec (~> 3.12)
   rubocop-ast
   ruby-lsp (~> 0.3.7)
-  trains!
   zeitwerk (~> 2.5)
 
 BUNDLED WITH

data/README.md

@@ -2,6 +2,21 @@
 
 A gem that statically analyses your Rails app and extracts information about its structure.
 
+[![DeepSource](https://deepsource.io/gh/faraazahmad/trains.svg/?label=active+issues&show_trend=true&token=RKfXNZL_RQe6j2NEhXv2iOeh)](https://deepsource.io/gh/faraazahmad/trains/?ref=repository-badge)
+[![DeepSource](https://deepsource.io/gh/faraazahmad/trains.svg/?label=resolved+issues&show_trend=true&token=RKfXNZL_RQe6j2NEhXv2iOeh)](https://deepsource.io/gh/faraazahmad/trains/?ref=repository-badge)
+
+## Index
+
+1. [Installation](#installation)
+2. [Usage](#usage)
+3. [Features](#features)
+    1. [Create Model definitions from migrations](#create-model-definitions-from-migrations)
+    2. [Create controller definitions from files](#create-controller-definitions-from-files)
+4. [Development](#development)
+5. [Contributing](#contributing)
+6. [License](#license)
+7. [Code of conduct](#code-of-conduct)
+
 ## Installation
 
 Install the gem and add it to the application's Gemfile by executing:

data/Rakefile

@@ -5,8 +5,4 @@ require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
-require "rubocop/rake_task"
-
-RuboCop::RakeTask.new
-
-task default: %i[spec rubocop]
+task default: %i[spec]

data/lib/trains/dto/app.rb

@@ -1,13 +1,6 @@
 module Trains
   module DTO
-    App = Struct.new(
-      'App',
-      :name,
-      :controllers,
-      :models,
-      :migrations,
-      :helpers,
-      keyword_init: true
-    )
+    App =
+      Data.define(:name, :controllers, :models, :migrations, :helpers, :routes)
   end
 end

data/lib/trains/dto/controller.rb

@@ -1,7 +1,7 @@
-require 'set'
+require "set"
 
 module Trains
   module DTO
-    Controller = Struct.new('Controller', :name, :method_list, keyword_init: true)
+    Controller = Data.define(:name, :method_list)
   end
 end

data/lib/trains/dto/field.rb

@@ -1,5 +1,5 @@
 module Trains
   module DTO
-    Field = Struct.new(:name, :type)
+    Field = Data.define(:name, :type)
   end
 end

data/lib/trains/dto/method.rb

@@ -1,5 +1,5 @@
 module Trains
   module DTO
-    Method = Struct.new('Method', :name, :source, :visibility, keyword_init: true)
+    Method = Data.define(:name)
   end
 end

data/lib/trains/dto/model.rb

@@ -1,5 +1,5 @@
 module Trains
   module DTO
-    Model = Struct.new(:name, :fields, :version)
+    Model = Data.define(:name, :fields, :version)
   end
 end

data/lib/trains/dto/route.rb

@@ -0,0 +1,5 @@
+module Trains
+  module DTO
+    Route = Data.define(:method, :param, :options)
+  end
+end

data/lib/trains/scanner.rb

@@ -3,21 +3,17 @@ module Trains
   class Scanner
     include Utils
 
-    attr_accessor :models, :controllers, :helpers, :migrations
-
-    def initialize(folder)
+    def initialize(folder, options = {})
       @root_folder = folder
       @nodes = []
       @models = []
       @controllers = []
       @helpers = []
-      @dir = Dir.new(File.expand_path(folder))
-      Dir.chdir @dir
+      @dir = File.expand_path(folder)
+      @options = options
     end
 
     def scan
-      # @nodes = get_tree(@dir)
-
       # Check if @folder is a Rails directory before beginning analysis
       rails_dir_result = RailsDir.check @dir
       case rails_dir_result
@@ -27,15 +23,17 @@ module Trains
         return(
           Result.new(
             data: nil,
-            error: ArgumentError.new('Not a Rails directory')
+            error: ArgumentError.new("Not a Rails directory")
           )
         )
       end
 
-      @migrations = Set[*get_migrations]
-      @controllers = Set[*get_controllers]
-      # @helpers = get_helpers
-      # @models = get_models
+      @models = get_models.to_set unless @options[:models] == false
+      @migrations = get_migrations.to_set unless @options[:migrations] == false
+      @controllers = get_controllers.to_set unless @options[:controllers] ==
+        false
+      @routes = get_routes.to_set unless @options[:routes] == false
+      # TODO: @helpers = get_helpers
 
       # Create instance of Trains::DTO::App
       DTO::App.new(
@@ -43,51 +41,61 @@ module Trains
         controllers: @controllers,
         models: @models,
         migrations: @migrations,
-        helpers: @helpers
+        helpers: @helpers,
+        routes: @routes
       )
     end
 
-    # Build central ASTStore
-    def build_ast_store
-      all_files = Dir.glob(File.join(@root_folder, '**', '*.rb'))
-      Parallel.each(all_files) do |file_path|
-        ASTStore.instance.set(
-          file_path,
-          RuboCop::AST::ProcessedSource.from_file(file_path, RUBY_VERSION.to_f)
-        )
-      end
+    private
+
+    def get_routes
+      route_file = [File.join(@dir, "config", "routes.rb")]
+
+      routes_results = parse_util(route_file, Visitor::Route)
+      routes_results
+        .select { |result| result.error.nil? }
+        .map { |result| result.data }
+        .flatten
     end
 
-    def get_models; end
+    def get_models
+      schema_file = [File.join(@dir, "db", "schema.rb")]
+      return unless File.exist?(schema_file.first)
 
-    def get_helpers
-      app_folder = @nodes[:children].find { |node| node[:path].include? 'app' }
-      helpers_folder =
-        app_folder[:children].find { |node| node[:path].include? 'app/helpers' }
-      helpers =
-        helpers_folder[:children].filter do |node|
-          node[:path].end_with? '_helper.rb'
-        end
+      models_results = parse_util(schema_file, Visitor::Schema)
+      models_results
+        .select { |result| result.error.nil? }
+        .map { |result| result.data }
+        .flatten
+    end
 
-      @helpers = parse_util(helpers, Visitor::Helper)
+    def get_helpers
     end
 
-    def get_gemfile; end
+    def get_gemfile
+    end
 
     def get_controllers
       controllers =
-        Dir.glob(File.join(@dir, 'app', 'controllers', '**', '*_controller.rb'))
+        Dir.glob(File.join(@dir, "app", "controllers", "**", "*_controller.rb"))
 
-      parse_util(controllers, Visitor::Controller)
+      controller_results = parse_util(controllers, Visitor::Controller)
+      controller_results
+        .select { |result| result.error.nil? }
+        .map { |result| result.data }
+        .flatten
     end
 
     def get_migrations
-      migrations = Dir.glob(File.join(@dir, 'db', 'migrate', '**', '*.rb'))
+      migrations = Dir.glob(File.join(@dir, "db", "migrate", "**", "*.rb"))
 
-      parse_util(migrations, Visitor::Migration)
+      migration_results = parse_util(migrations, Visitor::Migration)
+      migration_results
+        .select { |result| result.error.nil? }
+        .map { |result| result.data }
     end
 
-    def parse_util(file_nodes, klass)
+    def parse_util(file_nodes, visitor_class)
       unless file_nodes.class.include? Enumerable
         return(
           Result.new(
@@ -100,27 +108,30 @@ module Trains
         )
       end
 
-      begin
-        Parallel.map(file_nodes) do |node|
+      Parallel.map(file_nodes) do |node|
+        begin
           processed_source =
             RuboCop::AST::ProcessedSource.from_file(node, RUBY_VERSION.to_f)
-          visitor = klass.new
+          visitor = visitor_class.new
           visitor.process(processed_source.ast)
-          visitor.result
+
+          Result.new(data: visitor.result, error: nil)
+        rescue StandardError => e
+          puts "An error occurred while parsing #{node}. Use debug option to view backtrace. Skipping file..."
+          puts e.backtrace if @options[:debug]
+
+          Result.new(data: nil, error: e)
         end
-      rescue StandardError => e
-        puts e.backtrace
-        Result.new(data: nil, error: e)
       end
     end
 
-    def get_tree(node, prefix = '')
+    def get_tree(node, prefix = "")
       path = File.join(prefix, node)
       obj = { path: nil }
 
       # puts "DEBUG: #{path} #{ FastIgnore.new.allowed? path }"
       if path != @dir.to_path &&
-         FastIgnore.new.allowed?(path, directory: false) == false
+           FastIgnore.new.allowed?(path, directory: false) == false
         return nil
       end
 

data/lib/trains/utils/rails_dir.rb

@@ -3,9 +3,9 @@ module Trains
     class RailsDir
       # checks if supplied dir is in a Rails app dir
       def self.check(root_path)
-        rails_bin = File.join(root_path, 'bin', 'rails')
+        rails_bin = File.join(root_path, "bin", "rails")
 
-        Result.new(File.exist?(rails_bin), nil)
+        Result.new(data: File.exist?(rails_bin), error: nil)
       end
     end
   end

data/lib/trains/utils/result.rb

@@ -1,5 +1,5 @@
 module Trains
   module Utils
-    Result = Struct.new('Result', :data, :error)
+    Result = Struct.new("Result", :data, :error, keyword_init: true)
   end
 end

data/lib/trains/version.rb

@@ -1,3 +1,3 @@
 module Trains
-  VERSION = '0.0.2'
+  VERSION = '0.0.4'
 end

data/lib/trains/visitor/controller.rb

@@ -1,5 +1,5 @@
-require_relative '../dto/controller'
-require_relative '../dto/method'
+require_relative "../dto/controller"
+require_relative "../dto/method"
 
 module Trains
   module Visitor
@@ -12,31 +12,33 @@ module Trains
       end
 
       def on_class(node)
-        class_name = node.identifier.const_name
-        parent_class = node.parent_class.const_name.to_sym
-
-        is_controller =
-          if parent_class.nil?
-            true if class_name == :ApplicationController
-          else
-            parent_class == :"ActionController::Base"
-          end
-        return unless is_controller
+        class_name = node.identifier.const_name.to_s
+        parent_class = node.parent_class.const_name.to_s
+        return unless controller?(parent_class)
 
         @class_name = class_name
-      end
-
-      # List out all controller methods
-      def on_def(node)
-        method_name = node.method_name
-        @method_list.append(
-          DTO::Method.new(name: method_name.to_s, visibility: nil, source: nil)
-        )
+        parse_body(node.body) unless node.body.nil?
       end
 
       def result
         DTO::Controller.new(name: @class_name, method_list: @method_list.uniq)
       end
+
+      private
+
+      def parse_body(body)
+        body.each_child_node do |child|
+          @method_list << parse_method(child) if child.type == :def
+        end
+      end
+
+      def controller?(parent_class)
+        %w[ActionController::Base ApplicationController].include? parent_class
+      end
+
+      def parse_method(node)
+        DTO::Method.new(name: node.method_name.to_s)
+      end
     end
   end
 end

data/lib/trains/visitor/migration.rb

@@ -1,10 +1,10 @@
-require 'yaml'
+require "yaml"
 
 module Trains
   module Visitor
     # Visitor that parses DB migration and associates them with Rails models
     class Migration < Base
-      def_node_matcher :send_node?, '(send nil? ...)'
+      def_node_matcher :send_node?, "(send nil? ...)"
       attr_reader :is_migration, :model
 
       def initialize
@@ -19,7 +19,7 @@ module Trains
       end
 
       def on_class(node)
-        unless node.parent_class.source.include? 'ActiveRecord::Migration'
+        unless node.parent_class.source.include? "ActiveRecord::Migration"
           return
         end
 
@@ -29,6 +29,12 @@ module Trains
         process_node(node.body)
       end
 
+      def result
+        DTO::Model.new(@table_name, @fields, @migration_version)
+      end
+
+      private
+
       def extract_version(class_const)
         match = class_const.match(/\d+.\d+/)
         return nil if match.nil?
@@ -37,44 +43,62 @@ module Trains
       end
 
       def process_node(node)
-        process_def_node(node) if node.def_type?
+        return unless node.def_type?
+
+        process_def_node(node)
       end
 
       def process_def_node(node)
         allowed_method_names = %i[change up down]
-        allowed_table_modifiers = %i[create_table update_column]
+        allowed_table_modifiers = %i[create_table update_column add_column]
+        block_type_modifier = false
 
         method_name = node.method_name
         return unless allowed_method_names.include? method_name
 
-        table_modifier = node.body.children[0].method_name
+        table_modifier =
+          if node.body.children[0] == nil
+            block_type_modifier = false
+            # if table modifier is a one-liner method call
+            node.body.children[1]
+          elsif node.body.children[0].block_type?
+            block_type_modifier = true
+            # if table modifier is in a block
+            node.body.children[0].method_name
+          end
         return unless allowed_table_modifiers.include? table_modifier
 
-        raw_table_name = node.body.children[0].children[0].children[2].value.to_s
-        @table_name = raw_table_name.singularize.camelize
+        # Get the name of the table being modified
+        if block_type_modifier
+          raw_table_name =
+            node.body.children[0].children[0].children[2].value.to_s
+          @table_name = raw_table_name.singularize.camelize
 
-        node.body.children[0].children[2].each_child_node do |child|
-          process_migration_field(child)
+          node.body.children[0].children[2].each_child_node do |child|
+            process_migration_field(child)
+          end
+        else
+          raw_table_name = node.body.children[2].value.to_s
+          @table_name = raw_table_name.singularize.camelize
+
+          field_name = node.body.children[3].value
+          field_type = node.body.children[4].value
+          @fields.append(DTO::Field.new(field_name, field_type))
         end
       end
 
       def process_migration_field(node)
         return unless node.send_type?
 
-        if node.children.count < 3
-          if node.children[1] == :timestamps
-            @fields.append(DTO::Field.new(:created_at, :datetime))
-            @fields.append(DTO::Field.new(:updated_at, :datetime))
-          end
-        elsif node.children.count >= 3
-          type = node.children[1]
-          value = node.children[2].value
-          @fields.append(DTO::Field.new(value, type))
+        if node.children[1] == :timestamps
+          @fields.append(DTO::Field.new(:created_at, :datetime))
+          @fields.append(DTO::Field.new(:updated_at, :datetime))
+          return
         end
-      end
-
-      def result
-        DTO::Model.new(@table_name, @fields, @migration_version)
+        
+        type = node.children[1]
+        value = node.children[2].value unless node.children[2].hash_type?
+        @fields.append(DTO::Field.new(value, type))
       end
     end
   end

data/lib/trains/visitor/route.rb

@@ -0,0 +1,78 @@
+require_relative "../dto/route"
+
+module Trains
+  module Visitor
+    class Route < Base
+      def_node_matcher :route_parent?, <<~PATTERN
+        (block (send (send (send
+          (const nil? :Rails) :application) :routes) :draw)
+        ...)
+      PATTERN
+
+      def_node_matcher :route_method?, <<~PATTERN
+        (send nil? %1 ...)
+      PATTERN
+
+      ALLOWED_VERBS = %i[get put post update delete resources scope]
+
+      def initialize
+        @route_list = []
+      end
+
+      def result
+        @route_list
+      end
+
+      def on_block(node)
+        return unless route_parent?(node)
+
+        node.body.each_child_node do |child|
+          ALLOWED_VERBS.each do |verb|
+            if route_method?(child, verb)
+              @route_list << parse_route(child, verb)
+            end
+          end
+        end
+      end
+
+      private
+
+      def parse_route(node, verb)
+        method = verb
+        param =
+          case node.arguments[0].type
+          when :sym, :str
+            node.arguments[0].value
+          end
+        options = parse_hash(node.arguments[1])
+        DTO::Route.new(method: method, param: param, options: options)
+      end
+
+      def parse_hash(node)
+        options = {}
+        return options unless node.type == :hash
+
+        node.each_pair { |key, value| options[key.value] = parse_value(value) }
+      rescue StandardError => e
+        puts node.parent
+      ensure
+        return options
+      end
+
+      def parse_value(node)
+        case node.type
+        when :hash
+          parse_hash(node)
+        when :array
+          node.values.map { |value| parse_value(value) }
+        when :send
+          if node.method_name == :redirect
+            { redirect: node.arguments.first.value }
+          end
+        else
+          node.value
+        end
+      end
+    end
+  end
+end

data/lib/trains/visitor/schema.rb

@@ -0,0 +1,88 @@
+module Trains
+  module Visitor
+    # Visitor that parses DB migration and associates them with Rails models
+    class Schema < Base
+      def_node_matcher :versioned_schema?, <<~PATTERN
+        (block
+          (send (send (const (const nil? :ActiveRecord) :Schema) :[] (float ...)) :define ...)
+        ...)
+      PATTERN
+
+      def_node_matcher :unversioned_schema?, <<~PATTERN
+       (block
+        (send (const (const nil? :ActiveRecord) :Schema) :define ...)
+       ...)
+      PATTERN
+
+      def initialize
+        @models = []
+        @columns = []
+        @is_versioned = false
+      end
+
+      def on_block(node)
+        is_schema = versioned_schema?(node) || unversioned_schema?(node)
+        return unless is_schema
+
+        process_schema_body(node)
+      end
+
+      def result
+        @models
+      end
+
+      private
+
+      def each_table(ast)
+        case ast.body.type
+        when :begin
+          ast.body.children.each do |node|
+            next unless node.block_type? && node.method?(:create_table)
+
+            yield(node)
+          end
+        else
+          yield ast.body
+        end
+      end
+
+      def each_content(node, &block)
+        return enum_for(__method__, node) unless block
+
+        case node.body&.type
+        when :begin
+          node.body.children.each(&block)
+        else
+          yield(node.body)
+        end
+      end
+
+      def build_columns(node)
+        each_content(node)
+          .map do |child|
+            next unless child&.send_type?
+            next if child.method?(:index)
+
+            DTO::Field.new(
+              name: child.first_argument.str_content,
+              type: child.method_name
+            )
+          end
+          .compact
+      end
+
+      def process_schema_body(node)
+        each_table(node) do |table|
+          @table_name = table.send_node.first_argument.value
+          @columns = build_columns(table)
+
+          @models << DTO::Model.new(
+            name: @table_name.singularize.camelize,
+            fields: @columns,
+            version: nil
+          )
+        end
+      end
+    end
+  end
+end

data/trains.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative 'lib/trains/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'trains'
+  spec.version = Trains::VERSION
+  spec.authors = ['Syed Faraaz Ahmad']
+  spec.email = ['faraaz98@live.com']
+
+  spec.summary =
+    'Collect metadata about your Rails app by statically analyzing it'
+  spec.homepage = 'https://github.com/faraazahmad/trains'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 2.6.0'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = "https://github.com/faraazahmad/trains/blob/master/CHANGELOG.md"
+
+  # 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(__dir__) do
+      `git ls-files -z`.split("\x0")
+                       .reject do |f|
+        (f == __FILE__) ||
+          f.match(
+            %r{\A(?:(?:bin|test|spec|features)/|\.(?:git|travis|circleci)|appveyor)}
+          )
+      end
+    end
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activesupport', '~> 7.0'
+  spec.add_dependency 'parallel', '~> 1.22'
+  spec.add_dependency 'rubocop-ast', '~> 1.16'
+  spec.add_dependency 'zeitwerk', '~> 2.5'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trains
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
 platform: ruby
 authors:
 - Syed Faraaz Ahmad
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-19 00:00:00.000000000 Z
+date: 2023-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -76,7 +76,6 @@ files:
 - ".deepsource.toml"
 - ".rspec"
 - ".rubocop.yml"
-- ".ruby-version"
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -90,8 +89,8 @@ files:
 - lib/trains/dto/field.rb
 - lib/trains/dto/method.rb
 - lib/trains/dto/model.rb
+- lib/trains/dto/route.rb
 - lib/trains/scanner.rb
-- lib/trains/utils/ast_store.rb
 - lib/trains/utils/logger.rb
 - lib/trains/utils/rails_dir.rb
 - lib/trains/utils/result.rb
@@ -100,6 +99,9 @@ files:
 - lib/trains/visitor/controller.rb
 - lib/trains/visitor/helper.rb
 - lib/trains/visitor/migration.rb
+- lib/trains/visitor/route.rb
+- lib/trains/visitor/schema.rb
+- trains.gemspec
 homepage: https://github.com/faraazahmad/trains
 licenses:
 - MIT
@@ -107,6 +109,7 @@ metadata:
   homepage_uri: https://github.com/faraazahmad/trains
   source_code_uri: https://github.com/faraazahmad/trains
   changelog_uri: https://github.com/faraazahmad/trains/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 post_install_message: 
 rdoc_options: []
 require_paths:

data/.ruby-version

@@ -1 +0,0 @@
-3.0.0

data/lib/trains/utils/ast_store.rb

@@ -1,25 +0,0 @@
-require 'singleton'
-
-module Trains
-  module Utils
-    class ASTStore
-      include Singleton
-
-      def initialize
-        @store = {}
-      end
-
-      def set(file_path, ast_object)
-        @store[file_path] = ast_object
-      end
-
-      def get(file_path)
-        unless @store.key? file_path
-          set(file_path,
-              RuboCop::AST::ProcessedSource.from_file(file_path, RUBY_VERSION.to_f))
-        end
-        @store[file_path]
-      end
-    end
-  end
-end