rouge 4.2.0 → 4.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a3281f8cbea5fa288016ada176d8fd748d2426af2f6a02a49c4f519ae4a385c9
-  data.tar.gz: a0e5aae51677fa27c6c448d3d617b0f4748934ad267dc0be49b705e2fc89f93b
+  metadata.gz: de3a38233be791cfb87fbcee4e092afc1731ed4c2ac0bd9f4e8eb8d889a262c4
+  data.tar.gz: 81d1cf226f514155b861b1f127e55ffdf7cf9d40e2a8c8fa1ee5cd211052aeb0
 SHA512:
-  metadata.gz: 3fe33d5d2a60be45a82839227de784d92440a99c77e700d55cba412f1d8a2cb5b516013bd92f7db62f88a25fa6aee8bdd65415cd9c2203c1e4a1538549d7a1a7
-  data.tar.gz: 1b4598ed31db53da50a79e5aeaff8eca539c91dd7102b07a7e1106c4bd050071e689fb21a4d435b2e8d465cb91ae8a9275a91d777509961a6c95739e1ecc8d76
+  metadata.gz: 3ba279624b6990706218bced834a373cd4d5a15a487c862b07cc7042a924b429cad7518bea407f8ca85bda087395f1fa15abb231f0dd9ff0faa3b2b5e7cb108a
+  data.tar.gz: 93021b4af8761ddc54e22038b6926b7522f67c70c1ba0e7ebdb76ccb21375760f23efe4ebc9c4000bf3bba73499476fb9832596ac3f8eeca5f6f6f626e15069d

data/Gemfile

@@ -10,22 +10,22 @@ gem 'minitest', '>= 5.0'
 gem 'minitest-power_assert'
 gem 'power_assert', '~> 2.0'
 
-gem 'rubocop', '~> 1.0', '<= 1.11'
-gem 'rubocop-performance'
-
 # don't try to install redcarpet under jruby
 gem 'redcarpet', platforms: :ruby
 
 # Profiling
 gem 'memory_profiler', require: false
 
-# Needed for a Rake task
-gem 'git'
-gem 'yard'
-
 group :development do
   gem 'pry'
 
+  # Needed for a Rake task
+  gem 'git'
+  gem 'yard'
+
+  gem 'rubocop', '~> 1.0', '<= 1.11'
+  gem 'rubocop-performance'
+
   # docs
   gem 'github-markup'
 

data/lib/rouge/cli.rb

@@ -347,8 +347,7 @@ module Rouge
         formatter.format(lexer.lex(input), &method(:print))
       end
 
-    private_class_method
-      def self.parse_cgi(str)
+    private_class_method def self.parse_cgi(str)
         pairs = CGI.parse(str).map { |k, v| [k.to_sym, v.first] }
         Hash[pairs]
       end
@@ -511,8 +510,7 @@ module Rouge
     end
 
 
-  private_class_method
-    def self.normalize_syntax(argv)
+  private_class_method def self.normalize_syntax(argv)
       out = []
       argv.each do |arg|
         case arg

data/lib/rouge/demos/iecst

@@ -0,0 +1,21 @@
+// first-order lag derivative term
+(*
+  Parameter K must be set to T / (T + T1)
+*)
+FUNCTION_BLOCK DT2
+
+VAR_INPUT
+  IN : REAL;
+  K : REAL;
+END_VAR
+VAR_OUTPUT
+  Q : REAL;
+END_VAR
+VAR
+  H : REAL := 0.0;
+END_VAR
+
+BEGIN
+  Q := IN - H;
+  H := H + K * Q;
+END_FUNCTION_BLOCK

data/lib/rouge/guessers/disambiguation.rb

@@ -140,12 +140,17 @@ module Rouge
 
         Puppet
       end
-      
+
       disambiguate '*.p' do
         next Prolog if contains?(':-')
         next Prolog if matches?(/\A\w+(\(\w+\,\s*\w+\))*\./)
         next OpenEdge
       end
+
+      disambiguate '*.st' do
+        next IecST if matches?(/^\s*END_/i)
+        next Smalltalk
+      end
     end
   end
 end

data/lib/rouge/lexers/ada.rb

@@ -155,7 +155,7 @@ module Rouge
         end
 
         # Flag word-like things that don't match the ID pattern.
-        rule %r{\b(\p{Pc}|[[alpha]])\p{Word}*}, Error
+        rule %r{\b(\p{Pc}|[[:alpha:]])\p{Word}*}, Error
       end
     end
   end

data/lib/rouge/lexers/brainfuck.rb

@@ -9,6 +9,7 @@ module Rouge
       mimetypes 'text/x-brainfuck'
 
       title "Brainfuck"
+      aliases "bf"
       desc "The Brainfuck programming language"
 
       start { push :bol }

data/lib/rouge/lexers/clean.rb

@@ -79,7 +79,7 @@ module Rouge
 
         rule %r/code(\s+inline)?\s*{/, Comment::Preproc, :abc
 
-        rule %r/_*[a-z][\w_`]*/ do |m|
+        rule %r/_*[a-z][\w`]*/ do |m|
           if self.class.keywords.include?(m[0])
             token Keyword
           else
@@ -87,7 +87,7 @@ module Rouge
           end
         end
 
-        rule %r/_*[A-Z][\w_`]*/ do |m|
+        rule %r/_*[A-Z][\w`]*/ do |m|
           if m[0]=='True' || m[0]=='False'
             token Keyword::Constant
           else
@@ -95,7 +95,7 @@ module Rouge
           end
         end
 
-        rule %r/[^\w_\s`]/, Punctuation
+        rule %r/[^\w\s`]/, Punctuation
         rule %r/_\b/, Punctuation
       end
 
@@ -136,7 +136,7 @@ module Rouge
 
         rule %r/}/, Comment::Preproc, :pop!
         rule %r/\.\w*/, Keyword, :abc_rest_of_line
-        rule %r/[\w_]+/, Name::Builtin, :abc_rest_of_line
+        rule %r/[\w]+/, Name::Builtin, :abc_rest_of_line
       end
 
       state :abc_rest_of_line do

data/lib/rouge/lexers/cpp.rb

@@ -27,7 +27,7 @@ module Rouge
           delete dynamic_cast explicit export friend
           mutable namespace new operator private protected public
           reinterpret_cast requires restrict size_of static_cast this throw throws
-          typeid typename using virtual final override
+          typeid typename using virtual final override import module
 
           alignas alignof decltype noexcept static_assert
           thread_local try

data/lib/rouge/lexers/crystal.rb

@@ -21,7 +21,7 @@ module Rouge
         rule %r(
           :  # initial :
           @{0,2} # optional ivar, for :@foo and :@@foo
-          [a-z_]\w*[!?]? # the symbol
+          [\p{Ll}_]\p{Word}*[!?]? # the symbol
         )xi, Str::Symbol
 
         # special symbols
@@ -35,7 +35,7 @@ module Rouge
         # %-sigiled strings
         # %(abc), %[abc], %<abc>, %.abc., %r.abc., etc
         delimiter_map = { '{' => '}', '[' => ']', '(' => ')', '<' => '>' }
-        rule %r/%([rqswQWxiI])?([^\w\s}])/ do |m|
+        rule %r/%([rqswQWxiI])?([^\p{Word}\s}])/ do |m|
           open = Regexp.escape(m[2])
           close = Regexp.escape(delimiter_map[m[2]] || m[2])
           interp = /[rQWxI]/ === m[1]
@@ -77,7 +77,7 @@ module Rouge
 
       state :strings do
         mixin :symbols
-        rule %r/\b[a-z_]\w*?[?!]?:\s+/, Str::Symbol, :expr_start
+        rule %r/\b[\p{Ll}_]\p{Word}*?[?!]?:\s+/, Str::Symbol, :expr_start
         rule %r/"/, Str::Double, :simple_string
         rule %r/(?<!\.)`/, Str::Backtick, :simple_backtick
         rule %r/(')(\\u[a-fA-F0-9]{4}|\\u\{[a-fA-F0-9]{1,6}\}|\\[abefnrtv])?(\\\\|\\'|[^'])*(')/ do
@@ -166,9 +166,9 @@ module Rouge
         rule %r/@\[([^\]]+)\]/, Name::Decorator
 
         # names
-        rule %r/@@[a-z_]\w*/i, Name::Variable::Class
-        rule %r/@[a-z_]\w*/i, Name::Variable::Instance
-        rule %r/\$\w+/, Name::Variable::Global
+        rule %r/@@[\p{Ll}_]\p{Word}*/i, Name::Variable::Class
+        rule %r/@[\p{Ll}_]\p{Word}*/i, Name::Variable::Instance
+        rule %r/\$\p{Word}+/, Name::Variable::Global
         rule %r(\$[!@&`'+~=/\\,;.<>_*\$?:"]), Name::Variable::Global
         rule %r/\$-[0adFiIlpvw]/, Name::Variable::Global
         rule %r/::/, Operator
@@ -181,7 +181,7 @@ module Rouge
         rule %r(
           (module)
           (\s+)
-          ([a-zA-Z_][a-zA-Z0-9_]*(::[a-zA-Z_][a-zA-Z0-9_]*)*)
+          ([\p{L}_][\p{L}0-9_]*(::[\p{L}_][\p{L}0-9_]*)*)
         )x do
           groups Keyword, Text, Name::Namespace
         end
@@ -207,14 +207,14 @@ module Rouge
         # Otherwise, they will be parsed as :method_call
         rule %r/\.{2,3}/, Operator, :expr_start
 
-        rule %r/[A-Z][a-zA-Z0-9_]*/, Name::Constant, :method_call
-        rule %r/(\.|::)(\s*)([a-z_]\w*[!?]?|[*%&^`~+-\/\[<>=])/ do
+        rule %r/[\p{Lu}][\p{L}0-9_]*/, Name::Constant, :method_call
+        rule %r/(\.|::)(\s*)([\p{Ll}_]\p{Word}*[!?]?|[*%&^`~+-\/\[<>=])/ do
           groups Punctuation, Text, Name::Function
           push :method_call
         end
 
-        rule %r/[a-zA-Z_]\w*[?!]/, Name, :expr_start
-        rule %r/[a-zA-Z_]\w*/, Name, :method_call
+        rule %r/[\p{L}_]\p{Word}*[?!]/, Name, :expr_start
+        rule %r/[\p{L}_]\p{Word}*/, Name, :method_call
         rule %r/\*\*|\/\/|>=|<=|<=>|<<?|>>?|=~|={3}|!~|&&?|\|\||\./,
           Operator, :expr_start
         rule %r/{%|%}/, Punctuation
@@ -225,7 +225,7 @@ module Rouge
       end
 
       state :has_heredocs do
-        rule %r/(?<!\w)(<<[-~]?)(["`']?)([a-zA-Z_]\w*)(\2)/ do |m|
+        rule %r/(?<!\p{Word})(<<[-~]?)(["`']?)([\p{L}_]\p{Word}*)(\2)/ do |m|
           token Operator, m[1]
           token Name::Constant, "#{m[2]}#{m[3]}#{m[4]}"
           @heredoc_queue << [['<<-', '<<~'].include?(m[1]), m[3]]
@@ -282,9 +282,9 @@ module Rouge
         rule %r/\s+/, Text
         rule %r/\(/, Punctuation, :defexpr
         rule %r(
-          (?:([a-zA-Z_]\w*)(\.))?
+          (?:([\p{L}_]\p{Word}*)(\.))?
           (
-            [a-zA-Z_]\w*[!?]? |
+            [\p{L}_]\p{Word}*[!?]? |
             \*\*? | [-+]@? | [/%&\|^`~] | \[\]=? |
             <<? | >>? | <=>? | >= | ===?
           )
@@ -311,7 +311,7 @@ module Rouge
           goto :expr_start
         end
 
-        rule %r/[A-Z_]\w*/, Name::Class, :pop!
+        rule %r/[\p{Lu}_]\p{Word}*/, Name::Class, :pop!
 
         rule(//) { pop! }
       end
@@ -343,7 +343,7 @@ module Rouge
 
       state :string_intp do
         rule %r/[#][{]/, Str::Interpol, :in_interp
-        rule %r/#(@@?|\$)[a-z_]\w*/i, Str::Interpol
+        rule %r/#(@@?|\$)[\p{Ll}_]\p{Word}*/i, Str::Interpol
       end
 
       state :string_intp_escaped do
@@ -399,7 +399,7 @@ module Rouge
         rule %r(
           [?](\\[MC]-)*     # modifiers
           (\\([\\abefnrstv\#"']|x[a-fA-F0-9]{1,2}|[0-7]{1,3})|\S)
-          (?!\w)
+          (?!\p{Word})
         )x, Str::Char, :pop!
 
         # special case for using a single space.  Ruby demands that

data/lib/rouge/lexers/ecl.rb

@@ -114,8 +114,8 @@ module Rouge
         mixin :single_quote
 
         rule %r(\b(?i:(and|not|or|in))\b), Operator::Word
-        rule %r([:=|>|<|<>|/|\\|\+|-|=]), Operator
-        rule %r([\[\]{}();,\&,\.,\%]), Punctuation
+        rule %r(:=|>|<|<>|/|\\|\+|-|=), Operator
+        rule %r([\[\]{}();,\&\.\%]), Punctuation
 
         rule %r(\b(?i:(beginc\+\+.*?endc\+\+)))m, Str::Single
         rule %r(\b(?i:(embed.*?endembed)))m, Str::Single

data/lib/rouge/lexers/eiffel.rb

@@ -44,7 +44,7 @@ module Rouge
         rule %r/(?:\d(?:_*\d)*)?\.(?:(?:\d(?:_*\d)*)?[eE][+-]?)?\d(?:_*\d)*|\d(?:_*\d)*\.?/, Num::Float
 
         rule %r/:=|<<|>>|\(\||\|\)|->|\.|[{}\[\];(),:?]/, Punctuation::Indicator
-        rule %r/\\\\|\|\.\.\||\.\.|\/[~\/]?|[><\/]=?|[-+*^=~]/, Operator
+        rule %r/\\\\|\|\.\.\||\.\.|\/[~\/]?|[><\/]=?|[-+*^=~≤≥−∀∃¦⟳⟲]/, Operator
 
         rule %r/[A-Z][\dA-Z_]*/, Name::Class
         rule %r/[A-Za-z][\dA-Za-z_]*/, Name

data/lib/rouge/lexers/elixir.rb

@@ -135,7 +135,7 @@ module Rouge
               rule %r/[\\#]/, toktype
             end
 
-            uniq_chars = "#{open}#{close}".squeeze
+            uniq_chars = [open, close].uniq.join
             rule %r/[^##{uniq_chars}\\]+/m, toktype
           end
         end

data/lib/rouge/lexers/gdscript.rb

@@ -12,7 +12,7 @@ module Rouge
       mimetypes 'text/x-gdscript', 'application/x-gdscript'
 
       def self.keywords
-        @keywords = %w(
+        @keywords ||= %w(
           and in not or as breakpoint class class_name extends is func setget
           signal tool const enum export onready static var break continue
           if elif else for pass return match while remote master puppet
@@ -22,13 +22,13 @@ module Rouge
 
       # Reserved for future implementation
       def self.keywords_reserved
-        @keywords_reserved = %w(
+        @keywords_reserved ||= %w(
           do switch case
         ).join('|')
       end
 
       def self.builtins
-        builtins = %w(
+        @builtins ||= %w(
           Color8 ColorN abs acos asin assert atan atan2 bytes2var ceil char
           clamp convert cos cosh db2linear decimals dectime deg2rad dict2inst
           ease exp floor fmod fposmod funcref hash inst2dict instance_from_id
@@ -41,7 +41,7 @@ module Rouge
       end
 
       def self.builtins_type
-        @builtins_type = %w(
+        @builtins_type ||= %w(
           bool int float String Vector2 Rect2 Transform2D Vector3 AABB
           Plane Quat Basis Transform Color RID Object NodePath Dictionary
           Array PoolByteArray PoolIntArray PoolRealArray PoolStringArray

data/lib/rouge/lexers/ghc_cmm.rb

@@ -22,11 +22,11 @@ module Rouge
       ws = %r(\s|//.*?\n|/[*](?:[^*]|(?:[*][^/]))*[*]+/)mx
 
       # Make sure that this is not a preprocessor macro, e.g. `#if` or `#define`.
-      id = %r((?!\#[a-zA-Z])[\w#\$%_']+)
+      id = %r((?!\#[a-zA-Z])[\w#\$%']+)
 
       complex_id = %r(
-        (?:[\w#$%_']|\(\)|\(,\)|\[\]|[0-9])*
-        (?:[\w#$%_']+)
+        (?:[\w#$%']|\(\)|\(,\)|\[\]|[0-9])*
+        (?:[\w#$%']+)
       )mx
 
       state :root do

data/lib/rouge/lexers/hcl.rb

@@ -26,6 +26,7 @@ module Rouge
       state :primitives do
         rule %r/[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?([kKmMgG]b?)?/, Num::Float
         rule %r/[0-9]+([kKmMgG]b?)?/, Num::Integer
+        rule %r/[-+*\/!%&<>|=:?]/, Operator
 
         rule %r/"/, Str::Double, :dq
         rule %r/'/, Str::Single, :sq

data/lib/rouge/lexers/iecst.rb

@@ -0,0 +1,92 @@
+# -*- coding: utf-8 -*- #
+# frozen_string_literal: true
+
+module Rouge
+  module Lexers
+    class IecST < RegexLexer
+      tag 'iecst'
+      title "IEC 61131-3 Structured Text"
+      desc 'Structured text is a programming language for PLCs (programmable logic controllers).'
+      filenames '*.awl', '*.scl', '*.st'
+
+      mimetypes 'text/x-iecst'
+
+      def self.keywords
+        blocks = %w(
+          PROGRAM CONFIGURATION INITIAL_STEP INTERFACE FUNCTION_BLOCK FUNCTION ACTION TRANSITION
+          TYPE STRUCT STEP NAMESPACE LIBRARY CHANNEL FOLDER RESOURCE
+          VAR_ACCESS VAR_CONFIG VAR_EXTERNAL VAR_GLOBAL VAR_INPUT VAR_IN_OUT VAR_OUTPUT VAR_TEMP VAR
+          CONST METHOD PROPERTY
+          CASE FOR IF REPEAT WHILE
+        )
+        @keywords ||= Set.new %w(
+          AT BEGIN BY CONSTANT CONTINUE DO ELSE ELSIF EXIT EXTENDS FROM GET GOTO IMPLEMENTS JMP
+          NON_RETAIN OF PRIVATE PROTECTED PUBLIC RETAIN RETURN SET TASK THEN TO UNTIL USING WITH
+          __CATCH __ENDTRY __FINALLY __TRY
+        ) + blocks + blocks.map {|kw| "END_" + kw}
+      end
+
+      def self.types
+        @types ||= Set.new %w(
+          ANY ARRAY BOOL BYTE POINTER STRING
+          DATE DATE_AND_TIME DT TIME TIME_OF_DAY TOD
+          INT DINT LINT SINT UINT UDINT ULINT USINT
+          WORD DWORD LWORD
+          REAL LREAL
+        )
+      end
+
+      def self.literals
+        @literals ||= Set.new %w(TRUE FALSE NULL)
+      end
+
+      def self.operators
+        @operators ||= Set.new %w(AND EQ EXPT GE GT LE LT MOD NE NOT OR XOR)
+      end
+
+      state :whitespace do
+        # Spaces
+        rule %r/\s+/m, Text
+        # // Comments
+        rule %r((//).*$\n?), Comment::Single
+        # (* Comments *)
+        rule %r(\(\*.*?\*\))m, Comment::Multiline
+        # { Comments }
+        rule %r(\{.*?\})m, Comment::Special
+      end
+
+      state :root do
+        mixin :whitespace
+
+        rule %r/'[^']+'/, Literal::String::Single
+        rule %r/"[^"]+"/, Literal::String::Symbol
+        rule %r/%[IQM][XBWDL][\d.]*|%[IQ][\d.]*/, Name::Variable::Magic
+        rule %r/\b(?:D|DT|T|TOD)#[\d_shmd:]*/i, Literal::Date
+        rule %r/\b(?:16#[\d_a-f]+|0x[\d_a-f]+)\b/i, Literal::Number::Hex
+        rule %r/\b2#[01_]+/, Literal::Number::Bin
+        rule %r/(?:\b\d+(?:\.\d*)?|\B\.\d+)(?:e[+-]?\d+)?/i, Literal::Number::Float
+        rule %r/\b[\d.,_]+/, Literal::Number
+
+        rule %r/\b[A-Z_]+\b/i do |m|
+          name = m[0].upcase
+          if self.class.keywords.include?(name)
+            token Keyword
+          elsif self.class.types.include?(name)
+            token Keyword::Type
+          elsif self.class.literals.include?(name)
+            token Literal
+          elsif self.class.operators.include?(name)
+            token Operator
+          else
+            token Name
+          end
+        end
+
+        rule %r/S?R?:?=>?|&&?|\*\*?|<[=>]?|>=?|[-:^\/+#]/, Operator
+        rule %r/\b[a-z_]\w*(?=\s*\()/i, Name::Function
+        rule %r/\b[a-z_]\w*\b/i, Name
+        rule %r/[()\[\].,;]/, Punctuation
+      end
+    end
+  end
+end

data/lib/rouge/lexers/javascript.rb

@@ -100,7 +100,7 @@ module Rouge
 
       def self.keywords
         @keywords ||= Set.new %w(
-          as async await break case catch continue debugger default delete
+          async await break case catch continue debugger default delete
           do else export finally from for if import in instanceof new of
           return super switch this throw try typeof void while yield
         )

data/lib/rouge/lexers/julia.rb

@@ -252,15 +252,16 @@ module Rouge
         rule %r/\d+/, Literal::Number::Integer
       end
 
+      NAME_RE = %r/[\p{L}\p{Nl}\p{S}_][\p{Word}\p{S}\p{Po}!]*/
 
       state :funcname do
-        rule %r/[\p{L}\p{Nl}\p{S}_][\p{Word}\p{S}\p{Po}!]*/, Name::Function, :pop!
+        rule NAME_RE, Name::Function, :pop!
         rule %r/\([^\s\w{]{1,2}\)/, Operator, :pop!
         rule %r/[^\s\w{]{1,2}/, Operator, :pop!
       end
 
       state :typename do
-        rule %r/[\p{L}\p{Nl}\p{S}_][\p{Word}\p{S}\p{Po}!]*/, Name::Class, :pop!
+        rule NAME_RE, Name::Class, :pop!
       end
 
       state :stringescape do

data/lib/rouge/lexers/kotlin.rb

@@ -24,7 +24,7 @@ module Rouge
         while yield
       )
 
-      name_chars = %r'[-_\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}\p{Nd}\p{Pc}\p{Cf}\p{Mn}\p{Mc}]*'
+      name_chars = %r'[-\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}\p{Nd}\p{Pc}\p{Cf}\p{Mn}\p{Mc}]*'
 
       class_name = %r'`?[\p{Lu}]#{name_chars}`?'
       name = %r'`?[_\p{Lu}\p{Ll}\p{Lt}\p{Lm}\p{Nl}]#{name_chars}`?'

data/lib/rouge/lexers/make.rb

@@ -73,7 +73,7 @@ module Rouge
       end
 
       state :export do
-        rule %r/[\w[\$]{1,2}{}()-]/, Name::Variable
+        rule %r/[\w\${}()-]/, Name::Variable
         rule %r/\n/, Text, :pop!
         rule %r/[\t ]+/, Text
       end

data/lib/rouge/lexers/markdown.rb

@@ -107,7 +107,8 @@ module Rouge
           push :link
         end
 
-        rule %r/[*][*]#{edot}*?[*][*]/, Generic::Strong
+        rule %r/[*]{2}[^* \n][^*\n]*[*]{2}/, Generic::Strong
+        rule %r/[*]{3}[^* \n][^*\n]*[*]{3}/, Generic::EmphStrong
         rule %r/__#{edot}*?__/, Generic::Strong
 
         rule %r/[*]#{edot}*?[*]/, Generic::Emph

data/lib/rouge/lexers/mathematica.rb

@@ -7,7 +7,7 @@ module Rouge
       title "Mathematica"
       desc "Wolfram Mathematica, the world's definitive system for modern technical computing."
       tag 'mathematica'
-      aliases 'wl'
+      aliases 'wl', 'wolfram'
       filenames '*.m', '*.wl'
       mimetypes 'application/vnd.wolfram.mathematica.package', 'application/vnd.wolfram.wl'
 

data/lib/rouge/lexers/meson.rb

@@ -38,7 +38,6 @@ module Rouge
       end
 
       identifier =        /[[:alpha:]_][[:alnum:]_]*/
-      dotted_identifier = /[[:alpha:]_.][[:alnum:]_.]*/
 
       def current_string
         @current_string ||= StringRegister.new

data/lib/rouge/lexers/nasm.rb

@@ -14,11 +14,12 @@ module Rouge
       mimetypes 'text/x-nasm'
 
       state :root do
-			  rule %r/^\s*%/, Comment::Preproc, :preproc
+        rule %r/^\s*%/, Comment::Preproc, :preproc
 
-			  mixin :whitespace
+        mixin :whitespace
+        mixin :punctuation
 
-			  rule %r/[a-z$._?][\w$.?#@~]*:/i, Name::Label
+        rule %r/[a-z$._?][\w$.?#@~]*:/i, Name::Label
 
         rule %r/([a-z$._?][\w$.?#@~]*)(\s+)(equ)/i do
           groups Name::Constant, Keyword::Declaration, Keyword::Declaration
@@ -32,7 +33,7 @@ module Rouge
       end
 
       state :instruction_args do
-			  rule %r/"(\\\\"|[^"\\n])*"|'(\\\\'|[^'\\n])*'|`(\\\\`|[^`\\n])*`/, Str
+        rule %r/"(\\\\"|[^"\\n])*"|'(\\\\'|[^'\\n])*'|`(\\\\`|[^`\\n])*`/, Str
         rule %r/(?:0x[\da-f]+|$0[\da-f]*|\d+[\da-f]*h)/i, Num::Hex
         rule %r/[0-7]+q/i, Num::Oct
         rule %r/[01]+b/i, Num::Bin

data/lib/rouge/lexers/nginx.rb

@@ -53,6 +53,7 @@ module Rouge
         # mimetype
         rule %r([a-z-]+/[a-z-]+)i, Name::Class
 
+        rule %r/\d+\.\d+/, Num::Float
         rule %r/[0-9]+[kmg]?\b/i, Num::Integer
         rule %r/(~)(\s*)([^\s{]+)/ do
           groups Punctuation, Text, Str::Regex

data/lib/rouge/lexers/objective_c/common.rb

@@ -4,8 +4,6 @@
 module Rouge
   module Lexers
     module ObjectiveCCommon
-      id = /[a-z$_][a-z0-9$_]*/i
-
       def at_keywords
         @at_keywords ||= %w(
           selector private protected public encode synchronized try

data/lib/rouge/lexers/objective_c.rb

@@ -12,7 +12,7 @@ module Rouge
       tag 'objective_c'
       title "Objective-C"
       desc 'an extension of C commonly used to write Apple software'
-      aliases 'objc', 'obj-c', 'obj_c', 'objectivec'
+      aliases 'objc', 'obj-c', 'obj_c', 'objectivec', 'objective-c'
       filenames '*.m', '*.h'
 
       mimetypes 'text/x-objective_c', 'application/x-objective_c'

data/lib/rouge/lexers/ocl.rb

@@ -61,9 +61,9 @@ module Rouge
         rule %r/--.*/, Comment::Single
         rule %r/\d+/, Num::Integer
         rule %r/'/, Str::Single, :single_string
-        rule %r([->|+*/<>=~!@#%&|?^-]), Operator
+        rule %r([-|+*/<>=~!@#%&?^]), Operator
         rule %r/[;:()\[\],.]/, Punctuation
-        rule %r/\w[\w\d]*/ do |m|
+        rule %r/[a-zA-Z]\w*/ do |m|
           if self.class.operators.include? m[0]
             token Operator
           elsif self.class.keywords_type.include? m[0]

data/lib/rouge/lexers/openedge.rb

@@ -12,8 +12,6 @@ module Rouge
       title 'OpenEdge ABL'
       desc 'The OpenEdge ABL programming language'
 
-      # optional comment or whitespace
-      ws = %r((?:\s|//.*?\n|/[*].*?[*]/)+)
       id = /[a-zA-Z_&{}!][a-zA-Z0-9_\-&!}]*/
 
       def self.keywords