lookbook 2.3.1 → 3.0.0.alpha.2

data/lib/lookbook/component/base.rb

@@ -0,0 +1,270 @@
+require "action_view"
+
+module Lookbook
+  module Component
+    class Base < ActionView::Base
+      attr_accessor :original_view_context
+
+      def set_original_view_context(view_context)
+        self.original_view_context = view_context
+      end
+
+      def render_in(view_context, &block)
+        self.class.compile
+
+        @view_context = view_context
+        self.original_view_context ||= view_context
+
+        @output_buffer = ActionView::OutputBuffer.new
+        @lookup_context ||= view_context.lookup_context
+        @view_flow ||= view_context.view_flow
+
+        @current_template = nil unless defined?(@current_template)
+        old_current_template = @current_template
+        @current_template = self
+
+        @_content_evaluated = false
+        @_render_in_block = block
+
+        before_render
+
+        render? ? render_template.to_s : ""
+      ensure
+        @current_template = old_current_template
+      end
+
+      def before_render
+      end
+
+      def render?
+        true
+      end
+
+      def initialize(*)
+      end
+
+      def call
+        raise "Components must define a call method or provide a template file."
+      end
+
+      def render(options = {}, args = {}, &block)
+        if options.respond_to?(:set_original_view_context)
+          options.set_original_view_context(original_view_context)
+          super
+        else
+          original_view_context.render(options, args, &block)
+        end
+      end
+
+      def controller
+        @_controller ||= view_context.controller
+      end
+
+      def helpers
+        @_helpers ||= original_view_context || controller.view_context
+      end
+
+      def virtual_path
+        self.class.virtual_path
+      end
+
+      def content
+        @_content_evaluated = true
+        return @_content if defined?(@_content)
+
+        @_content = render_in_block_provided? ? view_context.capture(self, &@_render_in_block) : ""
+      end
+
+      def content?
+        render_in_block_provided?
+      end
+
+      private
+
+      attr_reader :view_context
+
+      def render_in_block_provided?
+        @view_context && @_render_in_block
+      end
+
+      def content_evaluated?
+        @_content_evaluated
+      end
+
+      def is_singular?(str)
+        str.pluralize.singularize == str
+      end
+
+      def get_slot(name)
+        content unless content_evaluated?
+
+        @_set_slots ||= []
+        slot = @_set_slots.find { |s| s[:name].to_sym == name.to_sym }
+        slot[:content] if slot
+      end
+
+      def get_slots(name)
+        content unless content_evaluated?
+
+        @_set_slots ||= []
+        slots = @_set_slots.select { |s| s[:name].to_sym == name.to_sym }
+        slots.map { |s| s[:content] }
+      end
+
+      def set_slot(name, *args, &block)
+        handler = self.class.registered_slots[name.to_sym]
+        result = if handler.respond_to?(:method_defined?) && handler.method_defined?(:render_in)
+          # component class
+          handler.new(*args)
+        else
+          renderable_function = handler.bind(self)
+          if block
+            renderable_function.call(*args) do |*rargs|
+              view_context.capture(*rargs, &block)
+            end
+          else
+            renderable_function.call(*args)
+          end
+        end
+
+        # if the result is a component, render it
+        result = if result.respond_to?(:render_in)
+          if view_context
+            view_context.render result, &block
+          else
+            render result, &block
+          end
+        else
+          result
+        end
+
+        @_set_slots ||= []
+        @_set_slots << {
+          name: name.to_sym,
+          content: result.is_a?(String) ? result.html_safe : nil
+        }
+
+        nil
+      end
+      ruby2_keywords(:set_slot) if respond_to?(:ruby2_keywords, true)
+
+      def method_missing(method, ...)
+        if view_context && helpers.respond_to?(method.to_sym)
+          helpers.send(method.to_sym, ...)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        (view_context && helpers.respond_to?(method.to_sym, include_private)) || super
+      end
+
+      class << self
+        attr_accessor :source_location, :virtual_path
+
+        def template_path
+          return unless source_location
+          @_tmpl_path ||= begin
+            component_name = name.demodulize.underscore
+            directory = File.dirname(source_location)
+
+            file_path = File.join(directory, "#{component_name}.html.erb")
+            file_path if File.exist?(file_path)
+          end
+        end
+
+        def inherited(child)
+          compile
+
+          if !child.instance_methods(false).include?(:render_template) && !child.compiled?
+            child.class_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def render_template
+                self.class.compile(force: true)
+                render_template
+              end
+            RUBY
+          end
+
+          if defined?(Rails) && Rails.application && !(child < Rails.application.routes.url_helpers)
+            child.include Rails.application.routes.url_helpers
+          end
+
+          child.source_location = caller_locations(1, 10).reject { |l| l.base_label == "inherited" }[0].path
+          child.virtual_path = child.source_location.gsub(/(\.rb)/, "")
+
+          super
+        end
+
+        def compiled?
+          compiler.compiled?
+        end
+
+        def compile(force: false)
+          compiler.compile(force: force)
+        end
+
+        def compiler
+          @_compiler ||= Compiler.new(self)
+        end
+
+        def type
+          "text/html"
+        end
+
+        def identifier
+          source_location
+        end
+
+        def registered_slots
+          @_registered_slots ||= {}
+        end
+
+        def with_slot(slot_name, handler = nil, &block)
+          slot_name = slot_name.to_s.singularize.to_sym
+
+          if handler
+            registered_slots[slot_name.to_sym] = if handler.respond_to?(:method_defined?) && handler.method_defined?(:render_in)
+              handler
+            else
+              instance_method(handler)
+            end
+          elsif block
+            method_name = :"_call_#{slot_name}"
+            define_method method_name, &block
+            registered_slots[slot_name.to_sym] = instance_method(method_name)
+          else
+            method_name = :"_call_#{slot_name}"
+            define_method method_name do |&block|
+              view_context.capture(&block)
+            end
+            registered_slots[slot_name.to_sym] = instance_method(method_name)
+          end
+
+          define_method :"with_#{slot_name}" do |*args, &block|
+            set_slot(slot_name, *args, &block)
+          end
+          ruby2_keywords(:"with_#{slot_name}") if respond_to?(:ruby2_keywords, true)
+
+          define_method slot_name do |*args, &block|
+            get_slot(slot_name)
+          end
+          ruby2_keywords(slot_name.to_sym) if respond_to?(:ruby2_keywords, true)
+
+          define_method slot_name.to_s.pluralize.to_sym do |*args, &block|
+            get_slots(slot_name)
+          end
+          ruby2_keywords(slot_name.to_s.pluralize.to_sym) if respond_to?(:ruby2_keywords, true)
+
+          define_method :"#{slot_name}?" do
+            get_slot(slot_name).present?
+          end
+
+          define_method :"#{slot_name.to_s.pluralize}?" do
+            get_slots(slot_name).any?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lookbook/component/compile_cache.rb

@@ -0,0 +1,28 @@
+module Lookbook
+  module Component
+    module CompileCache
+      mattr_accessor :cache, instance_reader: false, instance_accessor: false do
+        Set.new
+      end
+
+      module_function
+
+      def register(klass)
+        cache << klass
+      end
+
+      def compiled?(klass)
+        # cache.include? klass
+        false
+      end
+
+      def invalidate_class!(klass)
+        cache.delete(klass)
+      end
+
+      def invalidate!
+        cache.clear
+      end
+    end
+  end
+end

data/lib/lookbook/component/compiler.rb

@@ -0,0 +1,94 @@
+require "concurrent-ruby"
+
+module Lookbook
+  module Component
+    class Compiler
+      def initialize(component_class)
+        @component_class = component_class
+        @redefinition_lock = Mutex.new
+      end
+
+      def compiled?
+        CompileCache.compiled?(component_class)
+      end
+
+      def development?
+        Rails.env.development? || Rails.env.test?
+      end
+
+      def compile(force: false)
+        return if compiled? && !force
+        return if component_class == Lookbook::Component::Base
+
+        component_class.superclass.compile if should_compile_superclass?
+
+        if template_path.present?
+          redefinition_lock.synchronize do
+            component_class.silence_redefinition_of_method("call")
+            # rubocop:disable Style/EvalWithLocation
+            component_class.class_eval <<-RUBY, template_path, 0
+            def call
+              #{compiled_template(template_path)}
+            end
+            RUBY
+            # rubocop:enable Style/EvalWithLocation
+          end
+        end
+
+        define_render_template_for
+
+        CompileCache.register(component_class)
+      end
+
+      private
+
+      attr_reader :component_class, :redefinition_lock
+
+      def define_render_template_for
+        redefinition_lock.synchronize do
+          component_class.silence_redefinition_of_method(:render_template)
+          component_class.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def render_template
+          call
+        end
+          RUBY
+        end
+      end
+
+      def template_path
+        component_class.template_path
+      end
+
+      def compiled_template(file_path)
+        handler = ActionView::Template.handler_for_extension(File.extname(file_path).delete("."))
+        template = File.read(file_path)
+
+        compile_template(template, handler)
+      end
+
+      def compile_template(template, handler)
+        template.rstrip!
+
+        if handler.method(:call).parameters.length > 1
+          handler.call(component_class, template)
+        else
+          handler.call(
+            OpenStruct.new(
+              source: template,
+              identifier: component_class.identifier,
+              type: component_class.type
+            )
+          )
+        end
+      end
+
+      def should_compile_superclass?
+        development? && template_path.nil? &&
+          !(
+            component_class.instance_methods(false).include?(:call) ||
+              component_class.private_instance_methods(false).include?(:call)
+          )
+      end
+    end
+  end
+end

data/lib/lookbook/concerns/entity_tree_node.rb

@@ -0,0 +1,59 @@
+module Lookbook
+  module EntityTreeNode
+    extend ActiveSupport::Concern
+
+    def ancestors
+      ancestors = []
+      current_parent = parent
+      while current_parent
+        ancestors.unshift current_parent
+        current_parent = current_parent.parent
+      end
+      ancestors
+    end
+
+    def siblings
+      parent.children.filter { _1.lookup_path == lookup_path }
+    end
+
+    def index
+      parent.children.index(self)
+    end
+
+    def last?
+      self == parent.children.last
+    end
+
+    def first?
+      self == parent.children.first
+    end
+
+    def next
+    end
+
+    def previous
+    end
+
+    def parent_lookup_path
+      File.dirname(lookup_path).delete_prefix(".")
+    end
+
+    def navigable?
+      url_path.present?
+    end
+
+    def depth
+      @depth ||= lookup_path.split("/").size
+    end
+
+    def search_terms
+      [label.downcase, *parent&.search_terms].flatten
+    end
+
+    def children = []
+
+    def parent = nil
+
+    def root? = false
+  end
+end

data/lib/lookbook/concerns/feature_checks.rb

@@ -0,0 +1,17 @@
+module Lookbook
+  module FeatureChecks
+    extend ActiveSupport::Concern
+
+    def view_component_available?
+      @has_view_component ||= Utils.gem_installed?("view_component")
+    end
+
+    def listen_available?
+      @has_listen ||= Utils.gem_installed?("listen") && defined?(::Listen)
+    end
+
+    def action_mailer_available?
+      @has_action_mailer ||= !!defined?(::ActionMailer)
+    end
+  end
+end

data/lib/lookbook/concerns/loggable.rb

@@ -0,0 +1,11 @@
+module Lookbook
+  module Loggable
+    extend ActiveSupport::Concern
+
+    [:debug, :info, :warn, :error, :fatal].each do |level|
+      define_method(level) do |*args|
+        Lookbook.logger.send(level, *args)
+      end
+    end
+  end
+end

data/lib/lookbook/config.rb

@@ -0,0 +1,210 @@
+module Lookbook
+  class Config
+    class << self
+      alias_method :default, :new
+
+      def defaults
+        DataObject.new({
+          project_name: "Lookbook",
+          project_links: [],
+
+          component_paths: ["app/views", "app/components"],
+
+          preview_controller: "LookbookPreviewController",
+          preview_layout: nil,
+          preview_url_param: :name,
+          preview_overview_template: "lookbook/previews/overview",
+          preview_paths: ["lookbook/previews", "test/components/previews"],
+          preview_watch_paths: [],
+          preview_watch_extensions: ["rb", "html.*"],
+          preview_display_options: {},
+          preview_disable_action_view_annotations: true,
+
+          preview_tags: default_preview_tags,
+
+          preview_statuses: default_preview_statuses,
+          preview_default_status: nil,
+
+          preview_embed_panels: [:usage, :output, :notes, :params],
+
+          previews_nav_label: "Previews",
+          previews_nav_filter: true,
+
+          inspector_target_preview_template: "lookbook/inspector/preview",
+          inspector_target_mailer_template: "lookbook/inspector/mailer_preview",
+          inspector_panels: default_inspector_panels,
+          inspector_preview_panels: [:preview, :output].freeze,
+          inspector_drawer_panels: [:usage, :params, :metadata, "*"],
+          inspector_param_inputs: default_inspector_param_inputs,
+
+          page_route: "pages",
+          page_paths: ["lookbook/docs", "test/components/docs"],
+          page_extensions: ["md", "html.*", "md.*"],
+          page_watch_paths: [],
+          page_watch_extensions: [],
+          page_frontmatter_defaults: default_frontmatter_options,
+
+          pages_nav_label: "Pages",
+          pages_nav_filter: true,
+
+          ui_nav_panels: [:previews, :pages],
+          ui_status_bar: Rails.env.development?,
+          ui_color_scheme_switcher: true,
+
+          markdown_options: default_markdown_options,
+
+          languages: default_languages,
+
+          reload_on_change: Rails.env.development?,
+          mount_path: "/lookbook",
+
+          enabled: Rails.env.development? || Rails.env.test?
+        })
+      end
+
+      def default_inspector_panels
+        {
+          preview: {
+            label: "Preview",
+            partial: "lookbook/inspector/panels/preview"
+          },
+          output: {
+            label: "Output",
+            partial: "lookbook/inspector/panels/output"
+          },
+          usage: {
+            label: "Usage",
+            partial: "lookbook/inspector/panels/usage"
+          },
+          params: {
+            label: "Params",
+            partial: "lookbook/inspector/panels/params",
+            disabled: ->(data) { !data.target.params? }
+          },
+          metadata: {
+            label: "Metadata",
+            partial: "lookbook/inspector/panels/metadata"
+          }
+        }
+      end
+
+      def default_inspector_param_inputs
+        {
+          text: {
+            partial: "lookbook/inspector/inputs/text"
+          },
+          email: {
+            partial: "lookbook/inspector/inputs/text"
+          },
+          number: {
+            partial: "lookbook/inspector/inputs/text"
+          },
+          tel: {
+            partial: "lookbook/inspector/inputs/text"
+          },
+          url: {
+            partial: "lookbook/inspector/inputs/text"
+          },
+          textarea: {
+            partial: "lookbook/inspector/inputs/textarea"
+          },
+          select: {
+            partial: "lookbook/inspector/inputs/select"
+          },
+          checkbox: {
+            partial: "lookbook/inspector/inputs/checkbox"
+          },
+          toggle: {
+            partial: "lookbook/inspector/inputs/checkbox"
+          }
+        }
+      end
+
+      def default_preview_tags
+        [
+          Lookbook::DisplayTag,
+          Lookbook::HiddenTag,
+          Lookbook::IdTag,
+          Lookbook::LabelTag,
+          Lookbook::LocationTag,
+          Lookbook::ParamTag,
+          Lookbook::StatusTag
+        ]
+      end
+
+      def default_preview_statuses
+        {
+          ready: {
+            label: "Ready",
+            color: :green,
+            description: "Ready for use."
+          },
+          wip: {
+            label: "In Progress",
+            color: :amber,
+            description: "Work in progress. Reference with caution."
+          },
+          deprecated: {
+            label: "Deprecated",
+            color: :red,
+            description: "Deprecated, or to be deprecated."
+          }
+        }
+      end
+
+      def default_markdown_options
+        {
+          tables: true,
+          fenced_code_blocks: true,
+          disable_indented_code_blocks: true,
+          strikethrough: true,
+          highlight: true,
+          with_toc_data: true,
+          lax_spacing: true,
+          escape_html: false
+        }
+      end
+
+      def default_languages
+        {
+          html: {
+            label: "HTML",
+            ext: ".html",
+            comment: "<!-- %s -->"
+          },
+          ruby: {
+            label: "Ruby",
+            ext: ".rb",
+            comment: "# %s"
+          },
+          erb: {
+            label: "ERB",
+            ext: ".erb",
+            comment: "<%%# %s %%>"
+          }
+        }
+      end
+
+      def default_frontmatter_options
+        {
+          footer: true,
+          header: true,
+          landing: false,
+          data: {}
+        }
+      end
+    end
+
+    class_attribute :current, default: defaults, instance_predicate: false
+
+    def initialize
+      @config = self.class.defaults
+    end
+
+    delegate_missing_to :config
+
+    private
+
+    attr_reader :config
+  end
+end

data/lib/lookbook/data_object.rb

@@ -0,0 +1,21 @@
+module Lookbook
+  class DataObject
+    class << self
+      def new(*args, **properties)
+        merged_args = args.map(&:to_h).reduce({}) { _1.merge(_2) }
+        data = {**merged_args, **properties}.deep_symbolize_keys
+        ActiveSupport::OrderedOptions.new.merge!(data.transform_values { convert_value(_1) })
+      end
+
+      def convert_value(value)
+        if value.is_a?(Hash)
+          DataObject.new(value)
+        elsif value.is_a?(Array)
+          value.map { DataObject.convert_value(_1) }
+        else
+          value
+        end
+      end
+    end
+  end
+end