trains 0.0.8 → 0.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be756e07f687c79e259385beb680f5749c54a880273be056ba83a717aa821887
-  data.tar.gz: da3fc5403f7844919f9bfd3ac49ef37479e7f4149328e851d1b1e654353398af
+  metadata.gz: 706372a84f876f65aec9c638d6ad2c17dd6255f6dbc942bccbe1f0f81b86e069
+  data.tar.gz: 431b9033167ed91a657dd00ca806c16c1c3df454f74ec276eb7e79baf8407adf
 SHA512:
-  metadata.gz: 3a389ed84aedba71b13061c4233389d3008bd895a532f506a9f492a6d6aaa54ae96708d27f0e4cba9269f1666ef8f614c5ebf467a8bbf70c63595b449e2bcc0f
-  data.tar.gz: be28d384e28be094161bcdb28105a4bef9dd2d7f86978936f554bf699a205c1953a88bd1de071c1005f2ec4d5c54e91bf6ace9e20f7f917bc8204b46ced1a431
+  metadata.gz: a9b1de71a3735c43afee1f793ad0af94e9d8d7d0fced82023c3927d52e2821cf730b997ae7eeab53816208c11320ed4168c381d3d5fa18d0c1c8c8cb3f008006
+  data.tar.gz: c3eac1a413ece2f2ff937f642843aefb7188b63cd25c03d6f394a223b63a1ebb8c25c0a05e7d63c6c903d94687b2f59beb2eebed7b196c7f2e2405573a363075

data/lib/trains/scanner.rb

@@ -49,7 +49,7 @@ module Trains
     def generate_models
       return get_models if File.exist?(File.join(@dir, 'db', 'schema.rb'))
 
-      migrations = get_migrations
+      migrations = get_migrations.flatten.reject(&:nil?)
       Utils::MigrationTailor.stitch(migrations)
     end
 

data/lib/trains/utils/args.rb

@@ -5,6 +5,8 @@ module Trains
     # utility module to deal with parsing of arguments
     module Args
       def parse_args(node)
+        return if node.nil?
+
         case node.type
         when :hash
           parse_hash(node)
@@ -19,6 +21,8 @@ module Trains
 
         node.each_pair { |key, value| options[key.value] = parse_value(value) }
       rescue StandardError => e
+        puts 'Error boi'
+        puts e
         puts node.parent
       ensure
         return options
@@ -34,7 +38,13 @@ module Trains
           if node.method_name == :redirect
             { redirect: node.arguments.first.value }
           end
-        else
+        # skipcq: RB-LI1006
+        when :true
+          true
+        # skipcq: RB-LI1006
+        when :false
+          false
+        when :sym, :str, :integer
           node.value
         end
       end

data/lib/trains/utils/logger.rb

@@ -1,6 +1,14 @@
-module Logger
-  def debug(log)
-    puts '[DEBUG]:'.bold.blue
-    pp log
+# frozen_string_literal: true
+
+module Trains
+  module Utils
+    # Module with logging basics
+    module Logger
+      def self.debug(log)
+        puts '[DEBUG]:'
+        # skipcq: RB-RB-LI1008
+        pp log
+      end
+    end
   end
 end

data/lib/trains/utils/migration_tailor.rb

@@ -6,14 +6,14 @@ module Trains
 
         migrations.each do |mig|
           case mig.modifier
-          when :create_table
+          when :create_table, :create_join_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
+          when :add_column, :add_reference
             models[mig.table_name].fields.push(*mig.fields)
           when :remove_column
             column =
@@ -34,6 +34,9 @@ module Trains
 
             models[mig.table_name].fields << mig.fields.first
           end
+
+        rescue NoMethodError
+          next
         end
 
         models

data/lib/trains/version.rb

@@ -1,3 +1,3 @@
 module Trains
-  VERSION = '0.0.8'
+  VERSION = '0.0.10'.freeze
 end

data/lib/trains/visitor/migration.rb

@@ -4,19 +4,31 @@ 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? ...)'
-      attr_reader :is_migration, :model
+      include Utils::Args
 
+      def_node_matcher :send_node?, '(send nil? ...)'
+      attr_reader :is_migration, :model, :result
+
+      ALLOWED_METHOD_NAMES = %i[change up].freeze
+      ALLOWED_TABLE_MODIFIERS = %i[
+        create_table
+        create_join_table
+        change_table
+        safety_assured
+        update_column
+      ].freeze
+      COLUMN_MODIFIERS = %i[
+        add_column
+        change_column
+        add_reference
+        remove_column
+      ].freeze
+
+      # skipcq: RB-LI1087
       def initialize
-        @model = nil
-        @table_modifier = nil
-        @table_name = nil
-        @is_class = false
-        @is_migration = false
-        @class_name = nil
-        @fields = []
-
-        @scope = { class: nil, method: nil, send: nil }
+        @result = []
+        @migration_class = nil
+        @migration_version = nil
       end
 
       def on_class(node)
@@ -27,16 +39,12 @@ module Trains
         @migration_class = node.children.first.source
         @migration_version = extract_version(node.parent_class.source)
 
-        process_node(node.body)
-      end
+        node.each_descendant(:def) do |child_node|
+          next if child_node.body.nil?
+          next unless ALLOWED_METHOD_NAMES.include?(child_node.method_name)
 
-      def result
-        DTO::Migration.new(
-          table_name: @table_name,
-          modifier: @table_modifier,
-          fields: @fields,
-          version: @migration_version
-        )
+          process_migration(child_node)
+        end
       end
 
       private
@@ -48,75 +56,140 @@ module Trains
         match.to_s.to_f
       end
 
-      def process_node(node)
-        return unless node.def_type?
+      def process_migration(node)
+        case node.body.type
+        when :send
+          @result << parse_one_liner_migration(node.body)
+        when :begin
+          if node.body.children.map(&:type).include?(:block)
+            migration = parse_block_migration(node.body)
+            @result = [*@result, *migration] if migration
+          else
+            node.body.each_descendant(:send) do |send_node|
+              migration = parse_one_liner_migration(send_node)
+              @result << migration if migration
+            end
+          end
+        when :block
+          @result = [*@result, *parse_block_migration(node)]
+        when :if, :until
+          puts "Using unsupported logic within Rails migration: #{node.body.type}"
+        else
+          puts "[process_migration]: Unable to parse the following node:"
+          # skipcq: RB-RB-LI1008
+          pp node
+        end
+      end
+
+      def parse_one_liner_migration(node)
+        return unless COLUMN_MODIFIERS.include?(node.method_name)
+
+        arguments = node.arguments
+        table_name = arguments[0].value.to_s.singularize.camelize
+        column_name = arguments[1].value
+
+        if node.method_name == :add_reference
+          type = :bigint
+          column_name = "#{arguments[1].value}_id".to_sym
+        else
+          type = arguments[2].value unless node.method_name == :remove_column
+        end
 
-        process_def_node(node)
+        DTO::Migration.new(
+          table_name,
+          node.method_name,
+          [DTO::Field.new(column_name, type)],
+          @migration_version
+        )
       end
 
-      def process_def_node(node)
-        allowed_method_names = %i[change up down]
-        allowed_table_modifiers = %i[
-          create_table
-          change_table
-          update_column
-          add_column
-          remove_column
-          change_column
-          add_index
-        ]
-        column_modifiers = %i[
-          add_column
-          change_column
-          remove_column
-        ]
-
-        method_name = node.method_name
-        return unless allowed_method_names.include? method_name
-        return if node.body.nil?
-
-        table_modifier =
-          # if table modifier is a one-liner method call
-          if node.body.children[0].nil?
-            node.body.children[1]
-          elsif node.body.children[0].block_type?
-            # if table modifier is in a block
-            node.body.children[0].method_name
-          elsif node.body.children[0].send_type?
-            node.body.children[0].method_name
-          end
-        return unless allowed_table_modifiers.include? table_modifier
+      def parse_block_migration(node)
+        migrations = []
+        # Visit every send_node that performs DDL tasks
+        node.children.each do |ddl_node|
+          next if ddl_node.is_a?(Symbol)
+
+          fields = []
+          if ddl_node.is_a?(RuboCop::AST::BlockNode)
+            next unless ALLOWED_TABLE_MODIFIERS.include?(ddl_node.method_name)
 
-        @table_modifier = table_modifier
+            if ddl_node.method_name == :safety_assured
+              ddl_node.each_descendant(:send) do |send_node|
+                migrations = [*migrations,
+                              *parse_one_liner_migration(send_node)]
+              end
 
-        node.each_descendant(:send) do |send_node|
-          if allowed_table_modifiers.include?(send_node.method_name)
-            raw_table_name = send_node.arguments[0]
-            @table_name = raw_table_name.value.to_s.singularize.camelize
-            if column_modifiers.include?(send_node.method_name)
-              @fields.append(DTO::Field.new(send_node.arguments[1].value,
-                                            send_node.arguments[2]&.value))
+              next
             end
 
-            next
-          end
+            table_name = ddl_node.send_node.arguments[0].value.to_s.singularize.camelize
+            case ddl_node.method_name
+            when :create_join_table
+              field_one = ddl_node.send_node.arguments[0].value.to_s
+              field_two = ddl_node.send_node.arguments[1].value.to_s
+
+              table_name = field_one.camelize + field_two.camelize
+
+              fields << DTO::Field.new("#{field_one.singularize}_id".to_sym,
+                                       :bigint)
+              fields << DTO::Field.new("#{field_two.singularize}_id".to_sym,
+                                       :bigint)
+            when :create_table
+              fields << DTO::Field.new(:id, :bigint)
+            end
 
-          next if allowed_table_modifiers.include?(send_node.method_name)
+            ddl_node.body.each_descendant(:send) do |send_node|
+              fields = [*fields, *parse_migration_field(send_node)]
+            end
 
-          parse_migration_field(send_node)
+            migrations << DTO::Migration.new(
+              table_name,
+              ddl_node.method_name,
+              fields,
+              @migration_version
+            )
+          elsif ddl_node.is_a?(RuboCop::AST::SendNode)
+            migrations = [*migrations, *parse_one_liner_migration(ddl_node)]
+          end
         end
+
+        migrations
       end
 
       def parse_migration_field(node)
+        fields = []
+        # t.timestamps
         if node.children[1] == :timestamps
-          @fields.append(DTO::Field.new(:created_at, :datetime))
-          @fields.append(DTO::Field.new(:updated_at, :datetime))
-          return
+          fields << DTO::Field.new(:created_at, :datetime)
+          fields << DTO::Field.new(:updated_at, :datetime)
+          return fields
+        end
+
+        return [] if node.arguments.nil? || node.arguments.empty?
+
+        # method used to create the column
+        # string is the col_method in t.string
+        col_method = node.children[1]
+        case col_method
+        when :column
+          # t.column col_name, col_type
+          type = node.children[3].value
+          value = node.children[2].value
+          fields << DTO::Field.new(value, type)
+        when :references, :belongs_to
+          # t.references
+          type = :bigint
+          value = "#{node.children[2].value}_id".to_sym
+          fields << DTO::Field.new(value, type)
+        when :index
+        else
+          # t.string, t.integer etc.
+          type = node.children[1]
+          value = parse_args(node.children[2])
+          fields << DTO::Field.new(value, type)
         end
 
-        type = node.children[1]
-        value = node.children[2].value unless node.children[2].hash_type?
-        @fields.append(DTO::Field.new(value, type))
+        fields
       end
     end
   end

data/lib/trains/visitor/route.rb

@@ -36,7 +36,6 @@ module Trains
             end
           end
         end
-
       end
 
       private
@@ -48,7 +47,7 @@ module Trains
           when :sym, :str
             node.arguments[0].value
           end
-        options = parse_hash(node.arguments[1])
+        options = parse_args(node.arguments[1]) || {}
         DTO::Route.new(method:, param:, options:)
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trains
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.10
 platform: ruby
 authors:
 - Syed Faraaz Ahmad
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-05-23 00:00:00.000000000 Z
+date: 2023-06-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport