amber 0.2.6

data/lib/amber/render/view.rb

@@ -0,0 +1,189 @@
+#
+# All pages and layouts are evaluated in the context of a View object.
+#
+# Any methods you want to make available to these templates should be added to this class.
+#
+
+require 'i18n'
+require 'amber/render/helpers/html_helper'
+require 'amber/render/helpers/navigation_helper'
+require 'amber/render/helpers/haml_helper'
+require 'amber/render/helpers/language_helper'
+
+module Amber
+  module Render
+    class View
+      attr_reader :locals
+      attr_reader :page
+      attr_reader :site
+
+      # include helpers (get added as member functions)
+      include HtmlHelper
+      include NavigationHelper
+      include HamlHelper
+      include LanguageHelper
+
+      def initialize(page, site)
+        @page = page
+        @site = site
+        @stack = []
+        @locals = {}
+        @this = StaticPage::PropertySet.new # TODO: come up with a better way to handle this.
+                                            # @this is not actually used, it is just there so haml headers don't bomb out.
+      end
+
+      #
+      # more or less the same as Rails render()
+      #
+      # supported options:
+      #   :page    -- page path or page object to render
+      #   :file    -- renders the file specified, using suffix to determine type.
+      #   :partial -- same as :file, but disables layout
+      #   :text    -- string to render
+      #   :type    -- required for :text
+      #
+      def render(options={}, locals={}, toc_only=false, &block)
+        push_context @locals, @page
+        @locals    = @locals.merge(locals)
+        locale     = I18n.locale = @locals[:locale]
+        options    = parse_render_options(locale, options)
+        @page      = options[:page] if options[:page]
+        render_toc = should_render_toc?(locale, options, @page)
+        template   = pick_template(locale, options)
+        if toc_only
+          template.render(self, :mode => :toc, :href_base => options[:href_base])
+        else
+          layout = pick_layout(locale, options)
+          if layout
+            layout.render(self) do |layout_yield_argument|
+              template.render(self, :mode => layout_yield_argument, :toc => render_toc)
+            end
+          else
+            template.render(self, :mode => :content, :toc => render_toc)
+          end
+        end
+      rescue StandardError => exc
+        if @site.continue_on_error
+          report_error(exc, options)
+        else
+          raise exc
+        end
+      ensure
+        @locals, @page = pop_context
+        I18n.locale = @locals[:locale]
+      end
+
+      def render_toc(options={}, locals={})
+        render(options, locals, true)
+      end
+
+      private
+
+      def find_file(path, site, page, locale)
+        search = [
+          path,
+          "#{site.pages_dir}/#{path}",
+          "#{page.file_path}/#{path}",
+          "#{File.dirname(page.file_path)}/#{path}",
+          "#{site.config_dir}/#{path}"
+        ]
+        search.each do |path|
+          return path if File.exists?(path)
+          Dir["#{path}.#{locale}.*"].each do |path_with_locale|
+            return path_with_locale if File.exists?(path_with_locale)
+          end
+          Dir["#{path}.*"].each do |path_with_suffix|
+            return path_with_suffix if File.exists?(path_with_suffix)
+          end
+        end
+        raise MissingTemplate.new(path)
+      end
+
+      def partialize(path)
+        File.dirname(path) + "/_" + File.basename(path)
+      end
+
+      def push_context(locals, page)
+        @stack.push([locals, page])
+      end
+
+      def pop_context
+        @stack.pop
+      end
+
+      #
+      # cleans up the `options` arg that is passed to render()
+      #
+      def parse_render_options(locale, options)
+        # handle non-hash options
+        if options.is_a?(String)
+          page = @site.find_page(options)
+          if page
+            options = {:page => page}
+          else
+            options = {:partial => options}
+          end
+        elsif options.is_a?(StaticPage)
+          options = {:page => options}
+        end
+
+        # convert :page, :partial, or :file to the real deal
+        if options[:page]
+          if options[:page].is_a?(String)
+            options[:page] = @site.find_page(options[:page])
+          end
+          options[:href_base] ||= page_path(options[:page], locale)
+        elsif options[:partial]
+          options[:partial] = find_file(partialize(options[:partial]), @site, @page, locale)
+        elsif options[:file]
+          options[:file] = find_file(options[:file], @site, @page, locale)
+        end
+        return options
+      end
+
+      def should_render_toc?(locale, options, page)
+        if options[:partial].nil?
+          if page.prop(locale, :toc).nil?
+            true
+          else
+            page.prop(locale, :toc)
+          end
+        else
+          false
+        end
+      end
+
+      def pick_template(locale, options)
+        if options[:page]
+          Template.new(file: options[:page].content_file(locale))
+        elsif options[:file]
+          Template.new(file: options[:file])
+        elsif options[:partial]
+          Template.new(file: options[:partial], partial: true)
+        elsif options[:text]
+          Template.new(content: options[:text], type: (options[:type] || :text))
+        end
+      end
+
+      def pick_layout(locale, options)
+        if options[:layout] && !options[:partial]
+          Render::Layout[options[:layout]]
+        else
+          nil
+        end
+      end
+
+      def report_error(exc, options)
+        if exc.is_a? MissingTemplate
+          msg = "ERROR: render() could not find file from #{options.inspect}"
+          Amber.logger.error(msg)
+          Amber.log_exception(exc)
+          "<pre>%s</pre>" % [msg, exc, exc.backtrace].flatten.join("\n")
+        else
+          Amber.log_exception(exc)
+          "<pre>%s</pre>" % [exc, exc.backtrace].flatten.join("\n")
+        end
+      end
+    end
+  end
+end

data/lib/amber/server.rb

@@ -0,0 +1,113 @@
+#
+# A very simple http server for use when previewing pages.
+#
+
+require 'webrick'
+
+module Amber
+  class Server
+    attr_reader :site
+    attr_reader :port
+
+    def self.start(options)
+      Server.new(options).start
+    end
+
+    def initialize(options)
+      @site = options[:site]
+      @port = options[:port]
+      @server = WEBrick::HTTPServer.new :Port => @port, :BindAddress => '127.0.0.1', :DocumentRoot => @site.dest_dir
+      @server.mount '/', StaticPageServlet, self
+    end
+
+    def start
+      trap 'INT' do
+        @server.shutdown
+      end
+      @server.start
+    end
+  end
+
+  class StaticPageServlet < WEBrick::HTTPServlet::FileHandler
+
+    def initialize(http_server, amber_server)
+      @logger = http_server.logger
+      @server = amber_server
+      super(http_server, @server.site.dest_dir, {:FanyIndexing => true})
+    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
+      end
+
+      if File.exists?(File.join(dest_dir, request.path))
+        @logger.info "Serve static file %s" % File.join(dest_dir, request.path)
+        super(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
+      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(/\/$/, '')
+    end
+
+    def get_locale(request)
+      match = /\/(#{Amber::POSSIBLE_LANGUAGE_CODES.join('|')})(\/|$)/.match(request.path)
+      if match.nil?
+        nil
+      else
+        match[1]
+      end
+    end
+  end
+
+end

data/lib/amber/site.rb

@@ -0,0 +1,154 @@
+require 'forwardable'
+require 'fileutils'
+
+module Amber
+  class Site
+    extend Forwardable
+
+    attr_accessor :page_list
+    attr_accessor :root
+    attr_accessor :continue_on_error
+
+    def_delegators :@config, :dest_dir, :locales, :default_locale
+
+    def initialize(root_dir)
+      @continue_on_error = true
+      @config = SiteConfiguration.load(self, root_dir)
+    end
+
+    def load_pages
+      @root          = nil
+      @pages_by_path = {}
+      @pages_by_name = {}
+      @page_list     = PageArray.new
+      @dir_list      = []
+      @config.mount_points.each do |mp|
+        add_mount_point(mp)
+        mp.reset_timestamp
+      end
+    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)
+        putc '.'; $stdout.flush
+      end
+      @dir_list.each do |directory|
+        src = File.join(@config.pages_dir, directory)
+        dst = File.join(@config.dest_dir, directory)
+        Render::Asset.render_dir(src, dst)
+        putc '.'; $stdout.flush
+      end
+      puts
+    end
+
+    def clear
+      Dir.glob("#{@config.dest_dir}/*").each do |file|
+        FileUtils.rm_r(file)
+      end
+    end
+
+    def with_destination(new_dest)
+      dest_dir = @config.dest_dir
+      @config.dest_dir = new_dest
+      yield
+      @config.dest_dir = dest_dir
+    end
+
+    def find_pages(filter)
+     filter = filter.downcase
+     if filter =~ /\//
+        path = filter.split('/').map{|segment| segment.gsub(/[^0-9a-z_-]/, '')}
+        path_str = path.join('/')
+        if (page = @pages_by_path[path_str])
+          page
+        elsif matched_path = @page_paths.grep(/#{Regexp.escape(path_str)}/).first
+          @pages_by_path[matched_path]
+        elsif page = @pages_by_name[path.last]
+          page
+        else
+          nil
+        end
+      else
+        @pages_by_name[filter]
+      end
+    end
+
+    def find_page(filter)
+      find_pages(filter)
+    end
+
+    def all_pages
+      @page_list
+    end
+
+    def find_page_by_path(path)
+      @pages_by_path[path]
+    end
+
+    def find_page_by_name(name)
+      @pages_by_name[name]
+    end
+
+    private
+
+    def add_mount_point(mp)
+      # create base_page
+      base_page = begin
+        if mp.path == '/'
+          @root = StaticPage.new(nil, 'root', mp.pages_dir)
+          add_page(@root)
+          @root
+        else
+          name = File.basename(mp.path)
+          page = StaticPage.new(find_parent(mp.path), name, mp.pages_dir)
+          add_page(page)
+          page
+        end
+      end
+      base_page.mount_point = mp
+
+      # load menu and locals
+      I18n.load_path += Dir[File.join(mp.locales_dir, '/*.{rb,yml,yaml}')] if mp.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
+    end
+
+    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"
+        else
+          @pages_by_path[alias_path] = page
+        end
+      end
+      @page_list << page
+    end
+
+    def find_parent(path)
+      so_far = []
+      path.split('/').compact.each do |path_segment|
+        so_far << path_segment
+        if page = @pages_by_path[so_far.join('/')]
+          return page
+        end
+      end
+      return @root
+    end
+
+  end
+end