pakada 0.0.0 → 0.0.1

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -1,12 +1,5 @@
 source "http://rubygems.org"
 
-group :pakada do
-  gem "pakada", :path => "."
-end
-
-group :testing do
-  gem "mocha"
-  gem "fakefs"
-  gem "fakefs-require"
-end
+gemspec
 
+gem "awesome_print"

data/Rakefile

@@ -1,4 +1,9 @@
 require "bundler"
-Bundler.setup(:pakada)
+Bundler.setup :development
 
-require "pakada/tasks"
+require "rspec/core/rake_task"
+
+task :default => :spec
+RSpec::Core::RakeTask.new :spec
+
+Bundler::GemHelper.install_tasks

data/lib/pakada/module.rb

@@ -1,81 +1,65 @@
 class Pakada
   module Module
-    @descendants = Dictionary.new
+    @descendants = {}
     
     class << self
       attr_reader :descendants
       
-      def prepare
-        specs = []
-        Gem.loaded_specs.each do |name, spec|
-          next unless name =~ Regexp.new("^#{gem_prefix}")
-          i = $LOAD_PATH.find_index(spec.load_paths.first)
-          specs[i] = spec
-        end
-        specs.delete(nil)
+      def included(klass)
+        klass.send :include, Hooked::Container
+        
+        klass.singleton_class.class_eval { attr_reader :module_name, :path }
         
-        specs.reverse.each do |spec|
-          name = spec.name[gem_prefix.length..-1].to_sym
-          @descendants[name] = {
-            :gemspec => spec,
-            :klass => nil,
-            :path => spec.full_gem_path,
-          } unless @descendants[name]
+        unless klass.module_name
+          klass.instance_variable_set :@module_name, detect_name(klass.to_s)
+        end
+        unless klass.module_name
+          raise "Could not detect name for module #{klass}"
         end
-      end
-      
-      def load
-        prepare
         
-        @descendants.each do |name, mod|
-          next if mod[:klass]
-          require(mod[:gemspec].full_gem_path + "/module")
+        unless klass.path
+          # use Kernel.caller instead of self.caller so Mocha doesn't explode...
+          file = Kernel.caller[0].split(":")[0]
+          klass.instance_variable_set :@path, detect_path(file)
         end
+        
+        @descendants[klass.module_name] = klass
       end
       
-      def gem_prefix
-        @gem_prefix ||= "pakada" + Pakada::VERSION.split(".")[0] + "-"
+      def detect_name(klass)
+        name = klass.gsub(/^Pakada::/, "").
+          gsub(/([A-Z]+)([A-Z][a-z])/, "\\1_\\2").
+          gsub(/([a-z])([A-Z])/, "\\1_\\2").
+          gsub(/::/, "_").
+          downcase
+        return name.to_sym if name.match /^[a-z0-9_]+$/
       end
       
-      def included(klass)
-        klass.class_eval { @hooks = {} }
-        klass.extend(ClassMethods)
+      def detect_path(file)
+        filepath = nil
+        filepath = file if file =~ /^\// && File.exists?(file)
+        $LOAD_PATH.each do |dir|
+          x = File.join dir, file
+          if File.exists? x
+            filepath = File.expand_path x
+            break
+          end
+        end unless filepath
+        return unless filepath
         
-        name = klass.to_s.underscore.split("_")[0..-2].join("_")
-        @descendants[name.to_sym][:klass] = klass
+        segments = File.dirname(filepath).split("/").reverse
+        pos = segments.find_index("lib") || -1
+        
+        segments[(pos + 1)..-1].reverse.join "/"
       end
     end
     
-    def hook(name, *args)
-      hooks = self.class.class_eval { @hooks }
-      hooks[name].each {|h| instance_exec(*args, &h) } if hooks[name]
-    end
-    
-    def version
-      return self.class.version
+    def module_name
+      self.class.module_name
     end
     
     def path
-      return self.class.path
-    end
-    
-    module ClassMethods
-      def hook(name, &block)
-        @hooks[name] ||= []
-        @hooks[name] << block
-      end
-      
-      def name
-        return @name ||= Pakada::Module.descendants.find {|m| m[1][:klass] == self }[0]
-      end
-      
-      def version
-        return Pakada::Module.descendants[name][:gemspec].version.to_s
-      end
-      
-      def path
-        return Pakada::Module.descendants[name][:path]
-      end
+      self.class.path
     end
   end
 end

data/lib/pakada/version.rb

@@ -1,3 +1,3 @@
 class Pakada
-  VERSION = Gem.loaded_specs["pakada"].version.to_s
+  VERSION = "0.0.1"
 end

data/lib/pakada.rb

@@ -1,113 +1,97 @@
 require "rack"
-require "pakada/support"
+require "hooked"
 
-require "pakada/application"
 require "pakada/module"
 require "pakada/version"
 
 class Pakada
-  class << self
-    attr_reader :modules, :middleware
-    attr_writer :env
-    
-    def boot(env = nil)
-      @env = env.to_sym if env
-      
-      load_middleware 
-      load_modules if @modules.empty?
-      
-      hook(:boot) unless testing?
-    end
-    
-    def load_middleware
-      config = YAML.load_file("config/middleware.yml") rescue {}
-      @middleware = Rack::Builder.new
-      config[env].each do |klass|
-        args = []
-        klass, args = klass.to_a[0] if klass.is_a?(Hash)
-        if args.is_a?(Array)
-          @middleware.use(klass.constantize, *args)
-        else
-          @middleware.use(klass.constantize, args)
-        end
-      end if config[env]
-    end
-    
-    def load_modules
-      Module.load
-      @modules = Dictionary.new
-      @hooks = {}
-      Module.descendants.each do |name, mod|
-        @modules[name] = mod[:klass].new
-        @modules[name].hook(:activate) unless testing?
-      end
-    end
-    
-    def [](name)
-      return modules[name]
-    end
-    
-    def []=(name, mod)
-      modules[name] = mod
-    end
-    
-    def hook(name, *args)
-      catch(:halt) { @modules.each_value {|mod| mod.hook(name, *args) } }
-    end
-    
-    def hook_reverse(name, *args)
-      catch(:halt) { @modules.reverse.each_value {|mod| mod.hook(name, *args) } }
-    end
-    
-    def app
-      unless @app
-        @middleware.run(Application)
-        @app = @middleware.to_app
-      end
-      return @app
-    end
-    
-    def request
-      return Application.request
-    end
-    
-    def response
-      return Application.response
-    end
-    
-    def reset
-      @env = nil
-      @middleware = Rack::Builder.new
-      @modules = Dictionary.new
-      @app = nil
-    end
-    
-    def shutdown
-      hook_reverse(:shutdown) unless testing?
-      
-      reset
-    end
+  include Hooked::Container
+
+  DEFAULT_APP = proc do |req_env|
+    Rack::Response.new("Hi, I'm Pakada #{VERSION}").finish
+  end
+
+  attr_reader :env, :modules, :hooks, :middleware
+  attr_accessor :app
+  
+  def initialize
+    @middleware = []
+  end
+  
+  def development?
+    env == :development
+  end
+  
+  def testing?
+    env == :testing
+  end
+  
+  def production?
+    env == :production
+  end
+  
+  def boot
+    load_env
+    load_modules
+    load_hooks
     
-    def env
-      return @env ||= (ENV["RACK_ENV"] || :development).to_sym
+    hooks.invoke(:boot) unless testing?
+  end
+  
+  def load_env
+    @env = (ENV["RACK_ENV"] || :development).to_sym
+  end
+  
+  def load_modules
+    @modules = Pakada::Module.descendants.values.inject({}) do |h, m|
+      h[m.module_name] = m.new; h
     end
-    
-    def development?
-      return env == :development
+  end
+  
+  def load_hooks
+    raise "modules have not been loaded" unless modules.respond_to? :values
+    @hooks = Hooked::Controller.new self, *modules.values
+  end
+  
+  def call(req_env)
+    to_app.call(req_env)
+  end
+  
+  def to_app
+    builder = Rack::Builder.new
+    middleware.each {|mw| builder.use *(Array === mw ? mw : [mw]) }
+    builder.run proc {|req_env| handle_request(req_env) }
+    builder
+  end
+  
+  def handle_request(req_env)
+    req = Rack::Request.new req_env
+    hooks.invoke(:request, req).finish
+  end
+  
+  hookable :boot do |nothing|; end
+  
+  hookable :request do |ctx|
+    resp = (app || DEFAULT_APP).call ctx.args.env
+    ctx.result = Rack::Response.new resp[2], *resp[0..1]
+  end
+  
+  class << self
+    def instance
+      @instance ||= new
     end
     
-    def testing?
-      return env == :testing
+    def reset_instance
+      @instance = nil
     end
     
-    def staging?
-      return env == :staging
+    def method_missing(m, *args, &block)
+      super(m, *args, &block) unless instance.respond_to? m
+      instance.send m, *args, &block
     end
     
-    def production?
-      return env == :production
+    def respond_to?(m)
+      super(m) || instance.respond_to?(m)
     end
   end
-  
-  reset
 end

data/pakada.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "pakada/version"
+
+Gem::Specification.new do |s|
+  s.name        = "pakada"
+  s.version     = Pakada::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Lars Gierth"]
+  s.email       = ["lars.gierth@gmail.com"]
+  s.homepage    = "http://rubygems.org/gems/pakada"
+  s.summary     = %q{Very Extensible HTTP Container For Ruby}
+  #s.description = %q{TODO: Write a gem description}
+
+  s.add_dependency "rack", "~> 1.2.1"
+  s.add_dependency "hooked", "~> 0.1.0"
+
+  s.add_development_dependency "rspec", "~> 2.3"
+  s.add_development_dependency "mocha", "~> 0.9.10"
+  s.add_development_dependency "fakefs", "~> 0.3.1"
+  s.add_development_dependency "fakefs-require", "~> 0.2.1"
+
+  s.files         = `git ls-files`.split("\n") - [".gitignore", ".rvmrc", "config.ru"]
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/module_spec.rb

@@ -0,0 +1,180 @@
+# -*- encoding: utf-8 -*-
+
+require "spec_helper"
+
+describe Pakada::Module do
+  describe ".descendants" do
+    it "keeps a list containing its descendants" do
+      Pakada::Module.descendants.should == {}
+    end
+  end
+  
+  describe ".detect_path" do
+    before :each do
+      FakeFS.activate!
+      FakeFS::Require.activate! :fallback => true
+    end
+    
+    after :each do
+      FakeFS::Require.deactivate!
+      FakeFS.deactivate!
+      FakeFS::FileSystem.clear
+    end
+    
+    it "loops through the load path to find a matching path" do
+      m = Pakada::Module
+      
+      path = "/my/path"
+      FileUtils.mkdir_p path + "/lib"
+      FileUtils.touch path + "/lib/some_module.rb"
+      $LOAD_PATH << path + "/lib"
+      
+      m.detect_path("some_module.rb").should == path
+      m.detect_path(path + "/lib/some_module.rb").should == path
+      $LOAD_PATH.delete path + "/lib"
+      
+      m.detect_path("config.ru").should be_nil
+    end
+  end
+  
+  describe ".detect_name" do
+    it "strips off Pakada:: and normalizes the klass name" do
+      m = Pakada::Module
+      
+      m.detect_name("Pakada::SomeModule::FOO").should == :some_module_foo
+      m.detect_name("My_Module").should == :my_module
+      
+      m.detect_name("L337").should == :l337
+      m.detect_name("Läö7").should be_nil
+    end
+  end
+  
+  describe ".included hook" do
+    before :each do
+      FakeFS.activate!
+      FakeFS::Require.activate! :fallback => true
+    end
+    
+    after :each do
+      Pakada::Module.descendants.clear
+      
+      FakeFS::Require.deactivate!
+      FakeFS.deactivate!
+      FakeFS::FileSystem.clear
+    end
+    
+    it "tries to determine the module's name" do
+      klass = Class.new
+      Pakada::Module.should_receive(:detect_name).with(klass.to_s).once { :some_module }
+      klass.send(:include, Pakada::Module)
+      klass.module_name.should == :some_module
+    end
+    
+    it "crashes if it can't detect a name" do
+      klass = Class.new
+      Pakada::Module.should_receive(:detect_name).with(klass.to_s).once { nil }
+      proc { klass.send(:include, Pakada::Module) }.should raise_error(RuntimeError)
+    end
+    
+    it "respects an already set name" do
+      Pakada::Module.should_not_receive(:detect_name)
+      klass = Class.new do
+        @module_name = :some_module
+        include Pakada::Module
+      end
+      klass.module_name.should == :some_module
+    end
+    
+    it "tries to determine the module's path" do
+      path = "/my/path"
+      file = path + "/lib/some_module.rb"
+      
+      Kernel.should_receive(:mock_caller).once { [file + ":1: in `something'"] }
+      Kernel.instance_eval do
+        alias orig_caller caller
+        alias caller mock_caller
+      end
+      
+      Pakada::Module.should_receive(:detect_path).with(file).once { path }
+      klass = Class.new do
+        @module_name = :some_module
+        include Pakada::Module
+      end
+      klass.path.should == path
+      
+      Kernel.instance_eval { alias caller orig_caller }
+    end
+    
+    it "respects an already set path" do
+      Pakada::Module.should_not_receive(:detect_path)
+      klass = Class.new do
+        @module_name = :some_module
+        @path = "/my/path"
+        include Pakada::Module
+      end
+      klass.path.should == "/my/path"
+    end
+    
+    it "adds the module to the list of descendants" do
+      klass = Class.new do
+        @module_name = :some_module
+        include Pakada::Module
+      end
+      Pakada::Module.descendants[:some_module].should == klass
+    end
+  end
+end
+
+describe "SomeModule" do
+  before :each do
+    @klass = Class.new do
+      @module_name = :foo
+      @path = "/opt/pakada"
+      include Pakada::Module
+    end
+    @obj = @klass.new
+  end
+  
+  after :each do
+    @klass, @obj = nil
+    Pakada::Module.descendants.clear
+  end
+  
+  it "is a hooking container" do
+    @obj.should respond_to(:hooked)
+    @obj.should respond_to(:hooked=)
+    @obj.should respond_to(:hookable)
+  end
+  
+  describe ".module_name" do
+    it "contains the module's name" do
+      @klass.module_name.should == :foo
+    end
+    
+    it "is read-only" do
+      proc { @klass.module_name = :bar }.should raise_error(NoMethodError)
+    end
+  end
+  
+  describe ".path" do
+    it "contains the module's base path" do
+      @klass.path.should == "/opt/pakada"
+    end
+    
+    it "is read-only" do
+      proc { @klass.path = "/tmp/pkd" }.should raise_error(NoMethodError)
+    end
+  end
+  
+  describe "#module_name" do
+    it "is a shortcut for ::module_name" do
+      @obj.module_name.should == @klass.module_name
+    end
+  end
+  
+  describe "#path" do
+    it "is a shortcut for ::path" do
+      @obj.path.should == @klass.path
+    end
+  end
+end