tanuki 0.3.1 → 0.4.0

data/app/user/page/index/index.rb

@@ -1,2 +0,0 @@
-class User::Page::Index < Tanuki::Controller
-end

data/config/test_application.rb

@@ -1,2 +0,0 @@
-load_config :development_application
-set :root_page, ::Test::Page::Index

data/lib/tanuki/behavior/controller_behavior.rb

@@ -1,366 +0,0 @@
-module Tanuki
-
-  # Tanuki::ControllerBehavior contains basic methods for a framework controller.
-  # It 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
-
-    # Creates 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
-
-        # Register controller arguments, as declared with Tanuki::ControllerBehavior#has_arg.
-        @_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 controller on +route+. 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 # if
-          end # each
-
-        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
-
-    # Returns +true+, if controller is active.
-    def active?
-      @_active
-    end
-
-    # Retrieves child controller class on +route+. 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 needs to be configured.
-    def configure
-    end
-
-    # Returns +true+, if controller is current.
-    def current?
-      @_current
-    end
-
-    # If set, controller navigates to a given child route by default.
-    # Returned object should be either +nil+ (don't navigate), or a +Hash+ with keys:
-    # * +:route+ is the +Symbol+ for the route
-    # * +:args+ contain route arguments +Hash+
-    # * +:redirect+ makes a 302 redirect to this route, if true (optional)
-    def default_route
-      nil
-    end
-
-    # Calls +block+ once for each visible child controller on static or dynamic routes, passing it as a parameter.
-    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['PATH_INFO'].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 visible child controllers on static and dynamic routes.
-    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
-
-    # Invoked when child controller context needs to be processed before initializing.
-    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+, formatted back by +format_string+.
-    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. This hook can be used to make ghost routes.
-    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 characters +chrs+ and encodes a given string +s+ 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 controller +ctrl+ to a given route.
-      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 a +name+, derived from type +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 # ClassMethods
-
-    extend ClassMethods
-
-    class << self
-
-      # Dispathes route chain in context +ctx+ on +request_path+, starting with controller +klass+.
-      def dispatch(ctx, klass, request_path)
-        route_parts = parse_path(request_path)
-
-        # Set logical children for active controllers
-        curr = root_ctrl = klass.new(ctx, nil, nil, true)
-        route_parts.each do |route_part|
-          curr.instance_variable_set :@_active, true
-          nxt = curr[route_part[:route], *route_part[:args]]
-          curr.logical_child = nxt
-          curr = nxt
-        end
-
-        # Set links for active controllers and default routes
-        while route_part = curr.default_route
-
-          # Do a redirect, if some controller in the chain asks for it
-          if route_part[:redirect]
-            klass = curr.child_class(route_part)
-            return {:type => :redirect, :location => grow_link(curr, route_part, klass.arg_defs)}
-          end
-
-          # Add default route as logical child
-          curr.instance_variable_set :@_active, true
-          nxt = curr[route_part[:route], *route_part[:args]]
-          curr.logical_child = nxt
-          curr = nxt
-
-        end
-
-        # Find out dispatch result type from current controller
-        curr.instance_variable_set :@_active, true
-        curr.instance_variable_set :@_current, true
-        type = (curr.is_a? ctx.missing_page) ? :missing_page : :page
-
-        # Set visual children for active controllers
-        prev = curr
-        while curr = prev.visual_parent
-          curr.visual_child = prev
-          prev = curr
-        end
-
-        {:type => type, :controller => prev}
-      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 # do
-      end
-
-      # Unescapes a given link part for internal use.
-      def unescape(s)
-        s ? s.gsub(/\$([\/\$:-])/, '\1') : nil
-      end
-
-    end # class << self
-
-  end # ControllerBehavior
-
-end # Tanuki

data/lib/tanuki/behavior/meta_model_behavior.rb

@@ -1,160 +0,0 @@
-module Tanuki
-
-  # Tanuki::MetaModelBehavior contains all methods for the meta-model.
-  # In is included in the meta-model class.
-  module MetaModelBehavior
-
-      # Creates new meta-model +name+ in +namespace+.
-      # Model schema is passed as +data+.
-      # Stucture +models+ contains all models being generated.
-      def initialize(namespace, name, data, models)
-        @namespace = namespace
-        @name = name
-        @data = data
-        @models = models
-      end
-
-      # Returns class name for a given class type.
-      def class_name_for(class_type)
-        case class_type
-        when :model, :model_base then "#{@namespace}_Model_#{@name}"
-        when :manager, :manager_base then "#{@namespace}_Manager_#{@name}"
-        end
-      end
-
-      # Returns an array of code for alias-column name pair.
-      def key
-        @key.inspect
-      end
-
-      # Prepares data for template generation.
-      # Processes own keys, fields, etc.
-      def process!
-        process_source!
-        process_key!
-        process_joins!
-        process_filter!
-        process_order!
-      end
-
-      # Prepares data for building a Sequel +where+ clause.
-      def process_filter!
-        # TODO: ...
-      end
-
-      def process_key!
-        if @source.include? 'key' && @source['key'].nil?
-          @key = []
-        else
-          @key = @source['key'] || 'id'
-        end
-        @key = [@key] if @key.is_a? String
-        raise 'invalid key' unless @key.is_a? Array
-        @key.map! do |k|
-          parts = k.split('.').map {|p| p.to_sym }
-          raise "invalid key field #{k}" if parts.count > 2
-          if parts.count == 2
-            raise 'all key fields should belong to the first-source' if parts[0] != @first_source.to_s
-            parts
-          else
-            [@first_source, parts[0]]
-          end
-        end
-      end
-
-      # Prepares data for building a Sequel +order+ clause.
-      def process_order!
-        # TODO: ...
-      end
-
-      # Extracts the model firts-source information form the YAML @data
-      # and performs
-      def process_source!
-        guess_table = @name.pluralize
-        @data ||= {}
-        @source = @data['source'] || guess_table
-        @source = {'table' => @source} if @source.is_a? String
-        @first_source = (@source['table'] || guess_table).downcase.to_sym
-      end
-
-      def process_joins!
-        @joins = {}
-        @joins[@first_source] = nil
-        joins = @source['joins'] || {}
-        joins = [joins] if joins.is_a? String
-        joins = Hash[*joins.collect {|v| [v, nil] }.flatten] if joins.is_a? Array
-        if joins.is_a? Hash
-          joins.each_pair do |table_alias, join|
-            table_alias = table_alias.to_sym
-            raise "#{table_alias} is already in use" if @joins.include? table_alias
-            if join && (join['on'].is_a? Hash)
-              table_name = join['table'] || table_alias
-              on = join['on']
-              join_type = (join['type'] || 'inner').to_sym
-            else
-              on = join
-              table_name = table_alias
-              join_type = :inner
-            end
-            if on
-              on = Hash[*on.map do |lhs, rhs|
-                [[lhs,table_alias],[rhs,@first_source]].map do |side,table_alias|
-                  if side.is_a? String
-                    if m = side.match(/^\(('|")(.*)\1\)$/)
-                      m[2]
-                    else
-                      parts = side.split('.').map {|x| x.to_sym }
-                      case parts.count
-                      when 1
-                        [table_alias, parts[0]]
-                      when 2
-                        raise "Unknown alias #{parts[0]}" unless @joins.include? parts[0]
-                        parts
-                      else
-                        raise "Invalid column specification #{lhs}"
-                      end
-                    end
-                  else
-                    side
-                  end
-                end
-              end.flatten]
-            else
-              on = {}
-              @key.each do |k|
-                on[[table_alias, (@first_source.to_s.singularize << '_' << k[1].to_s).to_sym]] = k
-              end
-            end
-            @joins[table_alias] = {
-              :type => join_type,
-              :table => table_name,
-              :alias => table_alias,
-              :on => on
-            }
-          end
-        else
-          raise "`joins' should be either nil or string or array or hash"
-        end
-      end
-
-      # Prepares data for template generation.
-      # Processes foreign keys, fields, etc.
-      def process_relations!
-
-      end
-
-      # Returns code for alias-column name pair for field +field_name+.
-      def qualified_name(field_name)
-        parts = field_name.split('.')
-        if parts.length == 1
-          "%w{:#{@first_source} :#{field_name}}"
-        elsif parts.length == 2
-          "%w{:#{parts[0]} :#{parts[1]}}"
-        else
-          raise "field name for model #{@namespace}.#{@name} is invalid"
-        end
-      end
-
-  end # MetaModelBehavior
-
-end # Tanuki