coderay-beta 0.9.1

data/lib/coderay/scanners/java_script.rb

@@ -0,0 +1,224 @@
+module CodeRay
+module Scanners
+
+  class JavaScript < Scanner
+
+    include Streamable
+
+    register_for :java_script
+    file_extension 'js'
+
+    # The actual JavaScript keywords.
+    KEYWORDS = %w[
+      break case catch continue default delete do else
+      finally for function if in instanceof new
+      return switch throw try typeof var void while with
+    ]
+    PREDEFINED_CONSTANTS = %w[
+      false null true undefined
+    ]
+    
+    MAGIC_VARIABLES = %w[ this arguments ]  # arguments was introduced in JavaScript 1.4
+    
+    KEYWORDS_EXPECTING_VALUE = WordList.new.add %w[
+      case delete in instanceof new return throw typeof with
+    ]
+    
+    # Reserved for future use.
+    RESERVED_WORDS = %w[
+      abstract boolean byte char class debugger double enum export extends
+      final float goto implements import int interface long native package
+      private protected public short static super synchronized throws transient
+      volatile
+    ]
+    
+    IDENT_KIND = WordList.new(:ident).
+      add(RESERVED_WORDS, :reserved).
+      add(PREDEFINED_CONSTANTS, :pre_constant).
+      add(MAGIC_VARIABLES, :local_variable).
+      add(KEYWORDS, :keyword)
+
+    ESCAPE = / [bfnrtv\n\\'"] | x[a-fA-F0-9]{1,2} | [0-7]{1,3} /x
+    UNICODE_ESCAPE =  / u[a-fA-F0-9]{4} | U[a-fA-F0-9]{8} /x
+    REGEXP_ESCAPE =  / [bBdDsSwW] /x
+    STRING_CONTENT_PATTERN = {
+      "'" => /[^\\']+/,
+      '"' => /[^\\"]+/,
+      '/' => /[^\\\/]+/,
+    }
+    KEY_CHECK_PATTERN = {
+      "'" => / [^\\']* (?: \\.? [^\\']* )* '? \s* : /x,
+      '"' => / [^\\"]* (?: \\.? [^\\"]* )* "? \s* : /x,
+    }
+
+    def scan_tokens tokens, options
+
+      state = :initial
+      string_delimiter = nil
+      value_expected = true
+      key_expected = false
+      function_expected = false
+
+      until eos?
+
+        kind = nil
+        match = nil
+        
+        case state
+
+        when :initial
+
+          if match = scan(/ \s+ | \\\n /x)
+            value_expected = true if !value_expected && match.index(?\n)
+            tokens << [match, :space]
+            next
+
+          elsif scan(%r! // [^\n\\]* (?: \\. [^\n\\]* )* | /\* (?: .*? \*/ | .* ) !mx)
+            value_expected = true
+            kind = :comment
+
+          elsif check(/\.?\d/)
+            key_expected = value_expected = false
+            if scan(/0[xX][0-9A-Fa-f]+/)
+              kind = :hex
+            elsif scan(/(?>0[0-7]+)(?![89.eEfF])/)
+              kind = :oct
+            elsif scan(/\d+[fF]|\d*\.\d+(?:[eE][+-]?\d+)?[fF]?|\d+[eE][+-]?\d+[fF]?/)
+              kind = :float
+            elsif scan(/\d+/)
+              kind = :integer
+            end
+          
+          elsif value_expected && match = scan(/<([[:alpha:]]\w*) (?: [^\/>]*\/> | .*?<\/\1>)/xim)
+            # FIXME: scan over nested tags
+            xml_scanner.tokenize match
+            value_expected = false
+            next
+            
+          elsif match = scan(/ [-+*=<>?:;,!&^|(\[{~%]+ | \.(?!\d) /x)
+            value_expected = true
+            last_operator = match[-1]
+            key_expected = (last_operator == ?{) || (last_operator == ?,)
+            function_expected = false
+            kind = :operator
+
+          elsif scan(/ [)\]}]+ /x)
+            function_expected = key_expected = value_expected = false
+            kind = :operator
+
+          elsif match = scan(/ [$a-zA-Z_][A-Za-z_0-9$]* /x)
+            kind = IDENT_KIND[match]
+            value_expected = (kind == :keyword) && KEYWORDS_EXPECTING_VALUE[match]
+            # TODO: labels
+            if kind == :ident
+              if match.index(?$)  # $ allowed inside an identifier
+                kind = :predefined
+              elsif function_expected
+                kind = :function
+              elsif check(/\s*[=:]\s*function\b/)
+                kind = :function
+              elsif key_expected && check(/\s*:/)
+                kind = :key
+              end
+            end
+            function_expected = (kind == :keyword) && (match == 'function')
+            key_expected = false
+          
+          elsif match = scan(/["']/)
+            if key_expected && check(KEY_CHECK_PATTERN[match])
+              state = :key
+            else
+              state = :string
+            end
+            tokens << [:open, state]
+            string_delimiter = match
+            kind = :delimiter
+
+          elsif value_expected && (match = scan(/\/(?=\S)/))
+            tokens << [:open, :regexp]
+            state = :regexp
+            string_delimiter = '/'
+            kind = :delimiter
+
+          elsif scan(/ \/ /x)
+            value_expected = true
+            key_expected = false
+            kind = :operator
+
+          else
+            getch
+            kind = :error
+
+          end
+
+        when :string, :regexp, :key
+          if scan(STRING_CONTENT_PATTERN[string_delimiter])
+            kind = :content
+          elsif match = scan(/["'\/]/)
+            tokens << [match, :delimiter]
+            if state == :regexp
+              modifiers = scan(/[gim]+/)
+              tokens << [modifiers, :modifier] if modifiers && !modifiers.empty?
+            end
+            tokens << [:close, state]
+            string_delimiter = nil
+            key_expected = value_expected = false
+            state = :initial
+            next
+          elsif state != :regexp && (match = scan(/ \\ (?: #{ESCAPE} | #{UNICODE_ESCAPE} ) /mox))
+            if string_delimiter == "'" && !(match == "\\\\" || match == "\\'")
+              kind = :content
+            else
+              kind = :char
+            end
+          elsif state == :regexp && scan(/ \\ (?: #{ESCAPE} | #{REGEXP_ESCAPE} | #{UNICODE_ESCAPE} ) /mox)
+            kind = :char
+          elsif scan(/\\./m)
+            kind = :content
+          elsif scan(/ \\ | $ /x)
+            tokens << [:close, state]
+            kind = :error
+            key_expected = value_expected = false
+            state = :initial
+          else
+            raise_inspect "else case \" reached; %p not handled." % peek(1), tokens
+          end
+
+        else
+          raise_inspect 'Unknown state', tokens
+
+        end
+
+        match ||= matched
+        if $DEBUG and not kind
+          raise_inspect 'Error token %p in line %d' %
+            [[match, kind], line], tokens
+        end
+        raise_inspect 'Empty token', tokens unless match
+        
+        tokens << [match, kind]
+
+      end
+
+      if [:string, :regexp].include? state
+        tokens << [:close, state]
+      end
+
+      tokens
+    end
+
+  protected
+
+    def reset_instance
+      super
+      @xml_scanner.reset if defined? @xml_scanner
+    end
+
+    def xml_scanner
+      @xml_scanner ||= CodeRay.scanner :xml, :tokens => @tokens, :keep_tokens => true, :keep_state => true
+    end
+
+  end
+  
+end
+end

data/lib/coderay/scanners/json.rb

@@ -0,0 +1,112 @@
+module CodeRay
+module Scanners
+  
+  class JSON < Scanner
+    
+    include Streamable
+    
+    register_for :json
+    file_extension 'json'
+    
+    KINDS_NOT_LOC = [
+      :float, :char, :content, :delimiter,
+      :error, :integer, :operator, :value,
+    ]
+    
+    CONSTANTS = %w( true false null )
+    IDENT_KIND = WordList.new(:key).add(CONSTANTS, :value)
+    
+    ESCAPE = / [bfnrt\\"\/] /x
+    UNICODE_ESCAPE =  / u[a-fA-F0-9]{4} /x
+    
+    def scan_tokens tokens, options
+      
+      state = :initial
+      stack = []
+      string_delimiter = nil
+      key_expected = false
+      
+      until eos?
+        
+        kind = nil
+        match = nil
+        
+        case state
+        
+        when :initial
+          if match = scan(/ \s+ | \\\n /x)
+            tokens << [match, :space]
+            next
+          elsif match = scan(/ [:,\[{\]}] /x)
+            kind = :operator
+            case match
+            when '{' then stack << :object; key_expected = true
+            when '[' then stack << :array
+            when ':' then key_expected = false
+            when ',' then key_expected = true if stack.last == :object
+            when '}', ']' then stack.pop  # no error recovery, but works for valid JSON
+            end
+          elsif match = scan(/ true | false | null /x)
+            kind = IDENT_KIND[match]
+          elsif match = scan(/-?(?:0|[1-9]\d*)/)
+            kind = :integer
+            if scan(/\.\d+(?:[eE][-+]?\d+)?|[eE][-+]?\d+/)
+              match << matched
+              kind = :float
+            end
+          elsif match = scan(/"/)
+            state = key_expected ? :key : :string
+            tokens << [:open, state]
+            kind = :delimiter
+          else
+            getch
+            kind = :error
+          end
+          
+        when :string, :key
+          if scan(/[^\\"]+/)
+            kind = :content
+          elsif scan(/"/)
+            tokens << ['"', :delimiter]
+            tokens << [:close, state]
+            state = :initial
+            next
+          elsif scan(/ \\ (?: #{ESCAPE} | #{UNICODE_ESCAPE} ) /mox)
+            kind = :char
+          elsif scan(/\\./m)
+            kind = :content
+          elsif scan(/ \\ | $ /x)
+            tokens << [:close, :delimiter]
+            kind = :error
+            state = :initial
+          else
+            raise_inspect "else case \" reached; %p not handled." % peek(1), tokens
+          end
+          
+        else
+          raise_inspect 'Unknown state', tokens
+          
+        end
+        
+        match ||= matched
+        if $DEBUG and not kind
+          raise_inspect 'Error token %p in line %d' %
+            [[match, kind], line], tokens
+        end
+        raise_inspect 'Empty token', tokens unless match
+        
+        tokens << [match, kind]
+        
+      end
+      
+      if [:string, :key].include? state
+        tokens << [:close, state]
+      end
+      
+      tokens
+    end
+    
+  end
+  
+end
+end

data/lib/coderay/scanners/nitro_xhtml.rb

@@ -0,0 +1,136 @@
+module CodeRay
+module Scanners
+
+  load :html
+  load :ruby
+
+  # Nitro XHTML Scanner
+  class NitroXHTML < Scanner
+
+    include Streamable
+    register_for :nitro_xhtml
+    file_extension :xhtml
+    title 'Nitro XHTML'
+
+    KINDS_NOT_LOC = HTML::KINDS_NOT_LOC
+    
+    NITRO_RUBY_BLOCK = /
+      <\?r
+      (?>
+        [^\?]*
+        (?> \?(?!>) [^\?]* )*
+      )
+      (?: \?> )?
+    |
+      <ruby>
+      (?>
+        [^<]*
+        (?> <(?!\/ruby>) [^<]* )*
+      )
+      (?: <\/ruby> )?
+    |
+      <%
+      (?>
+        [^%]*
+        (?> %(?!>) [^%]* )*
+      )
+      (?: %> )?
+    /mx
+
+    NITRO_VALUE_BLOCK = /
+      \#
+      (?:
+        \{
+        [^{}]*
+        (?>
+          \{ [^}]* \}
+          (?> [^{}]* )
+        )*
+        \}?
+      | \| [^|]* \|?
+      | \( [^)]* \)?
+      | \[ [^\]]* \]?
+      | \\ [^\\]* \\?
+      )
+    /x
+
+    NITRO_ENTITY = /
+      % (?: \#\d+ | \w+ ) ;
+    /
+
+    START_OF_RUBY = /
+      (?=[<\#%])
+      < (?: \?r | % | ruby> )
+    | \# [{(|]
+    | % (?: \#\d+ | \w+ ) ;
+    /x
+
+    CLOSING_PAREN = Hash.new do |h, p|
+      h[p] = p
+    end.update( {
+      '(' => ')',
+      '[' => ']',
+      '{' => '}',
+    } )
+
+  private
+
+    def setup
+      @ruby_scanner = CodeRay.scanner :ruby, :tokens => @tokens, :keep_tokens => true
+      @html_scanner = CodeRay.scanner :html, :tokens => @tokens, :keep_tokens => true, :keep_state => true
+    end
+
+    def reset_instance
+      super
+      @html_scanner.reset
+    end
+
+    def scan_tokens tokens, options
+
+      until eos?
+
+        if (match = scan_until(/(?=#{START_OF_RUBY})/o) || scan_until(/\z/)) and not match.empty?
+          @html_scanner.tokenize match
+
+        elsif match = scan(/#{NITRO_VALUE_BLOCK}/o)
+          start_tag = match[0,2]
+          delimiter = CLOSING_PAREN[start_tag[1,1]]
+          end_tag = match[-1,1] == delimiter ? delimiter : ''
+          tokens << [:open, :inline]
+          tokens << [start_tag, :inline_delimiter]
+          code = match[start_tag.size .. -1 - end_tag.size]
+          @ruby_scanner.tokenize code
+          tokens << [end_tag, :inline_delimiter] unless end_tag.empty?
+          tokens << [:close, :inline]
+
+        elsif match = scan(/#{NITRO_RUBY_BLOCK}/o)
+          start_tag = '<?r'
+          end_tag = match[-2,2] == '?>' ? '?>' : ''
+          tokens << [:open, :inline]
+          tokens << [start_tag, :inline_delimiter]
+          code = match[start_tag.size .. -(end_tag.size)-1]
+          @ruby_scanner.tokenize code
+          tokens << [end_tag, :inline_delimiter] unless end_tag.empty?
+          tokens << [:close, :inline]
+
+        elsif entity = scan(/#{NITRO_ENTITY}/o)
+          tokens << [entity, :entity]
+        
+        elsif scan(/%/)
+          tokens << [matched, :error]
+
+        else
+          raise_inspect 'else-case reached!', tokens
+          
+        end
+
+      end
+
+      tokens
+
+    end
+
+  end
+
+end
+end