trains 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5967b89c0edf52539f69630d235c4e32b0a14a34e2739f593ca666e6ea451e02
-  data.tar.gz: 95ef423ff42e64a346931ce84d1becd8d810fcb92b52e51bf9f628d84821e273
+  metadata.gz: e4c83b37c56def34baa1bd60260cecec154d1da870f2b43471994f60c2a7397e
+  data.tar.gz: 3075d23e3f460a9787a0c1184c05ece0bbe21ca8d676bfa8828bb8b5cd91c1ac
 SHA512:
-  metadata.gz: 32e6e039363c647c6175a770636d4082edc081f525d8dba56628d47e1cf55e56218ca0b6b39969b9cf64b50e6216fcdcc5dc589d0abfeeffc01f224afc9b3aaa
-  data.tar.gz: 5de86fe0d626f302865a2b9b6b8d4c41ea6fbf9ff20ddc7057ef06a71cca1324af3c226a016339eb78d8bc8da5c7c7a914d5e7828d8ca6b0965daf3537db8e15
+  metadata.gz: 47357749dc2a2effab891336c1c0d2e338474288b720dd01eac00173adba3b9ce41f5bbd06bafec55b2319e25b2faa128aab9805c4251009de0ac3617661ac2c
+  data.tar.gz: 7dd8d5c09dd6a6e84da47a74f805dc9b26cfad3943f98d433668bb2f8d4adb1d4f08a5607355e1c2e9a25cee91e59ff4b3016f087dad05f9a86e57fbfe01c7cc

data/.deepsource.toml

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

data/Gemfile.lock

@@ -45,6 +45,7 @@ GEM
     zeitwerk (2.5.4)
 
 PLATFORMS
+  x86_64-darwin-21
   x86_64-linux
 
 DEPENDENCIES

data/README.md

@@ -10,8 +10,8 @@ A gem that statically analyses your Rails app and extracts information about its
 1. [Installation](#installation)
 2. [Usage](#usage)
 3. [Features](#features)
-    3.1 [Create Model definitions from migrations](#create-model-definitions-from-migrations)
-    3.2 [Create controller definitions from files](#create-controller-definitions-from-files)
+    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)

data/lib/trains/dto/app.rb

@@ -1,13 +1,8 @@
+# frozen_string_literal: true
+
 module Trains
   module DTO
-    App = Struct.new(
-      'App',
-      :name,
-      :controllers,
-      :models,
-      :migrations,
-      :helpers,
-      keyword_init: true
-    )
+    App =
+      Data.define(:name, :controllers, :models, :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/migration.rb

@@ -0,0 +1,5 @@
+module Trains
+  module DTO
+    Migration = Data.define(:table_name, :modifier, :fields, :version)
+  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,16 @@ 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
+      @models = {}
+      @controllers = {}
+      @helpers = {}
+      @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
@@ -32,62 +27,85 @@ module Trains
         )
       end
 
-      @migrations = Set[*get_migrations]
-      @controllers = Set[*get_controllers]
-      # @helpers = get_helpers
-      # @models = get_models
+      @models = generate_models unless @options[:models] == false
+      @controllers = get_controllers 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(
         name: nil,
         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
+
+    # Generate models from either db/schema.rb
+    # else stitch together migrations to create models
+    def generate_models
+      return get_models if File.exist?(File.join(@dir, 'db', 'schema.rb'))
+
+      migrations = get_migrations
+      Utils::MigrationTailor.stitch(migrations)
     end
 
-    def get_models; end
+    def get_routes
+      route_file = [File.join(@dir, 'config', 'routes.rb')]
 
-    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
+      routes_results = parse_util(route_file, Visitor::Route)
+      routes_results
+        .select { |result| result.error.nil? }
+        .map(&:data)
+        .flatten
+    end
+
+    def get_models
+      result_hash = {}
+      schema_file = [File.join(@dir, 'db', 'schema.rb')]
+      models_results = parse_util(schema_file, Visitor::Schema)
 
-      @helpers = parse_util(helpers, Visitor::Helper)
+      models_results
+        .select { |result| result.error.nil? }
+        .map(&:data)
+        .flatten
+        .each { |model| result_hash[model.name] = model }
+
+      result_hash
     end
 
+    def get_helpers; end
+
     def get_gemfile; end
 
     def get_controllers
+      result_hash = {}
       controllers =
         Dir.glob(File.join(@dir, 'app', 'controllers', '**', '*_controller.rb'))
+      controller_results = parse_util(controllers, Visitor::Controller)
+
+      controller_results
+        .select { |result| result.error.nil? }
+        .map(&:data)
+        .flatten
+        .each { |controller| result_hash[controller.name] = controller }
 
-      parse_util(controllers, Visitor::Controller)
+      result_hash
     end
 
     def get_migrations
       migrations = Dir.glob(File.join(@dir, 'db', 'migrate', '**', '*.rb'))
+      migration_results = parse_util(migrations, Visitor::Migration)
 
-      parse_util(migrations, Visitor::Migration)
+      migration_results
+        .select { |result| result.error.nil? }
+        .map(&: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,40 +118,22 @@ module Trains
         )
       end
 
-      begin
-        Parallel.map(file_nodes) do |node|
-          processed_source =
-            RuboCop::AST::ProcessedSource.from_file(node, RUBY_VERSION.to_f)
-          visitor = klass.new
-          visitor.process(processed_source.ast)
-          visitor.result
-        end
-      rescue StandardError => e
-        puts e.backtrace
-        Result.new(data: nil, error: e)
-      end
-    end
-
-    def get_tree(node, prefix = '')
-      path = File.join(prefix, node)
-      obj = { path: nil }
+      Parallel.map(file_nodes) do |node|
+        processed_source =
+          RuboCop::AST::ProcessedSource.from_file(node, RUBY_VERSION.to_f)
+        visitor = visitor_class.new
+        visitor.process(processed_source.ast)
 
-      # puts "DEBUG: #{path} #{ FastIgnore.new.allowed? path }"
-      if path != @dir.to_path &&
-         FastIgnore.new.allowed?(path, directory: false) == false
-        return nil
-      end
-
-      if Dir.exist? path
-        children = []
-        Dir.each_child path do |child|
-          child_node = get_tree(child, path)
-          children.append(child_node) unless child_node.nil?
+        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..."
+        if @options[:debug]
+          puts e.message
+          puts e.backtrace
         end
-        obj[:children] = children
-      end
 
-      obj
+        Result.new(data: nil, error: e)
+      end
     end
   end
 end

data/lib/trains/utils/migration_tailor.rb

@@ -0,0 +1,43 @@
+module Trains
+  module Utils
+    module MigrationTailor
+      def self.stitch(migrations)
+        models = {}
+
+        migrations.each do |mig|
+          case mig.modifier
+          when :create_table
+            models[mig.table_name] = {}
+            models[mig.table_name] = Trains::DTO::Model.new(
+              name: mig.table_name,
+              fields: mig.fields,
+              version: mig.version
+            )
+          when :add_column
+            models[mig.table_name].fields.push(*mig.fields)
+          when :remove_column
+            column =
+              models[mig.table_name].fields.find do |field|
+                field.name == mig.fields.first.name
+              end
+            models[mig.table_name].fields.delete(column)
+          when :change_table
+          # TODO: handle renaming columns
+          when :change_column
+            # get column
+            column =
+              models[mig.table_name].fields.find do |field|
+                field.name == mig.fields.first.name
+              end
+            # replace it with new column object
+            models[mig.table_name].fields.delete(column)
+
+            models[mig.table_name].fields << mig.fields.first
+          end
+        end
+
+        models
+      end
+    end
+  end
+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.3'
+  VERSION = '0.0.5'
 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,14 +1,15 @@
-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
         @model = nil
+        @table_modifier = nil
         @table_name = nil
         @is_class = false
         @is_migration = false
@@ -19,7 +20,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 +30,17 @@ module Trains
         process_node(node.body)
       end
 
+      def result
+        DTO::Migration.new(
+          table_name: @table_name,
+          modifier: @table_modifier,
+          fields: @fields,
+          version: @migration_version
+        )
+      end
+
+      private
+
       def extract_version(class_const)
         match = class_const.match(/\d+.\d+/)
         return nil if match.nil?
@@ -37,44 +49,72 @@ 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
+          change_table
+          update_column
+          add_column
+          remove_column
+          change_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
+        return if node.body.nil?
+
+        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
+        @table_modifier = table_modifier
 
-        node.body.children[0].children[2].each_child_node do |child|
-          process_migration_field(child)
+        # 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)
+          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,79 @@
+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)
+        return if node.body.nil?
+
+        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

@@ -36,4 +36,5 @@ Gem::Specification.new do |spec|
   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.3
+  version: 0.0.5
 platform: ruby
 authors:
 - Syed Faraaz Ahmad
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-02-19 00:00:00.000000000 Z
+date: 2023-04-21 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
@@ -89,10 +88,12 @@ files:
 - lib/trains/dto/controller.rb
 - lib/trains/dto/field.rb
 - lib/trains/dto/method.rb
+- lib/trains/dto/migration.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/migration_tailor.rb
 - lib/trains/utils/rails_dir.rb
 - lib/trains/utils/result.rb
 - lib/trains/version.rb
@@ -100,6 +101,8 @@ 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:
@@ -108,6 +111,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