murdoc 0.1.13 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ff69e5073e356e1352ca86544832cf54a4aa59fd
-  data.tar.gz: 157c3522d529acf574fb7bca9c673dc5fde93d23
+  metadata.gz: 6ef249b35659b0df1ac35d233d7ded20dc29e45b
+  data.tar.gz: 7017b589cae5baf9511e1aaf065931b32d30c75a
 SHA512:
-  metadata.gz: d48ee92831d38fb6299f1c1ba6fffc56579a4b0b99e8235d9813c50daec1146b9d2d1c0eca56222f69280ffe90c2eb8b7320c67ebec150619ff26036dd84f837
-  data.tar.gz: 403188b4870aa15f253dd6222f9f5e49e8751965b15d2e1a7b11836d8d165be191103fdd2b655d7290741e6a560ef340a1f8ff6958d45bd83f4cd0bb8f86fc95
+  metadata.gz: 935006a39b60ce7b2d6c2d1c4eb8247758f36a60a2ce2174757d8befea55231dc5916b3c167d8d1c26b1f693c7eff06b0a7c7c4ca0f2713c12791b0b9d102e15
+  data.tar.gz: 87622f60399b0217f751cfa09b60eeea353d2af8a00727293057feaffac8de8ebc25ad3a7a5f5a16c186e57466214cb725911abde2fddaf922697ae7682a6227

data/.gitignore

@@ -0,0 +1,16 @@
+# rcov generated
+coverage
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+Gemfile.lock
+
+# jeweler generated
+pkg

data/.rspec

@@ -1 +1,2 @@
 --colour
+--format d

data/.travis.yml

@@ -1,6 +1,4 @@
 script: "bundle exec rake"
 rvm:
-  - 1.8.7
-  - 1.9.2
-  - ree
+  - 2.1.5
   - jruby

data/Gemfile

@@ -1,12 +1,3 @@
 source "http://rubygems.org"
 
-gem "kramdown"
-gem "haml", "~> 3.0.0"
-
-group :development do
-  gem "jeweler"
-  gem "rake"
-  gem "rspec", "~> 2.4.0"
-  gem "rdiscount", "~> 1.6.5", :platform => :mri
-end
-
+gemspec

data/README.md

@@ -9,13 +9,13 @@ You may also want to see:
 * [Rocco](http://rtomayko.github.com/rocco/)
 
 Dependencies
-============
+------------
 
 * Haml
 * Either RDiscount (for MRI rubies) or Kramdown (for non-mri rubies)
 
 Example
-=======
+-------
 
 See example at [GH.pages](http://jsus.github.com/murdoc).
 
@@ -23,7 +23,7 @@ See also:
 * [example](http://jsus.github.com/murdoc/docs) of integration with [jsus](http://github.com/jsus/jsus)
 * [LSD documentation guides](https://github.com/lovelyscalabledrawings/lsd-guides/tree/gh-pages/grid)
 
-License and authorship
-======================
+License
+-------
 
 Public domain, see UNLICENSE file.

data/Rakefile

@@ -1,27 +1,5 @@
 require 'rubygems'
-require 'bundler'
-begin
-  Bundler.setup(:default, :development)
-rescue Bundler::BundlerError => e
-  $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
-  exit e.status_code
-end
-require 'rake'
-
-require 'jeweler'
-Jeweler::Tasks.new do |gem|
-  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
-  gem.name = "murdoc"
-  gem.homepage = "http://github.com/markiz/murdoc"
-  gem.license = "Public Domain"
-  gem.summary = "Annotated documentation generator"
-  gem.description = "Annotated documentation generator, see README.md for details"
-  gem.email = "markizko@gmail.com"
-  gem.authors = ["Mark Abramov"]
-  gem.executables = ["murdoc", "murdoc-strip-comments"]
-end
-Jeweler::RubygemsDotOrgTasks.new
+require "bundler/gem_tasks"
 
 require 'rspec/core'
 require 'rspec/core/rake_task'

data/bin/murdoc

@@ -9,7 +9,7 @@ option_parser = OptionParser.new do |opts|
   opts.banner = "murdoc <input file> <output html>"
 
   opts.on("--[no-]syntax-highlight", "Highlight syntax using pygments") do |h|
-    options[:highlight_source] = h
+    options[:highlight] = h
   end
 
   opts.on("-t", "--template [FILENAME]", "Use custom haml template for output") do |t|

data/bin/murdoc-strip-comments

@@ -2,9 +2,11 @@
 require "optparse"
 $: << "./lib/"
 require "murdoc"
+require 'pp'
 
 options = {}
 source_type = nil
+do_not_count_comment_lines = false
 
 option_parser = OptionParser.new do |opts|
   opts.banner = "murdoc-strip-comments [input file]\n\nWhen no input file is provided, murdoc-strip-comments uses standard input stream."
@@ -13,16 +15,27 @@ option_parser = OptionParser.new do |opts|
     source_type = st
   end
 
+  opts.on("--do-not-count-comment-lines") do |dncl|
+    do_not_count_comment_lines = dncl
+  end
+
   opts.on_tail("-h", "--help", "Show this message") do
     puts opts
     exit
   end
-
 end
 
 option_parser.parse!
 
-annotator = Murdoc::Annotator.from_file(ARGV[0] || "/dev/stdin", source_type, {})
+annotator = Murdoc::Annotator.from_file(ARGV[0] || "/dev/stdin", source_type, do_not_count_comment_lines)
+prev_paragraph = nil
 annotator.paragraphs.each do |paragraph|
-  puts paragraph.source
+  if prev_paragraph
+    print "\n" * [(paragraph.starting_line - prev_paragraph.starting_line - prev_paragraph.source.lines.count), 0].max
+  end
+
+  if !(paragraph.source =~ /\A\s*\z/m)
+    puts paragraph.source
+  end
+  prev_paragraph = paragraph
 end

data/lib/murdoc.rb

@@ -10,36 +10,50 @@
 
 
 module Murdoc
+  AnnotatedFile = Struct.new(:filename, :source, :source_type, :paragraphs, :formatted_paragraphs)
+
+  def self.annotate(filename, highlight = true, do_not_count_comment_lines = false)
+    filename = File.expand_path(filename)
+    annotator = Annotator.from_file(filename, nil, do_not_count_comment_lines)
+    AnnotatedFile.new(filename,
+        annotator.source,
+        annotator.source_type,
+        annotator.paragraphs,
+        annotator.paragraphs.map {|p| FormattedParagraph.new(p, highlight) })
+  end
+
   def self.generate_from_file(input, output, options = {})
     options = default_options.merge(options)
-    annotator = Annotator.from_file(input, nil, options)
+    annotator = Annotator.from_file(input, nil)
     File.open(output, "w+") do |f|
-      f.puts Formatter.new(options[:template]).render(:paragraphs => annotator.paragraphs,
-                                                      :stylesheet => File.read(options[:stylesheet]))
+      annotated_file = annotate(input, options[:highlight], options[:do_not_count_comment_lines])
+      f.puts Renderer.new(options[:template]).render(:annotated_file => annotated_file,
+                                                     :stylesheet => File.read(options[:stylesheet]))
     end
   end
 
   def self.generate_from_multiple_files(input_files, output, options = {})
     options = default_options_for_multiple_files.merge(options)
-    annotators = input_files.map {|fn| Annotator.from_file(fn, nil, options) }
+    annotated_files = input_files.map {|fn| annotate(fn, options[:highlight], options[:do_not_count_comment_lines]) }
     File.open(output, "w+") do |f|
-      f.puts Formatter.new(options[:template]).render(:annotators => annotators,
-                                                      :filenames => input_files,
-                                                      :stylesheet => File.read(options[:stylesheet]))
+      f.puts Renderer.new(options[:template]).render(:annotated_files => annotated_files,
+                                                     :stylesheet => File.read(options[:stylesheet]))
     end
   end
 
   def self.default_options
-    @@options ||= {
-        :template =>   "#{markup_dir}/template.haml",
-        :stylesheet => "#{markup_dir}/stylesheet.css"
+    @options ||= {
+      template:   "#{markup_dir}/template.haml",
+      stylesheet: "#{markup_dir}/stylesheet.css",
+      highlight: true
     }
   end
 
   def self.default_options_for_multiple_files
-    @@options ||= {
-        :template =>   "#{markup_dir}/template_multifile.haml",
-        :stylesheet => "#{markup_dir}/stylesheet.css"
+    @options ||= {
+      template:   "#{markup_dir}/template_multifile.haml",
+      stylesheet: "#{markup_dir}/stylesheet.css",
+      highlight: true
     }
   end
 
@@ -49,7 +63,13 @@ module Murdoc
 end
 
 require "murdoc/annotator"
+require "murdoc/scanner"
 require "murdoc/paragraph"
-require "murdoc/formatter"
-
-Dir["#{File.dirname(File.expand_path(__FILE__))}/murdoc/languages/*.rb"].each {|lang| require lang }
+require "murdoc/formatted_paragraph"
+require "murdoc/renderer"
+require "murdoc/languages/base"
+require "murdoc/languages/html"
+require "murdoc/languages/coffeescript"
+require "murdoc/languages/javascript"
+require "murdoc/languages/ruby"
+require "murdoc/languages/markdown"

data/lib/murdoc/annotator.rb

@@ -1,40 +1,33 @@
-# Annotator class does all the main job: parses out comments
-# and returns annotated code
-
-
-# Main module
 module Murdoc
   class Annotator
+    attr_accessor :source
+
     # Attribute accessor containing the resulting paragraphs
     attr_accessor :paragraphs
 
-    # Options
-    # Available options:
-    #   `:highlight_source` -- highlights source syntax using pygments (default: true)
-    attr_accessor :options
-
-    def self.default_options
-      {
-          :highlight_source => true
-      }
-    end
-
+    # Source language
+    attr_accessor :language
 
     # `source` string contains annotated source code
     # `source_type` is one of supported source types (currently `[:ruby, :javascript]`)
-    def initialize(source, source_type, options = {})
+    def initialize(source, source_type, do_not_count_comment_lines = false)
       self.source_type = source_type
-      self.options     = self.class.default_options.merge(options)
+      self.language    = Languages.get(source_type)
       self.source      = source
+      self.paragraphs  = if !language.annotation_only?
+        Scanner.new(language).call(source, do_not_count_comment_lines)
+      else
+        [Paragraph.new('', source, 0, nil)]
+      end
     end
 
 
     # You may also initialize annotator from file, it will even try to detect the
     # source type from extension.
-    def self.from_file(filename, source_type = nil, options = {})
+    def self.from_file(filename, source_type = nil, do_not_count_comment_lines = false)
       self.new(File.read(filename),
-               source_type || detect_source_type_from_filename(filename),
-               options)
+               source_type || Languages.detect(filename),
+               do_not_count_comment_lines)
     end
 
     def source_type
@@ -42,122 +35,7 @@ module Murdoc
     end
 
     def source_type=(source_type)
-      @source_type = source_type.to_s
-    end
-
-    # Big and hairy code parser
-    def source=(src)
-      @source = src
-      @paragraphs = []
-      lines = src.split("\n")
-
-      # splitting stuff into lines and setting cursor into initial position
-      i = 0
-      source_lines_counter = 0
-      while i < lines.size
-        comment_lines = []
-        # get single line comments
-        if comment_symbols[:single_line]
-          while i < lines.size && lines[i] =~ /^\s*#{Regexp.escape(comment_symbols[:single_line])}(.*)/
-            comment_lines << $1
-            i += 1
-          end
-        end
-
-        # getting multiline comments
-        if comment_symbols[:multiline]
-          begin_symbol = Regexp.escape(comment_symbols[:multiline][:begin])
-          end_symbol = Regexp.escape(comment_symbols[:multiline][:end])
-          if i < lines.size && lines[i] =~ /\s*#{begin_symbol}/
-            begin
-              match = lines[i].match /\s*(#{begin_symbol})?\s?(.*?)(#{end_symbol}|$)/
-              comment_lines << match[2]
-              i += 1
-            end while i < lines.size && !(lines[i-1] =~ /\s*#{end_symbol}/)
-          end
-        end
-
-        # getting source lines
-        source_lines = []
-        starting_line = if options[:do_not_count_comment_lines]
-          source_lines_counter
-        else
-          i
-        end
-
-        while i < lines.size && !is_comment(lines[i])
-          source_lines << lines[i]
-          source_lines_counter += 1
-          i += 1
-        end
-
-        # post-processing: stripping comments and removing empty strings from beginnings and ends
-        starting_line += postprocess_source(source_lines)
-        postprocess_comments(comment_lines)
-        # clear comment lines if that's commented out code
-        comment_lines.clear if comment_lines[0] =~ /^:code:$/
-
-        # if we have comments or source
-        if comment_lines.size > 0 || source_lines.size > 0
-          @paragraphs << Paragraph.new(source_lines.join("\n"),
-                                       comment_lines.join("\n"),
-                                       starting_line,
-                                       source_type,
-                                       options)
-        end
-      end
-    end
-
-    # Rest of the file quite less self-explanatory
-    def source
-      @source
-    end
-
-  protected
-    def comment_symbols
-      super || {}
-    end
-
-    # Method for checking source for comments. Used for getting consequent non-comments
-    # into resulting stream
-    def is_comment(line)
-      result = false
-      # If source supports single line comments
-      if comment_symbols[:single_line]
-        result ||= line =~ /^\s*#{Regexp.escape(comment_symbols[:single_line])}/
-      end
-
-      # If source supports multi-line comments
-      if comment_symbols[:multiline]
-        result ||= line =~ /^\s*#{Regexp.escape(comment_symbols[:multiline][:begin])}/
-      end
-      result
-    end
-
-    #
-    # Removes trailing spaces from comments, also removes first space from comments,
-    # but only if there's only one space there (not to mess with markdown)
-    #
-    def postprocess_comments(comment_lines)
-      comment_lines.map! {|l| l.sub(/^\s([^\s])/, '\\1').rstrip }
-      comment_lines.delete_at(0) while comment_lines.size > 0 && comment_lines[0].empty?
-      comment_lines.delete_at(-1) while comment_lines.size > 0 && comment_lines[-1].empty?
-    end
-
-
-    # Removes blank lines from beginning and end of source lines
-    # returns starting offset for source (number of lines deleted from beginning)
-    def postprocess_source(source_lines)
-      starting_offset = 0
-      while source_lines.size > 0 && source_lines[0] =~ /^\s*$/
-        starting_offset += 1
-        source_lines.delete_at(0)
-      end
-
-      while source_lines.size > 0 && source_lines[-1] =~ /^\s*$/
-        source_lines.delete_at(-1)
-      end
-      starting_offset
+      @source_type = (source_type || :base).to_sym
     end
   end
 end

data/lib/murdoc/formatted_paragraph.rb

@@ -0,0 +1,41 @@
+require 'forwardable'
+module Murdoc
+  class FormattedParagraph
+    extend Forwardable
+
+    def_delegators :paragraph, :annotation, :source, :starting_line, :source_type
+
+    attr_reader :paragraph
+    attr_reader :highlight
+
+    def initialize(paragraph, highlight = true)
+      @paragraph = paragraph
+      @highlight = highlight
+    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? && highlight && source_type != :base
+        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