herb 0.9.7-arm-linux-gnu → 0.10.0-arm-linux-gnu

data/lib/herb/ast/erb_render_node.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require "did_you_mean"
+
+module Herb
+  module AST
+    class ERBRenderNode < Node
+      PARTIAL_EXTENSIONS = Herb::PARTIAL_EXTENSIONS
+
+      def static_partial?
+        keywords&.partial && !keywords&.partial&.value&.empty?
+      end
+
+      def dynamic?
+        !static_partial? && (keywords&.object || keywords&.renderable)
+      end
+
+      def partial_path
+        keywords&.partial&.value
+      end
+
+      def template_name
+        keywords&.template_path&.value
+      end
+
+      def layout_name
+        keywords&.layout&.value
+      end
+
+      def local_names
+        keywords&.locals&.map { |local| local.name&.value }&.compact || []
+      end
+
+      def resolve(view_root: nil, source_directory: nil)
+        name = partial_path || template_name
+
+        return nil unless name
+
+        view_root = Pathname.new(view_root) unless view_root.nil? || view_root.is_a?(Pathname)
+
+        candidates = candidate_paths(name, view_root, source_directory)
+        candidates.find(&:exist?)
+      end
+
+      def candidate_paths(name = nil, view_root = nil, source_directory = nil)
+        name ||= partial_path || template_name
+
+        return [] unless name
+
+        view_root = Pathname.new(view_root) unless view_root.nil? || view_root.is_a?(Pathname)
+
+        directory = File.dirname(name) if name.include?("/")
+        base = name.include?("/") ? File.basename(name) : name
+        source_directory = Pathname.new(source_directory) if source_directory && !source_directory.is_a?(Pathname)
+
+        PARTIAL_EXTENSIONS.flat_map do |extension|
+          paths = [] #: Array[Pathname]
+
+          if directory
+            paths << view_root.join(directory, "_#{base}#{extension}") if view_root
+          else
+            paths << source_directory.join("_#{base}#{extension}") if source_directory
+            paths << view_root.join("_#{base}#{extension}") if view_root
+          end
+
+          paths
+        end
+      end
+
+      def similar_partials(view_root: nil, source_directory: nil, limit: 3)
+        name = partial_path || template_name
+
+        return [] unless name
+
+        suggestions = [] #: Array[String]
+
+        if view_root
+          view_root = Pathname.new(view_root) unless view_root.is_a?(Pathname)
+
+          if view_root.directory?
+            all_partials = Dir[File.join(view_root, "**", Herb::PARTIAL_GLOB_PATTERN)].map do |file|
+              relative = Pathname.new(file).relative_path_from(view_root).to_s
+              relative.sub(%r{(^|/)_}, '\1').sub(/\..*\z/, "")
+            end
+
+            spell_checker = DidYouMean::SpellChecker.new(dictionary: all_partials)
+            suggestions = spell_checker.correct(name).first(limit)
+          end
+        elsif source_directory
+          source_directory = Pathname.new(source_directory) unless source_directory.is_a?(Pathname)
+
+          if source_directory.directory?
+            local_partials = Dir[File.join(source_directory, Herb::PARTIAL_GLOB_PATTERN)].map do |file|
+              File.basename(file).sub(/\A_/, "").sub(/\..*\z/, "")
+            end
+
+            unless local_partials.empty?
+              spell_checker = DidYouMean::SpellChecker.new(dictionary: local_partials)
+              suggestions = spell_checker.correct(name).first(limit)
+            end
+          end
+        end
+
+        if suggestions.empty?
+          suggestions.concat(find_non_partial_matches(name, view_root, source_directory))
+        end
+
+        suggestions
+      end
+
+      def find_non_partial_matches(name = nil, view_root = nil, source_directory = nil)
+        name ||= partial_path || template_name
+
+        return [] unless name
+
+        matches = [] #: Array[String]
+
+        PARTIAL_EXTENSIONS.each do |extension|
+          if name.include?("/")
+            next unless view_root
+
+            view_root = Pathname.new(view_root) unless view_root.is_a?(Pathname)
+            directory = File.dirname(name)
+            base = File.basename(name)
+            non_partial_path = view_root.join(directory, "#{base}#{extension}")
+
+            if non_partial_path.exist?
+              matches << "#{name}#{extension} exists as a template, not a partial. Rename to _#{base}#{extension} to use it with render"
+            end
+          else
+            if source_directory
+              source_directory = Pathname.new(source_directory) unless source_directory.is_a?(Pathname)
+              non_partial_path = source_directory.join("#{name}#{extension}")
+
+              if non_partial_path.exist?
+                matches << "#{name}#{extension} exists as a template, not a partial. Rename to _#{name}#{extension} to use it with render"
+              end
+            end
+
+            if view_root
+              view_root = Pathname.new(view_root) unless view_root.is_a?(Pathname)
+              non_partial_path = view_root.join("#{name}#{extension}")
+
+              if non_partial_path.exist?
+                matches << "#{name}#{extension} exists as a template, not a partial. Rename to _#{name}#{extension} to use it with render"
+              end
+            end
+          end
+        end
+
+        matches.uniq
+      end
+    end
+  end
+end

data/lib/herb/bootstrap.rb

@@ -18,7 +18,6 @@ module Herb
 
     def self.generate_templates
       require "pathname"
-      require "set"
       require_relative "../../templates/template"
 
       Dir.chdir(ROOT_PATH) do

data/lib/herb/cli.rb

@@ -8,7 +8,7 @@ require "optparse"
 class Herb::CLI
   include Herb::Colors
 
-  attr_accessor :json, :silent, :log_file, :no_timing, :local, :escape, :no_escape, :freeze, :debug, :tool, :strict, :analyze, :track_whitespace, :verbose, :isolate, :arena_stats, :leak_check, :action_view_helpers, :trim
+  attr_accessor :json, :silent, :log_file, :no_timing, :local, :escape, :no_escape, :freeze, :debug, :tool, :strict, :analyze, :track_whitespace, :verbose, :isolate, :arena_stats, :leak_check, :action_view_helpers, :trim, :optimize
 
   def initialize(args)
     @args = args
@@ -17,7 +17,7 @@ class Herb::CLI
 
   def call
     options
-    @file = @args[1]
+    @file = @args[1] unless @command == "dev"
 
     if silent
       if result.failed?
@@ -90,23 +90,29 @@ class Herb::CLI
         bundle exec herb [command] [options]
 
       Commands:
-        bundle exec herb lex [file]           Lex a file.
-        bundle exec herb parse [file]         Parse a file.
-        bundle exec herb compile [file]       Compile ERB template to Ruby code.
-        bundle exec herb render [file]        Compile and render ERB template to final output.
-        bundle exec herb analyze [path]       Analyze a project by passing a directory to the root of the project
-        bundle exec herb report [file]        Generate a Markdown bug report for a file
-        bundle exec herb config [path]        Show configuration and file patterns for a project
-        bundle exec herb ruby [file]          Extract Ruby from a file.
-        bundle exec herb html [file]          Extract HTML from a file.
-        bundle exec herb playground [file]    Open the content of the source file in the playground
-        bundle exec herb version              Prints the versions of the Herb gem and the libherb library.
-
-        bundle exec herb lint [patterns]      Lint templates (delegates to @herb-tools/linter)
-        bundle exec herb format [patterns]    Format templates (delegates to @herb-tools/formatter)
-        bundle exec herb highlight [file]     Syntax highlight templates (delegates to @herb-tools/highlighter)
-        bundle exec herb print [file]         Print AST (delegates to @herb-tools/printer)
-        bundle exec herb lsp                  Start the language server (delegates to @herb-tools/language-server)
+        bundle exec herb lex [file]                 Lex a file.
+        bundle exec herb parse [file]               Parse a file.
+        bundle exec herb compile [file]             Compile ERB template to Ruby code.
+        bundle exec herb render [file]              Compile and render ERB template to final output.
+        bundle exec herb analyze [path]             Analyze a project by passing a directory to the root of the project.
+        bundle exec herb report [file]              Generate a Markdown bug report for a file.
+        bundle exec herb config [path]              Show configuration and file patterns for a project.
+        bundle exec herb ruby [file]                Extract Ruby from a file.
+        bundle exec herb html [file]                Extract HTML from a file.
+        bundle exec herb diff [old] [new]           Diff two files and show the minimal set of AST differences.
+        bundle exec herb playground [file]          Open the content of the source file in the playground.
+        bundle exec herb dev                        Start the dev server and watch for file changes.
+        bundle exec herb version                    Prints the versions of the Herb gem and the libherb library.
+
+        bundle exec herb actionview check [path]    Check if render calls resolve to valid partial files.
+        bundle exec herb actionview graph [path]    Show render dependency graph for a project or file.
+        bundle exec herb actionview render [file]   Render ERB template using ActionView helpers.
+
+        bundle exec herb lint [patterns]            Lint templates (delegates to @herb-tools/linter)
+        bundle exec herb format [patterns]          Format templates (delegates to @herb-tools/formatter)
+        bundle exec herb highlight [file]           Syntax highlight templates (delegates to @herb-tools/highlighter)
+        bundle exec herb print [file]               Print AST (delegates to @herb-tools/printer)
+        bundle exec herb lsp                        Start the language server (delegates to @herb-tools/language-server)
 
       stdin:
         Commands that accept [file] also accept input via stdin:
@@ -197,6 +203,19 @@ class Herb::CLI
                     system(%(open "#{url}##{hash}"))
                     exit(0)
                   end
+                when "dev"
+                  case @args[1]
+                  when "stop" then dev_stop
+                  when "restart" then dev_restart
+                  when "status" then dev_status
+                  else
+                    @file = @args[1]
+                    run_dev_server
+                  end
+                when "actionview"
+                  run_actionview_command
+                when "diff"
+                  diff_files
                 when "lint"
                   run_node_tool("herb-lint", "@herb-tools/linter")
                 when "format"
@@ -306,6 +325,10 @@ class Herb::CLI
         self.trim = true
       end
 
+      parser.on("--optimize", "Enable compile-time optimizations for Action View helpers (for compile/render commands) (default: false)") do
+        self.optimize = true
+      end
+
       parser.on("--tool TOOL", "Show config for specific tool: linter, formatter (for config command)") do |t|
         self.tool = t.to_sym
       end
@@ -342,6 +365,143 @@ class Herb::CLI
     nil
   end
 
+  def run_actionview_command
+    subcommand = @args[1]
+    @file = @args[2]
+
+    target_path = @file ? File.expand_path(@file) : Dir.pwd
+    target_directory = File.directory?(target_path) ? target_path : File.dirname(target_path)
+    config = Herb::Configuration.new(target_directory)
+
+    if !(subcommand == "help" || subcommand.nil?) && (config.framework != "actionview")
+      project = config.project_root || target_directory
+      abort <<~MESSAGE
+        Herb also works outside of ActionView, but the `herb actionview` commands require the project to be explicitly configured for ActionView.
+
+        The project at '#{project}' is not configured to use ActionView (current framework: '#{config.framework}').
+
+        To enable ActionView support, add the following to your `.herb.yml`:
+
+          framework: actionview
+      MESSAGE
+    end
+
+    case subcommand
+    when "check"
+      require_relative "action_view/render_analyzer"
+
+      path = File.expand_path(@file || ".")
+
+      unless File.directory?(path)
+        puts "Not a directory: '#{path}'."
+        exit(1)
+      end
+
+      analyzer = Herb::ActionView::RenderAnalyzer.new(path)
+      has_issues = analyzer.check!
+
+      exit(has_issues ? 1 : 0)
+    when "graph"
+      require_relative "action_view/render_analyzer"
+
+      path = @file || "."
+
+      unless File.directory?(path) || File.file?(path)
+        puts "Not a file or directory: '#{path}'."
+        exit(1)
+      end
+
+      path = File.expand_path(path)
+      project_root = File.directory?(path) ? path : config.project_root&.to_s || File.dirname(path)
+      analyzer = Herb::ActionView::RenderAnalyzer.new(project_root)
+
+      if File.file?(path)
+        analyzer.graph_file!(path)
+      else
+        analyzer.graph!
+      end
+
+      exit(0)
+    when "render"
+      @file = @args[2]
+      actionview_render
+    when nil, "help"
+      puts <<~HELP
+        Herb ActionView Commands
+
+        Usage:
+          bundle exec herb actionview [subcommand] [options]
+
+        Subcommands:
+          check [path]    Check if render calls resolve to valid partial files
+          graph [path]    Show render dependency graph for a project or file
+          render [file]   Render ERB template using ActionView helpers
+
+        Examples:
+          bundle exec herb actionview check
+          bundle exec herb actionview graph
+          bundle exec herb actionview graph app/views/posts/show.html.erb
+          bundle exec herb actionview render app/views/posts/show.html.erb
+
+      HELP
+      exit(0)
+    else
+      puts "Unknown actionview subcommand: '#{subcommand}'"
+      puts "Run 'herb actionview help' for available subcommands."
+      exit(1)
+    end
+  end
+
+  def actionview_render
+    require "action_view"
+
+    source = file_content
+
+    lookup_context = ActionView::LookupContext.new([])
+    view = ActionView::Base.with_empty_template_cache.new(lookup_context, {}, nil)
+    handler = ActionView::Template::Handlers::ERB.new
+
+    template = ActionView::Template.new(
+      source,
+      @file || "(eval)",
+      handler,
+      locals: [],
+      format: :html
+    )
+
+    rendered = template.render(view, {})
+
+    if json
+      puts({ success: true, output: rendered, source: source }.to_json)
+    elsif silent
+      puts "Success"
+    else
+      puts rendered
+    end
+
+    exit(0)
+  rescue LoadError
+    puts "Error: ActionView is required for 'herb actionview render'."
+    puts ""
+    puts "Add it to your Gemfile:"
+    puts "  gem 'actionview'"
+    puts ""
+    puts "Or install it directly:"
+    puts "  gem install actionview"
+    exit(1)
+  rescue StandardError => e
+    if json
+      puts({ success: false, error: e.message, source: source }.to_json)
+    elsif silent
+      puts "Failed"
+    else
+      puts "Error: #{e.class}: #{e.message}"
+      puts e.backtrace.first(5).map { |line| "  #{line}" }.join("\n")
+    end
+
+    exit(1)
+  end
+
   def node_available?
     system("which node > /dev/null 2>&1")
   end
@@ -435,6 +595,77 @@ class Herb::CLI
     project.print_file_report(@file)
   end
 
+  def dev_stop
+    require_relative "dev/runner"
+    Herb::Dev::Runner.new.stop
+  end
+
+  def dev_restart
+    require_relative "dev/runner"
+    Herb::Dev::Runner.new(path: @file || ".").restart
+  end
+
+  def dev_status
+    require_relative "dev/runner"
+    Herb::Dev::Runner.new.status
+  end
+
+  def run_dev_server
+    require_relative "dev/runner"
+    Herb::Dev::Runner.new(path: @file || ".").run
+  end
+
+  def diff_files
+    old_file = @args[1]
+    new_file = @args[2]
+
+    if old_file.nil? || new_file.nil?
+      puts "Usage: herb diff <old_file> <new_file> [options]"
+      exit(1)
+    end
+
+    unless File.exist?(old_file)
+      puts "File doesn't exist: #{old_file}"
+      exit(1)
+    end
+
+    unless File.exist?(new_file)
+      puts "File doesn't exist: #{new_file}"
+      exit(1)
+    end
+
+    old_content = File.read(old_file)
+    new_content = File.read(new_file)
+
+    diff_result = Herb.diff(old_content, new_content)
+
+    if json
+      require "json"
+      puts JSON.pretty_generate(diff_result.to_hash)
+    elsif diff_result.identical?
+      puts "Trees are identical."
+    else
+      operations = diff_result.operations
+      puts "#{operations.size} difference#{"s" unless operations.size == 1} found:\n\n"
+
+      operations.each_with_index do |operation, index|
+        puts "  #{index + 1}. #{operation.type} at path [#{operation.path.join(", ")}]"
+
+        if operation.old_node
+          puts "     old: #{operation.old_node.type}"
+        end
+
+        if operation.new_node
+          puts "     new: #{operation.new_node.type}"
+        end
+
+        puts
+      end
+    end
+
+    exit(0)
+  end
+
   def compile_template
     require_relative "engine"
 
@@ -450,6 +681,7 @@ class Herb::CLI
         options[:debug_filename] = @file if @file
       end
 
+      options[:optimize] = true if optimize
       options[:trim] = true if trim
       options[:validate_ruby] = true
       engine = Herb::Engine.new(file_content, options)
@@ -538,7 +770,9 @@ class Herb::CLI
         options[:debug_filename] = @file if @file
       end
 
+      options[:optimize] = true if optimize
       options[:trim] = true if trim
+
       engine = Herb::Engine.new(file_content, options)
       compiled_code = engine.src
 

data/lib/herb/colors.rb

@@ -5,6 +5,10 @@
 
 module Herb
   module Colors
+    HIDE_CURSOR = "\e[?25l"
+    SHOW_CURSOR = "\e[?25h"
+    CLEAR_SCREEN = "\e[2J\e[H"
+
     module_function
 
     #: () -> bool
@@ -78,5 +82,19 @@ module Herb
 
       "\e[1m#{string}\e[0m"
     end
+
+    #: (String, Integer) -> String
+    def fg(string, color)
+      return string unless enabled?
+
+      "\e[38;5;#{color}m#{string}\e[0m"
+    end
+
+    #: (String, Integer, Integer) -> String
+    def fg_bg(string, foreground, background)
+      return string unless enabled?
+
+      "\e[38;5;#{foreground};48;5;#{background}m#{string}\e[0m"
+    end
   end
 end

data/lib/herb/configuration.rb

@@ -5,6 +5,12 @@ require "pathname"
 
 module Herb
   class Configuration
+    OPTIONS_PATH = File.expand_path("../../config/options.yml", __dir__ || __FILE__).freeze #: String
+    OPTIONS = YAML.safe_load_file(OPTIONS_PATH).freeze #: Hash[String, untyped]
+
+    VALID_FRAMEWORKS = OPTIONS["framework"]["values"].freeze #: Array[String]
+    VALID_TEMPLATE_ENGINES = OPTIONS["template_engine"]["values"].freeze #: Array[String]
+
     CONFIG_FILENAMES = [".herb.yml"].freeze
 
     PROJECT_INDICATORS = [
@@ -22,12 +28,13 @@ module Herb
     DEFAULTS_PATH = File.expand_path("defaults.yml", __dir__ || __FILE__).freeze
     DEFAULTS = YAML.safe_load_file(DEFAULTS_PATH).freeze
 
-    attr_reader :config, :config_path, :project_root
+    attr_reader :config, :user_config, :config_path, :project_root
 
     def initialize(project_path = nil)
       @start_path = project_path ? Pathname.new(project_path) : Pathname.pwd
       @config_path, @project_root = find_config_file
-      @config = load_config
+      @user_config = load_user_config
+      @config = deep_merge(DEFAULTS, @user_config)
     end
 
     def [](key)
@@ -42,6 +49,30 @@ module Herb
       @config["version"]
     end
 
+    #: () -> String
+    def framework
+      value = @config["framework"] || "ruby"
+
+      unless VALID_FRAMEWORKS.include?(value)
+        warn "[Herb] Unknown framework: #{value.inspect}. Valid values: #{VALID_FRAMEWORKS.join(", ")}. Defaulting to 'ruby'."
+        return "ruby"
+      end
+
+      value
+    end
+
+    #: () -> String
+    def template_engine
+      value = @config["template_engine"] || "erubi"
+
+      unless VALID_TEMPLATE_ENGINES.include?(value)
+        warn "[Herb] Unknown template_engine: #{value.inspect}. Valid values: #{VALID_TEMPLATE_ENGINES.join(", ")}. Defaulting to 'erubi'."
+        return "erubi"
+      end
+
+      value
+    end
+
     def files
       @config["files"] || {}
     end
@@ -62,6 +93,11 @@ module Herb
       @config["engine"] || {}
     end
 
+    #: (String, untyped) -> untyped
+    def engine_option(key, default = nil)
+      engine.fetch(key.to_s, default)
+    end
+
     def enabled_validators(overrides = {})
       config = dig("engine", "validators") || {}
 
@@ -221,26 +257,26 @@ module Herb
       end
     end
 
-    def load_config
-      return deep_merge(DEFAULTS, {}) unless @config_path&.exist?
+    def load_user_config
+      return {} unless @config_path&.exist?
 
       begin
-        user_config = YAML.safe_load_file(@config_path, permitted_classes: [Symbol]) || {}
-        deep_merge(DEFAULTS, user_config)
+        YAML.safe_load_file(@config_path, permitted_classes: [Symbol]) || {}
       rescue Psych::SyntaxError => e
         warn "Warning: Invalid YAML in #{@config_path}: #{e.message}"
-        deep_merge(DEFAULTS, {})
+
+        {}
       end
     end
 
     def deep_merge(base, override, additive_keys: ["include", "exclude"])
-      base.merge(override) do |key, old_val, new_val|
-        if old_val.is_a?(Hash) && new_val.is_a?(Hash)
-          deep_merge(old_val, new_val, additive_keys: additive_keys)
-        elsif old_val.is_a?(Array) && new_val.is_a?(Array) && additive_keys.include?(key)
-          old_val + new_val
+      base.merge(override) do |key, old_value, new_value|
+        if old_value.is_a?(Hash) && new_value.is_a?(Hash)
+          deep_merge(old_value, new_value, additive_keys: additive_keys)
+        elsif old_value.is_a?(Array) && new_value.is_a?(Array) && additive_keys.include?(key)
+          old_value + new_value
         else
-          new_val
+          new_value
         end
       end
     end

data/lib/herb/defaults.yml

@@ -1,3 +1,6 @@
+framework: ruby
+template_engine: erubi
+
 files:
   include:
     - "**/*.herb"