tanuki 0.1.3 → 0.2.1

data/lib/tanuki/configurator.rb

@@ -4,90 +4,53 @@ module Tanuki
   # Use Tanuki::development_application and Tanuki::production_application to create such a block.
   class Configurator
 
-    class << self
-
-      private
-
-      # Invokes Tanuki::Argument.store.
-      def argument(klass, arg_class)
-        Argument.store(klass, arg_class)
-      end
-
-      # Invokes Tanuki::Application.set.
-      def set(option, value)
-        Application.set(option, value)
-      end
-
-      # Invokes Tanuki::Application.use.
-      def use(middleware, *args, &block)
-        Application.use(middleware, *args, &block)
-      end
-
-      # Invokes Tanuki::Application.discard.
-      def discard(middleware)
-        Application.discard(middleware)
-      end
-
-      # Invokes Tanuki::Application.visitor.
-      def visitor(sym, &block)
-        Application.visitor(sym, &block)
-      end
+    # Configuration root.
+    attr_writer :config_root
+
+    # Creates a new configurator in context +ctx+ and +root+ directory.
+    # Configuration root +config_root+ defaults to _config_ directory in +root+.
+    def initialize(ctx, root, config_root=nil)
+      @context = ctx
+      set :root, root ? root : Dir.pwd
+      @config_root = config_root ? config_root : File.join(@context.root, 'config')
+    end
 
-    end # end class << self
+    # Loads and executes a given configuraion file with symbolic name +config+.
+    # If +silent+ is +true+, exception is not raised on missing file.
+    def load_config(config, silent=false)
+      file = File.join(@config_root, config.to_s) << '.rb'
+      return if silent && !(File.file? file)
+      instance_eval File.read(file)
+      true
+    end
 
-  end # end Configurator
+    private
 
-  # Creates default configuration for development environments.
-  def self.development_application(&block)
-    Application.set :development, true
-    Application.instance_eval do
-      use Rack::CommonLogger
-      use Rack::Lint
-      use Rack::Reloader, 0
-      use Rack::ShowExceptions
+    # Invokes Tanuki::Argument::store.
+    def argument(klass, arg_class)
+      Argument.store(klass, arg_class)
     end
-    common_application(&block)
-  end
 
-  # Creates default configuration for production environments.
-  def self.production_application(&block)
-    Application.set :development, false
-    common_application(&block)
-  end
+    # Sets an +option+ to +value+ in the current context.
+    def set(option, value)
+      @context.send("#{option}=".to_sym, value)
+    end
 
-  private
+    # Invokes Tanuki::Application::use.
+    def use(middleware, *args, &block)
+      Application.use(middleware, *args, &block)
+    end
 
-  # Creates default configuration for common environments.
-  def self.common_application(&block)
-    Application.instance_eval do
-      use Rack::Head
-      use Rack::ShowStatus
-      set :server, [:thin, :mongrel, :webrick]
-      set :host, '0.0.0.0'
-      set :port, 3000
-      set :root, File.expand_path('..', $0)
-      set :app_root, proc { File.join(root, 'app') }
-      set :cache_root, proc { File.join(root, 'cache') }
-      set :schema_root, proc { File.join(root, 'schema') }
-      set :root_page, ::User_Page_Index
-      set :missing_page, ::Tanuki_Page_Missing
-      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 }
-      visitor :string do s = ''; proc {|out| s << out.to_s } end
+    # Invokes Tanuki::Application::discard.
+    def discard(middleware)
+      Application.discard(middleware)
     end
-    Argument.instance_eval do
-      store Fixnum, Argument::Integer
-      store Bignum, Argument::Integer
-      store Range, Argument::IntegerRange
-      store String, Argument::String
+
+    # Invokes Tanuki::Application::visitor.
+    def visitor(sym, &block)
+      Application.visitor(sym, &block)
     end
-    Application.instance_eval { @context = @context.child }
-    Configurator.instance_eval(&block) if block_given?
-    Application.run
-  end
+
+  end # end Configurator
 
 end # end Tanuki

data/lib/tanuki/context.rb

@@ -1,36 +1,48 @@
 module Tanuki
 
   # Tanuki::Context is used to create unique environments for each request.
-  # Once a context variable has been set, it cannot be redefined.
-  # Child contexts are used to override parent context variables without changing them directly.
-  # Use Tanuki::Context#child to create new contexts.
+  # Child contexts inherit parent context entries and can override them without modifying the parent context.
+  # Use Tanuki::Context::child to create new contexts.
   class Context
 
-    # Create and return child context.
-    def child
-      Class.new(self.class).new
+    @_defined = {}
+
+    # Creates and returns child context object.
+    # This object's superclass is going to be current context class.
+    def self.child
+      child = Class.new(self)
+      child.instance_variable_set(:@_defined, {})
+      child
     end
 
-    # Kernel#method_missing hook.
-    def method_missing(sym, arg=nil)
-      match = sym.to_s.match(/^([^=]+)(=)?$/)
-      self.class.instance_eval do
+    # Allowes arbitary values to be assigned to context with a +key=+ method.
+    # A reader in context object class is created for each assigned value.
+    def self.method_missing(sym, arg=nil)
+      match = sym.to_s.match(/\A(?!(?:child|method_missing)=\Z)([^=]+)(=)?\Z/)
+      raise "`#{sym}' method cannot be called for Context and its descendants" unless match
+      defined = @_defined
+      class << self; self; end.instance_eval do
         method_sym = match[1].to_sym
-        unless instance_methods(false).include? method_sym
-          if arg.is_a? Proc
-            define_method(method_sym, &arg)
-          else
-            define_method(method_sym) { arg }
-          end
-          return arg
+        if defined.include? method_sym
+          undef_method method_sym
+        else
+          defined[method_sym] = nil
+        end
+        if arg.is_a? Proc
+          define_method(method_sym, &arg)
         else
-          raise "context entry `#{match[1]}' redefined, use Context#child"
+          define_method(method_sym) { arg }
         end
+        return arg
       end if match[2]
-      warn "#{__FILE__}:#{__LINE__}: warning: undefined context entry `#{sym}' for #{self}"
       super
     end
 
+    # Disallow context instantiation
+    def self.new
+      raise "contexts cannot be instantiated"
+    end
+
   end # end Context
 
 end # end Tanuki

data/lib/tanuki/{module_extensions.rb → extensions/module.rb}

@@ -1,12 +1,12 @@
 class Module
 
-  # Creates a reader +sym+ and a writer +sym=+ for the instance variable +@_sym+.
+  # 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+.
+  # Creates a reader +sym+ for the instance variable @_sym.
   def internal_attr_reader(*syms)
     syms.each do |sym|
       ivar = "@_#{sym}".to_sym
@@ -15,7 +15,7 @@ class Module
     end
   end
 
-  # Creates a writer +sym=+ for the instance variable +@_sym+.
+  # Creates a writer +sym=+ for the instance variable @_sym.
   def internal_attr_writer(*syms)
     syms.each do |sym|
       ivar = "@_#{sym}".to_sym

data/lib/tanuki/extensions/object.rb

@@ -0,0 +1,12 @@
+class Object
+
+  # Runs Tanuki::Loader for every missing constant in main namespace.
+  def self.const_missing(sym)
+    unless (paths = Dir.glob(Tanuki::Loader.combined_class_path(sym))).empty?
+      paths.reverse_each {|path| require path }
+      return const_get(sym)
+    end
+    super
+  end
+
+end # end Object

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

@@ -0,0 +1,18 @@
+module Rack
+  class StaticDir
+
+    # Initializes a +Rack::File+ server at +root+ or +Dir.pwd+.
+    def initialize(app, root=nil)
+      @app = app
+      @file_server = Rack::File.new(root || Dir.pwd)
+    end
+
+    # Returns file contents, if requested file exists.
+    def call(env)
+      result = @file_server.call(env)
+      return result if result[0] == 200
+      @app.call(env)
+    end
+
+  end # end
+end # end Rack

data/lib/tanuki/i18n.rb

@@ -7,12 +7,14 @@ module Tanuki
 
     # Adds language routes of root controller class when invoked.
     def configure
+      raise 'languages are not configured' if @_ctx.languages.size == 0
       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
+      raise 'default language is not configured' unless @_ctx.language
       {:route => @_ctx.language.to_s, :args => {}}
     end
 
@@ -21,7 +23,7 @@ module Tanuki
       @_visual_child.default_view
     end
 
-    # Adds child language to its context.
+    # Adds child controller language to its context.
     def process_child_context(ctx, route)
       ctx = ctx.child
       ctx.language = route.to_sym

data/lib/tanuki/launcher.rb

@@ -2,15 +2,16 @@ module Tanuki
 
   # Tanuki::Launcher is called on every request.
   # It is used to build output starting with the default view of the root controller.
+  # Rack iterates over an instance of this object on every request.
   class Launcher
 
-    # Creates a new Tanuki::Launcher with root controller ctrl in context ctx.
+    # 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.
+    # 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

data/lib/tanuki/loader.rb

@@ -5,30 +5,46 @@ module Tanuki
 
     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)
+      # Returns the path to a source file in +root+ containing class +klass+.
+      def class_path(klass, root)
+        path = const_to_path(klass, root)
         File.join(path, path.match("#{File::SEPARATOR}([^#{File::SEPARATOR}]*)$")[1] << '.rb')
       end
 
+      # Returns the path to a source file containing class +klass+.
+      # Seatches across all common roots.
+      def combined_class_path(klass)
+        class_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__)
+        app_root = "{#{context_app_root = @context.app_root},#{@context.gen_root}"
+        app_root << ",#{local_app_root}" if local_app_root != context_app_root
+        app_root << '}'
+      end
+
+      # Assigns a context to Tanuki::Loader.
+      # This context should have common framework paths defined in it.
       def context=(ctx)
         @context = ctx
       end
 
-      # Checks if templates contain a compiled template sym for class klass
+      # 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.
+      # Runs template +sym+ with optional +args+ and +block+ from object +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)
+        owner, st_path = *template_owner(obj.class, sym)
         if st_path
-          owner = template_owner(obj.class, sym)
-          ct_path = compiled_template_path(obj.class, sym)
+          ct_path = compiled_template_path(owner, 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')
@@ -55,14 +71,14 @@ module Tanuki
       private
 
       # Path to Tanuki::TemplateCompiler for internal use.
-      COMPILER_PATH = File.join(File.expand_path('..', __FILE__), 'template_compiler.rb')
+      COMPILER_PATH = File.expand_path(File.join('..', 'template_compiler.rb'), __FILE__)
 
       # Extension glob for template files.
       TEMPLATE_EXT = '.t{html,txt}'
 
-      # Compiles template sym from owner class using source in st_file to ct_path.
+      # 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.
+      # (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)
@@ -79,53 +95,28 @@ module Tanuki
         no_refresh
       end
 
-      # Returns the path to a compiled template file containing template method_name for class klass.
+      # 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)
+        File.join(const_to_path(klass, @context.gen_root), method_name.to_s << '.tpl.rb')
       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)
+      # 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)
       end
 
-      # Finds the direct template method_name owner among ancestors of class klass.
+      # 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]
+          files = Dir.glob(File.join(const_to_path(ancestor, @app_root ||= combined_app_root), method_file))
+          return ancestor, files[0] unless files.empty?
         end
-        nil
+        [nil, 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
+end # end Tanuki

data/lib/tanuki/template_compiler.rb

@@ -5,7 +5,7 @@ module Tanuki
 
     class << self
 
-      # Compiles a template from a given src string to ios for method sym in class klass.
+      # Compiles a template from a given +src+ string to +ios+ for method +sym+ in class +klass+.
       def compile_template(ios, src, klass, sym)
         ios << "# encoding: #{src.encoding}\nclass #{klass}\ndef #{sym}_view(*args,&block)\nproc do|_,ctx|\n" \
           "if _has_tpl ctx,self.class,:#{sym}\nctx=_ctx(ctx)"
@@ -14,7 +14,7 @@ module Tanuki
         ios << "\nelse\n(_run_tpl ctx,self,:#{sym},*args,&block).call(_,ctx)\nend\nend\nend\nend"
       end
 
-      # Compiles code from a given src string to ios.
+      # Compiles code from a given +src+ string to +ios+.
       def compile(ios, src)
         state = :outer
         last_state = nil
@@ -68,9 +68,10 @@ module Tanuki
       # Scanner states that output the evaluated result.
       PRINT_STATES = [:outer, :code_print]
 
+      # Generates code for Ruby template bits from a given +src+ to +ios+ for a given +state+.
       def process_code_state(ios, src, state)
         src.strip!
-        src.gsub! /^[ \t]+/, ''
+        src.gsub!(/^[ \t]+/, '')
         case state
         when :code_line, :code_span then
           ios << "\n#{src}"
@@ -79,14 +80,14 @@ module Tanuki
         when :code_template then
           ios << "\n(#{src}).call(_,ctx)"
         when :code_visitor
-          inner_m = src.match /^([^ \(]+)?(\([^\)]*\))?\s*(.*)$/
+          inner_m = src.match(/^([^ \(]+)?(\([^\)]*\))?\s*(.*)$/)
           ios << "\n#{inner_m[1]}_result=(#{inner_m[3]}).call(#{inner_m[1]}_visitor#{inner_m[2]},ctx)"
         when :l10n then
           localize(ios, src)
         end
       end
 
-      # Returns the next expected pattern for a given state.
+      # Returns the next expected pattern for a given +state+.
       def expect_pattern(state)
         case state
         when :outer then %r{^\s*%%?|<%[=!_#%]?|<l10n>}
@@ -96,7 +97,7 @@ module Tanuki
         end
       end
 
-      # Returns the next state for a given match and current state.
+      # Returns the next state for a given +match+ and a given +state+.
       def next_state(state, match)
         case state
         when :outer then
@@ -121,7 +122,7 @@ module Tanuki
         end
       end
 
-      # Generates localization code from src.
+      # Generates localization code from +src+ to +ios+.
       def localize(ios, src)
         index = 0
         lngs = []

data/lib/tanuki/version.rb

@@ -1,6 +1,6 @@
 module Tanuki
 
   # Tanuki framework version.
-  VERSION = '0.1.3'
+  VERSION = '0.2.1'
 
 end # end Tanuki

data/lib/tanuki.rb

@@ -1,22 +1,28 @@
-module Tanuki
-  libdir = File.dirname(__FILE__)
-  $:.unshift(libdir) unless $:.include?(libdir)
-end
+libdir = File.dirname(__FILE__)
+$:.unshift(libdir) unless $:.include?(libdir)
 
 require 'rack'
 require 'fileutils'
+require 'sequel'
 require 'yaml'
 require 'escape_utils'
 require 'escape_utils/url/rack'
 require 'tanuki/version'
-require 'tanuki/module_extensions'
+require 'tanuki/extensions/module'
+require 'tanuki/extensions/object'
+require 'tanuki/extensions/rack/static_dir'
+require 'tanuki/behavior/controller_behavior'
+require 'tanuki/behavior/meta_model_behavior'
+require 'tanuki/behavior/model_behavior'
+require 'tanuki/behavior/object_behavior'
 require 'tanuki/argument'
 require 'tanuki/configurator'
 require 'tanuki/context'
-require 'tanuki/controller_behavior'
 require 'tanuki/launcher'
 require 'tanuki/loader'
 require 'tanuki/i18n'
-require 'tanuki/object_behavior'
 require 'tanuki/template_compiler'
-require 'tanuki/application'
+require 'tanuki/application'
+
+module Tanuki
+end

data/schema/tanuki/models/controller.yml

@@ -3,9 +3,8 @@ namespaces:
     default: Tanuki
 source:
     table: tanuki_controllers
-    alias: tc
-key: tc.class
-to_s: tc.title
+key: class
+to_s: title
 attributes:
     class: { type: String, size: 80, required: true }
     title: { type: String, required: true }

data/schema/tanuki/models/page.yml

@@ -3,13 +3,12 @@ namespaces:
     default: Tanuki
 source:
     table: tanuki_pages
-    alias: tp
-key: tp.id
-to_s: [tp.long_title, tp.title]
+key: id
+to_s: [long_title, title]
 order:
     by:
-        tp.parent_id: asc
-        tp.order: asc
+        parent_id: asc
+        order: asc
     reorder: tp.order
 attributes:
     parent: { type: Object, required: true }
@@ -28,9 +27,9 @@ relations:
         type: one-to-many
         inverse: children
         join:
-            alias: tpp
+            alias: tp
             on:
-                tpp.id: tp.parent_id
+                tp.id: parent_id
     controller:
         class: Controller
         type: one-to-many
@@ -38,7 +37,7 @@ relations:
         join:
             alias: tc
             on:
-                tc.id: tp.parent_id
+                tc.id: parent_id
 list:
     parent: ~
     title: { link: true }