rouge 2.0.2 → 2.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 58d67e05c1ce7c2db44d5ce537e17a233f77148b
-  data.tar.gz: 879be7fc4c49e621e7c88107138bf44a2d43f8b6
+  metadata.gz: 93043d4d750807111180be1a7d6582d7d8338470
+  data.tar.gz: 9b99367f2a290e9c4c0a040142866a641bb06803
 SHA512:
-  metadata.gz: 54fbeee82ad363f158c292fbf3140befa2a8a5164f73d167ecdf3e1f012956e958137ec77f5d4bb539e707e6e4db0111d513d2a6042b991a43f32e9755885ae0
-  data.tar.gz: df96e836f4254a16ad9acbe5a3612dff4ec0c309365b546334eb87179f7cff604f536e664c8e3b31ecab7cb969c56004f8473b0722ffab325105bb0e11c324e3
+  metadata.gz: 302965016c0054702b7a0e97c1d8fecb6a755ae4957e127870e2d6eecd4131d8589e4f20b6c44b751edcceb0d3030cdfa27004ac9388d6b44e72b0133451a6f9
+  data.tar.gz: 52de7875d8d80e34c93cec6c86afdf8292bebfeabcac389a746c18b95bd46bb070b9410020ca609bd4beec241fdf243a07792cc927a4b7832254005f007c40c1

data/lib/rouge.rb

@@ -6,6 +6,11 @@ require 'pathname'
 # The containing module for Rouge
 module Rouge
   class << self
+    def reload!
+      Object.send :remove_const, :Rouge
+      load __FILE__
+    end
+
     # Highlight some text with a given lexer and formatter.
     #
     # @example

data/lib/rouge/demos/tulip

@@ -1,14 +1,13 @@
-# ref.tlp
 @module ref
 
-ref value = Instance (spawn [! loop value ])
+ref value = Ref (spawn [ ! => loop value ])
 
 loop value = receive [
   .set new-value => loop new-value
-  p, .get => (send p value; loop value)
+  p, id, .get => { send p (id, value); loop value }
 ]
 
-@module Instance pid [
+@object Ref pid [
   set val = .set val > send pid
   get! = .get > send-wait pid
 ]

data/lib/rouge/formatters/html_pygments.rb

@@ -7,7 +7,7 @@ module Rouge
       end
 
       def stream(tokens, &b)
-        yield %<<pre class="#@css_class"><code>>
+        yield %(<pre class="#{@css_class}"><code>)
         @inner.stream(tokens, &b)
         yield "</code></pre>"
       end

data/lib/rouge/formatters/html_table.rb

@@ -41,16 +41,16 @@ module Rouge
           sprintf("#{@line_format}", i) << "\n"
         end.join('')
 
-        numbers = %<<pre class="lineno">#{formatted_line_numbers}</pre>>
+        numbers = %(<pre class="lineno">#{formatted_line_numbers}</pre>)
 
-        yield %<<table class="#@table_class"><tbody><tr>>
+        yield %(<table class="#@table_class"><tbody><tr>)
 
         # the "gl" class applies the style for Generic.Lineno
-        yield %<<td class="#@gutter_class gl">>
+        yield %(<td class="#@gutter_class gl">)
         yield numbers
         yield '</td>'
 
-        yield %<<td class="#@code_class"><pre>>
+        yield %(<td class="#@code_class"><pre>)
         yield formatted
         yield '</pre></td>'
 

data/lib/rouge/guesser.rb

@@ -1,5 +1,14 @@
 module Rouge
   class Guesser
+    class Ambiguous < StandardError
+      attr_reader :alternatives
+      def initialize(alternatives); @alternatives = alternatives; end
+
+      def message
+        "Ambiguous guess: can't decide between #{alternatives.map(&:tag).inspect}"
+      end
+    end
+
     def self.guess(guessers, lexers)
       original_size = lexers.size
 

data/lib/rouge/lexer.rb

@@ -122,15 +122,6 @@ module Rouge
         Guesser.guess(guessers, Lexer.all)
       end
 
-      class AmbiguousGuess < StandardError
-        attr_reader :alternatives
-        def initialize(alternatives); @alternatives = alternatives; end
-
-        def message
-          "Ambiguous guess: can't decide between #{alternatives.map(&:tag).inspect}"
-        end
-      end
-
       # Guess which lexer to use based on a hash of info.
       #
       # @option info :mimetype
@@ -150,7 +141,7 @@ module Rouge
         return Lexers::PlainText if lexers.empty?
         return lexers[0] if lexers.size == 1
 
-        raise AmbiguousGuess.new(lexers)
+        raise Guesser::Ambiguous.new(lexers)
       end
 
       def guess_by_mimetype(mt)

data/lib/rouge/lexers/markdown.rb

@@ -46,7 +46,7 @@ module Rouge
 
         rule /\n\n((    |\t).*?\n|\n)+/, Str::Backtick
 
-        rule /(`+)#{edot}*\1/, Str::Backtick
+        rule /(`+)#{edot}+?\1/, Str::Backtick
 
         # various uses of * are in order of precedence
 

data/lib/rouge/lexers/php.rb

@@ -90,7 +90,7 @@ module Rouge
         end
 
         rule /[~!%^&*+=\|:.<>\/?@-]+/, Operator
-        rule /[\[\]{}();,]+/, Punctuation
+        rule /[\[\]{}();,]/, Punctuation
         rule /class\b/, Keyword, :classname
         # anonymous functions
         rule /(function)(\s*)(?=\()/ do

data/lib/rouge/lexers/praat.rb

@@ -37,7 +37,7 @@ module Rouge
         demoOptionKeyPressed demoShiftKeyPressed demoShow demoWaitForInput
         demoWindowTitle demoX demoY differenceLimensToPhon do editor endPause
         endSendPraat endsWith erb erbToHertz erf erfc exitScript exp
-        extractNumber fileReadable fisherP fisherQ floor gaussP gaussQ
+        extractNumber fileReadable fisherP fisherQ floor gaussP gaussQ hash
         hertzToBark hertzToErb hertzToMel hertzToSemitones imax imin
         incompleteBeta incompleteGammaP index index_regex integer invBinomialP
         invBinomialQ invChiSquareQ invFisherQ invGaussQ invSigmoid invStudentQ
@@ -104,12 +104,21 @@ module Rouge
           groups Text, Comment::Single
         end
 
-        rule /^#.*?$/,        Comment::Single
-        rule /;[^\n]*/,       Comment::Single
-        rule /\s+/,           Text
-        rule /\bprocedure\b/, Keyword,        :procedure_definition
-        rule /\bcall\b/,      Keyword,        :procedure_call
-        rule /@/,             Name::Function, :procedure_call
+        rule /^#.*?$/,         Comment::Single
+        rule /;[^\n]*/,        Comment::Single
+        rule /\s+/,            Text
+
+        rule /(\bprocedure)(\s+)/ do
+          groups Keyword, Text
+          push :procedure_definition
+        end
+
+        rule /(\bcall)(\s+)/ do
+          groups Keyword, Text
+          push :procedure_call
+        end
+
+        rule /@/,              Name::Function, :procedure_call
 
         mixin :function_call
 
@@ -142,7 +151,7 @@ module Rouge
       end
 
       state :command do
-        rule /( ?[\w()-]+ ?)/, Keyword
+        rule /( ?([^\s:\.'])+ ?)/, Keyword
         mixin :string_interpolated
 
         rule /\.{3}/ do
@@ -161,32 +170,26 @@ module Rouge
       end
 
       state :procedure_call do
-        rule /\s+/, Text
+        mixin :string_interpolated
 
-        rule /([\w.]+)(:|\s*\()/ do
-          groups Name::Function, Punctuation
-          pop!
-        end
+        rule /(:|\s*\()/, Punctuation, :pop!
 
-        rule /([\w.]+)/ do
-          token Name::Function
+        rule /'/,            Name::Function
+        rule /[^:\('\n\s]+/, Name::Function
+
+        rule /(?=\s+)/ do
+          token Text
           pop!
           push :old_arguments
         end
       end
 
       state :procedure_definition do
-        rule /\s/, Text
+        rule /(:|\s*\()/, Punctuation, :pop!
 
-        rule /([\w.]+)(\s*?[(:])/ do
-          groups Name::Function, Text
-          pop!
-        end
+        rule /[^:\(\n\s]+/, Name::Function
 
-        rule /([\w.]+)([^\n]*)/ do
-          groups Name::Function, Text
-          pop!
-        end
+        rule /(\s+)/, Text, :pop!
       end
 
       state :function_call do

data/lib/rouge/lexers/ruby.rb

@@ -202,14 +202,6 @@ module Rouge
         rule /(?<!\.)(?:#{builtins_g.join('|')})\b/,
           Name::Builtin, :method_call
 
-        # char operator.  ?x evaulates to "x", unless there's a digit
-        # beforehand like x>=0?n[x]:""
-        rule %r(
-          [?](\\[MC]-)*     # modifiers
-          (\\([\\abefnrstv\#"']|x[a-fA-F0-9]{1,2}|[0-7]{1,3})|\S)
-          (?!\w)
-        )x, Str::Char
-
         mixin :has_heredocs
 
         rule /[A-Z][a-zA-Z0-9_]*/, Name::Constant, :method_call
@@ -223,7 +215,8 @@ module Rouge
         rule /\*\*|<<?|>>?|>=|<=|<=>|=~|={3}|!~|&&?|\|\||\.{1,3}/,
           Operator, :expr_start
         rule /[-+\/*%=<>&!^|~]=?/, Operator, :expr_start
-        rule %r<[\[({,?:\\;/]>, Punctuation, :expr_start
+        rule(/[?]/) { token Punctuation; push :ternary; push :expr_start }
+        rule %r<[\[({,:\\;/]>, Punctuation, :expr_start
         rule %r<[\])}]>, Punctuation
       end
 
@@ -313,6 +306,12 @@ module Rouge
         rule(//) { pop! }
       end
 
+      state :ternary do
+        rule(/:(?!:)/) { token Punctuation; goto :expr_start }
+
+        mixin :root
+      end
+
       state :defexpr do
         rule /(\))(\.|::)?/ do
           groups Punctuation, Operator
@@ -350,6 +349,8 @@ module Rouge
           goto :expr_start
         end
 
+        rule(/(?=\n)/) { pop! }
+
         rule(//) { goto :method_call_spaced }
       end
 
@@ -382,6 +383,14 @@ module Rouge
           goto :slash_regex
         end
 
+        # char operator.  ?x evaulates to "x", unless there's a digit
+        # beforehand like x>=0?n[x]:""
+        rule %r(
+          [?](\\[MC]-)*     # modifiers
+          (\\([\\abefnrstv\#"']|x[a-fA-F0-9]{1,2}|[0-7]{1,3})|\S)
+          (?!\w)
+        )x, Str::Char, :pop!
+
         # special case for using a single space.  Ruby demands that
         # these be in a single line, otherwise it would make no sense.
         rule /(\s*)(%[rqswQWxiI]? \S* )/ do

data/lib/rouge/lexers/tulip.rb

@@ -1,73 +1,75 @@
 module Rouge
   module Lexers
     class Tulip < RegexLexer
+      desc 'the tulip programming language (twitter.com/tuliplang)'
       tag 'tulip'
-      aliases 'tlp'
+      aliases 'tulip'
+
       filenames '*.tlp'
-      desc 'The tulip programming language http://github.com/jneen/tulip'
 
-      id = /\w[\w-]*/
+      mimetypes 'text/x-tulip', 'application/x-tulip'
 
       def self.analyze_text(text)
-        return 1 if text.shebang?('tulip')
+        return 1 if text.shebang? 'tulip'
+        return 0
       end
 
-      state :root do
+      id = /[a-z][\w-]*/i
+      upper_id = /[A-Z][\w-]*/
+
+      state :comments_and_whitespace do
         rule /\s+/, Text
-        rule /#.*?\n/, Comment
-        rule /%#{id}/, Keyword::Type
+        rule /#.*?$/, Comment
+      end
+
+      state :root do
+        mixin :comments_and_whitespace
+
         rule /@#{id}/, Keyword
-        rule /[.][.]?#{id}/, Name::Label
-        rule /-#{id}[?]?/, Str::Symbol
-        rule /\d+/, Num
-        rule %r(/#{id}?), Name::Decorator
-        rule %r((#{id}/)(#{id})) do
-          groups Name::Namespace, Name::Variable
+
+
+        rule /[>,!\[\]:{}()=;\/]/, Punctuation
+
+        rule /(\\#{id})([{])/ do
+          groups Name::Variable, Str
+          push :nested_string
         end
 
-        rule /"{/, Str, :string_interp
-        rule /'?{/, Str, :string
-        rule /['"][^\s)\]]+/, Str
+        rule /\\#{id}/, Name::Function
 
-        rule /[$]/, Name::Variable
+        rule /"/, Str, :dq
 
-        rule /[-+:;~!()\[\]=?>|_%,]/, Punctuation
-        rule /[.][.][.]/, Punctuation
-        rule id, Name
-      end
+        rule /'{/, Str, :nested_string
 
-      state :string_base do
-        rule /{/ do
-          token Str; push
-        end
+        rule /[.]#{id}/, Name::Tag
+        rule /[$]#{id}/, Name::Variable
 
-        rule /}/, Str, :pop!
-        rule /[$]/, Str
-        rule /[^${}\\]+/, Str
-      end
+        rule /[0-9]+([.][0-9]+)?/, Num
 
-      state :string do
-        mixin :string_base
-        rule /\\/, Str
-      end
+        rule /#{id}/, Name
 
-      state :interp do
-        rule(/[(]/) { token Punctuation; push }
-        rule /[)]/, Punctuation, :pop!
-        mixin :root
+        rule /</, Comment::Preproc, :angle_brackets
       end
 
-      state :interp_root do
-        rule /[(]/, Str::Interpol, :interp
-        rule /[)]/, Str::Interpol, :pop!
-        mixin :root
+      state :dq do
+        rule /[^\\"]+/, Str
+        rule /"/, Str, :pop!
+        rule /\\./, Str::Escape
       end
 
-      state :string_interp do
+      state :nested_string do
         rule /\\./, Str::Escape
-        rule /[$][(]/, Str::Interpol, :interp_root
-        rule /[$]#{id}?/, Name::Variable
-        mixin :string_base
+        rule(/{/) { token Str; push :nested_string }
+        rule(/}/) { token Str; pop! }
+        rule(/[^{}\\]+/) { token Str }
+      end
+
+      state :angle_brackets do
+        mixin :comments_and_whitespace
+        rule />/, Comment::Preproc, :pop!
+        rule /[*:]/, Punctuation
+        rule /#{upper_id}/, Keyword::Type
+        rule /#{id}/, Name::Variable
       end
     end
   end

data/lib/rouge/regex_lexer.rb

@@ -109,7 +109,7 @@ module Rouge
           proc do |stream|
             puts "    yielding #{tok.qualname}, #{stream[0].inspect}" if @debug
             @output_stream.call(tok, stream[0])
-            puts "    pushing #{@stack.last.name}" if @debug
+            puts "    pushing :#{@stack.last.name}" if @debug
             @stack.push(@stack.last)
           end
         when Symbol
@@ -117,7 +117,7 @@ module Rouge
             puts "    yielding #{tok.qualname}, #{stream[0].inspect}" if @debug
             @output_stream.call(tok, stream[0])
             state = @states[next_state] || self.class.get_state(next_state)
-            puts "    pushing #{state.name}" if @debug
+            puts "    pushing :#{state.name}" if @debug
             @stack.push(state)
           end
         when nil
@@ -261,7 +261,7 @@ module Rouge
       until stream.eos?
         if @debug
           puts "lexer: #{self.class.tag}"
-          puts "stack: #{stack.map(&:name).inspect}"
+          puts "stack: #{stack.map(&:name).map(&:to_sym).inspect}"
           puts "stream: #{stream.peek(20).inspect}"
         end
 
@@ -385,7 +385,7 @@ module Rouge
         self.state
       end
 
-      puts "    pushing #{push_state.name}" if @debug
+      puts "    pushing :#{push_state.name}" if @debug
       stack.push(push_state)
     end
 
@@ -405,7 +405,7 @@ module Rouge
     def goto(state_name)
       raise 'empty stack!' if stack.empty?
 
-      puts "    going to state #{state_name} " if @debug
+      puts "    going to state :#{state_name} " if @debug
       stack[-1] = get_state(state_name)
     end
 

data/lib/rouge/version.rb

@@ -2,6 +2,6 @@
 
 module Rouge
   def self.version
-    "2.0.2"
+    "2.0.3"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rouge
 version: !ruby/object:Gem::Version
-  version: 2.0.2
+  version: 2.0.3
 platform: ruby
 authors:
 - Jeanine Adkisson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-27 00:00:00.000000000 Z
+date: 2016-07-14 00:00:00.000000000 Z
 dependencies: []
 description: Rouge aims to a be a simple, easy-to-extend drop-in replacement for pygments.
 email: