gitlab-lookbook 2.3.14

data/config/inputs.yml

@@ -0,0 +1,48 @@
+shared:
+  select:
+    partial: lookbook/inspector/inputs/select
+    opts: {}
+
+  textarea:
+    partial: lookbook/inspector/inputs/textarea
+    opts: {}
+
+  toggle:
+    partial: lookbook/inspector/inputs/toggle
+    opts: {}
+
+  color:
+    partial: lookbook/inspector/inputs/color
+    opts: {}
+
+  range:
+    partial: lookbook/inspector/inputs/range
+    opts: {}
+
+  text:
+    partial: lookbook/inspector/inputs/text
+    opts: {}
+
+  email:
+    partial: lookbook/inspector/inputs/text
+    opts: {}
+
+  number:
+    partial: lookbook/inspector/inputs/text
+    opts: {}
+
+  tel:
+    partial: lookbook/inspector/inputs/text
+    opts: {}
+
+  url:
+    partial: lookbook/inspector/inputs/text
+    opts: {}
+
+  date:
+    partial: lookbook/inspector/inputs/text_two_step
+    opts: {}
+
+  datetime_local:
+    partial: lookbook/inspector/inputs/text_two_step
+    opts: {}

data/config/languages.yml

@@ -0,0 +1,41 @@
+shared:
+  definitions:
+    - name: ruby
+      ext: .rb
+      label: Ruby
+      comment: "# %s"
+
+    - name: html
+      ext: .html
+      label: HTML
+      comment: "<!-- %s -->"
+
+    - name: erb
+      ext: .erb
+      label: ERB
+      comment: "<%%# %s %%>"
+
+    - name: haml
+      ext: .haml
+      label: Haml
+      comment: "<!-- %s -->"
+
+    - name: slim
+      ext: .slim
+      label: Slim
+      comment: "<!-- %s -->"
+
+    - name: tsx
+      ext: .tsx
+      label: TypeScript
+      comment: "// %s"
+
+    - name: js
+      ext: .js
+      label: JavasScript
+      comment: "// %s"
+
+    - name: css
+      ext: .css
+      label: CSS
+      comment: "/* %s */"

data/config/panels.yml

@@ -0,0 +1,28 @@
+shared:
+  preview:
+    partial: lookbook/inspector/panels/preview
+    label: Preview
+    hotkey: v
+
+  output:
+    partial: lookbook/inspector/panels/output
+    label: HTML
+    hotkey: h
+
+  source:
+    partial: lookbook/inspector/panels/source
+    label: Source
+    hotkey: s
+    copy: "->(data) { data.scenarios.map { |e| e.source }.join(\n) }"
+
+  notes:
+    partial: lookbook/inspector/panels/notes
+    label: Notes
+    hotkey: n
+    disabled: "->(data) { data.scenarios.select { |e| e.notes.present? }.none? }"
+
+  params:
+    partial: lookbook/inspector/panels/params
+    label: Params
+    hotkey: p
+    disabled: "->(data) { data.context.params.none? }"

data/config/routes.rb

@@ -0,0 +1,22 @@
+Lookbook::Engine.routes.draw do
+  if Lookbook::Engine.websocket.mountable?
+    mount Lookbook::Engine.websocket.server => "/cable", :as => :cable
+  end
+
+  root to: "application#index", as: :lookbook_home
+
+  get "/#{Lookbook.config.page_route}", to: "pages#index", as: :lookbook_page_index
+  get "/#{Lookbook.config.page_route}/*path", to: "pages#show", as: :lookbook_page
+
+  get "/previews", to: "previews#index", as: :lookbook_previews
+  get "/preview/*path", to: "previews#show", as: :lookbook_preview
+
+  get "/inspect/*path", to: "inspector#show", as: :lookbook_inspect
+
+  if Lookbook::Engine.preview_embeds_allowed?
+    get "/embed", to: "embeds#lookup", as: :lookbook_embed_lookup
+    get "/embed/*path", to: "embeds#show", as: :lookbook_embed
+  end
+
+  get "/*path", to: "application#not_found", via: :all
+end

data/config/tags.yml

@@ -0,0 +1,44 @@
+shared:
+  hidden:
+    label: Hidden status
+    opts: {}
+
+  label:
+    label: Label
+    opts: {}
+
+  display:
+    label: Display
+    opts: {}
+
+  priority:
+    label: Priority
+    opts: {}
+
+  id:
+    label: Id
+    opts: {}
+
+  component:
+    label: Component
+    opts: {}
+
+  renders:
+    label: Renders
+    opts: {}
+
+  param:
+    label: Param
+    opts: {}
+
+  logical_path:
+    label: Logical Path
+    opts: {}
+
+  source:
+    label: Source file
+    opts: {}
+
+  after_render:
+    label: After render
+    opts: {}

data/lib/gitlab-lookbook.rb

@@ -0,0 +1,6 @@
+# gitlab-lookbook is GitLab's fork of the lookbook gem. The library still lives
+# under the `Lookbook` namespace and is loaded from `lib/lookbook.rb`, so this
+# file exists only so that requiring the gem by its package name (e.g. via
+# Bundler's automatic `require`, or `gem "gitlab-lookbook"` without an explicit
+# `require:` option) loads the same code as `require "lookbook"`.
+require_relative "lookbook"

data/lib/lookbook/cable/cable.rb

@@ -0,0 +1,53 @@
+require "action_cable/engine"
+require_relative "connection"
+require_relative "reload_channel"
+
+module Lookbook
+  class Cable
+    attr_reader :engine_mount_path, :server, :logger
+
+    def initialize(engine_mount_path, logger: Lookbook.logger)
+      @engine_mount_path = engine_mount_path
+      @logger = logger
+
+      logger.info "Initializing websocket"
+
+      if Gem::Version.new(Rails.version) >= Gem::Version.new(6.0)
+        @server = ActionCable::Server::Base.new config: cable_config
+      else
+        @server = ActionCable::Server::Base.new
+        @server.config = cable_config
+      end
+    end
+
+    def broadcast(message, payload = nil)
+      logger.debug message.to_s
+      server.broadcast(message.to_s, payload.to_h)
+    end
+
+    def mount_path
+      "/cable"
+    end
+
+    def full_mount_path
+      "#{engine_mount_path}/#{mount_path}".gsub("//", "/")
+    end
+
+    def mountable?
+      true
+    end
+
+    alias_method :mounted?, :mountable?
+
+    protected
+
+    def cable_config
+      cable = ActionCable::Server::Configuration.new
+      cable.cable = {adapter: "async"}.with_indifferent_access
+      cable.mount_path = nil
+      cable.connection_class = -> { Lookbook::Connection }
+      cable.logger = logger
+      cable
+    end
+  end
+end

data/lib/lookbook/cable/connection.rb

@@ -0,0 +1,11 @@
+module Lookbook
+  class Connection < ActionCable::Connection::Base
+    identified_by :uid
+
+    def connect
+      self.uid = request.params[:uid]
+      logger.add_tags(uid)
+      logger.info "connected to Lookbook"
+    end
+  end
+end

data/lib/lookbook/cable/reload_channel.rb

@@ -0,0 +1,7 @@
+module Lookbook
+  class ReloadChannel < ActionCable::Channel::Base
+    def subscribed
+      stream_from "reload"
+    end
+  end
+end

data/lib/lookbook/engine.rb

@@ -0,0 +1,295 @@
+require "yard"
+
+module Lookbook
+  class Engine < Rails::Engine
+    isolate_namespace Lookbook
+
+    config.autoload_paths << File.expand_path(root.join("app/components"))
+
+    initializer "lookbook.assets.serve" do
+      config.app_middleware.use(
+        Rack::Static,
+        urls: ["/lookbook-assets"],
+        root: root.join("public").to_s
+      )
+    end
+
+    initializer "lookbook.set_autoload_paths", before: :set_autoload_paths do |app|
+      if opts.autoload_previews && opts.preview_paths.any?
+        paths_to_add = opts.preview_paths - app.config.autoload_paths
+        filtered_paths = paths_to_add.filter { |p| !Engine.component_paths.include?(p) }
+        app.config.autoload_paths.concat(filtered_paths) if filtered_paths.any?
+      end
+    end
+
+    config.before_configuration do
+      config.lookbook = Lookbook.config
+
+      if defined?(ViewComponent)
+        config.lookbook.using_view_component ||= true
+      else
+        require "view_component"
+        config.lookbook.using_view_component ||= false
+      end
+    end
+
+    config.after_initialize do
+      if opts.using_view_component
+        vc_config = Engine.host_config.view_component
+
+        if vc_config.key?(:previews)
+          # New config style (ViewComponent >= 4.0)
+          opts.preview_paths += vc_config.previews.paths
+
+          if opts.preview_controller == "Lookbook::PreviewController" ||
+              vc_config.previews.controller != "ViewComponentsController"
+            opts.preview_controller = vc_config.previews.controller
+          else
+            vc_config.previews.controller = opts.preview_controller
+          end
+
+          if opts.preview_layout.nil? || vc_config.previews.default_layout.present?
+            opts.preview_layout = vc_config.previews.default_layout
+          else
+            vc_config.previews.default_layout = opts.preview_layout
+          end
+
+          vc_config.previews.enabled = true
+
+          if vc_config.generate.path.present?
+            opts.component_paths << vc_config.generate.path
+          end
+        else
+          # Legacy config style (ViewComponent < 4.0)
+          opts.preview_paths += vc_config.preview_paths
+
+          if opts.preview_controller == "Lookbook::PreviewController" ||
+              vc_config.preview_controller != ViewComponent::Config.defaults.preview_controller
+            opts.preview_controller = vc_config.preview_controller
+          else
+            vc_config.preview_controller = opts.preview_controller
+          end
+
+          if opts.preview_layout.nil? || vc_config.default_preview_layout.present?
+            opts.preview_layout = vc_config.default_preview_layout
+          else
+            vc_config.default_preview_layout = opts.preview_layout
+          end
+
+          vc_config.show_previews = true
+
+          if vc_config.view_component_path.present?
+            opts.component_paths << vc_config.view_component_path
+          end
+        end
+
+        ViewComponent::Preview.extend(Lookbook::PreviewAfterRender)
+      end
+
+      if opts.reload_on_change.nil?
+        opts.reload_on_change = !host_config.cache_classes && host_config.reload_classes_only_on_change
+      end
+    end
+
+    config.after_initialize do
+      if Engine.reloading?
+        reloaders.add(:previews, Engine.preview_watch_paths, opts.listen_extensions, &Engine.method(:load_previews))
+        reloaders.add(:pages, Engine.page_watch_paths, opts.page_extensions, &Engine.method(:load_pages))
+        reloaders.execute unless opts.lazy_load_previews_and_pages
+      else
+        unless opts.lazy_load_previews_and_pages
+          Engine.load_previews
+          Engine.load_pages
+        end
+      end
+
+      Engine.run_hooks(:after_initialize)
+    end
+
+    def opts
+      Lookbook.config
+    end
+
+    def parser
+      @_parser ||= PreviewParser.new(opts.preview_paths, Engine.tags)
+    end
+
+    def reloaders
+      @_reloaders ||= Reloaders.new
+    end
+
+    class << self
+      delegate :app_name, to: :runtime_context
+
+      def mount_path
+        routes.find_script_name({})
+      end
+
+      def mounted?
+        mount_path.present?
+      end
+
+      def reloading?
+        opts.reload_on_change
+      end
+
+      def auto_refresh?
+        opts.live_updates == true &&
+          reloading? &&
+          runtime_context.web? &&
+          FileWatcher.evented?
+      end
+
+      def preview_embeds_allowed?
+        opts.preview_embeds.enabled == true && opts.preview_embeds.policy != "DENY"
+      end
+
+      def websocket
+        @_websocket ||= auto_refresh? ? Websocket.new(mount_path, logger: Lookbook.logger) : NullWebsocket.new
+      end
+
+      def runtime_context
+        @_runtime_context ||= RuntimeContext.new(env: Rails.env)
+      end
+
+      def theme
+        @_theme ||= Lookbook::Theme.new(opts.ui_theme, opts.ui_theme_overrides)
+      end
+
+      def panels
+        @_panels ||= PanelStore.init_from_config
+      end
+
+      def inputs
+        @_inputs ||= InputStore.init_from_config
+      end
+
+      def tags
+        @_tags ||= TagStore.init_from_config
+      end
+
+      def hooks
+        @_hooks ||= HookStore.new
+      end
+
+      def run_hooks(event_name, *args)
+        hooks.for_event(event_name).each do |hook|
+          hook.call(Lookbook, *args)
+        end
+      end
+
+      def host_app_path
+        Rails.application.root.join("app")
+      end
+
+      def host_config
+        Rails.application.config
+      end
+
+      def view_paths
+        # handle view path registry changes in Rails 7.1
+        paths = if defined?(ActionView::PathRegistry)
+          ActionView::PathRegistry.all_file_system_resolvers.map(&:path)
+        else
+          ActionView::ViewPaths.all_view_paths.flat_map(&paths)
+        end
+        paths.map { |path| Pathname(path.to_s) }
+      end
+
+      def component_paths
+        @_component_paths ||= begin
+          paths = [*opts.component_paths, *view_paths, host_app_path]
+          PathUtils.normalize_paths(paths)
+        end
+      end
+
+      def page_paths
+        @_page_paths ||= PathUtils.normalize_paths(opts.page_paths)
+      end
+
+      alias_method :page_watch_paths, :page_paths
+
+      def preview_paths
+        @_preview_paths ||= PathUtils.normalize_paths(opts.preview_paths)
+      end
+
+      def preview_watch_paths
+        @_preview_watch_paths ||= begin
+          paths = [*opts.preview_paths, *opts.component_paths, *opts.listen_paths, *view_paths].uniq
+          PathUtils.normalize_paths(paths)
+        end
+      end
+
+      def pages
+        @_pages ||= PageCollection.new
+
+        if opts.lazy_load_previews_and_pages && !@_loaded_pages
+          @_loaded_pages = true
+
+          if reloading?
+            reloaders.execute(:pages)
+          else
+            load_pages
+          end
+        end
+
+        @_pages
+      end
+
+      def previews
+        @_previews ||= PreviewCollection.new
+
+        if opts.lazy_load_previews_and_pages && !@_loaded_previews
+          @_loaded_previews = true
+
+          if reloading?
+            reloaders.execute(:previews)
+          else
+            load_previews
+          end
+        end
+
+        @_previews
+      end
+
+      def preview_controller
+        @_preview_controller = opts.preview_controller.constantize
+        @_preview_controller.include PreviewControllerActions
+      end
+
+      def load_previews(changes = nil)
+        changed_files = [*changes[:added], *changes[:modified]] if changes
+        parser.parse(changed_files) do |code_objects|
+          previews.load(code_objects.all(:class), changes)
+        end
+      rescue => e
+        Lookbook.logger.error(e)
+        raise e
+      end
+
+      def load_pages(changes = nil)
+        pages.load(Engine.page_paths, changes)
+      rescue => e
+        Lookbook.logger.error(e)
+        raise e
+      end
+
+      def notify_clients(changes = nil)
+        return unless changes.present?
+
+        websocket.broadcast(:reload)
+        run_hooks(:after_change, changes.to_h)
+      end
+
+      def files_changed(modified, added, removed)
+        changes = {modified: modified, added: added, removed: removed}
+        reloaders.register_changes(changes)
+        notify_clients(changes)
+      end
+    end
+
+    at_exit do
+      Engine.run_hooks(:before_exit)
+    end
+  end
+end

data/lib/lookbook/entities/collections/concerns/hierarchical_collection.rb

@@ -0,0 +1,28 @@
+module Lookbook
+  module HierarchicalCollection
+    extend ActiveSupport::Concern
+
+    TREE_BUILDER = nil
+
+    included do
+      def entities
+        @_cache[:entities] ||= collect_ordered_entities(to_tree(include_hidden: true))
+      end
+
+      def to_tree(include_hidden: false)
+        cache_key = include_hidden ? :tree_with_hidden : :tree
+        @_cache[cache_key] ||= self.class::TREE_BUILDER.call(@entities, include_hidden: include_hidden)
+      end
+
+      protected
+
+      def collect_ordered_entities(start_node)
+        start_node.flat_map do |node|
+          node_entity = node.content? ? [node.content] : []
+          child_entities = collect_ordered_entities(node)
+          [*node_entity, *child_entities]
+        end
+      end
+    end
+  end
+end

data/lib/lookbook/entities/collections/entity_collection.rb

@@ -0,0 +1,66 @@
+module Lookbook
+  class EntityCollection
+    include Enumerable
+
+    delegate_missing_to :entities
+
+    attr_reader :entities
+
+    def initialize(entities = nil)
+      @_cache = {}
+      @entities = []
+      add(entities)
+    end
+
+    def add(to_add = nil)
+      Array(to_add).each do |entity|
+        unless find_by_path(entity.lookup_path)
+          @entities.push(entity)
+        end
+      end
+      clear_cache
+    end
+
+    def find_by_id(id)
+      id = Utils.id(id)
+      @entities.find { |entity| entity.id == id }
+    end
+
+    def find_by_path(path)
+      @entities.find { |entity| entity.lookup_path.to_s == path.to_s }
+    end
+
+    def next(entity)
+      index = entities.find_index { |i| i.lookup_path == entity.lookup_path }
+      entities[index + 1] unless index.nil?
+    end
+
+    def previous(entity)
+      index = entities.find_index { |i| i.lookup_path == entity.lookup_path }
+      entities[index - 1] if !index.nil? && index > 0
+    end
+
+    def each(&block)
+      if block
+        entities.sort.each { |entity| yield entity }
+      else
+        to_enum(:each)
+      end
+    end
+
+    def flat_map(...)
+      entities.map(...).map { |e| e.respond_to?(:to_a) ? e.to_a : e }.flatten
+    end
+
+    def clear_all
+      @entities = []
+      clear_cache
+    end
+
+    protected
+
+    def clear_cache
+      @_cache = {}
+    end
+  end
+end