amber 0.2.6

data/lib/amber/page_array.rb

@@ -0,0 +1,61 @@
+#
+# Array of StaticPages
+#
+
+require 'bigdecimal'
+
+module Amber
+  class PageArray < Array
+
+    def limit(num)
+      PageArray.new(self[0..(num-1)])
+    end
+
+    #
+    # available options:
+    #
+    # :locale    -- the locale to use when comparing attributes
+    # :direction -- either :asc or :desc
+    # :numeric   -- if true, attributes are cast as numbers before comparison
+    #
+    def order_by(attr, options={})
+      locale = options[:locale] || I18n.locale
+      direction = options[:direction] || :asc
+      array = sort do |a,b|
+        if direction == :desc
+          a, b = b, a
+        end
+        a_prop = a.prop(locale, attr)
+        b_prop = b.prop(locale, attr)
+        if options[:numeric]
+          a_prop = to_numeric(a_prop)
+          b_prop = to_numeric(b_prop)
+        end
+        if a_prop.nil? && b_prop.nil?
+          0
+        elsif a_prop.nil?
+          1
+        elsif b_prop.nil?
+          -1
+        else
+          a_prop <=> b_prop
+        end
+      end
+      # remove pages from the results that have no value set for the attr
+      array.delete_if do |page|
+        page.prop(locale, attr).nil?
+      end
+      return PageArray.new.replace array
+    end
+
+    def to_numeric(anything)
+      num = BigDecimal.new(anything.to_s)
+      if num.frac == 0
+        num.to_i
+      else
+        num.to_f
+      end
+    end
+
+  end
+end

data/lib/amber/render/asset.rb

@@ -0,0 +1,55 @@
+#
+# For rendering things that are assets, like sass files.
+# Maybe images too?
+#
+
+require 'sass'
+
+module Amber
+  module Render
+    class Asset
+
+      RENDER_MAP = {
+        '.sass' => {:method => 'render_sass', :new_suffix => '.css', :args => [:sass]},
+        '.scss' => {:method => 'render_sass', :new_suffix => '.css', :args => [:scss]}
+      }
+
+      def self.render(src_file, dst_file)
+        unless Dir.exists?(File.dirname(dst_file))
+          FileUtils.mkdir_p(File.dirname(dst_file))
+        end
+        File.unlink(dst_file) if File.exists?(dst_file)
+        src_ext = File.extname(src_file)
+        renderer = RENDER_MAP[src_ext]
+        if renderer
+          content = self.send(renderer[:method], *([src_file] + renderer[:args]))
+          new_dst_file = dst_file.sub(/#{Regexp.escape(src_ext)}$/, renderer[:new_suffix])
+          File.open(new_dst_file,'w') do |w|
+            w.write(content)
+          end
+        else
+          File.link(src_file, dst_file)
+        end
+      rescue SystemCallError => exc
+        Amber.log_exception(exc)
+      end
+
+      def self.render_dir(src_dir, dst_dir)
+        Dir.chdir(src_dir) do
+          Dir.glob('*').each do |file|
+            next if File.directory?(file) || file =~ /^\./
+            src_file = File.join(src_dir, file)
+            dst_file = File.join(dst_dir, file)
+            render(src_file, dst_file)
+          end
+        end
+      end
+
+      def self.render_sass(src_file, syntax)
+        engine = Sass::Engine.new(File.read(src_file), :syntax => syntax)
+        engine.render
+      end
+
+    end
+  end
+end

data/lib/amber/render/autolink.rb

@@ -0,0 +1,78 @@
+# encoding: utf-8
+# adapted from https://github.com/tenderlove/rails_autolink
+# MIT license
+
+module Amber::Render::Autolink
+
+  def self.auto_link(text)
+    auto_link_email_addresses(auto_link_urls(text))
+  end
+
+  private
+
+  AUTO_LINK_RE = %r{
+      (?: ((?:ed2k|ftp|http|https|irc|mailto|news|gopher|nntp|telnet|webcal|xmpp|callto|feed|svn|urn|aim|rsync|tag|ssh|sftp|rtsp|afs|file):)// | www\. )
+      [^\s<\u00A0]+
+    }ix
+
+  # regexps for determining context, used high-volume
+  AUTO_LINK_CRE = [/<[^>]+$/, /^[^>]*>/, /<a\b.*?>/i, /<\/a>/i]
+
+  AUTO_EMAIL_LOCAL_RE = /[\w.!#\$%&'*\/=?^`{|}~+-]/
+  AUTO_EMAIL_RE = /[\w.!#\$%+-]\.?#{AUTO_EMAIL_LOCAL_RE}*@[\w-]+(?:\.[\w-]+)+/
+
+  BRACKETS = { ']' => '[', ')' => '(', '}' => '{' }
+
+  WORD_PATTERN = RUBY_VERSION < '1.9' ? '\w' : '\p{Word}'
+
+  # Turns all urls into clickable links.  If a block is given, each url
+  # is yielded and the result is used as the link text.
+  def self.auto_link_urls(text)
+    text.gsub(AUTO_LINK_RE) do
+      scheme, href = $1, $&
+      punctuation = []
+
+      if auto_linked?($`, $')
+        # do not change string; URL is already linked
+        href
+      else
+        # don't include trailing punctuation character as part of the URL
+        while href.sub!(/[^#{WORD_PATTERN}\/-]$/, '')
+          punctuation.push $&
+          if opening = BRACKETS[punctuation.last] and href.scan(opening).size > href.scan(punctuation.last).size
+            href << punctuation.pop
+            break
+          end
+        end
+
+        #link_text = block_given?? yield(href) : href
+        link_text = href.sub(/^#{scheme}\/\//,'')
+        href = 'http://' + href unless scheme
+        %(<a href="#{href}">#{link_text}</a>) + punctuation.reverse.join('')
+      end
+    end
+  end
+
+  # Turns all email addresses into clickable links.
+  def self.auto_link_email_addresses(text)
+    text.gsub(AUTO_EMAIL_RE) do
+      text = $&
+
+      if auto_linked?($`, $')
+        text
+      else
+        #display_text = (block_given?) ? yield(text) : text
+        #display_text = text
+        text.gsub!('@', '&#064').gsub!('.', '&#046;')
+        %(<a href="mailto:#{text}">#{text}</a>)
+      end
+    end
+  end
+
+  # Detects already linked context or position in the middle of a tag
+  def self.auto_linked?(left, right)
+    (left =~ AUTO_LINK_CRE[0] and right =~ AUTO_LINK_CRE[1]) or
+      (left.rindex(AUTO_LINK_CRE[2]) and $' !~ AUTO_LINK_CRE[3])
+  end
+
+end

data/lib/amber/render/bracketlink.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+#
+# bracket links are links in the form [[label => target]] or [[page-name]]
+#
+
+module Amber::Render::Bracketlink
+
+  # linking using double square brackets
+  BRACKET_LINK_RE = /
+    \[\[          # start [[
+    ([^\[\]]+)    # $text : one or more characters that are not [ or ] ($1)
+    \]\]          # end ]]
+  /x
+
+  def self.bracket_link(text, &block)
+    text.gsub(BRACKET_LINK_RE) do |m|
+      link_text = $~[1].strip
+      if link_text =~ /^.+\s*[-=]>\s*.+$/
+        # link_text == "from -> to"
+        from, to = link_text.split(/\s*[-=]>\s*/)[0..1]
+        from = "" unless from.instance_of? String # \ sanity check for
+        to   = "" unless from.instance_of? String # / badly formed links
+      else
+        # link_text == "to" (ie, no link label)
+        from = nil
+        to = link_text
+      end
+      yield(from, to)
+    end
+  end
+
+end

data/lib/amber/render/helpers/haml_helper.rb

@@ -0,0 +1,54 @@
+require 'pathname'
+
+module HamlHelper
+
+  #
+  # acts like haml_tag, capture_haml, or haml_concat, depending on how it is called.
+  #
+  # two or more args             --> like haml_tag
+  # one arg and a block          --> like haml_tag
+  # zero args and a block        --> like capture_haml
+  # one arg and no block         --> like haml_concat
+  #
+  # additionally, we allow the use of more than one class.
+  #
+  # some examples of these usages:
+  #
+  #   def display_robot(robot)
+  #     haml do                                # like capture_haml
+  #       haml '.head', robot.head_html        # like haml_tag
+  #       haml '.head' do                      # same
+  #         haml robot.head_html
+  #       end
+  #       haml '.body.metal', robot.body_html  # like haml_tag, but with multiple classes
+  #       haml '<a href="/x">link</a>'         # like haml_concat
+  #     end
+  #   end
+  #
+  # wrapping the helper in a capture_haml call is very useful, because then
+  # the helper can be used wherever a normal helper would be.
+  #
+  def haml(name=nil, *args, &block)
+    if name
+      if args.empty? and block.nil?
+        haml_concat name
+      else
+        if name =~ /^(.*?\.[^\.]*)(\..*)$/
+          # allow chaining of classes if there are multiple '.' in the first arg
+          name = $1
+          classes = $2.gsub('.',' ')
+          hsh = args.detect{|i| i.is_a?(Hash)}
+          unless hsh
+            hsh = {}
+            args << hsh
+          end
+          hsh[:class] = classes
+        end
+        haml_tag(name, *args, &block)
+      end
+    else
+      capture_haml(&block)
+    end
+  end
+
+end

data/lib/amber/render/helpers/html_helper.rb

@@ -0,0 +1,75 @@
+module Amber
+  module Render
+    module HtmlHelper
+
+      def html_head_base
+        href = (['..'] * @page.path.count).join('/')
+        "<base href=\"#{href}\" />"
+      end
+
+      #
+      # three forms:
+      #
+      #  (1) link('page-name')
+      #  (2) link('label' => 'page-name')
+      #  (3) link('label' => 'https://url')
+      #
+      # both accept optional options hash:
+      #
+      #  (1) link('page-name', :class => 'x')
+      #  (2) link('label' => 'page-name', :class => 'x')
+      #
+      def link(name, options=nil)
+        options = nil if options && !options.is_a?(Hash)
+        if name.is_a? Hash
+          klass = name.delete(:class)
+          label, name = name.to_a.first
+          if label.is_a? Symbol
+            label = I18n.t label
+          end
+        else
+          klass = options[:class] if options
+        end
+        if name =~ /^#/ || name =~ /^http/ || name =~ /\./
+          path = name
+          label ||= name
+        else
+          if index = name.index('#')
+            anchor = name[index..-1]
+            name_without_anchor = name[0..(index-1)]
+          else
+            anchor = ''
+            name_without_anchor = name
+          end
+          page = @site.find_page(name_without_anchor)
+          if page
+            label ||= page.nav_title
+            path = page_path(page) + anchor
+          else
+            puts "warning: dead link to `#{name_without_anchor}` from page `/#{I18n.locale}/#{@page.path.join('/')}`"
+            label ||= name_without_anchor
+            label += ' [dead link]'
+            path = name_without_anchor
+          end
+        end
+        if klass
+          %(<a href="#{path}" class="#{klass}">#{label}</a>)
+        else
+          %(<a href="#{path}">#{label}</a>)
+        end
+      end
+
+      #
+      # returns the shortest possible path. this would be nice to support some day, but more difficult with statically rendered sites.
+      #
+      def page_path(page, locale=I18n.locale)
+        if page.prop(locale, :alias)
+          "/#{locale}/#{page.prop(locale, :alias).first}/#{page.name}"
+        else
+          "/#{locale}/#{page.path.join('/')}"
+        end
+      end
+
+    end
+  end
+end

data/lib/amber/render/helpers/language_helper.rb

@@ -0,0 +1,25 @@
+module Amber
+  module Render
+    module LanguageHelper
+
+      def t(*args)
+        I18n.t(*args)
+      end
+
+      def translation_missing?
+        !@page.content_file_exists?(I18n.locale)
+      end
+
+      # return array of arrays, each array with: language_name, language_code, current_url_with_locale_switch
+      #
+      # [ ['English', :en, 'en/about-us'] ]
+      #
+      def available_languages
+        @site.locales.collect { |locale|
+          [Amber::POSSIBLE_LANGUAGES[locale][0], locale, "/"+([locale]+current_page_path).join('/')]
+        }
+      end
+
+    end
+  end
+end

data/lib/amber/render/helpers/navigation_helper.rb

@@ -0,0 +1,203 @@
+module Amber
+  module Render
+    module NavigationHelper
+
+      def has_navigation?
+        if current_page_path.empty? || @site.menu.nil?
+          false
+        else
+          submenu = @site.menu.submenu(current_page_path.first)
+          if submenu
+            second_level_children_count = submenu.size
+            if second_level_children_count.nil?
+              false
+            else
+              second_level_children_count >= 1
+            end
+          else
+            false
+          end
+        end
+      end
+
+      #
+      # yields each item
+      #
+      def top_navigation_items(options={})
+        if !@site.menu
+          yield({})
+        else
+          first = 'first'
+          if options[:include_home]
+            active = current_page_path.empty? ? 'active' : ''
+            yield({:class => [first, active].compact.join(' '), :href => menu_item_path(@site.menu), :label => menu_item_title(@site.menu)})
+            first = nil
+          end
+          @site.menu.each do |item|
+            active = current_page_path.first == item.name ? 'active' : ''
+            yield({:class => [first, active].compact.join(' '), :href => menu_item_path(item), :label => menu_item_title(item)})
+            first = nil
+          end
+        end
+      end
+
+      #
+      # yields each item
+      #
+      def navigation_items(menu=nil, level=1, &block)
+        if menu.nil?
+          menu = site.menu.submenu(current_page_path.first)
+        end
+        if menu
+          menu.each do |item|
+            title = menu_item_title(item)
+            if title
+              yield({
+                :href => menu_item_path(item),
+                :level => level,
+                :active => path_active_class(current_page_path, item),
+                :label => title
+              })
+            end
+            if path_open?(current_page_path, item)
+              navigation_items(item.submenu, level+1, &block)
+            end
+          end
+        end
+      end
+
+      def current_page_path
+        @current_page_path ||= begin
+          if @page
+            @page.path
+          #elsif params[:page].is_a? String
+          #  params[:page].split('/')
+          else
+            []
+          end
+        end
+      end
+
+      def menu_item_path(item)
+        "/" + ([I18n.locale]+item.path).join('/')
+      end
+
+      def menu_item_title(item)
+        page = @site.find_page_by_path(item.path_str) || @site.find_page_by_name(item.name)
+        if page
+          page.nav_title(I18n.locale)
+        else
+          nil
+        end
+      end
+
+      #
+      # inserts an directory index built from the page's children
+      #
+      # options:
+      #   :levels         -- the max levels to descend, default is 1
+      #   :page           -- StaticPage instance or nil
+      #   :include_toc    -- true or false
+      #   :order_by       -- arguments to PageArray#order_by
+      #   :heading        -- heading level to use
+      #
+      def child_summaries(options={})
+        page = options.delete(:page) || @page
+        unless page.is_a?(StaticPage)
+          page = @site.find_pages(page)
+        end
+        return "" if page.nil? or page.children.empty?
+
+        levels_max = options[:levels] || 1
+        level      = options.delete(:level) || 1
+        heading    = options.delete(:heading) || 2
+        locale     = @locals[:locale]
+        menu       = submenu_for_page(page)
+        if menu && menu.children.any?
+          children = menu.children
+        elsif options[:order_by]
+          children = page.children.order_by(*options[:order_by])
+        else
+          children = page.children
+        end
+
+        haml do
+          children.each do |child|
+            child_page = child.is_a?(Amber::Menu) ? page.child(child.name) : child
+            next unless child_page
+            haml "h#{heading}" do
+              haml :a, child_page.nav_title(locale), :href => page_path(child_page)
+            end
+            if summary = child_page.prop(locale, 'summary')
+              haml :p, summary
+            end
+            if options[:include_toc]
+              toc_html = render_toc(child_page, :locale => locale)
+              haml toc_html
+            end
+            if level < levels_max
+              haml(child_summaries({
+                :page => child_page,
+                :levels => levels_max,
+                :level => level+1,
+                :include_toc => options[:include_toc],
+                :order_by => options[:order_by],
+                :heading => heading+1
+              }))
+            end
+          end
+        end
+      rescue Exception => exc
+        Amber.log_exception(exc)
+      end
+
+      private
+
+      #
+      # returns string 'active', 'semi-active', or ''
+      #
+      def path_active_class(page_path, menu_item)
+        active = ''
+        if menu_item.path == page_path
+          active = 'active'
+        elsif menu_item.path_prefix_of?(page_path)
+          if menu_item.leaf_for_path?(page_path)
+            active = 'active'
+          else
+            active = 'semi-active'
+          end
+        end
+        active
+      end
+
+      #
+      # returns true if menu_item represents an parent of page
+      #
+      def path_open?(page_path, menu_item)
+        menu_item.path == page_path || menu_item.path_prefix_of?(page_path)
+      end
+
+      def submenu_for_page(page)
+        menu = @site.menu
+        page.path.each do |segment|
+          menu = menu.submenu(segment)
+        end
+        return menu
+      rescue
+        return nil
+      end
+
+    end
+  end
+end
+
+
+=begin
+
+  def act_as(page)
+    page = site.find_page(page)
+    @current_page_path = page.path
+    page_body(page)
+  end
+
+=end