herb 0.10.4 → 0.11.0

data/templates/template.rb

@@ -9,7 +9,7 @@ module Herb
   module Template
     def self.underscore(name)
       name
-        .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+        .gsub(/([A-Z])(?=[A-Z][a-z])/, '\1_')
         .gsub(/([a-z\d])([A-Z])/, '\1_\2')
     end
 
@@ -17,6 +17,22 @@ module Herb
     CONDITIONALLY_INVISIBLE_FIELD_CLASSES = ["PrismSerializedField", "PrismNodeField"].freeze
     ALL_INVISIBLE_FIELD_CLASSES = (ALWAYS_INVISIBLE_FIELD_CLASSES + CONDITIONALLY_INVISIBLE_FIELD_CLASSES).freeze
 
+    NON_NILABLE_RUBY_TYPES = [
+      "Array[Herb::AST::Node]",
+      "Array[Herb::AST::ERBWhenNode]",
+      "Array[Herb::AST::ERBInNode]",
+      "bool",
+      "nil"
+    ].freeze
+
+    PrismConfigField = Data.define(:name, :type)
+
+    PrismConfigNode = Data.define(:name, :type_id, :fields, :flags) do
+      def entries
+        flags ? [PrismConfigField.new(flags, "__flags")] + fields : fields
+      end
+    end
+
     class Field
       attr_reader :name, :options
 
@@ -25,6 +41,26 @@ module Herb
         @options = options
       end
 
+      def nilable?
+        !NON_NILABLE_RUBY_TYPES.include?(ruby_type)
+      end
+
+      def nilable_ruby_type
+        nilable? ? "#{ruby_type}?" : ruby_type
+      end
+
+      def default_ruby_value
+        case ruby_type
+        when "bool" then "false"
+        when /\AArray\[/ then "[]"
+        else "nil"
+        end
+      end
+
+      def writable?
+        options.fetch(:writable, false)
+      end
+
       def always_invisible?
         ALWAYS_INVISIBLE_FIELD_CLASSES.include?(self.class.name.split("::").last)
       end
@@ -367,12 +403,14 @@ module Herb
     class ErrorType
       include ConfigType
 
-      attr_reader :name, :type, :struct_type, :struct_name, :human, :fields, :message_template, :message_arguments
+      attr_reader :name, :type, :struct_type, :struct_name, :human, :fields, :message_template, :message_arguments, :suggestion_template, :suggestion_arguments
 
       def initialize(config)
         @name = config.fetch("name")
         @message_template = config.dig("message", "template")
         @message_arguments = config.dig("message", "arguments")
+        @suggestion_template = config.dig("suggestion", "template")
+        @suggestion_arguments = config.dig("suggestion", "arguments") || []
 
         camelized = Template.underscore(@name)
         @type = camelized.upcase
@@ -389,6 +427,14 @@ module Herb
         end
       end
 
+      def ruby_suggestion_arguments
+        suggestion_arguments.map { |argument| argument.gsub("->", ".") }
+      end
+
+      def ruby_suggestion_guards
+        suggestion_arguments.map { |argument| argument.split("->").first }.uniq
+      end
+
       def c_type
         @struct_type
       end
@@ -397,6 +443,8 @@ module Herb
     class NodeType
       include ConfigType
 
+      ERB_TAG_FIELDS = ["tag_opening", "content", "tag_closing"].freeze
+
       attr_reader :name, :type, :struct_type, :struct_name, :human, :fields
 
       def initialize(config)
@@ -412,10 +460,20 @@ module Herb
           type = field_type_for(field.fetch("type"))
           kind = normalize_kind(field.fetch("kind", nil), type, @name, field_name)
 
-          type.new(name: field_name, kind: kind)
+          type.new(name: field_name, kind: kind, writable: field.fetch("writable", false))
         end
       end
 
+      def erb_tag?
+        names = fields.map(&:name)
+
+        ERB_TAG_FIELDS.all? { |field| names.include?(field) }
+      end
+
+      def html?
+        name.start_with?("HTML")
+      end
+
       def c_type
         @struct_type
       end
@@ -485,6 +543,26 @@ module Herb
       end
     end
 
+    class HelperBlockArgument
+      attr_reader :name, :position, :type, :optional, :description
+
+      def initialize(config)
+        @name = config.fetch("name")
+        @position = config.fetch("position")
+        @type = Array(config.fetch("type"))
+        @optional = config.fetch("optional", false)
+        @description = config.fetch("description", "")
+      end
+
+      def type_display
+        @type.join(" | ")
+      end
+
+      def escaped_description
+        Template.escape_string(@description)
+      end
+    end
+
     class HelperOption
       attr_reader :name, :type, :maps_to, :description
 
@@ -519,13 +597,15 @@ module Herb
     end
 
     class HelperContent
-      attr_reader :source, :arg_position, :skip_if_hash, :to_s_suffix_when_single
+      attr_reader :source, :arg_position, :skip_if_hash, :to_s_suffix_when_single,
+                  :positional_arguments_with_block
 
       def initialize(config)
         @source = config.fetch("source")
         @arg_position = config.fetch("arg_position", nil)
         @skip_if_hash = config.fetch("skip_if_hash", false)
         @to_s_suffix_when_single = config.fetch("to_s_suffix_when_single", false)
+        @positional_arguments_with_block = config.fetch("positional_arguments_with_block", nil)
       end
 
       def null?
@@ -613,12 +693,183 @@ module Herb
       end
     end
 
+    class StateKind
+      attr_reader :name, :article, :prism_nodes
+
+      def initialize(config)
+        @name = config.fetch("name")
+        @article = config.fetch("article")
+        @prism_nodes = config.fetch("prism_nodes", [])
+        @literal = config.fetch("literal", false)
+        @value = config.fetch("value", false)
+        @unknown = config.fetch("unknown", false)
+        @falsy = config.fetch("falsy", false)
+        @nilable = config.fetch("nilable", false)
+      end
+
+      def literal?
+        @literal
+      end
+
+      def value?
+        @value
+      end
+
+      def unknown?
+        @unknown
+      end
+
+      def falsy?
+        @falsy
+      end
+
+      def nilable?
+        @nilable
+      end
+
+      def prism_constants
+        prism_nodes.map { |node| "PM_#{Template.underscore(node).upcase}" }
+      end
+    end
+
+    class HTMLElement
+      attr_reader :name, :description
+
+      def initialize(config)
+        @name = config.fetch("name")
+        @description = config.fetch("description")
+        @void = config.fetch("void", false)
+        @deprecated = config.fetch("deprecated", false)
+        @whitespace_preserving = config.fetch("whitespace_preserving", false)
+        @inline = config.fetch("inline", false)
+      end
+
+      def void? = @void
+      def deprecated? = @deprecated
+      def whitespace_preserving? = @whitespace_preserving
+      def inline? = @inline
+    end
+
+    class ForeignContentElement
+      attr_reader :name, :kind
+
+      def initialize(config)
+        @name = config.fetch("name")
+        @kind = config.fetch("kind")
+        @end_tag = config.fetch("end_tag", true)
+        @html_only = config.fetch("html_only", false)
+
+        raise "Unknown foreign content kind #{@kind.inspect} for #{@name}" unless ["raw_text", "rcdata"].include?(@kind)
+      end
+
+      def raw_text? = @kind == "raw_text"
+      def rcdata? = @kind == "rcdata"
+      def end_tag? = @end_tag
+      def html_only? = @html_only
+    end
+
+    class SlotsComponentAttribute
+      attr_reader :name, :type, :description
+
+      def initialize(config)
+        @name = config.fetch("name")
+        @type = config.fetch("type")
+        @description = config.fetch("description")
+      end
+    end
+
+    class SlotsComponent
+      attr_reader :name, :parents, :description, :attributes
+
+      def initialize(config)
+        @name = config.fetch("name")
+        @parents = config.fetch("parents", nil)
+        @description = config.fetch("description")
+        @attributes = config.fetch("attributes", []).map { |attribute| SlotsComponentAttribute.new(attribute) }
+        @deferred = config.fetch("deferred", false)
+        @void = config.fetch("void", false)
+      end
+
+      def deferred?
+        @deferred
+      end
+
+      def void?
+        @void
+      end
+    end
+
+    class StateOperator
+      attr_reader :operator, :mirrored, :negated
+
+      def initialize(config)
+        @operator = config.fetch("operator")
+        @mirrored = config.fetch("mirrored", nil)
+        @negated = config.fetch("negated")
+        @ordered = config.fetch("ordered", false)
+      end
+
+      def ordered?
+        @ordered
+      end
+    end
+
+    class StateTransform
+      attr_reader :name, :operation, :kinds, :returns, :only
+
+      def initialize(config)
+        @name = config.fetch("name")
+        @operation = config.fetch("operation")
+        @kinds = config.fetch("kinds", nil)
+        @returns = config.fetch("returns")
+        @only = config.fetch("only")
+      end
+
+      def ruby_kinds
+        kinds ? "[#{kinds.map { |kind| ":#{kind}" }.join(", ")}]" : "nil"
+      end
+
+      def typescript_kinds
+        kinds ? "[#{kinds.map(&:inspect).join(", ")}]" : "null"
+      end
+    end
+
+    class StatePredicate
+      attr_reader :name, :comparand, :operator, :kinds, :only, :rewrite, :negated
+
+      def initialize(config)
+        @name = config.fetch("name")
+        @comparand = config.fetch("comparand", nil)
+        @operator = config.fetch("operator", nil)
+        @kinds = config.fetch("kinds", nil)
+        @only = config.fetch("only")
+        @rewrite = config.fetch("rewrite", nil)
+        @negated = config.fetch("negated", nil)
+      end
+
+      def unary?
+        !operator.nil? && comparand.nil?
+      end
+
+      def ruby_kinds
+        kinds ? "[#{kinds.map { |kind| ":#{kind}" }.join(", ")}]" : "nil"
+      end
+
+      def typescript_kinds
+        kinds ? "[#{kinds.map(&:inspect).join(", ")}]" : "null"
+      end
+
+      def literal(value)
+        value.inspect
+      end
+    end
+
     class HelperType
-      attr_reader :name, :source, :gem, :output, :visibility, :supports_block,
+      attr_reader :name, :source, :gem, :output, :visibility, :receiver, :supports_block,
                   :supported, :description, :signature, :documentation_url, :tag,
                   :content, :attributes_arg, :attributes_arg_with_block,
                   :transform_style, :custom_transform,
-                  :arguments, :options, :special_behaviors, :aliases
+                  :arguments, :options, :block_arguments, :special_behaviors, :aliases
 
       def initialize(config)
         @name = config.fetch("name")
@@ -626,6 +877,7 @@ module Herb
         @gem = config.fetch("gem")
         @output = config.fetch("output", "html")
         @visibility = config.fetch("visibility", "public")
+        @receiver = config.fetch("receiver", "view")
         @supports_block = config.fetch("supports_block", false)
         @supported = config.fetch("supported", false)
         @description = config.fetch("description", "").strip
@@ -645,6 +897,7 @@ module Herb
 
         @arguments = (config.fetch("arguments", []) || []).map { |arg| HelperArgument.new(arg) }
         @options = (config.fetch("options", []) || []).map { |opt| HelperOption.new(opt) }
+        @block_arguments = (config.fetch("block_arguments", []) || []).map { |arg| HelperBlockArgument.new(arg) }
 
         raw_behaviors = config.fetch("special_behaviors", []) || []
         @special_behaviors = raw_behaviors.map { |b| HelperSpecialBehavior.new(b) }
@@ -719,6 +972,14 @@ module Herb
         @visibility == "internal"
       end
 
+      def view_receiver?
+        @receiver == "view"
+      end
+
+      def form_builder_receiver?
+        @receiver == "form_builder"
+      end
+
       def tag?
         !@tag.nil?
       end
@@ -872,8 +1133,10 @@ module Herb
                         )
                       end
 
-      rendered_template = read_template(template_path.to_s).result_with_hash({ nodes: nodes, errors: errors, union_kinds: union_kinds, helpers: helpers })
-      content = heading_for(name, template_file) + rendered_template
+      rendered_template = read_template(template_path.to_s).result_with_hash(
+        { nodes: nodes, errors: errors, union_kinds: union_kinds, helpers: helpers, prism_nodes: prism_nodes, prism_flags: prism_flags, state_predicates: state_predicates, state_kinds: state_kinds, state_transforms: state_transforms, state_operators: state_operators, slots_components: slots_components, foreign_content_elements: foreign_content_elements, html_elements: html_elements, boolean_attributes: boolean_attributes, whitespace_preserving_elements: whitespace_preserving_elements, parser_options: parser_options, inline_elements: inline_elements }
+      )
+      content = heading_for(name, template_file_display) + rendered_template
 
       check_gitignore(name)
 
@@ -912,11 +1175,220 @@ module Herb
       []
     end
 
+    class ParserOptionField
+      attr_reader :name, :type, :default, :description, :c_name, :nullable, :null_sentinel, :ruby_unit, :default_ms, :count_name
+
+      def initialize(config)
+        @name = config.fetch("name")
+        @type = config.fetch("type")
+        @default = config["default"]
+        @default_ms = config["default_ms"]
+        @description = config.fetch("description", "")
+        @c_name = config.fetch("c_name", @name)
+        @count_name = config["count_name"]
+        @const_name = config["const_name"]
+        @nullable = config.fetch("nullable", false)
+        @null_sentinel = config["null_sentinel"]
+        @ruby_unit = config["ruby_unit"]
+        @only = config["only"]
+        @skip = config.fetch("skip", [])
+        @lex = config.fetch("lex", false)
+      end
+
+      def for?(language)
+        return @only.include?(language.to_s) if @only
+
+        !@skip.include?(language.to_s)
+      end
+
+      def c_extractable?
+        for?(:c) && !string_array?
+      end
+
+      def lex?
+        @lex
+      end
+
+      def boolean?
+        @type == "boolean"
+      end
+
+      def string_array?
+        @type == "string_array"
+      end
+
+      def uint64?
+        @type == "uint64"
+      end
+
+      def pointer?
+        @type == "pointer_uint32"
+      end
+
+      def nullable?
+        @nullable
+      end
+
+      def snake_case
+        @name
+      end
+
+      def camel_case
+        @name.split("_").map.with_index { |word, index| index.zero? ? word : word.capitalize }.join
+      end
+
+      def pascal_case
+        @name.split("_").map(&:capitalize).join
+      end
+
+      def upper_snake
+        (@const_name || @name).upcase
+      end
+
+      def java_getter
+        prefix = boolean? ? "is" : "get"
+
+        "#{prefix}#{pascal_case}"
+      end
+
+      def java_jni_signature
+        return "()Z" if boolean?
+        return "()Ljava/lang/Integer;" if nullable?
+
+        "()I"
+      end
+
+      def ruby_constant?
+        !string_array?
+      end
+
+      def ruby_default
+        return "[]" if string_array?
+        return "nil" if nullable? && @default.nil?
+
+        if @ruby_unit == "seconds" && @default_ms
+          seconds = @default_ms.to_f / 1000
+
+          return seconds == seconds.to_i ? seconds.to_i : seconds
+        end
+
+        @default
+      end
+
+      def ruby_default_type
+        return ruby_type unless nullable?
+
+        ruby_type.delete_suffix("?")
+      end
+
+      def c_default
+        return @null_sentinel if nullable? && @default.nil?
+        return @default_ms if @default_ms
+
+        @default
+      end
+
+      def js_default
+        return "[]" if string_array?
+        return "null" if nullable? && @default.nil?
+
+        @default_ms || @default
+      end
+
+      def java_default
+        return "null" if nullable? && @default.nil?
+
+        @default_ms || @default
+      end
+
+      def rust_default
+        return "None" if string_array?
+        return "None" if nullable? && @default.nil?
+
+        value = @default_ms || @default
+
+        nullable? ? "Some(#{value})" : value
+      end
+
+      def c_type
+        return "bool" if boolean?
+        return "uint64_t" if uint64?
+        return "uint32_t*" if pointer?
+        return "const hb_string_T*" if string_array?
+
+        "uint32_t"
+      end
+
+      def ruby_type
+        return "bool" if boolean?
+        return "Array[String]" if string_array?
+        return "Numeric" if @ruby_unit == "seconds"
+
+        nullable? ? "Integer?" : "Integer"
+      end
+
+      def typescript_type
+        return "boolean" if boolean?
+        return "string[]" if string_array?
+
+        nullable? ? "number | null" : "number"
+      end
+
+      def java_type
+        return "boolean" if boolean?
+
+        nullable? ? "Integer" : "int"
+      end
+
+      def rust_type
+        return "bool" if boolean?
+        return "Option<Vec<String>>" if string_array?
+
+        nullable? ? "Option<u32>" : "u32"
+      end
+    end
+
+    class ParserOptionsConfig
+      attr_reader :fields, :internal_fields
+
+      def initialize(config)
+        @fields = (config.fetch("fields", []) || []).map { |f| ParserOptionField.new(f) }
+        @internal_fields = (config.fetch("internal_fields", []) || []).map { |f| ParserOptionField.new(f) }
+      end
+
+      def fields_for(language)
+        @fields.select { |field| field.for?(language) }
+      end
+
+      def extractable_fields_for(language)
+        fields_for(language).select(&:c_extractable?)
+      end
+
+      def lex_fields_for(language)
+        fields_for(language).select(&:lex?)
+      end
+
+      def parse_fields_for(language)
+        fields_for(language).reject(&:lex?)
+      end
+
+      def all_c_fields
+        fields_for(:c) + @internal_fields
+      end
+    end
+
+    def self.parser_options
+      config_data = config["parser_options"]
+
+      return nil unless config_data
+
+      ParserOptionsConfig.new(config_data)
+    end
+
     def self.nodes
       (config.dig("nodes", "types") || []).map { |node| NodeType.new(node) }
     end
 
-    # Collect all unique union kinds from node fields
     def self.union_kinds
       union_kinds_set = Set.new
 
@@ -941,8 +1413,91 @@ module Herb
       end
     end
 
+    def self.state_predicates
+      config = YAML.load_file("config/state/predicates.yml")
+
+      (config["predicates"] || []).map { |predicate| StatePredicate.new(predicate) }
+    end
+
+    def self.state_kinds
+      config = YAML.load_file("config/state/kind.yml")
+
+      (config["kinds"] || []).map { |kind| StateKind.new(kind) }
+    end
+
+    def self.state_transforms
+      config = YAML.load_file("config/state/transforms.yml")
+
+      (config["transforms"] || []).map { |transform| StateTransform.new(transform) }
+    end
+
+    def self.state_operators
+      config = YAML.load_file("config/state/operators.yml")
+
+      (config["comparisons"] || []).map { |operator| StateOperator.new(operator) }
+    end
+
+    def self.html_elements
+      YAML.load_file("config/html_elements.yml")["elements"].map { |element| HTMLElement.new(element) }
+    end
+
+    def self.boolean_attributes
+      YAML.load_file("config/html_elements.yml")["boolean_attributes"]
+    end
+
+    def self.whitespace_preserving_elements
+      raw_text = foreign_content_elements.select(&:raw_text?).map(&:name)
+      flagged = html_elements.select(&:whitespace_preserving?).map(&:name)
+
+      (raw_text + flagged).sort
+    end
+
+    def self.inline_elements
+      html_elements.select(&:inline?).map(&:name).sort
+    end
+
+    def self.foreign_content_elements
+      config = YAML.load_file("config/html_elements.yml")
+
+      (config["foreign_content_elements"] || []).map { |element| ForeignContentElement.new(element) }
+    end
+
+    def self.slots_components
+      config = YAML.load_file("config/slots/components.yml", aliases: true)
+
+      (config["components"] || []).map { |component| SlotsComponent.new(component) }
+    end
+
     def self.config
       YAML.load_file("config.yml")
     end
+
+    def self.prism_config_path
+      require_relative "../lib/herb/bootstrap"
+
+      vendored = File.join(Herb::Bootstrap::PRISM_VENDOR_DIR, "config.yml")
+
+      return vendored if File.exist?(vendored)
+
+      File.join(Herb::Bootstrap.find_prism_gem_path, "config.yml")
+    end
+
+    def self.prism_config
+      @prism_config ||= YAML.load_file(prism_config_path)
+    end
+
+    def self.prism_nodes
+      (prism_config["nodes"] || []).each_with_index.map do |node, index|
+        fields = (node["fields"] || []).map { |field| PrismConfigField.new(field["name"], field["type"]) }
+
+        PrismConfigNode.new(node["name"], index + 1, fields, node["flags"])
+      end
+    end
+
+    def self.prism_flags
+      (prism_config["flags"] || []).to_h do |group|
+        [group["name"], (group["values"] || []).map { |value| value["name"] }]
+      end
+    end
   end
 end