Module: CodeRay::Encoders::HTML::Output

Extended by:
Template::Simple
Defined in:
lib/coderay/encoders/html/output.rb,
lib/coderay/encoders/html/numerization.rb

Overview

This module is included in the output String from thew HTML Encoder.

It provides methods like wrap, div, page etc.

Remember to use #clone instead of #dup to keep the modules the object was extended with.

TODO: more doc.

Defined Under Namespace

Classes: Template

Constant Summary collapse

SPAN =

– don’t include the templates in docu

`<span class="CodeRay"><%CONTENT%></span>`
DIV = 
` str  #` <-- for stupid editors
      Template.new str
    end
  end
end

extend Template::Simple

#-- don't include the templates in docu

SPAN = `<span class="CodeRay"><%CONTENT%></span>`

DIV = <<-`DIV`
<div class="CodeRay">
  <div class="code"><pre><%CONTENT%></pre></div>
</div>
DIV
TABLE = 
module CodeRay
module Encoders

  class HTML

    # This module is included in the output String from thew HTML Encoder.
    #
    # It provides methods like wrap, div, page etc.
    #
    # Remember to use #clone instead of #dup to keep the modules the object was
    # extended with.
    #
    # TODO: more doc.
    module Output

require 'coderay/encoders/html/numerization.rb'

attr_accessor :css

class << self

  # This makes Output look like a class.
  #
  # Example:
  #
  #  a = Output.new '<span class="co">Code</span>'
  #  a.wrap! :page
  def new string, css = CSS.new, element = nil
    output = string.clone.extend self
    output.wrapped_in = element
    output.css = css
    output
  end

  # Raises an exception if an object that doesn't respond to to_str is extended by Output,
  # to prevent users from misuse. Use Module#remove_method to disable.
  def extended o
    warn "The Output module is intended to extend instances of String, not #{o.class}." unless o.respond_to? :to_str
  end

  def make_stylesheet css, in_tag = false
    sheet = css.stylesheet
    sheet = <<-CSS if in_tag
<style type="text/css">
#{sheet}
</style>
    CSS
    sheet
  end

  def page_template_for_css css
    sheet = make_stylesheet css
    PAGE.apply 'CSS', sheet
  end

  # Define a new wrapper. This is meta programming.
  def wrapper *wrappers
    wrappers.each do |wrapper|
      define_method wrapper do |*args|
        wrap wrapper, *args
      end
      define_method "#{wrapper}!".to_sym do |*args|
        wrap! wrapper, *args
      end
    end
  end

end

wrapper :div, :span, :page

def wrapped_in? element
  wrapped_in == element
end

def wrapped_in
  @wrapped_in ||= nil
end
attr_writer :wrapped_in

def wrap_in template
  clone.wrap_in! template
end

def wrap_in! template
  Template.wrap! self, template, 'CONTENT'
  self
end

def apply_title! title
  self.sub!(/(<title>)(<\/title>)/) { $1 + title + $2 }
  self
end

def wrap! element, *args
  return self if not element or element == wrapped_in
  case element
  when :div
    raise "Can't wrap %p in %p" % [wrapped_in, element] unless wrapped_in? nil
    wrap_in! DIV
  when :span
    raise "Can't wrap %p in %p" % [wrapped_in, element] unless wrapped_in? nil
    wrap_in! SPAN
  when :page
    wrap! :div if wrapped_in? nil
    raise "Can't wrap %p in %p" % [wrapped_in, element] unless wrapped_in? :div
    wrap_in! Output.page_template_for_css(@css)
    if args.first.is_a?(Hash) && title = args.first[:title]
      apply_title! title
    end
    self
  when nil
    return self
  else
    raise "Unknown value %p for :wrap" % element
  end
  @wrapped_in = element
  self
end

def wrap *args
  clone.wrap!(*args)
end

def stylesheet in_tag = false
  Output.make_stylesheet @css, in_tag
end

class Template < String

  def self.wrap! str, template, target
    target = Regexp.new(Regexp.escape("<%#{target}%>"))
    if template =~ target
      str[0,0] = $`
      str << $'
    else
      raise "Template target <%%%p%%> not found" % target
    end
  end

  def apply target, replacement
    target = Regexp.new(Regexp.escape("<%#{target}%>"))
    if self =~ target
      Template.new($` + replacement + $')
    else
      raise "Template target <%%%p%%> not found" % target
    end
  end

  module Simple
    def ` str  #` <-- for stupid editors
      Template.new str
    end
  end
end

extend Template::Simple

#-- don't include the templates in docu

SPAN = `<span class="CodeRay"><%CONTENT%></span>`

DIV = <<-`DIV`
<div class="CodeRay">
  <div class="code"><pre><%CONTENT%></pre></div>
</div>
DIV

TABLE = <<-`TABLE`
<table class="CodeRay"><tr>
  <td class="line_numbers" title="click to toggle" onclick="with (this.firstChild.style) { display = (display == '') ? 'none' : '' }"><pre><%LINE_NUMBERS%></pre></td>
  <td class="code"><pre ondblclick="with (this.style) { overflow = (overflow == 'auto' || overflow == '') ? 'visible' : 'auto' }"><%CONTENT%></pre></td>
</tr></table>
TABLE
LIST =

title=“double click to expand”

module CodeRay
module Encoders

  class HTML

    # This module is included in the output String from thew HTML Encoder.
    #
    # It provides methods like wrap, div, page etc.
    #
    # Remember to use #clone instead of #dup to keep the modules the object was
    # extended with.
    #
    # TODO: more doc.
    module Output

require 'coderay/encoders/html/numerization.rb'

attr_accessor :css

class << self

  # This makes Output look like a class.
  #
  # Example:
  #
  #  a = Output.new '<span class="co">Code</span>'
  #  a.wrap! :page
  def new string, css = CSS.new, element = nil
    output = string.clone.extend self
    output.wrapped_in = element
    output.css = css
    output
  end

  # Raises an exception if an object that doesn't respond to to_str is extended by Output,
  # to prevent users from misuse. Use Module#remove_method to disable.
  def extended o
    warn "The Output module is intended to extend instances of String, not #{o.class}." unless o.respond_to? :to_str
  end

  def make_stylesheet css, in_tag = false
    sheet = css.stylesheet
    sheet = <<-CSS if in_tag
<style type="text/css">
#{sheet}
</style>
    CSS
    sheet
  end

  def page_template_for_css css
    sheet = make_stylesheet css
    PAGE.apply 'CSS', sheet
  end

  # Define a new wrapper. This is meta programming.
  def wrapper *wrappers
    wrappers.each do |wrapper|
      define_method wrapper do |*args|
        wrap wrapper, *args
      end
      define_method "#{wrapper}!".to_sym do |*args|
        wrap! wrapper, *args
      end
    end
  end

end

wrapper :div, :span, :page

def wrapped_in? element
  wrapped_in == element
end

def wrapped_in
  @wrapped_in ||= nil
end
attr_writer :wrapped_in

def wrap_in template
  clone.wrap_in! template
end

def wrap_in! template
  Template.wrap! self, template, 'CONTENT'
  self
end

def apply_title! title
  self.sub!(/(<title>)(<\/title>)/) { $1 + title + $2 }
  self
end

def wrap! element, *args
  return self if not element or element == wrapped_in
  case element
  when :div
    raise "Can't wrap %p in %p" % [wrapped_in, element] unless wrapped_in? nil
    wrap_in! DIV
  when :span
    raise "Can't wrap %p in %p" % [wrapped_in, element] unless wrapped_in? nil
    wrap_in! SPAN
  when :page
    wrap! :div if wrapped_in? nil
    raise "Can't wrap %p in %p" % [wrapped_in, element] unless wrapped_in? :div
    wrap_in! Output.page_template_for_css(@css)
    if args.first.is_a?(Hash) && title = args.first[:title]
      apply_title! title
    end
    self
  when nil
    return self
  else
    raise "Unknown value %p for :wrap" % element
  end
  @wrapped_in = element
  self
end

def wrap *args
  clone.wrap!(*args)
end

def stylesheet in_tag = false
  Output.make_stylesheet @css, in_tag
end

class Template < String

  def self.wrap! str, template, target
    target = Regexp.new(Regexp.escape("<%#{target}%>"))
    if template =~ target
      str[0,0] = $`
      str << $'
    else
      raise "Template target <%%%p%%> not found" % target
    end
  end

  def apply target, replacement
    target = Regexp.new(Regexp.escape("<%#{target}%>"))
    if self =~ target
      Template.new($` + replacement + $')
    else
      raise "Template target <%%%p%%> not found" % target
    end
  end

  module Simple
    def ` str  #` <-- for stupid editors
      Template.new str
    end
  end
end

extend Template::Simple

#-- don't include the templates in docu

SPAN = `<span class="CodeRay"><%CONTENT%></span>`

DIV = <<-`DIV`
<div class="CodeRay">
  <div class="code"><pre><%CONTENT%></pre></div>
</div>
DIV

TABLE = <<-`TABLE`
<table class="CodeRay"><tr>
  <td class="line_numbers" title="click to toggle" onclick="with (this.firstChild.style) { display = (display == '') ? 'none' : '' }"><pre><%LINE_NUMBERS%></pre></td>
  <td class="code"><pre ondblclick="with (this.style) { overflow = (overflow == 'auto' || overflow == '') ? 'visible' : 'auto' }"><%CONTENT%></pre></td>
</tr></table>
TABLE
# title="double click to expand"

LIST = <<-`LIST`
<ol class="CodeRay">
<%CONTENT%>
</ol>
LIST
PAGE = 
module CodeRay
module Encoders

  class HTML

    # This module is included in the output String from thew HTML Encoder.
    #
    # It provides methods like wrap, div, page etc.
    #
    # Remember to use #clone instead of #dup to keep the modules the object was
    # extended with.
    #
    # TODO: more doc.
    module Output

require 'coderay/encoders/html/numerization.rb'

attr_accessor :css

class << self

  # This makes Output look like a class.
  #
  # Example:
  #
  #  a = Output.new '<span class="co">Code</span>'
  #  a.wrap! :page
  def new string, css = CSS.new, element = nil
    output = string.clone.extend self
    output.wrapped_in = element
    output.css = css
    output
  end

  # Raises an exception if an object that doesn't respond to to_str is extended by Output,
  # to prevent users from misuse. Use Module#remove_method to disable.
  def extended o
    warn "The Output module is intended to extend instances of String, not #{o.class}." unless o.respond_to? :to_str
  end

  def make_stylesheet css, in_tag = false
    sheet = css.stylesheet
    sheet = <<-CSS if in_tag
<style type="text/css">
#{sheet}
</style>
    CSS
    sheet
  end

  def page_template_for_css css
    sheet = make_stylesheet css
    PAGE.apply 'CSS', sheet
  end

  # Define a new wrapper. This is meta programming.
  def wrapper *wrappers
    wrappers.each do |wrapper|
      define_method wrapper do |*args|
        wrap wrapper, *args
      end
      define_method "#{wrapper}!".to_sym do |*args|
        wrap! wrapper, *args
      end
    end
  end

end

wrapper :div, :span, :page

def wrapped_in? element
  wrapped_in == element
end

def wrapped_in
  @wrapped_in ||= nil
end
attr_writer :wrapped_in

def wrap_in template
  clone.wrap_in! template
end

def wrap_in! template
  Template.wrap! self, template, 'CONTENT'
  self
end

def apply_title! title
  self.sub!(/(<title>)(<\/title>)/) { $1 + title + $2 }
  self
end

def wrap! element, *args
  return self if not element or element == wrapped_in
  case element
  when :div
    raise "Can't wrap %p in %p" % [wrapped_in, element] unless wrapped_in? nil
    wrap_in! DIV
  when :span
    raise "Can't wrap %p in %p" % [wrapped_in, element] unless wrapped_in? nil
    wrap_in! SPAN
  when :page
    wrap! :div if wrapped_in? nil
    raise "Can't wrap %p in %p" % [wrapped_in, element] unless wrapped_in? :div
    wrap_in! Output.page_template_for_css(@css)
    if args.first.is_a?(Hash) && title = args.first[:title]
      apply_title! title
    end
    self
  when nil
    return self
  else
    raise "Unknown value %p for :wrap" % element
  end
  @wrapped_in = element
  self
end

def wrap *args
  clone.wrap!(*args)
end

def stylesheet in_tag = false
  Output.make_stylesheet @css, in_tag
end

class Template < String

  def self.wrap! str, template, target
    target = Regexp.new(Regexp.escape("<%#{target}%>"))
    if template =~ target
      str[0,0] = $`
      str << $'
    else
      raise "Template target <%%%p%%> not found" % target
    end
  end

  def apply target, replacement
    target = Regexp.new(Regexp.escape("<%#{target}%>"))
    if self =~ target
      Template.new($` + replacement + $')
    else
      raise "Template target <%%%p%%> not found" % target
    end
  end

  module Simple
    def ` str  #` <-- for stupid editors
      Template.new str
    end
  end
end

extend Template::Simple

#-- don't include the templates in docu

SPAN = `<span class="CodeRay"><%CONTENT%></span>`

DIV = <<-`DIV`
<div class="CodeRay">
  <div class="code"><pre><%CONTENT%></pre></div>
</div>
DIV

TABLE = <<-`TABLE`
<table class="CodeRay"><tr>
  <td class="line_numbers" title="click to toggle" onclick="with (this.firstChild.style) { display = (display == '') ? 'none' : '' }"><pre><%LINE_NUMBERS%></pre></td>
  <td class="code"><pre ondblclick="with (this.style) { overflow = (overflow == 'auto' || overflow == '') ? 'visible' : 'auto' }"><%CONTENT%></pre></td>
</tr></table>
TABLE
# title="double click to expand"

LIST = <<-`LIST`
<ol class="CodeRay">
<%CONTENT%>
</ol>
LIST

PAGE = <<-`PAGE`
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="de">
<head>
  <meta http-equiv="content-type" content="text/html; charset=utf-8" />
  <title></title>
  <style type="text/css">
<%CSS%>
  </style>
</head>
<body style="background-color: white;">

<%CONTENT%>
</body>
</html>
PAGE

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Template::Simple

`

Instance Attribute Details

#css ⇒ Object

Returns the value of attribute css.



18
19
20
 
# File 'lib/coderay/encoders/html/output.rb', line 18

def css
  @css
end

#wrapped_in ⇒ Object 



76
77
78
 
# File 'lib/coderay/encoders/html/output.rb', line 76

def wrapped_in
  @wrapped_in ||= nil
end

Class Method Details

.extended(o) ⇒ Object

Raises an exception if an object that doesn’t respond to to_str is extended by Output, to prevent users from misuse. Use Module#remove_method to disable.



37
38
39
 
# File 'lib/coderay/encoders/html/output.rb', line 37

def extended o
  warn "The Output module is intended to extend instances of String, not #{o.class}." unless o.respond_to? :to_str
end

.make_stylesheet(css, in_tag = false) ⇒ Object 



41
42
43
44
45
46
47
48
49
 
# File 'lib/coderay/encoders/html/output.rb', line 41

def make_stylesheet css, in_tag = false
  sheet = css.stylesheet
  sheet = <<-CSS if in_tag
<style type="text/css">
#{sheet}
</style>
  CSS
  sheet
end

.new(string, css = CSS.new, element = nil) ⇒ Object

This makes Output look like a class.

Example:

a = Output.new '<span class="co">Code</span>'
a.wrap! :page



28
29
30
31
32
33
 
# File 'lib/coderay/encoders/html/output.rb', line 28

def new string, css = CSS.new, element = nil
  output = string.clone.extend self
  output.wrapped_in = element
  output.css = css
  output
end

.page_template_for_css(css) ⇒ Object 



51
52
53
54
 
# File 'lib/coderay/encoders/html/output.rb', line 51

def page_template_for_css css
  sheet = make_stylesheet css
  PAGE.apply 'CSS', sheet
end

.wrapper(*wrappers) ⇒ Object

Define a new wrapper. This is meta programming.



57
58
59
60
61
62
63
64
65
66
 
# File 'lib/coderay/encoders/html/output.rb', line 57

def wrapper *wrappers
  wrappers.each do |wrapper|
    define_method wrapper do |*args|
      wrap wrapper, *args
    end
    define_method "#{wrapper}!".to_sym do |*args|
      wrap! wrapper, *args
    end
  end
end

Instance Method Details

#apply_title!(title) ⇒ Object 



90
91
92
93
 
# File 'lib/coderay/encoders/html/output.rb', line 90

def apply_title! title
  self.sub!(/(<title>)(<\/title>)/) { $1 + title + $2 }
  self
end

#line_count ⇒ Object 



117
118
119
120
121
122
123
124
125
126
 
# File 'lib/coderay/encoders/html/numerization.rb', line 117

def line_count
  line_count = count("\n")
  position_of_last_newline = rindex(?\n)
  if position_of_last_newline
    after_last_newline = self[position_of_last_newline + 1 .. -1]
    ends_with_newline = after_last_newline[/\A(?:<\/span>)*\z/]
    line_count += 1 if not ends_with_newline
  end
  line_count
end

#numerize(*args) ⇒ Object 



8
9
10
 
# File 'lib/coderay/encoders/html/numerization.rb', line 8

def numerize *args
  clone.numerize!(*args)
end

#numerize!(mode = :table, options = {}) ⇒ Object

:table => [:div, :page, nil],

  :inline => :all,
  :list => [:div, :page, nil]
}
NUMERIZABLE_WRAPPINGS.default = :all



19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/coderay/encoders/html/numerization.rb', line 19

def numerize! mode = :table, options = {}
  return self unless mode

  options = DEFAULT_OPTIONS.merge options

  start = options[:line_number_start]
  unless start.is_a? Integer
    raise ArgumentError, "Invalid value %p for :line_number_start; Integer expected." % start
  end

  #allowed_wrappings = NUMERIZABLE_WRAPPINGS[mode]
  #unless allowed_wrappings == :all or allowed_wrappings.include? options[:wrap]
  #  raise ArgumentError, "Can't numerize, :wrap must be in %p, but is %p" % [NUMERIZABLE_WRAPPINGS, options[:wrap]]
  #end

  bold_every = options[:bold_every]
  highlight_lines = options[:highlight_lines]
  bolding =
    if bold_every == false && highlight_lines == nil
      proc { |line| line.to_s }
    elsif highlight_lines.is_a? Enumerable
      highlight_lines = highlight_lines.to_set
      proc do |line|
        if highlight_lines.include? line
          "<strong class=\"highlighted\">#{line}</strong>"  # highlighted line numbers in bold
        else
          line.to_s
        end
      end
    elsif bold_every.is_a? Integer
      raise ArgumentError, ":bolding can't be 0." if bold_every == 0
      proc do |line|
        if line % bold_every == 0
          "<strong>#{line}</strong>"  # every bold_every-th number in bold
        else
          line.to_s
        end
      end
    else
      raise ArgumentError, 'Invalid value %p for :bolding; false or Integer expected.' % bold_every
    end

  case mode
  when :inline
    max_width = (start + line_count).to_s.size
    line_number = start
    gsub!(/^/) do
      line_number_text = bolding.call line_number
      indent = ' ' * (max_width - line_number.to_s.size)  # TODO: Optimize (10^x)
      res = "<span class=\"no\">#{indent}#{line_number_text}</span> "
      line_number += 1
      res
    end

  when :table
    # This is really ugly.
    # Because even monospace fonts seem to have different heights when bold,
    # I make the newline bold, both in the code and the line numbers.
    # FIXME Still not working perfect for Mr. Internet Exploder
    line_numbers = (start ... start + line_count).to_a.map(&bolding).join("\n")
    line_numbers << "\n"  # also for Mr. MS Internet Exploder :-/
    line_numbers.gsub!(/\n/) { "<tt>\n</tt>" }

    line_numbers_table_tpl = TABLE.apply('LINE_NUMBERS', line_numbers)
    gsub!(/<\/div>\n/) { '</div>' }
    gsub!(/\n/) { "<tt>\n</tt>" }
    wrap_in! line_numbers_table_tpl
    @wrapped_in = :div

  when :list
    opened_tags = []
    gsub!(/^.*$\n?/) do |line|
      line.chomp!

      open = opened_tags.join
      line.scan(%r!<(/)?span[^>]*>?!) do |close,|
        if close
          opened_tags.pop
        else
          opened_tags << $&
        end
      end
      close = '</span>' * opened_tags.size

      "<li>#{open}#{line}#{close}</li>\n"
    end
    chomp!("\n")
    wrap_in! LIST
    @wrapped_in = :div

  else
    raise ArgumentError, 'Unknown value %p for mode: expected one of %p' %
      [mode, [:table, :list, :inline]]
  end

  self
end

#stylesheet(in_tag = false) ⇒ Object 



125
126
127
 
# File 'lib/coderay/encoders/html/output.rb', line 125

def stylesheet in_tag = false
  Output.make_stylesheet @css, in_tag
end

#wrap(*args) ⇒ Object 



121
122
123
 
# File 'lib/coderay/encoders/html/output.rb', line 121

def wrap *args
  clone.wrap!(*args)
end

#wrap!(element, *args) ⇒ Object 



95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/coderay/encoders/html/output.rb', line 95

def wrap! element, *args
  return self if not element or element == wrapped_in
  case element
  when :div
    raise "Can't wrap %p in %p" % [wrapped_in, element] unless wrapped_in? nil
    wrap_in! DIV
  when :span
    raise "Can't wrap %p in %p" % [wrapped_in, element] unless wrapped_in? nil
    wrap_in! SPAN
  when :page
    wrap! :div if wrapped_in? nil
    raise "Can't wrap %p in %p" % [wrapped_in, element] unless wrapped_in? :div
    wrap_in! Output.page_template_for_css(@css)
    if args.first.is_a?(Hash) && title = args.first[:title]
      apply_title! title
    end
    self
  when nil
    return self
  else
    raise "Unknown value %p for :wrap" % element
  end
  @wrapped_in = element
  self
end

#wrap_in(template) ⇒ Object 



81
82
83
 
# File 'lib/coderay/encoders/html/output.rb', line 81

def wrap_in template
  clone.wrap_in! template
end

#wrap_in!(template) ⇒ Object 



85
86
87
88
 
# File 'lib/coderay/encoders/html/output.rb', line 85

def wrap_in! template
  Template.wrap! self, template, 'CONTENT'
  self
end

#wrapped_in?(element) ⇒ Boolean

Returns:

  • (Boolean) 


72
73
74
 
# File 'lib/coderay/encoders/html/output.rb', line 72

def wrapped_in? element
  wrapped_in == element
end