herb 0.7.5 → 0.8.0

data/lib/herb/libherb/array.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-# typed: ignore
-
-# rbs_inline: disabled
-
-require "forwardable"
-
-module Herb
-  module LibHerb
-    attach_function :array_get, [:pointer, :int], :pointer
-    attach_function :array_capacity, [:pointer], :size_t
-    attach_function :array_size, [:pointer], :size_t
-
-    class Array
-      extend Forwardable
-
-      attr_reader :pointer, :item_class
-
-      def_delegators :items, :first, :last, :[]
-
-      def initialize(pointer, item_class)
-        @pointer = pointer
-        @item_class = item_class
-      end
-
-      def capacity
-        LibHerb.array_capacity(pointer)
-      end
-
-      def size
-        LibHerb.array_size(pointer)
-      end
-
-      def item_pointers
-        size.times.map { |item|
-          LibHerb.array_get(pointer, item)
-        }
-      end
-
-      def items
-        item_pointers.map { |item_pointer|
-          item_class.new(item_pointer)
-        }
-      end
-
-      def inspect
-        %(#<#{self.class} size=#{size} capacity=#{capacity} item_class=#{item_class} pointer=#{pointer}>)
-      end
-    end
-  end
-end

data/lib/herb/libherb/ast_node.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-# typed: ignore
-
-# rbs_inline: disabled
-
-module Herb
-  module LibHerb
-    attach_function :ast_node_type, [:pointer], :int
-    attach_function :ast_node_type_to_string, [:pointer], :string
-    attach_function :ast_node_children, [:pointer], :pointer
-    attach_function :ast_node_child_count, [:pointer], :size_t
-    attach_function :ast_pretty_print_node, [:pointer, :size_t, :size_t, :pointer], :void
-    attach_function :ast_node_free, [:pointer], :void
-
-    class ASTNode
-      attr_reader :pointer
-
-      def initialize(pointer)
-        @pointer = pointer
-      end
-
-      def type_int
-        LibHerb.ast_node_type(pointer)
-      end
-
-      def type
-        LibHerb.ast_node_type_to_string(pointer)
-      end
-
-      def child_count
-        LibHerb.ast_node_child_count(pointer)
-      end
-
-      def children
-        LibHerb::Array.new(
-          LibHerb.ast_node_children(pointer),
-          ASTNode
-        )
-      end
-
-      def inspect
-        LibHerb::Buffer.with do |output|
-          LibHerb.ast_pretty_print_node(pointer, 0, 0, output.pointer)
-
-          output.read.force_encoding("utf-8") # TODO: remove force_encoding
-        end
-      end
-    end
-  end
-end

data/lib/herb/libherb/buffer.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-# typed: ignore
-
-# rbs_inline: disabled
-
-module Herb
-  module LibHerb
-    attach_function :buffer_init, [:pointer], :bool
-    attach_function :buffer_free, [:pointer], :void
-    attach_function :buffer_value, [:pointer], :pointer
-    attach_function :buffer_length, [:pointer], :size_t
-    attach_function :buffer_capacity, [:pointer], :size_t
-    attach_function :buffer_sizeof, [], :size_t
-    attach_function :buffer_append, [:pointer, :pointer], :void
-
-    class Buffer
-      SIZEOF = LibHerb.buffer_sizeof
-
-      attr_reader :pointer
-
-      def initialize(pointer)
-        @pointer = pointer
-      end
-
-      def append(string)
-        LibHerb.buffer_append(pointer, string)
-      end
-
-      def value
-        LibHerb.buffer_value(pointer)
-      end
-
-      def length
-        LibHerb.buffer_length(pointer)
-      end
-
-      def capacity
-        LibHerb.buffer_capacity(pointer)
-      end
-
-      def read
-        value.read_string(length)
-      end
-
-      def self.with
-        FFI::MemoryPointer.new(SIZEOF) do |pointer|
-          raise "couldn't allocate Buffer" unless LibHerb.buffer_init(pointer)
-
-          return yield new(pointer)
-        ensure
-          LibHerb.buffer_free(pointer)
-        end
-      end
-    end
-  end
-end

data/lib/herb/libherb/extract_result.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-# typed: ignore
-
-# rbs_inline: disabled
-
-require "forwardable"
-
-module Herb
-  class ExtractResult
-    extend Forwardable
-
-    def_delegators :@buffer, :read
-
-    attr_accessor :buffer
-
-    def initialize(pointer)
-      @buffer = LibHerb::Buffer.new(pointer)
-    end
-  end
-end

data/lib/herb/libherb/lex_result.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-# typed: ignore
-
-# rbs_inline: disabled
-
-require "forwardable"
-
-module Herb
-  class LexResult
-    extend Forwardable
-
-    def_delegators :@array, :items, :size, :capacity
-
-    attr_accessor :array
-
-    def initialize(pointer)
-      @array = LibHerb::Array.new(pointer, LibHerb::Token)
-    end
-
-    def as_json
-      JSON.parse(to_json)
-    end
-
-    def to_json(*_args)
-      "[#{@array.items.map(&:to_json).join(", ")}]"
-    end
-
-    def inspect
-      @array.items.map(&:inspect).join("\n")
-    end
-  end
-end

data/lib/herb/libherb/libherb.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-# typed: ignore
-
-# rbs_inline: disabled
-
-require "herb/libherb/ast_node"
-require "herb/libherb/buffer"
-require "herb/libherb/array"
-require "herb/libherb/token"
-
-require "herb/libherb/lex_result"
-require "herb/libherb/parse_result"
-
-module Herb
-  VERSION = LibHerb.herb_version.read_string
-
-  def self.parse(source)
-    ParseResult.new(
-      LibHerb.herb_parse(source)
-    )
-  end
-
-  def self.lex(source)
-    LexResult.new(
-      LibHerb.herb_lex(source)
-    )
-  end
-
-  def self.lex_to_json(source)
-    LibHerb::Buffer.with do |output|
-      LibHerb.herb_lex_json_to_buffer(source, output.pointer)
-
-      JSON.parse(output.read.force_encoding("utf-8"))
-    end
-  end
-
-  def self.extract_ruby(source)
-    LibHerb::Buffer.with do |output|
-      LibHerb.herb_extract_ruby_to_buffer(source, output.pointer)
-
-      output.read
-    end
-  end
-
-  def self.extract_html(source)
-    LibHerb::Buffer.with do |output|
-      LibHerb.herb_extract_html_to_buffer(source, output.pointer)
-
-      output.read
-    end
-  end
-end

data/lib/herb/libherb/parse_result.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-# typed: ignore
-
-# rbs_inline: disabled
-
-require "forwardable"
-
-module Herb
-  class ParseResult
-    extend Forwardable
-
-    def_delegators :@root_node, :type, :child_count
-
-    attr_accessor :root_node
-
-    def initialize(pointer)
-      @root_node = LibHerb::ASTNode.new(pointer)
-    end
-  end
-end

data/lib/herb/libherb/token.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-# typed: ignore
-
-# rbs_inline: disabled
-
-module Herb
-  module LibHerb
-    attach_function :token_to_string, [:pointer], :string
-    attach_function :token_to_json, [:pointer], :string
-    attach_function :token_type_to_string, [:int], :pointer
-    attach_function :token_value, [:pointer], :pointer
-    attach_function :token_type, [:pointer], :int
-
-    class Token
-      attr_reader :pointer
-
-      def initialize(pointer)
-        @pointer = pointer
-      end
-
-      def value
-        @value ||= LibHerb.token_value(pointer).read_string
-      end
-
-      def type
-        @type ||= LibHerb.token_type_to_string(type_int).read_string
-      end
-
-      def type_int
-        @type_int ||= LibHerb.token_type(pointer)
-      end
-
-      def inspect
-        LibHerb.token_to_string(pointer).force_encoding("utf-8")
-      end
-
-      def as_json
-        JSON.parse(to_json)
-      end
-
-      def to_json(*_args)
-        LibHerb.token_to_json(pointer).force_encoding("utf-8")
-      end
-    end
-  end
-end

data/lib/herb/libherb.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-# typed: ignore
-
-# rbs_inline: disabled
-
-require "ffi"
-require "rbconfig"
-
-module Herb
-  module LibHerb
-    extend FFI::Library
-
-    def self.library_extension
-      RbConfig::CONFIG["DLEXT"]
-    end
-
-    def self.library_name
-      "libherb.#{library_extension}"
-    end
-
-    def self.library_path
-      File.expand_path("../../#{library_name}", __dir__)
-    end
-
-    ffi_lib(library_path)
-
-    attach_function :herb_lex_to_buffer, [:pointer, :pointer], :void
-    attach_function :herb_lex_json_to_buffer, [:pointer, :pointer], :void
-    attach_function :herb_lex, [:pointer], :pointer
-    attach_function :herb_parse, [:pointer], :pointer
-    attach_function :herb_extract_ruby_to_buffer, [:pointer, :pointer], :void
-    attach_function :herb_extract_html_to_buffer, [:pointer, :pointer], :void
-    attach_function :herb_version, [], :pointer
-  end
-end

data/src/buffer.c

@@ -1,241 +0,0 @@
-#include <stdint.h>
-#include <stdio.h>
-#include <string.h>
-
-#include "include/buffer.h"
-#include "include/macros.h"
-#include "include/memory.h"
-#include "include/util.h"
-
-bool buffer_init(buffer_T* buffer) {
-  buffer->capacity = 1024;
-  buffer->length = 0;
-  buffer->value = nullable_safe_malloc((buffer->capacity + 1) * sizeof(char));
-
-  if (!buffer->value) {
-    fprintf(stderr, "Error: Failed to initialize buffer with capacity of %zu.\n", buffer->capacity);
-    return false;
-  }
-
-  buffer->value[0] = '\0';
-
-  return true;
-}
-
-buffer_T buffer_new(void) {
-  buffer_T buffer;
-  buffer_init(&buffer);
-  return buffer;
-}
-
-char* buffer_value(const buffer_T* buffer) {
-  return buffer->value;
-}
-
-size_t buffer_length(const buffer_T* buffer) {
-  return buffer->length;
-}
-
-size_t buffer_capacity(const buffer_T* buffer) {
-  return buffer->capacity;
-}
-
-size_t buffer_sizeof(void) {
-  return sizeof(buffer_T);
-}
-
-/**
- * Increases the capacity of the buffer if needed to accommodate additional content.
- * This function only handles memory allocation and does not modify the buffer content
- * or null termination.
- *
- * @param buffer The buffer to increase capacity for
- * @param additional_capacity The additional length needed beyond current buffer capacity
- * @return true if capacity was increased, false if reallocation failed
- */
-bool buffer_increase_capacity(buffer_T* buffer, const size_t additional_capacity) {
-  if (additional_capacity + 1 >= SIZE_MAX) {
-    fprintf(stderr, "Error: Buffer capacity would overflow system limits.\n");
-    exit(1);
-  }
-
-  const size_t new_capacity = buffer->capacity + additional_capacity;
-
-  return buffer_resize(buffer, new_capacity);
-}
-
-/**
- * Resizes the capacity of the buffer to the specified new capacity.
- *
- * @param buffer The buffer to resize
- * @param new_capacity The new capacity to resize the buffer to
- * @return true if capacity was resized, false if reallocation failed
- */
-bool buffer_resize(buffer_T* buffer, const size_t new_capacity) {
-  if (new_capacity + 1 >= SIZE_MAX) {
-    fprintf(stderr, "Error: Buffer capacity would overflow system limits.\n");
-    exit(1);
-  }
-
-  char* new_value = nullable_safe_realloc(buffer->value, new_capacity + 1);
-
-  if (unlikely(new_value == NULL)) {
-    fprintf(stderr, "Error: Failed to resize buffer to %zu.\n", new_capacity);
-    exit(1);
-  }
-
-  buffer->value = new_value;
-  buffer->capacity = new_capacity;
-
-  return true;
-}
-
-/**
- * Expands the capacity of the buffer by doubling its current capacity.
- * This function is a convenience function that calls buffer_increase_capacity
- * with a factor of 2.
- *
- * @param buffer The buffer to expand capacity for
- * @return true if capacity was increased, false if reallocation failed
- */
-bool buffer_expand_capacity(buffer_T* buffer) {
-  return buffer_resize(buffer, buffer->capacity * 2);
-}
-
-/**
- * Expands the capacity of the buffer if needed to accommodate additional content.
- * This function is a convenience function that calls buffer_has_capacity and
- * buffer_expand_capacity.
- *
- * @param buffer The buffer to expand capacity for
- * @param required_length The additional length needed beyond current buffer capacity
- * @return true if capacity was increased, false if reallocation failed
- */
-bool buffer_expand_if_needed(buffer_T* buffer, const size_t required_length) {
-  if (buffer_has_capacity(buffer, required_length)) { return true; }
-
-  bool should_double_capacity = required_length < buffer->capacity;
-  size_t new_capacity = 0;
-
-  if (should_double_capacity) {
-    new_capacity = buffer->capacity * 2;
-  } else {
-    new_capacity = buffer->capacity + (required_length * 2);
-  }
-
-  return buffer_resize(buffer, new_capacity);
-}
-
-/**
- * Appends a null-terminated string to the buffer.
- * @note This function requires that 'text' is a properly null-terminated string.
- * When reading data from files or other non-string sources, ensure the data is
- * null-terminated before calling this function, or use buffer_append_with_length instead.
- *
- * @param buffer The buffer to append to
- * @param text A null-terminated string to append
- * @return void
- */
-void buffer_append(buffer_T* buffer, const char* text) {
-  if (!buffer || !text) { return; }
-  if (text[0] == '\0') { return; }
-
-  size_t text_length = strlen(text);
-
-  if (!buffer_expand_if_needed(buffer, text_length)) { return; }
-
-  memcpy(buffer->value + buffer->length, text, text_length);
-  buffer->length += text_length;
-  buffer->value[buffer->length] = '\0';
-}
-
-/**
- * Appends a string of specified length to the buffer.
- * Unlike buffer_append(), this function does not require the text to be
- * null-terminated as it uses the provided length instead of strlen().
- * This is particularly useful when working with data from files, network
- * buffers, or other non-null-terminated sources.
- *
- * @param buffer The buffer to append to
- * @param text The text to append (doesn't need to be null-terminated)
- * @param length The number of bytes to append from text
- * @return void
- */
-void buffer_append_with_length(buffer_T* buffer, const char* text, const size_t length) {
-  if (!buffer || !text || length == 0) { return; }
-  if (!buffer_expand_if_needed(buffer, length)) { return; }
-
-  memcpy(buffer->value + buffer->length, text, length);
-
-  buffer->length += length;
-  buffer->value[buffer->length] = '\0';
-}
-
-void buffer_append_char(buffer_T* buffer, const char character) {
-  static char string[2];
-
-  string[0] = character;
-  string[1] = '\0';
-
-  buffer_append(buffer, string);
-}
-
-void buffer_append_repeated(buffer_T* buffer, const char character, size_t length) {
-  if (length == 0) { return; }
-
-  char* spaces = malloc(length + 1);
-  if (!spaces) { return; }
-
-  memset(spaces, character, length);
-  spaces[length] = '\0';
-
-  buffer_append(buffer, spaces);
-
-  free(spaces);
-}
-
-void buffer_append_whitespace(buffer_T* buffer, const size_t length) {
-  buffer_append_repeated(buffer, ' ', length);
-}
-
-void buffer_prepend(buffer_T* buffer, const char* text) {
-  if (!buffer || !text) { return; }
-  if (text[0] == '\0') { return; }
-
-  size_t text_length = strlen(text);
-
-  if (!buffer_expand_if_needed(buffer, text_length)) { return; }
-
-  memmove(buffer->value + text_length, buffer->value, buffer->length + 1);
-  memcpy(buffer->value, text, text_length);
-
-  buffer->length += text_length;
-}
-
-void buffer_concat(buffer_T* destination, buffer_T* source) {
-  if (source->length == 0) { return; }
-  if (!buffer_expand_if_needed(destination, source->length)) { return; }
-
-  memcpy(destination->value + destination->length, source->value, source->length);
-
-  destination->length += source->length;
-  destination->value[destination->length] = '\0';
-}
-
-bool buffer_has_capacity(buffer_T* buffer, const size_t required_length) {
-  return (buffer->length + required_length <= buffer->capacity);
-}
-
-void buffer_clear(buffer_T* buffer) {
-  buffer->length = 0;
-  buffer->value[0] = '\0';
-}
-
-void buffer_free(buffer_T* buffer) {
-  if (!buffer) { return; }
-
-  if (buffer->value != NULL) { free(buffer->value); }
-
-  buffer->value = NULL;
-  buffer->length = buffer->capacity = 0;
-}

data/src/include/array.h

@@ -1,33 +0,0 @@
-#ifndef HERB_ARRAY_H
-#define HERB_ARRAY_H
-
-#include <stdlib.h>
-
-typedef struct ARRAY_STRUCT {
-  void** items;
-  size_t size;
-  size_t capacity;
-} array_T;
-
-array_T* array_init(size_t capacity);
-
-void* array_get(const array_T* array, size_t index);
-void* array_first(array_T* array);
-void* array_last(array_T* array);
-
-void array_append(array_T* array, void* item);
-void array_set(const array_T* array, size_t index, void* item);
-void array_free(array_T** array);
-void array_remove(array_T* array, size_t index);
-
-size_t array_index_of(array_T* array, void* item);
-void array_remove_item(array_T* array, void* item);
-
-void array_push(array_T* array, void* item);
-void* array_pop(array_T* array);
-
-size_t array_capacity(const array_T* array);
-size_t array_size(const array_T* array);
-size_t array_sizeof(void);
-
-#endif

data/src/include/buffer.h

@@ -1,39 +0,0 @@
-#ifndef HERB_BUFFER_H
-#define HERB_BUFFER_H
-
-#include <stdbool.h>
-#include <stdlib.h>
-
-typedef struct BUFFER_STRUCT {
-  char* value;
-  size_t length;
-  size_t capacity;
-} buffer_T;
-
-bool buffer_init(buffer_T* buffer);
-buffer_T buffer_new(void);
-
-bool buffer_increase_capacity(buffer_T* buffer, size_t additional_capacity);
-bool buffer_has_capacity(buffer_T* buffer, size_t required_length);
-bool buffer_expand_capacity(buffer_T* buffer);
-bool buffer_expand_if_needed(buffer_T* buffer, size_t required_length);
-bool buffer_resize(buffer_T* buffer, size_t new_capacity);
-
-void buffer_append(buffer_T* buffer, const char* text);
-void buffer_append_with_length(buffer_T* buffer, const char* text, size_t length);
-void buffer_append_char(buffer_T* buffer, char character);
-void buffer_append_repeated(buffer_T* buffer, char character, size_t length);
-void buffer_append_whitespace(buffer_T* buffer, size_t length);
-void buffer_prepend(buffer_T* buffer, const char* text);
-void buffer_concat(buffer_T* destination, buffer_T* source);
-
-char* buffer_value(const buffer_T* buffer);
-
-size_t buffer_length(const buffer_T* buffer);
-size_t buffer_capacity(const buffer_T* buffer);
-size_t buffer_sizeof(void);
-
-void buffer_clear(buffer_T* buffer);
-void buffer_free(buffer_T* buffer);
-
-#endif