rouge_ecl 0.0.1

data/lib/rouge/lexers/cfscript.rb

@@ -0,0 +1,153 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+
+    class Cfscript < RegexLexer
+      title "CFScript"
+      desc 'CFScript, the CFML scripting language'
+      tag 'cfscript'
+      aliases 'cfc'
+      filenames '*.cfc'
+
+      def self.keywords
+        @keywords ||= %w(
+          if else var xml default break switch do try catch throw in continue for return while required
+        )
+      end
+
+      def self.declarations
+        @declarations ||= %w(
+          component property function remote public package private
+        )
+      end
+
+      def self.types
+        @types ||= %w(
+          any array binary boolean component date guid numeric query string struct uuid void xml
+        )
+      end
+
+      constants = %w(application session client cookie super this variables arguments cgi)
+
+
+      operators = %w(\+\+ -- && \|\| <= >= < > == != mod eq lt gt lte gte not is and or xor eqv imp equal contains \? )
+      dotted_id = /[$a-zA-Z_][a-zA-Z0-9_.]*/
+
+      state :root do
+        mixin :comments_and_whitespace
+        rule /(?:#{operators.join('|')}|does not contain|greater than(?: or equal to)?|less than(?: or equal to)?)\b/i, Operator, :expr_start
+        rule %r([-<>+*%&|\^/!=]=?), Operator, :expr_start
+
+        rule /[(\[,]/, Punctuation, :expr_start
+        rule /;/, Punctuation, :statement
+        rule /[)\].]/, Punctuation
+
+        rule /[?]/ do
+          token Punctuation
+          push :ternary
+          push :expr_start
+        end
+
+        rule /[{}]/, Punctuation, :statement
+
+        rule /(?:#{constants.join('|')})\b/, Name::Constant
+        rule /(?:true|false|null)\b/, Keyword::Constant
+        rule /import\b/, Keyword::Namespace, :import
+        rule /(#{dotted_id})(\s*)(:)(\s*)/ do
+          groups Name, Text, Punctuation, Text
+          push :expr_start
+        end
+
+        rule /([A-Za-z_$][\w.]*)(\s*)(\()/ do |m|
+          if self.class.keywords.include? m[1]
+            token Keyword, m[1]
+            token Text, m[2]
+            token Punctuation, m[3]
+          else
+            token Name::Function, m[1]
+            token Text, m[2]
+            token Punctuation, m[3]
+          end
+        end
+
+        rule dotted_id do |m|
+          if self.class.declarations.include? m[0]
+            token Keyword::Declaration
+            push :expr_start
+          elsif self.class.keywords.include? m[0]
+            token Keyword
+            push :expr_start
+          elsif self.class.types.include? m[0]
+            token Keyword::Type
+            push :expr_start
+          else
+            token Name::Other
+          end
+        end
+
+        rule /[0-9][0-9]*\.[0-9]+([eE][0-9]+)?[fd]?/, Num::Float
+        rule /0x[0-9a-fA-F]+/, Num::Hex
+        rule /[0-9]+/, Num::Integer
+        rule /"(\\\\|\\"|[^"])*"/, Str::Double
+        rule /'(\\\\|\\'|[^'])*'/, Str::Single
+
+      end
+
+      # same as java, broken out
+      state :comments_and_whitespace do
+        rule /\s+/, Text
+        rule %r(//.*?$), Comment::Single
+        rule %r(/\*.*?\*/)m, Comment::Multiline
+      end
+
+      state :expr_start do
+        mixin :comments_and_whitespace
+
+        rule /[{]/, Punctuation, :object
+
+        rule //, Text, :pop!
+      end
+
+      state :statement do
+
+        rule /[{}]/, Punctuation
+
+        mixin :expr_start
+      end
+
+      # object literals
+      state :object do
+        mixin :comments_and_whitespace
+        rule /[}]/ do
+          token Punctuation
+          push :expr_start
+        end
+
+        rule /(#{dotted_id})(\s*)(:)/ do
+          groups Name::Other, Text, Punctuation
+          push :expr_start
+        end
+
+        rule /:/, Punctuation
+        mixin :root
+      end
+
+      # ternary expressions, where <dotted_id>: is not a label!
+      state :ternary do
+        rule /:/ do
+          token Punctuation
+          goto :expr_start
+        end
+
+        mixin :root
+      end
+
+      state :import do
+        rule /\s+/m, Text
+        rule /[a-z0-9_.]+\*?/i, Name::Namespace, :pop!
+      end
+
+    end
+  end
+end

data/lib/rouge/lexers/clojure.rb

@@ -0,0 +1,112 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class Clojure < RegexLexer
+      title "Clojure"
+      desc "The Clojure programming language (clojure.org)"
+
+      tag 'clojure'
+      aliases 'clj', 'cljs'
+
+      filenames '*.clj', '*.cljs', '*.cljc', 'build.boot', '*.edn'
+
+      mimetypes 'text/x-clojure', 'application/x-clojure'
+
+      def self.keywords
+        @keywords ||= Set.new %w(
+          fn def defn defmacro defmethod defmulti defn- defstruct if
+          cond let for
+        )
+      end
+
+      def self.builtins
+        @builtins ||= Set.new %w(
+          . ..  * + - -> / < <= = == > >= accessor agent agent-errors
+          aget alength all-ns alter and append-child apply array-map
+          aset aset-boolean aset-byte aset-char aset-double aset-float
+          aset-int aset-long aset-short assert assoc await await-for bean
+          binding bit-and bit-not bit-or bit-shift-left bit-shift-right
+          bit-xor boolean branch?  butlast byte cast char children
+          class clear-agent-errors comment commute comp comparator
+          complement concat conj cons constantly construct-proxy
+          contains? count create-ns create-struct cycle dec  deref
+          difference disj dissoc distinct doall doc dorun doseq dosync
+          dotimes doto double down drop drop-while edit end? ensure eval
+          every? false? ffirst file-seq filter find find-doc find-ns
+          find-var first float flush fnseq frest gensym get-proxy-class
+          get hash-map hash-set identical? identity if-let import in-ns
+          inc index insert-child insert-left insert-right inspect-table
+          inspect-tree instance? int interleave intersection into
+          into-array iterate join key keys keyword keyword? last lazy-cat
+          lazy-cons left lefts line-seq list* list load load-file locking
+          long loop macroexpand macroexpand-1 make-array make-node map
+          map-invert map? mapcat max max-key memfn merge merge-with meta
+          min min-key name namespace neg? new newline next nil? node not
+          not-any? not-every? not= ns-imports ns-interns ns-map ns-name
+          ns-publics ns-refers ns-resolve ns-unmap nth nthrest or parse
+          partial path peek pop pos? pr pr-str print print-str println
+          println-str prn prn-str project proxy proxy-mappings quot
+          rand rand-int range re-find re-groups re-matcher re-matches
+          re-pattern re-seq read read-line reduce ref ref-set refer rem
+          remove remove-method remove-ns rename rename-keys repeat replace
+          replicate resolve rest resultset-seq reverse rfirst right
+          rights root rrest rseq second select select-keys send send-off
+          seq seq-zip seq? set short slurp some sort sort-by sorted-map
+          sorted-map-by sorted-set special-symbol? split-at split-with
+          str string?  struct struct-map subs subvec symbol symbol?
+          sync take take-nth take-while test time to-array to-array-2d
+          tree-seq true? union up update-proxy val vals var-get var-set
+          var? vector vector-zip vector? when when-first when-let
+          when-not with-local-vars with-meta with-open with-out-str
+          xml-seq xml-zip zero? zipmap zipper'
+        )
+      end
+
+      identifier = %r([\w!$%*+,<=>?/.-]+)
+      keyword = %r([\w!\#$%*+,<=>?/.-]+)
+
+      def name_token(name)
+        return Keyword if self.class.keywords.include?(name)
+        return Name::Builtin if self.class.builtins.include?(name)
+        nil
+      end
+
+      state :root do
+        rule /;.*?$/, Comment::Single
+        rule /\s+/m, Text::Whitespace
+
+        rule /-?\d+\.\d+/, Num::Float
+        rule /-?\d+/, Num::Integer
+        rule /0x-?[0-9a-fA-F]+/, Num::Hex
+
+        rule /"(\\.|[^"])*"/, Str
+        rule /'#{keyword}/, Str::Symbol
+        rule /::?#{keyword}/, Name::Constant
+        rule /\\(.|[a-z]+)/i, Str::Char
+
+
+        rule /~@|[`\'#^~&@]/, Operator
+
+        rule /(\()(\s*)(#{identifier})/m do |m|
+          token Punctuation, m[1]
+          token Text::Whitespace, m[2]
+          token(name_token(m[3]) || Name::Function, m[3])
+        end
+
+        rule identifier do |m|
+          token name_token(m[0]) || Name
+        end
+
+        # vectors
+        rule /[\[\]]/, Punctuation
+
+        # maps
+        rule /[{}]/, Punctuation
+
+        # parentheses
+        rule /[()]/, Punctuation
+      end
+    end
+  end
+end

data/lib/rouge/lexers/cmake.rb

@@ -0,0 +1,206 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Lexers
+    class CMake < RegexLexer
+      title 'CMake'
+      desc 'The cross-platform, open-source build system'
+      tag 'cmake'
+      filenames 'CMakeLists.txt', '*.cmake'
+      mimetypes 'text/x-cmake'
+
+      SPACE = '[ \t]'
+      BRACKET_OPEN = '\[=*\['
+
+      STATES_MAP = {
+        :root => Text,
+        :bracket_string => Str::Double,
+        :quoted_argument => Str::Double,
+        :bracket_comment => Comment::Multiline,
+        :variable_reference => Name::Variable,
+      }
+
+      BUILTIN_COMMANDS = Set.new %w[
+        add_compile_options
+        add_custom_command
+        add_custom_target
+        add_definitions
+        add_dependencies
+        add_executable
+        add_library
+        add_subdirectory
+        add_test
+        aux_source_directory
+        break
+        build_command
+        build_name
+        cmake_host_system_information
+        cmake_minimum_required
+        cmake_policy
+        configure_file
+        create_test_sourcelist
+        define_property
+        else
+        elseif
+        enable_language
+        enable_testing
+        endforeach
+        endfunction
+        endif
+        endmacro
+        endwhile
+        exec_program
+        execute_process
+        export
+        export_library_dependencies
+        file
+        find_file
+        find_library
+        find_package
+        find_path
+        find_program
+        fltk_wrap_ui
+        foreach
+        function
+        get_cmake_property
+        get_directory_property
+        get_filename_component
+        get_property
+        get_source_file_property
+        get_target_property
+        get_test_property
+        if
+        include
+        include_directories
+        include_external_msproject
+        include_regular_expression
+        install
+        install_files
+        install_programs
+        install_targets
+        link_directories
+        link_libraries
+        list
+        load_cache
+        load_command
+        macro
+        make_directory
+        mark_as_advanced
+        math
+        message
+        option
+        output_required_files
+        project
+        qt_wrap_cpp
+        qt_wrap_ui
+        remove
+        remove_definitions
+        return
+        separate_arguments
+        set
+        set_directory_properties
+        set_property
+        set_source_files_properties
+        set_target_properties
+        set_tests_properties
+        site_name
+        source_group
+        string
+        subdir_depends
+        subdirs
+        target_compile_definitions
+        target_compile_options
+        target_include_directories
+        target_link_libraries
+        try_compile
+        try_run
+        unset
+        use_mangled_mesa
+        utility_source
+        variable_requires
+        variable_watch
+        while
+        write_file
+      ]
+
+      state :default do
+        rule /\r\n?|\n/ do
+          token STATES_MAP[state.name.to_sym]
+        end
+        rule /./ do
+          token STATES_MAP[state.name.to_sym]
+        end
+      end
+
+      state :variable_interpolation do
+        rule /\$\{/ do
+          token Str::Interpol
+          push :variable_reference
+        end
+      end
+
+      state :bracket_close do
+        rule /\]=*\]/ do |m|
+          token STATES_MAP[state.name.to_sym]
+          goto :root if m[0].length == @bracket_len
+        end
+      end
+
+      state :root do
+        mixin :variable_interpolation
+
+        rule /#{SPACE}/, Text
+        rule /[()]/, Punctuation
+
+        rule /##{BRACKET_OPEN}/ do |m|
+          token Comment::Multiline
+          @bracket_len = m[0].length - 1 # decount '#'
+          goto :bracket_comment
+        end
+        rule /#{BRACKET_OPEN}/ do |m|
+          token Str::Double
+          @bracket_len = m[0].length
+          goto :bracket_string
+        end
+
+        rule /"/, Str::Double, :quoted_argument
+
+        rule /([A-Za-z_][A-Za-z0-9_]*)(#{SPACE}*)(\()/ do |m|
+          groups BUILTIN_COMMANDS.include?(m[1]) ? Name::Builtin : Name::Function, Text, Punctuation
+        end
+
+        rule /#.*/, Comment::Single
+
+        mixin :default
+      end
+
+      state :bracket_string do
+        mixin :bracket_close
+        mixin :variable_interpolation
+        mixin :default
+      end
+
+      state :bracket_comment do
+        mixin :bracket_close
+        mixin :default
+      end
+
+      state :variable_reference do
+        mixin :variable_interpolation
+
+        rule /}/, Str::Interpol, :pop!
+
+        mixin :default
+      end
+
+      state :quoted_argument do
+        mixin :variable_interpolation
+
+        rule /"/, Str::Double, :root
+        rule /\\[()#" \\$@^trn;]/, Str::Escape
+
+        mixin :default
+      end
+    end
+  end
+end