syntaxi 0.5.0

data/lib/syntaxi.rb

@@ -0,0 +1,274 @@
+require 'syntax/convertors/html'
+
+# Syntaxi is a class for formatting code blocks in your HTML. It can:
+# * Add line numbers
+# * Wrap long lines automatically
+# * Perform syntax coloring using Jamis Buck's Syntax gem
+#
+# == How to Write your Code Block
+#
+# In order for Syntaxi to do its magic, you'll need to write your code blocks
+# like this:
+#
+#   [code lang="ruby"]
+#   def foo
+#     puts 'bar'
+#   end
+#   [/code]
+#
+# The square bracket syntax allows Syntaxi to work seamlessly in HTML,
+# Markdown, and Textile alike. The +lang+ attribute specifies the language
+# of the code block.
+#
+# == How to Process the Text
+#
+# Having Syntaxi format your code containing the special code blocks is easy.
+# Lets say your text is stored in +text+. To format this text simply do the
+# following:
+#
+#   text = Syntaxi.new(text).process
+#
+# == Syntax coloring
+#
+# If the +lang+ attribute you specified in your opening code block tag
+# is recognized by Jamis Buck's Syntax gem, the block will have syntax coloring
+# applied to it automatically. See the documentation for Syntax to learn
+# more about how to style the different spans it produces.
+#
+# == Line Numbers
+#
+# Syntaxi can also add line numbers to your code blocks. It can do this in two
+# different ways:
+# * Inline line numbering will add line numbers at the beginning of each line.
+# * Floating line numbering will create a <div> to contain the line numbers and
+#   float that <div> left, so that selecting text from the code block will
+#   select only the code, and not the line numbers.
+#
+# By default, line numbering is set to +inline+. To change the line number
+# method, simply call line_number_method= like so:
+#
+#   Syntaxi.line_number_method = 'floating'
+#
+# Valid values are 'none', 'inline', and 'floating'
+#
+# == Line Wrap
+#
+# Because your code blocks will often have lines that are longer than the
+# available width, Syntaxi can wrap long lines for you. If possible the line
+# break will done on a space. No line numbers will appear on the wrapped
+# portions of long lines (but subsequent lines will still have the right
+# line numbers).
+#
+# By default, line wrap is enabled and wraps on column 60. To disable line 
+# wrap, simply call wrap_enabled= with +false+:
+#
+#   Syntaxi.wrap_enabled = false
+#
+# To change the column on which to wrap, call wrap_at_column= like this:
+#
+#   Syntaxi.wrap_at_column = 70
+#
+# == Where to set the Options
+#
+# Since the configuration options are stored as class variables, you need only change
+# them once, and all future instances of Syntaxi will use the new values.
+# If your entire application will use the same values, simply set the values
+# to your liking at the beginning of execution. In Ruby on Rails, an ideal
+# place to do this is in [RAILS_ROOT]/config/environment.rb.
+class Syntaxi
+
+  # Specifies the line numbering method
+  # one of [none|floating|inline]
+  @@line_number_method = 'inline' 
+
+  # Sets the line number method. Valid values are 'none', 'floating', or
+  # 'inline'. Default is +'inline'+
+  #
+  # See Syntaxi class documentation for more information.
+  def self.line_number_method=(meth)
+    %w{none floating inline}.include?(meth) || raise("Invalid Line Number Method. Must be one of [none|floating|inline].")
+    @@line_number_method = meth
+  end
+
+  # specifies whether or not to wrap long lines
+  @@wrap_enabled = true
+
+  # Sets whether or not to wrap long lines. Defaults is +true+
+  #
+  # See Syntaxi class documentation for more information.
+  def self.wrap_enabled=(enabled)
+    @@wrap_enabled = enabled
+  end
+
+  # Specifies the column on which to wrap if line wrap is enabled
+  @@wrap_at_column = 60
+
+  # Sets the column on which to wrap if line wrap is enabled. Defaults to
+  # +65+
+  #
+  # See Syntaxi class documentation for more information.
+  def self.wrap_at_column=(col)
+    @@wrap_at_column = col
+  end
+
+  # Instance variable to hold the code
+	@text
+
+	def initialize(text) #:nodoc:
+		@text = text
+	end
+
+  # Processes the text that this object was initialized with according to the
+  # configuration parameters.
+	def process
+		# pick out any existing <code> blocks and replace with a placeholder
+    ignores = {}
+		ignore_index = 0
+		@text.gsub!(/<code.*?code>/m){
+			ignore_index += 1
+			ignores[ignore_index] = $&
+			"<!--syntaxi-code-ignore-block-" + ignore_index.to_s + "-->"
+		}
+
+		# format the specified sections
+		@text.gsub!(/\[code.+?lang\s?=\s?['"](.*?)['"].*?\](.*?)\[\/code\]/m){
+      language = $1
+      code = $2
+
+      # fix any spacy weirdness
+      code = code.sub(/^\s*\n*/, '')
+      code = code.gsub(/\t/, '  ')
+      code = code.gsub(/\r\n/, "\n")
+
+      # count the number of lines in this code block for later
+      line_count = code.split("\n").length
+
+      # do line wrapping if required
+      code = wrap_long_lines(code, line_count) if @@wrap_enabled
+
+      # do the syntax coloring
+      code = Syntax::Convertors::HTML.for_syntax(language).convert(code, false)
+
+      # do the line numbering
+      code = 
+        case @@line_number_method
+          when 'none'
+            add_no_line_numbers(code)
+          when 'floating'
+            add_floating_line_numbers(code, line_count)
+          when 'inline'
+            add_inline_line_numbers(code, line_count)
+        end
+
+      # return the code to the gsub
+			code
+		}
+
+    # put the existing <code> blocks back in
+		@text.gsub!(/<!--syntaxi-code-ignore-block-(\d+?)-->/) {
+			ignores[$1.to_i]
+		}
+
+    # return all the processed text
+    @text
+	end
+
+  private
+
+  # No line numbering required, so just wrap the code block
+  def add_no_line_numbers(code) #:nodoc:
+    code.gsub!(/\a/, '')
+    "<pre><code>" + code + "</code></pre>"
+  end
+
+  # Inline line numbers are just numbers at the beginning of the actual line
+  # followed by some spaces.
+	def add_inline_line_numbers(code, lines) #:nodoc:
+		i = 0
+		out = ''
+		width = lines.to_s.length
+		code.each_line do |line|
+      if line =~ /\a/
+        out += line.sub(/\a/, '')
+      else
+        i += 1
+			  out += "<span class=\"line_number\">" + i.to_s.rjust(width) + "</span>" + "  " + line
+      end
+		end
+		"<pre><code>" + out + "</code></pre>"
+	end
+
+  # Floating line numbers are created by floating the line numbers left. This
+  # makes is possible to select the code in the web browser without also
+  # selecting the line numbers. Very useful, but can act strangely in some
+  # browsers, so use with caution
+  def add_floating_line_numbers(code, lines) #:nodoc:
+    i = 0
+		out_numbers = '<pre style="overflow: hidden;"><code class="line_number" style="float: left; margin-right: 1em">'
+    out_code = '<code>'
+		width = lines.to_s.length
+		code.each_line do |line|
+      if line =~ /\a/
+        out_numbers += "&nbsp;\n"
+        out_code += line.sub(/\a/, '')
+      else
+        i += 1
+        out_numbers += i.to_s.rjust(width).gsub(/ /, '&nbsp;') + "\n"
+			  out_code += line.sub(/^ */) {
+          $& ? $&.gsub(/ /, '&nbsp;') : ''
+        }
+      end
+		end
+		out_numbers.chomp + '</code>' + out_code + '</code></pre>'
+  end
+
+  # Wrap long lines using intelligent line wrap (indent wrapped lines to match
+  # the indent of the line being wrapped)
+  def wrap_long_lines(code, lines) #:nodoc:
+    out = ''
+    line_wrap_indicator = "\a" # bell character is not modified by Syntax
+    line_num_width = lines.to_s.length # for inline line numbering
+
+    code.each_line do |line|
+      if line.length > @@wrap_at_column
+
+        # determine proper indent
+        line =~ /^\s*/
+        if @@line_number_method == 'inline'
+          indent = '  ' + (' ' * ($&.length + line_num_width))
+        else
+          indent = ' ' * $&.length
+        end
+
+        # split this line up into mutliple lines. break on spaces if possible
+        first_line = true
+        max_line_length = @@wrap_at_column
+        while line
+          if line.length < max_line_length
+            # last part
+            out += line_wrap_indicator + indent + line
+            line = nil
+          elsif i = line.rindex(/\s/, max_line_length)
+            # long part with a space in it
+            out += line_wrap_indicator + indent unless first_line
+            out += line[0, i + 1] + "\n"
+            line = line[i + 1, line.length]
+          else
+            # long part with no space in it
+            out += line_wrap_indicator + indent unless first_line
+            out += line[0, max_line_length] + "\n"
+            line = line[max_line_length, line.length]
+          end
+          # not the first line anymore
+          first_line = false
+          max_line_length = @@wrap_at_column - indent.length
+        end
+
+      else
+        out += line
+      end
+    end
+    out
+  end
+
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.8.11
+specification_version: 1
+name: syntaxi
+version: !ruby/object:Gem::Version 
+  version: 0.5.0
+date: 2005-12-12 00:00:00 -08:00
+summary: "Syntaxi formats code blocks in text (line number, line wrap, syntax color)"
+require_paths: 
+  - lib
+email: tom@cube6media.com
+homepage: http://syntaxi.rubyforge.org
+rubyforge_project: syntaxi
+description: 
+autorequire: syntaxi
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+authors: 
+  - Tom Werner
+files: 
+  - lib/syntaxi.rb
+test_files: []
+rdoc_options: []
+extra_rdoc_files: []
+executables: []
+extensions: []
+requirements: []
+dependencies: 
+  - !ruby/object:Gem::Dependency 
+    name: syntax
+    version_requirement: 
+    version_requirements: !ruby/object:Gem::Version::Requirement 
+      requirements: 
+        - 
+          - "="
+          - !ruby/object:Gem::Version 
+            version: 1.0.0
+      version: