Class: SlimLint::Atom

Inherits:
Object
  • Object
show all
Defined in:
lib/slim_lint/atom.rb

Overview

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.

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(value) ⇒ Atom

Creates an atom from the specified value.

Parameters:

  • value (Object) 


16
17
18
 
# File 'lib/slim_lint/atom.rb', line 16

def initialize(value)
  @value = value
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method_sym, *args) { ... } ⇒ Object

Redirect methods to the value this SlimLint::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.

Parameters:

  • method_sym (Symbol) —

    method that was called

  • args (Array)

Yields:

  • block that was passed to the method



70
71
72
73
74
75
76
 
# 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

Instance Attribute Details

#line ⇒ Object

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



11
12
13
 
# File 'lib/slim_lint/atom.rb', line 11

def line
  @line
end

Instance Method Details

#==(other) ⇒ Boolean

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.

Parameters:

  • other (Object)

Returns:

  • (Boolean) 


28
29
30
 
# File 'lib/slim_lint/atom.rb', line 28

def ==(other)
  @value == (other.is_a?(Atom) ? other.instance_variable_get(:@value) : other)
end

#inspect ⇒ String

Displays a string representation of this SlimLint::Atom suitable for debugging.

Returns:

  • (String) 


58
59
60
 
# File 'lib/slim_lint/atom.rb', line 58

def inspect
  "<#Atom #{@value.inspect}>"
end

#match?(pattern) ⇒ Boolean

Returns whether this atom matches the given Sexp pattern.

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

Parameters:

  • (Array, Object)

Returns:

  • (Boolean) 


39
40
41
42
43
44
45
46
 
# 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

#respond_to?(method_sym, include_private = false) ⇒ Boolean

Return whether this SlimLint::Atom or the value it wraps responds to the given message.

Parameters:

  • method_sym (Symbol)
  • include_private (Boolean) (defaults to: false)

Returns:

  • (Boolean) 


90
91
92
93
94
95
96
 
# 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) ⇒ Boolean

Parameters:

  • method_name (String, Symbol) —

    method name

  • args (Array)

Returns:

  • (Boolean) 


80
81
82
 
# 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 ⇒ String

Displays the string representation the value this SlimLint::Atom wraps.

Returns:

  • (String) 


51
52
53
 
# File 'lib/slim_lint/atom.rb', line 51

def to_s
  @value.to_s
end