docrb 0.2.0 → 0.3.0

data/lib/docrb/markdown.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-module Docrb
-  # Renderer provides a Redcarpet renderer with Rouge extensions
-  class Renderer < Redcarpet::Render::HTML
-    def initialize(extensions = {})
-      super extensions.merge(link_attributes: { target: "_blank" })
-    end
-    include Rouge::Plugins::Redcarpet
-  end
-
-  # InlineRenderer provides a renderer for inline contents. This renderer
-  # does not emit paragraph tags.
-  class InlineRenderer < Renderer
-    def paragraph(text)
-      text
-    end
-  end
-
-  # Markdown provides utilities for generating HTML from markdown contents
-  class Markdown
-    # Internal: Creates a new renderer based on a provided type by setting
-    # sensible defaults.
-    #
-    # type - Type of the renderer to be initialised. Use Docrb::Renderer or
-    #        InlineRenderer
-    def self.make_render(type)
-      Redcarpet::Markdown.new(
-        type,
-        fenced_code_blocks: true,
-        autolink: true
-      )
-    end
-
-    # Renders a given input using the default renderer.
-    #
-    # input - Markdown content to be rendered
-    #
-    # Returns an HTML string containing the rendered Markdown content
-    def self.render(input)
-      make_render(Renderer).render(input)
-    end
-
-    # Renders a given input using the inline renderer.
-    #
-    # input - Markdown content to be rendered
-    #
-    # Returns an HTML string containing the rendered Markdown content
-    def self.inline(input)
-      make_render(InlineRenderer).render(input)
-    end
-
-    # Renders a given Ruby source code into HTML
-    #
-    # source - Source code to be rendered
-    #
-    # Returns an HTML string containing the rendered source code
-    def self.render_source(source)
-      render("```ruby\n#{source}\n```")
-    end
-  end
-end

data/lib/docrb/module_extensions.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-unless Class.respond_to? :try?
-  class Object
-    def try?(method, *args, **kwargs, &)
-      send(method, *args, **kwargs, &) if respond_to?(method)
-    end
-
-    def self.try?(method, *args, **kwargs, &)
-      send(method, *args, **kwargs, &) if respond_to?(method)
-    end
-  end
-end

data/lib/docrb/resolvable.rb

@@ -1,178 +0,0 @@
-# frozen_string_literal: true
-
-module Docrb
-  # Resolvable implements utilities for resolving names and class paths on a
-  # container context (module/class)
-  class Resolvable
-    # Returns a matcher for a provided name
-    #
-    # name - Name to match against
-    def by_name(name)
-      ->(obj) { obj.name == name }
-    end
-
-    # Returns a matcher for a provided name and type
-    #
-    # name - Name to match against
-    # type - Object type to match against (:def/:sdef/:class/:module...)
-    def by_name_and_type(name, type)
-      ->(obj) { obj.name == name && obj.type == type }
-    end
-
-    # Attempts to resolve a method with a provided name in the container's
-    # context. This method attempts to match for instance methods, class
-    # methods, and finally by recursively calling this method on the inherited
-    # members, if any.
-    #
-    # name - Name of the method to be resolved.
-    #
-    # Returns a method structure, or nil, in case none is found.
-    def resolve_method(name)
-      if (local = try?(:defs)&.find(&by_name(name)))
-        return local
-      end
-
-      if (local = try?(:sdefs)&.find(&by_name(name)))
-        return local
-      end
-
-      # Inherited?
-      if (inherited = try?(:inherits)&.try?(:resolve_method, name, type))
-        return inherited
-      end
-
-      nil
-    end
-
-    # Resolves a container using a provided reference.
-    #
-    # ref - Either a reference hash (containing :class_path, :target, :name), or
-    #       a symbol representing the name of the container being resolved.
-    #
-    # Returns a matched container or nil, in case none is found.
-    def resolve_container(ref)
-      if ref.is_a? Hash
-        path = ref
-               .slice(:class_path, :target, :name)
-               .values
-               .flatten
-               .compact
-        return resolve_container(path)
-      end
-
-      ref = [ref] if ref.is_a? Symbol
-
-      if ref.length == 1
-        name = ref.first
-        # module?
-        if (mod = try?(:modules)&.find(&by_name(name)))
-          return mod
-        end
-
-        # class?
-        if (cls = try?(:classes)&.find(&by_name(name)))
-          return cls
-        end
-
-        # parent?
-        return @parent&.resolve_container(ref)
-      end
-
-      obj = self
-      while ref.length.positive?
-        obj = resolve_container(ref.shift)
-        return nil if obj.nil?
-      end
-
-      obj
-    end
-
-    # Resolves a provided name in the current containter's context. This method
-    # will attempt to return an object matching the provided name by looking for
-    # it in the following subcontainers: modules, classes, methods, attributes,
-    # and recursively performing the resolution on the container's parent, if
-    # any.
-    #
-    # name - Name of the object being resolved
-    #
-    # Returns the first object found by the provided name, or nil, in case none
-    # is found.
-    def resolve(name)
-      return nil if name.nil?
-
-      name = name.to_sym
-
-      # module?
-      if (mod = try?(:modules)&.find(&by_name(name)))
-        return mod
-      end
-
-      # class?
-      if (cls = try?(:classes)&.find(&by_name(name)))
-        return cls
-      end
-
-      # method?
-      if (met = resolve_method(name))
-        return met
-      end
-
-      # attribute?
-      if (att = try?(:attributes)&.find(&by_name(name)))
-        return att
-      end
-
-      if (obj = @parent&.resolve(name))
-        return obj
-      end
-
-      nil
-    end
-
-    # Resolves a provided ref by creating its path string representation and
-    # calling #resolve_qualified
-    #
-    # ref - Hash representing the reference being resolved.
-    #
-    # Returns the object under the provided reference, or nil.
-    def resolve_ref(ref)
-      path = ref
-             .slice(:class_path, :target, :name)
-             .values
-             .flatten
-             .compact
-      return resolve_qualified(path.join("::")) if path.length > 1
-
-      resolve(path[0])
-    end
-
-    # Resolves a qualified path under the current container's context.
-    #
-    # path - Path of the object being resolved. Must be a string containing the
-    #        object name being searched, or a classpath for it (e.g.
-    #        `Foo::Bar::Baz`)
-    def resolve_qualified(path)
-      components = path.split("::").map(&:to_sym)
-      obj = root
-      until components.empty?
-        obj = obj.resolve(components.shift)
-        break if obj.nil?
-      end
-      obj
-    end
-
-    # Returns the root object for the current container
-    def root
-      obj = self
-      obj = obj.parent while obj.parent
-      obj
-    end
-
-    # Returns the container's full qualified path
-    def path
-      return [] if parent.nil?
-
-      parent.path + [name]
-    end
-  end
-end