rouge 1.4.0 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7271e7e935f4e3a5e38187c5d53cd71578453f30
-  data.tar.gz: 1bd9cdf5744f515565f86602c0d6ac7b382d1afc
+  metadata.gz: f56238615c98f486c5d3cd978aac53f45e6bb2ee
+  data.tar.gz: 4659578e0b792daf6e8ad9085a4d2dd0312d5749
 SHA512:
-  metadata.gz: 4d8b40f7d369bab8e223ffa6cbea7742a707e849e9dc3f11a88eb30fd6c23accaf2b43a9176bdeae1cf671901fc61f9379897c220e0d0fc2ec124e2a851d07fe
-  data.tar.gz: 4a4541ed068a997755964649ed02d56e332609877f1282d4ded0e84073fb867ae14021470f9bf6e8740885f71ead3f8b551028dc0cfd80c1266c49b1d1f9a248
+  metadata.gz: 97d1c64beea24ce75095a5f2975ff3aa8d902725120f4022ed69b3ac29681cd9e6e61ff88f44ec65733d7795f1a00ae17594e8d5d23ef4419570d1d50c43331e
+  data.tar.gz: b43ec6cbb46295bca0cd5185b1e21202c1583c10f6b0fb447c9ae5d53e5d5469dd0dbde18d13ecfc2044033cc0afd6b45055b2fe44cd11d05d635222b53a0ee0

data/lib/rouge/demos/swift

@@ -0,0 +1,5 @@
+// Say hello to poeple
+func sayHello(personName: String) -> String {
+    let greeting = "Hello, " + personName + "!"
+    return greeting
+}

data/lib/rouge/formatters/terminal256.rb

@@ -19,7 +19,7 @@ module Rouge
         tokens.each do |tok, val|
           escape = escape_sequence(tok)
           yield escape.style_string
-          yield val
+          yield val.gsub("\n", "\n#{escape.style_string}")
           yield escape.reset_string
         end
       end
@@ -126,11 +126,14 @@ module Rouge
           hexes.map { |h| h.to_i(16) }
         end
 
+        # max distance between two colors, #000000 to #ffffff
+        MAX_DISTANCE = 257 * 257 * 3
+
         def self.closest_color(r, g, b)
           @@colors_cache ||= {}
           key = (r << 16) + (g << 8) + b
           @@colors_cache.fetch(key) do
-            distance = 257 * 257 * 3 # (max distance, from #000000 to #ffffff)
+            distance = MAX_DISTANCE
 
             match = 0
 

data/lib/rouge/lexers/elixir.rb

@@ -29,8 +29,8 @@ module Rouge
         rule /(?<!\.)\b(and|not|or|when|xor|in)\b/, Operator::Word
         rule %r{%=|\*=|\*\*=|\+=|\-=|\^=|\|\|=|
              <=>|<(?!<|=)|>(?!<|=|>)|<=|>=|===|==|=~|!=|!~|(?=[\s\t])\?|
-             (?<=[\s\t])!+|&&|\|\||\^|\*|\+|\-|/|
-             \||\+\+|\-\-|\*\*|\/\/|\<\-|\<\>|<<|>>|=|\.}x, Operator
+             (?<=[\s\t])!+|&(&&?|(?!\d))|\|\||\^|\*|\+|\-|/|
+             \||\+\+|\-\-|\*\*|\/\/|\<\-|\<\>|<<|>>|=|\.|~~~}x, Operator
         rule %r{(?<!:)(:)([a-zA-Z_]\w*([?!]|=(?![>=]))?|\<\>|===?|>=?|<=?|
              <=>|&&?|%\(\)|%\[\]|%\{\}|\+\+?|\-\-?|\|\|?|\!|//|[%&`/\|]|
              \*\*?|=?~|<\-)|([a-zA-Z_]\w*([?!])?)(:)(?!:)}, Str::Symbol
@@ -38,11 +38,11 @@ module Rouge
         rule /\b(nil|true|false)\b(?![?!])|\b[A-Z]\w*\b/, Name::Constant
         rule /\b(__(FILE|LINE|MODULE|MAIN|FUNCTION)__)\b(?![?!])/, Name::Builtin::Pseudo
         rule /[a-zA-Z_!][\w_]*[!\?]?/, Name
-        rule %r{::|[(){};,/\|:\\\[\]]}, Punctuation
+        rule %r{::|[%(){};,/\|:\\\[\]]}, Punctuation
         rule /@[a-zA-Z_]\w*|&\d/, Name::Variable
         rule %r{\b(0[xX][0-9A-Fa-f]+|\d(_?\d)*(\.(?![^\d\s])
              (_?\d)*)?([eE][-+]?\d(_?\d)*)?|0[bB][01]+)\b}x, Num
-        rule %r{%r\/.*\/}, Str::Regex
+        rule %r{~r\/.*\/}, Str::Regex
 
         mixin :strings
       end

data/lib/rouge/lexers/objective_c.rb

@@ -14,7 +14,7 @@ module Rouge
         @at_keywords ||= %w(
           selector private protected public encode synchronized try
           throw catch finally end property synthesize dynamic optional
-          interface implementation
+          interface implementation import
         )
       end
 

data/lib/rouge/lexers/ruby.rb

@@ -196,18 +196,18 @@ module Rouge
         mixin :has_heredocs
 
         rule /[A-Z][a-zA-Z0-9_]+/, Name::Constant, :method_call
-        rule /(\.|::)([a-z_]\w*[!?]?|[*%&^`~+-\/\[<>=])/ do
-          groups Punctuation, Name::Function
+        rule /(\.|::)(\s*)([a-z_]\w*[!?]?|[*%&^`~+-\/\[<>=])/ do
+          groups Punctuation, Text, Name::Function
           push :expr_start
         end
 
         rule /[a-zA-Z_]\w*[?!]/, Name, :expr_start
         rule /[a-zA-Z_]\w*/, Name, :method_call
-        rule /\[|\]|\*\*|<<?|>>?|>=|<=|<=>|=~|={3}|!~|&&?|\|\||\.{1,3}/,
+        rule /\*\*|<<?|>>?|>=|<=|<=>|=~|={3}|!~|&&?|\|\||\.{1,3}/,
           Operator, :expr_start
         rule /[-+\/*%=<>&!^|~]=?/, Operator, :expr_start
-        rule %r<[({,?:\\;/]>, Punctuation, :expr_start
-        rule %r<[)}]>, Punctuation
+        rule %r<[\[({,?:\\;/]>, Punctuation, :expr_start
+        rule %r<[\])}]>, Punctuation
       end
 
       state :has_heredocs do

data/lib/rouge/lexers/swift.rb

@@ -0,0 +1,128 @@
+# encoding: utf-8
+
+module Rouge
+  module Lexers
+    class Swift < RegexLexer
+      tag 'swift'
+      filenames '*.swift'
+
+      desc 'Multi paradigm, compiled programming language developed by Apple for iOS and OS X development. (developer.apple.com/swift)'
+
+      id_head = /_|(?!\p{Mc})\p{Alpha}|[^\u0000-\uFFFF]/
+      id_rest = /[\p{Alnum}_]|[^\u0000-\uFFFF]/
+      id = /#{id_head}#{id_rest}*/
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          break case continue default do else fallthrough if in for return switch where while
+
+          as dynamicType is new super self Self Type __COLUMN__ __FILE__ __FUNCTION__ __LINE__
+
+          associativity didSet get infix inout left mutating none nonmutating operator override postfix precedence prefix right set unowned unowned(safe) unowned(unsafe) weak willSet
+        )
+      end
+
+      def self.declarations
+        @declarations ||= Set.new %w(
+          class deinit enum extension func import init let protocol static struct subscript typealias var
+        )
+      end
+
+      def self.types
+        @types ||= Set.new %w(
+          Int8 Int16 Int32 Int64 UInt8 UInt16 UInt32 UInt64 Int
+          Double Float
+          Bool
+          String Character
+        )
+      end
+
+      def self.constants
+        @constants ||= Set.new %w(
+          true false nil
+        )
+      end
+
+      state :whitespace do
+        rule /\s+/m, Text
+        rule %r(\/\/.*?\n), Comment::Single
+        rule %r((?<re>\/\*(?:(?>[^\/\*\*\/]+)|\g<re>)*\*\/))m, Comment::Multiline
+      end
+
+      state :root do
+        mixin :whitespace
+        rule /\$(([1-9]\d*)?\d)/, Name::Variable
+
+        rule %r{[()\[\]{}:;,?]}, Punctuation
+        rule %r([-/=+*%<>!&|^.~]+), Operator
+        rule /@?"/, Str, :dq
+        rule /'(\\.|.)'/, Str::Char
+        rule /(\d+\*|\d*\.\d+)(e[+-]?[0-9]+)?/i, Num::Float
+        rule /\d+e[+-]?[0-9]+/i, Num::Float
+        rule /0_?[0-7]+(?:_[0-7]+)*/, Num::Oct
+        rule /0x[0-9A-Fa-f]+(?:_[0-9A-Fa-f]+)*/, Num::Hex
+        rule /0b[01]+(?:_[01]+)*/, Num::Bin
+        rule %r{[\d]+(?:_\d+)*}, Num::Integer
+
+        rule /(?!\b(if|while|for)\b)\b#{id}(?=\s*[(])/, Name::Function
+
+        rule /(#?#{id})(\s*)(:)/ do
+          groups Name::Variable, Text, Punctuation
+        end
+
+        rule /(let|var)\b(\s*)(#{id})/ do
+          groups Keyword, Text, Name::Variable
+        end
+
+        rule id do |m|
+          if self.class.keywords.include? m[0]
+            token Keyword
+          elsif self.class.declarations.include? m[0]
+            token Keyword::Declaration
+          elsif self.class.types.include? m[0]
+            token Keyword::Type
+          elsif self.class.constants.include? m[0]
+            token Keyword::Constant
+          else
+            token Name
+          end
+        end
+        rule id, Name
+      end
+
+      state :dq do
+        rule /\\[\\0tnr'"]/, Str::Escape
+        rule /\\[(]/, Str::Escape, :interp
+        rule /\\x\h{2}/, Str::Escape
+        rule /\\u\h{4}/, Str::Escape
+        rule /\\U\h{8}/, Str::Escape
+        rule /[^\\"]+/, Str
+        rule /"/, Str, :pop!
+      end
+
+      state :interp do
+        rule /[(]/, Punctuation, :interp_inner
+        rule /[)]/, Str::Escape, :pop!
+        mixin :root
+      end
+
+      state :interp_inner do
+        rule /[(]/, Punctuation, :push
+        rule /[)]/, Punctuation, :pop!
+        mixin :root
+      end
+
+      state :class do
+        mixin :whitespace
+        rule id, Name::Class, :pop!
+      end
+
+      state :namespace do
+        mixin :whitespace
+        rule /(?=[(])/, Text, :pop!
+        rule /(#{id}|[.])+/, Name::Namespace, :pop!
+      end
+
+    end
+  end
+end

data/lib/rouge/theme.rb

@@ -90,7 +90,11 @@ module Rouge
       end
 
       def get_style(token)
-        get_own_style(token) || styles[Token::Tokens::Text]
+        get_own_style(token) || base_style
+      end
+
+      def base_style
+        styles[Token::Tokens::Text]
       end
 
       def name(n=nil)
@@ -148,6 +152,10 @@ module Rouge
       end
     end
 
+    def render_base(selector, &b)
+      self.class.base_style.render(selector, &b)
+    end
+
     def style_for(tok)
       self.class.get_style(tok)
     end

data/lib/rouge/version.rb

@@ -1,5 +1,5 @@
 module Rouge
   def self.version
-    "1.4.0"
+    "1.5.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rouge
 version: !ruby/object:Gem::Version
-  version: 1.4.0
+  version: 1.5.0
 platform: ruby
 authors:
 - Jay Adkisson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-29 00:00:00.000000000 Z
+date: 2014-07-12 00:00:00.000000000 Z
 dependencies: []
 description: Rouge aims to a be a simple, easy-to-extend drop-in replacement for pygments.
 email:
@@ -82,6 +82,7 @@ files:
 - lib/rouge/demos/smalltalk
 - lib/rouge/demos/sml
 - lib/rouge/demos/sql
+- lib/rouge/demos/swift
 - lib/rouge/demos/tcl
 - lib/rouge/demos/tex
 - lib/rouge/demos/toml
@@ -157,6 +158,7 @@ files:
 - lib/rouge/lexers/smalltalk.rb
 - lib/rouge/lexers/sml.rb
 - lib/rouge/lexers/sql.rb
+- lib/rouge/lexers/swift.rb
 - lib/rouge/lexers/tcl.rb
 - lib/rouge/lexers/tex.rb
 - lib/rouge/lexers/toml.rb
@@ -199,8 +201,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: rouge
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A pure-ruby colorizer based on pygments
 test_files: []
+has_rdoc: