lego-core 0.0.1

data/lib/lego/controller/action_context.rb

@@ -0,0 +1,56 @@
+#
+#
+
+class Lego::Controller::ActionContext
+
+  attr_accessor :response, :env, :route
+  
+  def initialize
+    setup_defaults
+  end
+
+  def options(key)
+    "#{self.class::ApplicationClass.current_config.options(key)}"
+  end
+
+  def run(route, env)
+    @route = route
+    @env = env 
+    setup_instance_vars_from_route
+    evaluate_action
+    [@response[:code], @response[:headers], @response[:body]]
+  end
+
+private
+
+  #
+  # setup_instance_vars_from_route extracts variables found in route[:instance_vars] thats setup by the route matchers
+  # and converts them to instance variables which makes them availible to the ActionContext.
+  #
+
+  def setup_instance_vars_from_route
+    @route[:instance_vars].each_key do |var|
+      instance_variable_set("@#{var}", @route[:instance_vars][var])
+    end if @route[:instance_vars]
+    @response[:code] = @route[:set_response_code] if @route[:set_response_code]
+  end
+
+  #
+  # evaluate_action executes route[:action_block] and appends the output to @response[:body]
+  #
+
+  def evaluate_action
+    @response[:body] << instance_eval(&@route[:action_block]) if @route[:action_block]
+  end
+
+  #
+  # setup_defaults creates a default @response object with enough data to satisfies Rack.
+  #
+
+  def setup_defaults
+    @response = {}
+    @response[:headers] = {'Content-Type' => 'text/html'}
+    @response[:code]    = 200
+    @response[:body]    = ''
+  end
+end

data/lib/lego/controller/config.rb

@@ -0,0 +1,25 @@
+module Lego::Controller::Config
+  extend self
+  
+  def extended(mod)
+    mod.instance_eval do
+      def config
+        @config ||= {}.merge(Lego::Controller::Config.config)
+      end
+    end
+  end
+  
+  def options(key)
+    config[key.to_s]
+  end
+  
+  def config
+    @config ||= {}
+  end
+  
+  def set(options={})
+    options.keys.each do |key|
+      config[key.to_s] = options[key]
+    end
+  end
+end

data/lib/lego/controller/route_handler.rb

@@ -0,0 +1,86 @@
+#
+# RouteHandler is the module that holds and handles routes for every controller class.
+#
+
+module Lego::Controller::RouteHandler
+
+  # InvalidMatcher Exception
+
+  class InvalidMatcher < Exception; end
+
+  extend self
+
+  #
+  # When extended we need to copy out matchers and routes to the class extending.
+  #
+
+  def extended(base)
+    base.matchers.concat(matchers)
+    base.routes.merge!(routes)
+  end
+
+  def add_route(method, options)
+    if method == :not_found
+      routes[:not_found] = options
+    else
+      routes[method] << options 
+    end
+  end
+
+  def add_matcher(module_name)
+    raise InvalidMatcher if not validate_matcher(module_name)
+    matchers << module_name
+  end
+
+  # Getter for cached instance variable holding routes.
+
+  def routes
+    cached_routes
+  end
+
+  # Getter for instance variable holding matchers.
+
+  def matchers
+    cached_matchers
+  end
+
+  def validate_matcher(module_name)
+    eval(module_name.to_s).respond_to?(:match_route)
+  end
+
+  def run_matchers(route, env)
+    matchers.each do |matcher|
+      return true if matcher.match_route(route, env) == true
+    end
+    false
+  end
+
+  def match_all_routes(env)
+    method = extract_method_from_env(env)
+    routes[method].each do |route|
+      return route if run_matchers(route, env)
+    end
+    nil 
+  end
+
+  private
+
+  def extract_method_from_env(env)
+    env["REQUEST_METHOD"].downcase.to_sym if env["REQUEST_METHOD"]
+  end
+
+  def cached_routes
+    @route_cache ||= {
+      :get       => [],
+      :post      => [],
+      :put       => [],
+      :head      => [],
+      :delete    => [],
+      :not_found => nil
+    }
+  end
+
+  def cached_matchers
+    @matcher_cache ||= []
+  end
+end

data/lib/lego/plugin.rb

@@ -0,0 +1,5 @@
+module Lego::Plugin
+  module Controller
+    autoload :NotFound, 'lego/plugin/controller/not_found'
+  end
+end

data/lib/lego/plugin/controller/not_found.rb

@@ -0,0 +1,11 @@
+module Lego::Plugin::Controller
+  module NotFound
+    def self.register(lego)
+      lego.add_plugin :controller, self
+    end
+
+    def not_found(&block)
+      add_route(:not_found, { :set_response_code => 404, :action_block => block })
+    end
+  end
+end

data/spec/integration/test_full_stack_spec.rb

@@ -0,0 +1,82 @@
+require File.join('spec', '/spec_helper')
+
+describe 'Full stack request' do
+
+  context 'with no routes specified' do
+    before do
+      reset_lego_base
+      class MyApp < Lego::Controller; end
+      rack_env = {
+      'PATH_INFO' => '/' ,
+      'REQUEST_METHOD' => 'GET'
+      }
+      @result = MyApp.call(rack_env)
+    end
+
+    it 'should respond with a valid 404 response' do
+      @result[0].should eql(404)
+      @result[1].should eql({"Content-Type"=>"text/html"})
+      @result[2].should eql('404 - Not found')
+    end
+
+    after do
+      rm_const 'MyApp'
+    end
+  end
+
+  context 'with global plugins' do
+    before do
+
+      reset_lego_base
+
+      module GlobalPlugin
+        def self.register(lego)
+          lego.add_plugin :view, View
+          lego.add_plugin :router, Matcher
+          lego.add_plugin :controller, Routes
+        end
+        module View
+          def h1(content)
+            "<h1>#{content}</h1>"
+          end
+        end
+        module Routes
+          def get(path, &block)
+            add_route(:get, {:path => path, :action_block => block})
+
+          end
+        end
+        module Matcher
+          def self.match_route(route, env)
+            (route[:path] == env['PATH_INFO']) ? true : false
+          end
+        end
+      end
+
+      Lego.plugin GlobalPlugin
+
+      class App1 < Lego::Controller
+        get '/hello' do
+          h1 'Hello world'
+        end
+      end
+
+      rack_env = {
+      'PATH_INFO' => '/hello' ,
+      'REQUEST_METHOD' => 'GET'
+      }
+      @result = App1.call(rack_env)
+    end
+
+    it 'should respond with with valid data' do
+      @result[0].should eql(200)
+      @result[1].should eql({"Content-Type"=>"text/html"})
+      @result[2].should eql('<h1>Hello world</h1>')
+    end
+
+    after do
+      rm_const 'App1', 'App2'
+    end
+  end
+
+end

data/spec/lego/controller/action_context_spec.rb

@@ -0,0 +1,73 @@
+require File.join('spec', '/spec_helper')
+
+describe Lego::Controller::ActionContext do
+
+  context 'generates rack response from @response hash' do
+    before do
+      @instance = Lego::Controller::ActionContext.new
+    end
+
+    it 'should set the current message body' do
+      @instance.response[:body] = "Hello again"
+      @instance.run({},nil).should eql([ 200, {"Content-Type"=>"text/html"}, 'Hello again' ])
+    end
+
+    it 'should set response headers' do
+      @instance.response[:headers] = {'Content-Type' => 'cust/head'}
+      @instance.run({},nil).should eql([ 200, {"Content-Type"=>"cust/head"}, '' ])
+    end
+
+    it 'should set response code' do
+      @instance.response[:code] = 666 
+      @instance.run({},nil).should eql([ 666, {"Content-Type"=>"text/html"}, '' ])
+    end
+  end
+
+  context '.run instance method' do
+    before do
+      @instance = Lego::Controller::ActionContext.new
+      @env = []
+    end
+
+    it 'should have a default Rack response' do
+      @instance.run("", @env).should eql([200, {'Content-Type' => 'text/html'} , ''])
+    end
+
+    it 'should evaluate :action_block in instance if exists in route' do
+      route = { :action_block => Proc.new{ "Hello my world!" }}
+      @instance.run(route, @env).should eql([200, {'Content-Type' => 'text/html'} , "Hello my world!" ])
+    end
+
+    it 'should convert route[:instance_vars] to instance variables' do
+      route = { :instance_vars => { :myvar => "This is my var" } }
+      @instance.run(route, @env).should eql([200, {'Content-Type' => 'text/html'} , '' ])
+      @instance.instance_variable_get(:@myvar).should eql("This is my var")
+    end
+
+    it 'should set response[:code] if set_response_route is set in route' do
+      route = { :set_response_code => 666 }
+      @instance.run(route, @env).should eql([666, {'Content-Type' => 'text/html'} , '' ])
+    end
+  end
+
+  context ".options helper method" do
+    before do
+      create_new_app "App", Lego::Controller
+      Lego::Controller::ActionContext::ApplicationClass = App
+      @instance = Lego::Controller::ActionContext.new
+      @env = []
+    end
+
+    it 'should evaluate :action_block in instance if exists in route' do
+      Lego::Controller.set :foo => "bar"
+      route = { :action_block => Proc.new{ options(:foo) }}
+      @instance.run(route, @env).should eql([200, {'Content-Type' => 'text/html'} , "bar" ])
+    end
+
+    after do
+      rm_const "App"
+    end
+  end
+
+end
+

data/spec/lego/controller/config_spec.rb

@@ -0,0 +1,102 @@
+require File.join('spec', '/spec_helper')
+
+describe Lego::Controller::Config do
+
+  context ".set options" do
+
+    context "on Lego::Controller" do
+
+      before do
+        create_new_app "App1", Lego::Controller
+        create_new_app "App2", Lego::Controller
+        Lego::Controller.set :foo => "bar"
+      end
+
+      it "should be accessible to Lego::Controller" do
+         Lego::Controller.current_config.options(:foo).should eql("bar")
+      end
+
+      it "should be accessible to App1" do
+         App1.current_config.options(:foo).should eql("bar")
+      end
+
+      it "should be accessible to App2" do
+         App2.current_config.options(:foo).should eql("bar")
+      end
+
+      after do
+        clean_config! Lego::Controller
+        rm_const "App1", "App2"
+      end
+    end
+
+    context "on Lego::Controller subclasses" do
+
+      before do
+        create_new_app "App1", Lego::Controller
+        create_new_app "App2", Lego::Controller
+        App1.set :app1 => "App1"
+      end
+
+      it "should be available to App1" do
+        App1.current_config.options(:app1).should eql("App1")
+      end
+
+      it "should NOT be available to App2" do
+        App2.current_config.options(:app1).should eql(nil)
+      end
+
+      it "should NOT be available to Lego::Controller" do
+        App2.current_config.options(:app1).should eql(nil)
+      end
+
+      after do
+        clean_config! Lego::Controller, App1, App2
+        rm_const "App1", "App2"
+      end
+    end
+  end 
+
+  context ".config" do
+    
+    before do
+      Lego::Controller.set :foo => "bar",
+                           :baz => "quux"
+    end
+
+    it "should contain the newly set options" do
+      Lego::Controller.current_config.config.should eql({"foo"=>"bar","baz"=>"quux"})
+    end
+
+    after do
+      clean_config! Lego::Controller
+    end
+  end
+
+  context ".options key" do
+
+    before do
+      Lego::Controller.set :my_symbol  => "my_symbol",
+                           "my_string" => "my_string"
+    end
+
+    it "should allow string acces to symbol keys" do
+      Lego::Controller.current_config.options("my_symbol").should eql("my_symbol")
+    end
+
+    it "should allow symbol acces to string keys" do
+      Lego::Controller.current_config.options(:my_string).should eql("my_string")
+    end
+
+    after do
+      clean_config! Lego::Controller
+    end
+  end
+end
+
+def clean_config!(*consts)
+  consts.each do |const|
+    const::Config.class_eval "remove_instance_variable :@config if @config"
+    const::Config.class_eval "remove_instance_variable :@env    if @env   "
+  end
+end