tanuki 0.3.1 → 0.4.0

data/lib/tanuki/css_compressor.rb

@@ -0,0 +1,50 @@
+module Tanuki
+
+  # Tanuki::CssCompressor takes a CSS source and makes it shorter,
+  # trying not to break the semantics.
+  class CssCompressor
+
+    class << self
+
+      # Compresses CSS source in +css+.
+      def compress(css)
+        @css = css
+        compress_structure
+        compress_colors
+        compress_dimensions
+        @css
+      end
+
+      private
+
+      # Compresses the CSS structure in +@css+.
+      def compress_structure
+        @css.gsub!(%r{/\*.*\*/}, '')
+        @css.strip!.gsub!(/\s*(\s|;|:|}|{|\)|\(|,)\s*/, '\1')
+        @css.gsub!(/[;]+/, ';')
+        @css.gsub!(';}', '}')
+      end
+
+      # Compresses CSS color values in +@css+.
+      def compress_colors
+        @css.gsub! /rgb\((\d{1,3}),(\d{1,3}),(\d{1,3})\)/ do
+          r = $~[1].to_i.to_s(16).rjust(2, '0')
+          g = $~[2].to_i.to_s(16).rjust(2, '0')
+          b = $~[3].to_i.to_s(16).rjust(2, '0')
+          "##{r}#{g}#{b}"
+        end
+        @css.gsub!(/#([0-9a-f])\1([0-9a-f])\2([0-9a-f])\3/, '#\1\2\3')
+      end
+
+      # Compresses CSS dimension values in +@css+.
+      def compress_dimensions
+        @css.gsub!(/(?<=[\s:])0(?:%|cm|em|ex|in|mm|pc|pt|px)/, '0')
+        @css.gsub!(/(?<=[\s:])([0-9]+[a-z]*)\s+\1\s+\1\s+\1/, '\1')
+        @css.gsub!(/(?<=[\s:])(\d+[a-z]*)\s+(\d+[a-z]*)\s+\1\s+\2/, '\1 \2')
+      end
+
+    end
+
+  end # CssCompressor
+
+end # Tanuki

data/lib/tanuki/extensions/module.rb

@@ -1,21 +1,37 @@
 class Module
 
   # Runs Tanuki::Loader for every missing constant in any namespace.
-  def const_missing(sym)
-    klass = "#{name + '::' if name != 'Object'}#{sym}"
+  def const_missing_with_balls(sym)
+    klass = "#{name + '::' unless name.nil? || (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)
+        return const_set(sym, Module.new)
       end
     else
       paths.reverse_each {|path| require path }
       return const_get(sym) if const_defined?(sym)
     end
-    raise NameError, "uninitialized constant #{name}::#{sym}"
+    const_missing_without_balls(sym)
   end
+  alias_method_chain :const_missing, :balls
 
-  # Creates a reader +sym+ and a writer +sym=+ for the instance variable @_sym.
+  # Sets the named constant to the given object, returning that object.
+  # Creates new constants and modules recursively if no constant with the
+  # given name and nesting previously existed.
+  def const_set_recursive(sym, obj)
+    sym.to_s.split('::').inject(self) do |klass, const|
+      if const_defined? const.to_sym
+        const = const_get(const)
+      else
+        const = const_set(const, Module.new)
+      end
+      const
+    end
+  end
+
+  # 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)

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

@@ -0,0 +1,35 @@
+require 'digest'
+
+module Rack
+  class FrozenRoute
+
+    # Creates a new +route+ (defined by a regular expression)
+    # that yields the same +body+ throughout the whole life of the
+    # application.
+    def initialize(app, route, content_type, body)
+      @app = app
+      @route = route
+      @headers = {
+        'Content-Type' => content_type,
+        'ETag'         => Digest::MD5.hexdigest(body)
+      }
+      @body = body.freeze
+    end
+
+    # Returns the defined +body+ if the route is matched.
+    def call(env)
+      if env['PATH_INFO'] =~ @route
+        if @headers['ETag'] == env['HTTP_IF_NONE_MATCH']
+          status = 304
+          body = []
+        else
+          status = 200
+          body = @body
+        end
+        return [status, @headers, body]
+      end
+      @app.call(env)
+    end
+
+  end # FrozenRoute
+end # Rack

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

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

data/lib/tanuki/extensions/sequel/model.rb

@@ -0,0 +1,7 @@
+class Sequel::Model
+  include Tanuki::BaseBehavior
+
+  def self.fetcher(controller_class)
+    @_tanuki_fetcher ||= Tanuki::Fetcher::Sequel.new(self, controller_class)
+  end
+end

data/lib/tanuki/i18n.rb

@@ -1,9 +1,7 @@
 module Tanuki
 
   # Tanuki::I18n is a drop-in controller for localizable applications.
-  class I18n
-
-    include ControllerBehavior
+  class I18n < Controller
 
     # Adds language routes of root controller class when invoked.
     def configure
@@ -15,12 +13,16 @@ module Tanuki
     # Returns default route according to default language.
     def default_route
       raise 'default language is not configured' unless @_ctx.language
-      {:route => @_ctx.language, :args => {}, :redirect => @_ctx.i18n_redirect}
+      {
+        :route    => @_ctx.language,
+        :args     => {},
+        :redirect => @_ctx.i18n_redirect
+      }
     end
 
     # Calls default view of visual child.
-    def default_view
-      @_visual_child.default_view
+    def view
+      @_visual_child.view
     end
 
     # Adds child controller language to its context.

data/lib/tanuki/loader.rb

@@ -1,6 +1,9 @@
+require 'stringio'
+
 module Tanuki
 
-  # Tanuki::Loader deals with framework paths resolving, and object and template loading.
+  # Tanuki::Loader deals with framework paths resolving,
+  # and object and template loading.
   class Loader
 
     class << self
@@ -8,27 +11,43 @@ module Tanuki
       # 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')
+        File.join(path, path.match(%r{/([^/]*)$})[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)
+        class_path(klass, @app_root ||= combined_app_root_glob)
       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)
+        const_to_path(klass, @app_root ||= combined_app_root_glob)
+      end
+
+      # Returns an array with all common roots.
+      def combined_app_root(include_gen_root=true)
+        local_app_root = File.expand_path('../../../app', __FILE__)
+        app_root = [@ctx_app_root ||= @context.app_root]
+        app_root << @context.gen_root if include_gen_root
+        app_root << local_app_root if local_app_root != @ctx_app_root
+        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 << '}'
+      def combined_app_root_glob(include_gen_root=true)
+        "{#{combined_app_root(include_gen_root).join(',')}}"
+      end
+
+      # Returns a regexp pattern of all common roots.
+      def combined_app_root_regexp(include_gen_root=true)
+        regexp_root = '^('
+        regexp_root << combined_app_root(include_gen_root).map do |dir|
+          Regexp.escape(dir)
+        end.join('|')
+        regexp_root << ')/?'
+        Regexp.new(regexp_root)
       end
 
       # Assigns a context to Tanuki::Loader.
@@ -37,18 +56,21 @@ module Tanuki
         @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+ with optional +args+ and +block+ from object +obj+.
+      # Loads template +sym+.
       #
       # 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)
-        owner, st_path = *template_owner(obj.class, sym)
+      # * Template source modification time is older than
+      #   compiled template modification time,
+      # * Tanuki::TemplateCompiler source modification time is older than
+      #   compiled template modification time.
+      def load_template(templates, obj, sym)
+        owner, st_path = *resource_owner(obj.class, sym)
         if st_path
           ct_path = compiled_template_path(owner, sym)
           ct_file_exists = File.file?(ct_path)
@@ -56,16 +78,21 @@ module Tanuki
           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)
+          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
+          method_name = (sym == 'view' ? sym : "#{sym}_view").to_sym
           owner.instance_eval do
-            unless (method_exists = instance_methods(false).include? method_name) && no_refresh
+            method_exists = instance_methods(false).include?(method_name)
+            unless method_exists && no_refresh
               remove_method method_name if method_exists
               load ct_path
             end
@@ -75,23 +102,121 @@ module Tanuki
           templates["#{owner}##{sym}"] = nil
           templates["#{obj.class}##{sym}"] = nil
 
-          obj.send(method_name, *args, &block)
+          method_name
         else
           raise "undefined template `#{sym}' for #{obj.class}"
         end
       end
 
+      def load_template_files(ctx, template_signature)
+        klass_name, method = *template_signature.split('#')
+        klass = klass_name.constantize
+        method = method.to_sym
+        _, path = *resource_owner(klass, method, JAVASCRIPT_EXT)
+        ctx.javascripts[path] = false if path
+        ctx.resources[template_signature] = nil
+      end
+
+      # Writes the compiled CSS file to disk
+      # and refreshes with a given +interval+ in seconds.
+      def refresh_css(interval=5)
+        return if @next_reload && @next_reload > Time.new
+        mode = File::RDWR|File::CREAT
+        File.open("#{@context.public_root}/bundle.css", mode) do |f|
+          f.flock(File::LOCK_EX) # Avoid race condition
+          now = Time.new
+          if !@next_reload || @next_reload < now
+            @next_reload = now + interval
+            @ctx_app_root ||= @context.app_root
+            f.rewind
+            compile_css(f, true)
+            f.flush.truncate(f.pos)
+          end # if
+        end # open
+      end
+
+      # Prepares the application for production mode. This includes:
+      # * precompiling all templates into memory,
+      # * and prebuilding static file like the CSS bundle.
+      def prepare_for_production
+        root_glob = combined_app_root_glob(false)
+        root_re = combined_app_root_regexp(false)
+
+        # Load application modules
+        path_re = /#{root_re}(?<path>.*)/
+        Dir.glob(File.join(root_glob, "**/*")) do |file|
+          if File.directory? file
+            file.match(path_re) do |m|
+              mod = File.join(file, File.basename(file)) << '.rb'
+              if File.file? mod
+                require mod
+              else
+                Object.const_set_recursive(m[:path].camelize, Module.new)
+              end
+            end # match
+          end # if
+        end
+
+        # Load templates
+        file_re = /#{root_re}(?<path>.*)\/.*\.(?<template>.*)\./
+        Dir.glob(File.join(root_glob, "**/*#{TEMPLATE_EXT}")) do |file|
+          file.match(file_re) do |m|
+            ios = StringIO.new
+            TemplateCompiler.compile_template(
+              ios, File.read(file), m[:path].camelize, m[:template], false
+            )
+            m[:path].camelize.constantize.class_eval(ios.string)
+          end # match
+        end # glob
+
+        # Load CSS
+        css = CssCompressor.compress(compile_css(StringIO.new).string)
+        Application.use(Rack::FrozenRoute, %r{/bundle.css}, 'text/css', css)
+        Application.pull_down(Rack::StaticDir)
+      end
+
+      # Runs template +sym+ with optional +args+ and +block+
+      # from object +obj+.
+      def run_template(templates, obj, sym, *args, &block)
+        method_name = load_template(templates, obj, sym)
+        obj.send(method_name, *args, &block)
+      end
+
       private
 
       # Path to Tanuki::TemplateCompiler for internal use.
-      COMPILER_PATH = File.expand_path(File.join('..', 'template_compiler.rb'), __FILE__)
+      COMPILER_PATH = File.expand_path(
+        '../template_compiler.rb',
+        __FILE__
+      ).freeze
 
       # Extension glob for template files.
-      TEMPLATE_EXT = '.t{html,txt}'
+      TEMPLATE_EXT = '.t{html,txt}'.freeze
+
+      # Extension glob for JavaScript files.
+      JAVASCRIPT_EXT = '.js'.freeze
+
+      # Extension glob for CSS files.
+      STYLESHEET_EXT = '.css'.freeze
+
+      # Compiles all application stylesheets into +ios+.
+      # Add path headers for each chunk of CSS if +mark_source+ is true.
+      def compile_css(ios, mark_source=false)
+        header = "/*** %s ***/\n"
+        Dir.glob("#{@ctx_app_root}/**/*#{STYLESHEET_EXT}") do |file|
+          if File.file? file
+            ios << header % file.sub("#{@ctx_app_root}/", '') if mark_source
+            ios << File.read(file) << "\n"
+          end
+        end
+        ios
+      end
 
-      # 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.
+      # 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
 
@@ -104,7 +229,9 @@ module Tanuki
           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)
+            TemplateCompiler.compile_template(
+              ct_file, st_file.read, owner, sym
+            )
           end
           FileUtils.mv(tmp_ct_path, ct_path)
         end
@@ -115,21 +242,27 @@ 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.gen_root), method_name.to_s << '.tpl.rb')
+        path = const_to_path(klass, @context.gen_root)
+        "#{path}/#{method_name.to_s << '.tpl.rb'}"
       end
 
       # 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)
+        path = klass.to_s.split('::').map(&:underscore).join('/').downcase
+        "#{root}/#{path}"
       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
+      # Finds the direct template +method_name+ owner
+      # among ancestors of class +klass+.
+      def resource_owner(klass, method_name, extension=TEMPLATE_EXT)
         klass.ancestors.each do |ancestor|
-          files = Dir.glob(File.join(const_to_path(ancestor, @app_root ||= combined_app_root), method_file))
+          path = const_to_path(ancestor, @app_root ||= combined_app_root_glob)
+          method_file = ancestor.to_s.split('::')[-1].underscore.downcase
+          method_file << '.' << method_name.to_s << extension
+          files = Dir["#{path}/#{method_file}"]
           return ancestor, files[0] unless files.empty?
         end
         [nil, nil]