tanuki 0.1.3

data/lib/tanuki/controller_behavior.rb

@@ -0,0 +1,324 @@
+module Tanuki
+
+  # Tanuki::ControllerBehavior contains basic methods for a framework controller.
+  # In is included in the base controller class.
+  module ControllerBehavior
+
+    include Enumerable
+
+    internal_attr_reader :model, :logical_parent, :link
+    internal_attr_accessor :logical_child, :visual_child
+
+    # Create new controller with context ctx, logical_parent controller, route_part definitions and a model.
+    def initialize(ctx, logical_parent, route_part, model=nil)
+      @_configured = false
+      @_ctx = ctx
+      @_model = model
+      @_args = {}
+      if @_logical_parent = logical_parent
+        @_route = route_part[:route]
+        self.class.arg_defs.each_pair do |arg_name, arg_def|
+          route_part[:args][arg_def[:index]] = @_args[arg_name] = arg_def[:arg].to_value(route_part[:args][arg_def[:index]])
+        end
+        @_link = self.class.grow_link(@_logical_parent, {:route => @_route, :args => @_args}, self.class.arg_defs)
+        initialize_route(*route_part[:args])
+      else
+        @_link = '/'
+        @_route = nil
+        initialize_route
+      end
+    end
+
+    # Invoked with route args when current route is initialized.
+    def initialize_route(*args)
+    end
+
+    # Returns controller context. Used internally by templates.
+    def _ctx(ctx)
+      @_ctx
+    end
+
+    # Initializes and retrieves child route object. Searches static, dynamic, and ghost routes (in that order).
+    def [](route, *args)
+      byname = (args.length == 1 and args[0].is_a? Hash)
+      ensure_configured!
+      key = [route, args.dup]
+      if cached = @_cache[key]
+        # Return form cache
+        return cached
+      elsif child_def = @_child_defs[route]
+        # Search static routes
+        klass = child_def[:class]
+        args = klass.extract_args(args[0]) if byname
+        child = klass.new(process_child_context(@_ctx, route), self, {:route => route, :args => args}, child_def[:model])
+      else
+        # Search dynamic routes
+        found = false
+        s = route.to_s
+        @_child_collection_defs.each do |collection_def|
+          if md = collection_def[:parse].match(s)
+            a_route = md['route'].to_sym
+            child_def = collection_def[:fetcher].fetch(a_route, collection_def[:format])
+            if child_def
+              klass = child_def[:class]
+              args = klass.extract_args(args[0]) if byname
+              embedded_args = klass.extract_args(md)
+              args.each_index {|i| embedded_args[i] = args[i] if args[i] }
+              child = klass.new(process_child_context(@_ctx, a_route), self,
+                {:route => a_route, :args => embedded_args}, child_def[:model])
+              found = true
+              break child
+            end
+          end
+        end
+        # If still not found, search ghost routes
+        child = missing_route(route, *args) unless found
+      end
+      @_cache[key] = child # Thread safe (possible overwrite, but within consistent state)
+    end
+
+    # Return true, if controller is active.
+    def active?
+      @_active
+    end
+
+    # Retrieves child route class. Searches static, dynamic, and ghost routes (in that order).
+    def child_class(route)
+      ensure_configured!
+      args = []
+      key = [route, args]
+      if cached = @_cache[key]
+        # Return from cache
+        return cached.class
+      elsif child_def = @_child_defs[route]
+        # Return from static routes
+        return child_def[:class]
+      else
+        # Search dynamic routes
+        s = route.to_s
+        @_child_collection_defs.each do |collection_def|
+          if md = collection_def[:parse].match(s)
+            a_route = md['route'].to_sym
+            child_def = collection_def[:fetcher].fetch(a_route, collection_def[:format])
+            return child_def[:class] if child_def
+          end
+        end
+        # If still not found, search ghost routes
+        return (@_cache[key] = missing_route(route, *args)).class
+      end
+    end
+
+    # Invoked when controller need to be configured.
+    def configure
+    end
+
+    # Return true, if controller is current.
+    def current?
+      @_current
+    end
+
+    # If set, controller navigates to a given child route by default.
+    def default_route
+      nil
+    end
+
+    def each(&block)
+      return Enumerator.new(self) unless block_given?
+      ensure_configured!
+      @_child_defs.each_pair do |route, child|
+        if route.is_a? Regexp
+          cd = @_child_collection_defs[child]
+          cd[:fetcher].fetch_all(cd[:format]) do |child_def|
+            key = [child_def[:route], []]
+            unless child = @_cache[key]
+              child = child_def[:class].new(process_child_context(@_ctx, route), self,
+                {:route => child_def[:route], :args => {}}, child_def[:model])
+              @_cache[key] = child
+            end
+            block.call child
+          end
+        else
+          yield self[route] unless child[:hidden]
+        end
+      end
+      self
+    end
+
+    # Invoked when controller configuration needs to be ensured.
+    def ensure_configured!
+      unless @_configured
+        @_child_defs = {}
+        @_child_collection_defs = []
+        @_cache={}
+        @_length = 0
+        configure
+        @_configured = true
+      end
+      nil
+    end
+
+    # Returns the link to the current controller, switching the active controller on the respective path level to self.
+    def forward_link
+      uri_parts = @_ctx.env['REQUEST_PATH'].split(/(?<!\$)\//)
+      link_parts = link.split(/(?<!\$)\//)
+      link_parts.each_index {|i| uri_parts[i] = link_parts[i] }
+      uri_parts.join('/') << ((qs = @_ctx.env['QUERY_STRING']).empty? ? '' : "?#{qs}")
+    end
+
+    # Returns the number of children.
+    def length
+      if @_child_collection_defs.length > 0
+        if @_length_is_valid
+          @_length
+        else
+          @_child_collection_defs.each {|cd| @_length += cd[:fetcher].length }
+          @_length_is_valid = true
+        end
+      else
+        @_length
+      end
+    end
+
+    # Process context passed to child
+    def process_child_context(ctx, route)
+      ctx
+    end
+
+    alias_method :size, :length
+
+    # Returns controller string representation. Defaults to route name.
+    def to_s
+      @_route.to_s
+    end
+
+    # Invoked when visual parent needs to be determined. Defaults to logical parent.
+    def visual_parent
+      @_logical_parent
+    end
+
+    private
+
+    # Defines a child of class klass on route with model, optionally hidden.
+    def has_child(klass, route, model=nil, hidden=false)
+      @_child_defs[route] = {:class => klass, :model => model, :hidden => hidden}
+      @_length += 1 unless hidden
+      self
+    end
+
+    # Defines a child collection of type parse_regexp.
+    def has_child_collection(parse_regexp, format_string, child_def_fetcher)
+      @_child_defs[parse_regexp] = @_child_collection_defs.size
+      @_child_collection_defs << {:parse => parse_regexp, :format => format_string, :fetcher => child_def_fetcher}
+      @_length_is_valid = false
+    end
+
+    # Invoked for route with args when a route is missing.
+    def missing_route(route, *args)
+      @_ctx.missing_page.new(@_ctx, self, {:route => route, :args => []})
+    end
+
+    # Tanuki::ControllerBehavior mixed-in class methods.
+    module ClassMethods
+
+      # Returns own or superclass argument definitions.
+      def arg_defs
+        @_arg_defs ||= superclass.arg_defs.dup
+      end
+
+      # Escapes a given string for use in links.
+      def escape(s, chrs)
+        s ? Rack::Utils.escape(s.to_s.gsub(/[\$#{chrs}]/, '$\0')) : nil
+      end
+
+      # Extracts arguments, initializing default values beforehand. Searches md hash for default value overrides.
+      def extract_args(md)
+        res = []
+        arg_defs.each_pair do |name, arg|
+          res[arg[:index]] = md[name]
+        end
+        res
+      end
+
+      # Builds link from root to self.
+      def grow_link(ctrl, route_part, arg_defs)
+        own_link = escape(route_part[:route], '\/:') << route_part[:args].map do |k, v|
+          arg_defs[k][:arg].default == v ? '' : ":#{escape(k, '\/:-')}-#{escape(v, '\/:')}"
+        end.join
+        "#{ctrl.link == '/' ? '' : ctrl.link}/#{own_link}"
+      end
+
+      # Defines an argument with name, derived from object obj with additional args.
+      def has_arg(name, obj, *args)
+        # TODO Ensure thread safety
+        arg_defs[name] = {:arg => Argument.to_argument(obj, *args), :index => @_arg_defs.size}
+      end
+
+      # Prepares the extended module.
+      def self.extended(mod)
+        mod.instance_variable_set(:@_arg_defs, {})
+      end
+
+    end # end ClassMethods
+
+    extend ClassMethods
+
+    class << self
+
+      # Dispathes route chain in context ctx on request_path, starting with controller klass.
+      def dispatch(ctx, klass, request_path)
+        parts = parse_path(request_path)
+        curr = root_ctrl = klass.new(ctx, nil, nil, true)
+        parts.each do |part|
+          curr.instance_variable_set :@_active, true
+          nxt = curr[part[:route], *part[:args]]
+          curr.logical_child = nxt
+          curr = nxt
+        end
+        curr.instance_variable_set :@_active, true
+        curr.instance_variable_set :@_current, true
+        if route = curr.default_route
+          klass = curr.child_class(route)
+          {:type => :redirect, :location => grow_link(curr, route, klass.arg_defs)}
+        else
+          type = (curr.is_a? ctx.missing_page) ? :missing_page : :page
+          prev = curr
+          while curr = prev.visual_parent
+            curr.visual_child = prev
+            prev = curr
+          end
+          {:type => type, :controller => prev}
+        end
+      end
+
+      # Extends the including module with Tanuki::ControllerBehavior::ClassMethods.
+      def included(mod)
+        mod.extend ClassMethods
+      end
+
+      private
+
+      # Parses path to return route name and arguments.
+      def parse_path(path)
+        path[1..-1].split(/(?<!\$)\//).map do |s|
+          arr = s.gsub('$/', '/').split(/(?<!\$):/)
+          route_part = {:route => unescape(arr[0]).to_sym}
+          args = {}
+          arr[1..-1].each do |argval|
+            varr = argval.split(/(?<!\$)-/)
+            args[unescape(varr[0])] = unescape(varr[1..-1].join) # TODO Predict argument
+          end
+          route_part[:args] = extract_args(args)
+          route_part
+        end
+      end
+
+      # Unescape a given link part for internal use.
+      def unescape(s)
+        s ? s.gsub(/\$([\/\$:-])/, '\1') : nil
+      end
+
+    end # end class << self
+
+  end # end ControllerBehavior
+
+end # end Tanuki

data/lib/tanuki/i18n.rb

@@ -0,0 +1,33 @@
+module Tanuki
+
+  # Tanuki::I18n is a drop-in controller for localizable applications.
+  class I18n
+
+    include ControllerBehavior
+
+    # Adds language routes of root controller class when invoked.
+    def configure
+      root_page = @_ctx.root_page
+      @_ctx.languages.each {|lng| has_child root_page, lng }
+    end
+
+    # Returns default route according to default language.
+    def default_route
+      {:route => @_ctx.language.to_s, :args => {}}
+    end
+
+    # Calls default view of visual child.
+    def default_view
+      @_visual_child.default_view
+    end
+
+    # Adds child language to its context.
+    def process_child_context(ctx, route)
+      ctx = ctx.child
+      ctx.language = route.to_sym
+      ctx
+    end
+
+  end # end I18n
+
+end # end Tanuki

data/lib/tanuki/launcher.rb

@@ -0,0 +1,20 @@
+module Tanuki
+
+  # Tanuki::Launcher is called on every request.
+  # It is used to build output starting with the default view of the root controller.
+  class Launcher
+
+    # Creates a new Tanuki::Launcher with root controller ctrl in context ctx.
+    def initialize(ctrl, ctx)
+      @ctrl = ctrl
+      @ctx = ctx
+    end
+
+    # Passes a given block to the requested page template tree.
+    def each(&block)
+      @ctrl.default_view.call(proc {|out| block.call(out.to_s) }, @ctx)
+    end
+
+  end # end Launcher
+
+end # end Tanuki

data/lib/tanuki/loader.rb

@@ -0,0 +1,131 @@
+module Tanuki
+
+  # Tanuki::Loader deals with framework paths resolving, and object and template loading.
+  class Loader
+
+    class << self
+
+      # Returns the path to a source file containing class klass.
+      def class_path(klass)
+        path = const_to_path(klass, @context.app_root, File::SEPARATOR)
+        File.join(path, path.match("#{File::SEPARATOR}([^#{File::SEPARATOR}]*)$")[1] << '.rb')
+      end
+
+      def context=(ctx)
+        @context = ctx
+      end
+
+      # Checks if templates contain a compiled template sym for class klass
+      def has_template?(templates, klass, sym)
+        templates.include? "#{klass}##{sym}"
+      end
+
+      # Runs template sym from obj.
+      # Template is recompiled from source on two conditions:
+      # * template source modification time is older than compiled template modification time,
+      # * Tanuki::TemplateCompiler source modification time is older than compiled template modification time.
+      def run_template(templates, obj, sym, *args, &block)
+        st_path = source_template_path(obj.class, sym)
+        if st_path
+          owner = template_owner(obj.class, sym)
+          ct_path = compiled_template_path(obj.class, sym)
+          ct_file_exists = File.file?(ct_path)
+          ct_file_mtime = ct_file_exists ? File.mtime(ct_path) : nil
+          st_file = File.new(st_path, 'r:UTF-8')
+          if !ct_file_exists || st_file.mtime > ct_file_mtime || File.mtime(COMPILER_PATH) > ct_file_mtime
+            no_refresh = compile_template(st_file, ct_path, ct_file_mtime, owner, sym)
+          else
+            no_refresh = true
+          end
+          method_name = "#{sym}_view".to_sym
+          owner.instance_eval do
+            unless (method_exists = instance_methods(false).include? method_name) && no_refresh
+              remove_method method_name if method_exists
+              load ct_path
+            end
+          end
+          templates["#{owner}##{sym}"] = nil
+          templates["#{obj.class}##{sym}"] = nil
+          obj.send(method_name, *args, &block)
+        else
+          raise "undefined template `#{sym}' for #{obj.class}"
+        end
+      end
+
+      private
+
+      # Path to Tanuki::TemplateCompiler for internal use.
+      COMPILER_PATH = File.join(File.expand_path('..', __FILE__), 'template_compiler.rb')
+
+      # Extension glob for template files.
+      TEMPLATE_EXT = '.t{html,txt}'
+
+      # Compiles template sym from owner class using source in st_file to ct_path.
+      # Compilation is only done if destination file modification time has not changed
+      # (is equal to ct_file_mtime) since file locking was initiated.
+      def compile_template(st_file, ct_path, ct_file_mtime, owner, sym)
+        no_refresh = true
+        st_file.flock(File::LOCK_EX)
+        if !File.file?(ct_path) || File.mtime(ct_path) == ct_file_mtime
+          no_refresh = false
+          ct_dir = File.dirname(ct_path)
+          FileUtils.mkdir_p(ct_dir) unless File.directory?(ct_dir)
+          File.open(tmp_ct_path = ct_path + '~', 'w:UTF-8') do |ct_file|
+            TemplateCompiler.compile_template(ct_file, st_file.read, owner, sym)
+          end
+          FileUtils.mv(tmp_ct_path, ct_path)
+        end
+        st_file.flock(File::LOCK_UN)
+        no_refresh
+      end
+
+      # Returns the path to a compiled template file containing template method_name for class klass.
+      def compiled_template_path(klass, method_name)
+        File.join(const_to_path(klass, @context.cache_root, '.'), method_name.to_s << '.rb')
+      end
+
+      # Transforms a given constant klass to path with a given root and separated by sep.
+      def const_to_path(klass, root, sep)
+        File.join(root, klass.to_s.split('_').map {|item| item.gsub(/(?!^)([A-Z])/, '_\1') }.join(sep).downcase)
+      end
+
+      # Returns the path to a source file containing template method_name for class klass.
+      def source_template_path(klass, method_name)
+        template_path(klass, method_name, @context.app_root, File::SEPARATOR, TEMPLATE_EXT)
+      end
+
+      # Finds the direct template method_name owner among ancestors of class klass.
+      def template_owner(klass, method_name)
+        method_file = method_name.to_s << TEMPLATE_EXT
+        klass.ancestors.each do |ancestor|
+          unless Dir.glob(File.join(const_to_path(ancestor, @context.app_root, File::SEPARATOR), method_file)).empty?
+            return ancestor
+          end
+        end
+        nil
+      end
+
+      # Returns the path to a file containing template method_name for class klass.
+      # This is done with a given root, extension ext, and separated by sep.
+      def template_path(klass, method_name, root, sep, ext)
+        if owner = template_owner(klass, method_name)
+          return Dir.glob(File.join(const_to_path(owner, root, sep), method_name.to_s << ext))[0]
+        end
+        nil
+      end
+
+    end # end class << self
+
+  end # end Path
+
+end # end Tanuki
+
+
+# Runs Tanuki::Loader for every missing constant in main namespace.
+def Object.const_missing(sym)
+  if File.file?(path = Tanuki::Loader.class_path(sym))
+    require path
+    return const_get(sym)
+  end
+  super
+end

data/lib/tanuki/module_extensions.rb

@@ -0,0 +1,27 @@
+class Module
+
+  # Creates a reader +sym+ and a writer +sym=+ for the instance variable +@_sym+.
+  def internal_attr_accessor(*syms)
+    internal_attr_reader(*syms)
+    internal_attr_writer(*syms)
+  end
+
+  # Creates a reader +sym+ for the instance variable +@_sym+.
+  def internal_attr_reader(*syms)
+    syms.each do |sym|
+      ivar = "@_#{sym}".to_sym
+      instance_variable_set(ivar, nil) unless instance_variable_defined? ivar
+      class_eval "def #{sym};#{ivar};end"
+    end
+  end
+
+  # Creates a writer +sym=+ for the instance variable +@_sym+.
+  def internal_attr_writer(*syms)
+    syms.each do |sym|
+      ivar = "@_#{sym}".to_sym
+      instance_variable_set(ivar, nil) unless instance_variable_defined? ivar
+      class_eval "def #{sym}=(obj);#{ivar}=obj;end"
+    end
+  end
+
+end # end Module

data/lib/tanuki/object_behavior.rb

@@ -0,0 +1,32 @@
+module Tanuki
+
+  # Tanuki::ControllerBehavior contains basic methods for a framework object.
+  # In is included in the base framework object class.
+  module ObjectBehavior
+
+    # Shortcut to Tanuki::Loader.has_template?. Used internally by templates.
+    def _has_tpl(ctx, klass, sym)
+      Tanuki::Loader.has_template?(ctx.templates, klass, sym)
+    end
+
+    # Shortcut to Tanuki::Loader.run_template. Used internally by templates.
+    def _run_tpl(ctx, obj, sym, *args, &block)
+      Tanuki::Loader.run_template(ctx.templates, obj, sym, *args, &block)
+    end
+
+    # Returns the same context as given. Used internally by templates.
+    def _ctx(ctx)
+      ctx
+    end
+
+    # Kernel#method_missing hook for fetching views.
+    def method_missing(sym, *args, &block)
+      if matches = sym.to_s.match(/^(.*)_view$/)
+        return Tanuki::Loader.run_template({}, self, matches[1].to_sym, *args, &block)
+      end
+      super
+    end
+
+  end # end ObjectBehavior
+
+end # end Tanuki