amber 0.2.6 → 0.3.8

data/lib/amber/server.rb

@@ -15,8 +15,9 @@ module Amber
 
     def initialize(options)
       @site = options[:site]
+      @host = options[:host]
       @port = options[:port]
-      @server = WEBrick::HTTPServer.new :Port => @port, :BindAddress => '127.0.0.1', :DocumentRoot => @site.dest_dir
+      @server = WEBrick::HTTPServer.new :Port => @port, :BindAddress => @host, :DocumentRoot => @site.dest_dir
       @server.mount '/', StaticPageServlet, self
     end
 
@@ -30,6 +31,9 @@ module Amber
 
   class StaticPageServlet < WEBrick::HTTPServlet::FileHandler
 
+    RENDERABLE_ASSET_RE = /(#{Amber::Render::Asset::SOURCE_MAP.keys.join('|')})$/
+    ASSET_RE = /\.(jpg|jpeg|png|gif|webm|css|js|ico)$/
+
     def initialize(http_server, amber_server)
       @logger = http_server.logger
       @server = amber_server
@@ -37,77 +41,139 @@ module Amber
     end
 
     def do_GET(request, response)
-      dest_dir = @server.site.dest_dir
-
-      # add local prefix for all paths that don't have a file suffix
-      if request.path !~ /\.[a-z]{2,4}$/
-        locale = get_locale(request)
-        if !locale
-          location = "http://localhost:#{@server.port}/#{I18n.default_locale}#{request.path.sub(/\/$/,'')}"
-          @logger.info "Redirect %s ==> %s" % [request.path, location]
-          response.header['Location'] = location
-          response.status = 307
-          return
-        end
+      if path_needs_to_be_prefixed?(request.path)
+        redirect_with_prefix(request, response)
+        return
       end
 
-      if File.exists?(File.join(dest_dir, request.path))
-        @logger.info "Serve static file %s" % File.join(dest_dir, request.path)
+      path = strip_locale_and_prefix(request.path)
+
+      if renderable_asset?(path)
+        @logger.info "Rendering asset file %s" % asset_source_file(path)
+        render_asset(path, request, response)
         super(request, response)
+      elsif static_file_exists?(request.path)
+        @logger.info "Serve static file %s" % static_file_path(request.path)
+        super(request, response)
+      elsif static_file_exists?(path)
+        request = request.clone
+        request.instance_variable_set(:@path_info, "/"+path)
+        @logger.info "Serve static file with locale prefix %s" % static_file_path(path)
+        super(request, response)
+      elsif path !~ ASSET_RE
+        render_page(path, request, response)
       else
-        path = strip_locale(request.path)
-        @server.site.load_pages
-        page = @server.site.find_page_by_path(path)
-        if page
-          @logger.info "Serving Page %s" % page.path.join('/')
-          response.status = 200
-          response.content_type = "text/html; charset=utf-8"
-          # always refresh the page we are fetching
-          Amber::Render::Layout.reload
-          @server.site.render
-          page.render_to_file(dest_dir, :force => true)
-          file = page.destination_file(dest_dir, locale)
-          if File.exists?(file)
-            content = File.read(file)
-          else
-            file = page.destination_file(dest_dir, I18n.default_locale)
-            if File.exists?(file)
-              content = File.read(file)
-            else
-              view = Render::View.new(page, @server.site)
-              content = view.render(:text => "No file found at #{file}")
-            end
-          end
-          response.body = content
-        else
-          request = request.clone
-          request.instance_variable_set(:@path_info, "/" + strip_locale(request.path_info))
-          @logger.info "Serve static file %s" % File.join(dest_dir, request.path_info)
-          super(request, response)
-        end
+        super(request, response)
       end
     end
-    #rescue Exception => exc
-    #  @logger.error exc.to_s
-    #  @logger.error exc.backtrace
-    #  response.status = 500
-    #  response.content_type = 'text/text'
-    #  response.body = exc.to_s + "\n\n\n\n" + exc.backtrace
 
     private
 
-    def strip_locale(path)
-      path.sub(/^\/(#{Amber::POSSIBLE_LANGUAGE_CODES.join('|')})(\/|$)/, '').sub(/\/$/, '')
+    def strip_locale_and_prefix(path)
+      # The path comes to the server as URL escaped codes, that are then
+      # converty to ascii. But these codes might be utf-8 characters, so we force
+      # utf-8 encouding to allows non-ascii paths. I am not sure if always forcing
+      # will be a problem.
+      path = path.force_encoding('utf-8')
+      if @server.site.path_prefix
+        path = path.sub(%r{^/?#{Regexp.escape(@server.site.path_prefix)}}, '')
+      end
+      path.sub(%r{^/?(#{Amber::POSSIBLE_LANGUAGE_CODES.join('|')})(/|$)}, '').sub(%r{/$}, '')
     end
 
-    def get_locale(request)
-      match = /\/(#{Amber::POSSIBLE_LANGUAGE_CODES.join('|')})(\/|$)/.match(request.path)
+    def get_locale(path)
+      match = /\/(#{Amber::POSSIBLE_LANGUAGE_CODES.join('|')})(\/|$)/.match(path)
       if match.nil?
         nil
       else
         match[1]
       end
     end
-  end
 
+    def path_needs_to_be_prefixed?(path)
+      if @server.site.path_prefix
+        path !~ /\.[a-z]{2,4}$/ && (
+          path !~ %r{^/?#{Regexp.escape(@server.site.path_prefix)}} ||
+          get_locale(path).nil?
+        )
+      else
+        path !~ /\.[a-z]{2,4}$/ && get_locale(path).nil?
+      end
+    end
+
+    def redirect_with_prefix(request, response)
+      path = request.path.gsub(%r{^/|/$}, '')
+      location = ["http://localhost:#{@server.port}", @server.site.path_prefix, I18n.default_locale, path].compact.join('/')
+      @logger.info "Redirect %s ==> %s" % [request.path, location]
+      response.header['Location'] = location
+      response.status = 307
+    end
+
+    def dst_dir
+      @server.site.dest_dir
+    end
+
+    def src_dir
+      @server.site.pages_dir
+    end
+
+    def static_file_exists?(path)
+      File.file?(File.join(dst_dir, path))
+    end
+
+    def static_file_path(path)
+      File.join(dst_dir, path)
+    end
+
+    def render_page(path, request, response)
+      locale = get_locale(request.path)
+      @server.site.load_pages
+      page = @server.site.find_page_by_path(path, locale)
+      if page
+        @logger.info "Serving Page %s" % page.path.join('/')
+        response.status = 200
+        response.content_type = "text/html; charset=utf-8"
+        # always refresh the page we are fetching
+        Amber::Render::Layout.reload
+        @server.site.render
+        page.render_to_file(dst_dir, :force => true)
+        file = page.destination_file(dst_dir, locale)
+        if File.exists?(file)
+          content = File.read(file)
+        else
+          file = page.destination_file(dst_dir, I18n.default_locale)
+          if File.exists?(file)
+            content = File.read(file)
+          else
+            view = Render::View.new(page, @server.site)
+            content = view.render(:text => "No file found at #{file}")
+          end
+        end
+        response.body = content
+      end
+    end
+
+    def renderable_asset?(path)
+      path =~ RENDERABLE_ASSET_RE && asset_source_file(path)
+    end
+
+    def asset_source_file(path)
+      dest_suffix = File.extname(path)
+      base_path = path.sub(RENDERABLE_ASSET_RE, '')
+      Amber::Render::Asset::SOURCE_MAP[dest_suffix].each do |source_suffix|
+        source_file_path = File.join(src_dir, base_path + source_suffix)
+        if File.exists?(source_file_path)
+          return source_file_path
+        end
+      end
+      return nil
+    end
+
+    def render_asset(path, request, response)
+      src_file = asset_source_file(path)
+      dst_file = [dst_dir, path].join
+      Amber::Render::Asset.render(src_file, dst_file)
+    end
+
+  end
 end

data/lib/amber/site.rb

@@ -9,32 +9,39 @@ module Amber
     attr_accessor :root
     attr_accessor :continue_on_error
 
-    def_delegators :@config, :dest_dir, :locales, :default_locale
+    # @config is the primary SiteConfiguration
+    def_delegators :@config, :pages_dir, :dest_dir, :locales, :default_locale, :path_prefix
 
     def initialize(root_dir)
       @continue_on_error = true
       @config = SiteConfiguration.load(self, root_dir)
     end
 
+    def add_config(config)
+      @config.children << config
+    end
+
     def load_pages
       @root          = nil
-      @pages_by_path = {}
-      @pages_by_name = {}
+      @pages_by_path = {}  # hash of pages keyed by page path
+      @pages_by_name = {}  # hash of pages keyed by page name
       @page_list     = PageArray.new
-      @dir_list      = []
-      @config.mount_points.each do |mp|
-        add_mount_point(mp)
-        mp.reset_timestamp
-      end
-    end
+      @dir_list      = []  # an array of non-page directories
+      @page_paths    = []  # an array of page paths, used for greping through paths.
 
-    def reload_pages_if_needed
-      if @pages_by_path.nil? || @config.pages_changed?
-        puts "Reloading pages ................."
-        load_pages
-      end
+      # some paths are specific to only one locale (e.g aliases)
+      @pages_by_locale_path = POSSIBLE_LANGUAGES.keys.inject(Hash.new({})) {|h,locale| h[locale] = {}; h}
+
+      add_configuration(@config)
     end
 
+    #def reload_pages_if_needed
+    #  if @pages_by_path.nil? || @config.pages_changed?
+    #    puts "Reloading pages ................."
+    #    load_pages
+    #  end
+    #end
+
     def render
       @page_list.each do |page|
         page.render_to_file(@config.dest_dir)
@@ -46,6 +53,10 @@ module Amber
         Render::Asset.render_dir(src, dst)
         putc '.'; $stdout.flush
       end
+      if @config.short_paths
+        render_short_path_symlinks
+      end
+      Render::Apache.write_htaccess(@config, @config.pages_dir, @config.dest_dir)
       puts
     end
 
@@ -62,6 +73,13 @@ module Amber
       @config.dest_dir = dest_dir
     end
 
+    #
+    # find pages by a filter.
+    # filter is a string composing a path segment.
+    # For example:
+    #   "chat/security"
+    # Which would match "/services/chat/security" but not "/services/security"
+    #
     def find_pages(filter)
      filter = filter.downcase
      if filter =~ /\//
@@ -89,54 +107,100 @@ module Amber
       @page_list
     end
 
-    def find_page_by_path(path)
-      @pages_by_path[path]
+    def find_page_by_path(path, locale=I18n.default_locale)
+      if locale.is_a? String
+        if I18n.locale_available?(locale)
+          locale = locale.to_sym
+        end
+      end
+      if path.is_a? Array
+        path = path.join('/')
+      end
+      @pages_by_locale_path[locale][path] || @pages_by_path[path]
     end
 
     def find_page_by_name(name)
       @pages_by_name[name]
     end
 
+    #
+    # returns the shortest possible path for a page, such that the path doesn't collide with
+    # another page or another page's aliases.
+    #
+    def shortest_path(page)
+      path_so_far = []
+      page.path.reverse.each do |path_segment|
+        path_so_far.push(path_segment)
+        path_str = path_so_far.join('/')
+        if @pages_by_path[path_str].nil? && short_paths[path_str] == page
+          return path_so_far
+        end
+      end
+      return []
+    end
+
     private
 
-    def add_mount_point(mp)
+    def add_configuration(config)
+      config.reset_timestamp
+
       # create base_page
       base_page = begin
-        if mp.path == '/'
-          @root = StaticPage.new(nil, 'root', mp.pages_dir)
+        if config.path.nil?
+          @root = StaticPage.new(nil, 'root', config.pages_dir)
           add_page(@root)
           @root
         else
-          name = File.basename(mp.path)
-          page = StaticPage.new(find_parent(mp.path), name, mp.pages_dir)
+          name = File.basename(config.path)
+          page = StaticPage.new(find_parent(config.path), name, config.pages_dir, config.path_prefix)
           add_page(page)
           page
         end
       end
-      base_page.mount_point = mp
+      base_page.config = config
 
       # load menu and locals
-      I18n.load_path += Dir[File.join(mp.locales_dir, '/*.{rb,yml,yaml}')] if mp.locales_dir
+      I18n.load_path += Dir[File.join(config.locales_dir, '/*.{rb,yml,yaml}')] if config.locales_dir
 
       # add the full directory tree
       base_page.scan_directory_tree do |page, asset_dir|
         add_page(page) if page
         @dir_list << asset_dir if asset_dir
       end
-      @page_paths = @pages_by_path.keys
+      @page_paths += @pages_by_path.keys
+
+      # recursively add sub-sites
+      config.children.each do |sub_config|
+        add_configuration(sub_config)
+      end
     end
 
+    #
+    # registers a page with the site, indexing the page path in our various hashes
+    #
     def add_page(page)
       @pages_by_name[page.name] = page
       @pages_by_path[page.path.join('/')] = page
-      page.aliases.each do |alias_path|
-        if @pages_by_path[alias_path]
-          Amber.logger.warn "WARNING: page `#{page.path.join('/')}` has alias `#{alias_path}`, but this path is already taken"
+      add_aliases(I18n.default_locale, page, @pages_by_path)
+      page.locales.each do |locale|
+        next if locale == I18n.default_locale
+        add_aliases(locale, page, @pages_by_locale_path[locale])
+      end
+      @page_list << page
+    end
+
+    #
+    # registers a page's aliases with the site
+    #
+    def add_aliases(locale, page, path_hash)
+      page.aliases(locale).each do |alias_path|
+        alias_path_str = alias_path.join('/')
+        if path_hash[alias_path_str]
+          Amber.logger.warn "WARNING: page `#{page.path.join('/')}` has alias `#{alias_path_str}`, but this path is already taken by `#{path_hash[alias_path_str].path.join('/')}` (locale = #{locale})."
         else
-          @pages_by_path[alias_path] = page
+          path_hash[alias_path_str] = page
         end
       end
-      @page_list << page
     end
 
     def find_parent(path)
@@ -150,5 +214,83 @@ module Amber
       return @root
     end
 
+    #
+    # adds symlinks for all possible 'short paths' for every page.
+    # this works by:
+    # (1) examine all pages in order of longest path depth and assign 'short paths' for each page.
+    # (2) examine all short paths in order of shortest path depth and create symlinks
+    #
+    def render_short_path_symlinks
+      short_paths.each do |path, page|
+        page.link_page_aliases(@config.dest_dir, [path])
+      end
+    end
+
+    #
+    # returns a hash containing all the automatically determined shortest paths for every page.
+    # the data structure looks like so:
+    #
+    # {
+    #   "ddd" => <page 'bbb/ddd'>,
+    #   "ccc" => <page 'bbb/ccc'>,
+    #   "red" => <page 'autoalias/red'>,
+    #   "blue"=> <page 'autoalias/blue'>,
+    #   "red/blue" => <page 'autoalias/red/blue'>
+    # }
+    #
+    # short_paths does not include the normal paths or normal aliases, just the automatic short path aliases.
+    #
+    def short_paths
+      @short_paths ||= begin
+        hash = {}
+        pages_in_path_depth_order.each do |record|
+          page = record[:page]
+          path = record[:path]
+          next if path.length == 1
+          path_prefix = path.dup
+          path.length.times do |depth|
+            path_prefix.shift
+            path_str = path_prefix.join('/')
+            if @pages_by_path[path_str].nil? && hash[path_str].nil?
+              hash[path_str] = page
+            end
+          end
+        end
+        # debug:
+        #hash.each do |path, record|
+        #  puts "#{record[:page].path.join('/')} => #{record[:path].join('/')}"
+        #end
+        hash
+      end
+    end
+
+    #
+    # Returns an array like this:
+    #
+    #   [
+    #     {:page => <page1>, :path => ['a', 'page1']},
+    #     {:page => <page2>, :path => ['a','b', 'page2']},
+    #   ]
+    #
+    # This array is sorted by the depth of the path (shortest first)
+    # Pages will appear multiple times (once for each path, including aliases)
+    #
+    def pages_in_path_depth_order
+      paths = {}
+      @page_list.each do |page|
+        paths[page.path] ||= page
+        locales = page.locales
+        locales << I18n.default_locale unless locales.include? I18n.default_locale
+        locales.each do |locale|
+          page.aliases(locale).each do |alias_path|
+            paths[alias_path] ||= page
+          end
+        end
+      end
+      paths.collect{|path, page| {page:page, path:path}}.sort{|a,b|
+        a[:path].length <=> a[:path].length
+      }
+    end
+
   end
 end