lego-core 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+coverage
+doc
+tmp/**/*

data/README.rdoc

@@ -0,0 +1,95 @@
+= Lego-core
+
+It's all about the bits an pieces!
+
+== Installation
+
+  sudo gem install lego-core
+
+== TODO
+
+- Write a text that describe what we are trying to do, and why :)
+- Write a roadmap for lego-core
+- Add before and after filter handling.
+
+== Example plugin (plugin.rb)
+
+  # This is a sample plugin that extends a few different Lego contexts.
+  #
+  # - View plugin
+  # - Controller plugin
+  # - Route matcher plugin
+  #
+  # This code will prob. be held in a different gem
+  
+  module SamplePlugin
+
+    # Register is called by lego when plugin is loaded
+
+    def self.register(lego)
+      lego.add_plugin :view, View
+      lego.add_plugin :router, Matcher
+      lego.add_plugin :controller, Routes
+    end
+
+    # A plugin module we load as a view helper
+
+    module View
+      def h1(content)
+        "<h1>#{content}</h1>"
+      end
+    end
+
+    # A very simply route helper
+
+    module Routes
+      def get(path, &block)
+        add_route(:get, {:path => path, :action_block => block})
+      end
+    end
+    
+    # A very simple route matcher
+
+    module Matcher
+      def self.match_route(route, env)
+        (route[:path] == env['PATH_INFO']) ? true : false
+      end
+    end
+  end
+  
+== Example Lego Application (my_app.rb)
+  
+  # This is how our Lego app would look with this plugin.
+
+  Lego.plugin SamplePlugin
+
+  class MyApp < Lego::Controller
+    get '/hello' do
+      h1 'Hello world'
+    end
+  end
+
+== Example Rackup/Shotgun file (config.ru)
+
+  # This is how you would use it with rack.
+
+  require 'rubygems'
+  require 'lego-core'
+  require 'plugin'
+  require 'my_app'
+
+  run MyApp 
+
+== Example run
+
+  # Start this app by running shotgun or rackup (these gems nees to be installed)
+  
+  shotgun config.ru
+
+== Thoughts
+
+- Move ActionContext and RouteHandler into different module that controller?
+- Add a plugin Context for before and after filters to make them pluggable?
+- Make the whole framework run inside an instance instead of as class methods?
+- When route is matchen with a different method than the one requested you should not respond 404, support for this?
+

data/Rakefile

@@ -0,0 +1,63 @@
+require 'rake'
+require 'rake/rdoctask'
+require 'rcov/rcovtask'
+
+
+begin
+  require 'spec/rake/spectask'
+rescue LoadError
+  puts 'To use rspec for testing you must install rspec gem:'
+  puts '$ sudo gem install rspec'
+  exit
+end
+
+desc "Default task is to run specs"
+task :default => :show_all_tasks
+
+desc "Run all examples with RCov"
+Spec::Rake::SpecTask.new('rcov') do |t|
+  t.spec_files = FileList['spec/**/*.rb']
+  t.spec_opts = ['--options', '"spec/spec.opts"']
+  # rcov
+  t.rcov = true
+  t.rcov_dir = 'doc/coverage'
+  t.rcov_opts = ['-p', '-T', '--exclude', 'spec']
+end
+
+desc "Run the specs under spec"
+Spec::Rake::SpecTask.new do |t|
+  t.spec_opts = ['--diff', '--options', "spec/spec.opts"]
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+desc "Print Specdoc for all specs"
+Spec::Rake::SpecTask.new('specdoc') do |t|
+  t.spec_opts = ["--format", "specdoc", "--dry-run", "--options", 'spec/spec.opts']
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+desc "Generate RDoc documentation"
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.options << '--line-numbers' << '--inline-source' << '--main' << 'README.rdoc' << '--charset' << 'utf-8'
+  rdoc.rdoc_dir = "doc"
+  rdoc.rdoc_files.include 'README.rdoc'
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "lego-core"
+    gemspec.summary = "It's all about the bits and peices"
+    gemspec.description = "It's all about the bits and peices"
+    gemspec.email = "mathias@globalinn.com"
+    gemspec.homepage = "http://github.com/stjernstrom/lego-core"
+    gemspec.authors = ["Mathias Stjernström", "Patrik Hedman"]
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+
+task :show_all_tasks do
+  system "rake -T"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/examples/config.ru

@@ -0,0 +1,137 @@
+require File.join(File.expand_path(File.dirname(__FILE__)), '..',  'lib', 'lego')
+
+module BasicRoutes
+  def self.register(lego)
+    lego.add_plugin :controller, ControllerPlugin 
+    lego.add_plugin :router, RouteMatcher 
+  end
+
+  module ControllerPlugin
+    def get(path, &block)
+      add_route(:get, { :path => path, :action_block => block })
+    end
+  end
+
+  module RouteMatcher
+    def self.match_route(route, env)
+      (route[:path] == env['PATH_INFO']) ? true : false
+    end
+  end
+end
+
+module RegexpMatcher  
+  def self.register(lego)
+    lego.add_plugin :router, self 
+  end
+
+  def self.match_route(route, env)
+    if route[:path].is_a?(Regexp) && match = route[:path].match(env['PATH_INFO'])
+      route[:instance_vars] = { :caps => match.captures }
+      true
+    else
+      false
+    end
+  end
+end
+
+module SymbolExtractor
+  def self.register(lego)
+    lego.add_plugin :router, self 
+  end
+
+  def self.match_route(route, env) 
+    return false if not route[:path].kind_of?(String)
+    matches = route[:path].scan(/:([\w]+)/) 
+    if matches.size > 0 
+      exp = Regexp.escape( route[:path] ).gsub(/:([\w]+)/, "([\\w]+)") 
+      if match = Regexp.new("^#{exp}$").match(env["PATH_INFO"]) 
+        route[:instance_vars] = {} if route[:instance_vars].nil?  
+        1.upto(matches.size) do |i| 
+           route[:instance_vars][matches[i-1]] = match.captures[i-1] 
+         end 
+        return true   
+      end 
+    end 
+    false 
+  end 
+end
+
+module HtmlPlug
+  def self.register(lego)
+    lego.add_plugin :view, Mod
+  end
+  module Mod
+    def h1(content)
+      "<h1>#{content}</h1>"
+    end
+    def b(content)
+      "<b>#{content}</b>"
+    end
+  end
+end
+
+class MyBlog < Lego::Controller
+  set :foo => "bar"
+
+  plugin BasicRoutes
+  plugin RegexpMatcher
+  plugin SymbolExtractor
+
+  # Sample ActionContext plugin giving h1() and b() methods to views.
+  plugin HtmlPlug
+
+  #
+  # Ex: http://localhost:9393/extract/something.jpg
+  # Sets up an instance variable with the matches
+  #     @caps[0] => 'something'
+  #     @caps[1] => 'jpg'
+  #
+  get /extract\/(\w+)\.(\w+)/ do
+    "We are extracting....#{@caps.inspect}" 
+  end
+
+  #
+  # Ex: http://localhost:9393/
+  #
+  get '/' do
+    "This is /"
+  end
+
+  #
+  # ex: http://localhost:9393/show/10
+  # Sets up an instance variable with the id
+  #   @id => 10
+  #
+  get '/show/:id' do
+    "This is show with id = #{@id}"
+  end
+
+  get '/options' do
+    options :foo # renders bar to the browser
+  end
+
+  #
+  # Demonstrating a simple ActionContext plugin (HtmlPlug)
+  # 
+  # Ex: http://localhost:9393/viewplugins
+  #
+  get '/viewplugins' do
+    h1("Hello, i'm a header.") + b("And im some stupid bold text.....")
+  end
+
+  #
+  # This action will be called if no other route matches. 
+  #
+  # Ex: http://localhost:9393/you_will_not_find_me/
+  #
+  not_found do
+    h1("404 - File not found") + "Lego could not find what you are looking for, sorry."
+  end
+
+
+end
+
+run MyBlog
+
+# Save this stuff to config.ru and fire it up with 'rackup'
+

data/lego-core.gemspec

@@ -0,0 +1,70 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{lego-core}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Mathias Stjernstr\303\266m", "Patrik Hedman"]
+  s.date = %q{2010-01-12}
+  s.description = %q{It's all about the bits and peices}
+  s.email = %q{mathias@globalinn.com}
+  s.extra_rdoc_files = [
+    "README.rdoc"
+  ]
+  s.files = [
+    ".gitignore",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION",
+     "examples/config.ru",
+     "lego-core.gemspec",
+     "lib/lego.rb",
+     "lib/lego/controller.rb",
+     "lib/lego/controller/action_context.rb",
+     "lib/lego/controller/config.rb",
+     "lib/lego/controller/route_handler.rb",
+     "lib/lego/plugin.rb",
+     "lib/lego/plugin/controller/not_found.rb",
+     "spec/integration/test_full_stack_spec.rb",
+     "spec/lego/controller/action_context_spec.rb",
+     "spec/lego/controller/config_spec.rb",
+     "spec/lego/controller/route_handler_spec.rb",
+     "spec/lego/controller_spec.rb",
+     "spec/lego/plugin/controller/not_found_spec.rb",
+     "spec/lego/plugin_spec.rb",
+     "spec/lego_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/stjernstrom/lego-core}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{It's all about the bits and peices}
+  s.test_files = [
+    "spec/integration/test_full_stack_spec.rb",
+     "spec/lego/controller/action_context_spec.rb",
+     "spec/lego/controller/config_spec.rb",
+     "spec/lego/controller/route_handler_spec.rb",
+     "spec/lego/controller_spec.rb",
+     "spec/lego/plugin/controller/not_found_spec.rb",
+     "spec/lego/plugin_spec.rb",
+     "spec/lego_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/lego.rb

@@ -0,0 +1,38 @@
+#
+#:title:Lego-Core
+#
+
+module Lego
+
+  file_path = File.expand_path( File.dirname(__FILE__) )
+  $LOAD_PATH.unshift( file_path ) unless $LOAD_PATH.include?( file_path )
+
+  VERSION = [0,0,1]
+
+  #
+  # Return the current Lego version.
+  #
+
+  def self.version
+    VERSION.join(".")
+  end
+
+  autoload :Controller,    'lego/controller'
+  autoload :Plugin,        'lego/plugin'
+
+  def self.config(&block)
+    class_eval &block
+  end
+
+  #
+  # plugin lets a plugin register itself globally
+  #
+
+  def self.plugin(plugin_module)
+    plugin_module.register(Lego::Controller)
+  end
+
+  def self.set(options={})
+    Lego::Controller.set options
+  end
+end

data/lib/lego/controller.rb

@@ -0,0 +1,162 @@
+#
+# = Lego::Controller
+# Lego::Controller is the context where you setup routes and stuff.
+#
+
+class Lego::Controller
+
+  autoload :ActionContext, 'lego/controller/action_context'
+  autoload :RouteHandler,  'lego/controller/route_handler'
+  autoload :Config,        'lego/controller/config'
+
+  class << self
+
+    #
+    # When Lego::Controller is inherited it will create a new Lego::Controller::ActionContext for the class thats inheriting
+    # and it will also create a new Lego::Controller::RouteHandler module for the class thats inheriting. 
+    #
+
+    def inherited(class_inheriting)
+      class_inheriting.const_set(:ActionContext, Class.new(Lego::Controller::ActionContext) do
+        const_set :ApplicationClass, class_inheriting
+      end)
+
+      class_inheriting.const_set(:RouteHandler,  Module.new { extend Lego::Controller::RouteHandler })
+      class_inheriting.const_set(:Config,        Module.new { extend Lego::Controller::Config })
+    end
+
+    # 
+    # Use register inside your plugin to inject your code into the right place.
+    #
+    # Context available are:
+    #
+    # - :controller
+    # - :router
+    # - :view
+    #
+    # and on the way
+    #
+    # - :helper ?
+    #
+
+    def add_plugin(context, plugin_module)
+
+      base = (self == Lego::Controller) ? Lego::Controller : self 
+
+      case context
+      when :controller
+        base.extend plugin_module
+      when :router
+        base::RouteHandler.add_matcher plugin_module 
+      when :view
+        base::ActionContext.instance_eval do
+          include plugin_module
+        end
+      end
+    end
+
+    # 
+    # add_route <method> <route> is exposed to your plugin as a shortcut for adding routes to the application they are plugged in to.
+    # 
+    # <method> is a symbol for the request method it should match
+    # 
+    # Valid options are:
+    #
+    # - :get
+    # - :post
+    # - :put
+    # - :head
+    # - :options
+    # - :not_found
+    #
+    # <route> is a hash with keys to be handled by the route matchers and also the ActionContext
+    #
+    # Valid options are anything your route matcher can handle. But there's some keys that's special for Lego and they are.
+    #
+    # - :action_block      => A block thats going to be executed inside ActionContext.
+    # - :instance_vars     => A hash where the keys beeing converted to ActionContext vars ex: { :var1 => "value1", :var2 => "value2" } 
+    # - :set_response_code => An integer representing the response code.
+    #
+
+    def add_route(method, route)
+      self::RouteHandler.add_route(method, route)
+    end
+
+    #
+    # Use plugin in your controllers to choose which extensions you want to use in this controller. 
+    #
+    # Extensions then inject themself into the right context.
+    #
+
+    def plugin(plugin_module)
+      plugin_module.register(self)
+    end
+
+    #
+    # Provides acces to the current Config class
+    #
+
+    def current_config
+      self::Config
+    end
+
+    #
+    # Use set to define environment agnostic configuration options
+    #
+    # Usage:
+    #   Lego::Controller.set :foo => "bar"
+    #
+
+    def set(options={})
+      current_config.set(options)
+    end
+
+    #
+    # Use environment to define environment specific configuration options 
+    #
+    # Usage:
+    #   Lego::Controller.environment :development do
+    #     set :foo => "bar"
+    #   end
+    #
+    # or set environment agnostic configuration options by leaving out the environment parameter
+    #
+    # Usage:
+    #   Lego::Controller.environment do
+    #     set :foo => "bar"
+    #   end
+    #
+
+    def environment(env=nil, &block)
+      raise ArgumentError, "No block provided" unless block_given?
+      current_config.environment(env, &block)
+    end
+
+    #
+    # call is used to handle an incomming Rack request. 
+    #
+    # If no matching route is found we check for a defined :not_found route
+    # and if no :not_found defined we send a simple 404 - not found.
+    #
+
+    def call(env)
+      if route = self::RouteHandler.match_all_routes(env)
+        self::ActionContext.new.run(route, env)
+      else
+        if route = self::RouteHandler.routes[:not_found]
+          self::ActionContext.new.run(route, env)
+        else
+          [404, {'Content-Type' => 'text/html'}, '404 - Not found'] 
+        end
+      end
+    end
+
+  end
+
+  #
+  # Core plugins
+  #
+
+  plugin Lego::Plugin::Controller::NotFound
+
+end