Class: Sass::Tree::Visitors::Perform

Inherits:
Base
  • Object
show all
Defined in:
lib/sass/tree/visitors/perform.rb

Overview

A visitor for converting a dynamic Sass tree into a static Sass tree.

Constant Summary

Constants inherited from Base

Base::NODE_NAME_RE

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Base

#node_name

Constructor Details

#initialize(env) ⇒ Perform (protected)

Returns a new instance of Perform.



12
13
14
 
# File 'lib/sass/tree/visitors/perform.rb', line 12

def initialize(env)
  @environment = env
end

Class Method Details

.visit(root, environment = Sass::Environment.new) ⇒ Tree::Node

Returns The resulting tree of static nodes.

Parameters:

  • root (Tree::Node) —

    The root node of the tree to visit.

  • environment (Sass::Environment) (defaults to: Sass::Environment.new) —

    The lexical environment.

Returns:

  • (Tree::Node) —

    The resulting tree of static nodes.



6
7
8
 
# File 'lib/sass/tree/visitors/perform.rb', line 6

def self.visit(root, environment = Sass::Environment.new)
  new(environment).send(:visit, root)
end

Instance Method Details

#visit(node) (protected)

If an exception is raised, this add proper metadata to the backtrace.



17
18
19
20
21
22
 
# File 'lib/sass/tree/visitors/perform.rb', line 17

def visit(node)
  super(node.dup)
rescue Sass::SyntaxError => e
  e.modify_backtrace(:filename => node.filename, :line => node.line)
  raise e
end

#visit_children(parent) (protected)

Keeps track of the current environment.



25
26
27
28
29
30
 
# File 'lib/sass/tree/visitors/perform.rb', line 25

def visit_children(parent)
  with_environment Sass::Environment.new(@environment) do
    parent.children = super.flatten
    parent
  end
end

#visit_comment(node) (protected)

Removes this node from the tree if it's a silent comment.



54
55
56
57
58
59
60
61
 
# File 'lib/sass/tree/visitors/perform.rb', line 54

def visit_comment(node)
  return [] if node.invisible?
  check_for_loud_silent_comment node
  check_for_comment_interp node
  node.resolved_value = run_interp_no_strip(node.value)
  node.resolved_value.gsub!(/\\([\\#])/, '\1')
  node
end

#visit_debug(node) (protected)

Prints the expression to STDERR.



64
65
66
67
68
69
70
71
72
73
 
# File 'lib/sass/tree/visitors/perform.rb', line 64

def visit_debug(node)
  res = node.expr.perform(@environment)
  res = res.value if res.is_a?(Sass::Script::String)
  if node.filename
    $stderr.puts "#{node.filename}:#{node.line} DEBUG: #{res}"
  else
    $stderr.puts "Line #{node.line} DEBUG: #{res}"
  end
  []
end

#visit_directive(node) (protected) 



271
272
273
274
275
276
277
 
# File 'lib/sass/tree/visitors/perform.rb', line 271

def visit_directive(node)
  if node.value['#{']
    node.value = run_interp(Sass::Engine.parse_interp(node.value, node.line, 0, node.options))
  end
  yield
  node
end

#visit_each(node) (protected)

Runs the child nodes once for each value in the list.



76
77
78
79
80
81
82
83
84
85
 
# File 'lib/sass/tree/visitors/perform.rb', line 76

def visit_each(node)
  list = node.list.perform(@environment)

  with_environment Sass::Environment.new(@environment) do
    list.to_a.map do |v|
      @environment.set_local_var(node.var, v)
      node.children.map {|c| visit(c)}
    end.flatten
  end
end

#visit_extend(node) (protected)

Runs SassScript interpolation in the selector, and then parses the result into a Selector::CommaSequence.



89
90
91
92
93
 
# File 'lib/sass/tree/visitors/perform.rb', line 89

def visit_extend(node)
  parser = Sass::SCSS::CssParser.new(run_interp(node.selector), node.filename, node.line)
  node.resolved_selector = parser.parse_selector
  node
end

#visit_for(node) (protected)

Runs the child nodes once for each time through the loop, varying the variable each time.



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/sass/tree/visitors/perform.rb', line 96

def visit_for(node)
  from = node.from.perform(@environment)
  to = node.to.perform(@environment)
  from.assert_int!
  to.assert_int!

  to = to.coerce(from.numerator_units, from.denominator_units)
  range = Range.new(from.to_i, to.to_i, node.exclusive)

  with_environment Sass::Environment.new(@environment) do
    range.map do |i|
      @environment.set_local_var(node.var,
        Sass::Script::Number.new(i, from.numerator_units, from.denominator_units))
      node.children.map {|c| visit(c)}
    end.flatten
  end
end

#visit_function(node) (protected)

Loads the function into the environment.



115
116
117
118
119
 
# File 'lib/sass/tree/visitors/perform.rb', line 115

def visit_function(node)
  @environment.set_function(node.name,
    Sass::Callable.new(node.name, node.args, @environment, node.children))
  []
end

#visit_if(node) (protected)

Runs the child nodes if the conditional expression is true; otherwise, tries the else nodes.



123
124
125
126
127
128
129
130
131
132
 
# File 'lib/sass/tree/visitors/perform.rb', line 123

def visit_if(node)
  if node.expr.nil? || node.expr.perform(@environment).to_bool
    yield
    node.children
  elsif node.else
    visit(node.else)
  else
    []
  end
end

#visit_import(node) (protected)

Returns a static DirectiveNode if this is importing a CSS file, or parses and includes the imported Sass file.



136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
# File 'lib/sass/tree/visitors/perform.rb', line 136

def visit_import(node)
  if path = node.css_import?
    return Sass::Tree::DirectiveNode.new("@import url(#{path})")
  end
  file = node.imported_file
  handle_import_loop!(node) if @environment.files_in_use.include?(file.options[:filename])

  @environment.push_frame(:filename => node.filename, :line => node.line)
  root = file.to_tree
  Sass::Tree::Visitors::CheckNesting.visit(root)
  node.children = root.children.map {|c| visit(c)}.flatten
  node
rescue Sass::SyntaxError => e
  e.modify_backtrace(:filename => node.imported_file.options[:filename])
  e.add_backtrace(:filename => node.filename, :line => node.line)
  raise e
ensure
  @environment.pop_frame
end

#visit_mixin(node) (protected)

Runs a mixin.



164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
 
# File 'lib/sass/tree/visitors/perform.rb', line 164

def visit_mixin(node)
  handle_include_loop!(node) if @environment.mixins_in_use.include?(node.name)

  original_env = @environment
  original_env.push_frame(:filename => node.filename, :line => node.line)
  original_env.prepare_frame(:mixin => node.name)
  raise Sass::SyntaxError.new("Undefined mixin '#{node.name}'.") unless mixin = @environment.mixin(node.name)

  passed_args = node.args.dup
  passed_keywords = node.keywords.dup

  raise Sass::SyntaxError.new(<<END.gsub("\n", "")) if mixin.args.size < passed_args.size
Mixin #{node.name} takes #{mixin.args.size} argument#{'s' if mixin.args.size != 1}
 but #{node.args.size} #{node.args.size == 1 ? 'was' : 'were'} passed.
END

  passed_keywords.each do |name, value|
    # TODO: Make this fast
    unless mixin.args.find {|(var, default)| var.underscored_name == name}
      raise Sass::SyntaxError.new("Mixin #{node.name} doesn't have an argument named $#{name}")
    end
  end

  environment = mixin.args.zip(passed_args).
    inject(Sass::Environment.new(mixin.environment)) do |env, ((var, default), value)|
    env.set_local_var(var.name,
      if value
        value.perform(@environment)
      elsif kv = passed_keywords[var.underscored_name]
        kv.perform(@environment)
      elsif default
        default.perform(env)
      end)
    raise Sass::SyntaxError.new("Mixin #{node.name} is missing parameter #{var.inspect}.") unless env.var(var.name)
    env
  end

  with_environment(environment) {node.children = mixin.tree.map {|c| visit(c)}.flatten}
  node
rescue Sass::SyntaxError => e
  if original_env # Don't add backtrace info if this is an @include loop
    e.modify_backtrace(:mixin => node.name, :line => node.line)
    e.add_backtrace(:line => node.line)
  end
  raise e
ensure
  original_env.pop_frame if original_env
end

#visit_mixindef(node) (protected)

Loads a mixin into the environment.



157
158
159
160
161
 
# File 'lib/sass/tree/visitors/perform.rb', line 157

def visit_mixindef(node)
  @environment.set_mixin(node.name,
    Sass::Callable.new(node.name, node.args, @environment, node.children))
  []
end

#visit_prop(node) (protected)

Runs any SassScript that may be embedded in a property.



214
215
216
217
218
219
 
# File 'lib/sass/tree/visitors/perform.rb', line 214

def visit_prop(node)
  node.resolved_name = run_interp(node.name)
  val = node.value.perform(@environment)
  node.resolved_value = val.to_s
  yield
end

#visit_return(node) (protected)

Returns the value of the expression.



222
223
224
 
# File 'lib/sass/tree/visitors/perform.rb', line 222

def visit_return(node)
  throw :_sass_return, node.expr.perform(@environment)
end

#visit_root(node) (protected)

Sets the options on the environment if this is the top-level root.



45
46
47
48
49
50
51
 
# File 'lib/sass/tree/visitors/perform.rb', line 45

def visit_root(node)
  @environment.options = node.options if @environment.options.nil? || @environment.options.empty?
  yield
rescue Sass::SyntaxError => e
  e.sass_template ||= node.template
  raise e
end

#visit_rule(node) (protected)

Runs SassScript interpolation in the selector, and then parses the result into a Selector::CommaSequence.



228
229
230
231
232
233
234
235
236
237
 
# File 'lib/sass/tree/visitors/perform.rb', line 228

def visit_rule(node)
  parser = Sass::SCSS::StaticParser.new(run_interp(node.rule), node.filename, node.line)
  node.parsed_rules ||= parser.parse_selector
  if node.options[:trace_selectors]
    @environment.push_frame(:filename => node.filename, :line => node.line)
    node.stack_trace = @environment.stack_trace
    @environment.pop_frame
  end
  yield
end

#visit_variable(node) (protected)

Loads the new variable value into the environment.



240
241
242
243
244
245
 
# File 'lib/sass/tree/visitors/perform.rb', line 240

def visit_variable(node)
  return [] if node.guarded && [email protected](node.name).nil?
  val = node.expr.perform(@environment)
  @environment.set_var(node.name, val)
  []
end

#visit_warn(node) (protected)

Prints the expression to STDERR with a stylesheet trace.



248
249
250
251
252
253
254
255
256
257
258
259
260
 
# File 'lib/sass/tree/visitors/perform.rb', line 248

def visit_warn(node)
  @environment.push_frame(:filename => node.filename, :line => node.line)
  res = node.expr.perform(@environment)
  res = res.value if res.is_a?(Sass::Script::String)
  msg = "WARNING: #{res}\n         "
  msg << @environment.stack_trace.join("\n         ")
  # JRuby doesn't automatically add a newline for #warn
  msg << (RUBY_PLATFORM =~ /java/ ? "\n\n" : "\n")
  Sass::Util.sass_warn msg
  []
ensure
  @environment.pop_frame
end

#visit_while(node) (protected)

Runs the child nodes until the continuation expression becomes false.



263
264
265
266
267
268
269
 
# File 'lib/sass/tree/visitors/perform.rb', line 263

def visit_while(node)
  children = []
  with_environment Sass::Environment.new(@environment) do
    children += node.children.map {|c| visit(c)} while node.expr.perform(@environment).to_bool
  end
  children.flatten
end

#with_environment(env) { ... } ⇒ Object (protected)

Runs a block of code with the current environment replaced with the given one.

Parameters:

Yields:

  • A block in which the environment is set to env.

Returns:

  • (Object) —

    The return value of the block.



37
38
39
40
41
42
 
# File 'lib/sass/tree/visitors/perform.rb', line 37

def with_environment(env)
  old_env, @environment = @environment, env
  yield
ensure
  @environment = old_env
end