ahnnotate 0.2.0

data/lib/ahnnotate/facet/models/module_node.rb

@@ -0,0 +1,123 @@
+module Ahnnotate
+  module Facet
+    module Models
+      # ModuleNode is named as such since `Class.is_a?(Module) == true`.
+      class ModuleNode
+        # By including ClassMethods this way, I'm including the methods as
+        # instance methods. I'm doing this so that I can compute the table name
+        # on per-class basis.
+        #
+        # It's a bit unfortunate that this class will be used to both (1) keep
+        # track of how classes/modules relate to each other and (2) compute the
+        # table name.
+        include ActiveRecord::ModelSchema::ClassMethods
+
+        # Named to fit the ModelSchema interface. This is basically `Class#name`
+        attr_accessor :name
+        # Named to fit the ModelSchema interface. This is the "outer class"
+        attr_accessor :parent
+        # Named to fit the ModelSchema interface. This is the class that the
+        # current class inherits from. This is computed, whereas
+        # `claimed_superclass` is what is parsed from the source
+        attr_accessor :superclass
+        # Named to fit the ModelSchema interface. This is currently unsupported
+        attr_accessor :table_name_prefix
+
+        attr_writer :claimed_superclass
+        attr_writer :abstract_class
+        attr_writer :is_a_kind_of_activerecord_base
+        attr_accessor :explicit_table_name
+        attr_accessor :is_active_record_base
+        attr_accessor :path
+
+        def initialize(name,
+          parent: nil,
+          is_a_kind_of_activerecord_base: false,
+          claimed_superclass: nil,
+          explicit_table_name: nil,
+          abstract_class: nil)
+          self.name = name
+          self.parent = parent
+          self.is_a_kind_of_activerecord_base = is_a_kind_of_activerecord_base
+          self.claimed_superclass = claimed_superclass
+          self.explicit_table_name = explicit_table_name
+          self.abstract_class = abstract_class
+        end
+
+        # Named to fit the ModelSchema interface
+        def pluralize_table_names
+          true
+        end
+
+        def table_name_suffix
+        end
+
+        def is_a_kind_of_activerecord_base?
+          !!@is_a_kind_of_activerecord_base
+        end
+
+        # Named to fit the ModelSchema interface
+        def abstract_class?
+          !!@abstract_class
+        end
+
+        def claimed_superclass
+          @claimed_superclass.to_s
+        end
+
+        # Named to fit the ModelSchema interface. It was originally implemented
+        # in ActiveRecord::Inheritance. I've re-implemented it here via the
+        # documentation.
+        def base_class
+          if superclass.is_active_record_base
+            return self
+          end
+
+          if superclass.abstract_class?
+            return self
+          end
+
+          superclass.base_class
+        end
+
+        # Named to fit the ModelSchema interface. It was originally implemented
+        # in ActiveSupport::Introspection
+        def parents
+          if parent
+            [parent, *parent.parent]
+          else
+            []
+          end
+        end
+
+        def class_name
+          if @name
+            "#{parent.class_name}::#{@name}"
+          else
+            ""
+          end
+        end
+
+        def table_name
+          if explicit_table_name
+            return @explicit_table_name
+          end
+
+          super
+        end
+
+        def <(other)
+          other == ActiveRecord::Base && is_a_kind_of_activerecord_base?
+        end
+
+        def ==(other)
+          if is_active_record_base && other == ActiveRecord::Base
+            return true
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/ahnnotate/facet/models/processor.rb

@@ -0,0 +1,91 @@
+module Ahnnotate
+  module Facet
+    module Models
+      class Processor < Parser::AST::Processor
+        def call(content)
+          sexp = Parser::CurrentRuby.parse(content)
+
+          @current_class = ModuleNode.new(nil)
+          @classes = [@current_class]
+
+          process(sexp)
+
+          @classes.reject { |klass| klass.class_name == "" }
+        end
+
+        def on_class(node)
+          @current_class = module_node_create(node, parent: @current_class)
+          @classes.push(@current_class)
+
+          super
+
+          @current_class = @current_class.parent
+        end
+
+        alias on_module on_class
+
+        def on_send(node)
+          receiver, method_name, assigned_node = *node
+
+          if receiver == s(:self) && method_name == :table_name=
+            table_name = assigned_node.children.last
+            @current_class.table_name = table_name
+          end
+
+          if receiver == s(:self) && method_name == :abstract_class=
+            abstract_class =
+              if assigned_node.type == :true
+                true
+              else
+                false
+              end
+            @current_class.abstract_class = abstract_class
+          end
+        end
+
+        # ignore instance method definitions since method definition bodies
+        # can't contain class declarations
+        def on_def(_)
+        end
+
+        # ignore class method definitions since method definition bodies can't
+        # contain class declarations
+        def on_defs(_)
+        end
+
+        private
+
+        def module_node_create(node, parent:)
+          class_node, superclass_node, _body_node = *node
+
+          if node.type == :module
+            superclass_node = nil
+          end
+
+          class_name = resolve_class_name(class_node)
+          superclass_name = resolve_class_name(superclass_node)
+
+          classlike = ModuleNode.new(class_name.to_s)
+          classlike.claimed_superclass = superclass_name.to_s
+          classlike.parent = parent
+
+          classlike
+        end
+
+        def resolve_class_name(node)
+          outer, name = *node
+
+          if outer.nil?
+            name
+          else
+            "#{resolve_class_name(outer)}::#{name}"
+          end
+        end
+
+        def s(type, *children)
+          AST::Node.new(type, children)
+        end
+      end
+    end
+  end
+end

data/lib/ahnnotate/facet/models/resolve_active_record_models.rb

@@ -0,0 +1,42 @@
+module Ahnnotate
+  module Facet
+    module Models
+      class ResolveActiveRecordModels
+        include ProcParty
+
+        def call(object_space)
+          tree = {}
+          object_space.each do |_class_name, extracted_class|
+            superclass = extracted_class.superclass
+
+            tree[superclass] ||= Set.new
+            tree[superclass].add(extracted_class)
+          end
+
+          activerecord_family =
+            gather_family(object_space["::ActiveRecord::Base"], tree)
+
+          activerecord_family.each do |individual|
+            individual.is_a_kind_of_activerecord_base = true
+          end
+
+          object_space.values - [object_space[""], object_space["::ActiveRecord::Base"]]
+        end
+
+        private
+
+        def gather_family(node, tree)
+          gather_family_helper(node, tree).flatten
+        end
+
+        def gather_family_helper(node, tree)
+          if tree[node].nil?
+            return node
+          end
+
+          [node] + tree[node].map { |child| gather_family_helper(child, tree) }
+        end
+      end
+    end
+  end
+end

data/lib/ahnnotate/facet/models/resolve_class_relationships.rb

@@ -0,0 +1,67 @@
+module Ahnnotate
+  module Facet
+    module Models
+      class ResolveClassRelationships
+        include ProcParty
+
+        def call(extracted_classes)
+          object_space =
+            extracted_classes
+              .map(&method(:self_and_outer_class))
+              .flatten
+              .compact
+              .uniq
+              .map { |x| [x.class_name, x] }
+              .to_h
+
+          object_space[""] ||= ModuleNode.new(nil)
+
+          object_space["::ActiveRecord::Base"] =
+            ModuleNode.new(
+              "ActiveRecord::Base",
+              parent: object_space[""],
+              abstract_class: nil
+            )
+          object_space["::ActiveRecord::Base"].is_active_record_base = true
+
+          object_space.each do |class_name, extracted_class|
+            possible_namespace_levels = class_name.split("::")[1..-2] || []
+
+            if extracted_class.claimed_superclass == "" || extracted_class.claimed_superclass == nil
+              next
+            end
+
+            (possible_namespace_levels.size + 1).times do
+              class_uri_parts =
+                possible_namespace_levels + [extracted_class.claimed_superclass]
+
+              class_uri = "::#{class_uri_parts.join("::")}"
+
+              if object_space[class_uri]
+                extracted_class.superclass = object_space[class_uri]
+                break
+              end
+
+              possible_namespace_levels.pop
+            end
+          end
+
+          object_space
+        end
+
+        private
+
+        def self_and_outer_class(extracted_class)
+          if extracted_class.nil?
+            return nil
+          end
+
+          [
+            extracted_class,
+            self_and_outer_class(extracted_class.parent)
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/ahnnotate/facet/models/standin.rb

@@ -0,0 +1,41 @@
+module Ahnnotate
+  module Facet
+    module Models
+      class Standin
+        # Lol. It's a little easier in this case to deal with instances here.
+        # I'll need to create many instances to recreate the class structure of
+        # the models in order to most correctly compute the table name from the
+        # model name 🥳
+        include ActiveRecord::ModelSchema::ClassMethods
+
+        # boolean, is this an abstract class
+        attr_writer :abstract_class
+        # the class that the current class inherits from
+        attr_accessor :superclass
+        attr_accessor :base_class
+        # the outer class
+        attr_accessor :parent
+
+        def initialize(abstract_class:, superclass:, base_class:, parent:, is_active_record_base: false)
+          @abstract_class = abstract_class
+          @superclass = superclass
+          @base_class = base_class
+          @parent = parent
+          @is_active_record_base = is_active_record_base
+        end
+
+        def abstract_class?
+          !!@abstract_class
+        end
+
+        def ==(other)
+          if @is_active_record_base && other == ActiveRecord::Base
+            return true
+          end
+
+          super
+        end
+      end
+    end
+  end
+end

data/lib/ahnnotate/facet/models.rb

@@ -0,0 +1,10 @@
+module Ahnnotate
+  module Facet
+    module Models
+      def self.add(config, tables, vfs)
+        runner = Main.new(config, tables, vfs)
+        runner.call
+      end
+    end
+  end
+end

data/lib/ahnnotate/function/format.rb

@@ -0,0 +1,36 @@
+module Ahnnotate
+  module Function
+    class Format
+      attr_reader :comment
+
+      def initialize(comment:)
+        @comment = comment
+      end
+
+      def call(table, content)
+        table.string(comment: comment) + "\n" + strip_schema(content)
+      end
+
+      private
+
+      def strip_schema(content)
+        matches = pattern.match(content)
+
+        if matches
+          matches["post"]
+        else
+          content
+        end
+      end
+
+      def pattern
+        @pattern ||=
+          begin
+            newline = /\r?\n\r?/
+
+            /\A#{comment}\s==\sSchema\sInfo#{newline}?(?:^#{comment}[^\n]*$#{newline})*#{newline}(?<post>.*)/m
+          end
+      end
+    end
+  end
+end

data/lib/ahnnotate/function/main.rb

@@ -0,0 +1,32 @@
+module Ahnnotate
+  module Function
+    class Main
+      def initialize(root, options, config)
+        @root = root
+        @options = options
+        @config = config
+      end
+
+      def call
+        if @config["boot"]
+          eval @config["boot"]
+        end
+
+        vfs = Vfs.new(vfs_driver)
+
+        runner = Run.new(@config, vfs)
+        runner.call
+      end
+
+      private
+
+      def vfs_driver
+        if @options.fix?
+          VfsDriver::Filesystem.new(root: @root)
+        else
+          VfsDriver::ReadOnlyFilesystem.new(root: @root)
+        end
+      end
+    end
+  end
+end

data/lib/ahnnotate/function/run.rb

@@ -0,0 +1,24 @@
+module Ahnnotate
+  module Function
+    class Run
+      def initialize(config, vfs)
+        @config = config
+        @vfs = vfs
+      end
+
+      def call
+        Facet::Models.add(@config, tables_hash, @vfs)
+      end
+
+      private
+
+      def tables_hash
+        @tables_hash = tables.to_h
+      end
+
+      def tables
+        @tables ||= Tables.new
+      end
+    end
+  end
+end

data/lib/ahnnotate/function/tabularize.rb

@@ -0,0 +1,53 @@
+module Ahnnotate
+  module Function
+    class Tabularize
+      def initialize(prefix:, cell_divider:)
+        @prefix = prefix
+        @cell_divider = cell_divider
+      end
+
+      def call(data, column_names)
+        output = StringIO.new
+        minimum_column_lengths = Hash.new { 0 }
+
+        rows = data.map do |row|
+          row_hash = {}
+
+          column_names.each do |c|
+            value = row.public_send(c).to_s
+
+            row_hash[c] = value
+
+            if value.size > minimum_column_lengths[c]
+              minimum_column_lengths[c] = value.size
+            end
+          end
+
+          row_hash
+        end
+
+        rows.each do |row|
+          # Note: minimum_column_lengths shouldn't include any of the columns
+          # with a length of zero since they were never explicitly set (to 0)
+          minimum_column_lengths.each.with_index do |(column_name, column_max_length), index|
+            if index == 0
+              output.print(@prefix)
+            end
+
+            if_rightmost_column = index + 1 == minimum_column_lengths.size
+
+            if if_rightmost_column
+              output.puts "#{row[column_name]}"
+            else
+              column_length = row[column_name].size
+              spaces_length = column_max_length - column_length
+              output.print "#{row[column_name]}#{" " * spaces_length}#{@cell_divider}"
+            end
+          end
+        end
+
+        output.string.gsub(/ +$/, "")
+      end
+    end
+  end
+end

data/lib/ahnnotate/index.rb

@@ -0,0 +1,26 @@
+module Ahnnotate
+  class Index
+    attr_accessor :name
+    attr_accessor :columns
+    attr_accessor :comment
+    attr_accessor :unique
+
+    def initialize(**args)
+      args.each do |key, value|
+        public_send("#{key}=", value)
+      end
+    end
+
+    def presentable_columns
+      "(#{columns.join(", ")})"
+    end
+
+    def presentable_unique
+      if unique
+        "UNIQUE"
+      else
+        ""
+      end
+    end
+  end
+end

data/lib/ahnnotate/options.rb

@@ -0,0 +1,48 @@
+module Ahnnotate
+  class Options
+    def self.attribute_names
+      @attribute_names ||= []
+    end
+
+    def self.attr_writer(*names)
+      attribute_names.push(*names)
+      super
+    end
+
+    def self.attr_question(*names)
+      names.each do |name|
+        attr_writer(name)
+
+        define_method("#{name}?") do
+          !!instance_variable_get("@#{name}")
+        end
+      end
+    end
+
+    attr_question :exit
+    attr_question :fix
+
+    def initialize(**args)
+      args.each do |key, value|
+        public_send("#{key}=", value)
+      end
+    end
+
+    def to_s
+      output = StringIO.new
+
+      output.puts "🧐  options:"
+      self.class.attribute_names.each do |attribute_name|
+        output.print "🧐    #{attribute_name}: "
+
+        if instance_variable_defined?("@#{attribute_name}")
+          output.puts "undefined"
+        else
+          output.puts instance_variable_get("@#{attribute_name}").inspect
+        end
+      end
+
+      output.string
+    end
+  end
+end

data/lib/ahnnotate/rails.rake

@@ -0,0 +1,44 @@
+namespace :db do
+  task :migrate do
+    $rake_ahnnotate_config ||= Ahnnotate::Config.load(root: Rails.root)
+
+    if $rake_ahnnotate_config["rake_db_autorun"]
+      Rake::Task["ahnnotate:all"].reenable
+      Rake::Task["ahnnotate:all"].invoke
+    end
+  end
+
+  task :rollback do
+    $rake_ahnnotate_config ||= Ahnnotate::Config.load(root: Rails.root)
+
+    if $rake_ahnnotate_config["rake_db_autorun"]
+      Rake::Task["ahnnotate:all"].reenable
+      Rake::Task["ahnnotate:all"].invoke
+    end
+  end
+end
+
+namespace :ahnnotate do
+  desc "Run ahnnotate"
+  task :all do
+    require "ahnnotate/cli"
+    require "shellwords"
+
+    # This should either be `rails` or `rake` (since newer versions of Rails
+    # can call rake tasks with either executable)
+    exe_name = File.basename($0)
+
+    argv = ENV.fetch("COMMENTATE", "--fix")
+    argv = Shellwords.split(argv)
+
+    puts "Commentating models..."
+
+    cli = Ahnnotate::Cli.new(name: "#{exe_name} ahnnotate")
+    cli.run(argv, $rake_ahnnotate_config)
+
+    puts "Done!"
+  end
+end
+
+desc "Run rake task `ahnnotate:all`"
+task ahnnotate: "ahnnotate:all"

data/lib/ahnnotate/railtie.rb

@@ -0,0 +1,7 @@
+module Ahnnotate
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load "ahnnotate/rails.rake"
+    end
+  end
+end

data/lib/ahnnotate/table.rb

@@ -0,0 +1,44 @@
+module Ahnnotate
+  class Table
+    attr_accessor :name
+    attr_accessor :columns
+    attr_accessor :indexes
+
+    def initialize(**args)
+      args.each do |key, value|
+        public_send("#{key}=", value)
+      end
+    end
+
+    def string(comment:)
+      tabularizer =
+        Function::Tabularize.new(
+          prefix: "#{comment}   ",
+          cell_divider: "    "
+        )
+
+      output = StringIO.new
+      output.puts "#{comment} == Schema Info"
+      output.puts comment
+      output.puts "#{comment} Table name: #{@name}"
+      output.puts comment
+      output.print tabularizer.call(columns, [:name, :type, :details])
+      output.puts comment
+
+      if indexes.any?
+        output.puts "#{comment} Indexes:"
+        output.puts comment
+        output.print tabularizer.call(indexes, [:name, :presentable_columns, :presentable_unique, :comment])
+        output.puts comment
+      end
+
+      output.string
+    end
+
+    private
+
+    def longest_column_name_length
+      @longest_column_name_length ||= @columns.map(&:name).map(&:size).max
+    end
+  end
+end