Class: Sass::Script::Tree::Funcall

Inherits:
Node
  • Object
show all
Defined in:
lib/sass/script/tree/funcall.rb

Overview

A SassScript parse node representing a function call.

A function call either calls one of the functions in Functions, or if no function with the given name exists it returns a string representation of the function call.

Instance Attribute Summary collapse

Attributes inherited from Node

#filename, #line, #options, #source_range

Instance Method Summary collapse

Methods inherited from Node

#dasherize, #force_division!, #opts, #perform

Constructor Details

#initialize(name_or_callable, args, keywords, splat, kwarg_splat) ⇒ Funcall

Returns a new instance of Funcall.

Parameters:



52
53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/sass/script/tree/funcall.rb', line 52

def initialize(name_or_callable, args, keywords, splat, kwarg_splat)
  if name_or_callable.is_a?(Sass::Callable)
    @callable = name_or_callable
    @name = name_or_callable.name
  else
    @callable = nil
    @name = name_or_callable
  end
  @args = args
  @keywords = keywords
  @splat = splat
  @kwarg_splat = kwarg_splat
  super()
end

Instance Attribute Details

#args ⇒ Array<Node> (readonly)

The arguments to the function.

Returns:



24
25
26
 
# File 'lib/sass/script/tree/funcall.rb', line 24

def args
  @args
end

#callable ⇒ Sass::Callable (readonly)

The callable to be invoked

Returns:



19
20
21
 
# File 'lib/sass/script/tree/funcall.rb', line 19

def callable
  @callable
end

#keywords ⇒ Sass::Util::NormalizedMap<Node> (readonly)

The keyword arguments to the function.

Returns:



29
30
31
 
# File 'lib/sass/script/tree/funcall.rb', line 29

def keywords
  @keywords
end

#kwarg_splat ⇒ Node?

The second splat argument for this function, if one exists.

If this exists, it's always a map of keyword arguments, and #splat is always either a list or an arglist.

Returns:



45
46
47
 
# File 'lib/sass/script/tree/funcall.rb', line 45

def kwarg_splat
  @kwarg_splat
end

#name ⇒ String (readonly)

The name of the function.

Returns:

  • (String) 


14
15
16
 
# File 'lib/sass/script/tree/funcall.rb', line 14

def name
  @name
end

#splat ⇒ Node?

The first splat argument for this function, if one exists.

This could be a list of positional arguments, a map of keyword arguments, or an arglist containing both.

Returns:



37
38
39
 
# File 'lib/sass/script/tree/funcall.rb', line 37

def splat
  @splat
end

Instance Method Details

#_perform(environment) ⇒ Sass::Script::Value (protected)

Evaluates the function call.

Parameters:

  • environment (Sass::Environment) —

    The environment in which to evaluate the SassScript

Returns:

Raises:



127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
 
# File 'lib/sass/script/tree/funcall.rb', line 127

def _perform(environment)
  args = @args.each_with_index.
    map {|a, i| perform_arg(a, environment, signature && signature.args[i])}
  keywords = Sass::Util.map_hash(@keywords) do |k, v|
    [k, perform_arg(v, environment, k.tr('-', '_'))]
  end
  splat = Sass::Tree::Visitors::Perform.perform_splat(
    @splat, keywords, @kwarg_splat, environment)

  fn = @callable || environment.function(@name)

  if fn && fn.origin == :stylesheet
    environment.stack.with_function(filename, line, name) do
      return without_original(perform_sass_fn(fn, args, splat, environment))
    end
  end

  args = construct_ruby_args(ruby_name, args, splat, environment)

  if Sass::Script::Functions.callable?(ruby_name) && (!fn || fn.origin == :builtin)
    local_environment = Sass::Environment.new(environment.global_env, environment.options)
    local_environment.caller = Sass::ReadOnlyEnvironment.new(environment, environment.options)
    result = local_environment.stack.with_function(filename, line, name) do
      opts(Sass::Script::Functions::EvaluationContext.new(
        local_environment).send(ruby_name, *args))
    end
    without_original(result)
  else
    opts(to_literal(args))
  end
rescue ArgumentError => e
  reformat_argument_error(e)
end

#children ⇒ Array<Node>

Returns the arguments to the function.

Returns:

See Also:



103
104
105
106
107
108
 
# File 'lib/sass/script/tree/funcall.rb', line 103

def children
  res = @args + @keywords.values
  res << @splat if @splat
  res << @kwarg_splat if @kwarg_splat
  res
end

#deep_copy

See Also:



111
112
113
114
115
116
117
118
 
# File 'lib/sass/script/tree/funcall.rb', line 111

def deep_copy
  node = dup
  node.instance_variable_set('@args', args.map {|a| a.deep_copy})
  copied_keywords = Sass::Util::NormalizedMap.new
  @keywords.as_stored.each {|k, v| copied_keywords[k] = v.deep_copy}
  node.instance_variable_set('@keywords', copied_keywords)
  node
end

#inspect ⇒ String

Returns A string representation of the function call.

Returns:

  • (String) —

    A string representation of the function call



68
69
70
71
72
73
74
75
76
77
 
# File 'lib/sass/script/tree/funcall.rb', line 68

def inspect
  args = @args.map {|a| a.inspect}.join(', ')
  keywords = @keywords.as_stored.to_a.map {|k, v| "$#{k}: #{v.inspect}"}.join(', ')
  if self.splat
    splat = args.empty? && keywords.empty? ? "" : ", "
    splat = "#{splat}#{self.splat.inspect}..."
    splat = "#{splat}, #{kwarg_splat.inspect}..." if kwarg_splat
  end
  "#{name}(#{args}#{', ' unless args.empty? || keywords.empty?}#{keywords}#{splat})"
end

#to_literal(args) (protected)

Compass historically overrode this before it changed name to #to_value. We should get rid of it in the future.



163
164
165
 
# File 'lib/sass/script/tree/funcall.rb', line 163

def to_literal(args)
  to_value(args)
end

#to_sass(opts = {})

See Also:



80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
# File 'lib/sass/script/tree/funcall.rb', line 80

def to_sass(opts = {})
  arg_to_sass = lambda do |arg|
    sass = arg.to_sass(opts)
    sass = "(#{sass})" if arg.is_a?(Sass::Script::Tree::ListLiteral) && arg.separator == :comma
    sass
  end

  args = @args.map(&arg_to_sass)
  keywords = @keywords.as_stored.to_a.map {|k, v| "$#{dasherize(k, opts)}: #{arg_to_sass[v]}"}

  if self.splat
    splat = "#{arg_to_sass[self.splat]}..."
    kwarg_splat = "#{arg_to_sass[self.kwarg_splat]}..." if self.kwarg_splat
  end

  arglist = [args, splat, keywords, kwarg_splat].flatten.compact.join(', ')
  "#{dasherize(name, opts)}(#{arglist})"
end

#to_value(args) (protected)

This method is factored out from _perform so that compass can override it with a cross-browser implementation for functions that require vendor prefixes in the generated css.



170
171
172
 
# File 'lib/sass/script/tree/funcall.rb', line 170

def to_value(args)
  Sass::Script::Value::String.new("#{name}(#{args.join(', ')})")
end