tanuki 0.3.0 → 0.3.1

data/lib/tanuki/behavior/controller_behavior.rb

@@ -1,7 +1,7 @@
 module Tanuki
 
   # Tanuki::ControllerBehavior contains basic methods for a framework controller.
-  # In is included in the base controller class.
+  # It is included in the base controller class.
   module ControllerBehavior
 
     include Enumerable
@@ -16,10 +16,13 @@ module Tanuki
       @_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
@@ -44,14 +47,19 @@ module Tanuki
       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
@@ -68,11 +76,14 @@ module Tanuki
                 {:route => a_route, :args => embedded_args}, child_def[:model])
               found = true
               break child
-            end
-          end
+            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
@@ -88,12 +99,17 @@ module Tanuki
       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|
@@ -103,8 +119,10 @@ module Tanuki
             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
 
@@ -263,7 +281,7 @@ module Tanuki
         mod.instance_variable_set(:@_arg_defs, {})
       end
 
-    end # end ClassMethods
+    end # ClassMethods
 
     extend ClassMethods
 
@@ -272,6 +290,8 @@ module Tanuki
       # 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
@@ -279,24 +299,36 @@ module Tanuki
           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
 
@@ -319,7 +351,7 @@ module Tanuki
           end
           route_part[:args] = extract_args(args)
           route_part
-        end
+        end # do
       end
 
       # Unescapes a given link part for internal use.
@@ -327,8 +359,8 @@ module Tanuki
         s ? s.gsub(/\$([\/\$:-])/, '\1') : nil
       end
 
-    end # end class << self
+    end # class << self
 
-  end # end ControllerBehavior
+  end # ControllerBehavior
 
-end # end Tanuki
+end # Tanuki

data/lib/tanuki/behavior/meta_model_behavior.rb

@@ -32,10 +32,22 @@ module Tanuki
       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!
-        @key = @source['key'] || 'id'
+        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|
@@ -50,6 +62,11 @@ module Tanuki
         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!
@@ -63,11 +80,6 @@ module Tanuki
       def process_joins!
         @joins = {}
         @joins[@first_source] = nil
-      end
-
-      # Prepares data for template generation.
-      # Processes foreign keys, fields, etc.
-      def process_relations!
         joins = @source['joins'] || {}
         joins = [joins] if joins.is_a? String
         joins = Hash[*joins.collect {|v| [v, nil] }.flatten] if joins.is_a? Array
@@ -75,32 +87,62 @@ module Tanuki
           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
-              if join['on'].is_a Hash
-                table_name = join['table'] || table_alias
-                on = join['on']
-              else
-                on = join
-                table_name = table_alias
-              end
+            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 = nil
-               table_name = table_alias
+              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.to_sym]] = []
-                # TODO choose a right priciple
+                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('.')
@@ -113,6 +155,6 @@ module Tanuki
         end
       end
 
-  end # end MetaModelBehavior
+  end # MetaModelBehavior
 
-end # end Tanuki
+end # Tanuki

data/lib/tanuki/behavior/model_behavior.rb

@@ -105,7 +105,7 @@ module Tanuki
         mod.instance_variable_set(:@_relations, {})
       end
 
-    end # end ClassMethods
+    end # ClassMethods
 
     class << self
 
@@ -114,8 +114,8 @@ module Tanuki
         mod.extend ClassMethods
       end
 
-    end # end class << self
+    end # class << self
 
-  end # end ModelBehaviour
+  end # ModelBehaviour
 
-end # end Tanuki
+end # Tanuki

data/lib/tanuki/behavior/object_behavior.rb

@@ -27,6 +27,6 @@ module Tanuki
       super
     end
 
-  end # end BaseBehavior
+  end # BaseBehavior
 
-end # end Tanuki
+end # Tanuki

data/lib/tanuki/configurator.rb

@@ -49,6 +49,6 @@ module Tanuki
       Application.visitor(sym, &block)
     end
 
-  end # end Configurator
+  end # Configurator
 
-end # end Tanuki
+end # Tanuki

data/lib/tanuki/context.rb

@@ -46,16 +46,21 @@ module Tanuki
         defined = @_defined
         class << self; self; end.instance_eval do
           method_sym = match[1].to_sym
+
+          # Search cache, if method exists; add as necessary
           if defined.include? method_sym
             undef_method method_sym
           else
             defined[method_sym] = nil
           end
+
+          # Register value in context
           if arg.is_a? Proc
             define_method(method_sym, &arg)
           else
             define_method(method_sym) { arg }
           end
+
           return arg
         end if match[2]
         super
@@ -66,8 +71,8 @@ module Tanuki
         raise "contexts cannot be instantiated"
       end
 
-    end # end class << self
+    end # class << self
 
-  end # end Context
+  end # Context
 
-end # end Tanuki
+end # Tanuki

data/lib/tanuki/extensions/module.rb

@@ -1,5 +1,20 @@
 class Module
 
+  # Runs Tanuki::Loader for every missing constant in any namespace.
+  def const_missing(sym)
+    klass = "#{name + '::' if name != 'Object'}#{sym}"
+    paths = Dir.glob(Tanuki::Loader.combined_class_path(klass))
+    if paths.empty?
+      unless Dir.glob(Tanuki::Loader.combined_class_dir(klass)).empty?
+        return const_set(sym, Class.new)
+      end
+    else
+      paths.reverse_each {|path| require path }
+      return const_get(sym) if const_defined?(sym)
+    end
+    raise NameError, "uninitialized constant #{name}::#{sym}"
+  end
+
   # Creates a reader +sym+ and a writer +sym=+ for the instance variable @_sym.
   def internal_attr_accessor(*syms)
     internal_attr_reader(*syms)
@@ -24,4 +39,4 @@ class Module
     end
   end
 
-end # end Module
+end # Module

data/lib/tanuki/extensions/rack/builder.rb

@@ -22,5 +22,5 @@ module Rack
       end
     end
 
-  end # end
-end # end Rack
+  end #
+end # Rack

data/lib/tanuki/extensions/rack/server.rb

@@ -14,5 +14,5 @@ module Rack
 
     alias_method_chain :options, :tanuki
 
-  end # end
-end # end Rack
+  end #
+end # Rack

data/lib/tanuki/extensions/rack/static_dir.rb

@@ -14,5 +14,5 @@ module Rack
       @app.call(env)
     end
 
-  end # end
-end # end Rack
+  end #
+end # Rack

data/lib/tanuki/i18n.rb

@@ -30,6 +30,6 @@ module Tanuki
       ctx
     end
 
-  end # end I18n
+  end # I18n
 
-end # end Tanuki
+end # Tanuki

data/lib/tanuki/launcher.rb

@@ -16,6 +16,6 @@ module Tanuki
       @ctrl.default_view.call(proc {|out| block.call(out.to_s) }, @ctx)
     end
 
-  end # end Launcher
+  end # Launcher
 
-end # end Tanuki
+end # Tanuki

data/lib/tanuki/loader.rb

@@ -17,6 +17,12 @@ module Tanuki
         class_path(klass, @app_root ||= combined_app_root)
       end
 
+      # Returns the path to a directory containing class +klass+.
+      # Seatches across all common roots.
+      def combined_class_dir(klass)
+        const_to_path(klass, @app_root ||= combined_app_root)
+      end
+
       # Returns a glob pattern of all common roots.
       def combined_app_root
         local_app_root = File.expand_path(File.join('..', '..', '..', 'app'), __FILE__)
@@ -48,11 +54,15 @@ module Tanuki
           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')
+
+          # Find out if template refresh is required
           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
+
+          # Load template
           method_name = "#{sym}_view".to_sym
           owner.instance_eval do
             unless (method_exists = instance_methods(false).include? method_name) && no_refresh
@@ -60,8 +70,11 @@ module Tanuki
               load ct_path
             end
           end
+
+          # Register template in cache
           templates["#{owner}##{sym}"] = nil
           templates["#{obj.class}##{sym}"] = nil
+
           obj.send(method_name, *args, &block)
         else
           raise "undefined template `#{sym}' for #{obj.class}"
@@ -81,7 +94,11 @@ module Tanuki
       # (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
+
+        # Lock template source to avoid race condition
         st_file.flock(File::LOCK_EX)
+
+        # Compile, if template still needs compiling on lock release
         if !File.file?(ct_path) || File.mtime(ct_path) == ct_file_mtime
           no_refresh = false
           ct_dir = File.dirname(ct_path)
@@ -91,7 +108,10 @@ module Tanuki
           end
           FileUtils.mv(tmp_ct_path, ct_path)
         end
+
+        # Release lock
         st_file.flock(File::LOCK_UN)
+
         no_refresh
       end
 
@@ -102,7 +122,7 @@ module Tanuki
 
       # Transforms a given constant +klass+ to a path with a given +root+.
       def const_to_path(klass, root)
-        File.join(root, klass.to_s.split('_').map {|item| item.gsub(/(?!^)([A-Z])/, '_\1') }.join(File::SEPARATOR).downcase)
+        File.join(root, klass.to_s.split('::').map {|item| item.gsub(/(?!^)([A-Z])/, '_\1') }.join(File::SEPARATOR).downcase)
       end
 
       # Finds the direct template +method_name+ owner among ancestors of class +klass+.
@@ -115,8 +135,8 @@ module Tanuki
         [nil, nil]
       end
 
-    end # end class << self
+    end # class << self
 
-  end # end Path
+  end # Path
 
-end # end Tanuki
+end # Tanuki

data/lib/tanuki/model_generator.rb

@@ -0,0 +1,114 @@
+module Tanuki
+
+  # Tanuki::ModelGenerator is used for, well, generating models
+  class ModelGenerator
+
+    # A collection of all model definitions represented as hash of hashes where
+    # the first nesting level represents namespaces
+    # and the second one contains named model bodies +Hash+.
+    attr_reader :models
+
+    # +Hash+ for collecting the template render-time info for models.
+    # Keys in this hash are full qualified names of models (+namespace_model_name+).
+    # Values are hashes in the form of +{:generated => [], :failed => [], :skipped => []}+
+    # where all subentries correspond to template generation statuses.
+    attr_reader :tried
+
+    # Creates a model generator configured by given context +ctx+.
+    def initialize(ctx)
+      @ctx = ctx
+      @tried = {}
+      @models = {}
+    end
+
+    # Loads all models into memory from a given +schema_root+ and prepares
+    # their own properties to be rendered in class templates.
+    def read_models(schema_root)
+      Dir.entries(schema_root).reject {|path| path =~ /\A\.{1,2}\Z/ }.each do |namespace_path|
+        namespace_name = namespace_path.split('_').map {|s| s.capitalize }.join
+        namespace = @models[namespace_name] = {}
+        Dir.glob(File.join(schema_root, namespace_path, 'models', '*.yml')) do |file_path|
+          model_name = File.basename(file_path, '.yml').split('_').map {|s| s.capitalize }.join
+          meta_model = namespace[model_name] = Tanuki::MetaModel.new(
+            namespace_name,
+            model_name,
+            YAML.load_file(file_path),
+            @models
+          )
+          meta_model.process!
+          if @tried.include? namespace_model_name = "#{namespace_name}.#{model_name}"
+            next
+          else
+            @tried[namespace_model_name] = {:generated => [], :failed => [], :skipped => []}
+            @tried["#{namespace_model_name} (base)"] = {:generated => [], :failed => [], :skipped => []}
+          end
+        end
+      end
+    end
+
+    # Generates all models that were read from a given +schema_root+.
+    # Generation paths are determined by context given in the constructor.
+    def generate(schema_root)
+      read_models schema_root
+      process_models
+      generate_classes
+    end
+
+    # Renders a model class by applying +class_type+ template
+    # to a given +meta_model+. Classes are splitted in two parts:
+    # * user-extendable part (+base=false+), which resides in +ctx.app_root+,
+    # * other part with framework-specific code (+base=true+), which resides in +ctx.gen_root+.
+    # +namespace_model_name+ is used as a label for error report collection
+    # in Tanuki::ModelGenerator#tried hash.
+    def generate_class(meta_model, namespace_model_name, class_type, base)
+      class_name = meta_model.class_name_for class_type
+      namespace_model_name += ' (base)' if base
+      path = Tanuki::Loader.class_path(class_name, base ? @ctx.gen_root : @ctx.app_root)
+      if base || !(File.exists? path)
+        begin
+          dirname = File.dirname(path)
+          FileUtils.mkdir_p dirname unless File.directory? dirname
+          File.open path, 'w' do |file|
+            writer = proc {|out| file.print out.to_s }
+            Loader.run_template({}, meta_model, class_type).call(writer, @ctx)
+          end
+          @tried[namespace_model_name][:generated] << class_name
+        rescue
+          @tried[namespace_model_name][:failed] << class_name
+        end
+      else
+        @tried[namespace_model_name][:skipped] << class_name
+      end
+    end
+
+    # Iterates over all loaded model definitions and renders
+    # all available class templates for them.
+    def generate_classes
+      @models.each do |namespace_name, namespace |
+        namespace.each do |model_name, meta_model|
+          namespace_model_name = "#{namespace_name}.#{model_name}"
+          {
+            :model => false,
+            :model_base => true,
+            :manager => false,
+            :manager_base => true
+          }.each do |class_type, base|
+            generate_class meta_model, namespace_model_name, class_type, base
+          end
+        end
+      end
+    end
+
+    # Iterates over all loaded model definitions, giving them a chance to meet each other
+    # and make any cross-model assumptions (like names for foreign keys).
+    def process_models
+      @models.each do |namespace_name, namespace |
+        namespace.each do |model_name, meta_model|
+          meta_model.process_relations!
+        end
+      end
+    end
+
+  end # ModelGenerator
+
+end # Tanuki