rubymonolith 0.1.5 → 0.1.7

data/app/controllers/monolith/models_controller.rb

@@ -0,0 +1,319 @@
+# app/controllers/monolith/models_controller.rb
+module Monolith
+  class ModelsController < Monolith::ApplicationController
+    def index
+      render Index.new.tap { _1.models = Model.all }
+    end
+
+    def show
+      model = Model.find(params[:id].to_s)
+      return render plain: "Model not found", status: :not_found unless model
+
+      render Show.new.tap { |v| v.model = model }
+    end
+
+    # =======================
+    # Inline ActiveModel-like object
+    # =======================
+    class Model
+      attr_reader :name, :klass
+
+      def self.all
+        Rails.application.eager_load!
+
+        models = ActiveRecord::Base.descendants
+          .reject(&:abstract_class?)
+          .sort_by(&:name)
+
+        models.map { |klass| new(klass) }
+      end
+
+      def self.find(name)
+        Rails.application.eager_load!
+
+        klass = ActiveRecord::Base.descendants.find { |k| k.name == name }
+        klass && new(klass)
+      end
+
+      def initialize(klass)
+        @klass = klass
+        @name = klass.name
+      end
+
+      def to_param
+        name
+      end
+
+      def table_name
+        klass.table_name
+      end
+
+      def column_names
+        klass.column_names
+      rescue
+        []
+      end
+
+      def primary_key
+        klass.primary_key
+      rescue
+        nil
+      end
+
+      def validations
+        klass.validators.map do |validator|
+          {
+            type: validator.class.name.demodulize.gsub(/Validator$/, ''),
+            attributes: validator.attributes,
+            options: validator.options
+          }
+        end
+      rescue
+        []
+      end
+
+      def associations
+        klass.reflect_on_all_associations.map do |assoc|
+          {
+            name: assoc.name,
+            type: assoc.macro,
+            class_name: assoc.class_name,
+            foreign_key: assoc.foreign_key,
+            options: assoc.options
+          }
+        end
+      rescue
+        []
+      end
+
+      def scopes
+        # Get custom scopes (not default scopes)
+        scope_names = klass.respond_to?(:scopes) ? klass.scopes.keys : []
+        scope_names.map(&:to_s).sort
+      rescue
+        []
+      end
+
+      def callbacks
+        [:before_validation, :after_validation, :before_save, :after_save,
+         :before_create, :after_create, :before_update, :after_update,
+         :before_destroy, :after_destroy].flat_map do |callback_type|
+          klass._get_callbacks(callback_type).map do |callback|
+            {
+              type: callback_type,
+              filter: callback.filter
+            }
+          end
+        end.compact
+      rescue
+        []
+      end
+
+      def source_location
+        return nil unless klass.respond_to?(:instance_methods)
+
+        # Try to find the model file
+        file_path = "#{Rails.root}/app/models/#{name.underscore}.rb"
+        File.exist?(file_path) ? file_path : nil
+      end
+
+      def source_code
+        return nil unless source_location
+
+        File.read(source_location)
+      rescue
+        nil
+      end
+
+      def instance_methods
+        (klass.instance_methods - ActiveRecord::Base.instance_methods)
+          .sort
+          .map(&:to_s)
+      rescue
+        []
+      end
+
+      def class_methods
+        (klass.methods - ActiveRecord::Base.methods)
+          .sort
+          .map(&:to_s)
+      rescue
+        []
+      end
+    end
+
+    # =======================
+    # Phlex views
+    # =======================
+    class Index < View
+      attr_writer :models
+
+      def view_template
+        div(class: "p-6 space-y-4") do
+          h1(class: "text-2xl font-bold") { "Models" }
+          p(class: "text-sm") { "#{@models.size} ActiveRecord models in your application." }
+
+          Table @models do
+            it.row("Model") {
+              nav_link it.name, controller: "/monolith/models", action: :show, id: it.to_param
+            }
+            it.row("Table") { |m|
+              code { m.table_name }
+            }
+            it.row("Columns") {
+              it.column_names.size.to_s
+            }
+          end
+        end
+      end
+    end
+
+    class Show < View
+      attr_writer :model
+
+      def view_template
+        m = @model
+
+        div(class: "p-6 space-y-6") do
+          h1(class: "text-2xl font-bold") { m.name }
+          p { code { m.table_name } }
+
+          # Columns
+          section do
+            h2(class: "text-xl font-bold mb-2") { "Columns (#{m.column_names.size})" }
+            if m.column_names.any?
+              ul(class: "list-disc pl-6") do
+                m.column_names.each do |col|
+                  li {
+                    plain col
+                    if col == m.primary_key
+                      span(class: "text-sm") { " (primary key)" }
+                    end
+                  }
+                end
+              end
+            else
+              p { em { "No columns" } }
+            end
+          end
+
+          # Validations
+          section do
+            h2(class: "text-xl font-bold mb-2") { "Validations (#{m.validations.size})" }
+            if m.validations.any?
+              ul(class: "list-disc pl-6 space-y-1") do
+                m.validations.each do |validation|
+                  li do
+                    strong { validation[:type] }
+                    plain " on "
+                    code { validation[:attributes].join(", ") }
+                    if validation[:options].any?
+                      plain " "
+                      code { validation[:options].inspect }
+                    end
+                  end
+                end
+              end
+            else
+              p { em { "No validations" } }
+            end
+          end
+
+          # Associations
+          section do
+            h2(class: "text-xl font-bold mb-2") { "Associations (#{m.associations.size})" }
+            if m.associations.any?
+              ul(class: "list-disc pl-6 space-y-1") do
+                m.associations.each do |assoc|
+                  li do
+                    strong { assoc[:type].to_s }
+                    plain " :"
+                    code { assoc[:name].to_s }
+                    plain " → "
+                    plain assoc[:class_name]
+                    plain " (FK: "
+                    code { assoc[:foreign_key].to_s }
+                    plain ")"
+                  end
+                end
+              end
+            else
+              p { em { "No associations" } }
+            end
+          end
+
+          # Scopes
+          if m.scopes.any?
+            section do
+              h2(class: "text-xl font-bold mb-2") { "Scopes (#{m.scopes.size})" }
+              ul(class: "list-disc pl-6") do
+                m.scopes.each do |scope_name|
+                  li { code { scope_name } }
+                end
+              end
+            end
+          end
+
+          # Callbacks
+          if m.callbacks.any?
+            section do
+              h2(class: "text-xl font-bold mb-2") { "Callbacks (#{m.callbacks.size})" }
+              ul(class: "list-disc pl-6 space-y-1") do
+                m.callbacks.each do |callback|
+                  li do
+                    strong { callback[:type].to_s }
+                    plain " → "
+                    code { callback[:filter].to_s }
+                  end
+                end
+              end
+            end
+          end
+
+          # Instance Methods
+          if m.instance_methods.any?
+            section do
+              h2(class: "text-xl font-bold mb-2") { "Instance Methods (#{m.instance_methods.size})" }
+              details do
+                summary(class: "cursor-pointer") { "Show methods" }
+                ul(class: "list-disc pl-6 mt-2 grid grid-cols-2 md:grid-cols-3 gap-1") do
+                  m.instance_methods.each do |method_name|
+                    li { code { method_name } }
+                  end
+                end
+              end
+            end
+          end
+
+          # Class Methods
+          if m.class_methods.any?
+            section do
+              h2(class: "text-xl font-bold mb-2") { "Class Methods (#{m.class_methods.size})" }
+              details do
+                summary(class: "cursor-pointer") { "Show methods" }
+                ul(class: "list-disc pl-6 mt-2 grid grid-cols-2 md:grid-cols-3 gap-1") do
+                  m.class_methods.each do |method_name|
+                    li { code { method_name } }
+                  end
+                end
+              end
+            end
+          end
+
+          # Source Code
+          if m.source_code
+            section do
+              h2(class: "text-xl font-bold mb-2") { "Source Code" }
+              p(class: "text-sm mb-2") { code { m.source_location } }
+              pre(class: "border p-4 overflow-x-auto text-xs") do
+                code { m.source_code }
+              end
+            end
+          end
+
+          div(class: "pt-4") { nav_link "← All models", controller: "/monolith/models", action: :index }
+        end
+      end
+    end
+  end
+end

data/app/controllers/monolith/routes_controller.rb

@@ -0,0 +1,157 @@
+# app/controllers/monolith/routes_controller.rb
+module Monolith
+  class RoutesController < Monolith::ApplicationController
+    def index
+      render Index.new.tap { _1.routes = Route.all }
+    end
+
+    def show
+      route = Route.find(params[:id].to_s)
+      return render plain: "Route not found", status: :not_found unless route
+
+      render Show.new.tap { |v| v.route = route }
+    end
+
+    # =======================
+    # Inline ActiveModel-like object
+    # =======================
+    class Route
+      attr_reader :name, :verb, :path, :controller, :action, :constraints, :defaults, :required_parts
+
+      def self.all
+        Rails.application.routes.routes.map.with_index { |route, idx| from_route(route, idx) }.compact.sort_by(&:display_name)
+      end
+
+      def self.find(id)
+        all.find { |r| r.to_param == id }
+      end
+
+      def self.from_route(route, idx)
+        name = route.name.to_s
+        verb = route.verb.to_s
+        path = route.path.spec.to_s
+
+        # Extract controller and action
+        defaults = route.defaults
+        controller = defaults[:controller]
+        action = defaults[:action]
+
+        # Skip routes without controller/action or internal Rails routes
+        return nil if controller.nil? || action.nil?
+        return nil if controller.to_s.start_with?("rails/")
+
+        new(
+          name: name.empty? ? nil : name,
+          verb: verb,
+          path: path,
+          controller: controller,
+          action: action,
+          constraints: route.constraints.except(:request_method),
+          defaults: defaults.except(:controller, :action),
+          required_parts: route.required_parts,
+          id: idx
+        )
+      end
+
+      def initialize(name:, verb:, path:, controller:, action:, constraints:, defaults:, required_parts:, id:)
+        @name = name
+        @verb = verb
+        @path = path
+        @controller = controller
+        @action = action
+        @constraints = constraints
+        @defaults = defaults
+        @required_parts = required_parts
+        @id = id
+      end
+
+      def to_param
+        @id.to_s
+      end
+
+      def display_name
+        name || "#{controller}##{action}"
+      end
+
+      def full_controller_action
+        "#{controller}##{action}"
+      end
+    end
+
+    # =======================
+    # Phlex views
+    # =======================
+    class Index < View
+      attr_writer :routes
+
+      def view_template
+        div(class: "p-6 space-y-4") do
+          h1(class: "text-2xl font-bold") { "Routes" }
+          p(class: "text-sm") { "#{@routes.size} routes in your Rails application." }
+
+          Table @routes do
+            it.row("Name") {
+              nav_link it.display_name, controller: "/monolith/routes", action: :show, id: it.to_param
+            }
+            it.row("Verb") { |r|
+              code { r.verb }
+            }
+            it.row("Path") { |r|
+              code { r.path }
+            }
+            it.row("Controller#Action") {
+              it.full_controller_action
+            }
+          end
+        end
+      end
+    end
+
+    class Show < View
+      attr_writer :route
+
+      def view_template
+        r = @route
+
+        div(class: "p-6 space-y-4") do
+          h1(class: "text-2xl font-bold") { r.display_name }
+          p { code { "#{r.verb} #{r.path}" } }
+
+          dl(class: "grid grid-cols-1 md:grid-cols-2 gap-x-8 gap-y-2") do
+            dt(class: "font-semibold") { "Name" }
+            dd { r.name || em { "—" } }
+
+            dt(class: "font-semibold") { "Verb" }
+            dd { code { r.verb } }
+
+            dt(class: "font-semibold") { "Path" }
+            dd { code { r.path } }
+
+            dt(class: "font-semibold") { "Controller" }
+            dd { r.controller }
+
+            dt(class: "font-semibold") { "Action" }
+            dd { r.action }
+
+            if r.required_parts.any?
+              dt(class: "font-semibold") { "Required Parts" }
+              dd { r.required_parts.join(", ") }
+            end
+
+            if r.defaults.any?
+              dt(class: "font-semibold") { "Defaults" }
+              dd { code { r.defaults.inspect } }
+            end
+
+            if r.constraints.any?
+              dt(class: "font-semibold") { "Constraints" }
+              dd { code { r.constraints.inspect } }
+            end
+          end
+
+          div(class: "pt-4") { nav_link "← All routes", controller: "/monolith/routes", action: :index }
+        end
+      end
+    end
+  end
+end

data/app/controllers/monolith/tables_controller.rb

@@ -0,0 +1,168 @@
+# app/controllers/monolith/tables_controller.rb
+module Monolith
+  class TablesController < Monolith::ApplicationController
+    before_action :set_pagination
+    before_action :set_table, only: :show
+
+    def index
+      render Index.new.tap { _1.tables = Table.all }
+    end
+
+    def show
+      not_found! unless @table
+      rows = @table.rows(page: @page, per_page: @per_page)
+      render Show.new.tap { |v|
+        v.table   = @table
+        v.rows    = rows[:data]
+        v.total   = rows[:total]
+        v.page    = @page
+        v.per_page= @per_page
+      }
+    end
+
+    private
+
+    def set_pagination
+      @page     = params[:page].to_i
+      @page     = 1 if @page < 1
+      @per_page = (params[:per_page] || 50).to_i
+      @per_page = 50 if @per_page <= 0
+      @per_page = 500 if @per_page > 500
+    end
+
+    def set_table
+      @table = Table.find(params[:id].to_s) if params[:id].present?
+    end
+
+    def not_found!
+      render plain: "Not found", status: :not_found
+    end
+
+    # =======================
+    # Inline ActiveModel-like object
+    # =======================
+    class Table
+      attr_reader :name
+
+      EXCLUDED = %w[schema_migrations ar_internal_metadata].freeze
+
+      def self.all
+        tables.map { |t| new(t) }
+      end
+
+      def self.find(name)
+        return nil unless tables.include?(name)
+        new(name)
+      end
+
+      # ---- instance ----
+      def initialize(name)
+        @name = name
+      end
+
+      def to_param = name
+
+      def columns
+        @columns ||= conn.columns(name).map(&:name)
+      end
+
+      def primary_key
+        @primary_key ||= conn.primary_key(name)
+      end
+
+      # Returns { data: [Hash], total: Integer }
+      def rows(page:, per_page:)
+        offset = (page - 1) * per_page
+        total  = conn.exec_query("SELECT COUNT(*) AS c FROM #{qtn(name)}").first["c"]
+
+        order_sql = primary_key ? "ORDER BY #{qcn(primary_key)}" : ""
+        sql = <<~SQL
+          SELECT *
+          FROM #{qtn(name)}
+          #{order_sql}
+          LIMIT #{per_page.to_i} OFFSET #{offset.to_i}
+        SQL
+
+        data = conn.exec_query(sql).to_a
+        { data: data, total: total }
+      end
+
+      private
+
+      def self.conn = ActiveRecord::Base.connection
+      def conn = self.class.conn
+
+      def self.tables
+        @tables ||= (conn.tables - EXCLUDED).sort
+      end
+
+      def qtn(t) = conn.quote_table_name(t)
+      def qcn(c) = "#{qtn(name)}.#{conn.quote_column_name(c)}"
+    end
+
+    # =======================
+    # Phlex views
+    # =======================
+    class Index < View
+      attr_writer :tables
+
+      def view_template
+        div(class: "p-6 space-y-4") do
+          h1(class: "text-2xl font-bold") { "Tables" }
+          ul(class: "list-disc pl-6 space-y-1") do
+            @tables.each do |t|
+              li { nav_link t.name, controller: "/monolith/tables", action: :show, id: t.name }
+            end
+          end
+        end
+      end
+    end
+
+    class Show < View
+      attr_writer :table, :rows, :page, :per_page, :total
+
+      def view_template
+        div(class: "p-6 space-y-4") do
+          h1(class: "text-2xl font-bold") { @table.name }
+          p do
+            plain "Rows "
+            strong { "#{start_row}-#{end_row}" }
+            plain " of #{@total} (per page: #{@per_page})"
+            if @table.primary_key
+              span(class: "ml-2 text-sm") { "PK: #{@table.primary_key}" }
+            end
+          end
+
+          Table @table.columns do
+            it.row(col) {
+              format_cell(it[col])
+            }
+          end
+
+          div(class: "flex items-center gap-3") do
+            if @page > 1
+              nav_link "← Prev", controller: "/monolith/tables", action: :show, id: @table.name, page: @page - 1, per_page: @per_page
+            end
+            if end_row < @total
+              nav_link "Next →", controller: "/monolith/tables", action: :show, id: @table.name, page: @page + 1, per_page: @per_page
+            end
+            span(class: "text-sm ml-auto") { "Page #{@page}" }
+            nav_link "All tables", controller: "/monolith/tables", action: :index
+          end
+        end
+      end
+
+      def start_row = ((@page - 1) * @per_page) + 1
+      def end_row = [@page * @per_page, @total].min
+
+      def format_cell(v)
+        case v
+        when Hash, Array then code { v.ai(plain: true) rescue v.to_json }
+        when Time, DateTime, Date then v.iso8601
+        else
+          v.nil? ? em { "NULL" } : v.to_s
+        end
+      end
+    end
+  end
+end

data/app/views/monolith/base.rb

@@ -0,0 +1,3 @@
+class Monolith::Views::Base < Monolith::Components::Base
+  include Phlex::Rails::Layout
+end

data/app/views/monolith/layouts/base.rb

@@ -0,0 +1,23 @@
+class Monolith::Views::Layouts::Base < Monolith::Views::Base
+  def around_template(&)
+    html do
+      head do
+        title { @title }
+        meta name: "viewport", content: "width=device-width,initial-scale=1"
+        meta charset: "utf-8"
+        meta name: "apple-mobile-web-app-capable", content: "yes"
+        meta name: "apple-mobile-web-app-status-bar-style", content: "black-translucent"
+        csp_meta_tag
+        csrf_meta_tags
+        stylesheet_link_tag "monolith/tailwind", data_turbo_track: "reload"
+        javascript_importmap_tags
+      end
+
+      body(&)
+    end
+  end
+
+  def view_template
+    yield self if block_given?
+  end
+end

data/config/routes.rb

@@ -1,2 +1,16 @@
 Monolith::Engine.routes.draw do
+  root to: "home#show"
+
+  resources :emails, only: [:index, :show]
+  resources :tables, only: [:index, :show]
+  resources :gems, only: [:index, :show]
+  resources :routes, only: [:index, :show]
+  resources :models, only: [:index, :show]
+  resources :generators, only: [:index, :show] do
+    member do
+      post :create
+    end
+  end
+
+  get "/exceptions/:id", to: "exceptions#show", as: :exception
 end

data/lib/generators/monolith/content/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Explain the generator
+
+Example:
+    bin/rails generate install Thing
+
+    This will create:
+        what/will/it/create