pico 0.0.1

data/lib/pico/rake.rb

@@ -0,0 +1,15 @@
+task :env do
+  Pico.application.root = Rake.application.original_dir
+end
+
+desc "Open up a console"
+task console: :env do
+  require "pico/pry_context"
+  Pico::PryContext.start!
+end
+
+desc "Run the test suite"
+task test: :env do
+  require "pico/test_runner"
+  Pico::TestRunner.run!
+end

data/lib/pico/ruse_extensions.rb

@@ -0,0 +1,9 @@
+Ruse::TypeResolver.class_eval do
+  def load_type(type_name)
+    @injector.pico_context.resolve_const type_name
+  end
+end
+
+Ruse::Injector.class_eval do
+  attr_accessor :pico_context
+end

data/lib/pico/string_inflections.rb

@@ -0,0 +1,30 @@
+module Pico
+  module StringInflections
+    refine String do
+      def to_camel_case
+        str = "_#{self}"
+        str.gsub!(%r{_[a-z]}) { |snake| snake.slice(1).upcase }
+        str.gsub!('/', '::')
+        str
+      end
+
+      def to_snake_case
+        str = gsub '::', '/'
+        # Convert FOOBar => FooBar
+        str.gsub! %r{[[:upper:]]{2,}} do |uppercase|
+          bit = uppercase[0]
+          bit << uppercase[1...-1].downcase
+          bit << uppercase[-1]
+          bit
+        end
+        str.gsub! %r{[[:lower:]][[:upper:]]+[[:lower:]]} do |camel|
+          bit = camel[0]
+          bit << '_'
+          bit << camel[1..-1].downcase
+        end
+        str.downcase!
+        str
+      end
+    end
+  end
+end

data/lib/pico/test_runner.rb

@@ -0,0 +1,27 @@
+module Pico
+  module TestRunner
+    extend self
+
+    def run!
+      Bundler.require :test
+
+      pid = fork do
+        Pico.shutdown! # For when we're inside pry
+        %w(test spec).each do |test_dir| load_test_files_in test_dir; end
+        Minitest.autorun
+      end
+
+      _, status = Process.wait2 pid
+      status.exitstatus == 0
+    end
+
+    def load_test_files_in(test_dir)
+      path = Pico.application.root.join(test_dir)
+      return unless path.directory?
+      $LOAD_PATH << path
+      Dir[path.join("**/*_#{test_dir}.rb")].each do |test_file|
+        load test_file
+      end
+    end
+  end
+end

data/lib/pico/version.rb

@@ -0,0 +1,3 @@
+module Pico
+  VERSION = "0.0.1"
+end

data/pico.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pico/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pico"
+  spec.version       = Pico::VERSION
+  spec.authors       = ["ntl"]
+  spec.email         = ["nathanladd+github@gmail.com"]
+  spec.summary       = %q{Pico is a micro framework designed to get you some basic, essential functionality and then get out of your way.}
+  spec.description   = %q{A very light weight framework for ruby designed to handle a small number of details common to most every application.}
+  spec.homepage      = "https://github.com/ntl/pico"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^test/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "ruse", "~> 0.0.4"
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "colorize"
+  spec.add_development_dependency "fakefs"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "minitest-reporters"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rake"
+end

data/test/integration/autoloading_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+class AutoloadingTest < Minitest::Test
+  include FakesFilesystem
+  include TestsAutoloading
+
+  def test_simple_case
+    assert_equal 'hello from A::AA', Foo::A.references_aa
+  end
+
+  def test_negative_case
+    assert_raises NameError do
+      Foo::A.references_abracadabra
+    end
+  end
+
+  def test_deeply_nested_module_with_implicit_namespaces
+    assert_equal 'hello from C::CA::CAA::CAAA', Foo::A.references_caaa
+  end
+
+  def test_reference_from_within_constant
+    assert_equal 'hello from A', Foo::D.references_a
+    assert_equal 'hello from B::BA', Foo::D.new.references_b_ba
+  end
+
+  def test_invoking_method_inside_implicit_namespace_raises_error
+    exception = assert_raises NameError do
+      Foo::C.hello
+    end
+    assert_equal "uninitialized constant C (in Foo)", exception.message
+  end
+
+  def test_raises_name_error_if_no_context_found
+    exception = assert_raises NameError do
+      Abracadabra
+    end
+    assert_equal "uninitialized constant Abracadabra", exception.message
+  end
+
+  def test_application_autoload_paths
+    Pico.application.resolve_const 'A'
+    assert_equal 'hello from MyApp::A', MyApp::A.message
+    # Implicit namespace
+    assert_equal 'hello from MyApp::B::BA', MyApp::A.references_b_ba
+  end
+
+end

data/test/support/fakes_filesystem.rb

@@ -0,0 +1,182 @@
+module FakesFilesystem
+  def before_setup
+    super
+    FakeFS::FileSystem.clear
+    FakeFS.activate!
+    World.build!
+    monkeypatch_assert!
+  end
+
+  def after_teardown
+    unmonkeypatch_assert!
+    FakeFS.deactivate!
+    super
+  end
+
+  private
+
+  def monkeypatch_assert!
+    Minitest::Assertions.module_eval do
+      alias_method :orig_diff, :diff
+      def diff(*args)
+        FakeFS.without { orig_diff *args }
+      end
+    end
+  end
+
+  def unmonkeypatch_assert!
+    Minitest::Assertions.module_eval do
+      undef_method :diff
+      alias_method :diff, :orig_diff
+    end
+  end
+
+  module World
+    extend self
+
+    def build!
+      Dir.mkdir '/foo'
+
+      File.write "/foo/a.rb", <<-FILE
+module A
+  def self.message
+    "hello from A"
+  end
+
+  def self.references_aa
+    AA.message
+  end
+
+  def self.references_abracadabra
+    Abracadabra.message
+  end
+
+  def self.references_caaa
+    C::CA::CAA::CAAA.message
+  end
+
+  module AB
+    def self.message
+      "hello from A::AB"
+    end
+
+    module ABA
+      def self.message
+        "hello from A::AB::ABA"
+      end
+
+      def self.references_abb
+        ABB.message
+      end
+    end
+  end
+end
+     FILE
+
+     Dir.mkdir "/foo/a"
+     File.write "/foo/a/aa.rb", <<-FILE
+module A
+  module AA
+    def self.message
+      "hello from A::AA"
+    end
+  end
+end
+      FILE
+
+      Dir.mkdir "/foo/a/ab"
+      File.write "/foo/a/ab/abb.rb", <<-FILE
+module A
+  module AB
+    module ABB
+      def self.message
+        "hello from A::AB::ABB"
+      end
+    end
+  end
+end
+      FILE
+
+      Dir.mkdir "/foo/b"
+      File.write "/foo/b/ba.rb", <<-FILE
+module B
+  module BA
+    def self.message
+      "hello from B::BA"
+    end
+  end
+end
+      FILE
+
+      Dir.mkdir "/foo/c"
+      Dir.mkdir "/foo/c/ca"
+      Dir.mkdir "/foo/c/ca/caa"
+      File.write "/foo/c/ca/caa/caaa.rb", <<-FILE
+module C
+  module CA
+    module CAA
+      module CAAA
+        def self.message
+          "hello from C::CA::CAA::CAAA"
+        end
+      end
+    end
+  end
+end
+      FILE
+
+      File.write "/foo/d.rb", <<-FILE
+class D
+  def self.references_a
+    A.message
+  end
+  def references_b_ba
+    B::BA.message
+  end
+end
+      FILE
+
+      Dir.mkdir "/bar"
+      File.write "/bar/a.rb", <<-FILE
+module A
+  def self.message
+    "hello from Bar::A"
+  end
+end
+      FILE
+
+      File.write "/bar/b.rb", <<-FILE
+module B
+  def self.message
+    "hello from Bar::B"
+  end
+end
+      FILE
+
+      Dir.mkdir "/my_app"
+      Dir.mkdir "/my_app/lib"
+      File.write "/my_app/lib/a.rb", <<-FILE
+module A
+  def self.message
+    "hello from MyApp::A"
+  end
+
+  def self.references_b_ba
+    B::BA.message
+  end
+end
+      FILE
+
+      Dir.mkdir "/my_app/lib/b"
+      File.write "/my_app/lib/b/ba.rb", <<-FILE
+module B
+  module BA
+    def self.message
+      "hello from MyApp::B::BA"
+    end
+  end
+end
+      FILE
+    end
+  end
+end

data/test/support/tests_autoloading.rb

@@ -0,0 +1,16 @@
+module TestsAutoloading
+  def setup
+    @foo = Pico.define_context :Foo, root: "/foo"
+    @bar = Pico.define_context :Bar, root: '/bar', parent: :Foo
+    @app = Pico.define_application :MyApp, root: "/my_app" do
+      self.autoload_paths << 'lib'
+    end
+    Pico.boot!
+    assert_nil Pico::Autoloader.current_autoloader
+  end
+
+  def teardown
+    assert_nil Pico::Autoloader.current_autoloader,
+      "Each test in this file must clean up after itself"
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,36 @@
+require "bundler"
+Bundler.setup
+
+require "minitest/autorun"
+require "minitest/reporters"
+
+require "colorize"
+require "fakefs/safe"
+require "ostruct"
+require "pathname"
+require "stringio"
+
+Minitest::Reporters.use! Minitest::Reporters::DefaultReporter.new
+
+require_relative "../lib/pico"
+
+$LOAD_PATH << "test/support"
+
+Minitest::Test.class_eval do
+  autoload :FakesFilesystem, "fakes_filesystem"
+  autoload :TestsAutoloading, "tests_autoloading"
+
+  def after_teardown
+    Pico.shutdown!
+  end
+end
+
+class Binding
+  def method_missing(sym, *)
+    return super unless sym == :pry
+    FakeFS.without do
+      require 'pry'
+      pry
+    end
+  end
+end

data/test/unit/application_test.rb

@@ -0,0 +1,79 @@
+require 'test_helper'
+
+class ApplicationTest < Minitest::Test
+  def test_defining_an_application
+    Pico.define_application :Foo
+    Pico.boot!
+    refute_nil Pico.application
+    assert_equal :Foo, Pico.application.name
+    assert_equal Pathname(__FILE__).dirname, Pico.application.root
+  end
+
+  def test_autoload_paths
+    Pico.define_application :Foo do
+      self.autoload_paths = %w(lib app)
+    end
+
+    assert_equal %w(lib app), Pico.application.autoload_paths
+  end
+
+  def test_providing_objects
+    Pico.define_application :Foo do
+      provide as: 'foo' do :provided_foo; end
+      provide :provided_bar, as: 'bar'
+      provide 'MyClass', as: 'baz'
+    end
+    Pico.boot!
+
+    my_class = Class.new do def message; :provided_baz; end ; end
+    Object.const_set :MyClass, my_class
+
+    consumer = Class.new do
+      attr :foo, :bar, :baz, :ping
+      def initialize(foo, bar, baz, ping:)
+        @foo = foo ; @bar = bar ; @baz = baz; @ping = ping
+      end
+    end
+    Foo.const_set :Consumer, consumer
+
+    obj = Foo.build(:Consumer, ping: 'pong')
+    assert_equal :provided_foo, obj.foo
+    assert_equal :provided_bar, obj.bar
+    assert_equal :provided_baz, obj.baz.message
+    assert_equal 'pong', obj.ping
+
+  ensure
+    Object.send :remove_const, :MyClass
+  end
+
+  def test_wraps_ruse_errors
+    Pico.define_application :Foo
+    Pico.boot!
+
+    consumer = Class.new do
+      attr :unmet_dep
+      def initialize(unmet_dep)
+        @unmet_dep = unmet_dep
+      end
+    end
+    Foo.const_set :Consumer, consumer
+
+    exception = assert_raises Pico::Exception do
+      Foo.build(:Consumer)
+    end
+
+    assert_equal "could not resolve dependency `unmet_dep'", exception.message
+  end
+
+  def test_cannot_provide_object_as_block_and_arg
+    exception = assert_raises ArgumentError do
+      Pico.define_application :Foo do
+        provide :a_value, as: :foo do
+          :another_value
+        end
+      end
+    end
+
+    assert_equal "cannot supply a block and a value", exception.message
+  end
+end