asana2flowdock 1.0.0

data/vendor/bundle/ruby/1.9.1/gems/coderay-1.1.0/lib/coderay/scanners/ruby/patterns.rb

@@ -0,0 +1,178 @@
+# encoding: utf-8
+module CodeRay
+module Scanners
+  
+  module Ruby::Patterns  # :nodoc: all
+    
+    KEYWORDS = %w[
+      and def end in or unless begin
+      defined? ensure module redo super until
+      BEGIN break do next rescue then
+      when END case else for retry
+      while alias class elsif if not return
+      undef yield
+    ]
+    
+    # See http://murfy.de/ruby-constants.
+    PREDEFINED_CONSTANTS = %w[
+      nil true false self
+      DATA ARGV ARGF ENV
+      FALSE TRUE NIL
+      STDERR STDIN STDOUT
+      TOPLEVEL_BINDING
+      RUBY_COPYRIGHT RUBY_DESCRIPTION RUBY_ENGINE RUBY_PATCHLEVEL
+      RUBY_PLATFORM RUBY_RELEASE_DATE RUBY_REVISION RUBY_VERSION
+      __FILE__ __LINE__ __ENCODING__
+    ]
+    
+    IDENT_KIND = WordList.new(:ident).
+      add(KEYWORDS, :keyword).
+      add(PREDEFINED_CONSTANTS, :predefined_constant)
+    
+    KEYWORD_NEW_STATE = WordList.new(:initial).
+      add(%w[ def ], :def_expected).
+      add(%w[ undef ], :undef_expected).
+      add(%w[ alias ], :alias_expected).
+      add(%w[ class module ], :module_expected)
+    
+    IDENT = 'ä'[/[[:alpha:]]/] == 'ä' ? Regexp.new('[[:alpha:]_[^\0-\177]][[:alnum:]_[^\0-\177]]*') : /[^\W\d]\w*/
+    
+    METHOD_NAME = / #{IDENT} [?!]? /ox
+    METHOD_NAME_OPERATOR = /
+      \*\*?           # multiplication and power
+      | [-+~]@?       # plus, minus, tilde with and without at sign
+      | [\/%&|^`]     # division, modulo or format strings, and, or, xor, system
+      | \[\]=?        # array getter and setter
+      | << | >>       # append or shift left, shift right
+      | <=?>? | >=?   # comparison, rocket operator
+      | ===? | =~     # simple equality, case equality, match
+      | ![~=@]?       # negation with and without at sign, not-equal and not-match
+    /ox
+    METHOD_SUFFIX = / (?: [?!] | = (?![~>]|=(?!>)) ) /x
+    METHOD_NAME_EX = / #{IDENT} #{METHOD_SUFFIX}? | #{METHOD_NAME_OPERATOR} /ox
+    METHOD_AFTER_DOT = / #{IDENT} [?!]? | #{METHOD_NAME_OPERATOR} /ox
+    INSTANCE_VARIABLE = / @ #{IDENT} /ox
+    CLASS_VARIABLE = / @@ #{IDENT} /ox
+    OBJECT_VARIABLE = / @@? #{IDENT} /ox
+    GLOBAL_VARIABLE = / \$ (?: #{IDENT} | [1-9]\d* | 0\w* | [~&+`'=\/,;_.<>!@$?*":\\] | -[a-zA-Z_0-9] ) /ox
+    PREFIX_VARIABLE = / #{GLOBAL_VARIABLE} | #{OBJECT_VARIABLE} /ox
+    VARIABLE = / @?@? #{IDENT} | #{GLOBAL_VARIABLE} /ox
+    
+    QUOTE_TO_TYPE = {
+      '`' => :shell,
+      '/'=> :regexp,
+    }
+    QUOTE_TO_TYPE.default = :string
+    
+    REGEXP_MODIFIERS = /[mousenix]*/
+    
+    DECIMAL = /\d+(?:_\d+)*/
+    OCTAL = /0_?[0-7]+(?:_[0-7]+)*/
+    HEXADECIMAL = /0x[0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*/
+    BINARY = /0b[01]+(?:_[01]+)*/
+    
+    EXPONENT = / [eE] [+-]? #{DECIMAL} /ox
+    FLOAT_SUFFIX = / #{EXPONENT} | \. #{DECIMAL} #{EXPONENT}? /ox
+    FLOAT_OR_INT = / #{DECIMAL} (?: #{FLOAT_SUFFIX} () )? /ox
+    NUMERIC = / (?: (?=0) (?: #{OCTAL} | #{HEXADECIMAL} | #{BINARY} ) | #{FLOAT_OR_INT} ) /ox
+    
+    SYMBOL = /
+      :
+      (?:
+        #{METHOD_NAME_EX}
+      | #{PREFIX_VARIABLE}
+      | ['"]
+      )
+    /ox
+    METHOD_NAME_OR_SYMBOL = / #{METHOD_NAME_EX} | #{SYMBOL} /ox
+    
+    SIMPLE_ESCAPE = /
+        [abefnrstv]
+      |  [0-7]{1,3}
+      | x[0-9A-Fa-f]{1,2}
+      | .
+    /mx
+    
+    CONTROL_META_ESCAPE = /
+      (?: M-|C-|c )
+      (?: \\ (?: M-|C-|c ) )*
+      (?: [^\\] | \\ #{SIMPLE_ESCAPE} )?
+    /mox
+    
+    ESCAPE = /
+      #{CONTROL_META_ESCAPE} | #{SIMPLE_ESCAPE}
+    /mox
+    
+    CHARACTER = /
+      \?
+      (?:
+        [^\s\\]
+      | \\ #{ESCAPE}
+      )
+    /mox
+    
+    # NOTE: This is not completely correct, but
+    # nobody needs heredoc delimiters ending with \n.
+    HEREDOC_OPEN = /
+      << (-)?              # $1 = float
+      (?:
+        ( [A-Za-z_0-9]+ )  # $2 = delim
+      |
+        ( ["'`\/] )        # $3 = quote, type
+        ( [^\n]*? ) \3     # $4 = delim
+      )
+    /mx
+    
+    RUBYDOC = /
+      =begin (?!\S)
+      .*?
+      (?: \Z | ^=end (?!\S) [^\n]* )
+    /mx
+    
+    DATA = /
+      __END__$
+      .*?
+      (?: \Z | (?=^\#CODE) )
+    /mx
+    
+    RUBYDOC_OR_DATA = / #{RUBYDOC} | #{DATA} /xo
+    
+    # Checks for a valid value to follow. This enables
+    # value_expected in method calls without parentheses.
+    VALUE_FOLLOWS = /
+      (?>[ \t\f\v]+)
+      (?:
+        [%\/][^\s=]
+      | <<-?\S
+      | [-+] \d
+      | #{CHARACTER}
+      )
+    /ox
+    KEYWORDS_EXPECTING_VALUE = WordList.new.add(%w[
+      and end in or unless begin
+      defined? ensure redo super until
+      break do next rescue then
+      when case else for retry
+      while elsif if not return
+      yield
+    ])
+    
+    FANCY_STRING_START = / % ( [iIqQrswWx] | (?![a-zA-Z0-9]) ) ([^a-zA-Z0-9]) /x
+    FANCY_STRING_KIND = Hash.new(:string).merge({
+      'i' => :symbol,
+      'I' => :symbol,
+      'r' => :regexp,
+      's' => :symbol,
+      'x' => :shell,
+    })
+    FANCY_STRING_INTERPRETED = Hash.new(true).merge({
+      'i' => false,
+      'q' => false,
+      's' => false,
+      'w' => false,
+    })
+    
+  end
+  
+end
+end

data/vendor/bundle/ruby/1.9.1/gems/coderay-1.1.0/lib/coderay/scanners/ruby/string_state.rb

@@ -0,0 +1,71 @@
+# encoding: utf-8
+module CodeRay
+module Scanners
+  
+  class Ruby
+    
+    class StringState < Struct.new :type, :interpreted, :delim, :heredoc,
+      :opening_paren, :paren_depth, :pattern, :next_state  # :nodoc: all
+      
+      CLOSING_PAREN = Hash[ *%w[
+        ( )
+        [ ]
+        < >
+        { }
+      ] ].each { |k,v| k.freeze; v.freeze }  # debug, if I try to change it with <<
+      
+      STRING_PATTERN = Hash.new do |h, k|
+        delim, interpreted = *k
+        delim_pattern = Regexp.escape(delim)
+        if closing_paren = CLOSING_PAREN[delim]
+          delim_pattern << Regexp.escape(closing_paren)
+        end
+        delim_pattern << '\\\\' unless delim == '\\'
+        
+        # special_escapes =
+        #   case interpreted
+        #   when :regexp_symbols
+        #     '| [|?*+(){}\[\].^$]'
+        #   end
+        
+        if interpreted && delim != '#'
+          / (?= [#{delim_pattern}] | \# [{$@] ) /mx
+        else
+          / (?= [#{delim_pattern}] ) /mx
+        end.tap do |pattern|
+          h[k] = pattern if (delim.respond_to?(:ord) ? delim.ord : delim[0]) < 256
+        end
+      end
+      
+      def initialize kind, interpreted, delim, heredoc = false
+        if heredoc
+          pattern = heredoc_pattern delim, interpreted, heredoc == :indented
+          delim = nil
+        else
+          pattern = STRING_PATTERN[ [delim, interpreted] ]
+          if closing_paren = CLOSING_PAREN[delim]
+            opening_paren = delim
+            delim = closing_paren
+            paren_depth = 1
+          end
+        end
+        super kind, interpreted, delim, heredoc, opening_paren, paren_depth, pattern, :initial
+      end
+      
+      def heredoc_pattern delim, interpreted, indented
+        # delim = delim.dup  # workaround for old Ruby
+        delim_pattern = Regexp.escape(delim)
+        delim_pattern = / (?:\A|\n) #{ '(?>[ \t]*)' if indented } #{ Regexp.new delim_pattern } $ /x
+        if interpreted
+          / (?= #{delim_pattern}() | \\ | \# [{$@] ) /mx  # $1 set == end of heredoc
+        else
+          / (?= #{delim_pattern}() | \\ ) /mx
+        end
+      end
+      
+    end
+    
+  end
+  
+end
+end

data/vendor/bundle/ruby/1.9.1/gems/coderay-1.1.0/lib/coderay/scanners/sass.rb

@@ -0,0 +1,232 @@
+module CodeRay
+module Scanners
+  
+  # A scanner for Sass.
+  class Sass < CSS
+    
+    register_for :sass
+    file_extension 'sass'
+    
+  protected
+    
+    def setup
+      @state = :initial
+    end
+    
+    def scan_tokens encoder, options
+      states = Array(options[:state] || @state).dup
+      
+      encoder.begin_group :string if states.last == :sqstring || states.last == :dqstring
+      
+      until eos?
+        
+        if bol? && (match = scan(/(?>( +)?(\/[\*\/])(.+)?)(?=\n)/))
+          encoder.text_token self[1], :space if self[1]
+          encoder.begin_group :comment
+          encoder.text_token self[2], :delimiter
+          encoder.text_token self[3], :content if self[3]
+          if match = scan(/(?:\n+#{self[1]} .*)+/)
+            encoder.text_token match, :content
+          end
+          encoder.end_group :comment
+        elsif match = scan(/\n|[^\n\S]+\n?/)
+          encoder.text_token match, :space
+          if match.index(/\n/)
+            value_expected = false
+            states.pop if states.last == :include
+          end
+        
+        elsif states.last == :sass_inline && (match = scan(/\}/))
+          encoder.text_token match, :inline_delimiter
+          encoder.end_group :inline
+          states.pop
+        
+        elsif case states.last
+          when :initial, :media, :sass_inline
+            if match = scan(/(?>#{RE::Ident})(?!\()/ox)
+              encoder.text_token match, value_expected ? :value : (check(/.*:(?![a-z])/) ? :key : :tag)
+              next
+            elsif !value_expected && (match = scan(/\*/))
+              encoder.text_token match, :tag
+              next
+            elsif match = scan(RE::Class)
+              encoder.text_token match, :class
+              next
+            elsif match = scan(RE::Id)
+              encoder.text_token match, :id
+              next
+            elsif match = scan(RE::PseudoClass)
+              encoder.text_token match, :pseudo_class
+              next
+            elsif match = scan(RE::AttributeSelector)
+              # TODO: Improve highlighting inside of attribute selectors.
+              encoder.text_token match[0,1], :operator
+              encoder.text_token match[1..-2], :attribute_name if match.size > 2
+              encoder.text_token match[-1,1], :operator if match[-1] == ?]
+              next
+            elsif match = scan(/(\=|@mixin +)#{RE::Ident}/o)
+              encoder.text_token match, :function
+              next
+            elsif match = scan(/@import\b/)
+              encoder.text_token match, :directive
+              states << :include
+              next
+            elsif match = scan(/@media\b/)
+              encoder.text_token match, :directive
+              # states.push :media_before_name
+              next
+            end
+          
+          when :block
+            if match = scan(/(?>#{RE::Ident})(?!\()/ox)
+              if value_expected
+                encoder.text_token match, :value
+              else
+                encoder.text_token match, :key
+              end
+              next
+            end
+            
+          when :sqstring, :dqstring
+            if match = scan(states.last == :sqstring ? /(?:[^\n\'\#]+|\\\n|#{RE::Escape}|#(?!\{))+/o : /(?:[^\n\"\#]+|\\\n|#{RE::Escape}|#(?!\{))+/o)
+              encoder.text_token match, :content
+            elsif match = scan(/['"]/)
+              encoder.text_token match, :delimiter
+              encoder.end_group :string
+              states.pop
+            elsif match = scan(/#\{/)
+              encoder.begin_group :inline
+              encoder.text_token match, :inline_delimiter
+              states.push :sass_inline
+            elsif match = scan(/ \\ | $ /x)
+              encoder.end_group states.last
+              encoder.text_token match, :error unless match.empty?
+              states.pop
+            else
+              raise_inspect "else case #{states.last} reached; %p not handled." % peek(1), encoder
+            end
+          
+          when :include
+            if match = scan(/[^\s'",]+/)
+              encoder.text_token match, :include
+              next
+            end
+          
+          else
+            #:nocov:
+            raise_inspect 'Unknown state: %p' % [states.last], encoder
+            #:nocov:
+            
+          end
+          
+        elsif match = scan(/\$#{RE::Ident}/o)
+          encoder.text_token match, :variable
+          next
+        
+        elsif match = scan(/&/)
+          encoder.text_token match, :local_variable
+          
+        elsif match = scan(/\+#{RE::Ident}/o)
+          encoder.text_token match, :include
+          value_expected = true
+          
+        elsif match = scan(/\/\*(?:.*?\*\/|.*)|\/\/.*/)
+          encoder.text_token match, :comment
+          
+        elsif match = scan(/#\{/)
+          encoder.begin_group :inline
+          encoder.text_token match, :inline_delimiter
+          states.push :sass_inline
+          
+        elsif match = scan(/\{/)
+          value_expected = false
+          encoder.text_token match, :operator
+          states.push :block
+          
+        elsif match = scan(/\}/)
+          value_expected = false
+          encoder.text_token match, :operator
+          if states.last == :block || states.last == :media
+            states.pop
+          end
+          
+        elsif match = scan(/['"]/)
+          encoder.begin_group :string
+          encoder.text_token match, :delimiter
+          if states.include? :sass_inline
+            # no nesting, just scan the string until delimiter
+            content = scan_until(/(?=#{match}|\}|\z)/)
+            encoder.text_token content, :content unless content.empty?
+            encoder.text_token match, :delimiter if scan(/#{match}/)
+            encoder.end_group :string
+          else
+            states.push match == "'" ? :sqstring : :dqstring
+          end
+          
+        elsif match = scan(/#{RE::Function}/o)
+          encoder.begin_group :function
+          start = match[/^[-\w]+\(/]
+          encoder.text_token start, :delimiter
+          if match[-1] == ?)
+            encoder.text_token match[start.size..-2], :content
+            encoder.text_token ')', :delimiter
+          else
+            encoder.text_token match[start.size..-1], :content if start.size < match.size
+          end
+          encoder.end_group :function
+          
+        elsif match = scan(/[a-z][-a-z_]*(?=\()/o)
+          encoder.text_token match, :predefined
+          
+        elsif match = scan(/(?: #{RE::Dimension} | #{RE::Percentage} | #{RE::Num} )/ox)
+          encoder.text_token match, :float
+          
+        elsif match = scan(/#{RE::HexColor}/o)
+          encoder.text_token match, :color
+          
+        elsif match = scan(/! *(?:important|optional)/)
+          encoder.text_token match, :important
+          
+        elsif match = scan(/(?:rgb|hsl)a?\([^()\n]*\)?/)
+          encoder.text_token match, :color
+          
+        elsif match = scan(/@else if\b|#{RE::AtKeyword}/o)
+          encoder.text_token match, :directive
+          value_expected = true
+          
+        elsif match = scan(/ == | != | [-+*\/>~:;,.=()] /x)
+          if match == ':'
+            value_expected = true
+          elsif match == ';'
+            value_expected = false
+          end
+          encoder.text_token match, :operator
+          
+        else
+          encoder.text_token getch, :error
+          
+        end
+        
+      end
+      
+      states.pop if states.last == :include
+      
+      if options[:keep_state]
+        @state = states.dup
+      end
+      
+      while state = states.pop
+        if state == :sass_inline
+          encoder.end_group :inline
+        elsif state == :sqstring || state == :dqstring
+          encoder.end_group :string
+        end
+      end
+      
+      encoder
+    end
+    
+  end
+  
+end
+end