geminfo 0.1.0 → 0.1.1

data/path/gems/coderay-1.1.0/lib/coderay/scanners/haml.rb

@@ -1,168 +0,0 @@
-module CodeRay
-module Scanners
-  
-  load :ruby
-  load :html
-  load :java_script
-  
-  class HAML < Scanner
-    
-    register_for :haml
-    title 'HAML Template'
-    
-    KINDS_NOT_LOC = HTML::KINDS_NOT_LOC
-    
-  protected
-    
-    def setup
-      super
-      @ruby_scanner          = CodeRay.scanner :ruby, :tokens => @tokens, :keep_tokens => true
-      @embedded_ruby_scanner = CodeRay.scanner :ruby, :tokens => @tokens, :keep_tokens => true, :state => @ruby_scanner.interpreted_string_state
-      @html_scanner          = CodeRay.scanner :html, :tokens => @tokens, :keep_tokens => true
-    end
-    
-    def scan_tokens encoder, options
-      
-      match = nil
-      code = ''
-      
-      until eos?
-        
-        if bol?
-          if match = scan(/!!!.*/)
-            encoder.text_token match, :doctype
-            next
-          end
-          
-          if match = scan(/(?>( *)(\/(?!\[if)|-\#|:javascript|:ruby|:\w+) *)(?=\n)/)
-            encoder.text_token match, :comment
-            
-            code = self[2]
-            if match = scan(/(?:\n+#{self[1]} .*)+/)
-              case code
-              when '/', '-#'
-                encoder.text_token match, :comment
-              when ':javascript'
-                # TODO: recognize #{...} snippets inside JavaScript
-                @java_script_scanner ||= CodeRay.scanner :java_script, :tokens => @tokens, :keep_tokens => true
-                @java_script_scanner.tokenize match, :tokens => encoder
-              when ':ruby'
-                @ruby_scanner.tokenize match, :tokens => encoder
-              when /:\w+/
-                encoder.text_token match, :comment
-              else
-                raise 'else-case reached: %p' % [code]
-              end
-            end
-          end
-          
-          if match = scan(/ +/)
-            encoder.text_token match, :space
-          end
-          
-          if match = scan(/\/.*/)
-            encoder.text_token match, :comment
-            next
-          end
-          
-          if match = scan(/\\/)
-            encoder.text_token match, :plain
-            if match = scan(/.+/)
-              @html_scanner.tokenize match, :tokens => encoder
-            end
-            next
-          end
-          
-          tag = false
-          
-          if match = scan(/%[\w:]+\/?/)
-            encoder.text_token match, :tag
-            # if match = scan(/( +)(.+)/)
-            #   encoder.text_token self[1], :space
-            #   @embedded_ruby_scanner.tokenize self[2], :tokens => encoder
-            # end
-            tag = true
-          end
-          
-          while match = scan(/([.#])[-\w]*\w/)
-            encoder.text_token match, self[1] == '#' ? :constant : :class
-            tag = true
-          end
-          
-          if tag && match = scan(/(\()([^)]+)?(\))?/)
-            # TODO: recognize title=@title, class="widget_#{@widget.number}"
-            encoder.text_token self[1], :plain
-            @html_scanner.tokenize self[2], :tokens => encoder, :state => :attribute if self[2]
-            encoder.text_token self[3], :plain if self[3]
-          end
-          
-          if tag && match = scan(/\{/)
-            encoder.text_token match, :plain
-            
-            code = ''
-            level = 1
-            while true
-              code << scan(/([^\{\},\n]|, *\n?)*/)
-              case match = getch
-              when '{'
-                level += 1
-                code << match
-              when '}'
-                level -= 1
-                if level > 0
-                  code << match
-                else
-                  break
-                end
-              when "\n", ",", nil
-                break
-              end
-            end
-            @ruby_scanner.tokenize code, :tokens => encoder unless code.empty?
-            
-            encoder.text_token match, :plain if match
-          end
-          
-          if tag && match = scan(/(\[)([^\]\n]+)?(\])?/)
-            encoder.text_token self[1], :plain
-            @ruby_scanner.tokenize self[2], :tokens => encoder if self[2]
-            encoder.text_token self[3], :plain if self[3]
-          end
-          
-          if tag && match = scan(/\//)
-            encoder.text_token match, :tag
-          end
-          
-          if scan(/(>?<?[-=]|[&!]=|(& |!)|~)( *)([^,\n\|]+(?:(, *|\|(?=.|\n.*\|$))\n?[^,\n\|]*)*)?/)
-            encoder.text_token self[1] + self[3], :plain
-            if self[4]
-              if self[2]
-                @embedded_ruby_scanner.tokenize self[4], :tokens => encoder
-              else
-                @ruby_scanner.tokenize self[4], :tokens => encoder
-              end
-            end
-          elsif match = scan(/((?:<|><?)(?![!?\/\w]))?(.+)?/)
-            encoder.text_token self[1], :plain if self[1]
-            # TODO: recognize #{...} snippets
-            @html_scanner.tokenize self[2], :tokens => encoder if self[2]
-          end
-          
-        elsif match = scan(/.+/)
-          @html_scanner.tokenize match, :tokens => encoder
-          
-        end
-        
-        if match = scan(/\n/)
-          encoder.text_token match, :space
-        end
-      end
-      
-      encoder
-      
-    end
-    
-  end
-  
-end
-end

data/path/gems/coderay-1.1.0/lib/coderay/scanners/html.rb

@@ -1,275 +0,0 @@
-module CodeRay
-module Scanners
-  
-  # HTML Scanner
-  # 
-  # Alias: +xhtml+
-  # 
-  # See also: Scanners::XML
-  class HTML < Scanner
-    
-    register_for :html
-    
-    KINDS_NOT_LOC = [
-      :comment, :doctype, :preprocessor,
-      :tag, :attribute_name, :operator,
-      :attribute_value, :string,
-      :plain, :entity, :error,
-    ]  # :nodoc:
-    
-    EVENT_ATTRIBUTES = %w(
-      onabort onafterprint onbeforeprint onbeforeunload onblur oncanplay
-      oncanplaythrough onchange onclick oncontextmenu oncuechange ondblclick
-      ondrag ondragdrop ondragend ondragenter ondragleave ondragover
-      ondragstart ondrop ondurationchange onemptied onended onerror onfocus
-      onformchange onforminput onhashchange oninput oninvalid onkeydown
-      onkeypress onkeyup onload onloadeddata onloadedmetadata onloadstart
-      onmessage onmousedown onmousemove onmouseout onmouseover onmouseup
-      onmousewheel onmove onoffline ononline onpagehide onpageshow onpause
-      onplay onplaying onpopstate onprogress onratechange onreadystatechange
-      onredo onreset onresize onscroll onseeked onseeking onselect onshow
-      onstalled onstorage onsubmit onsuspend ontimeupdate onundo onunload
-      onvolumechange onwaiting
-    )
-    
-    IN_ATTRIBUTE = WordList::CaseIgnoring.new(nil).
-      add(EVENT_ATTRIBUTES, :script).
-      add(['style'], :style)
-    
-    ATTR_NAME = /[\w.:-]+/  # :nodoc:
-    TAG_END = /\/?>/  # :nodoc:
-    HEX = /[0-9a-fA-F]/  # :nodoc:
-    ENTITY = /
-      &
-      (?:
-        \w+
-      |
-        \#
-        (?:
-          \d+
-        |
-          x#{HEX}+
-        )
-      )
-      ;
-    /ox  # :nodoc:
-    
-    PLAIN_STRING_CONTENT = {
-      "'" => /[^&'>\n]+/,
-      '"' => /[^&">\n]+/,
-    }  # :nodoc:
-    
-    def reset
-      super
-      @state = :initial
-      @plain_string_content = nil
-    end
-    
-  protected
-    
-    def setup
-      @state = :initial
-      @plain_string_content = nil
-      @in_tag = nil
-    end
-    
-    def scan_java_script encoder, code
-      if code && !code.empty?
-        @java_script_scanner ||= Scanners::JavaScript.new '', :keep_tokens => true
-        @java_script_scanner.tokenize code, :tokens => encoder
-      end
-    end
-    
-    def scan_css encoder, code, state = [:initial]
-      if code && !code.empty?
-        @css_scanner ||= Scanners::CSS.new '', :keep_tokens => true
-        @css_scanner.tokenize code, :tokens => encoder, :state => state
-      end
-    end
-    
-    def scan_tokens encoder, options
-      state = options[:state] || @state
-      plain_string_content = @plain_string_content
-      in_tag = @in_tag
-      in_attribute = nil
-      
-      encoder.begin_group :string if state == :attribute_value_string
-      
-      until eos?
-        
-        if state != :in_special_tag && match = scan(/\s+/m)
-          encoder.text_token match, :space
-          
-        else
-          
-          case state
-          
-          when :initial
-            if match = scan(/<!\[CDATA\[/)
-              encoder.text_token match, :inline_delimiter
-              if match = scan(/.*?\]\]>/m)
-                encoder.text_token match[0..-4], :plain
-                encoder.text_token ']]>', :inline_delimiter
-              elsif match = scan(/.+/)
-                encoder.text_token match, :error
-              end
-            elsif match = scan(/<!--(?:.*?-->|.*)/m)
-              encoder.text_token match, :comment
-            elsif match = scan(/<!(\w+)(?:.*?>|.*)|\]>/m)
-              encoder.text_token match, :doctype
-            elsif match = scan(/<\?xml(?:.*?\?>|.*)/m)
-              encoder.text_token match, :preprocessor
-            elsif match = scan(/<\?(?:.*?\?>|.*)/m)
-              encoder.text_token match, :comment
-            elsif match = scan(/<\/[-\w.:]*>?/m)
-              in_tag = nil
-              encoder.text_token match, :tag
-            elsif match = scan(/<(?:(script|style)|[-\w.:]+)(>)?/m)
-              encoder.text_token match, :tag
-              in_tag = self[1]
-              if self[2]
-                state = :in_special_tag if in_tag
-              else
-                state = :attribute
-              end
-            elsif match = scan(/[^<>&]+/)
-              encoder.text_token match, :plain
-            elsif match = scan(/#{ENTITY}/ox)
-              encoder.text_token match, :entity
-            elsif match = scan(/[<>&]/)
-              in_tag = nil
-              encoder.text_token match, :error
-            else
-              raise_inspect '[BUG] else-case reached with state %p' % [state], encoder
-            end
-            
-          when :attribute
-            if match = scan(/#{TAG_END}/o)
-              encoder.text_token match, :tag
-              in_attribute = nil
-              if in_tag
-                state = :in_special_tag
-              else
-                state = :initial
-              end
-            elsif match = scan(/#{ATTR_NAME}/o)
-              in_attribute = IN_ATTRIBUTE[match]
-              encoder.text_token match, :attribute_name
-              state = :attribute_equal
-            else
-              in_tag = nil
-              encoder.text_token getch, :error
-            end
-            
-          when :attribute_equal
-            if match = scan(/=/)  #/
-              encoder.text_token match, :operator
-              state = :attribute_value
-            else
-              state = :attribute
-              next
-            end
-            
-          when :attribute_value
-            if match = scan(/#{ATTR_NAME}/o)
-              encoder.text_token match, :attribute_value
-              state = :attribute
-            elsif match = scan(/["']/)
-              if in_attribute == :script || in_attribute == :style
-                encoder.begin_group :string
-                encoder.text_token match, :delimiter
-                if scan(/javascript:[ \t]*/)
-                  encoder.text_token matched, :comment
-                end
-                code = scan_until(match == '"' ? /(?="|\z)/ : /(?='|\z)/)
-                if in_attribute == :script
-                  scan_java_script encoder, code
-                else
-                  scan_css encoder, code, [:block]
-                end
-                match = scan(/["']/)
-                encoder.text_token match, :delimiter if match
-                encoder.end_group :string
-                state = :attribute
-                in_attribute = nil
-              else
-                encoder.begin_group :string
-                state = :attribute_value_string
-                plain_string_content = PLAIN_STRING_CONTENT[match]
-                encoder.text_token match, :delimiter
-              end
-            elsif match = scan(/#{TAG_END}/o)
-              encoder.text_token match, :tag
-              state = :initial
-            else
-              encoder.text_token getch, :error
-            end
-            
-          when :attribute_value_string
-            if match = scan(plain_string_content)
-              encoder.text_token match, :content
-            elsif match = scan(/['"]/)
-              encoder.text_token match, :delimiter
-              encoder.end_group :string
-              state = :attribute
-            elsif match = scan(/#{ENTITY}/ox)
-              encoder.text_token match, :entity
-            elsif match = scan(/&/)
-              encoder.text_token match, :content
-            elsif match = scan(/[\n>]/)
-              encoder.end_group :string
-              state = :initial
-              encoder.text_token match, :error
-            end
-            
-          when :in_special_tag
-            case in_tag
-            when 'script', 'style'
-              encoder.text_token match, :space if match = scan(/[ \t]*\n/)
-              if scan(/(\s*<!--)(?:(.*?)(-->)|(.*))/m)
-                code = self[2] || self[4]
-                closing = self[3]
-                encoder.text_token self[1], :comment
-              else
-                code = scan_until(/(?=(?:\n\s*)?<\/#{in_tag}>)|\z/)
-                closing = false
-              end
-              unless code.empty?
-                encoder.begin_group :inline
-                if in_tag == 'script'
-                  scan_java_script encoder, code
-                else
-                  scan_css encoder, code
-                end
-                encoder.end_group :inline
-              end
-              encoder.text_token closing, :comment if closing
-              state = :initial
-            else
-              raise 'unknown special tag: %p' % [in_tag]
-            end
-            
-          else
-            raise_inspect 'Unknown state: %p' % [state], encoder
-            
-          end
-          
-        end
-        
-      end
-      
-      if options[:keep_state]
-        @state = state
-        @plain_string_content = plain_string_content
-        @in_tag = in_tag
-      end
-      
-      encoder.end_group :string if state == :attribute_value_string
-      
-      encoder
-    end
-    
-  end
-  
-end
-end

data/path/gems/coderay-1.1.0/lib/coderay/scanners/java.rb

@@ -1,174 +0,0 @@
-module CodeRay
-module Scanners
-  
-  # Scanner for Java.
-  class Java < Scanner
-    
-    register_for :java
-    
-    autoload :BuiltinTypes, CodeRay.coderay_path('scanners', 'java', 'builtin_types')
-    
-    # http://java.sun.com/docs/books/tutorial/java/nutsandbolts/_keywords.html
-    KEYWORDS = %w[
-      assert break case catch continue default do else
-      finally for if instanceof import new package
-      return switch throw try typeof while
-      debugger export
-    ]  # :nodoc:
-    RESERVED = %w[ const goto ]  # :nodoc:
-    CONSTANTS = %w[ false null true ]  # :nodoc:
-    MAGIC_VARIABLES = %w[ this super ]  # :nodoc:
-    TYPES = %w[
-      boolean byte char class double enum float int interface long
-      short void
-    ] << '[]'  # :nodoc: because int[] should be highlighted as a type
-    DIRECTIVES = %w[
-      abstract extends final implements native private protected public
-      static strictfp synchronized throws transient volatile
-    ]  # :nodoc:
-    
-    IDENT_KIND = WordList.new(:ident).
-      add(KEYWORDS, :keyword).
-      add(RESERVED, :reserved).
-      add(CONSTANTS, :predefined_constant).
-      add(MAGIC_VARIABLES, :local_variable).
-      add(TYPES, :type).
-      add(BuiltinTypes::List, :predefined_type).
-      add(BuiltinTypes::List.select { |builtin| builtin[/(Error|Exception)$/] }, :exception).
-      add(DIRECTIVES, :directive)  # :nodoc:
-
-    ESCAPE = / [bfnrtv\n\\'"] | x[a-fA-F0-9]{1,2} | [0-7]{1,3} /x  # :nodoc:
-    UNICODE_ESCAPE =  / u[a-fA-F0-9]{4} | U[a-fA-F0-9]{8} /x  # :nodoc:
-    STRING_CONTENT_PATTERN = {
-      "'" => /[^\\']+/,
-      '"' => /[^\\"]+/,
-      '/' => /[^\\\/]+/,
-    }  # :nodoc:
-    IDENT = /[a-zA-Z_][A-Za-z_0-9]*/  # :nodoc:
-    
-  protected
-    
-    def scan_tokens encoder, options
-
-      state = :initial
-      string_delimiter = nil
-      package_name_expected = false
-      class_name_follows = false
-      last_token_dot = false
-
-      until eos?
-
-        case state
-
-        when :initial
-
-          if match = scan(/ \s+ | \\\n /x)
-            encoder.text_token match, :space
-            next
-          
-          elsif match = scan(%r! // [^\n\\]* (?: \\. [^\n\\]* )* | /\* (?: .*? \*/ | .* ) !mx)
-            encoder.text_token match, :comment
-            next
-          
-          elsif package_name_expected && match = scan(/ #{IDENT} (?: \. #{IDENT} )* /ox)
-            encoder.text_token match, package_name_expected
-          
-          elsif match = scan(/ #{IDENT} | \[\] /ox)
-            kind = IDENT_KIND[match]
-            if last_token_dot
-              kind = :ident
-            elsif class_name_follows
-              kind = :class
-              class_name_follows = false
-            else
-              case match
-              when 'import'
-                package_name_expected = :include
-              when 'package'
-                package_name_expected = :namespace
-              when 'class', 'interface'
-                class_name_follows = true
-              end
-            end
-            encoder.text_token match, kind
-          
-          elsif match = scan(/ \.(?!\d) | [,?:()\[\]}] | -- | \+\+ | && | \|\| | \*\*=? | [-+*\/%^~&|<>=!]=? | <<<?=? | >>>?=? /x)
-            encoder.text_token match, :operator
-          
-          elsif match = scan(/;/)
-            package_name_expected = false
-            encoder.text_token match, :operator
-          
-          elsif match = scan(/\{/)
-            class_name_follows = false
-            encoder.text_token match, :operator
-          
-          elsif check(/[\d.]/)
-            if match = scan(/0[xX][0-9A-Fa-f]+/)
-              encoder.text_token match, :hex
-            elsif match = scan(/(?>0[0-7]+)(?![89.eEfF])/)
-              encoder.text_token match, :octal
-            elsif match = scan(/\d+[fFdD]|\d*\.\d+(?:[eE][+-]?\d+)?[fFdD]?|\d+[eE][+-]?\d+[fFdD]?/)
-              encoder.text_token match, :float
-            elsif match = scan(/\d+[lL]?/)
-              encoder.text_token match, :integer
-            end
-
-          elsif match = scan(/["']/)
-            state = :string
-            encoder.begin_group state
-            string_delimiter = match
-            encoder.text_token match, :delimiter
-
-          elsif match = scan(/ @ #{IDENT} /ox)
-            encoder.text_token match, :annotation
-
-          else
-            encoder.text_token getch, :error
-
-          end
-
-        when :string
-          if match = scan(STRING_CONTENT_PATTERN[string_delimiter])
-            encoder.text_token match, :content
-          elsif match = scan(/["'\/]/)
-            encoder.text_token match, :delimiter
-            encoder.end_group state
-            state = :initial
-            string_delimiter = nil
-          elsif state == :string && (match = scan(/ \\ (?: #{ESCAPE} | #{UNICODE_ESCAPE} ) /mox))
-            if string_delimiter == "'" && !(match == "\\\\" || match == "\\'")
-              encoder.text_token match, :content
-            else
-              encoder.text_token match, :char
-            end
-          elsif match = scan(/\\./m)
-            encoder.text_token match, :content
-          elsif match = scan(/ \\ | $ /x)
-            encoder.end_group state
-            state = :initial
-            encoder.text_token match, :error unless match.empty?
-          else
-            raise_inspect "else case \" reached; %p not handled." % peek(1), encoder
-          end
-
-        else
-          raise_inspect 'Unknown state', encoder
-
-        end
-        
-        last_token_dot = match == '.'
-        
-      end
-
-      if state == :string
-        encoder.end_group state
-      end
-
-      encoder
-    end
-
-  end
-
-end
-end