class SlimLint::Atom

Represents an atomic, childless, literal value within an S-expression.

This creates a light wrapper around literal values of S-expressions so we can make an {Atom} quack like a {Sexp} without being an {Sexp}.

Attributes

line[RW]

Stores the line number of the code in the original document that this Atom came from.

Public Class Methods

new(value) click to toggle source

Creates an atom from the specified value.

@param value [Object]

# File lib/slim_lint/atom.rb, line 16
def initialize(value)
  @value = value
end

Public Instance Methods

==(other) click to toggle source

Returns whether this atom is equivalent to another object.

This defines a helper which unwraps the inner value of the atom to compare against a literal value, saving us having to do it ourselves everywhere else.

@param other [Object] @return [Boolean]

# File lib/slim_lint/atom.rb, line 28
def ==(other)
  @value == (other.is_a?(Atom) ? other.instance_variable_get(:@value) : other)
end
inspect() click to toggle source

Displays a string representation of this {Atom} suitable for debugging.

@return [String]

# File lib/slim_lint/atom.rb, line 58
def inspect
  "<#Atom #{@value.inspect}>"
end
match?(pattern) click to toggle source

Returns whether this atom matches the given Sexp pattern.

This exists solely to make an {Atom} quack like a {Sexp}, so we don't have to manually check the type when doing comparisons elsewhere.

@param [Array, Object] @return [Boolean]

# File lib/slim_lint/atom.rb, line 39
def match?(pattern)
  # Delegate matching logic if we're comparing against a matcher
  if pattern.is_a?(SlimLint::Matcher::Base)
    return pattern.match?(@value)
  end

  @value == pattern
end
method_missing(method_sym, *args, &block) click to toggle source

Redirect methods to the value this {Atom} wraps.

Again, this is for convenience so we don't need to manually unwrap the value ourselves. It's pretty magical, but results in much DRYer code.

@param method_sym [Symbol] method that was called @param args [Array] @yield block that was passed to the method

Calls superclass method
# File lib/slim_lint/atom.rb, line 70
def method_missing(method_sym, *args, &block)
  if @value.respond_to?(method_sym)
    @value.send(method_sym, *args, &block)
  else
    super
  end
end
respond_to?(method_sym, include_private = false) click to toggle source

Return whether this {Atom} or the value it wraps responds to the given message.

@param method_sym [Symbol] @param include_private [Boolean] @return [Boolean]

Calls superclass method
# File lib/slim_lint/atom.rb, line 90
def respond_to?(method_sym, include_private = false)
  if super
    true
  else
    @value.respond_to?(method_sym, include_private)
  end
end
respond_to_missing?(method_name, *args) click to toggle source

@param method_name [String,Symbol] method name @param args [Array]

Calls superclass method
# File lib/slim_lint/atom.rb, line 80
def respond_to_missing?(method_name, *args)
  @value.__send__(:respond_to_missing?, method_name, *args) || super
end
to_s() click to toggle source

Displays the string representation the value this {Atom} wraps.

@return [String]

# File lib/slim_lint/atom.rb, line 51
def to_s
  @value.to_s
end