rugments 1.0.0.beta1

data/lib/rugments/lexers/shell.rb

@@ -0,0 +1,150 @@
+module Rugments
+  module Lexers
+    class Shell < RegexLexer
+      title 'shell'
+      desc 'Various shell languages, including sh and bash'
+
+      tag 'shell'
+      aliases 'bash', 'zsh', 'ksh', 'sh'
+      filenames '*.sh', '*.bash', '*.zsh', '*.ksh',
+                '.bashrc', '.zshrc', '.kshrc', '.profile', 'PKGBUILD'
+
+      mimetypes 'application/x-sh', 'application/x-shellscript'
+
+      def self.analyze_text(text)
+        text.shebang?(/(ba|z|k)?sh/) ? 1 : 0
+      end
+
+      KEYWORDS = %w(
+        if fi else while do done for then return function
+        select continue until esac elif in
+      ).join('|')
+
+      BUILTINS = %w(
+        alias bg bind break builtin caller cd command compgen
+        complete declare dirs disown echo enable eval exec exit
+        export false fc fg getopts hash help history jobs kill let
+        local logout popd printf pushd pwd read readonly set shift
+        shopt source suspend test time times trap true type typeset
+        ulimit umask unalias unset wait
+      ).join('|')
+
+      state :basic do
+        rule /#.*$/, Comment
+
+        rule /\b(#{KEYWORDS})\s*\b/, Keyword
+        rule /\bcase\b/, Keyword, :case
+
+        rule /\b(#{BUILTINS})\s*\b(?!\.)/, Name::Builtin
+
+        rule /^\S*[\$%>#] +/, Generic::Prompt
+
+        rule /(\b\w+)(=)/ do |_m|
+          groups Name::Variable, Operator
+        end
+
+        rule /[\[\]{}()=]/, Operator
+        rule /&&|\|\|/, Operator
+        # rule /\|\|/, Operator
+
+        rule /<<</, Operator # here-string
+        rule /<<-?\s*(\'?)\\?(\w+)\1/ do |m|
+          lsh = Str::Heredoc
+          token lsh
+          heredocstr = Regexp.escape(m[2])
+
+          push do
+            rule /\s*#{heredocstr}\s*\n/, lsh, :pop!
+            rule /.*?\n/, lsh
+          end
+        end
+      end
+
+      state :double_quotes do
+        # NB: "abc$" is literally the string abc$.
+        # Here we prevent :interp from interpreting $" as a variable.
+        rule /(?:\$#?)?"/, Str::Double, :pop!
+        mixin :interp
+        rule /[^"`\\$]+/, Str::Double
+      end
+
+      state :single_quotes do
+        rule /'/, Str::Single, :pop!
+        rule /[^']+/, Str::Single
+      end
+
+      state :data do
+        rule /\s+/, Text
+        rule /\\./, Str::Escape
+        rule /\$?"/, Str::Double, :double_quotes
+
+        # single quotes are much easier than double quotes - we can
+        # literally just scan until the next single quote.
+        # POSIX: Enclosing characters in single-quotes ( '' )
+        # shall preserve the literal value of each character within the
+        # single-quotes. A single-quote cannot occur within single-quotes.
+        rule /$?'/, Str::Single, :single_quotes
+
+        rule /\*/, Keyword
+
+        rule /;/, Text
+        rule /[^=\*\s{}()$"'`\\<]+/, Text
+        rule /\d+(?= |\Z)/, Num
+        rule /</, Text
+        mixin :interp
+      end
+
+      state :curly do
+        rule /}/, Keyword, :pop!
+        rule /:-/, Keyword
+        rule /[a-zA-Z0-9_]+/, Name::Variable
+        rule /[^}:"`'$]+/, Punctuation
+        mixin :root
+      end
+
+      state :paren do
+        rule /\)/, Keyword, :pop!
+        mixin :root
+      end
+
+      state :math do
+        rule /\)\)/, Keyword, :pop!
+        rule %r{[-+*/%^|&]|\*\*|\|\|}, Operator
+        rule /\d+/, Num
+        mixin :root
+      end
+
+      state :case do
+        rule /\besac\b/, Keyword, :pop!
+        rule /\|/, Punctuation
+        rule /\)/, Punctuation, :case_stanza
+        mixin :root
+      end
+
+      state :case_stanza do
+        rule /;;/, Punctuation, :pop!
+        mixin :root
+      end
+
+      state :backticks do
+        rule /`/, Str::Backtick, :pop!
+        mixin :root
+      end
+
+      state :interp do
+        rule /\\$/, Str::Escape # line continuation
+        rule /\\./, Str::Escape
+        rule /\$\(\(/, Keyword, :math
+        rule /\$\(/, Keyword, :paren
+        rule /\${#?/, Keyword, :curly
+        rule /`/, Str::Backtick, :backticks
+        rule /\$#?(\w+|.)/, Name::Variable
+      end
+
+      state :root do
+        mixin :basic
+        mixin :data
+      end
+    end
+  end
+end

data/lib/rugments/lexers/slim.rb

@@ -0,0 +1,222 @@
+module Rugments
+  module Lexers
+    # A lexer for the Slim tempalte language
+    # @see http://slim-lang.org
+    class Slim < RegexLexer
+      include Indentation
+
+      title 'Slim'
+      desc 'The Slim template language'
+
+      tag 'slim'
+
+      filenames '*.slim'
+
+      # Ruby identifier characters
+      ruby_chars = /[\w\!\?\@\$]/
+
+      # Since you are allowed to wrap lines with a backslash, include \\\n in characters
+      dot = /(\\\n|.)/
+
+      def self.analyze_text(text)
+        return 1 if text.start_with? 'doctype'
+        return 1 if text =~ /(\*)(\{.+?\})/ # Contans a hash splat
+      end
+
+      def ruby
+        @ruby ||= Ruby.new(options)
+      end
+
+      def html
+        @html ||= HTML.new(options)
+      end
+
+      def filters
+        @filters ||= {
+          'ruby' => ruby,
+          'erb' => ERB.new(options),
+          'javascript' => Javascript.new(options),
+          'css' => CSS.new(options),
+          'coffee' => Coffeescript.new(options),
+          'markdown' => Markdown.new(options),
+          'scss' => Scss.new(options),
+          'sass' => Sass.new(options)
+        }
+      end
+
+      state :root do
+        rule /\s*\n/, Text
+        rule(/\s*/) { |m| token Text; indentation(m[0]) }
+      end
+
+      state :content do
+        mixin :css
+
+        rule /\/#{dot}*/, Comment, :indented_block
+
+        rule /(doctype)(\s+)(.*)/ do
+          groups Name::Namespace, Text::Whitespace, Text
+          pop!
+        end
+
+        # filters, shamelessly ripped from HAML
+        rule /(\w*):\s*\n/ do |m|
+          token Name::Decorator
+          pop!
+          starts_block :filter_block
+
+          filter_name = m[1].strip
+
+          @filter_lexer = filters[filter_name]
+          @filter_lexer.reset! unless @filter_lexer.nil?
+
+          puts "    slim: filter #{filter_name.inspect} #{@filter_lexer.inspect}" if @debug
+        end
+
+        # Text
+        rule %r{[\|'](?=\s)} do
+          token Punctuation
+          pop!
+          starts_block :plain_block
+          goto :plain_block
+        end
+
+        rule /-|==|=/, Punctuation, :ruby_line
+
+        # Dynamic tags
+        rule /(\*)(#{ruby_chars}+\(.*?\))/ do |m|
+          token Punctuation, m[1]
+          delegate ruby, m[2]
+          push :tag
+        end
+
+        rule /(\*)(#{ruby_chars}+)/ do |m|
+          token Punctuation, m[1]
+          delegate ruby, m[2]
+          push :tag
+        end
+
+        # rule /<\w+(?=.*>)/, Keyword::Constant, :tag # Maybe do this, look ahead and stuff
+        rule %r{(</?[\w\s\=\'\"]+?/?>)} do |m| # Dirty html
+          delegate html, m[1]
+          pop!
+        end
+
+        # Ordinary slim tags
+        rule /\w+/, Name::Tag, :tag
+      end
+
+      state :tag do
+        mixin :css
+        mixin :indented_block
+        mixin :interpolation
+
+        # Whitespace control
+        rule /[<>]/, Punctuation
+
+        # Trim whitespace
+        rule /\s+?/, Text::Whitespace
+
+        # Splats, these two might be mergable?
+        rule /(\*)(#{ruby_chars}+)/ do |m|
+          token Punctuation, m[1]
+          delegate ruby, m[2]
+        end
+
+        rule /(\*)(\{#{dot}+?\})/ do |m|
+          token Punctuation, m[1]
+          delegate ruby, m[2]
+        end
+
+        # Attributes
+        rule /([\w\-]+)(\s*)(\=)/ do |m|
+          token Name::Attribute, m[1]
+          token Text::Whitespace, m[2]
+          token Punctuation, m[3]
+          push :html_attr
+        end
+
+        # Ruby value
+        rule /(\=)(#{dot}+)/ do |m|
+          token Punctuation, m[1]
+          # token Keyword::Constant, m[2]
+          delegate ruby, m[2]
+        end
+
+        rule /#{dot}+?/, Text
+
+        rule /\s*\n/, Text::Whitespace, :pop!
+      end
+
+      state :css do
+        rule(/\.\w+/) { token Name::Class; goto :tag }
+        rule(/#\w+/) { token Name::Function; goto :tag }
+      end
+
+      state :html_attr do
+        # Strings, double/single quoted
+        rule %r{\s*(['"])#{dot}*\1}, Literal::String, :pop!
+
+        # Ruby stuff
+        rule(/(#{ruby_chars}+\(.*?\))/) { |m| delegate ruby, m[1]; pop! }
+        rule(/(#{ruby_chars}+)/) { |m| delegate ruby, m[1]; pop! }
+
+        rule /\s+/, Text::Whitespace
+      end
+
+      state :ruby_line do
+        # Need at top
+        mixin :indented_block
+
+        rule(/,\s*\n/) { delegate ruby }
+        rule /[ ]\|[ \t]*\n/, Str::Escape
+        rule(/.*?(?=(,$| \|)?[ \t]*$)/) { delegate ruby }
+      end
+
+      state :filter_block do
+        rule /([^#\n]|#[^{\n]|(\\\\)*\\#\{)+/ do
+          if @filter_lexer
+            delegate @filter_lexer
+          else
+            token Name::Decorator
+          end
+        end
+
+        mixin :interpolation
+        mixin :indented_block
+      end
+
+      state :plain_block do
+        mixin :interpolation
+
+        rule %r{(</?[\w\s\=\'\"]+?/?>)} do |m| # Dirty html
+          delegate html, m[1]
+        end
+
+        # rule /([^#\n]|#[^{\n]|(\\\\)*\\#\{)+/ do
+        rule /#{dot}+?/, Text
+
+        mixin :indented_block
+      end
+
+      state :interpolation do
+        rule /#[{]/, Str::Interpol, :ruby_interp
+      end
+
+      state :ruby_interp do
+        rule /[}]/, Str::Interpol, :pop!
+        mixin :ruby_interp_inner
+      end
+
+      state :ruby_interp_inner do
+        rule(/[{]/) { delegate ruby; push :ruby_interp_inner }
+        rule(/[}]/) { delegate ruby; pop! }
+        rule(/[^{}]+/) { delegate ruby }
+      end
+
+      state :indented_block do
+        rule(/(?<!\\)\n/) { token Text; reset_stack }
+      end
+    end
+  end
+end

data/lib/rugments/lexers/smalltalk.rb

@@ -0,0 +1,114 @@
+module Rugments
+  module Lexers
+    class Smalltalk < RegexLexer
+      title 'Smalltalk'
+      desc 'The Smalltalk programming language'
+
+      tag 'smalltalk'
+      aliases 'st', 'squeak'
+      filenames '*.st'
+      mimetypes 'text/x-smalltalk'
+
+      ops = %r{[-+*/\\~<>=|&!?,@%]}
+
+      state :root do
+        rule /(<)(\w+:)(.*?)(>)/ do
+          groups Punctuation, Keyword, Text, Punctuation
+        end
+
+        # mixin :squeak_fileout
+        mixin :whitespaces
+        mixin :method_definition
+        rule /([|])([\w\s]*)([|])/ do
+          groups Punctuation, Name::Variable, Punctuation
+        end
+        mixin :objects
+        rule /\^|:=|_/, Operator
+
+        rule /[)}\]]/, Punctuation, :after_object
+        rule /[({\[!]/, Punctuation
+      end
+
+      state :method_definition do
+        rule /([a-z]\w*:)(\s*)(\w+)/i do
+          groups Name::Function, Text, Name::Variable
+        end
+
+        rule /^(\s*)(\b[a-z]\w*\b)(\s*)$/i do
+          groups Text, Name::Function, Text
+        end
+
+        rule %r{^(\s*)(#{ops}+)(\s*)(\w+)(\s*)$} do
+          groups Text, Name::Function, Text, Name::Variable, Text
+        end
+      end
+
+      state :block_variables do
+        mixin :whitespaces
+        rule /(:)(\s*)(\w+)/ do
+          groups Operator, Text, Name::Variable
+        end
+
+        rule /[|]/, Punctuation, :pop!
+
+        rule(//) { pop! }
+      end
+
+      state :literals do
+        rule /'(''|.)*?'/m, Str, :after_object
+        rule /[$]./, Str::Char, :after_object
+        rule /#[(]/, Str::Symbol, :parenth
+        rule /(\d+r)?-?\d+(\.\d+)?(e-?\d+)?/,
+             Num, :after_object
+        rule /#("[^"]*"|#{ops}+|[\w:]+)/,
+             Str::Symbol, :after_object
+      end
+
+      state :parenth do
+        rule /[)]/ do
+          token Str::Symbol
+          goto :after_object
+        end
+
+        mixin :inner_parenth
+      end
+
+      state :inner_parenth do
+        rule /#[(]/, Str::Symbol, :inner_parenth
+        rule /[)]/, Str::Symbol, :pop!
+        mixin :whitespaces
+        mixin :literals
+        rule /(#{ops}|[\w:])+/, Str::Symbol
+      end
+
+      state :whitespaces do
+        rule /! !$/, Keyword # squeak chunk delimiter
+        rule /\s+/m, Text
+        rule /".*?"/m, Comment
+      end
+
+      state :objects do
+        rule /\[/, Punctuation, :block_variables
+        rule /(self|super|true|false|nil|thisContext)\b/,
+             Name::Builtin::Pseudo, :after_object
+        rule /[A-Z]\w*(?!:)\b/, Name::Class, :after_object
+        rule /[a-z]\w*(?!:)\b/, Name::Variable, :after_object
+        mixin :literals
+      end
+
+      state :after_object do
+        mixin :whitespaces
+        rule /(ifTrue|ifFalse|whileTrue|whileFalse|timesRepeat):/,
+             Name::Builtin, :pop!
+        rule /new(?!:)\b/, Name::Builtin
+        rule /:=|_/, Operator, :pop!
+        rule /[a-z]+\w*:/i, Name::Function, :pop!
+        rule /[a-z]+\w*/i, Name::Function
+        rule /#{ops}+/, Name::Function, :pop!
+        rule /[.]/, Punctuation, :pop!
+        rule /;/, Punctuation
+        rule(//) { pop! }
+      end
+    end
+  end
+end