rjq 0.1.0

data/lib/rjq/modules.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Rjq
+  class ModuleResolver
+    ResolvedModule = Struct.new(:name, :path, :content, :data, keyword_init: true)
+
+    DEFAULT_MAX_BYTES = 1_048_576
+
+    def initialize(paths: [], use_default_paths: true, max_bytes: DEFAULT_MAX_BYTES)
+      configured = paths.map { |path| File.expand_path(path) }
+      if use_default_paths
+        configured.concat(ENV.fetch('JQ_LIBRARY_PATH', '').split(File::PATH_SEPARATOR).reject(&:empty?))
+        configured.concat([File.expand_path('~/.jq'), File.expand_path('~/.rjq')])
+      end
+      @roots = configured.uniq.freeze
+      @max_bytes = max_bytes
+      @cache = {}
+    end
+
+    def resolve(name, from: nil, metadata: {}, data: false)
+      validate_name!(name)
+      extension = data ? '.json' : '.jq'
+      candidates(name, extension, from, metadata).each do |candidate|
+        next unless File.file?(candidate)
+
+        path = File.realpath(candidate)
+        validate_root!(path)
+        return cached_source(name, path, data)
+      end
+      raise CompileError, "module #{name.inspect} not found"
+    end
+
+    def initial_metadata
+      {}
+    end
+
+    private
+
+    def candidates(name, extension, from, metadata)
+      bases = search_bases(from, metadata)
+      filename = name.end_with?(extension) ? name : "#{name}#{extension}"
+      bases.flat_map do |base|
+        [File.expand_path(filename, base), File.expand_path(File.join(name, File.basename(filename)), base)]
+      end.uniq
+    end
+
+    def search_bases(from, metadata)
+      search = metadata['search']
+      if search
+        raise CompileError, 'module search metadata must be a string' unless search.is_a?(String)
+
+        return [File.expand_path(search, from ? File.dirname(from) : Dir.pwd)]
+      end
+
+      bases = []
+      bases << File.dirname(from) if from
+      bases.concat(@roots)
+      bases.uniq
+    end
+
+    def validate_name!(name)
+      unless name.is_a?(String) && !name.empty? && !name.include?("\0") && !Pathname.new(name).absolute?
+        raise CompileError, 'invalid module path'
+      end
+    end
+
+    def validate_root!(path)
+      roots = @roots.filter_map { |root| File.realpath(root) if File.directory?(root) }
+      return if roots.any? { |root| path == root || path.start_with?("#{root}#{File::SEPARATOR}") }
+
+      raise CompileError, "module path escapes configured library roots: #{path}"
+    end
+
+    def cached_source(name, path, data)
+      key = [path, data]
+      @cache[key] ||= begin
+        size = File.size(path)
+        raise CompileError, "module exceeds #{@max_bytes} byte limit: #{path}" if size > @max_bytes
+
+        ResolvedModule.new(name: name, path: path, content: File.binread(path), data: data).freeze
+      end
+    end
+  end
+
+  Modules = ModuleResolver
+end

data/lib/rjq/number.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module Rjq
+  class Number < Numeric
+    include Comparable
+
+    NUMBER_PATTERN = /\A-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?\z/
+
+    attr_reader :literal
+
+    def self.parse(literal)
+      new(literal)
+    end
+
+    def initialize(literal)
+      @literal = literal.to_s.freeze
+      raise ArgumentError, 'invalid number literal' unless NUMBER_PATTERN.match?(@literal)
+
+      @value = Float(@literal)
+      parse_decimal_components
+      freeze
+    end
+
+    def dump
+      return literal unless literal.match?(/[eE]/)
+
+      render_exponent_literal
+    end
+
+    def to_f
+      @value
+    end
+
+    def to_i
+      @value.to_i
+    end
+
+    def to_int
+      to_i
+    end
+
+    def to_s
+      dump
+    end
+
+    def inspect
+      "#<#{self.class} #{literal}>"
+    end
+
+    def <=>(other)
+      return decimal_compare(other) if other.is_a?(Number)
+
+      @value <=> numeric_value(other)
+    end
+
+    def ==(other)
+      return decimal_compare(other).zero? if other.is_a?(Number)
+
+      other.is_a?(Numeric) && @value == numeric_value(other)
+    end
+
+    def eql?(other)
+      other.is_a?(Numeric) && self == other
+    end
+
+    def hash
+      @value.hash
+    end
+
+    def coerce(other)
+      [numeric_value(other), @value]
+    end
+
+    def +(other) = @value + numeric_value(other)
+    def -(other) = @value - numeric_value(other)
+    def *(other) = @value * numeric_value(other)
+    def /(other) = @value / numeric_value(other)
+    def %(other) = @value % numeric_value(other)
+    def **(other) = @value**numeric_value(other)
+    def remainder(other) = @value.remainder(numeric_value(other))
+    def -@ = -@value
+    def +@ = @value
+
+    def abs = @value.abs
+    def ceil = @value.ceil
+    def floor = @value.floor
+    def round(...) = @value.round(...)
+    def truncate = @value.truncate
+    def finite? = @value.finite?
+    def infinite? = @value.infinite?
+    def nan? = @value.nan?
+    def negative? = @value.negative?
+    def positive? = @value.positive?
+    def zero? = @value.zero?
+
+    def decimal_compare(other)
+      sign_comparison = @decimal_sign <=> other.instance_variable_get(:@decimal_sign)
+      return sign_comparison unless sign_comparison.zero?
+      return 0 if @decimal_sign.zero?
+
+      other_digits = other.instance_variable_get(:@decimal_digits)
+      other_exponent = other.instance_variable_get(:@decimal_exponent)
+      magnitude_comparison = (@decimal_digits.length + @decimal_exponent) <=> (other_digits.length + other_exponent)
+      return magnitude_comparison * @decimal_sign unless magnitude_comparison.zero?
+
+      coefficient_comparison = compare_coefficients(@decimal_digits, other_digits)
+      coefficient_comparison * @decimal_sign
+    end
+
+    private
+
+    def numeric_value(value)
+      return value.to_f if value.is_a?(Number)
+      return value if value.is_a?(Numeric)
+
+      raise TypeError, "#{value.class} can't be coerced into #{self.class}"
+    end
+
+    def parse_decimal_components
+      sign, integer, fraction, exponent = literal.match(
+        /\A(-?)(\d+)(?:\.(\d+))?(?:[eE]([+-]?\d+))?\z/
+      ).captures
+      fraction ||= ''
+      digits = (integer + fraction).sub(/\A0+/, '')
+      if digits.empty?
+        @decimal_sign = 0
+        @decimal_digits = '0'.freeze
+        @decimal_exponent = 0
+        return
+      end
+
+      trailing_zeros = digits[/0+\z/]&.length.to_i
+      @decimal_sign = sign == '-' ? -1 : 1
+      @decimal_digits = digits[0, digits.length - trailing_zeros].freeze
+      @decimal_exponent = (exponent ? Integer(exponent, 10) : 0) - fraction.length + trailing_zeros
+    end
+
+    def compare_coefficients(left, right)
+      length = [left.length, right.length].max
+      length.times do |index|
+        comparison = (left.getbyte(index) || 48) <=> (right.getbyte(index) || 48)
+        return comparison unless comparison.zero?
+      end
+      0
+    end
+
+    def render_exponent_literal
+      sign, integer, fraction, exponent = literal.match(
+        /\A(-?)(\d+)(?:\.(\d+))?[eE]([+-]?\d+)\z/
+      ).captures
+      fraction ||= ''
+      exponent = Integer(exponent, 10)
+      digits = integer + fraction
+      first_significant = digits.index(/[1-9]/)
+      return render_zero(sign, fraction.length, exponent) unless first_significant
+
+      decimal_position = integer.length + exponent
+      scientific_exponent = decimal_position - first_significant - 1
+      significant = digits[first_significant..]
+      if scientific_exponent.positive? || scientific_exponent < -6
+        coefficient = significant.length == 1 ? significant : "#{significant[0]}.#{significant[1..]}"
+        return "#{sign}#{coefficient}E#{format_exponent(scientific_exponent)}"
+      end
+
+      "#{sign}#{render_decimal(digits, decimal_position)}"
+    end
+
+    def render_zero(sign, fraction_length, exponent)
+      scientific_exponent = exponent - fraction_length
+      return "#{sign}0E#{format_exponent(scientific_exponent)}" if scientific_exponent.positive? || scientific_exponent < -6
+
+      sign + render_decimal('0' * (fraction_length + 1), 1 + exponent)
+    end
+
+    def render_decimal(digits, decimal_position)
+      if decimal_position <= 0
+        "0.#{'0' * -decimal_position}#{digits}"
+      elsif decimal_position >= digits.length
+        digits + ('0' * (decimal_position - digits.length))
+      else
+        "#{digits[0...decimal_position]}.#{digits[decimal_position..]}"
+      end.sub(/\A0+(?=\d)/, '')
+    end
+
+    def format_exponent(exponent)
+      exponent.positive? ? "+#{exponent}" : exponent.to_s
+    end
+  end
+end

data/lib/rjq/opcodes.rb

@@ -0,0 +1,130 @@
+# frozen_string_literal: true
+
+module Rjq
+  module Opcodes
+    ALL = %i[
+      load_input load_const string_interp format variable field index_const index_filter slice_const slice_filter
+      each path optional pipe append binding array object branch try reduce foreach label break unary binary assign
+      call tail_call recurse scoped_def
+    ].freeze
+
+    MNEMONICS = ALL.to_h { |opcode| [opcode, opcode.to_s] }.freeze
+  end
+
+  Instruction = Struct.new(:op, :arg1, :arg2, :loc, keyword_init: true) do
+    def to_s
+      text = [Opcodes::MNEMONICS.fetch(op), format_arg(arg1), format_arg(arg2)].compact.join(' ')
+      loc ? "#{text} @ #{loc.filename}:#{loc.line}:#{loc.column}" : text
+    end
+
+    private
+
+    def format_arg(value)
+      return nil if value.nil?
+
+      case value
+      when BytecodeBlock
+        "<block:#{value.instructions.length}>"
+      when BytecodeFunctionDefinition
+        "<def:#{value.name}/#{value.params.length}>"
+      when Array
+        "[#{value.map { |item| format_arg(item) }.join(',')}]"
+      when Hash
+        "{#{value.map { |key, item| "#{key}:#{format_arg(item)}" }.join(',')}}"
+      else
+        value.inspect
+      end
+    end
+  end
+
+  BytecodeBlock = Struct.new(:instructions, keyword_init: true)
+
+  TailCall = Struct.new(:input, :context, :definition, :arg_blocks, keyword_init: true)
+
+  BytecodeFunctionDefinition = Struct.new(:name, :params, :body, :closure, keyword_init: true) do
+    def with_closure(functions)
+      self.class.new(name: name, params: params, body: body, closure: functions)
+    end
+  end
+
+  class Program
+    attr_reader :instructions, :constants, :definitions, :module_metadata, :module_variables
+
+    def initialize(instructions:, constants: [], definitions: [], module_metadata: {}, module_variables: {})
+      @instructions = instructions
+      @constants = constants
+      @definitions = definitions
+      @module_metadata = module_metadata
+      @module_variables = module_variables
+    end
+
+    def disasm
+      lines = []
+      append_disasm(lines, instructions, 'main', 0)
+      definitions.each do |definition|
+        append_disasm(lines, definition.body.instructions,
+                      "definition:#{definition.name}/#{definition.params.length}", 0)
+      end
+      lines.join("\n")
+    end
+
+    def finalize!
+      freeze_value(instructions)
+      freeze_value(constants)
+      freeze_value(definitions)
+      freeze_value(module_metadata)
+      freeze_value(module_variables)
+      freeze
+    end
+
+    private
+
+    def append_disasm(lines, block, name, indent)
+      pad = ' ' * indent
+      lines << "#{pad}== #{name} =="
+      block.each_with_index do |instruction, index|
+        lines << format("#{pad}%04d %s", index, instruction)
+        append_nested(lines, instruction, indent + 2)
+      end
+    end
+
+    def append_nested(lines, instruction, indent)
+      append_nested_value(lines, instruction.arg1, indent, 'arg1')
+      append_nested_value(lines, instruction.arg2, indent, 'arg2')
+    end
+
+    def append_nested_value(lines, value, indent, name)
+      case value
+      when BytecodeBlock
+        append_disasm(lines, value.instructions, name, indent)
+      when BytecodeFunctionDefinition
+        append_disasm(lines, value.body.instructions, "#{name}:#{value.name}/#{value.params.length}", indent)
+      when Array
+        value.each_with_index { |item, index| append_nested_value(lines, item, indent, "#{name}[#{index}]") }
+      when Hash
+        value.each { |key, item| append_nested_value(lines, item, indent, "#{name}.#{key}") }
+      end
+    end
+
+    def freeze_value(root)
+      stack = [root]
+      seen = {}
+      until stack.empty?
+        value = stack.pop
+        next if value.nil? || seen[value.object_id]
+
+        seen[value.object_id] = true
+        case value
+        when Array
+          stack.concat(value)
+        when Hash
+          stack.concat(value.keys)
+          stack.concat(value.values)
+        when Struct
+          stack.concat(value.to_a)
+        end
+        value.freeze
+      end
+    end
+  end
+end