pico 0.0.1

data/lib/pico/application.rb

@@ -0,0 +1,120 @@
+module Pico
+  class Application < Context
+    attr :autoload_paths, :injector
+
+    def initialize(name, root: nil, **params, &config_block)
+      super name, root: root, **params
+      @autoload_paths = []
+      @injector = build_injector
+      configure(config_block) if block_given?
+    end
+
+    def configure(config_block)
+      ConfigurationContext.evaluate(config_block, application: self)
+    end
+
+    def boot!
+      self.root ||= self.class.default_root
+      super
+    end
+
+    def build_const_resolver(expanded_const)
+      resolver = super
+      resolver.autoload_paths = autoload_paths
+      resolver
+    end
+
+    def possible_implicit_namespace?(path)
+      autoload_paths.any? do |autoload_path|
+        root.join(autoload_path, path).directory?
+      end
+    end
+
+    def root=(dir)
+      raise ArgumentError, "Cannot alter root after booting" if booted?
+      @root = Pathname(dir)
+    end
+
+    private
+
+    def build_injector
+      injector = Ruse.create_injector
+      injector.pico_context = self
+      injector
+    end
+
+    def build_mod
+      ApplicationModule.new self
+    end
+
+    class << self
+      def default_root
+        caller_locations.reduce do |previous_location, location|
+          if previous_location.label == "boot!" && File.basename(location.path) != "pico.rb"
+            return Pathname(location.absolute_path).dirname
+          end
+          location
+        end
+      end
+    end
+
+    class ApplicationModule < Module
+      attr :application
+
+      def initialize(application)
+        @application = application
+        extend self
+      end
+
+      def build(const_name, **params)
+        child_injector = application.injector.clone
+        child_injector.configure values: params
+        child_injector.get const_name
+      rescue Ruse::UnknownServiceError => ruse_error
+        raise Exception, "could not resolve dependency `#{ruse_error}'"
+      end
+    end
+
+    class ConfigurationContext
+      def initialize(application)
+        define_singleton_method :__application__ do
+          application
+        end
+      end
+
+      def self.evaluate(config_block, application:)
+        new(application).instance_eval &config_block
+      end
+
+      def autoload_paths
+        __application__.autoload_paths
+      end
+
+      def autoload_paths=(paths)
+        autoload_paths.clear
+        autoload_paths.concat paths
+      end
+
+      def provide(provision = nil, as:, &factory_block)
+        if block_given?
+          raise ArgumentError, "cannot supply a block and a value" if provision
+          provision = factory_block
+        end
+        config_key, value = extract_ruse_config provision
+        __application__.injector.configure config_key => { as.to_sym => value }
+      end
+
+      private
+
+      def extract_ruse_config(provision)
+        case provision
+        when Class then [:aliases, provision.name]
+        when String then [:aliases, provision]
+        when -> p { p.respond_to?(:call) } then [:factories, provision]
+        else [:values, provision]
+        end
+      end
+    end
+
+  end
+end

data/lib/pico/autoloader.rb

@@ -0,0 +1,131 @@
+module Pico
+  using Pico::StringInflections
+
+  class Autoloader
+    attr :base_nibbles, :context, :from, :dir_paths
+
+    def initialize(from)
+      @from = from
+      @context, @base_nibbles = fetch_context_and_base_nibbles
+      @dir_paths = [nil]
+    end
+
+    def <<(const_name)
+      raise_name_error!(const_name) unless context
+      @dir_paths = each_possible_const(const_name).reduce [] do |new_paths, possible_const|
+        resolved_const = context.resolve_const possible_const
+        throw :const, resolved_const if resolved_const
+        new_paths << possible_const if dir?(possible_const)
+        new_paths
+      end
+      raise_name_error!(const_name) if dir_paths.empty?
+    end
+
+    def each_possible_const(const_name)
+      return to_enum(:each_possible_const, const_name) unless block_given?
+      dir_paths.each do |dir_path|
+        base_nibbles.map { |e| yield constify(e, *dir_path, const_name) }
+        yield constify(*dir_path, const_name)
+      end
+    end
+
+    def dir?(possible_const)
+      context.possible_implicit_namespace? possible_const.to_snake_case
+    end
+
+    def constify(*nibbles)
+      nibbles.compact.join '::'
+    end
+
+    def raise_name_error!(const_name = dir_paths.last)
+      message = "uninitialized constant #{const_name}"
+      message << " (in #{context.mod})" if context
+      raise NameError, message
+    end
+
+    # given "Foo::Bar::Baz", return ["Foo::Bar::Baz", "Foo::Bar", etc.]
+    def fetch_context_and_base_nibbles
+      each_base_nibble.to_a.reverse.reduce [] do |ary, (mod, const)|
+        owner = Pico.contexts.each_value.detect { |c| c.mod == mod }
+        return [owner, ary] if owner
+        ary.map! do |e| e.insert 0, '::'; e.insert 0, const; end
+        ary << const
+      end
+      nil
+    end
+
+    # given "Foo::Bar::Baz", return ["Foo", "Bar", "Baz"]
+    def each_base_nibble
+      return to_enum(:each_base_nibble) unless block_given?
+      from.name.split('::').reduce Object do |mod, const|
+        mod = mod.const_get const
+        yield [mod, const]
+        mod
+      end
+    end
+
+    module ThreadedState
+      def autoloaders
+        @autoloaders ||= {}
+      end
+
+      def current_autoloader
+        autoloaders[current_thread_id]
+      end
+
+      def set_current_autoloader(to:)
+        autoloaders[current_thread_id] = to
+      end
+
+      def current_thread_id
+        Thread.current.object_id
+      end
+    end
+    extend ThreadedState
+
+    module HandleConstMissing
+      def handle(*args)
+        found_const = catch :const do
+          handle! *args and return NullModule
+        end
+        throw :const, found_const
+      rescue NameError => name_error; raise name_error
+      ensure
+        set_current_autoloader(to: nil) if found_const or name_error
+      end
+
+      def handle!(const_name, from:)
+        autoloader = current_autoloader || new(from)
+        autoloader << String(const_name)
+        set_current_autoloader to: autoloader
+      end
+    end
+    extend HandleConstMissing
+
+    module NullModule
+      extend self
+
+      def method_missing(*)
+        Autoloader.current_autoloader.raise_name_error!
+      ensure
+        Autoloader.set_current_autoloader to: nil
+      end
+    end
+  end
+end
+
+class Module
+  def const_missing(const)
+    catch :const do
+      Pico::Autoloader.handle const, from: self
+    end
+  rescue NameError => name_error
+    if name_error.class == NameError
+      # Reraise the error to keep our junk out of the backtrace
+      raise NameError, name_error.message
+    else
+      # NoMethodError inherits from NameError
+      raise name_error
+    end
+  end
+end

data/lib/pico/context.rb

@@ -0,0 +1,89 @@
+require "pico/context/const_resolver"
+
+module Pico
+  class Context
+    attr :mod, :name, :root
+
+    def initialize(name, parent: nil, root:)
+      @mod    = build_mod
+      @name   = name
+      @root   = Pathname(root) if root
+      @parent = parent
+    end
+
+    class << self
+      def owner(const)
+        owner, _ = Autoloader.owner_and_ascending_nibbles const
+        owner
+      end
+    end
+
+    def build_mod
+      Module.new
+    end
+
+    def boot!
+      parent.const_set name, mod
+    end
+
+    def booted?
+      parent.const_defined? name
+    end
+
+    def eager_load!
+      Dir[root.join('**/*.rb')].each do |rb_file|
+        load_file rb_file
+      end
+    end
+
+    def load_file(rb_file)
+      mod.module_eval File.read(rb_file), rb_file.to_s
+    end
+
+    def parent
+      return Object unless @parent
+      Pico.contexts.fetch(@parent.to_sym).mod
+    end
+
+    def reload!
+      shutdown!
+      @mod = build_mod
+      boot!
+    end
+
+    def possible_implicit_namespace?(path)
+      root.join(path).directory?
+    end
+
+    def resolve_const(expanded_const)
+      build_const_resolver(expanded_const).resolve
+    end
+
+    def shutdown!
+      parent.send(:remove_const, name)
+    end
+
+    private
+
+    def build_const_resolver(expanded_const)
+      ConstResolver.new(
+        context: self,
+        expanded_const: String(expanded_const).dup.freeze,
+      )
+    end
+
+  end
+
+  class AutoloadError < NameError
+    attr :const, :rb_file
+
+    def initialize(const:, rb_file:)
+      @const   = const
+      @rb_file = rb_file
+    end
+
+    def message
+      "Expected #{rb_file} to define #{const}"
+    end
+  end
+end

data/lib/pico/context/const_resolver.rb

@@ -0,0 +1,80 @@
+module Pico
+  using StringInflections
+
+  class Context
+    class ConstResolver
+      attr :current_path, :autoload_paths, :context, :expanded_const
+
+      def initialize(context:, expanded_const:, autoload_paths: [''])
+        @autoload_paths = autoload_paths
+        @context        = context
+        @expanded_const = expanded_const
+      end
+
+      def autoload_paths=(paths)
+        autoload_paths.clear
+        autoload_paths.concat paths
+      end
+
+      def const_get
+        walk_const_parts.reduce context.mod do |mod, const_part|
+          return nil unless mod.const_defined?(const_part)
+          mod.const_get const_part
+        end
+      end
+
+      def each_autoload_path
+        autoload_paths.each do |autoload_path|
+          @current_path = context.root.join autoload_path
+          yield
+        end
+        @current_path = nil
+      end
+
+      def each_possible_rb_file
+        each_autoload_path do
+          base_path = current_path.join expanded_const.to_snake_case
+          each_rb_file_from_base_path base_path do |rb_file|
+            yield rb_file if File.exist?(rb_file)
+          end
+        end
+      end
+
+      def each_rb_file_from_base_path(base_path)
+        base_path.ascend do |path|
+          return if path == context.root
+          rb_file = path.sub_ext '.rb'
+          yield rb_file if rb_file.file?
+        end
+      end
+
+      def resolve
+        each_possible_rb_file do |rb_file|
+          context.load_file rb_file
+          check_loaded rb_file
+        end
+        const_get
+      end
+
+      def walk_const_parts(const = expanded_const)
+        return to_enum(:walk_const_parts, const) if block_given?
+        const.split '::'
+      end
+
+      def check_loaded(rb_file)
+        expected_const = expected_const_defined_in_rb_file rb_file
+        walk_const_parts(expected_const).reduce context.mod do |mod, const_part|
+          mod.const_defined?(const_part) or
+            raise AutoloadError.new(const: expected_const, rb_file: rb_file)
+          mod.const_get const_part
+        end
+      end
+
+      def expected_const_defined_in_rb_file(rb_file, autoload_path: current_path)
+        rel_path = rb_file.sub_ext('').relative_path_from(autoload_path).to_s
+        matcher = %r{\A(#{rel_path.to_camel_case})}i
+        expanded_const.match(matcher).captures.fetch 0
+      end
+    end
+  end
+end

data/lib/pico/pry_context.rb

@@ -0,0 +1,71 @@
+require 'pry'
+
+require "pico/test_runner"
+
+module Pico
+  module PryContext
+    extend self
+
+    attr :commands_defined
+
+    def start!
+      if Pico.application.booted?
+        raise Error, "cannot start pry context if application has booted"
+      end
+      define_commands unless commands_defined
+      Pico.boot!
+      Pico.application.mod.pry
+    end
+
+    def define_commands
+      define_reload_command
+      define_rake_command
+      define_tmux_command if ENV['TMUX']
+      @commands_defined = true
+    end
+
+    def define_reload_command
+      Pry::Commands.block_command "reload!", "Reload #{Pico.application.name}" do
+        puts "Reloading #{Pico.application.name}..."
+        Pico.application.reload!
+        _pry_.binding_stack.push Pico.application.mod.__binding__
+        _pry_.binding_stack.shift until _pry_.binding_stack.size == 1
+      end
+    end
+
+    def define_rake_command
+      Pry::Commands.create_command "rake", keep_retval: true do
+        description "Run the test suite"
+
+        def process
+          build_passed = Pico::TestRunner.run!
+          operator = args.shift
+          command = args.shift
+          evaluate_hook(build_passed, operator, command, args) if operator
+          build_passed
+        end
+
+        def evaluate_hook(build_passed, operator, command, args)
+          if operator == '&&'
+            run(command, args) if build_passed
+          elsif operator == '||'
+            run(command, args) unless build_passed
+          else
+            raise ArgumentError, "Must supply either '&&' or '||' operators, followed by a pry command"
+          end
+        end
+      end
+
+      def define_tmux_command
+        Pry::Commands.create_command "tmux" do
+          description "Run a tmux command"
+
+          def process
+            system 'tmux', *args
+          end
+        end
+      end
+    end
+
+  end
+end