herb 0.7.2-x86_64-linux-gnu → 0.7.4-x86_64-linux-gnu

data/templates/template.rb

@@ -0,0 +1,406 @@
+# frozen_string_literal: true
+# typed: false
+
+require "erb"
+require "fileutils"
+require "yaml"
+
+module Herb
+  module Template
+    class Field
+      attr_reader :name, :options
+
+      def initialize(name:, **options)
+        @name = name
+        @options = options
+      end
+    end
+
+    class ArrayField < Field
+      def initialize(kind:, **options)
+        @kind = kind
+        super(**options)
+      end
+
+      def ruby_type
+        return "Array" unless specific_kind
+        return "Array[Herb::AST::#{specific_kind}]" if specific_kind.end_with?("Node")
+
+        "Array[#{specific_kind}]"
+      end
+
+      def c_type
+        "array_T*"
+      end
+
+      def c_item_type
+        if specific_kind
+          "AST_#{specific_kind.gsub(/(?<=[a-zA-Z])(?=[A-Z][a-z])/, "_").upcase}_T*"
+        else
+          "void*"
+        end
+      end
+
+      def specific_kind
+        @kind unless @kind.is_a?(Array)
+      end
+
+      def union_kind
+        @kind if @kind.is_a?(Array)
+      end
+    end
+
+    class NodeField < Field
+      def initialize(kind:, **options)
+        @kind = kind
+        super(**options)
+      end
+
+      def c_type
+        if specific_kind
+          "struct AST_#{specific_kind.gsub(/(?<=[a-zA-Z])(?=[A-Z][a-z])/, "_").upcase}_STRUCT*"
+        else
+          "AST_NODE_T*"
+        end
+      end
+
+      def ruby_type
+        "Herb::AST::#{specific_kind || "Node"}"
+      end
+
+      def specific_kind
+        @kind unless @kind.is_a?(Array)
+      end
+
+      def union_kind
+        @kind if @kind.is_a?(Array)
+      end
+    end
+
+    class TokenField < Field
+      def ruby_type
+        "Herb::Token"
+      end
+
+      def c_type
+        "token_T*"
+      end
+    end
+
+    class TokenTypeField < Field
+      def ruby_type
+        "String"
+      end
+
+      def c_type
+        "token_type_T"
+      end
+    end
+
+    class StringField < Field
+      def ruby_type
+        "String"
+      end
+
+      def c_type
+        "const char*"
+      end
+    end
+
+    class PositionField < Field
+      def ruby_type
+        "Herb::Position"
+      end
+
+      def c_type
+        "position_T*"
+      end
+    end
+
+    class IntegerField < Field
+      def ruby_type
+        "Integer"
+      end
+
+      def c_type
+        "const int"
+      end
+    end
+
+    class SizeTField < Field
+      def ruby_type
+        "Integer"
+      end
+
+      def c_type
+        "size_t"
+      end
+    end
+
+    class BooleanField < Field
+      def ruby_type
+        "bool"
+      end
+
+      def c_type
+        "bool"
+      end
+    end
+
+    class PrismNodeField < Field
+      def ruby_type
+        "Prism::Node"
+      end
+
+      def c_type
+        "pm_node_t*"
+      end
+    end
+
+    class VoidPointerField < Field
+      def ruby_type
+        "nil"
+      end
+
+      def c_type
+        "void*"
+      end
+    end
+
+    class AnalyzedRubyField < Field
+      def ruby_type
+        "nil"
+      end
+
+      def c_type
+        "analyzed_ruby_T*"
+      end
+    end
+
+    class ElementSourceField < Field
+      def ruby_type
+        "String"
+      end
+
+      def c_type
+        "element_source_t"
+      end
+    end
+
+    module ConfigType
+      private
+
+      def normalize_kind(kind, type, name, field_name)
+        if kind
+          kind = [kind] unless kind.is_a?(Array)
+
+          kind = kind.first if kind.size == 1
+        elsif type < NodeField
+          raise "Missing kind in config.yml for field #{name}##{field_name}"
+        end
+
+        kind
+      end
+
+      def field_type_for(name)
+        case name
+        when "array"      then ArrayField
+        when "node"       then NodeField
+        when "token"      then TokenField
+        when "token_type" then TokenTypeField
+        when "string"     then StringField
+        when "position"   then PositionField
+        when "size_t"     then SizeTField
+        when "boolean"    then BooleanField
+        when "prism_node" then PrismNodeField
+        when "analyzed_ruby" then AnalyzedRubyField
+        when "element_source" then ElementSourceField
+        when "void*" then VoidPointerField
+        else raise("Unknown field type: #{name.inspect}")
+        end
+      end
+    end
+
+    class ErrorType
+      include ConfigType
+
+      attr_reader :name, :type, :struct_type, :struct_name, :human, :fields, :message_template, :message_arguments
+
+      def initialize(config)
+        @name = config.fetch("name")
+        @message_template = config.dig("message", "template")
+        @message_arguments = config.dig("message", "arguments")
+
+        camelized = @name.gsub(/(?<=[a-zA-Z])(?=[A-Z][a-z])/, "_")
+        @type = camelized.upcase
+        @struct_type = "#{camelized.upcase}_T"
+        @struct_name = "#{camelized.upcase}_STRUCT"
+        @human = camelized.downcase
+
+        @fields = config.fetch("fields", []).map do |field|
+          field_name = field.fetch("name")
+          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)
+        end
+      end
+    end
+
+    class NodeType
+      include ConfigType
+
+      attr_reader :name, :type, :struct_type, :struct_name, :human, :fields
+
+      def initialize(config)
+        @name = config.fetch("name")
+        camelized = @name.gsub(/(?<=[a-zA-Z])(?=[A-Z][a-z])/, "_")
+        @type = "AST_#{camelized.upcase}"
+        @struct_type = "AST_#{camelized.upcase}_T"
+        @struct_name = "AST_#{camelized.upcase}_STRUCT"
+        @human = camelized.downcase
+
+        @fields = config.fetch("fields", []).map do |field|
+          field_name = field.fetch("name")
+          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)
+        end
+      end
+    end
+
+    class PrintfMessageTemplate
+      MAX_STRING_SIZE = 128
+
+      # Estimated sizes for different format specifiers
+      ESTIMATED_SIZES = {
+        "%s" => MAX_STRING_SIZE, # Strings are truncated
+        "%d" => 11,  # INT_MAX is 10 digits + sign
+        "%u" => 10,  # UINT_MAX fits in 10 digits
+        "%zu" => 20,  # Large enough for size_t
+        "%llu" => 20, # Large enough for long long unsigned
+        "%ld" => 20, # Large enough for long int
+        "%f" => 32,  # Floating point with precision
+        "%lf" => 32, # Long double
+      }.freeze
+
+      def self.estimate_buffer_size(template)
+        base_length = template.length
+        total_size = base_length
+
+        format_specifiers = template.scan(/%[sdulfz]/)
+
+        format_specifiers.each_with_index do |specifier, _i|
+          estimated_size = ESTIMATED_SIZES[specifier] || 16 # Default extra buffer
+          total_size += estimated_size
+        end
+
+        total_size += 1 # Null terminator
+        total_size
+      end
+    end
+
+    def self.heading_for(file, template_file)
+      case File.extname(file)
+      when ".rb", ".rbs"
+        <<~HEADING
+          # frozen_string_literal: true
+          # typed: true
+
+          # NOTE: This file is generated by the templates/template.rb script and should not be
+          # modified manually. See #{template_file}
+
+        HEADING
+      else
+        <<~HEADING
+          // NOTE: This file is generated by the templates/template.rb script and should not
+          // be modified manually. See #{template_file}
+
+        HEADING
+      end
+    end
+
+    def self.check_gitignore(name)
+      file = Pathname.new(name)
+      file = file.absolute? ? file.relative_path_from(File.expand_path("../", __dir__)).to_s : file.to_s
+      return if gitignore_lines.include?(file)
+
+      puts "[WARNING]: make sure to add `#{file}` to the `.gitignore`"
+      puts
+    end
+
+    def self.render(template_file)
+      name = Pathname.new(template_file)
+      name = if name.absolute?
+               template_file.gsub(
+                 "#{__dir__}/",
+                 __dir__.delete_suffix("templates").to_s
+               )
+             else
+               name.to_s.delete_prefix("templates/")
+             end
+
+      name = name.delete_suffix(".erb")
+
+      destination = if Pathname.new(name).absolute?
+                      Pathname.new(name)
+                    else
+                      Pathname.new(
+                        File.expand_path("../#{name}", __dir__)
+                      )
+                    end
+
+      puts "Rendering #{template_file.delete_prefix("#{File.expand_path("../", __dir__)}/")} → #{destination}"
+
+      template_file = Pathname.new(template_file)
+      template_path = if template_file.absolute?
+                        template_file
+                      else
+                        Pathname(
+                          File.expand_path("../#{template_file}", __dir__)
+                        )
+                      end
+
+      rendered_template = read_template(template_path.to_s).result_with_hash({ nodes: nodes, errors: errors })
+      content = heading_for(name, template_file) + rendered_template
+
+      check_gitignore(name)
+
+      FileUtils.mkdir_p(File.dirname(destination))
+      File.write(destination, content)
+    rescue SyntaxError => e
+      puts
+      puts "Error while rendering #{template_file}:"
+      puts e
+      puts
+    end
+
+    def self.read_template(path)
+      content = File.read(path, encoding: Encoding::UTF_8)
+
+      ERB.new(content, trim_mode: "-").tap do |erb|
+        erb.filename = path
+      end
+    end
+
+    def self.gitignore_lines
+      @gitignore_lines ||= File.readlines(".gitignore").map(&:chomp)
+    rescue Errno::ENOENT
+      puts "[Herb Templates] Couldn't find .gitignore"
+      []
+    end
+
+    def self.nodes
+      (config.dig("nodes", "types") || []).map { |node| NodeType.new(node) }
+    end
+
+    def self.errors
+      (config.dig("errors", "types") || []).map { |node| ErrorType.new(node) }
+    end
+
+    def self.config
+      YAML.load_file("config.yml")
+    end
+  end
+end

data/templates/wasm/error_helpers.cpp.erb

@@ -0,0 +1,93 @@
+#include <emscripten/bind.h>
+#include <emscripten/val.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "extension_helpers.h"
+
+extern "C" {
+#include "../src/include/herb.h"
+#include "../src/include/token.h"
+#include "../src/include/array.h"
+#include "../src/include/errors.h"
+#include "../src/include/ast_node.h"
+#include "../src/include/ast_nodes.h"
+}
+
+using namespace emscripten;
+
+val CreateLocation(location_T* location);
+val CreateToken(token_T* token);
+val NodeFromCStruct(AST_NODE_T* node);
+val NodesArrayFromCArray(array_T* array);
+val ErrorFromCStruct(ERROR_T* error);
+val ErrorsArrayFromCArray(array_T* array);
+
+<%- errors.each do |error| -%>
+val <%= error.name %>FromCStruct(<%= error.struct_type %>* <%= error.human %>) {
+  if (!<%= error.human %>) {
+    return val::null();
+  }
+
+  val Object = val::global("Object");
+  val result = Object.new_();
+
+  result.set("type", CreateString(error_type_to_string(&<%= error.human %>->base)));
+  result.set("message", CreateString(<%= error.human %>->base.message));
+  result.set("location", CreateLocation(<%= error.human %>->base.location));
+  <%- error.fields.each do |field| -%>
+  <%- case field -%>
+  <%- when Herb::Template::StringField -%>
+  result.set("<%= field.name %>", CreateString(<%= error.human %>-><%= field.name %>));
+  <%- when Herb::Template::NodeField -%>
+  result.set("<%= field.name %>", NodeFromCStruct((AST_NODE_T*)<%= error.human %>-><%= field.name %>));
+  <%- when Herb::Template::TokenField -%>
+  result.set("<%= field.name %>", CreateToken(<%= error.human %>-><%= field.name %>));
+  <%- when Herb::Template::TokenTypeField -%>
+  result.set("<%= field.name %>", CreateString(token_type_to_string(<%= error.human %>-><%= field.name %>)));
+  <%- when Herb::Template::BooleanField -%>
+  result.set("<%= field.name %>", <%= error.human %>-><%= field.name %>);
+  <%- when Herb::Template::ArrayField -%>
+  result.set("<%= field.name %>", NodesArrayFromCArray(<%= error.human %>-><%= field.name %>));
+  <%- else -%>
+  result.set("<%= field.name %>", val::null());
+  <%- end -%>
+  <%- end -%>
+
+  return result;
+}
+
+<%- end -%>
+
+val ErrorsArrayFromCArray(array_T* array) {
+  val Array = val::global("Array");
+  val result = Array.new_();
+
+  if (array) {
+    for (size_t i = 0; i < array_size(array); i++) {
+      ERROR_T* error = (ERROR_T*)array_get(array, i);
+      if (error) {
+        result.call<void>("push", ErrorFromCStruct(error));
+      }
+    }
+  }
+
+  return result;
+}
+
+val ErrorFromCStruct(ERROR_T* error) {
+  if (!error) {
+    return val::null();
+  }
+
+  switch (error->type) {
+  <%- errors.each do |error| -%>
+    case <%= error.type %>:
+      return <%= error.name %>FromCStruct((<%= error.struct_type %>*)error);
+  <%- end -%>
+    default:
+      return val::null();
+  }
+}

data/templates/wasm/error_helpers.h.erb

@@ -0,0 +1,15 @@
+#ifndef HERB_EXTENSION_ERRORS_H
+#define HERB_EXTENSION_ERRORS_H
+
+extern "C" {
+#include "../src/include/herb.h"
+}
+
+emscripten::val ErrorFromCStruct(ERROR_T* error);
+emscripten::val ErrorsArrayFromCArray(array_T* array);
+
+<%- errors.each do |error| -%>
+emscripten::val <%= error.name %>FromCStruct(<%= error.struct_type %>* <%= error.human %>);
+<%- end -%>
+
+#endif

data/templates/wasm/nodes.cpp.erb

@@ -0,0 +1,79 @@
+#include <emscripten/bind.h>
+#include <emscripten/val.h>
+
+#include "error_helpers.h"
+#include "extension_helpers.h"
+
+#include "../src/include/herb.h"
+#include "../src/include/token.h"
+#include "../src/include/array.h"
+#include "../src/include/ast_node.h"
+#include "../src/include/ast_nodes.h"
+#include "../src/include/location.h"
+
+using namespace emscripten;
+
+val NodeFromCStruct(AST_NODE_T* node);
+val NodesArrayFromCArray(array_T* array);
+
+<%- nodes.each do |node| -%>
+val <%= node.name %>FromCStruct(<%= node.struct_type %>* <%= node.human %>) {
+  if (!<%= node.human %>) return val::null();
+
+  val result = val::object();
+  result.set("type", CreateString(ast_node_type_to_string(&<%= node.human %>->base)));
+  result.set("location", CreateLocation(<%= node.human %>->base.location));
+  result.set("errors", ErrorsArrayFromCArray(<%= node.human %>->base.errors));
+
+  <%- node.fields.each do |field| -%>
+  <%- case field -%>
+  <%- when Herb::Template::StringField -%>
+  result.set("<%= field.name %>", CreateString(<%= node.human %>-><%= field.name %>));
+  <%- when Herb::Template::NodeField -%>
+  result.set("<%= field.name %>", NodeFromCStruct((AST_NODE_T*) <%= node.human %>-><%= field.name %>));
+  <%- when Herb::Template::TokenField -%>
+  result.set("<%= field.name %>", CreateToken(<%= node.human %>-><%= field.name %>));
+  <%- when Herb::Template::BooleanField -%>
+  result.set("<%= field.name %>", <%= node.human %>-><%= field.name %> ? true : false);
+  <%- when Herb::Template::ArrayField -%>
+  result.set("<%= field.name %>", NodesArrayFromCArray(<%= node.human %>-><%= field.name %>));
+  <%- when Herb::Template::ElementSourceField -%>
+  result.set("<%= field.name %>", CreateString(element_source_to_string(<%= node.human %>-><%= field.name %>)));
+  <%- else -%>
+  result.set("<%= field.name %>", val::null());
+  <%- end -%>
+  <%- end -%>
+
+  return result;
+}
+
+<%- end -%>
+
+val NodeFromCStruct(AST_NODE_T* node) {
+  if (!node) return val::null();
+
+  switch (node->type) {
+  <%- nodes.each do |node| -%>
+  case <%= node.type %>:
+    return <%= node.name %>FromCStruct((<%= node.struct_type %>*) node);
+  <%- end -%>
+  default:
+    return val::null();
+  }
+}
+
+val NodesArrayFromCArray(array_T* array) {
+  if (!array) return val::null();
+
+  val jsArray = val::array();
+
+  for (size_t i = 0; i < array_size(array); i++) {
+    AST_NODE_T* child_node = (AST_NODE_T*) array_get(array, i);
+
+    if (child_node) {
+      jsArray.set(i, NodeFromCStruct(child_node));
+    }
+  }
+
+  return jsArray;
+}

data/templates/wasm/nodes.h.erb

@@ -0,0 +1,15 @@
+#ifndef HERB_EXTENSION_NODES_H
+#define HERB_EXTENSION_NODES_H
+
+extern "C" {
+#include "../src/include/herb.h"
+}
+
+emscripten::val NodeFromCStruct(AST_NODE_T* node);
+emscripten::val NodesArrayFromCArray(array_T* array);
+
+<%- nodes.each do |node| -%>
+emscripten::val <%= node.human %>NodeFromCStruct(<%= node.struct_type %>* <%= node.human %>);
+<%- end -%>
+
+#endif

data/vendor/prism/Rakefile

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rake/clean"
+
+task default: %i[compile test]
+
+require_relative "templates/template"
+
+desc "Generate all ERB template based files"
+task templates: Prism::Template::TEMPLATES
+
+make = RUBY_PLATFORM.match?(/openbsd|freebsd/) ? "gmake" : "make"
+task(make: :templates) { sh(make) }
+task(make_no_debug: :templates) { sh("#{make} all-no-debug") }
+task(make_minimal: :templates) { sh("#{make} minimal") }
+
+task compile: :make
+task compile_no_debug: %i[make_no_debug compile]
+task compile_minimal: %i[make_minimal compile]
+
+# decorate the gem build task with prerequisites
+task build: [:check_manifest, :templates]
+
+# the C extension
+task "compile:prism" => ["templates"] # must be before the ExtensionTask is created
+
+if RUBY_ENGINE == "ruby" and !ENV["PRISM_FFI_BACKEND"]
+  require "rake/extensiontask"
+
+  Rake::ExtensionTask.new(:compile) do |ext|
+    ext.name = "prism"
+    ext.ext_dir = "ext/prism"
+    ext.lib_dir = "lib/prism"
+    ext.gem_spec = Gem::Specification.load("prism.gemspec")
+  end
+elsif RUBY_ENGINE == "jruby"
+  require "rake/javaextensiontask"
+
+  # This compiles java to make sure any templating changes produces valid code.
+  Rake::JavaExtensionTask.new(:compile) do |ext|
+    ext.name = "prism"
+    ext.ext_dir = "java"
+    ext.lib_dir = "tmp"
+    ext.source_version = "1.8"
+    ext.target_version = "1.8"
+    ext.gem_spec = Gem::Specification.load("prism.gemspec")
+  end
+end
+
+# So `rake clobber` will delete generated files
+CLOBBER.concat(Prism::Template::TEMPLATES)
+CLOBBER.concat(["build"])
+CLOBBER << "lib/prism/prism.#{RbConfig::CONFIG["DLEXT"]}"
+
+Prism::Template::TEMPLATES.each do |filepath|
+  desc "Generate #{filepath}"
+  file filepath => ["templates/#{filepath}.erb", "templates/template.rb", "config.yml"] do |t|
+    Prism::Template.render(t.name)
+  end
+end
+
+namespace :build do
+  task :dev_version_set do
+    filepath = File.expand_path("prism.gemspec", __dir__)
+    File.write(filepath, File.read(filepath).sub(/spec\.version = ".+?"/, %Q{spec.version = "9999.9.9"}))
+  end
+
+  task :dev_version_clear do
+    sh "git checkout -- prism.gemspec Gemfile.lock"
+  end
+
+  desc "Build a development version of the gem"
+  task dev: ["build:dev_version_set", "build", "build:dev_version_clear"]
+end