Class: TreeHaver::Backends::Citrus::Language

Inherits:
Object
  • Object
show all
Includes:
Comparable
Defined in:
lib/tree_haver/backends/citrus.rb

Overview

Citrus grammar wrapper

Unlike tree-sitter which loads compiled .so files, Citrus uses Ruby modules that define grammars. This class wraps a Citrus grammar module.

Examples:

# For TOML, use toml-rb's grammar
language = TreeHaver::Backends::Citrus::Language.new(TomlRB::Document)

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(grammar_module) ⇒ Language

Returns a new instance of Language.

Parameters:

  • grammar_module (Module) —

    A Citrus grammar module with a parse method



100
101
102
103
104
105
106
107
108
 
# File 'lib/tree_haver/backends/citrus.rb', line 100

def initialize(grammar_module)
  unless grammar_module.respond_to?(:parse)
    raise TreeHaver::NotAvailable,
      "Grammar module must respond to :parse. " \
        "Expected a Citrus grammar module (e.g., TomlRB::Document)."
  end
  @grammar_module = grammar_module
  @backend = :citrus
end

Instance Attribute Details

#backend ⇒ Symbol (readonly)

The backend this language is for

Returns:

  • (Symbol) 


97
98
99
 
# File 'lib/tree_haver/backends/citrus.rb', line 97

def backend
  @backend
end

#grammar_module ⇒ Module (readonly)

The Citrus grammar module

Returns:

  • (Module) —

    Citrus grammar module (e.g., TomlRB::Document)



93
94
95
 
# File 'lib/tree_haver/backends/citrus.rb', line 93

def grammar_module
  @grammar_module
end

Class Method Details

.from_library(path = nil, symbol: nil, name: nil) ⇒ Object Also known as: from_path 



151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
 
# File 'lib/tree_haver/backends/citrus.rb', line 151

def from_library(path = nil, symbol: nil, name: nil)
  # Derive language name from path, symbol, or explicit name
  lang_name = name&.to_sym ||
    symbol&.to_s&.sub(/^tree_sitter_/, "")&.to_sym ||
    path && TreeHaver::LibraryPathUtils.derive_language_name_from_path(path)&.to_sym

  unless lang_name
    raise TreeHaver::NotAvailable,
      "Citrus backend requires a language name. " \
        "Provide name: parameter or register a grammar with TreeHaver.register_language."
  end

  # Look up registered Citrus grammar
  registration = TreeHaver::LanguageRegistry.registered(lang_name, :citrus)

  unless registration
    raise TreeHaver::NotAvailable,
      "No Citrus grammar registered for #{lang_name.inspect}. " \
        "Register one with: TreeHaver.register_language(:#{lang_name}, grammar_module: YourGrammar)"
  end

  grammar_module = registration[:grammar_module]
  new(grammar_module)
end

Instance Method Details

#<=>(other) ⇒ Integer?

Compare languages for equality

Citrus languages are equal if they have the same backend and grammar_module. Grammar module uniquely identifies a Citrus language.

Parameters:

  • other (Object) —

    object to compare with

Returns:

  • (Integer, nil) —

    -1, 0, 1, or nil if not comparable



117
118
119
120
121
122
123
 
# File 'lib/tree_haver/backends/citrus.rb', line 117

def <=>(other)
  return unless other.is_a?(Language)
  return unless other.backend == @backend

  # Compare by grammar_module name (modules are compared by object_id by default)
  @grammar_module.name <=> other.grammar_module.name
end

#hash ⇒ Integer

Hash value for this language (for use in Sets/Hashes)

Returns:

  • (Integer) 


127
128
129
 
# File 'lib/tree_haver/backends/citrus.rb', line 127

def hash
  [@backend, @grammar_module.name].hash
end