dirload 0.6.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 96c8cec00fefea226ccd40b45b876c674ab1c58782033134d42b202c3b4fe27e
+  data.tar.gz: 52bd411227f4d22d78162e0a4a90eb1c23a80d9b63ce434d88e274eb173b4dec
+SHA512:
+  metadata.gz: 70624c6d69e6a945a3e1cb18c55483ca07724cc683641dfe6ff1a3d2b733c5079c3294e1e4dada1c1612be38c7292cd064882cc0d8efb79eddcf52b2ebf74d73
+  data.tar.gz: 86c1ea5c9d70fe629351f2b07a6f1441c3bef6ff71ac6b7df2d8350e417c2dbebe09eb9f2025fe8d01aa56b01c268682d364e3ba9d3383fdec286da7b8a9e97b

data/lib/adapters/adapter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# rubocop:disable Lint/UnusedMethodArgument
+
+module Dirload
+  class Adapter
+    EXTENSIONS = [].freeze
+
+    def mapload(file_path:) = nil
+
+    def preload(file_path:) = nil
+
+    def evaluate(file_path:, top_level_binding: nil) = nil
+  end
+end
+
+# rubocop:enable Lint/UnusedMethodArgument

data/lib/adapters/markdown_adapter.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'lowkey'
+require_relative 'adapter'
+
+module Dirload
+  class MarkdownAdapter < Adapter
+    EXTENSIONS = %w[md rd markdown raindown].freeze
+  end
+end

data/lib/adapters/rbx_adapter.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'lowkey'
+require_relative 'adapter'
+require_relative '../loader'
+
+def top_level_binding
+  binding
+end
+
+module Dirload
+  class RBXAdapter < Adapter
+    EXTENSIONS = ['rbx'].freeze
+
+    # Map all definitions and dependencies.
+    def mapload(file_path:)
+      Lowkey.load(file_path)
+    end
+
+    # Then autoload all dependencies for those files.
+    def preload(file_path:)
+      Loader.add_autoloads(file_proxy: Lowkey[file_path])
+    end
+
+    # Now we can load the file into Ruby.
+    def evaluate(file_path:)
+      # 1. "File Load" phase.
+      file_proxy = Lowkey[file_path] || Lowkey.load(file_path)
+      templates = wrap_render_methods(file_proxy:)
+
+      # 2. "Class Load" phase.
+      # Not a security risk because "eval" is equivalent to "load" or "require_relative" in this context.
+      eval(file_proxy.export, top_level_binding, file_proxy.file_path, 0) # rubocop:disable Security/Eval
+
+      # 3. "Runtime" phase (before low nodes are rendered).
+      # Templates only exist if antlers gem has been required by another gem (like LowNode) and the template contains antlers syntax.
+      templates.each do |namespace, method_template|
+        klass = Object.const_get(namespace)
+        method, template = method_template
+        # TODO: If params contain "**props" or similar then send that, so that LowNode can replicate it.
+        params = method.params.map(&:name)
+
+        next unless supports_templates?(klass) || raise(UnsupportedTemplate, "Template for '#{namespace}' identified but not implemented")
+
+        # TODO: Make template engine configurable.
+        klass.build_template(template:, params:, engine: Antlers, namespace:)
+      end
+    end
+
+    private
+
+    def supports_templates?(klass)
+      klass.respond_to?(:render) && klass.respond_to?(:template) && klass.respond_to?(:build_template)
+    end
+
+    def wrap_render_methods(file_proxy:)
+      # GOAL: Templates could be organised by method and template rendering engine.
+      templates = {}
+
+      file_proxy.definitions.each_value do |class_proxy|
+        render_method = class_proxy.respond_to?(:instance_methods) ? class_proxy.instance_methods[:render] : nil
+
+        next unless render_method
+
+        render_method_body = render_method.body.export
+
+        if defined?(Antlers) && ['{', '<{'].any? { |needle| render_method_body.include?(needle) }
+          templates[class_proxy.namespace] = [render_method, render_method_body]
+        end
+
+        # Intended to target HTML or Antlers tags. Use HEREDOC "<<~" in a plain Ruby (".rb") file, not RBX.
+        render_method.body.wrap(prefix: '%q{', suffix: '}') if render_method_body.strip.start_with?('<')
+      end
+
+      templates
+    end
+  end
+end

data/lib/adapters/ruby_adapter.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'lowkey'
+require_relative 'adapter'
+require_relative '../loader'
+
+module Dirload
+  class RubyAdapter < Adapter
+    EXTENSIONS = ['rb'].freeze
+
+    # Map all definitions and dependencies.
+    def mapload(file_path:)
+      Lowkey.load(file_path)
+    end
+
+    # Then autoload all dependencies for those files.
+    def preload(file_path:)
+      Loader.add_autoloads(file_proxy: Lowkey[file_path])
+    end
+
+    # Now we can load the file into Ruby.
+    def evaluate(file_path:)
+      load(file_path)
+    end
+  end
+end

data/lib/dirload.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative 'adapters/markdown_adapter'
+require_relative 'adapters/rbx_adapter'
+require_relative 'adapters/ruby_adapter'
+require_relative 'loader'
+require_relative 'metadata'
+
+module Dirload
+  class UnsupportedFileType < StandardError; end
+  class UnsupportedTemplate < StandardError; end
+
+  ADAPTERS = [MarkdownAdapter.new, RBXAdapter.new, RubyAdapter.new].freeze
+
+  def dirload(path, pwd = Dir.pwd, error: false) # rubocop:disable Metrics/AbcSize
+    absolute_path = File.expand_path(path, pwd)
+
+    return adapter_load(file_path: absolute_path) unless File.directory?(absolute_path)
+
+    loaded_paths = {}
+    missed_paths = []
+    file_types = {}
+
+    file_paths(absolute_path:).each do |file_path|
+      if (adapter = find_adapter(file_path:))
+        loaded_paths[file_path] = adapter
+      else
+        missed_paths << adapter
+      end
+
+      file_types[extension(file_path:)] ||= []
+      file_types[extension(file_path:)] << file_path
+    end
+
+    step(:mapload, loaded_paths:)
+    step(:preload, loaded_paths:)
+    step(:evaluate, loaded_paths:)
+
+    Metadata.new(loaded_paths:, missed_paths:, file_types:)
+  end
+
+  private
+
+  def file_paths(absolute_path:)
+    Dir["#{absolute_path}/**/*"].filter { !File.directory?(it) }
+  end
+
+  def adapter_load(file_path:)
+    adapter = find_adapter(file_path:)
+
+    raise(UnsupportedFileType, "Could not load #{file_path}") if adapter.nil?
+
+    adapter.evaluate(file_path:)
+  end
+
+  def step(step, loaded_paths:)
+    loaded_paths.each do |file_path, adapter|
+      adapter&.send(step, file_path:)
+    end
+  end
+
+  def find_adapter(file_path:)
+    ADAPTERS.find { |adapter| adapter.class::EXTENSIONS.include?(extension(file_path:)) }
+  end
+
+  def extension(file_path:)
+    File.extname(file_path).delete_prefix('.')
+  end
+end
+
+Kernel.send(:include, Dirload)

data/lib/loader.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Dirload
+  class Loader
+    class MissingDependencyError < StandardError; end
+
+    class << self
+      def add_autoloads(file_proxy:)
+        autoloads = []
+
+        file_proxy.dependencies.each do |namespace_with_dependency|
+          *namespace, dependency = namespace_with_dependency.split('::')
+
+          dependency_proxies = find_dependency_proxies(namespace:, dependency:)
+
+          current_namespace = Object
+          namespace.each do |module_name|
+            current_namespace.const_set(module_name, Module.new) unless current_namespace.const_defined?(module_name)
+            current_namespace = current_namespace.const_get(module_name)
+          end
+
+          dependency_proxies.each do |dependency_proxy|
+            autoloads << { origin: file_proxy.file_path, current_namespace:, dependency:, file_path: dependency_proxy.file_path }
+            current_namespace.autoload(dependency.to_sym, dependency_proxy.file_path)
+          end
+        end
+
+        autoloads
+      end
+
+      def find_dependency_proxies(namespace:, dependency:)
+        return Lowkey[dependency] || raise(MissingDependencyError) if namespace.empty?
+
+        namespace_with_dependency = [namespace, dependency].join('::')
+        return Lowkey[namespace_with_dependency] if Lowkey[namespace_with_dependency]
+
+        namespace.pop
+        find_dependency_proxies(namespace:, dependency:)
+      rescue MissingDependencyError => e
+        raise(MissingDependencyError, "Couldn't autoload #{dependency}. Require it manually?") unless const_get(dependency)
+
+        []
+      end
+    end
+  end
+end

data/lib/metadata.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'adapters/markdown_adapter'
+
+module Dirload
+  class Metadata
+    EXTENSIONS = [
+      *::Dirload::MarkdownAdapter::EXTENSIONS,
+      *::Dirload::RBXAdapter::EXTENSIONS,
+      *::Dirload::RubyAdapter::EXTENSIONS
+    ].freeze
+
+    attr_accessor :loaded_paths, :missed_paths, :file_types
+
+    def initialize(loaded_paths:, missed_paths:, file_types:)
+      @loaded_paths = loaded_paths
+      @missed_paths = missed_paths
+      @file_types = file_types
+    end
+  end
+end

data/lib/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Dirload
+  VERSION = '0.6.2'
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: dirload
+version: !ruby/object:Gem::Version
+  version: 0.6.2
+platform: ruby
+authors:
+- maedi
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lowkey
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: An autoloader that lets you use any module namespace with any folder
+  structure and mix in manual requires.
+email:
+- maediprichard@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/adapters/adapter.rb
+- lib/adapters/markdown_adapter.rb
+- lib/adapters/rbx_adapter.rb
+- lib/adapters/ruby_adapter.rb
+- lib/dirload.rb
+- lib/loader.rb
+- lib/metadata.rb
+- lib/version.rb
+homepage: https://github.com/low-rb/dirload
+licenses: []
+metadata:
+  homepage_uri: https://github.com/low-rb/dirload
+  source_code_uri: https://github.com/low-rb/dirload/src/branch/main
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.6
+specification_version: 4
+summary: An autoloader without namespace and folder structure conventions
+test_files: []