antoinette 0.1.0 → 0.1.1

data/lib/antoinette/services/weaver.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "haikunator"
+require "json"
+
+module Antoinette
+  class Weaver
+    Bundle = Struct.new(:name, :elm_apps, :templates)
+
+    def initialize(
+      elm_analyzer: ElmAppUsageAnalyzer.new,
+      partial_resolver: PartialResolver.new,
+      custom_view_paths: []
+    )
+      @elm_analyzer = elm_analyzer
+      @partial_resolver = partial_resolver
+      @custom_view_paths = custom_view_paths
+    end
+
+    def bundles
+      @bundles ||= @elm_analyzer.layout_apps.then do |layout_apps|
+        @elm_analyzer.mappings.map do |apps, templates|
+          resolved_templates = resolve_templates_from_partials(templates)
+          merged_apps = (apps + layout_apps).uniq.sort
+          Bundle.new(
+            Haikunator.haikunate,
+            merged_apps,
+            resolved_templates.sort
+          )
+        end.sort_by { |bundle| -bundle.elm_apps.count }
+      end
+    end
+
+    def generate_json
+      output = {bundles: bundles.map do |bundle|
+        {
+          name: bundle.name,
+          elm_apps: bundle.elm_apps,
+          templates: bundle.templates
+        }
+      end}
+      output[:custom_view_paths] = @custom_view_paths if @custom_view_paths.any?
+      JSON.pretty_generate(output)
+    end
+
+    def resolve_templates_from_partials(templates)
+      templates.flat_map do |template|
+        if template.start_with?("_") || template.include?("/_")
+          partial_path = template.sub(%r{^app/views/}, "")
+          @partial_resolver.resolve(partial_path).map do |parent|
+            "app/views/#{parent}"
+          end
+        else
+          template
+        end
+      end.uniq
+    end
+  end
+end

data/lib/antoinette/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Antoinette
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/antoinette.rb

@@ -1,6 +1,15 @@
-require "antoinette/version"
+# frozen_string_literal: true
+
+require_relative "antoinette/version"
+require_relative "antoinette/services/partial_resolver"
+require_relative "antoinette/services/elm_app_usage_analyzer"
+require_relative "antoinette/services/weaver"
+require_relative "antoinette/services/compile_elm"
+require_relative "antoinette/services/concat_bundle"
+require_relative "antoinette/services/inject_script_tag"
+require_relative "antoinette/services/clear_script_tag"
+require_relative "antoinette/cli/commands"
+require_relative "antoinette/engine" if defined?(Rails::Engine)
 
 module Antoinette
-  class Error < StandardError; end
-  # Your code goes here...
 end

data/lib/generators/antoinette/install_generator.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/base"
+
+module Antoinette
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Install Antoinette into your Rails application"
+
+      def create_config_file
+        create_file "config/antoinette.json", <<~JSON
+          {
+            "elm_path": "elm",
+            "bundles": []
+          }
+        JSON
+      end
+
+      def create_client_directory
+        empty_directory "app/client"
+      end
+
+      def copy_elm_files
+        copy_file "BundleGraph.elm", "app/client/BundleGraph.elm"
+        copy_file "Sankey.elm", "app/client/Sankey.elm"
+      end
+
+      def install_elm_dependencies
+        say "Installing Elm dependencies..."
+        run "elm install elm/browser"
+        run "elm install elm/html"
+        run "elm install elm/json"
+        run "elm install elm/svg"
+      end
+
+      def copy_controller
+        copy_file "graph_controller.rb", "app/controllers/antoinette/graph_controller.rb"
+      end
+
+      def copy_view
+        copy_file "show.html.erb", "app/views/antoinette/graph/show.html.erb"
+      end
+
+      def create_antoinette_binstub
+        create_file "bin/antoinette", <<~RUBY
+          #!/usr/bin/env ruby
+          require_relative "../config/environment"
+          Dry::CLI.new(Antoinette::CLI::Commands).call
+        RUBY
+        chmod "bin/antoinette", 0o755
+      end
+
+      def create_assets_directory
+        empty_directory "app/assets/javascripts/antoinette"
+      end
+
+      def update_gitignore
+        gitignore_path = Rails.root.join(".gitignore")
+        ignore_line = "app/assets/javascripts/antoinette/"
+
+        if File.exist?(gitignore_path) && !File.read(gitignore_path).include?(ignore_line)
+          append_to_file ".gitignore", "#{ignore_line}\n"
+        end
+      end
+
+      def add_routes
+        route_content = <<~RUBY
+          get "/antoinette", to: "antoinette/graph#show"
+        RUBY
+
+        route route_content
+      end
+
+      def show_post_install_message
+        say ""
+        say "Antoinette has been installed!", :green
+        say ""
+        say "Next steps:"
+        say "  1. Run `bin/antoinette config` to generate bundle configuration"
+        say "  2. Run `bin/antoinette build` to compile Elm bundles"
+        say ""
+      end
+    end
+  end
+end

data/lib/generators/antoinette/templates/BundleGraph.elm

@@ -0,0 +1,344 @@
+module BundleGraph exposing (main)
+
+import Browser
+import Dict
+import Html exposing (Html, button, div, h1, text)
+import Html.Attributes exposing (disabled, style)
+import Html.Events exposing (onClick)
+import Json.Decode as Decode exposing (Decoder)
+import Sankey exposing (layout, render)
+
+
+type alias Model =
+    { bundles : List Bundle
+    , selectedNodeId : Maybe String
+    , lockedNodeIds : List String
+    }
+
+
+type alias Bundle =
+    { name : String
+    , elmApps : List String
+    , templates : List String
+    }
+
+
+type alias Flags =
+    { bundles : List Bundle
+    }
+
+
+type alias LabelNode =
+    { id : String
+    , label : String
+    , column : Int
+    }
+
+
+type Msg
+    = SelectNode String
+    | DeselectNode
+    | ToggleLockNode String
+    | ClearSelection
+
+
+main : Program Decode.Value Model Msg
+main =
+    Browser.element
+        { init = init
+        , update = update
+        , view = view
+        , subscriptions = \_ -> Sub.none
+        }
+
+
+init : Decode.Value -> ( Model, Cmd Msg )
+init flags =
+    case Decode.decodeValue flagsDecoder flags of
+        Ok decoded ->
+            ( { bundles = decoded.bundles
+              , selectedNodeId = Nothing
+              , lockedNodeIds = []
+              }
+            , Cmd.none
+            )
+
+        Err _ ->
+            ( { bundles = []
+              , selectedNodeId = Nothing
+              , lockedNodeIds = []
+              }
+            , Cmd.none
+            )
+
+
+update : Msg -> Model -> ( Model, Cmd Msg )
+update msg model =
+    case msg of
+        SelectNode appId ->
+            ( { model | selectedNodeId = Just appId }, Cmd.none )
+
+        DeselectNode ->
+            case model.selectedNodeId of
+                Just nodeId ->
+                    if List.member nodeId model.lockedNodeIds then
+                        ( model, Cmd.none )
+
+                    else
+                        ( { model | selectedNodeId = Nothing }, Cmd.none )
+
+                Nothing ->
+                    ( model, Cmd.none )
+
+        ToggleLockNode nodeId ->
+            if List.member nodeId model.lockedNodeIds then
+                ( { model
+                    | lockedNodeIds = List.filter (\id -> id /= nodeId) model.lockedNodeIds
+                  }
+                , Cmd.none
+                )
+
+            else
+                ( { model | lockedNodeIds = nodeId :: model.lockedNodeIds }
+                , Cmd.none
+                )
+
+        ClearSelection ->
+            ( { model | selectedNodeId = Nothing, lockedNodeIds = [] }, Cmd.none )
+
+
+view : Model -> Html Msg
+view model =
+    let
+        nodes =
+            buildNodes model.bundles
+
+        columnWidths =
+            buildColumnWidths nodes
+
+        highlightedNodeIds =
+            case model.selectedNodeId of
+                Just id ->
+                    id :: model.lockedNodeIds
+
+                Nothing ->
+                    model.lockedNodeIds
+
+        sankeyModel =
+            { svgWidth = 1100
+            , svgHeight = totalHeight model.bundles
+            , columnWidths = columnWidths
+            , nodePadding = 8
+            , columnSpacing = 350
+            , edgeColor = "#60A5FA"
+            , edgeOpacity = 0.3
+            , fontSize = 11
+            , highlightedNodeIds = highlightedNodeIds
+            , lockedNodeIds = model.lockedNodeIds
+            }
+
+        events =
+            { onSelectNode = SelectNode
+            , onDeselectNode = DeselectNode
+            , onLockNode = ToggleLockNode
+            }
+
+        diagram =
+            layout sankeyModel nodes (buildEdges model.bundles)
+
+        hasSelection =
+            not (List.isEmpty model.lockedNodeIds)
+
+        buttonStyles =
+            if hasSelection then
+                [ style "color" "#6b7280"
+                , style "cursor" "pointer"
+                , style "border" "1px solid #374151"
+                ]
+
+            else
+                [ style "color" "#9ca3af"
+                , style "cursor" "not-allowed"
+                , style "border" "1px solid #d1d5db"
+                ]
+    in
+    div []
+        [ div [ style "display" "flex", style "align-items" "center", style "gap" "16px" ]
+            [ h1
+                [ style "font-family" "system-ui, sans-serif"
+                , style "margin-bottom" "10px"
+                , style "color" "#374151"
+                ]
+                [ text "Antoinette Bundle Graph" ]
+            , button
+                ([ onClick ClearSelection
+                 , style "font-size" "12px"
+                 , style "margin-bottom" "8px"
+                 , style "border-radius" "4px"
+                 , style "padding" "4px 8px"
+                 , style "background" "white"
+                 , disabled (not hasSelection)
+                 ]
+                    ++ buttonStyles
+                )
+                [ text "Clear Selection" ]
+            ]
+        , render sankeyModel events diagram
+        ]
+
+
+totalHeight : List Bundle -> Float
+totalHeight bundles =
+    let
+        elmApps =
+            uniqueElmApps bundles
+
+        templates =
+            uniqueTemplates bundles
+
+        maxItems =
+            max (List.length elmApps) (max (List.length bundles) (List.length templates))
+
+        rowHeight =
+            27
+    in
+    toFloat (maxItems * rowHeight + 100)
+
+
+buildColumnWidths : List LabelNode -> Dict.Dict Int Float
+buildColumnWidths nodes =
+    let
+        padding =
+            2
+
+        labelWidth node =
+            let
+                perCharacter =
+                    case node.column of
+                        2 ->
+                            6
+
+                        _ ->
+                            7
+            in
+            toFloat (padding + String.length node.label * perCharacter)
+
+        updateMax node dict =
+            let
+                currentMax =
+                    Dict.get node.column dict |> Maybe.withDefault 0
+
+                nodeWidth =
+                    labelWidth node
+            in
+            Dict.insert node.column (max currentMax nodeWidth) dict
+    in
+    List.foldl updateMax Dict.empty nodes
+
+
+buildNodes : List Bundle -> List LabelNode
+buildNodes bundles =
+    let
+        elmAppNodes =
+            uniqueElmApps bundles
+                |> List.map
+                    (\app ->
+                        { id = "app:" ++ app
+                        , label = app
+                        , column = 0
+                        }
+                    )
+
+        bundleNodes =
+            bundles
+                |> List.map
+                    (\bundle ->
+                        { id = "bundle:" ++ bundle.name
+                        , label = bundle.name
+                        , column = 1
+                        }
+                    )
+
+        templateNodes =
+            uniqueTemplates bundles
+                |> List.map
+                    (\template ->
+                        { id = "template:" ++ template
+                        , label = template
+                        , column = 2
+                        }
+                    )
+    in
+    elmAppNodes ++ bundleNodes ++ templateNodes
+
+
+buildEdges : List Bundle -> List { fromId : String, toId : String }
+buildEdges bundles =
+    let
+        appToBundleEdges =
+            bundles
+                |> List.concatMap
+                    (\bundle ->
+                        bundle.elmApps
+                            |> List.map
+                                (\app ->
+                                    { fromId = "app:" ++ app
+                                    , toId = "bundle:" ++ bundle.name
+                                    }
+                                )
+                    )
+
+        bundleToTemplateEdges =
+            bundles
+                |> List.concatMap
+                    (\bundle ->
+                        bundle.templates
+                            |> List.map
+                                (\template ->
+                                    { fromId = "bundle:" ++ bundle.name
+                                    , toId = "template:" ++ template
+                                    }
+                                )
+                    )
+    in
+    appToBundleEdges ++ bundleToTemplateEdges
+
+
+uniqueElmApps : List Bundle -> List String
+uniqueElmApps bundles =
+    bundles
+        |> List.concatMap .elmApps
+        |> List.sort
+        |> unique
+
+
+uniqueTemplates : List Bundle -> List String
+uniqueTemplates bundles =
+    bundles
+        |> List.concatMap .templates
+        |> List.sort
+        |> unique
+
+
+unique : List comparable -> List comparable
+unique list =
+    case list of
+        [] ->
+            []
+
+        first :: rest ->
+            first :: unique (List.filter (\x -> x /= first) rest)
+
+
+flagsDecoder : Decoder Flags
+flagsDecoder =
+    Decode.map Flags
+        (Decode.field "bundles" (Decode.list bundleDecoder))
+
+
+bundleDecoder : Decoder Bundle
+bundleDecoder =
+    Decode.map3 Bundle
+        (Decode.field "name" Decode.string)
+        (Decode.field "elm_apps" (Decode.list Decode.string))
+        (Decode.field "templates" (Decode.list Decode.string))