tanuki 0.1.3 → 0.2.1

data/config/common_application.rb

@@ -0,0 +1,31 @@
+load_config :common
+
+# Rack middleware
+use Rack::Head
+use Rack::StaticDir, 'public'
+
+# Server
+set :server, [:thin, :mongrel, :webrick]
+set :host, '0.0.0.0'
+set :port, 3000
+
+# Default controllers
+set :root_page, ::User_Page_Index
+set :missing_page, ::Tanuki_Page_Missing
+
+# Internationalization
+set :i18n, false
+set :language, nil
+set :language_fallback, {}
+set :languages, proc { language_fallback.keys }
+set :best_language, proc {|lngs| language_fallback[language].each {|lng| return lng if lngs.include? lng }; nil }
+set :best_translation, proc {|trn| language_fallback[language].each {|lng| return trn[lng] if trn.include? lng }; nil }
+
+# Visitors
+visitor :string do s = ''; proc {|out| s << out.to_s } end
+
+# Argument associations
+argument Fixnum, Argument::Integer
+argument Bignum, Argument::Integer
+argument Range, Argument::IntegerRange
+argument String, Argument::String

data/config/development_application.rb

@@ -0,0 +1,8 @@
+load_config :common_application
+set :development, true
+
+# Rack middleware
+use Rack::CommonLogger
+use Rack::Lint
+use Rack::Reloader, 0
+use Rack::ShowExceptions

data/config/production_application.rb

@@ -0,0 +1,2 @@
+load_config :common_application
+set :development, false

data/lib/tanuki/application.rb

@@ -4,37 +4,33 @@ module Tanuki
   # It contains core application functionality like configuration, request handling and view management.
   class Application
 
-    @context = Loader.context = Context.new
-    @rack_middleware = {}
+    @context = (Loader.context = Context).child
+    @rack_middleware = []
 
     class << self
 
-      # Removes a given middleware from the Rack middleware pipeline
+      # Removes all occurences of a given +middleware+ from the Rack middleware pipeline.
       def discard(middleware)
-        @rack_middleware.delete(middleware)
+        @rack_middleware.delete_if {|item| item[0] == middleware }
       end
 
-      # Runs the application with current settings
+      # Runs the application with current settings.
       def run
         rack_builder = Rack::Builder.new
-        @rack_middleware.each {|middleware, params| rack_builder.use(middleware, *params[0], &params[1]) }
+        @rack_middleware.each {|item| rack_builder.use(item[0], *item[1], &item[2]) }
         rack_builder.run(rack_app)
         srv = available_server
-        puts "A wild Tanuki appears!", "You used #{srv.name.gsub(/.*::/, '')} at #{@context.host}:#{@context.port}."
+        puts "A wild Tanuki appears! Press Ctrl-C to set it free.",
+          "You used #{srv.name.gsub(/.*::/, '')} at #{@context.host}:#{@context.port}."
         srv.run rack_builder.to_app, :Host => @context.host, :Port => @context.port
       end
 
-      # Sets an option to value in the current context.
-      def set(option, value)
-        @context.send("#{option}=".to_sym, value)
-      end
-
-      # Adds a given middleware to the Rack middleware pipeline
+      # Adds a given +middleware+ with optional +args+ and +block+ to the Rack middleware pipeline.
       def use(middleware, *args, &block)
-        @rack_middleware[middleware] = [args, block]
+        @rack_middleware << [middleware, args, block]
       end
 
-      # Adds a template visitor block. This block must return a Proc.
+      # Adds a template visitor +block+. This +block+ must return a +Proc+.
       #
       #  visitor :escape do
       #    s = ''
@@ -50,7 +46,7 @@ module Tanuki
       #  <%_escape escaped_view %>
       #  <%_printf('<div>%s</div>') formatted_view %>
       def visitor(sym, &block)
-        ObjectBehavior.instance_eval { define_method "#{sym}_visitor".to_sym, &block }
+        BaseBehavior.instance_eval { define_method "#{sym}_visitor".to_sym, &block }
       end
 
       private
@@ -67,7 +63,7 @@ module Tanuki
         raise "servers #{@context.server.join(', ')} not found"
       end
 
-      # Returns an array of template outputs for controller ctrl in context ctx.
+      # Returns an array of template outputs for controller +ctrl+ in context +request_ctx+.
       def build_body(ctrl, request_ctx)
         arr = []
         Launcher.new(ctrl, request_ctx).each &proc {|out| arr << out.to_s }
@@ -84,14 +80,14 @@ module Tanuki
         proc do |env|
           request_ctx = ctx.child
           request_ctx.templates = {}
-          if match = env['REQUEST_PATH'].match(/^(.+)(?<!\$)\/$/)
+          if match = env['PATH_INFO'].match(/^(.+)(?<!\$)\/$/)
             loc = match[1]
             loc << "?#{env['QUERY_STRING']}" unless env['QUERY_STRING'].empty?
             [301, {'Location' => loc, 'Content-Type' => 'text/html; charset=utf-8'}, []]
           else
             request_ctx.env = env
             result = ::Tanuki::ControllerBehavior.dispatch(request_ctx, ctx.i18n ? ::Tanuki::I18n : ctx.root_page,
-              Rack::Utils.unescape(env['REQUEST_PATH']).force_encoding('UTF-8'))
+              Rack::Utils.unescape(env['PATH_INFO']).force_encoding('UTF-8'))
             case result[:type]
             when :redirect then
               [302, {'Location' => result[:location], 'Content-Type' => 'text/html; charset=utf-8'}, []]

data/lib/tanuki/argument/base.rb

@@ -6,7 +6,7 @@ module Tanuki
 
       attr_reader :default, :value
 
-      # Initializes the argument with a default value.
+      # Initializes the argument with a +default+ value.
       def initialize(default)
         @value = @default = default
       end
@@ -16,7 +16,7 @@ module Tanuki
         @value.to_s
       end
 
-      # Sets the value with required rules.
+      # Sets the value to +obj+ with required rules.
       def value=(obj)
         @value = to_value(obj)
       end

data/lib/tanuki/argument/integer.rb

@@ -1,10 +1,10 @@
 module Tanuki
   module Argument
 
-    # Tanuki::Argument::Integer is a class for Integer arguments.
+    # Tanuki::Argument::Integer is a class for +Integer+ arguments.
     class Integer < Base
 
-      # Returns argument value from a string representation.
+      # Returns argument value from an object +obj+.
       def to_value(obj)
         begin Kernel::Integer obj rescue @default end
       end

data/lib/tanuki/argument/integer_range.rb

@@ -1,16 +1,16 @@
 module Tanuki
   module Argument
 
-    # Tanuki::Argument::IntegerRange is a class for Integer arguments with a certain value range.
+    # Tanuki::Argument::IntegerRange is a class for +Integer+ arguments with a certain value range.
     class IntegerRange < Integer
 
-      # Initializes the argument with a default value and allowed value range.
+      # Initializes the argument with a +default+ value and allowed value +range+.
       def initialize(range, default=nil)
         super(default ? default : range.first)
         @range = range
       end
 
-      # Returns argument value from a string representation.
+      # Returns argument value from an object +obj+.
       def to_value(obj)
         i = super(obj)
         @range.include?(i) ? i : @default

data/lib/tanuki/argument/string.rb

@@ -1,10 +1,10 @@
 module Tanuki
   module Argument
 
-    # Tanuki::Argument::String is a class for String arguments.
+    # Tanuki::Argument::String is a class for +String+ arguments.
     class String < Base
 
-      # Returns argument value from a string representation.
+      # Returns argument value from an object +obj+.
       def to_value(obj)
         obj.to_s
       end

data/lib/tanuki/argument.rb

@@ -12,12 +12,12 @@ module Tanuki
 
     class << self
 
-      # Remove argument association for a given type class.
+      # Removes argument association for a given type class +klass+.
       def delete(klass)
         @assoc.delete(klass)
       end
 
-      # Associate a given type class with an argument class.
+      # Associates a given type class +klass+ with an argument class +arg_class+.
       def store(klass, arg_class)
         warn "Tanuki::Argument::Base is not an ancestor of `#{arg_class}'" unless arg_class.ancestors.include? Argument::Base
         @assoc[klass] = arg_class
@@ -25,7 +25,7 @@ module Tanuki
 
       alias_method :[], :store
 
-      # Convert a given type object to an argument object.
+      # Converts a given type object +obj+ to an argument object with optional +args+.
       def to_argument(obj, *args)
         if @assoc.include?(klass = obj.class)
           @assoc[klass].new(obj, *args)

data/lib/tanuki/{controller_behavior.rb → behavior/controller_behavior.rb}

@@ -9,7 +9,7 @@ module Tanuki
     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.
+    # 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
@@ -29,7 +29,7 @@ module Tanuki
       end
     end
 
-    # Invoked with route args when current route is initialized.
+    # Invoked with route +args+ when current route is initialized.
     def initialize_route(*args)
     end
 
@@ -38,7 +38,7 @@ module Tanuki
       @_ctx
     end
 
-    # Initializes and retrieves child route object. Searches static, dynamic, and ghost routes (in that order).
+    # 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!
@@ -77,12 +77,12 @@ module Tanuki
       @_cache[key] = child # Thread safe (possible overwrite, but within consistent state)
     end
 
-    # Return true, if controller is active.
+    # Returns true, if controller is active.
     def active?
       @_active
     end
 
-    # Retrieves child route class. Searches static, dynamic, and ghost routes (in that order).
+    # Retrieves child controller class on +route+. Searches static, dynamic, and ghost routes (in that order).
     def child_class(route)
       ensure_configured!
       args = []
@@ -108,11 +108,11 @@ module Tanuki
       end
     end
 
-    # Invoked when controller need to be configured.
+    # Invoked when controller needs to be configured.
     def configure
     end
 
-    # Return true, if controller is current.
+    # Returns true, if controller is current.
     def current?
       @_current
     end
@@ -122,6 +122,7 @@ module Tanuki
       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!
@@ -157,15 +158,15 @@ module Tanuki
       nil
     end
 
-    # Returns the link to the current controller, switching the active controller on the respective path level to self.
+    # 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(/(?<!\$)\//)
+      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 children.
+    # Returns the number of visible child controllers on static and dynamic routes.
     def length
       if @_child_collection_defs.length > 0
         if @_length_is_valid
@@ -179,7 +180,7 @@ module Tanuki
       end
     end
 
-    # Process context passed to child
+    # Invoked when child controller context needs to be processed before initializing.
     def process_child_context(ctx, route)
       ctx
     end
@@ -198,21 +199,21 @@ module Tanuki
 
     private
 
-    # Defines a child of class klass on route with model, optionally hidden.
+    # 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.
+    # 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.
+    # 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
@@ -225,12 +226,12 @@ module Tanuki
         @_arg_defs ||= superclass.arg_defs.dup
       end
 
-      # Escapes a given string for use in links.
+      # 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.
+      # 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|
@@ -239,7 +240,7 @@ module Tanuki
         res
       end
 
-      # Builds link from root to self.
+      # 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, '\/:')}"
@@ -247,7 +248,7 @@ module Tanuki
         "#{ctrl.link == '/' ? '' : ctrl.link}/#{own_link}"
       end
 
-      # Defines an argument with name, derived from object obj with additional args.
+      # 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}
@@ -264,7 +265,7 @@ module Tanuki
 
     class << self
 
-      # Dispathes route chain in context ctx on request_path, starting with controller klass.
+      # 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)
@@ -297,7 +298,7 @@ module Tanuki
 
       private
 
-      # Parses path to return route name and arguments.
+      # Parses +path+ to return route name and arguments.
       def parse_path(path)
         path[1..-1].split(/(?<!\$)\//).map do |s|
           arr = s.gsub('$/', '/').split(/(?<!\$):/)
@@ -312,7 +313,7 @@ module Tanuki
         end
       end
 
-      # Unescape a given link part for internal use.
+      # Unescapes a given link part for internal use.
       def unescape(s)
         s ? s.gsub(/\$([\/\$:-])/, '\1') : nil
       end

data/lib/tanuki/behavior/meta_model_behavior.rb

@@ -0,0 +1,43 @@
+module Tanuki
+
+  module MetaModelBehavior
+
+      def initialize(namespace, name, data)
+        @namespace = namespace
+        @name = name
+        @data = data
+      end
+
+      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
+
+      def key
+        if @data['key'].nil?
+          []
+        elsif @data['key'].is_a? Array
+          @data['key'].map {|item| qualified_name(item) }
+        elsif @data['key'].is_a? String
+          [qualified_name(@data['key'])]
+        else
+          raise "key for model #{@namespace}.#{@name} is invalid"
+        end
+      end
+
+      def qualified_name(field_name)
+        parts = field_name.split('.')
+        if parts.length == 1
+          ":#{field_name}"
+        elsif parts.length == 2
+          ":#{parts[1]}.qualify(:#{parts[0]}"
+        else
+          raise "field name for model #{@namespace}.#{@name} is invalid"
+        end
+      end
+
+  end # end MetaModelBehavior
+
+end # end Tanuki

data/lib/tanuki/behavior/model_behavior.rb

@@ -0,0 +1,112 @@
+module Tanuki
+
+  module ModelBehavior
+
+    def initialize(data = {}, lazy = false)
+      @_data = data
+      @_loaded = !lazy
+    end
+
+    def [](attribute)
+      ensure_loaded!
+      self.class[attribute].get(@_data)
+    end
+
+    def []=(attribute, value)
+      @_errors ||= {}
+      @_original ||= {}
+      begin
+        @_original[attribute] = self[attribute] unless @_original.include? attribute
+        self.class[attribute].set(@_data, value)
+        @_errors.delete(attribute)
+      rescue
+        @_errors[attribute] = {:value => value, :error => $!}
+      end
+    end
+
+    def internals_get(attribute)
+      self.class[attribute].internals_get(@_data)
+    end
+
+    def internals_set(attribute, internal_value)
+      @_errors ||= {}
+      internals_set(self.class[attribute], @_data)
+    end
+
+    def get_updates
+      @_original ||= {}
+      original_data = {}
+      self.class.attributes.each_pair do |name, attrib|
+        attrib.set(original_data, @_original[name])
+      end
+      updates = {}
+      original_data.each_pair do |field, value|
+        updates[field] = data[field] if data[field] != original_data[field]
+      end
+      updates
+    end
+
+    def get_error(attribute)
+      @_errors ||= {}
+      @_errors[attribute]
+    end
+
+    def invalid?(attribute)
+      @_errors.include? attribute
+    end
+
+    def has_errors?
+      @_errors ||= {}
+      @_errors == {}
+    end
+
+    def errors
+      @_errors ||= {}
+      @_errors
+    end
+
+    module ClassMethods
+
+      def create(data, ctx, lazy = false) # IDENTITY TRACKING AND LAZY LOADING
+        entity_key = extract_key(data)
+        key = [self, entity_key] #extract_key is generated ad hoc by model compiler!
+        if cached = ctx.entity_cache[key]
+          cached
+        else
+          ctx.entity_cache[key] = get(*entity_key) # get is generated Ad Hoc by model compiler
+        end
+      end
+
+      def has_attribute(attribute, attr_def)
+        @_attributes ||= superclass.instance_variable_get(:@_attributes).dup
+        @_attributes[attribute] = attr_def
+      end
+
+      def [](attribute)
+        @_attributes[attribute]
+      end
+
+      def has_reference(attribute, reference_def)
+        @_references ||= superclass.instance_variable_get(:@_references).dup
+        @_references[attribute] = reference_def
+      end
+
+      # Prepares the extended module.
+      def self.extended(mod)
+        mod.instance_variable_set(:@_attributes, {})
+        mod.instance_variable_set(:@_references, {})
+      end
+
+    end # end ClassMethods
+
+    class << self
+
+      def included(mod)
+        mod.extend ClassMethods
+      end
+
+    end # end class << self
+
+  end # end ModelBehaviour
+
+end # end Tanuki

data/lib/tanuki/{object_behavior.rb → behavior/object_behavior.rb}

@@ -1,15 +1,15 @@
 module Tanuki
 
-  # Tanuki::ControllerBehavior contains basic methods for a framework object.
+  # Tanuki::BaseBehavior contains basic methods for a templatable object.
   # In is included in the base framework object class.
-  module ObjectBehavior
+  module BaseBehavior
 
-    # Shortcut to Tanuki::Loader.has_template?. Used internally by templates.
+    # 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.
+    # 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
@@ -19,7 +19,7 @@ module Tanuki
       ctx
     end
 
-    # Kernel#method_missing hook for fetching views.
+    # Allows to return template blocks. E. g. returns +foobar+ template block when +foobar_view+ method is called.
     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)
@@ -27,6 +27,6 @@ module Tanuki
       super
     end
 
-  end # end ObjectBehavior
+  end # end BaseBehavior
 
 end # end Tanuki