rouge_ecl 0.0.1

data/lib/rouge/template_lexer.rb

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  # @abstract
+  # A TemplateLexer is one that accepts a :parent option, to specify
+  # which language is being templated.  The lexer class can specify its
+  # own default for the parent lexer, which is otherwise defaulted to
+  # HTML.
+  class TemplateLexer < RegexLexer
+    # the parent lexer - the one being templated.
+    def parent
+      return @parent if instance_variable_defined? :@parent
+      @parent = lexer_option(:parent) || Lexers::HTML.new(@options)
+    end
+
+    option :parent, "the parent language (default: html)"
+
+    start { parent.reset! }
+  end
+end

data/lib/rouge/text_analyzer.rb

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  class TextAnalyzer < String
+    # Find a shebang.  Returns nil if no shebang is present.
+    def shebang
+      return @shebang if instance_variable_defined? :@shebang
+
+      self =~ /\A\s*#!(.*)$/
+      @shebang = $1
+    end
+
+    # Check if the given shebang is present.
+    #
+    # This normalizes things so that `text.shebang?('bash')` will detect
+    # `#!/bash`, '#!/bin/bash', '#!/usr/bin/env bash', and '#!/bin/bash -x'
+    def shebang?(match)
+      return false unless shebang
+      match = /\b#{match}(\s|$)/
+      match === shebang
+    end
+
+    # Return the contents of the doctype tag if present, nil otherwise.
+    def doctype
+      return @doctype if instance_variable_defined? :@doctype
+
+      self =~ %r(\A\s*
+        (?:<\?.*?\?>\s*)? # possible <?xml...?> tag
+        <!DOCTYPE\s+(.+?)>
+      )xm
+      @doctype = $1
+    end
+
+    # Check if the doctype matches a given regexp or string
+    def doctype?(type=//)
+      type === doctype
+    end
+
+    # Return true if the result of lexing with the given lexer contains no
+    # error tokens.
+    def lexes_cleanly?(lexer)
+      lexer.lex(self) do |(tok, _)|
+        return false if tok.name == 'Error'
+      end
+
+      true
+    end
+  end
+end

data/lib/rouge/theme.rb

@@ -0,0 +1,213 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  class Theme
+    include Token::Tokens
+
+    class Style < Hash
+      def initialize(theme, hsh={})
+        super()
+        @theme = theme
+        merge!(hsh)
+      end
+
+      [:fg, :bg].each do |mode|
+        define_method mode do
+          return self[mode] unless @theme
+          @theme.palette(self[mode]) if self[mode]
+        end
+      end
+
+      def render(selector, &b)
+        return enum_for(:render, selector).to_a.join("\n") unless b
+
+        return if empty?
+
+        yield "#{selector} {"
+        rendered_rules.each do |rule|
+          yield "  #{rule};"
+        end
+        yield "}"
+      end
+
+      def rendered_rules(&b)
+        return enum_for(:rendered_rules) unless b
+        yield "color: #{fg}" if fg
+        yield "background-color: #{bg}" if bg
+        yield "font-weight: bold" if self[:bold]
+        yield "font-style: italic" if self[:italic]
+        yield "text-decoration: underline" if self[:underline]
+
+        (self[:rules] || []).each(&b)
+      end
+    end
+
+    def styles
+      @styles ||= self.class.styles.dup
+    end
+
+    @palette = {}
+    def self.palette(arg={})
+      @palette ||= InheritableHash.new(superclass.palette)
+
+      if arg.is_a? Hash
+        @palette.merge! arg
+        @palette
+      else
+        case arg
+        when /#[0-9a-f]+/i
+          arg
+        else
+          @palette[arg] or raise "not in palette: #{arg.inspect}"
+        end
+      end
+    end
+
+    def palette(*a) self.class.palette(*a) end
+
+    @styles = {}
+    def self.styles
+      @styles ||= InheritableHash.new(superclass.styles)
+    end
+
+    def self.render(opts={}, &b)
+      new(opts).render(&b)
+    end
+
+    def get_own_style(token)
+      self.class.get_own_style(token)
+    end
+
+    def get_style(token)
+      self.class.get_style(token)
+    end
+
+    class << self
+      def style(*tokens)
+        style = tokens.last.is_a?(Hash) ? tokens.pop : {}
+
+        tokens.each do |tok|
+          styles[tok] = style
+        end
+      end
+
+      def get_own_style(token)
+        token.token_chain.reverse_each do |anc|
+          return Style.new(self, styles[anc]) if styles[anc]
+        end
+
+        nil
+      end
+
+      def get_style(token)
+        get_own_style(token) || base_style
+      end
+
+      def base_style
+        get_own_style(Token::Tokens::Text)
+      end
+
+      def name(n=nil)
+        return @name if n.nil?
+
+        @name = n.to_s
+        register(@name)
+      end
+
+      def register(name)
+        Theme.registry[name.to_s] = self
+      end
+
+      def find(n)
+        registry[n.to_s]
+      end
+
+      def registry
+        @registry ||= {}
+      end
+    end
+  end
+
+  module HasModes
+    def mode(arg=:absent)
+      return @mode if arg == :absent
+
+      @modes ||= {}
+      @modes[arg] ||= get_mode(arg)
+    end
+
+    def get_mode(mode)
+      return self if self.mode == mode
+
+      new_name = "#{self.name}.#{mode}"
+      Class.new(self) { name(new_name); set_mode!(mode) }
+    end
+
+    def set_mode!(mode)
+      @mode = mode
+      send("make_#{mode}!")
+    end
+
+    def mode!(arg)
+      alt_name = "#{self.name}.#{arg}"
+      register(alt_name)
+      set_mode!(arg)
+    end
+  end
+
+  class CSSTheme < Theme
+    def initialize(opts={})
+      @scope = opts[:scope] || '.highlight'
+    end
+
+    def render(&b)
+      return enum_for(:render).to_a.join("\n") unless b
+
+      # shared styles for tableized line numbers
+      yield "#{@scope} table td { padding: 5px; }"
+      yield "#{@scope} table pre { margin: 0; }"
+
+      styles.each do |tok, style|
+        Style.new(self, style).render(css_selector(tok), &b)
+      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
+
+  private
+    def css_selector(token)
+      inflate_token(token).map do |tok|
+        raise "unknown token: #{tok.inspect}" if tok.shortname.nil?
+
+        single_css_selector(tok)
+      end.join(', ')
+    end
+
+    def single_css_selector(token)
+      return @scope if token == Text
+
+      "#{@scope} .#{token.shortname}"
+    end
+
+    # yield all of the tokens that should be styled the same
+    # as the given token.  Essentially this recursively all of
+    # the subtokens, except those which are more specifically
+    # styled.
+    def inflate_token(tok, &b)
+      return enum_for(:inflate_token, tok) unless block_given?
+
+      yield tok
+      tok.sub_tokens.each do |(_, st)|
+        next if styles[st]
+
+        inflate_token(st, &b)
+      end
+    end
+  end
+end

data/lib/rouge/themes/base16.rb

@@ -0,0 +1,130 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Themes
+    # default base16 theme
+    # by Chris Kempson (http://chriskempson.com)
+    class Base16 < CSSTheme
+      name 'base16'
+
+      palette base00: "#151515"
+      palette base01: "#202020"
+      palette base02: "#303030"
+      palette base03: "#505050"
+      palette base04: "#b0b0b0"
+      palette base05: "#d0d0d0"
+      palette base06: "#e0e0e0"
+      palette base07: "#f5f5f5"
+      palette base08: "#ac4142"
+      palette base09: "#d28445"
+      palette base0A: "#f4bf75"
+      palette base0B: "#90a959"
+      palette base0C: "#75b5aa"
+      palette base0D: "#6a9fb5"
+      palette base0E: "#aa759f"
+      palette base0F: "#8f5536"
+
+      extend HasModes
+
+      def self.light!
+        mode :dark # indicate that there is a dark variant
+        mode! :light
+      end
+
+      def self.dark!
+        mode :light # indicate that there is a light variant
+        mode! :dark
+      end
+
+      def self.make_dark!
+        style Text, :fg => :base05, :bg => :base00
+      end
+
+      def self.make_light!
+        style Text, :fg => :base02
+      end
+
+      light!
+
+      style Error, :fg => :base00, :bg => :base08
+      style Comment, :fg => :base03
+
+      style Comment::Preproc,
+            Name::Tag, :fg => :base0A
+
+      style Operator,
+            Punctuation, :fg => :base05
+
+      style Generic::Inserted, :fg => :base0B
+      style Generic::Deleted, :fg => :base08
+      style Generic::Heading, :fg => :base0D, :bg => :base00, :bold => true
+
+      style Keyword, :fg => :base0E
+      style Keyword::Constant,
+            Keyword::Type, :fg => :base09
+
+      style Keyword::Declaration, :fg => :base09
+
+      style Literal::String, :fg => :base0B
+      style Literal::String::Regex, :fg => :base0C
+
+      style Literal::String::Interpol,
+            Literal::String::Escape, :fg => :base0F
+
+      style Name::Namespace,
+            Name::Class,
+            Name::Constant, :fg => :base0A
+
+      style Name::Attribute, :fg => :base0D
+
+      style Literal::Number,
+            Literal::String::Symbol, :fg => :base0B
+
+      class Solarized < Base16
+        name 'base16.solarized'
+        light!
+        # author "Ethan Schoonover (http://ethanschoonover.com/solarized)"
+
+        palette base00: "#002b36"
+        palette base01: "#073642"
+        palette base02: "#586e75"
+        palette base03: "#657b83"
+        palette base04: "#839496"
+        palette base05: "#93a1a1"
+        palette base06: "#eee8d5"
+        palette base07: "#fdf6e3"
+        palette base08: "#dc322f"
+        palette base09: "#cb4b16"
+        palette base0A: "#b58900"
+        palette base0B: "#859900"
+        palette base0C: "#2aa198"
+        palette base0D: "#268bd2"
+        palette base0E: "#6c71c4"
+        palette base0F: "#d33682"
+      end
+
+      class Monokai < Base16
+        name 'base16.monokai'
+        dark!
+
+        # author "Wimer Hazenberg (http://www.monokai.nl)"
+        palette base00: "#272822"
+        palette base01: "#383830"
+        palette base02: "#49483e"
+        palette base03: "#75715e"
+        palette base04: "#a59f85"
+        palette base05: "#f8f8f2"
+        palette base06: "#f5f4f1"
+        palette base07: "#f9f8f5"
+        palette base08: "#f92672"
+        palette base09: "#fd971f"
+        palette base0A: "#f4bf75"
+        palette base0B: "#a6e22e"
+        palette base0C: "#a1efe4"
+        palette base0D: "#66d9ef"
+        palette base0E: "#ae81ff"
+        palette base0F: "#cc6633"
+      end
+    end
+  end
+end

data/lib/rouge/themes/colorful.rb

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*- #
+
+module Rouge
+  module Themes
+    # stolen from pygments
+    class Colorful < CSSTheme
+      name 'colorful'
+
+      style Text,                        :fg => "#bbbbbb", :bg => '#000'
+
+      style Comment,                     :fg => "#888"
+      style Comment::Preproc,            :fg => "#579"
+      style Comment::Special,            :fg => "#cc0000", :bold => true
+
+      style Keyword,                     :fg => "#080", :bold => true
+      style Keyword::Pseudo,             :fg => "#038"
+      style Keyword::Type,               :fg => "#339"
+
+      style Operator,                    :fg => "#333"
+      style Operator::Word,              :fg => "#000", :bold => true
+
+      style Name::Builtin,               :fg => "#007020"
+      style Name::Function,              :fg => "#06B", :bold => true
+      style Name::Class,                 :fg => "#B06", :bold => true
+      style Name::Namespace,             :fg => "#0e84b5", :bold => true
+      style Name::Exception,             :fg => "#F00", :bold => true
+      style Name::Variable,              :fg => "#963"
+      style Name::Variable::Instance,    :fg => "#33B"
+      style Name::Variable::Class,       :fg => "#369"
+      style Name::Variable::Global,      :fg => "#d70", :bold => true
+      style Name::Constant,              :fg => "#036", :bold => true
+      style Name::Label,                 :fg => "#970", :bold => true
+      style Name::Entity,                :fg => "#800", :bold => true
+      style Name::Attribute,             :fg => "#00C"
+      style Name::Tag,                   :fg => "#070"
+      style Name::Decorator,             :fg => "#555", :bold => true
+
+      style Literal::String,             :bg => "#fff0f0"
+      style Literal::String::Char,       :fg => "#04D"
+      style Literal::String::Doc,        :fg => "#D42"
+      style Literal::String::Interpol,   :bg => "#eee"
+      style Literal::String::Escape,     :fg => "#666", :bold => true
+      style Literal::String::Regex,      :fg => "#000", :bg => "#fff0ff"
+      style Literal::String::Symbol,     :fg => "#A60"
+      style Literal::String::Other,      :fg => "#D20"
+
+      style Literal::Number,             :fg => "#60E", :bold => true
+      style Literal::Number::Integer,    :fg => "#00D", :bold => true
+      style Literal::Number::Float,      :fg => "#60E", :bold => true
+      style Literal::Number::Hex,        :fg => "#058", :bold => true
+      style Literal::Number::Oct,        :fg => "#40E", :bold => true
+
+      style Generic::Heading,            :fg => "#000080", :bold => true
+      style Generic::Subheading,         :fg => "#800080", :bold => true
+      style Generic::Deleted,            :fg => "#A00000"
+      style Generic::Inserted,           :fg => "#00A000"
+      style Generic::Error,              :fg => "#FF0000"
+      style Generic::Emph,               :italic => true
+      style Generic::Strong,             :bold => true
+      style Generic::Prompt,             :fg => "#c65d09", :bold => true
+      style Generic::Output,             :fg => "#888"
+      style Generic::Traceback,          :fg => "#04D"
+
+      style Error,                       :fg => "#F00", :bg => "#FAA"
+    end
+  end
+end