PageRenderTime 72ms CodeModel.GetById 24ms app.highlight 44ms RepoModel.GetById 1ms app.codeStats 0ms

/scalate-jruby/src/main/resources/haml-3.0.25/lib/sass/script/lexer.rb

http://github.com/scalate/scalate
Ruby | 337 lines | 240 code | 37 blank | 60 comment | 33 complexity | 134a3b05be0e749f9b41280bdc15ed9d MD5 | raw file
  1require 'sass/scss/rx'
  2
  3require 'strscan'
  4
  5module Sass
  6  module Script
  7    # The lexical analyzer for SassScript.
  8    # It takes a raw string and converts it to individual tokens
  9    # that are easier to parse.
 10    class Lexer
 11      include Sass::SCSS::RX
 12
 13      # A struct containing information about an individual token.
 14      #
 15      # `type`: \[`Symbol`\]
 16      # : The type of token.
 17      #
 18      # `value`: \[`Object`\]
 19      # : The Ruby object corresponding to the value of the token.
 20      #
 21      # `line`: \[`Fixnum`\]
 22      # : The line of the source file on which the token appears.
 23      #
 24      # `offset`: \[`Fixnum`\]
 25      # : The number of bytes into the line the SassScript token appeared.
 26      #
 27      # `pos`: \[`Fixnum`\]
 28      # : The scanner position at which the SassScript token appeared.
 29      Token = Struct.new(:type, :value, :line, :offset, :pos)
 30
 31      # The line number of the lexer's current position.
 32      #
 33      # @return [Fixnum]
 34      attr_reader :line
 35
 36      # The number of bytes into the current line
 37      # of the lexer's current position.
 38      #
 39      # @return [Fixnum]
 40      attr_reader :offset
 41
 42      # A hash from operator strings to the corresponding token types.
 43      OPERATORS = {
 44        '+' => :plus,
 45        '-' => :minus,
 46        '*' => :times,
 47        '/' => :div,
 48        '%' => :mod,
 49        '=' => :single_eq,
 50        ':' => :colon,
 51        '(' => :lparen,
 52        ')' => :rparen,
 53        ',' => :comma,
 54        'and' => :and,
 55        'or' => :or,
 56        'not' => :not,
 57        '==' => :eq,
 58        '!=' => :neq,
 59        '>=' => :gte,
 60        '<=' => :lte,
 61        '>' => :gt,
 62        '<' => :lt,
 63        '#{' => :begin_interpolation,
 64        '}' => :end_interpolation,
 65        ';' => :semicolon,
 66        '{' => :lcurly,
 67      }
 68
 69      OPERATORS_REVERSE = Haml::Util.map_hash(OPERATORS) {|k, v| [v, k]}
 70
 71      TOKEN_NAMES = Haml::Util.map_hash(OPERATORS_REVERSE) {|k, v| [k, v.inspect]}.merge({
 72          :const => "variable (e.g. $foo)",
 73          :ident => "identifier (e.g. middle)",
 74          :bool => "boolean (e.g. true, false)",
 75        })
 76
 77      # A list of operator strings ordered with longer names first
 78      # so that `>` and `<` don't clobber `>=` and `<=`.
 79      OP_NAMES = OPERATORS.keys.sort_by {|o| -o.size}
 80
 81      # A sub-list of {OP_NAMES} that only includes operators
 82      # with identifier names.
 83      IDENT_OP_NAMES = OP_NAMES.select {|k, v| k =~ /^\w+/}
 84
 85      # A hash of regular expressions that are used for tokenizing.
 86      REGULAR_EXPRESSIONS = {
 87        :whitespace => /\s+/,
 88        :comment => COMMENT,
 89        :single_line_comment => SINGLE_LINE_COMMENT,
 90        :variable => /([!\$])(#{IDENT})/,
 91        :ident => /(#{IDENT})(\()?/,
 92        :number => /(-)?(?:(\d*\.\d+)|(\d+))([a-zA-Z%]+)?/,
 93        :color => HEXCOLOR,
 94        :bool => /(true|false)\b/,
 95        :ident_op => %r{(#{Regexp.union(*IDENT_OP_NAMES.map{|s| Regexp.new(Regexp.escape(s) + "(?!#{NMCHAR}|\Z)")})})},
 96        :op => %r{(#{Regexp.union(*OP_NAMES)})},
 97      }
 98
 99      class << self
100        private
101        def string_re(open, close)
102          /#{open}((?:\\.|\#(?!\{)|[^#{close}\\#])*)(#{close}|#\{)/
103        end
104      end
105
106      # A hash of regular expressions that are used for tokenizing strings.
107      #
108      # The key is a `[Symbol, Boolean]` pair.
109      # The symbol represents which style of quotation to use,
110      # while the boolean represents whether or not the string
111      # is following an interpolated segment.
112      STRING_REGULAR_EXPRESSIONS = {
113        [:double, false] => string_re('"', '"'),
114        [:single, false] => string_re("'", "'"),
115        [:double, true] => string_re('', '"'),
116        [:single, true] => string_re('', "'"),
117        [:uri, false] => /url\(#{W}(#{URLCHAR}*?)(#{W}\)|#\{)/,
118        [:uri, true] => /(#{URLCHAR}*?)(#{W}\)|#\{)/,
119      }
120
121      # @param str [String, StringScanner] The source text to lex
122      # @param line [Fixnum] The line on which the SassScript appears.
123      #   Used for error reporting
124      # @param offset [Fixnum] The number of characters in on which the SassScript appears.
125      #   Used for error reporting
126      # @param options [{Symbol => Object}] An options hash;
127      #   see {file:SASS_REFERENCE.md#sass_options the Sass options documentation}
128      def initialize(str, line, offset, options)
129        @scanner = str.is_a?(StringScanner) ? str : StringScanner.new(str)
130        @line = line
131        @offset = offset
132        @options = options
133        @interpolation_stack = []
134        @prev = nil
135      end
136
137      # Moves the lexer forward one token.
138      #
139      # @return [Token] The token that was moved past
140      def next
141        @tok ||= read_token
142        @tok, tok = nil, @tok
143        @prev = tok
144        return tok
145      end
146
147      # Returns whether or not there's whitespace before the next token.
148      #
149      # @return [Boolean]
150      def whitespace?(tok = @tok)
151        if tok
152          @scanner.string[0...tok.pos] =~ /\s\Z/
153        else
154          @scanner.string[@scanner.pos, 1] =~ /^\s/ ||
155            @scanner.string[@scanner.pos - 1, 1] =~ /\s\Z/
156        end
157      end
158
159      # Returns the next token without moving the lexer forward.
160      #
161      # @return [Token] The next token
162      def peek
163        @tok ||= read_token
164      end
165
166      # Rewinds the underlying StringScanner
167      # to before the token returned by \{#peek}.
168      def unpeek!
169        @scanner.pos = @tok.pos if @tok
170      end
171
172      # @return [Boolean] Whether or not there's more source text to lex.
173      def done?
174        whitespace unless after_interpolation? && @interpolation_stack.last
175        @scanner.eos? && @tok.nil?
176      end
177
178      # @return [Boolean] Whether or not the last token lexed was `:end_interpolation`.
179      def after_interpolation?
180        @prev && @prev.type == :end_interpolation
181      end
182
183      # Raise an error to the effect that `name` was expected in the input stream
184      # and wasn't found.
185      #
186      # This calls \{#unpeek!} to rewind the scanner to immediately after
187      # the last returned token.
188      #
189      # @param name [String] The name of the entity that was expected but not found
190      # @raise [Sass::SyntaxError]
191      def expected!(name)
192        unpeek!
193        Sass::SCSS::Parser.expected(@scanner, name, @line)
194      end
195
196      # Records all non-comment text the lexer consumes within the block
197      # and returns it as a string.
198      #
199      # @yield A block in which text is recorded
200      # @return [String]
201      def str
202        old_pos = @tok ? @tok.pos : @scanner.pos
203        yield
204        new_pos = @tok ? @tok.pos : @scanner.pos
205        @scanner.string[old_pos...new_pos]
206      end
207
208      private
209
210      def read_token
211        return if done?
212        return unless value = token
213        type, val, size = value
214        size ||= @scanner.matched_size
215
216        val.line = @line if val.is_a?(Script::Node)
217        Token.new(type, val, @line,
218          current_position - size, @scanner.pos - size)
219      end
220
221      def whitespace
222        nil while scan(REGULAR_EXPRESSIONS[:whitespace]) ||
223          scan(REGULAR_EXPRESSIONS[:comment]) ||
224          scan(REGULAR_EXPRESSIONS[:single_line_comment])
225      end
226
227      def token
228        if after_interpolation? && (interp_type = @interpolation_stack.pop)
229          return string(interp_type, true)
230        end
231
232        variable || string(:double, false) || string(:single, false) || number ||
233          color || bool || string(:uri, false) || raw(UNICODERANGE) ||
234          special_fun || ident_op || ident || op
235      end
236
237      def variable
238        _variable(REGULAR_EXPRESSIONS[:variable])
239      end
240
241      def _variable(rx)
242        line = @line
243        offset = @offset
244        return unless scan(rx)
245        if @scanner[1] == '!' && @scanner[2] != 'important'
246          Script.var_warning(@scanner[2], line, offset + 1, @options[:filename])
247        end
248
249        [:const, @scanner[2]]
250      end
251
252      def ident
253        return unless scan(REGULAR_EXPRESSIONS[:ident])
254        [@scanner[2] ? :funcall : :ident, @scanner[1]]
255      end
256
257      def string(re, open)
258        return unless scan(STRING_REGULAR_EXPRESSIONS[[re, open]])
259        if @scanner[2] == '#{' #'
260          @scanner.pos -= 2 # Don't actually consume the #{
261          @interpolation_stack << re
262        end
263        str =
264          if re == :uri
265            Script::String.new("#{'url(' unless open}#{@scanner[1]}#{')' unless @scanner[2] == '#{'}")
266          else
267            Script::String.new(@scanner[1].gsub(/\\(['"]|\#\{)/, '\1'), :string)
268          end
269        [:string, str]
270      end
271
272      def number
273        return unless scan(REGULAR_EXPRESSIONS[:number])
274        value = @scanner[2] ? @scanner[2].to_f : @scanner[3].to_i
275        value = -value if @scanner[1]
276        [:number, Script::Number.new(value, Array(@scanner[4]))]
277      end
278
279      def color
280        return unless s = scan(REGULAR_EXPRESSIONS[:color])
281        raise Sass::SyntaxError.new(<<MESSAGE.rstrip) unless s.size == 4 || s.size == 7
282Colors must have either three or six digits: '#{s}'
283MESSAGE
284        value = s.scan(/^#(..?)(..?)(..?)$/).first.
285          map {|num| num.ljust(2, num).to_i(16)}
286        [:color, Script::Color.new(value)]
287      end
288
289      def bool
290        return unless s = scan(REGULAR_EXPRESSIONS[:bool])
291        [:bool, Script::Bool.new(s == 'true')]
292      end
293
294      def special_fun
295        return unless str1 = scan(/((-[\w-]+-)?calc|expression|progid:[a-z\.]*)\(/i)
296        str2, _ = Haml::Shared.balance(@scanner, ?(, ?), 1)
297        c = str2.count("\n")
298        old_line = @line
299        old_offset = @offset
300        @line += c
301        @offset = (c == 0 ? @offset + str2.size : str2[/\n(.*)/, 1].size)
302        [:special_fun,
303          Haml::Util.merge_adjacent_strings(
304            [str1] + Sass::Engine.parse_interp(str2, old_line, old_offset, @options)),
305          str1.size + str2.size]
306      end
307
308      def ident_op
309        return unless op = scan(REGULAR_EXPRESSIONS[:ident_op])
310        [OPERATORS[op]]
311      end
312
313      def op
314        return unless op = scan(REGULAR_EXPRESSIONS[:op])
315        @interpolation_stack << nil if op == :begin_interpolation
316        [OPERATORS[op]]
317      end
318
319      def raw(rx)
320        return unless val = scan(rx)
321        [:raw, val]
322      end
323
324      def scan(re)
325        return unless str = @scanner.scan(re)
326        c = str.count("\n")
327        @line += c
328        @offset = (c == 0 ? @offset + str.size : str[/\n(.*)/, 1].size)
329        str
330      end
331
332      def current_position
333        @offset + 1
334      end
335    end
336  end
337end