markdown_ruby_documentation 0.12.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a09494db3392aaca6d279d31c3023d6ffd20c508
-  data.tar.gz: 4e8b9fba4a5b9cdc51c6452aa4659217f0549990
+  metadata.gz: 473a53d5f03184b6f4fd03121ff0c9234ff2e0ef
+  data.tar.gz: 68055dc5da34403f9284502c8805114ff1863833
 SHA512:
-  metadata.gz: da975ebe6e44e8efa59e7104ea7693fc854cbd0a501efd601c3df94a572b4b76ab1d422cc6e1eadeef09d0039cbf88fa4787c3dcbc45a013fa9a99e43e4a16d2
-  data.tar.gz: 0dc703252b6360aa7ca0d36b7736c5b148935ae21818613cc9a47e0794849ecc23155e5a4fbbac7edf888efb531f3c53d73dc95d0d3052e8c44474846b35e511
+  metadata.gz: eaf7ffa30459a699a9217e0be2277dec446265dc6a20ba177f7715f8ece4f5b6491cda7ed5959b633da079fc1180411f60e7994b100fd0174ff1aeecc9464833
+  data.tar.gz: c98fefe346906e267609a5c2188fc5fd1be500d0835734911bcca6f4232efd24022d31aec2447414295fd45b4943255e572915fb6eade4ff037d74cf2631d5ed

data/lib/markdown_ruby_documentation/constants_presenter.rb

@@ -35,7 +35,7 @@ module MarkdownRubyDocumentation
     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
+        const[v] = self.class.format(c) unless [Regexp, Module, Class].include?(c.class)
       end
     end
   end

data/lib/markdown_ruby_documentation/generate.rb

@@ -1,6 +1,6 @@
 module MarkdownRubyDocumentation
   class Generate
-    # @param [Class] subjects ruby classes to generate documentation from.
+    # @param [Array[Class, String]] subjects ruby classes to generate documentation from and file location.
     # @param [Module] erb_methods must contain #link_to_markdown and contain any additional methods for comment ERB
     # @param [Proc] output_object given name: and text: for use in saving the the files.
     # @param [String] load_path
@@ -18,16 +18,18 @@ module MarkdownRubyDocumentation
         erb_methods_class.extend TemplateParser::CommentMacros
         erb_methods_class.extend erb_methods
         TemplateParser::CommentMacros.include erb_methods
-        left_padding(subjects)
-        progressbar(subjects)
+        subject_classes = subjects.map { |h| h.fetch(:class) }
+        left_padding(subject_classes)
+        progressbar(subject_classes)
         progressbar.title = "Compiling Markdown".ljust(left_padding)
         batches           = subjects.each_slice(parallel_config.fetch(:in_threads, 2))
         threads           = []
         batches.each do |batch|
           threads << Thread.new(batch) do |(_batch)|
           Array[_batch].flatten.map do |subject|
-              progressbar.title = subject.name.ljust(left_padding)
-              Page.new(subject:           subject,
+            progressbar.title = subject.fetch(:class).name.ljust(left_padding)
+            Page.new(subject_class:       subject.fetch(:class),
+                     subject_location:    subject.fetch(:file_path).to_s,
                        output_object:     output_object,
                        erb_methods_class: erb_methods_class,
                        load_path:         load_path).call.tap { progressbar.increment }
@@ -59,16 +61,18 @@ module MarkdownRubyDocumentation
     end
 
     class Page
-      attr_reader :subject, :output_object, :erb_methods_class, :load_path
+      attr_reader :subject, :subject_location, :output_object, :erb_methods_class, :load_path
 
-      def initialize(subject:,
+      def initialize(subject_class:,
+                     subject_location:,
                      methods: [],
                      load_path:,
                      output_object:,
                      erb_methods_class:)
-        initialize_methods(methods, subject)
+        initialize_methods(methods, subject_class, subject_location)
         @erb_methods_class = erb_methods_class
-        @subject           = subject
+        @subject           = subject_class
+        @subject_location  = subject_location
         methods            = methods
         @methods           = methods
         @load_path         = load_path
@@ -84,21 +88,21 @@ module MarkdownRubyDocumentation
       end
 
       private
-      def initialize_methods(methods, subject)
+      def initialize_methods(methods, subject, subject_location)
         if methods.empty?
-          all_instance_and_class_methods(methods, subject)
+          all_instance_and_class_methods(methods, subject, subject_location)
         else
-          methods.map! { |method| method.is_a?(Symbol) ? InstanceMethod.new("#{subject.name}##{method}", context: subject) : method }
+          methods.map! { |method| method.is_a?(Symbol) ? InstanceMethod.new("#{subject.name}##{method}", context: subject, file_path: subject_location) : method }
         end
       end
 
-      def all_instance_and_class_methods(methods, subject)
+      def all_instance_and_class_methods(methods, subject, subject_location)
         native_instance_methods = (subject.instance_methods(false) - Object.instance_methods(false)).concat(subject.private_instance_methods(false) - Object.private_instance_methods(false))
         super_instance_methods  = (subject.instance_methods(true) - Object.instance_methods(true)).concat(subject.private_instance_methods(true) - Object.private_instance_methods(true)) - native_instance_methods
         klass_m                 = subject.methods(false).concat(subject.private_methods(false)) - Object.methods
-        methods.concat super_instance_methods.reverse.map { |method| InstanceMethod.new("#{subject.name}##{method}", context: subject, visibility: :super) }
-        methods.concat native_instance_methods.map { |method| InstanceMethod.new("#{subject.name}##{method}", context: subject, visibility: :native) }
-        methods.concat klass_m.map { |method| ClassMethod.new("#{subject.name}.#{method}", context: subject) }
+        methods.concat super_instance_methods.reverse.map { |method| InstanceMethod.new("#{subject.name}##{method}", context: subject, visibility: :super, file_path: subject_location) }
+        methods.concat native_instance_methods.map { |method| InstanceMethod.new("#{subject.name}##{method}", context: subject, visibility: :native, file_path: subject_location) }
+        methods.concat klass_m.map { |method| ClassMethod.new("#{subject.name}.#{method}", context: subject, file_path: subject_location) }
       end
 
       def methods_pipeline

data/lib/markdown_ruby_documentation/git_hub_link.rb

@@ -10,13 +10,13 @@ module MarkdownRubyDocumentation
 
     def call(hash)
       hash.each do |name, values|
-        hash[name][:text] = "#{values[:text]}\n\n[show on github](#{create_link(name: name, method_object: values[:method_object])})"
+        hash[name][:text] = "#{values[:text]}\n\n[show on github](#{create_link(name: name, method_object: values[:method_object], context: subject)})"
       end
     end
 
-    def create_link(name: nil, method_object: nil)
+    def create_link(name: nil, method_object: nil, context: Kernel)
       if name && method_object.nil?
-        method_object = Method.create("##{name}")
+        method_object = Method.create("##{name}", context: context)
       end
       MethodUrl.new(subject: subject, base_url: base_url, root: root, method_object: method_object).to_s
     end
@@ -66,7 +66,7 @@ module MarkdownRubyDocumentation
       end
 
       def to_s
-        file, lineno = subject.public_send(method_object.type, method_object.name).source_location
+        file, lineno = method_object.source_location
         FileUrl.new(file_path: file, base_url: base_url, root: root).link(file, lineno)
       end
     end

data/lib/markdown_ruby_documentation/method.rb

@@ -2,12 +2,15 @@ module MarkdownRubyDocumentation
   class Method
     InvalidMethodReference = Class.new(StandardError)
     attr_reader :method_reference, :visibility
+    attr_accessor :file_path, :line_no
     protected :method_reference
 
-    def initialize(method_reference, context: Kernel, visibility: :public)
+    def initialize(method_reference, context: Kernel, visibility: :public, file_path: nil, line_no: nil)
       @method_reference = method_reference.to_s
       @context          = context
-      @visibility = visibility
+      @visibility       = visibility
+      @file_path        = file_path
+      @line_no          = line_no
     end
 
     # @param [String] method_reference
@@ -16,16 +19,16 @@ module MarkdownRubyDocumentation
     #   "Constant.class_method_name" class method on a specific constant.
     #   "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, visibility: :public)
+    def self.create(method_reference, null_method: false, context: Kernel, visibility: :public, file_path: nil)
       return method_reference if method_reference.is_a?(Method)
       case method_reference
       when InstanceMethod
-        InstanceMethod.new(method_reference, context: context, visibility: visibility)
+        InstanceMethod.new(method_reference, context: context, visibility: visibility, file_path: file_path)
       when ClassMethod
-        ClassMethod.new(method_reference, context: context, visibility: visibility)
+        ClassMethod.new(method_reference, context: context, visibility: visibility, file_path: file_path)
       else
         if null_method
-          NullMethod.new(method_reference, context: context, visibility: visibility)
+          NullMethod.new(method_reference, context: context, visibility: visibility, file_path: file_path)
         else
           raise InvalidMethodReference, "method_reference is formatted incorrectly: '#{method_reference}'"
         end
@@ -63,7 +66,7 @@ module MarkdownRubyDocumentation
         constant = method_reference.split(type_symbol).first
         begin
           constant.constantize
-        rescue NameError => e
+        rescue NameError
           @context.const_get(constant)
         end
       end
@@ -97,6 +100,14 @@ module MarkdownRubyDocumentation
       context.public_send(type, name)
     end
 
+    def source_location
+      if file_path && line_no
+        [file_path, line_no]
+      else
+        context.public_send(type, name).source_location
+      end
+    end
+
     def type
       raise NotImplementedError
     end

data/lib/markdown_ruby_documentation/template_parser/parsing.rb

@@ -41,12 +41,45 @@ module MarkdownRubyDocumentation
       end
 
       def ruby_class_meth_comment(method)
-        method.context.public_send(method.type, method.name).comment
-
+        comment = method.context.public_send(method.type, method.name).comment
+        if comment.blank?
+          look_for_class_macro_comment(method)
+        else
+          comment
+        end
       rescue MethodSource::SourceNotFoundError => e
         raise e.class, "#{ method.context}#{method.type_symbol}#{method.name}, \n#{e.message}"
       end
 
+      CLASS_MACROS = [:attribute]
+      def source_location(file_path, name)
+        return unless file_path && name
+        found_match = nil
+        CLASS_MACROS.each do |macro|
+          if (ln = get_line_number(file_path.split(":").first, "#{macro} #{Regexp.escape(name.inspect)}"))
+            found_match = ln
+          end
+        end
+        [file_path, found_match] if found_match
+      end
+
+      def get_line_number(file, word)
+        return unless file && word
+        count = 0
+        file_or_result = File.open(file, "r") { |file| file.each_line { |line|
+          count += 1
+          return count if line =~ /^[\s]*#{word}/
+        }}
+        file_or_result.is_a?(File) ? nil : file_or_result
+      end
+
+      def look_for_class_macro_comment(method)
+        return "" unless (sl = source_location(method.file_path, method.name))
+        MethodSource.comment_helper(sl, method.name).tap do |comment|
+          method.line_no = sl[1] unless comment.blank?
+        end
+      end
+
       def ruby_class_meth_source_location(method)
         method.context.public_send(method.type, method.name).source_location
       end

data/lib/markdown_ruby_documentation/version.rb

@@ -1,3 +1,3 @@
 module MarkdownRubyDocumentation
-  VERSION = "0.12.0"
+  VERSION = "0.13.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: markdown_ruby_documentation
 version: !ruby/object:Gem::Version
-  version: 0.12.0
+  version: 0.13.0
 platform: ruby
 authors:
 - Dustin Zeisler
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-23 00:00:00.000000000 Z
+date: 2016-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: method_source