markdown_ruby_documentation 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d39e3d18cd3a64d5b953bbacef111b3628327fad
-  data.tar.gz: ab5e4c28c68bba449977477e375fac1b89db4e14
+  metadata.gz: 98da1a6202c25d0e20c630339f0ec5c9c6bb1898
+  data.tar.gz: 6af3bf690dd9f17d014ea6c5cc28eca39e975172
 SHA512:
-  metadata.gz: afa43b83d03e03e1e97c5ae87d7e319885ae111c02b1ea7c6d6d09d31ac85b8f4beee1d8fc8b579db929e1ed29513ba25ba82a88e20e9c15488726caeb379ad5
-  data.tar.gz: 69c1b5800e28bfc574ecc51a981679bacd06147abf46e5efaa6408f942f3d9f468fc18e6ca1081a22d01c5e12cff07eca8fc1d6eff9ad6d513cd8642fada9240
+  metadata.gz: 333233006d8b7304ed481d52b0b5d38b2b7605d644fae481d584be890ac59af4f9b3c43faaa8c29cc2f1e6dc3fa954fcb18d7481060640e86be4abb014188eb0
+  data.tar.gz: a06f239ab1f24aabf81c63e0adf2f34f35d01a4df7558d2a5f1eed1119d5393991c64a83ea6b721e4097be79846ada30dc425e349a49b514a641650e204858e1

data/README.md

@@ -86,11 +86,29 @@ Creates a url to the file on GitHub based on the current sha or it defaults to m
 * "#instance_method_name" an instance method in the current scope.
     * `__method__` returns `#<current_method_name>`
 
-#### `pretty_code(ruby_source)`
-Convert underscore methods to more English like sentence.
+#### `ruby_to_markdown`
+Converts case statements and if statements to bulleted markdown
+ **option 1**
+   * param [String] ruby_source
+   * param [Hash] disable_processors (optional) See processors list.
+   *example ruby_to_markdown "def method_name\n'hello'\nend", readable_ruby_numbers: false**
+ **option 2 - Assumes methods source of current method**
+   * param [Hash] disable_processors (optional) See processors list.
+   *example ruby_to_markdown readable_ruby_numbers: false*
+   
+**processors**
+* readable_ruby_numbers
+* pretty_early_return
+* convert_early_return_to_if_else
+* ternary_to_if_else
+* ruby_if_statement_to_md
+* ruby_case_statement_to_md
+* ruby_operators_to_english
+* methods_as_local_links
+* remove_end_keyword
+* constants_with_name_and_value
+* remove_memoized_vars
 
-#### `link_local_methods_from_pretty_code(pretty_code, include: <Optional array of matching strings>)`
-link_local_methods_from_pretty_code("`hello i am a method`") => "[hello i am a method](#hello-i-am-a-method)"
 
 #### `format_link`
 format_link "#i_do_other_things" => [I do other things](#i-do-other-things)
@@ -98,18 +116,12 @@ format_link "The method 10", "#i_do_other_things" => [The method 10](#i-do-other
 
 Instance method that call other methods will results in an error.
 
-#### `method_as_local_links`
-method_as_local_links("i_return_one + i_return_two") => "^`i_return_one` + ^`i_return_two`"
+#### `methods_as_local_links`
+methods_as_local_links("i_return_one + i_return_two") => "^`i_return_one` + ^`i_return_two`"
 
 #### `constants_with_name_and_value`
 constants_with_name_and_value("SOME_CONST_VALUE") => "`SOME_CONST_VALUE => "1"`"
 
-#### `quoted_strings_as_local_links(text, include: <Optional array of matching strings>)`
-quoted_strings_as_local_links('"this is Bob"') => "^`the_is_bob`"
-
-#### `ruby_to_markdown`
-Converts case statements and if statements to bulleted markdown
-
 #### `readable_ruby_numbers`
 Add commas to any ruby numbers. To provide additional formatting it yields a block given the number object.
 

data/lib/markdown_ruby_documentation.rb

@@ -1,7 +1,9 @@
 require "markdown_ruby_documentation/version"
 require "markdown_ruby_documentation/summary"
-require "markdown_ruby_documentation/instance_to_class_methods"
-require "markdown_ruby_documentation/print_method_source"
+require "markdown_ruby_documentation/template_parser/parsing"
+require "markdown_ruby_documentation/template_parser/any_args"
+require "markdown_ruby_documentation/template_parser/instance_to_class_methods"
+require "markdown_ruby_documentation/template_parser/print_method_source"
 require "markdown_ruby_documentation/template_parser"
 require "markdown_ruby_documentation/markdown_presenter"
 require "markdown_ruby_documentation/generate"

data/lib/markdown_ruby_documentation/constants_presenter.rb

@@ -14,16 +14,7 @@ module MarkdownRubyDocumentation
       interface
     end
 
-    private
-
-    def constants
-      subject.constants.each_with_object({}) do |v, const|
-        c        = subject.const_get(v)
-        const[v] = format(c) unless c.class == Module || c.class == Class
-      end
-    end
-
-    def format(value)
+    def self.format(value)
       case value
       when Fixnum
         ActiveSupport::NumberHelper.number_to_delimited(value)
@@ -34,5 +25,13 @@ module MarkdownRubyDocumentation
       end
     end
 
+    private
+
+    def constants
+      subject.constants.each_with_object({}) do |v, const|
+        c        = subject.const_get(v)
+        const[v] = self.class.format(c) unless c.class == Module || c.class == Class
+      end
+    end
   end
 end

data/lib/markdown_ruby_documentation/method.rb

@@ -1,5 +1,6 @@
 module MarkdownRubyDocumentation
   class Method
+    InvalidMethodReference = Class.new(StandardError)
     attr_reader :method_reference
     protected :method_reference
 
@@ -15,6 +16,7 @@ module MarkdownRubyDocumentation
     #   "SomeClass#instance_method_name" an instance method on a specific constant.
     #   "#instance_method_name" an instance method in the current scope.
     def self.create(method_reference, null_method: false, context: Kernel)
+      return method_reference if method_reference.is_a?(Method)
       case method_reference
       when InstanceMethod
         InstanceMethod.new(method_reference, context: context)
@@ -24,7 +26,7 @@ module MarkdownRubyDocumentation
         if null_method
           NullMethod.new(method_reference, context: context)
         else
-          raise ArgumentError, "method_reference is formatted incorrectly: '#{method_reference}'"
+          raise InvalidMethodReference, "method_reference is formatted incorrectly: '#{method_reference}'"
         end
       end
     end
@@ -41,7 +43,7 @@ module MarkdownRubyDocumentation
 
     def self.===(value)
       if value.is_a?(String)
-        value.include?(type_symbol)
+        value.include?(type_symbol) && !!/\A[:A-Za-z_0-9!?#{type_symbol}]+\z/.match(value)
       else
         super
       end

data/lib/markdown_ruby_documentation/template_parser.rb

@@ -44,14 +44,16 @@ module MarkdownRubyDocumentation
       using
     )
 
-    attr_reader :ruby_class, :methods, :erb_methods_class
+    attr_reader :ruby_class, :methods, :erb_methods_class, :current_method
 
     def parser
       @parser ||= methods.each_with_object({}) do |method, hash|
         begin
-          value = parse_erb(insert_method_name(strip_comment_hash(extract_dsl_comment_from_method(method)), method), method)
+          @current_method = method
+          value           = parse_erb(insert_method_name(strip_comment_hash(extract_dsl_comment_from_method(method)), method), method)
         rescue MethodSource::SourceNotFoundError => e
-          value = false
+          @current_method = nil
+          value           = false
           puts e.message unless IGNORE_METHODS.any? { |im| e.message.include? im }
         end
         if value
@@ -61,6 +63,8 @@ module MarkdownRubyDocumentation
     end
 
     module CommentMacros
+      include Parsing
+
       # @param [String] str
       # @example
       # @return [String] of any comments proceeding a method def
@@ -79,7 +83,7 @@ module MarkdownRubyDocumentation
       # @param [String] str
       # @example
       # @return [Object] anything that the evaluated method would return.
-      def eval_method(str)
+      def eval_method(str=current_method)
         case (method = Method.create(str, context: ruby_class))
         when ClassMethod
           method.context.public_send(method.name)
@@ -88,58 +92,99 @@ module MarkdownRubyDocumentation
         end
       end
 
-      # @param [String] input
+      # @param [String] method_reference
       # @return [String] the source of a method block is returned as text.
-      def print_method_source(input)
-        method = Method.create(input.dup, context: ruby_class)
+      def print_method_source(method_reference=current_method)
+        method = Method.create(method_reference.dup, context: ruby_class)
         PrintMethodSource.new(method: method).print
       end
 
-      def git_hub_method_url(input)
-        method = Method.create(input.dup, context: ruby_class)
+
+      # @param [String] method_reference
+      def git_hub_method_url(method_reference=current_method)
+        method = Method.create(method_reference.dup, context: ruby_class)
         GitHubLink::MethodUrl.new(subject: method.context, method_object: method)
       end
 
-      def git_hub_file_url(file_path)
-        if file_path.include?("/")
-          GitHubLink::FileUrl.new(file_path: file_path)
+      def git_hub_file_url(file_path_or_const)
+        if file_path_or_const.include?("/")
+          GitHubLink::FileUrl.new(file_path: file_path_or_const)
         else
-          const    = Object.const_get(file_path)
+          const    = Object.const_get(file_path_or_const)
           a_method = const.public_instance_methods.first
-          git_hub_method_url("#{file_path}##{a_method}")
+          git_hub_method_url("#{file_path_or_const}##{a_method}")
         end
       end
 
-      def pretty_code(source_code, humanize: true)
-        source_code = ternary_to_if_else(source_code)
-        source_code = pretty_early_return(source_code)
-        source_code.gsub!(/@[a-z][a-z0-9_]+ \|\|=?\s/, "") # @memoized_vars ||=
-        source_code.gsub!(":", '')
-        source_code.gsub!("&&", "and")
-        source_code.gsub!(">=", "is greater than or equal to")
-        source_code.gsub!("<=", "is less than or equal to")
-        source_code.gsub!(" < ", " is less than ")
-        source_code.gsub!(" > ", " is greater than ")
-        source_code.gsub!(" == ", " Equal to ")
-        source_code.gsub!("nil?", "is missing?")
-        source_code.gsub!("elsif", "else if")
-        source_code.gsub!("||", "or")
-        source_code.gsub!(/([0-9][0-9_]+[0-9]+)/) do |match|
-          match.gsub("_", ",")
-        end
-        if humanize
-          source_code.gsub!(/["']?[a-z_A-Z?!0-9]*["']?/) do |s|
-            if s.include?("_") && !(/["'][a-z_A-Z?!0-9]*["']/ =~ s)
-              "'#{s.humanize}'"
-            else
-              s.humanize(capitalize: false)
-            end
-          end
+      RUBY_TO_MARKDOWN_PROCESSORS = [
+        :readable_ruby_numbers,
+        :pretty_early_return,
+        :convert_early_return_to_if_else,
+        :ternary_to_if_else,
+        :ruby_if_statement_to_md,
+        :ruby_case_statement_to_md,
+        :ruby_operators_to_english,
+        :nil_check_readable,
+        :question_mark_method_format,
+        :methods_as_local_links,
+        :remove_end_keyword,
+        :constants_with_name_and_value,
+        :remove_memoized_vars,
+      ]
+
+      def ruby_to_markdown(*args)
+        any_args           = AnyArgs.new(args:                args,
+                                         print_method_source: method(:print_method_source),
+                                         caller:              caller,
+                                         for_method:          __method__,
+                                         method_creator:      method(:create_method_with_ruby_class))
+        disable_processors = any_args.disable_processors
+        ruby_source        = any_args.source_code
+
+        RUBY_TO_MARKDOWN_PROCESSORS.each do |processor|
+          options     = disable_processors.fetch(processor, {})
+          ruby_source = send(processor, ruby_source, options) if options
         end
-        source_code
+        ruby_source
+      end
+
+      def remove_memoized_vars(source_code=print_method_source, *)
+        source_code.gsub(/@[a-z][a-z0-9_]+ \|\|=?\s/, "") # @memoized_vars ||=
+      end
+
+      def nil_check_readable(source_code, proc: false)
+        conversions = {
+          ".nil?" => " is missing?"
+        }
+        gsub_replacement(source_code, conversions, proc: proc)
+      end
+
+      def elsif_to_else_if(source_code, proc: false)
+        conversions = {
+          "elsif" => "else if"
+        }
+        gsub_replacement(source_code, conversions, proc: proc)
+      end
+
+      def remove_colons(source_code)
+        source_code.gsub(":", '')
       end
 
-      def readable_ruby_numbers(source_code, &block)
+      def ruby_operators_to_english(source_code, proc: false)
+        conversions = {
+          "&&"   => "and",
+          ">="   => "is greater than or equal to",
+          "<="   => "is less than or equal to",
+          " < "  => " is less than ",
+          " > "  => " is greater than ",
+          " == " => " Equal to ",
+          "||"   => "or"
+        }
+
+        gsub_replacement(source_code, conversions, proc: proc)
+      end
+
+      def readable_ruby_numbers(source_code, *, &block)
         source_code.gsub(/([0-9][0-9_]+[0-9]+)/) do |match|
           value = eval(match)
           if block_given?
@@ -150,14 +195,6 @@ module MarkdownRubyDocumentation
         end
       end
 
-      def link_local_methods_from_pretty_code(pretty_code, include: nil)
-        pretty_code.gsub(/([`][a-zA-Z_0-9!?\s]+[`])/) do |match|
-          include_code(include, match) do
-            variables_as_local_links match.underscore.gsub(" ", "_").gsub(/`/, "")
-          end
-        end
-      end
-
       def include_code(include, text, &do_action)
         if include.nil? || (include.present? && include.include?(remove_quotes(text)))
           do_action.call(text)
@@ -168,24 +205,32 @@ module MarkdownRubyDocumentation
 
       private :include_code
 
-      def convert_early_return_to_if_else(source_code)
-        source_code.gsub(/(.+) if (.+)/, "if \\2\n\\1\nend")
+      def convert_early_return_to_if_else(source_code, *)
+        source_code = source_code.gsub(/(.+) if (.+)/, "if \\2\n\\1\nend")
+        source_code.gsub(/(.+) unless (.+)/, "unless \\2\n\\1\nend")
       end
 
-      def pretty_early_return(source_code)
+      def pretty_early_return(source_code, *)
         source_code.gsub(/return (unless|if)/, 'return nothing \1')
       end
 
-      def ternary_to_if_else(ternary)
+      def ternary_to_if_else(ternary, *)
         ternary.gsub(/(.*) \? (.*) \: (.*)/, "if \\1\n\\2\nelse\n\\3\nend")
       end
 
+      # @param [String] title the name of the link
+      # @param [String] link_ref the url with method anchor
+      # @example format_link("MyLink", "path/to/it#method_name?")
+      #   #=> "[MyLink](#path/to/it#method-name)"
       def format_link(title, link_ref)
         path, anchor   = *link_ref.to_s.split("#")
         formatted_path = [path, anchor.try!(:dasherize).try!(:delete, "?")].compact.join("#")
         "[#{title}](#{formatted_path})"
       end
 
+      # @param [String] link_ref the url with method anchor
+      # @example title_from_link"path/to/it#method_name?")
+      #   #=> "[Method Name](#path/to/it#method-name)"
       def title_from_link(link_ref)
         [link_ref.split("/").last.split("#").last.to_s.humanize, link_ref]
       end
@@ -195,56 +240,60 @@ module MarkdownRubyDocumentation
         raise "Client needs to define MarkdownRubyDocumentation::TemplateParser::CommentMacros#link_to_markdown"
       end
 
-      def method_as_local_links(ruby_source)
+      def methods_as_local_links(ruby_source,
+                                 call_on_title: :titleize,
+                                 proc:          -> (match, anchor) { "[#{match}](#{anchor})" })
         ruby_source.gsub(/(\b(?<!['"])[a-z_][a-z_0-9?!]*(?!['"]))/) do |match|
-          is_a_method_on_ruby_class?(match) ? "^`#{match}`" : match
-        end
-      end
-
-      alias_method(:variables_as_local_links, :method_as_local_links)
-
-      def quoted_strings_as_local_links(text, include: nil)
-        text.gsub(/(['|"][a-zA-Z_0-9!?\s]+['|"])/) do |match|
-          include_code(include, match) do
-            "^`#{remove_quotes(match).underscore.gsub(" ", "_")}`"
+          if is_a_method_on_ruby_class?(match)
+
+            title = if call_on_title
+                      call_on_title = [*call_on_title].compact
+                      match.public_send(call_on_title.first, *call_on_title[1..-1])
+                    else
+                      match
+                    end
+            proc.call(title, "##{match.downcase.dasherize.delete(" ").delete('?')}")
+          else
+            match
           end
         end
       end
 
-      def constants_with_name_and_value(ruby_source)
+      def constants_with_name_and_value(ruby_source, *)
         ruby_source.gsub(/([A-Z]+[A-Z_0-9]+)/) do |match|
           value = ruby_class.const_get(match)
-          "`#{match} => #{value.inspect}`"
+          "[#{ConstantsPresenter.format(value)}](##{match.dasherize.downcase})"
         end
       end
 
-      def ruby_to_markdown(ruby_source)
-        ruby_source = readable_ruby_numbers(ruby_source)
-        ruby_source = pretty_early_return(ruby_source)
-        ruby_source = convert_early_return_to_if_else(ruby_source)
-        ruby_source = ternary_to_if_else(ruby_source)
-        ruby_source = ruby_if_statement_to_md(ruby_source)
-        ruby_source = ruby_case_statement_to_md(ruby_source)
-        remove_end_keyword(ruby_source)
+      def question_mark_method_format(ruby_source, *)
+        ruby_source.gsub(/(\b(?<!['"])\.[a-z_][a-z_0-9]+\?(?!['"]))/) do |match|
+          " is #{match}".sub(".", "")
+        end
       end
 
-      def remove_end_keyword(ruby_source)
-        ruby_source.gsub!(/^[\s]*end\n?/, "")
+      def remove_end_keyword(ruby_source, *)
+        ruby_source.gsub(/^[\s]*end\n?/, "")
       end
 
-      def ruby_if_statement_to_md(ruby_source)
-        ruby_source.gsub!(/else if(.*)/, "* __ElseIf__\\1\n__Then__")
-        ruby_source.gsub!(/elsif(.*)/, "* __ElseIf__\\1\n__Then__")
-        ruby_source.gsub!(/if(.*)/, "* __If__\\1\n__Then__")
-        ruby_source.gsub!("else", "* __Else__")
-        ruby_source
+      def ruby_if_statement_to_md(ruby_source, proc: false)
+        conversions = {
+          /else if(.*)/ => "* __ElseIf__\\1\n__Then__",
+          /elsif(.*)/   => "* __ElseIf__\\1\n__Then__",
+          /if(.*)/      => "* __If__\\1\n__Then__",
+          /unless(.*)/  => "* __Unless__\\1\n__Then__",
+          "else"        => "* __Else__"
+        }
+        gsub_replacement(ruby_source, conversions, proc: proc)
       end
 
-      def ruby_case_statement_to_md(ruby_source)
-        ruby_source.gsub!(/case(.*)/, "* __Given__\\1")
-        ruby_source.gsub!(/when(.*)/, "* __When__\\1\n__Then__")
-        ruby_source.gsub!("else", "* __Else__")
-        ruby_source
+      def ruby_case_statement_to_md(ruby_source, proc: false)
+        conversions = {
+          /case(.*)/ => "* __Given__\\1",
+          /when(.*)/ => "* __When__\\1\n__Then__",
+          "else"     => "* __Else__"
+        }
+        gsub_replacement(ruby_source, conversions, proc: proc)
       end
 
       def hash_to_markdown_table(hash, key_name:, value_name:)
@@ -273,76 +322,53 @@ module MarkdownRubyDocumentation
 
       private
 
-      def is_a_method_on_ruby_class?(method)
-        [*ruby_class.public_instance_methods, *ruby_class.private_instance_methods].include?(remove_quotes(method).to_sym)
-      end
-
-      def remove_quotes(string)
-        string.gsub(/['|"]/, "")
+      def fetch_strings(source_code, &block)
+        source_code.gsub(/["']?[a-z_A-Z?!0-9]*["']?/, &block)
       end
 
-      def insert_method_name(string, method)
-        string.gsub("__method__", "'#{method.to_s}'")
+      def fetch_strings_that_contain_codes(source_code, &block)
+        source_code.gsub(/["']?[a-z_A-Z?!0-9]*["']?/, &block)
       end
 
-      def parse_erb(str, method)
-        filename, lineno = ruby_class_meth_source_location(method)
-
-        ruby_class.module_eval(<<-RUBY, __FILE__, __LINE__+1)
-        def self.get_binding
-          self.send(:binding)
+      def fetch_methods(source_code, &block)
+        source_code.gsub(/(\b(?<!['"])[a-z_][a-z_0-9?!]*(?!['"]))/) do |match|
+          block.call(match) if is_a_method_on_ruby_class?(match)
         end
-        RUBY
-        ruby_class.extend(CommentMacros)
-        erb = ERB.new(str, nil, "-")
-        erb.result(ruby_class.get_binding)
-      rescue => e
-        raise e.class, e.message, ["#{filename}:#{lineno}:in `#{method.name}'", *e.backtrace]
-      end
-
-      def strip_comment_hash(str)
-        str.gsub(/^#[\s]?/, "")
-      end
-
-      def ruby_class_meth_comment(method)
-        method.context.public_send(method.type, method.name).comment
-
-      rescue MethodSource::SourceNotFoundError => e
-        raise e.class, "#{ method.context}#{method.type_symbol}#{method.name}, \n#{e.message}"
       end
 
-      def ruby_class_meth_source_location(method)
-        method.context.public_send(method.type, method.name).source_location
+      def fetch_symbols(source_code, &block)
+        source_code = source_code.gsub(/:[a-z_?!0-9]+/, &block)
+        source_code = source_code.gsub(/[a-z_?!0-9]+:/, &block)
       end
 
-      def extract_dsl_comment(comment_string)
-        if (v = when_start_and_end(comment_string))
-          v
-        elsif (x = when_only_start(comment_string))
-          x << "[//]: # (This method has no mark_end)"
-        else
-          ""
-        end
+      def is_a_method_on_ruby_class?(method)
+        [*ruby_class.public_instance_methods, *ruby_class.private_instance_methods].include?(remove_quotes(method).to_sym)
       end
 
-      def when_start_and_end(comment_string)
-        v = /#{START_TOKEN}\n((.|\n)*)#{END_TOKEN}/.match(comment_string)
-        v.try!(:captures).try!(:first)
+      def remove_quotes(string)
+        string.gsub(/['|"]/, "")
       end
 
-      def when_only_start(comment_string)
-        v = /#{START_TOKEN}\n((.|\n)*)/.match(comment_string)
-        v.try!(:captures).try!(:first)
+      def ruby_class
+        @ruby_class || self
       end
 
-      def extract_dsl_comment_from_method(method)
-        extract_dsl_comment strip_comment_hash(ruby_class_meth_comment(method))
+      def create_method_with_ruby_class(method_reference)
+        Method.create(method_reference, context: ruby_class)
       end
 
-      def ruby_class
-        @ruby_class || self
+      def gsub_replacement(source_code, conversions, proc: false)
+        conversions.each do |symbol, replacement|
+          source_code = if proc
+                          source_code.gsub(symbol, &proc.curry[replacement])
+                        else
+                          source_code.gsub(symbol, replacement)
+                        end
+        end
+        source_code
       end
     end
+
     include CommentMacros
   end
 end

data/lib/markdown_ruby_documentation/template_parser/any_args.rb

@@ -0,0 +1,49 @@
+module MarkdownRubyDocumentation
+  class AnyArgs
+    attr_reader :disable_processors, :source_code
+
+    def initialize(args:, print_method_source:, caller:, for_method:, method_creator:)
+      @args                = args
+      @print_method_source = print_method_source
+      @caller              = caller
+      @for_method          = for_method
+      @method_creator      = method_creator
+      call
+    end
+
+    private
+
+    attr_reader :args, :print_method_source, :caller, :for_method, :method_creator
+
+    def call
+      if args.first.is_a?(Hash)
+        when_hash_first(args.first)
+      elsif args.first.is_a?(String)
+        when_string_first(args)
+      elsif args.empty?
+        when_no_args
+      else
+        raise ArgumentError, "Incorrect arguments given: #{for_method}(#{args})", caller
+      end
+    end
+
+    def when_hash_first(options)
+      @disable_processors = options
+      if options.has_key?(:method_reference)
+        @source_code        = print_method_source.call(method_creator.call(options[:method_reference]))
+      else
+        @source_code        = print_method_source.call
+      end
+    end
+
+    def when_string_first(args)
+      @source_code        = args.first
+      @disable_processors = args[1] || {}
+    end
+
+    def when_no_args
+      @disable_processors = {}
+      @source_code        = print_method_source.call
+    end
+  end
+end

data/lib/markdown_ruby_documentation/template_parser/parsing.rb

@@ -0,0 +1,71 @@
+module MarkdownRubyDocumentation
+  class TemplateParser
+    module Parsing
+      def parse_erb(str, method)
+        filename, lineno = ruby_class_meth_source_location(method)
+        adjusted_lineno  = (lineno - ruby_class_meth_comment(method).split("\n").count-1)
+        ruby_class.module_eval(<<-RUBY, __FILE__, __LINE__+1)
+        def self.get_binding
+          self.send(:binding)
+        end
+        RUBY
+        ruby_class.send(:define_singleton_method, :current_method) do
+          method
+        end
+
+        ruby_class.extend(CommentMacros)
+
+        erb          = ERB.new(str, nil, "-")
+
+        erb.lineno   = adjusted_lineno if erb.respond_to?(:lineno)
+        erb.filename = filename if erb.respond_to?(:filename)
+        erb.result(ruby_class.get_binding)
+      rescue => e
+        raise e.class, e.message, ["#{filename}:#{adjusted_lineno}:in `#{method.name}'", *e.backtrace]
+      end
+
+      def insert_method_name(string, method)
+        string.gsub("__method__", "'#{method.to_s}'")
+      end
+
+      def strip_comment_hash(str)
+        str.gsub(/^#[\s]?/, "")
+      end
+
+      def ruby_class_meth_comment(method)
+        method.context.public_send(method.type, method.name).comment
+
+      rescue MethodSource::SourceNotFoundError => e
+        raise e.class, "#{ method.context}#{method.type_symbol}#{method.name}, \n#{e.message}"
+      end
+
+      def ruby_class_meth_source_location(method)
+        method.context.public_send(method.type, method.name).source_location
+      end
+
+      def extract_dsl_comment(comment_string)
+        if (v = when_start_and_end(comment_string))
+          v
+        elsif (x = when_only_start(comment_string))
+          x << "[//]: # (This method has no mark_end)"
+        else
+          ""
+        end
+      end
+
+      def when_start_and_end(comment_string)
+        v = /#{START_TOKEN}\n((.|\n)*)#{END_TOKEN}/.match(comment_string)
+        v.try!(:captures).try!(:first)
+      end
+
+      def when_only_start(comment_string)
+        v = /#{START_TOKEN}\n((.|\n)*)/.match(comment_string)
+        v.try!(:captures).try!(:first)
+      end
+
+      def extract_dsl_comment_from_method(method)
+        extract_dsl_comment strip_comment_hash(ruby_class_meth_comment(method))
+      end
+    end
+  end
+end

data/lib/markdown_ruby_documentation/version.rb

@@ -1,3 +1,3 @@
 module MarkdownRubyDocumentation
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: markdown_ruby_documentation
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Dustin Zeisler
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-04-25 00:00:00.000000000 Z
+date: 2016-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: method_source
@@ -120,17 +120,19 @@ files:
 - lib/markdown_ruby_documentation/generate.rb
 - lib/markdown_ruby_documentation/git_hub_link.rb
 - lib/markdown_ruby_documentation/git_hub_project.rb
-- lib/markdown_ruby_documentation/instance_to_class_methods.rb
 - lib/markdown_ruby_documentation/markdown_presenter.rb
 - lib/markdown_ruby_documentation/method.rb
 - lib/markdown_ruby_documentation/method/class_method.rb
 - lib/markdown_ruby_documentation/method/instance_method.rb
 - lib/markdown_ruby_documentation/method/null_method.rb
 - lib/markdown_ruby_documentation/method_linker.rb
-- lib/markdown_ruby_documentation/print_method_source.rb
 - lib/markdown_ruby_documentation/reject_blank_methods.rb
 - lib/markdown_ruby_documentation/summary.rb
 - lib/markdown_ruby_documentation/template_parser.rb
+- lib/markdown_ruby_documentation/template_parser/any_args.rb
+- lib/markdown_ruby_documentation/template_parser/instance_to_class_methods.rb
+- lib/markdown_ruby_documentation/template_parser/parsing.rb
+- lib/markdown_ruby_documentation/template_parser/print_method_source.rb
 - lib/markdown_ruby_documentation/version.rb
 - lib/markdown_ruby_documentation/write_markdown_to_disk.rb
 - markdown_ruby_documenation.gemspec