trellis 0.0.1 → 0.0.2

data/lib/trellis/trellis.rb

@@ -46,12 +46,12 @@ module Trellis
   # pages and it must define a home page or entry point into the application  
   class Application
     include Logging
+    include Rack::Utils
     
     # descendant application classes get a singleton class level instances for 
     # holding homepage, dependent pages, static resource routing paths
     def self.inherited(child) #:nodoc:
-      child.meta_attr_reader(:homepage)
-      child.attr_array(:pages, :create_accessor => false)
+      child.class_attr_reader(:homepage)
       child.attr_array(:static_routes)
       child.meta_def(:logger) { Application.logger }
       super
@@ -61,13 +61,7 @@ module Trellis
     # the entry point is the URL pattern / where the application is mounted
     def self.home(sym)
       @homepage = sym   
-      @pages << sym
     end 
-
-    # class method that takes a list of page symbols
-    def self.pages(*syms)
-      @pages = @pages | syms
-    end
     
     # define url paths for static resources
     def self.map_static(urls = [], root = File.expand_path("#{File.dirname($0)}/../html/"))
@@ -86,6 +80,7 @@ module Trellis
     end
     
     def configured_instance
+      # configure rack middleware
       application = Rack::ShowStatus.new(self)
       application = Rack::ShowExceptions.new(application)
       application = Rack::CommonLogger.new(application, Application.logger)
@@ -97,38 +92,51 @@ module Trellis
       end
       application
     end
+
+    # find the first page with a suitable router, if none is found use the default router
+    def find_router_for(request)
+      match = Page.subclasses.values.find { |page| page.router && page.router.matches?(request) }
+      match ? match.router : DefaultRouter.new(:application => self)
+    end
     
     # implements the rack specification
     def call(env)
       response = Rack::Response.new
       request = Rack::Request.new(env)
-      session = env["rack.session"]  
-      
-      route = DefaultRouter.new(self).route(request)
-      
+
       Application.logger.debug "request received with url_root of #{request.script_name}"
+
+      session = env["rack.session"]
+
+      router = find_router_for(request)
+      route = router.route(request)
       
       page = route.destination.new if route.destination
       if page
         page.class.url_root = request.script_name
+        page.path = request.path_info.sub(/^\//, '')
         page.inject_dependent_pages
         page.call_if_provided(:before_load)
         page.load_page_session_information(session)
         page.call_if_provided(:after_load)
         page.params = request.params.keys_to_symbols
-        page = page.process_event(route.event, route.value, route.source, session) if route.event
+        router.inject_parameters_into_page_instance(page, request)
+        result = route.event ? page.process_event(route.event, route.value, route.source, session) : page
 
         # prepare the http response
-        if request.post? && page.kind_of?(Trellis::Page)
-          # redirect after post
+        if (request.post? || route.event) && result.kind_of?(Trellis::Page)
+          # for action events of posts then use redirect after post pattern
+          # remove the events path and just return to the page
+          path = result.path ? result.path.gsub(/\/events\/.*/, '') : result.class.class_to_sym
           response.status = 302
-          response.headers["Location"] = "#{request.script_name}/#{page.class.class_to_sym}"
+          response.headers["Location"] = "#{request.script_name}/#{path}"
         else
-          response.body = page.kind_of?(Trellis::Page) ? page.render : page
+          # for render requests simply render the page
+          response.body = result.kind_of?(Trellis::Page) ? result.render : result
           response.status = 200
         end
       else
-        # could find a page with default router, now what?
+        response.status = 404
       end
       response.finish
     end
@@ -140,7 +148,7 @@ module Trellis
   class Route
     attr_reader :destination, :event, :source, :value
 
-    def initialize(destination, event, source, value)    
+    def initialize(destination, event = nil, source = nil, value = nil)
       @destination, @event, @source, @value = destination, event, source, value
     end
   end
@@ -148,24 +156,111 @@ module Trellis
   # -- Router --
   # A Router returns a Route in response to an HTTP request
   class Router
-    attr_reader :application
+    EVENT_REGEX = %r{^(?:.+)/events/(?:([^/\.]+)(?:\.([^/\.]+)?)?)(?:/(?:([^\.]+)?))?}
+
+    attr_reader :application, :pattern, :keys, :path, :page
     
-    def initialize(application)
-      @application = application
+    def initialize(options={})
+      @application = options[:application]
+      @path = options[:path]
+      @page = options[:page]
+      compile_path if @path
+    end
+
+    def route(request = nil)
+      # get the event information if any
+      value, source, event = request.path_info.match(EVENT_REGEX).to_a.reverse if request
+      Route.new(@page, event, source, value)
+    end
+
+    def matches?(request)
+      request.path_info.gsub(/\/events\/.*/, '').match(@pattern) != nil
+    end
+
+    def inject_parameters_into_page_instance(page, request)
+      # extract parameters and named parameters from request
+      if @pattern && @page && match = @pattern.match(request.path_info.gsub(/\/events\/.*/, ''))
+        values = match.captures.to_a
+        params =
+          if @keys.any?
+            @keys.zip(values).inject({}) do |hash,(k,v)|
+              if k == 'splat'
+                (hash[k] ||= []) << v
+              else
+                hash[k] = v
+              end
+              hash
+            end
+          elsif values.any?
+            {'captures' => values}
+          else
+            {}
+          end
+        params.each_pair { |name, value| page.instance_variable_set("@#{name}".to_sym, value) }
+      end
+    end
+
+    private
+
+    # borrowed (stolen) from Sinatra!
+    def compile_path
+      @keys = []
+      if @path.respond_to? :to_str
+        special_chars = %w{. + ( )}
+        pattern =
+          @path.to_str.gsub(/((:\w+)|[\*#{special_chars.join}])/) do |match|
+            case match
+            when "*"
+              @keys << 'splat'
+              "(.*?)"
+            when *special_chars
+              Regexp.escape(match)
+            else
+              @keys << $2[1..-1]
+              "([^/?&#]+)"
+            end
+          end
+        @pattern = /^#{pattern}$/
+      elsif @path.respond_to?(:keys) && @path.respond_to?(:match)
+        @pattern = @path
+        @keys = @path.keys
+      elsif @path.respond_to? :match
+        @pattern = path
+      else
+        raise TypeError, @path
+      end
     end
   end
   
   # -- DefaultRouter --
-  # The default routing scheme is in the form /page[.event_[source]][/value][?query_params]
+  # The default routing scheme is in the form /page[.event[_source]][/value][?query_params]
   class DefaultRouter < Router
-    ROUTE_REGEX = %r{^(?:/)([^.]+)(?:.([^_/]+)(?:_([^/]+))?)?(?:/([\w]+)$)?}
-    
-    def route(request)   
-      value, source, event, destination = request.path_info.match(ROUTE_REGEX).to_a.reverse 
+    ROUTE_REGEX = %r{^/([^/]+)(?:/(?:events/(?:([^/\.]+)(?:\.([^/\.]+)?)?)(?:/(?:([^\.]+)?))?)?)?}
+
+    def route(request)
+      value, source, event, destination = request.path_info.match(ROUTE_REGEX).to_a.reverse
       destination = @application.class.homepage unless destination
       page = Page.get_page(destination.to_sym)
-      
-      Route.new(page, event, source, value)      
+
+      Route.new(page, event, source, value)
+    end
+
+    def matches?(request)
+      request.path_info.match(ROUTE_REGEX) != nil
+    end
+
+    def self.to_uri(options={})
+      url_root = options[:url_root]
+      page = options[:page]
+      event = options[:event]
+      source = options[:source]
+      value = options[:value]
+      destination = page.kind_of?(Trellis::Page) ? (page.path || page.class.class_to_sym) : page
+      url_root = page.kind_of?(Trellis::Page) && page.class.url_root ? "/#{page.class.url_root}" : '/' unless url_root
+      source = source ? ".#{source}" : ''
+      value = value ? "/#{value}" : ''
+      event_info = event ? "/events/#{event}#{source}#{value}" : ''
+      "#{url_root}#{destination}#{event_info}"
     end
   end
   
@@ -179,7 +274,7 @@ module Trellis
     
     @@subclasses = Hash.new
     
-    attr_accessor :params, :logger
+    attr_accessor :params, :path, :logger
     
     def self.inherited(child) #:nodoc:
       @@subclasses[child.class_to_sym] = child
@@ -189,9 +284,10 @@ module Trellis
       child.attr_array(:components)
       child.attr_array(:stateful_components)
       child.attr_array(:persistents)
-      child.meta_attr_accessor :url_root
-      child.meta_attr_accessor :name
-      child.meta_attr_accessor :layout
+      child.class_attr_accessor :url_root
+      child.class_attr_accessor :name
+      child.class_attr_accessor :router
+      child.class_attr_accessor :layout
       child.meta_def(:add_stateful_component) { |tid,clazz| @stateful_components << [tid,clazz] }
  
       locate_template child        
@@ -232,15 +328,24 @@ module Trellis
     def self.pages(*syms)
       @pages = @pages | syms
     end
+
+    def self.route(path)
+      router = Router.new(:path => path, :page => self)
+      self.instance_variable_set(:@router, router)
+    end
     
     def self.persistent(*fields)
-      meta_attr_reader fields
+      instance_attr_accessor fields
       @persistents = @persistents | fields    
     end
     
     def self.get_page(sym)
       @@subclasses[sym]
     end
+
+    def self.subclasses
+      @@subclasses
+    end
     
     def initialize # TODO this is Ugly.... should no do it in initialize since it'll require super in child classes
       self.class.stateful_components.each do |id_component|
@@ -313,7 +418,7 @@ module Trellis
     
     def self.locate_template(clazz)   
       begin 
-        if clazz.url_root.nil? || clazz.url_root.blank?
+        if clazz.url_root.nil? || clazz.url_root.empty?
           dir = "#{File.dirname($0)}/../html/"
         else
           dir = "#{File.dirname($0)}#{clazz.url_root}/html/".gsub("Rack: ", '')
@@ -439,6 +544,9 @@ module Trellis
           @context.globals.send(sym, value)
         end
       end
+
+      #TODO add public page methods to the context
+
       
       # add the page to the context too
       @context.globals.page = page
@@ -477,8 +585,8 @@ module Trellis
       # component registration
       @@components[child.class_to_sym] = child
 
-      child.meta_attr_accessor(:body)
-      child.meta_attr_accessor(:cname)
+      child.class_attr_accessor(:body)
+      child.class_attr_accessor(:cname)
       child.cname = child.underscore_class_name
       child.meta_def(:stateful?) { @stateful }
       
@@ -531,10 +639,6 @@ module Trellis
       send("#{sym}=", default_value) if default_value
     end 
     
-    def self.dom_contribution(&block) #TODO names don't match!
-      @document_modifications << block
-    end
-    
     def self.add_style_links_to_page(page, attributes)
       style_links.each do |href|  
         href = href.replace_ant_style_properties(attributes) if attributes
@@ -603,13 +707,17 @@ module Trellis
       end
     end
 
-    def self.page_contribution(sym, contribution, options=nil)
-      # add the contribution to the appropriate array of contributions
-      # scripts, class_scripts, styles, class_styles, script_links, style_links
-      scope = options[:scope] || :class if options
-      receiver = sym.to_s.plural
-      receiver = "class_#{receiver}" if scope == :class
-      instance_variable_get("@#{receiver}").send(:<<, contribution)      
+    def self.page_contribution(sym, contribution=nil, options=nil, &block)
+      unless (sym == :dom && block_given?)
+        # add the contribution to the appropriate array of contributions
+        # scripts, class_scripts, styles, class_styles, script_links, style_links
+        scope = options[:scope] || :class if options
+        receiver = sym.to_s.plural
+        receiver = "class_#{receiver}" if scope == :class
+        instance_variable_get("@#{receiver}").send(:<<, contribution)
+      else
+        @document_modifications << block
+      end
     end    
     
     def self.get_component(sym)
@@ -646,7 +754,7 @@ module Trellis
     def save_component_session_information(page, instance_variable_name, session_data)
       self.class.persistents.each do |field|
         key = "#{page.class}_#{self.class}_#{instance_variable_name}_#{field}"
-        session_data[key] = instance_variable_get("@#{field}".to_sym)
+        session_data[key] = instance_variable_get("@#{field}".to_sym) if session_data
       end 
     end 
 
@@ -654,7 +762,7 @@ module Trellis
       self.class.persistents.each do |field|
         field_sym = "@#{field}".to_sym
         current_value = instance_variable_get(field_sym)
-        new_value = session_data["#{page.class}_#{self.class}_#{instance_variable_name}_#{field}"]
+        new_value = session_data["#{page.class}_#{self.class}_#{instance_variable_name}_#{field}"] if session_data
         if current_value != new_value && new_value != nil
           instance_variable_set(field_sym, new_value)
         end      
@@ -685,7 +793,7 @@ module Trellis
         # create pass-through methods for each event handler in the component (on_something methods)
         self.public_instance_methods.each do |method_name|
           if method_name.starts_with?('on_')
-            page.meta_def("#{method_name}_from_#{cname}#{id}") do |*args|
+            page.meta_def("#{method_name}_from_#{cname}_#{id}") do |*args|
               result = page.instance_variable_get("@#{cname}_#{id}".to_sym).send(method_name.to_sym, *args)
               # if the method returns a page, navigate to that page, otherwise navigate to the source page
               (result && result.kind_of?(String)) ? result : page
@@ -697,5 +805,7 @@ module Trellis
   end
   
   # load trellis core components
-  require 'trellis/core_components'
+  require 'trellis/component_library/core_components'
+  require 'trellis/component_library/grid'
+  require 'trellis/component_library/object_editor'
 end

data/lib/trellis/utils.rb

@@ -57,19 +57,25 @@ class Class #:nodoc:
       downcase.split('/').last
   end
   
-  def meta_attr_accessor(*syms)
+  def class_attr_accessor(*syms)
     syms.flatten.each do |sym|
       metaclass.instance_eval { attr_accessor(sym) }
     end
   end
+
+  def instance_attr_accessor(*syms)
+    syms.flatten.each do |sym|
+      instance_eval { attr_accessor(sym) }
+    end
+  end
   
-  def meta_attr_reader(*syms)
+  def class_attr_reader(*syms)
     syms.flatten.each do |sym|
       metaclass.instance_eval { attr_reader(sym) }
     end
   end
   
-  def meta_attr_writer(*syms)
+  def class_attr_writer(*syms)
     syms.flatten.each do |sym|
       metaclass.instance_eval { attr_writer(sym) }
     end

data/lib/trellis/version.rb

@@ -28,7 +28,7 @@ module Trellis
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 0
-    TINY  = 1
+    TINY  = 2
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/tasks/rspec.rake

@@ -18,4 +18,5 @@ desc "Run the specs under spec"
 Spec::Rake::SpecTask.new do |t|
   t.spec_opts = ['--options', "test/spec.opts"]
   t.spec_files = FileList['test/**/*_spec.rb']
-end
+  #t.rcov = true
+end

data/test/application_spec.rb

@@ -3,7 +3,7 @@ require File.dirname(__FILE__) + '/spec_helper.rb'
 require "rack" 
 require_fixtures 'application_spec_applications'
 
-describe Trellis::Application, " a Trellis application when declared" do
+describe Trellis::Application, " when declared" do
   before do
     @homepage = TestApp::MyApp.instance_eval { @homepage }
     @pages = TestApp::MyApp.instance_eval { @pages }
@@ -14,19 +14,19 @@ describe Trellis::Application, " a Trellis application when declared" do
     @homepage.should == :home
   end
   
-  it "should contain the home page in its collection of pages" do
-    @pages.include?(:home).should be(true)
-  end
-  
   it "should contain any declared static routes" do
     images_route = @static_routes.select { |item| item[:urls].include?('/images') }
-    images_route.should_not be_empty    
+    images_route.should_not be_empty  
     style_route = @static_routes.select { |item| item[:urls].include?('/style') }
     style_route.should_not be_empty  
     favicon_route = @static_routes.select { |item| item[:urls].include?('/favicon.ico') }
     favicon_route.should_not be_empty
-    yui_route = @static_routes.select { |item| item[:urls].include?('/yui') && item[:root].include?('./js') }
-    yui_route.should_not be_empty    
+    jquery_route = @static_routes.select { |item| item[:urls].include?('/jquery') && item[:root].include?('./js') }
+    jquery_route.should_not be_empty
+  end
+
+  it "should include Rack::Utils" do
+    TestApp::MyApp.included_modules.should include(Rack::Utils)
   end
  
 end
@@ -47,33 +47,58 @@ describe Trellis::Application, " when requesting the root url with a GET" do
   end
 end
 
-describe Trellis::Application, " when sending an event to a page" do
+describe Trellis::Application, " requesting a route" do
   before(:each) do
     application = TestApp::MyApp.new
-    @request = Rack::MockRequest.new(application) 
+    @request = Rack::MockRequest.new(application)
   end
-  
-  it "if the event handler returns self it should render the receiving page" do
-    response = @request.get("/home.event1")
-    response.body.should == "<html><body><h1>Hello World!</h1></body></html>"
+
+  it "should return a 404 (not found)" do
+    response = @request.get("/blowup")
+    response.status.should be(404)
   end
-  
-  it "should return a response as a string if the event handler returns a String" do
-    response = @request.get("/home.event2")
-    response.body.should == "just some text"
-  end  
-  
-  it "should render the injected page as a response if the event handler returns an injected page " do
-    response = @request.get("/home.event3")
-    response.body.should == "<html><body><p>Goodbye Cruel World </p></body></html>"
+
+  it "should return the page contents of the first page matching the route" do
+    response = @request.get("/whoa")
+    response.body.should == "<html><body>whoa!</body></html>"
+  end
+
+  it "should support a single named parameter" do
+    response_brian = @request.get("/hello/brian")
+    response_anne = @request.get("/hello/anne")
+    response_brian.body.should == "<html><body><h2>Hello</h2>brian</body></html>"
+    response_anne.body.should == '<html><body><h2>Hello</h2>anne</body></html>'
+  end
+
+  it "should support multiple named parameters" do
+    response = @request.get('/report/2009/05/31')
+    response.body.should == "<html><body><h2>Report for</h2>05/31/2009</body></html>"
+  end
+
+  it "should support optional parameters" do
+    response_all_params = @request.get('/foobar/hello/world')
+    response_one_param = @request.get('/foobar/hello')
+    response_no_param = @request.get('/foobar')
+    response_all_params.body.should == "<html><body>hello-world</body></html>"
+    response_one_param.body.should == "<html><body>hello-</body></html>"
+    response_no_param.body.should == "<html><body>-</body></html>"
+  end
+
+  it "should support a wildcard parameters" do
+    response = @request.get('/splat/goodbye/cruel/world')
+    response.body.should == '<html><body>goodbye/cruel/world</body></html>'
+  end
+
+  it "should supports mixing multiple splat" do
+    response = @request.get('/splats/bar/foo/bling/baz/boom')
+    response.body.should == '<html><body>barblingbaz/boom</body></html>'
+
+    no_route_response = @request.get('/splats/bar/foo/baz')
+    no_route_response.status.should be(404)
   end
-end
 
-describe Trellis::Page, " when calling inject_dependent_pages on an instance of child class of Page" do
-  it "should contain instances of the injected pages" do
-    homepage = TestApp::Home.new
-    homepage.inject_dependent_pages
-    injected_page = homepage.instance_eval { @other }
-    injected_page.class.should == TestApp::Other
+  it "should supports mixing named and wildcard params" do
+    response = @request.get('/mixed/afoo/bar/baz')
+    response.body.should == '<html><body>bar/baz-afoo</body></html>'
   end
 end