ebsm 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6f67cacb0b8f96cb6a3d1772bba3e2b8fb49095e7cd7088127a4c14e080aa792
+  data.tar.gz: 4efb427fbed1f5ffba5b13cd4b448223d1bf1a41c6e46873e03c539296e7e0fa
+SHA512:
+  metadata.gz: 672b49abb7e7081fa96ea0077a845a50d6745e792b5b5a4d4923593cd5a1c9c4f165742128b20d345b611b60d6608835ef3b57603d1f771c893e9fdc2238c878
+  data.tar.gz: 87aefd8f087c5d27941b64af730fd96083cc8b7f19cc779776ca39a2df4bd4f3c1ee89d6c52b971c6f7833fcd564c9c2a4be5b3a2a5b234f0c3d5e6f90f6aa14

data/Gemfile

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ebsm.gemspec
+gemspec
+
+# Specify development dependencies here and not in the gemspec
+gem 'markspec'
+gem 'rake'
+gem 'rspec'
+gem 'rubocop'
+gem 'rubocop-rake'
+gem 'rubocop-rspec'
+gem 'rubocop-yard'
+gem 'yard'
+gem 'yard-rspec'

data/ebsm.gemspec

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'lib/ebsm/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ebsm'
+  spec.version       = Ebsm::VERSION
+  spec.authors       = ['David Siaw']
+  spec.email         = ['874280+davidsiaw@users.noreply.github.com']
+
+  spec.summary       = 'Ebsm gem'
+  spec.description   = 'Does not do anything'
+  spec.homepage      = 'https://github.com/davidsiaw/ebsm'
+  spec.license       = 'MIT'
+  spec.required_ruby_version = Gem::Requirement.new('>= 3.0')
+
+  spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/davidsiaw/ebsm'
+  spec.metadata['changelog_uri'] = 'https://github.com/davidsiaw/ebsm'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+
+  spec.files         = Dir['{exe,data,lib}/**/*'] + %w[Gemfile ebsm.gemspec]
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'bsm'
+end

data/exe/ebsm

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'ebsm'
+require 'bsm'
+
+# When set, print the expanded bsm2 literate text (the output of
+# Ebsm::Renderer#render) instead of compiling it to binary. Useful for
+# debugging ebsm scripting: you see exactly what the templating produced
+# before bsm2 turns it into bytes.
+output_bsm2 = ARGV.delete('--bsm') || ARGV.delete('-b')
+
+content = ARGF.read
+
+begin
+  expanded = Ebsm::Renderer.new.render(content)
+  if output_bsm2
+    print expanded
+  else
+    print Ebsm::Renderer.new.bsm2_evaluate(content)
+  end
+rescue Ebsm::Error => e
+  warn e.format
+  exit 1
+end

data/lib/ebsm/dsl.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require 'ebsm/hex'
+
+module Ebsm
+  # The evaluation context for an ebsm template -- the object whose binding an
+  # ERB template is evaluated against. Any public method here is available
+  # inside a [expr] interpolation or a <% ... %> code block.
+  #
+  # Helper methods are expected to return strings that the bsm2 lexer can
+  # consume on a '; ' data line -- typically space-separated hex byte pairs, so
+  # that e.g. [le32 0x12345678] expands to "; 78 56 34 12".
+  class Dsl
+    def initialize
+      @emitted = []
+    end
+
+    # Source lines of the template being rendered, set by the renderer before
+    # evaluation so #eval_at can report the text of an offending line.
+    attr_writer :lines
+
+    # The [source_line, expanded_text] pairs emitted by #line, in order. The
+    # renderer reads this to feed each ; line to bsm2 individually so a bsm2
+    # error can be reported against the original source line.
+    attr_reader :emitted
+
+    # --- Byte helpers -------------------------------------------------------
+    # Each helper emits +value+ as space-separated hex byte pairs, raising
+    # Ebsm::Error if +value+ is not an Integer or does not fit the width.
+
+    # Emit +value+ as a single hex byte pair (0..0xff).
+    # @param value [Integer] the byte value, 0..255.
+    # @return [String] two lowercase hex digits.
+    def byte(value)
+      hex.pack_hex(value, 'C', 0xff)
+    end
+
+    # Emit +count+ copies of +value+ as space-separated lowercase hex pairs.
+    # Handy for padding/filling, e.g. [repeat 0x00, 16] pads 16 zero bytes.
+    # +value+ must be an Integer 0..255; +count+ must be a non-negative Integer.
+    # @param value [Integer] the byte to repeat, 0..255.
+    # @param count [Integer] non-negative number of copies.
+    # @return [String] space-separated hex byte pairs.
+    def repeat(value, count)
+      unless count.is_a?(Integer) && !count.negative?
+        raise Ebsm::Error,
+              "#{count.inspect} is not a non-negative Integer"
+      end
+
+      hex_val = hex.hex_pair(value)
+      Array.new(count, hex_val).join(' ')
+    end
+
+    # Emit every byte of +value+ as space-separated lowercase hex pairs.
+    # Accepts a String (its bytes) or an Enumerable of Integers (each 0..255).
+    # Useful for dumping a whole string or byte array in one call, e.g.
+    # [bytes chunk] where chunk is a binary String, or [bytes arr] where arr
+    # is an Array of Integers assigned on a # line.
+    # @param value [String, Enumerable<Integer>] the bytes to emit.
+    # @return [String] space-separated hex byte pairs.
+    def bytes(value)
+      ints = value.is_a?(String) ? value.bytes : value.to_a
+      ints.map { |b| hex.hex_pair(b) }.join(' ')
+    end
+
+    # Emit +value+ as 2 little-endian hex byte pairs (0..0xffff).
+    # @param value [Integer] 0..0xffff.
+    # @return [String] two space-separated hex byte pairs.
+    def le16(value)
+      hex.pack_hex(value, 'v', 0xffff)
+    end
+
+    # Emit +value+ as 2 big-endian hex byte pairs (0..0xffff).
+    # @param value [Integer] 0..0xffff.
+    # @return [String] two space-separated hex byte pairs.
+    def be16(value)
+      hex.pack_hex(value, 'n', 0xffff)
+    end
+
+    # Emit +value+ as 4 little-endian hex byte pairs (0..0xffffffff).
+    # @param value [Integer] 0..0xffffffff.
+    # @return [String] four space-separated hex byte pairs.
+    def le32(value)
+      hex.pack_hex(value, 'V', 0xffffffff)
+    end
+
+    # Emit +value+ as 4 big-endian hex byte pairs (0..0xffffffff).
+    # @param value [Integer] 0..0xffffffff.
+    # @return [String] four space-separated hex byte pairs.
+    def be32(value)
+      hex.pack_hex(value, 'N', 0xffffffff)
+    end
+
+    # Emit +value+ as 8 little-endian hex byte pairs.
+    # @param value [Integer] 0..0xffffffffffffffff.
+    # @return [String] eight space-separated hex byte pairs.
+    def le64(value)
+      hex.pack_hex(value, 'Q<', 0xffffffffffffffff)
+    end
+
+    # Emit +value+ as 8 big-endian hex byte pairs.
+    # @param value [Integer] 0..0xffffffffffffffff.
+    # @return [String] eight space-separated hex byte pairs.
+    def be64(value)
+      hex.pack_hex(value, 'Q>', 0xffffffffffffffff)
+    end
+
+    # Emit +value+ as a 32-bit (single-precision) little-endian IEEE 754 float.
+    # @param value [Float] the float to encode.
+    # @return [String] four space-separated hex byte pairs.
+    def lef32(value)
+      hex.pack_float(value, 'e')
+    end
+
+    # Emit +value+ as a 32-bit (single-precision) big-endian IEEE 754 float.
+    # @param value [Float] the float to encode.
+    # @return [String] four space-separated hex byte pairs.
+    def bef32(value)
+      hex.pack_float(value, 'g')
+    end
+
+    # Emit +value+ as a 64-bit (double-precision) little-endian IEEE 754 float.
+    # @param value [Float] the float to encode.
+    # @return [String] eight space-separated hex byte pairs.
+    def lef64(value)
+      hex.pack_float(value, 'E')
+    end
+
+    # Emit +value+ as a 64-bit (double-precision) big-endian IEEE 754 float.
+    # @param value [Float] the float to encode.
+    # @return [String] eight space-separated hex byte pairs.
+    def bef64(value)
+      hex.pack_float(value, 'G')
+    end
+
+    # Evaluate a [expr] interpolation, annotating any error with the source
+    # position of the bracket so the CLI can draw an arrow/tilde. Ebsm::Error
+    # (from helpers) is passed through with position attached; any other
+    # StandardError raised by the expression (NoMethodError, ArgumentError,
+    # etc.) is wrapped in an Ebsm::Error so it gets the same diagnostic.
+    # @param line_number [Integer] 1-indexed source line of the bracket.
+    # @param column [Integer] 1-indexed column of the opening bracket.
+    # @param char_length [Integer] length of the [...] bracket span.
+    # @return [Object] the result of the block.
+    # @yieldreturn [Object] the result of the [expr] expression.
+    def eval_at(line_number, column, char_length)
+      yield
+    rescue Ebsm::Error => e
+      raise annotate(e, line_number, column, char_length)
+    rescue StandardError => e
+      raise annotate(Ebsm::Error.new("#{e.message} (#{e.class})"),
+                     line_number, column, char_length)
+    end
+
+    # The binding the renderer evaluates the ERB template against. Methods set
+    # or called in <% %> / <%= %> resolve on this object.
+    # @return [Binding] this DSL's binding.
+    def erb_binding
+      binding
+    end
+
+    private
+
+    # Attach source position to +error+ and return it for re-raising.
+    def annotate(error, line_number, column, char_length)
+      error.line_number = line_number
+      error.column = column
+      error.char_length = char_length
+      error.line_text = @lines[line_number - 1]
+      error.source_lines = @lines
+      error
+    end
+
+    # Record that a ; data line (the fully-expanded +text+) came from
+    # +source_line+, and return +text+ so ERB still emits it. The renderer
+    # reads #emitted to bsm2_evaluate each ; line individually.
+    # @param source_line [Integer] 1-indexed source line of the ; line.
+    # @return [String] the expanded ; line text.
+    # @yieldreturn [String] the expanded ; line text.
+    def line(source_line)
+      text = yield
+      @emitted << [source_line, text]
+      text
+    end
+
+    # @return [Ebsm::Hex] a fresh Hex formatter.
+    def hex
+      Hex.new
+    end
+  end
+end

data/lib/ebsm/hex.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Ebsm
+  # Formats numbers as the hex byte pairs the bsm2 lexer consumes on a '; '
+  # data line. Owns the responsibility of validating a number (Integer in range,
+  # or Float) and rendering it as lowercase hex pairs, so that Ebsm::Renderer can
+  # stay focused on templating.
+  class Hex
+    # Convert +value+ to a byte sequence via Array#pack using +directive+ and
+    # render it as space-separated lowercase hex pairs. Raises Ebsm::Error if
+    # +value+ is not an Integer or lies outside 0..+max+.
+    # @param value [Integer] the integer to encode.
+    # @param directive [String] an Array#pack directive (e.g. 'V', 'N', 'C').
+    # @param max [Integer] the inclusive upper bound for +value+.
+    # @return [String] space-separated lowercase hex byte pairs.
+    def pack_hex(value, directive, max)
+      raise Ebsm::Error, "#{value.inspect} is not an Integer" unless value.is_a?(Integer)
+
+      if value.negative? || value > max
+        raise Ebsm::Error, format('0x%<v>s out of range 0..0x%<m>x',
+                                  v: value.to_s(16), m: max)
+      end
+
+      [value].pack(directive).bytes.map { |b| format('%02x', b) }.join(' ')
+    end
+
+    # Render a single Integer byte (0..255) as a two-digit lowercase hex pair,
+    # raising Ebsm::Error if it is not an Integer or is out of range.
+    # @param byte [Integer] the byte value, 0..255.
+    # @return [String] two lowercase hex digits.
+    def hex_pair(byte)
+      raise Ebsm::Error, "#{byte.inspect} is not an Integer" unless byte.is_a?(Integer)
+
+      raise Ebsm::Error, format('0x%<v>s out of range 0..0xff', v: byte.to_s(16)) if byte.negative? || byte > 0xff
+
+      format('%02x', byte)
+    end
+
+    # Convert a Float +value+ to its IEEE 754 binary representation via
+    # Array#pack using +directive+ and render it as space-separated lowercase
+    # hex pairs. Raises Ebsm::Error if +value+ is not a Float.
+    # @param value [Float] the float to encode.
+    # @param directive [String] an Array#pack float directive ('e','g','E','G').
+    # @return [String] space-separated lowercase hex byte pairs.
+    def pack_float(value, directive)
+      raise Ebsm::Error, "#{value.inspect} is not a Float" unless value.is_a?(Float)
+
+      [value].pack(directive).bytes.map { |b| format('%02x', b) }.join(' ')
+    end
+  end
+end

data/lib/ebsm/renderer.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require 'erb'
+require 'ebsm/dsl'
+
+module Ebsm
+  # Renders ebsm source to bsm2 literate text. Owns the source -> ERB template
+  # translation; the byte helpers users call inside [...] live on Ebsm::Dsl,
+  # whose binding the template is evaluated against.
+  class Renderer
+    # Translate ebsm source into an ERB program, evaluate it against a Dsl
+    # instance, and return the resulting bsm2 literate text. Each [expr] on a
+    # '; ' data line is wrapped so that an Ebsm::Error raised while evaluating
+    # it is annotated with its source line, column, and length for diagnostics.
+    # @param content [String] the ebsm source.
+    # @return [String] the expanded bsm2 literate text.
+    def render(content)
+      dsl = evaluate(content)
+      ERB.new(build_template(content), trim_mode: '-').result(dsl.erb_binding)
+    end
+
+    # Evaluate the template, then feed each emitted ; line to bsm2 individually
+    # so a bsm2 lexer error is reported against the original source line (not
+    # the expanded text's line number). Returns the concatenated binary bytes.
+    # @param content [String] the ebsm source.
+    # @return [String] the concatenated binary bytes.
+    def bsm2_evaluate(content)
+      dsl = evaluate(content)
+      ERB.new(build_template(content), trim_mode: '-').result(dsl.erb_binding)
+      generator = Bsm::Generator.new
+      source_lines = content.lines.map(&:chomp)
+      dsl.emitted.each_with_object(+'') do |(source_line, text), output|
+        output << generate_line(generator, source_line, text, source_lines)
+      end
+    end
+
+    # Compile a single expanded ; line, re-raising a bsm2 error as an
+    # Ebsm::Error annotated with the original +source_line+ and source context.
+    # @param generator [Bsm::Generator] the bsm2 generator.
+    # @param source_line [Integer] 1-indexed source line of the ; line.
+    # @param text [String] the expanded ; line text.
+    # @param source_lines [Array<String>] all source lines (chomped).
+    # @return [String] the compiled binary bytes for this line.
+    def generate_line(generator, source_line, text, source_lines)
+      generator.generate("#{text}\n")
+    rescue Bsm::InvalidInput => e
+      raise bsm_error(e, source_line, text, source_lines)
+    end
+
+    # Translate ebsm source into an ERB program. A '# ' line becomes an ERB
+    # code block, a '; ' line is wrapped in a #line call (so the renderer can
+    # track which source line each expanded ; line came from), anything else
+    # passes through verbatim (bsm2 ignores it).
+    # @param content [String] the ebsm source.
+    # @return [String] the ERB program.
+    def build_template(content)
+      content.lines.each_with_index.map do |line, index|
+        stripped = line.chomp
+        if stripped.start_with?('#')
+          "<% #{stripped[1..]} -%>\n"
+        elsif stripped.start_with?(';')
+          "<%= line(#{index + 1}) { #{expand_brackets(stripped, index + 1)} } %>\n"
+        else
+          line
+        end
+      end.join
+    end
+
+    # Build a Ruby double-quoted string expression that evaluates to the
+    # expanded ; line, with each [expr] replaced by an `eval_at(N, col, len)`
+    # interpolation. Literal text is escaped for a double-quoted Ruby string.
+    # An unclosed [ is left literal.
+    # @param stripped [String] the chomped ; source line.
+    # @param line_number [Integer] 1-indexed source line number.
+    # @return [String] a Ruby double-quoted string expression.
+    def expand_brackets(stripped, line_number)
+      expr = +'"'
+      index = 0
+      expr, index = expand_segment(expr, stripped, index, line_number) while index < stripped.length
+      "#{expr}\""
+    end
+
+    # Expand one segment of a ; line starting at +index+, returning the updated
+    # [expr, next_index]. A [expr] bracket becomes an eval_at interpolation; a
+    # literal run is escaped; an unclosed [ ends the walk.
+    # @param expr [String] the accumulator expression so far.
+    # @param stripped [String] the chomped ; source line.
+    # @param index [Integer] the current position in +stripped+.
+    # @param line_number [Integer] 1-indexed source line number.
+    # @return [Array(String, Integer)] the updated [expr, next_index].
+    def expand_segment(expr, stripped, index, line_number)
+      if stripped[index] == '['
+        close = stripped.index(']', index)
+        return [expr, stripped.length] unless close
+
+        [expr + bracket_expr(stripped, index, close, line_number), close + 1]
+      else
+        chunk_end = stripped.index('[', index) || stripped.length
+        [expr + escape_dq(stripped[index...chunk_end]), chunk_end]
+      end
+    end
+
+    private
+
+    def evaluate(content)
+      dsl = Dsl.new
+      dsl.lines = content.lines.map(&:chomp)
+      dsl
+    end
+
+    # The `eval_at(...)` interpolation expression for a [expr] bracket
+    # spanning +open+..+close+ in +stripped+.
+    def bracket_expr(stripped, open, close, line_number)
+      inner = stripped[(open + 1)...close]
+      column = open + 1
+      length = close - open + 1
+      "\#{eval_at(#{line_number}, #{column}, #{length}) { #{inner} }}"
+    end
+
+    # Escape a literal chunk for a double-quoted Ruby string: backslash,
+    # double-quote, and # when it would start an interpolation.
+    def escape_dq(chunk)
+      chunk.gsub(/[\\"]|\#(?=[{@$])/) { |m| "\\#{m}" }
+    end
+
+    # Build an Ebsm::Error from a bsm2 error, pointing at +source_line+ with
+    # +expanded_text+ as the arrow target and +source_lines+ for context.
+    def bsm_error(error, source_line, expanded_text, source_lines)
+      result = Ebsm::Error.new(error.message)
+      result.line_number = source_line
+      result.column = error.column
+      result.char_length = error.length
+      result.line_text = error.line_text
+      result.source_lines = source_lines
+      result.expanded_line = expanded_text unless expanded_text == source_lines[source_line - 1]
+      result
+    end
+  end
+end

data/lib/ebsm/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# Ebsm is a literate binary generator: a templating layer over bsm2 that lets
+# you mix prose, Ruby scripting (# lines), and byte data (; lines) in one
+# source file. See Ebsm::Renderer and Ebsm::Dsl.
+module Ebsm
+  # The ebsm gem version.
+  VERSION = '0.1.0'
+end

data/lib/ebsm.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require 'ebsm/version'
+require 'ebsm/hex'
+require 'ebsm/dsl'
+require 'ebsm/renderer'
+require 'bsm'
+
+# Ebsm is a literate binary generator: a templating layer over bsm2 that lets
+# you mix prose, Ruby scripting (# lines), and byte data (; lines) in one
+# source file. See Ebsm::Renderer and Ebsm::Dsl.
+module Ebsm
+  # An error raised while evaluating ebsm source. Carries the source position
+  # of the offending line plus (for bsm2-stage errors) the expanded bsm2 line
+  # the arrow actually points at, so the CLI can show both source and expanded
+  # context like bsm2 does.
+  class Error < StandardError
+    # Source position of the offending line/bracket, filled in by the renderer.
+    attr_accessor :line_number, :column, :char_length, :line_text
+    # All source lines (chomped), for printing context lines above the error.
+    attr_accessor :source_lines
+    # The expanded bsm2 line the arrow points at. nil for ebsm-stage helper
+    # errors (where the source line is the arrow target).
+    attr_accessor :expanded_line
+
+    # Format this error as a diagnostic with source context (2 lines above)
+    # and, for bsm2-stage errors, the expanded line the arrow points at:
+    #
+    #   EBSM: bsm2 error at source line 2 (expanded column 17)
+    #   ---
+    #     1 | # x = 0x12345678
+    #   > 2 | ; [le32 x] 45 asd
+    #       expanded:
+    #       ; 78 56 34 12 45 asd
+    #                       ^ hex byte needs two hex digits
+    # @return [String] the formatted diagnostic.
+    def format
+      body = "#{header}\n---\n"
+      body << context_lines
+      body << expanded_section if expanded_line
+      body << arrow_line
+      body
+    end
+
+    # The header line, noting whether the column is expanded (bsm2-stage) or
+    # source (ebsm-stage).
+    # @return [String] the header line.
+    def header
+      if expanded_line
+        "EBSM: bsm2 error at source line #{line_number} (expanded column #{column})"
+      else
+        "EBSM: error at source line #{line_number} (column #{column})"
+      end
+    end
+
+    # The "expanded:" label and the expanded bsm2 line -- shown only for
+    # bsm2-stage errors where the arrow target differs from source.
+    # @return [String] the expanded section.
+    def expanded_section
+      pad = ' ' * prefix_width
+      "#{pad}expanded:\n#{pad}#{expanded_line}\n"
+    end
+
+    # The arrow (with leading spaces to align under the displayed line) and the
+    # error message.
+    # @return [String] the arrow line with the message.
+    def arrow_line
+      indent = ' ' * (prefix_width + (column - 1))
+      "#{indent}#{arrow} #{message}\n"
+    end
+
+    # The numbered source lines from 2 above the error up to the error line,
+    # with `> ` marking the error line. Line numbers are right-padded to the
+    # error line's digit width so the `|` pipes align. When the error is near
+    # the top of the file and there are fewer than 2 source lines above, a
+    # single `beginning of file` marker fills the gap.
+    # @return [String] the numbered context lines.
+    def context_lines
+      width = line_number.to_s.length
+      first = [line_number - 2, 1].max
+      bof = line_number < 3 ? [bof_line(width)] : []
+      real = (first..line_number).map { |n| context_line(n, width) }
+      (bof + real).join
+    end
+
+    private
+
+    def prefix_width
+      "> #{line_number} | ".length
+    end
+
+    def arrow
+      "^#{'~' * (char_length - 1)}"
+    end
+
+    def context_line(number, width)
+      prefix = number == line_number ? '> ' : '  '
+      "#{prefix}#{number.to_s.rjust(width)} | #{source_lines[number - 1]}\n"
+    end
+
+    def bof_line(width)
+      "  #{' ' * width} | *beginning of file*\n"
+    end
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: ebsm
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- David Siaw
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2026-07-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bsm
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Does not do anything
+email:
+- 874280+davidsiaw@users.noreply.github.com
+executables:
+- ebsm
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- ebsm.gemspec
+- exe/ebsm
+- lib/ebsm.rb
+- lib/ebsm/dsl.rb
+- lib/ebsm/hex.rb
+- lib/ebsm/renderer.rb
+- lib/ebsm/version.rb
+homepage: https://github.com/davidsiaw/ebsm
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/davidsiaw/ebsm
+  source_code_uri: https://github.com/davidsiaw/ebsm
+  changelog_uri: https://github.com/davidsiaw/ebsm
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.22
+signing_key:
+specification_version: 4
+summary: Ebsm gem
+test_files: []