murdoc 0.1.13 → 0.2.0

data/lib/murdoc/languages/base.rb

@@ -0,0 +1,56 @@
+module Murdoc
+  module Languages
+    # Base language module
+    #
+    # Any new language module should inherit from Base, redefine .extensions
+    # and .comment_symbols methods, if needed, and add itself to Languages.map
+    # map.
+    class Base
+      def self.applies_for?(filename)
+        if extensions.include?(File.extname(filename).sub(/^\./, ''))
+          true
+        else
+          false
+        end
+      end
+
+      def self.annotation_only?
+        false
+      end
+
+      def self.extensions
+        []
+      end
+
+      def self.comment_symbols
+        {
+          single_line: nil,
+          multiline: nil
+        }
+      end
+
+      def self.name
+        super.sub(/^(.*::)?([^:]+)$/, '\\2').
+              gsub(/([a-z])([A-Z])/, '\\1_\\2').
+              downcase.to_sym
+      end
+    end
+
+    def self.map
+      @map ||= {}
+    end
+
+    def self.list
+      map.values
+    end
+
+    def self.get(name)
+      map.fetch(name, Base)
+    end
+
+    def self.detect(filename)
+      name, lang = map.detect {|name, lang| lang.applies_for?(filename) }
+      name
+    end
+  end
+end

data/lib/murdoc/languages/coffeescript.rb

@@ -0,0 +1,23 @@
+# Html language module
+module Murdoc
+  module Languages
+    class Coffeescript < Base
+      def self.comment_symbols
+        {
+          single_line: '#',
+          multiline: {
+            :begin => "###",
+            :end => "###"
+          }
+        }
+      end
+
+      def self.extensions
+        ['coffee']
+      end
+    end
+
+    self.map[:coffee] = Coffeescript
+    self.map[:coffeescript] = Coffeescript
+  end
+end

data/lib/murdoc/languages/html.rb

@@ -1,43 +1,22 @@
 # Html language module
 module Murdoc
   module Languages
-    module Html
-      module Annotator
-        def self.included(base)
-          base.extend ClassMethods
-        end
-
-        module ClassMethods
-          protected
-          def detect_source_type_from_filename(filename)
-            if File.extname(filename) == ".html"
-              :html
-            else
-              super if defined?(super)
-            end
-          end
-        end
+    class Html < Base
+      def self.comment_symbols
+        {
+          single_line: nil,
+          multiline: {
+            :begin => "<!--",
+            :end => "-->"
+          }
+        }
       end
 
-      module CommentSymbols
-        protected
-        def comment_symbols
-          if source_type == "html"
-            {:single_line => nil, :multiline => {:begin => "<!--", :end => "-->"}}
-          else
-            super if defined?(super)
-          end
-        end
+      def self.extensions
+        ['html']
       end
     end
-  end
-
-  class Annotator
-    include Languages::Html::Annotator
-    include Languages::Html::CommentSymbols
-  end
 
-  class Paragraph
-    include Languages::Html::CommentSymbols
+    self.map[:html] = Html
   end
 end

data/lib/murdoc/languages/javascript.rb

@@ -1,43 +1,22 @@
-# Javascript language module
 module Murdoc
   module Languages
-    module Javascript
-      module Annotator
-        def self.included(base)
-          base.extend ClassMethods
-        end
-
-        module ClassMethods
-          protected
-          def detect_source_type_from_filename(filename)
-            if File.extname(filename) == ".js"
-              :javascript
-            else
-              super if defined?(super)
-            end
-          end
-        end
+    class Javascript < Base
+      def self.comment_symbols
+        {
+          single_line: '//',
+          multiline: {
+            :begin => "/*",
+            :end => "*/"
+          }
+        }
       end
 
-      module CommentSymbols
-        protected
-        def comment_symbols
-          if source_type == "javascript"
-            {:single_line => "//", :multiline => {:begin => "/*", :end => "*/"}}
-          else
-            super if defined?(super)
-          end
-        end
+      def self.extensions
+        ['js']
       end
     end
-  end
-
-  class Annotator
-    include Languages::Javascript::Annotator
-    include Languages::Javascript::CommentSymbols
-  end
 
-  class Paragraph
-    include Languages::Javascript::CommentSymbols
+    self.map[:js] = Javascript
+    self.map[:javascript] = Javascript
   end
-end
+end

data/lib/murdoc/languages/markdown.rb

@@ -0,0 +1,24 @@
+# Html language module
+module Murdoc
+  module Languages
+    class Markdown < Base
+      def self.comment_symbols
+        {
+          single_line: nil,
+          multiline: nil
+        }
+      end
+
+      def self.annotation_only?
+        true
+      end
+
+      def self.extensions
+        ['markdown', 'md']
+      end
+    end
+
+    self.map[:md] = Markdown
+    self.map[:markdown] = Markdown
+  end
+end

data/lib/murdoc/languages/ruby.rb

@@ -1,43 +1,22 @@
 # Ruby language module
 module Murdoc
   module Languages
-    module Ruby
-      module Annotator
-        def self.included(base)
-          base.extend ClassMethods
-        end
-
-        module ClassMethods
-          protected
-          def detect_source_type_from_filename(filename)
-            if File.extname(filename) == ".rb"
-              :ruby
-            else
-              super if defined?(super)
-            end
-          end
-        end
+    class Ruby < Base
+      def self.comment_symbols
+        {
+          single_line: '#',
+          multiline: {
+            :begin => "=begin",
+            :end => "=end"
+          }
+        }
       end
 
-      module CommentSymbols
-        protected
-        def comment_symbols
-          if source_type == "ruby"
-            {:single_line => "#", :multiline => {:begin => "=begin", :end => "=end"}}
-          else
-            super if defined?(super)
-          end
-        end
+      def self.extensions
+        ['rb']
       end
     end
-  end
-
-  class Annotator
-    include Languages::Ruby::Annotator
-    include Languages::Ruby::CommentSymbols
-  end
 
-  class Paragraph
-    include Languages::Ruby::CommentSymbols
+    self.map[:ruby] = Ruby
   end
-end
+end

data/lib/murdoc/paragraph.rb

@@ -13,48 +13,12 @@ module Murdoc
     attr_accessor :annotation
     attr_accessor :source_type
     attr_accessor :starting_line
-    attr_accessor :options
 
-    def initialize(source, annotation, starting_line = 0, source_type = nil, options ={})
+    def initialize(source, annotation, starting_line = 0, source_type = nil)
       self.source = source
       self.annotation = annotation
       self.starting_line = starting_line
       self.source_type = source_type
-      self.options = options
-    end
-
-    def source_type
-      @source_type
-    end
-
-    def source_type=(source_type)
-      @source_type = source_type.to_s
-    end
-
-
-    def formatted_annotation
-      if defined?(Markdown)
-        Markdown.new(annotation, :smart).to_html
-      else
-        Kramdown::Document.new(annotation, :input => :markdown).to_html
-      end
-    end
-
-    def formatted_source
-      @formatted_source ||= if pygments_installed? && options[:highlight_source]
-        IO.popen("pygmentize -l #{source_type} -O encoding=UTF8 -f html -O nowrap", "w+") do |pipe|
-          pipe.puts source
-          pipe.close_write
-          pipe.read
-        end
-      else
-        CGI.escapeHTML(source)
-      end
-    end
-
-    protected
-    def pygments_installed?
-      @@pygments_installed ||= ENV['PATH'].split(':').any? { |dir| File.exist?("#{dir}/pygmentize") }
     end
   end
 end

data/lib/murdoc/{formatter.rb → renderer.rb}

@@ -1,7 +1,7 @@
 require "haml"
 
 module Murdoc
-  class Formatter
+  class Renderer
     attr_accessor :template
 
     def initialize(template_or_filename)
@@ -16,4 +16,4 @@ module Murdoc
       ::Haml::Engine.new(template).render(self, locals)
     end
   end
-end
+end

data/lib/murdoc/scanner.rb

@@ -0,0 +1,138 @@
+require 'strscan'
+
+module Murdoc
+  class Scanner
+    attr_reader :language
+
+    def initialize(language)
+      @language = language
+    end
+
+    def call(source, do_not_count_comment_lines = false)
+      paragraphs = []
+      ss = StringScanner.new(source)
+      line = i = src_line = 0
+
+      loop do
+        comment_lines = []
+        code_lines = []
+
+        # Multi line comments
+        if has_mlc?
+          while (ss.scan(mlcb_regex))
+            comment = ''
+
+            while (!ss.eos? && !ss.match?(/.*#{mlce_regex}/))
+              i += 1
+              comment << ss.scan(/.*?$/)
+              comment << ss.getch.to_s
+            end
+
+            if (fragment = ss.scan(/.*#{mlce_regex}/))
+              comment << fragment.sub(mlce_regex, '')
+            end
+
+            ss.scan(/[ \t]*\n/) # skip trailing whitespace and a newline
+            comment_lines << remove_common_space_prefix(comment)
+          end
+        end
+
+        # Single line comments
+        if has_slc?
+          while (ss.scan(slc_regex))
+            comment = ''
+            comment << ss.scan(/.*?$/)
+            comment << ss.getch.to_s
+            comment_lines << comment
+            i += 1
+          end
+        end
+
+
+        # Code
+        empty_leading_lines_count = skip_empty_lines(ss)
+        i += empty_leading_lines_count
+        src_line += empty_leading_lines_count
+
+        line = do_not_count_comment_lines ? src_line : i
+        while (!comment_start?(ss) && !ss.eos?)
+          code = ss.scan(/^.*?$/)
+          code << ss.getch.to_s
+          code_lines << code
+          i += 1
+          src_line += 1
+        end
+
+        code = post_process_code(code_lines.join(''))
+        comments = post_process_comments(comment_lines.join(''))
+
+        paragraphs << Paragraph.new(code,
+                                    comments,
+                                    line,
+                                    language.name)
+
+        break if ss.eos?
+      end
+
+      paragraphs
+    end
+
+    protected
+
+    def post_process_code(code)
+      code.rstrip
+    end
+
+    def post_process_comments(comments)
+      comments.strip.gsub(/^\s(\S)/, '\\1')
+    end
+
+    def comment_start?(ss)
+      (has_slc? && ss.match?(slc_regex)) ||
+          (has_mlc? && ss.match?(mlcb_regex))
+    end
+
+    def skip_empty_lines(ss)
+      i = 0
+      while (ss.scan(/\s*?$/) && !ss.eos?)
+        i += 1
+        ss.getch
+      end
+      i
+    end
+
+    def remove_common_space_prefix(str)
+      lines = str.split("\n")
+      # delete empty leading and trailing lines
+      lines.delete_at(0) while lines[0] && lines[0].empty?
+      lines.delete_at(-1) while lines[-1] && lines[-1].empty?
+
+      prefix_lengths =  lines.map {|l| l.match(/^( *)/)[1].length }.reject(&:zero?)
+      prefix = ' ' * (prefix_lengths.min || 0)
+      lines.map {|line| line.sub(/^#{prefix}/, '') }.join("\n")
+    end
+
+    def has_slc?
+      !!language.comment_symbols[:single_line]
+    end
+
+    def slc_regex
+      return @slc_regex unless @slc_regex.nil?
+      @slc_regex = has_slc? && /^[ \t]*#{Regexp.escape(language.comment_symbols[:single_line])}/
+    end
+
+    def has_mlc?
+      language.comment_symbols[:multiline] &&
+          language.comment_symbols[:multiline][:begin] &&
+          language.comment_symbols[:multiline][:end]
+    end
+
+    def mlcb_regex
+      has_mlc? && /^[ \t]*#{Regexp.escape(language.comment_symbols[:multiline][:begin])}/
+    end
+
+    def mlce_regex
+      has_mlc? && /#{Regexp.escape(language.comment_symbols[:multiline][:end])}/
+    end
+  end
+end