docrb-html 0.2.5 → 0.3.0

data/lib/renderer/defs/specialized_object.rb

@@ -1,172 +0,0 @@
-# frozen_string_literal: true
-
-class Renderer
-  class Defs
-    class SpecializedObject
-      def initialize(obj, parent, provider)
-        @obj = obj
-        @provider = provider
-        prepare(parent)
-      end
-
-      def self.specialize(obj, parent, provider)
-        return nil if obj.nil?
-
-        new(obj, parent, provider)
-      end
-
-      def [](key) = @obj[key]
-      def fetch(*, **, &) = @obj.fetch(*, **, &)
-
-      def resolve(name)
-        named = named_as(name)
-        modules.find(&named) \
-        || classes.find(&named) \
-        || attributes&.find(&named) \
-        || defs.find(&named) \
-        || sdefs.find(&named)
-      end
-
-      def resolve_inheritance(name)
-        named = named_as(name)
-        modules.find(&named) \
-        || classes.find(&named) \
-        || parent&.resolve_inheritance(name)
-      end
-
-      def resolve_parent(name)
-        parent = self[:parent]
-        return { type: "Unknown Ref", name: } unless parent
-
-        parent.resolve(name) || parent.resolve_parent(name)
-      end
-
-      def resolve_path(path)
-        p = path.dup
-        obj = self
-        until p.empty?
-          obj = obj.resolve(p[0])
-          return unless obj
-
-          p.shift
-        end
-        obj
-      end
-
-      def resolve_qualified(obj)
-        result = nil
-        query = nil
-
-        if obj[:class_path]&.length&.> 0
-          query = obj[:class_path] + [obj[:name]]
-          result = root.resolve_path(query)
-        else
-          query = obj[:name]
-          result = resolve(query)
-          result ||= resolve_inheritance(query)
-        end
-
-        puts "Qualified resolution of #{query.inspect} by #{name} failed." unless result
-
-        result
-      end
-
-      def method_missing(method_name, *args, **kwargs, &)
-        var = "@#{method_name}".to_sym
-        if instance_variables.include?(var)
-          instance_variable_get(var)
-        elsif @obj.key? method_name
-          @obj.fetch(method_name)
-        else
-          super
-        end
-      end
-
-      def respond_to_missing?(method_name, include_private = false)
-        instance_variables.include?("@#{method_name}".to_sym) || @obj.key?(method_name) || super
-      end
-
-      def to_s
-        "<SpecializedObject for #{@provider.path_of(@obj).join("::")}>"
-      end
-
-      def inspect = to_s
-
-      def prepare_inheritance
-        @inheritance_prepared = true
-        @inherits = coerce_inheritance_data(@obj[:inherits])
-        @extends = @obj[:extends]&.map { resolve_qualified _1 }
-        @includes = @obj[:includes]&.map { resolve_qualified _1 }
-        @classes.each(&:prepare_inheritance)
-        @modules.each(&:prepare_inheritance)
-      end
-
-      private
-
-      def make_path
-        r = [name]
-        p = parent
-        while p
-          r << p.name
-          p = p.parent
-        end
-
-        r.reverse
-      end
-
-      def parent_of(parent)
-        return unless parent
-
-        p = parent
-        while p
-          return p unless p.parent
-
-          p = p.parent
-        end
-
-        p
-      end
-
-      def specialize_defs(defs, _parent)
-        defs.values.map do |i|
-          decoration = if i[:source] == "inheritance"
-                         "inherited"
-                       elsif i[:overriding]
-                         "override"
-                       else
-                         ""
-                       end
-
-          origin = i[:source]
-
-          @provider.find_source(i)
-                   .merge({ decoration:, origin: })
-        end
-      end
-
-      def coerce_inheritance_data(obj)
-        return obj if obj.nil?
-
-        resolve_inheritance(obj) || obj
-      end
-
-      def prepare(parent)
-        @inheritance_prepared = true
-        @parent = parent
-        @defs = specialize_defs(@obj[:defs], self)
-        @sdefs = specialize_defs(@obj[:sdefs], self)
-        @attributes = (@obj[:attributes] || {}).values.map do |v|
-          @provider.prepare_attr(v)
-        end
-
-        @root = parent_of(parent)
-        @path = make_path
-
-        @classes = @obj[:classes].map { SpecializedObject.specialize(_1, self, @provider) }
-        @modules = @obj[:modules].map { SpecializedObject.specialize(_1, self, @provider) }
-      end
-
-      def named_as(n) = ->(o) { o.name == n }
-    end
-  end
-end

data/lib/renderer/defs/specialized_projection.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-class Renderer
-  class Defs
-    class SpecializedProjection < Array
-      def initialize(provider)
-        super()
-        @provider = provider
-        replace((provider.modules + provider.classes)
-          .map { provider.specialize_object _1 }
-          .each(&:prepare_inheritance))
-      end
-
-      def find_path(path)
-        path = @provider.path_of(path) unless path.is_a? Array
-        p = path.dup
-        obj = find { _1.name == p.first }
-        p.shift
-        return unless obj
-
-        until p.empty?
-          obj = obj.resolve(p.first)
-          p.shift
-          return unless obj
-        end
-
-        obj
-      end
-    end
-  end
-end

data/lib/renderer/defs.rb

@@ -1,180 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "defs/specialized_object"
-require_relative "defs/specialized_projection"
-
-class Renderer
-  class Defs
-    class << self
-      attr_reader :singleton
-    end
-
-    class << self
-      attr_writer :singleton
-    end
-
-    def initialize(base, metadata)
-      @data = JSON.parse(File.read("#{base}/data.json"), symbolize_names: true)
-      @meta = metadata
-      Defs.singleton = self
-    end
-
-    attr_reader :meta
-
-    def classes = @classes ||= make_paths(@data[:classes])
-    def modules = @modules ||= make_paths(@data[:modules])
-
-    def make_paths(obj)
-      return [] unless obj
-
-      obj.each { set_parent(_1, nil) }
-    end
-
-    def set_parent(obj, parent)
-      obj[:parent] = parent
-      obj[:classes].each { set_parent(_1, obj) }
-      obj[:modules].each { set_parent(_1, obj) }
-    end
-
-    def document_outline
-      (classes + modules).map { outline(_1) }
-    end
-
-    def outline(object, level = 0)
-      defs = object[:defs].values.map { map_method(_1) }.sort_by { _1[:name] }
-      sdefs = object[:sdefs].values.map { map_method(_1) }.sort_by { _1[:name] }
-      attributes = object[:attributes]&.values&.map { prepare_attr(_1) }&.sort_by { _1[:name] }
-
-      {
-        level:,
-        name: object[:name],
-        type: object[:type],
-        classes: object[:classes].map { outline(_1, level + 1) },
-        modules: object[:modules].map { outline(_1, level + 1) },
-        defs: defs + sdefs,
-        attributes:
-      }
-    end
-
-    def map_method(met)
-      decoration = if met[:source] == "inheritance"
-                     "inherited"
-                   elsif met[:overriding]
-                     "override"
-                   end
-
-      obj = find_source(met)
-      type = [].tap do |arr|
-        arr << "Class" if obj[:type] == "defs"
-        arr << "Method"
-      end.join(" ")
-
-      {
-        name: obj[:name],
-        visibility: obj[:visibility],
-        args: obj[:args],
-        type:,
-        short_type: obj[:type],
-        doc: obj[:doc],
-        decoration:
-      }
-    end
-
-    def find_source(met)
-      obj = met
-      obj = obj[:definition] while obj[:source] != "source"
-      obj[:definition]
-    end
-
-    def prepare_attr(met)
-      decoration = if met[:source] == "inheritance"
-                     "inherited"
-                   elsif met[:overriding]
-                     "override"
-                   end
-      origin = met[:source]
-      att = find_source(met)
-      visibility = if att[:reader_visibility] == "public" && att[:writer_visibility] == "public"
-                     "read/write"
-                   elsif att[:reader_visibility] == "public" && att[:writer_visibility] != "public"
-                     "read-only"
-                   else
-                     "write-only"
-                   end
-
-      {
-        name: att[:name],
-        type: "Attribute",
-        visibility:,
-        decoration:,
-        origin:,
-        doc: att[:doc]
-      }
-    end
-
-    def path_of(item)
-      p = []
-      parent = item
-      until parent.nil?
-        p << parent[:name]
-        parent = parent[:parent]
-      end
-      p.reverse
-    end
-
-    def definitions_of(item)
-      item[:defined_by]&.map do |d|
-        path_components = d[:filename].split("/")
-        {
-          name: path_components.last,
-          href: git_url(d)
-        }
-      end
-    end
-
-    def git_url(definition)
-      "#{@meta.git_url}/blob/#{@meta.git_tip}#{definition[:filename].gsub(@meta.git_root,
-                                                                          "")}#L#{definition[:start_at]}"
-    end
-
-    def clean_file_path(definition) = definition[:filename].gsub(meta.git_root, "")
-
-    def specialized_projection
-      @specialized_projection ||= SpecializedProjection.new(self)
-    end
-
-    def specialize_data
-      @specialize_data ||= (data[:modules] + data[:classes])
-                           .map { specialize_object _1 }
-                           .each(&:prepare_inheritance)
-    end
-
-    def specialize_object(obj, parent = nil)
-      SpecializedObject.specialize(obj, parent, self)
-    end
-
-    def by_name(n) = ->(o) { o[:name] == n }
-
-    def doc_for(path)
-      path = path_of(path) if path.is_a? Hash
-      path = path.dup
-      named = by_name(path.shift)
-      root = classes.find(&named) || modules.find(&named)
-
-      return unless root
-
-      find_recursive(path, root)
-    end
-
-    def find_recursive(path, root)
-      return root if path.empty?
-
-      named = by_name(path.shift)
-      next_item = root.classes.find(&named) || root.modules.find(&named)
-
-      return nil unless next_item
-
-      find_recursive(path, next_item)
-    end
-  end
-end

data/lib/renderer.rb

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-require "erb"
-require "sassc"
-require "nokogiri"
-
-require_relative "renderer/version"
-require_relative "renderer/core_extensions"
-
-class Renderer
-  ASSETS_PATH = Pathname.new(__dir__).join("../assets")
-  TEMPLATES_PATH = Pathname.new(__dir__).join("../templates")
-  STYLE_BASE = SassC::Engine.new(File.read(ASSETS_PATH.join("style.scss")),
-                                 style: :compressed,
-                                 load_paths: [ASSETS_PATH]).render
-
-  def now = Time.now.strftime("%A, %-d %b %Y %H:%M:%S %Z")
-
-  def initialize(base, output)
-    @base = Pathname.new(base)
-    @output = Pathname.new(output)
-  end
-
-  def metadata = @metadata ||= Metadata.new(@base)
-  def defs = @defs ||= Defs.new(@base, metadata)
-  def footer = @footer ||= Component::Footer.new(version: VERSION, updated_at: now)
-
-  def render
-    project_header = Component::ProjectHeader.new(
-      name: metadata.name,
-      description: metadata.summary,
-      license: metadata.license,
-      owner: metadata.format_authors,
-      links: metadata.project_links
-    )
-
-    index = Page.new(title: "#{metadata.name} - Docrb") do
-      [
-        project_header,
-        Component::TabBar.new(
-          selected_index: 0,
-          items: [
-            { name: "Readme", href: "/" },
-            { name: "Components", href: "/components.html" }
-          ]
-        ),
-        Component::Markdown.new(source: File.read(@base.join("readme.html"))),
-        footer
-      ]
-    end
-
-    components = Page.new(title: "Components - #{metadata.name} - Docrb") do
-      [
-        project_header,
-        Component::TabBar.new(
-          selected_index: 1,
-          items: [
-            { name: "Readme", href: "/" },
-            { name: "Components", href: "/components.html" }
-          ]
-        ),
-        Component::ComponentList.new(list: defs.document_outline),
-        footer
-      ]
-    end
-
-    pages(defs.classes + defs.modules)
-
-    FileUtils.mkdir_p @output
-
-    index.render_to(@output.join("index.html"))
-    components.render_to(@output.join("components.html"))
-    File.write(@output.join("style.css"), STYLE_BASE)
-
-    copy_assets
-  end
-
-  def copy_assets
-    [
-      "js/filtering.js",
-      "favicon.ico"
-    ].each do |file|
-      File.write(@output.join(Pathname.new(file).basename),
-                 File.read(ASSETS_PATH.join(file)))
-    end
-  end
-
-  def pages(comps, parents = [])
-    comps.each do |comp|
-      page = Page.new(
-        title: "#{comp[:name]} - #{metadata.name} - Docrb",
-        level: parents.count
-      ) do
-        [
-          Component::ClassHeader.new(
-            type: comp[:type],
-            name: comp[:name],
-            definitions: defs.definitions_of(comp)
-          ),
-          Component::Breadcrumb.new(
-            project_name: metadata.name,
-            items: (parents + [comp]).map.with_index do |p, idx|
-              { name: p[:name], parents: parents[0...idx].map { _1[:name] } }
-            end
-          ),
-          Component::DocBox.new(
-            item: comp,
-            meta: metadata,
-            defs:
-          ),
-          footer
-        ]
-      end
-
-      parent_dir = @output.join(parents.map { _1[:name] }.join("/"))
-      FileUtils.mkdir_p(parent_dir)
-      page.render_to(parent_dir.join("#{comp[:name]}.html"))
-
-      pages(comp.fetch(:classes, []) + comp.fetch(:modules, []), parents + [comp])
-    end
-  end
-end
-
-require_relative "renderer/template"
-require_relative "renderer/component"
-require_relative "renderer/helpers"
-require_relative "renderer/page"
-require_relative "renderer/metadata"
-require_relative "renderer/defs"