lalala 4.0.0.dev.46

data/lib/lalala/ext_rack/i18n_negotiator.rb

@@ -0,0 +1,217 @@
+class Lalala::ExtRack::I18nNegotiator
+
+  include ActionDispatch::Routing::Redirection
+
+  def initialize(app, adapter)
+    @app     = app
+    @adapter = adapter
+  end
+
+  def call(env)
+    dup._call(env)
+  end
+
+protected
+
+  def _call(env)
+    @env = env
+
+    _locale = I18n.locale
+
+    if @adapter.ignored?(env)
+      return @app.call(env)
+    end
+
+    return determine_routing_path
+  ensure
+    I18n.locale = _locale
+  end
+
+private
+
+  def determine_routing_path
+
+    Rails.logger.debug "[I18n]: try one available locale..."
+    if m = one_available_locale?
+      @env['rack.locale']           = m[0]
+      @env['lalala.cannonical_url'] = nil
+      return action(true)
+    end
+
+    Rails.logger.debug "[I18n]: try one available locale for hostname..."
+    if m = hostname_with_one_available_locale?
+      @env['rack.locale']           = m[0]
+      @env['lalala.cannonical_url'] = nil
+      return action(true)
+    end
+
+    Rails.logger.debug "[I18n]: try first path component..."
+    if m = first_path_component_is_locale?
+      @env['rack.locale']           = m[0]
+      @env['SCRIPT_NAME']           = m[1]
+      @env['PATH_INFO']             = m[2]
+      @env['lalala.cannonical_url'] = nil
+      return action(true)
+    end
+
+    Rails.logger.debug "[I18n]: try Accept-Language..."
+    if m = accept_language_is_available?
+      @env['rack.locale']           = m[0]
+      @env['SCRIPT_NAME']           = m[1]
+      @env['lalala.cannonical_url'] = m[2]
+      return action(false)
+    end
+
+    @env['rack.locale'] = default_locale_for_hostname.to_sym
+    return action(true)
+  end
+
+  def action(deterministic)
+    action, new_env = @adapter.action(@env, deterministic)
+
+    case action
+
+    when :call
+      I18n.locale = new_env['rack.locale']
+
+      status, headers, body = @app.call(new_env)
+      headers['Content-Language'] = I18n.locale.to_s
+      headers['Canonical-URL'] = [headers['Canonical-URL'], @env['lalala.cannonical_url']]
+
+      return [status, headers, body]
+
+    when :redirect
+      return [301, {'Location' => canonical_url}, []]
+
+    end
+  end
+
+  def one_available_locale?
+    if available_locales.size == 1
+      return [available_locales.first.to_sym]
+    end
+
+    return nil
+  end
+
+  def hostname_with_one_available_locale?
+    if locales_for_hostname.size == 1
+      return [locales_for_hostname.first.to_sym]
+    end
+
+    return nil
+  end
+
+  def first_path_component_is_locale?
+    if locale_regex === path_info
+      locale = $1
+      path   = $2 || ""
+
+      path = "/" if path == ""
+
+      script_name = File.join(@env['SCRIPT_NAME'].to_s, locale.to_s)
+
+      return [locale.to_sym, script_name, path]
+    end
+
+    return nil
+  end
+
+  def accept_language_is_available?
+    header = @env['HTTP_ACCEPT_LANGUAGE'] || ""
+
+    accepted_locales = header.split(",")
+    accepted_locales = accepted_locales.map do |l|
+      l = l.strip
+      l = l.split(";q=")
+      l[0] = l[0].split('-').first
+      l.push "1.0" if l.size < 2
+      l
+    end
+
+    accepted_locales = accepted_locales.sort_by do |(_, qval)|
+      qval.to_f * -1.0
+    end
+
+    accepted_locales = accepted_locales.map do |(locale, _)|
+      locale
+    end
+
+    accepted_locale = accepted_locales.detect do |locale|
+      (locale == "*") or locales_for_hostname_set.include?(locale)
+    end
+
+    if accepted_locale == "*"
+      accepted_locale = nil
+    end
+
+    if accepted_locale
+      script_name = File.join(@env['SCRIPT_NAME'].to_s, accepted_locale.to_s)
+
+      url_env = @env.dup
+      url_env['SCRIPT_NAME'] = script_name
+      url = Rack::Request.new(url_env).url
+
+      return [accepted_locale.to_sym, script_name, url]
+    end
+
+    return nil
+  end
+
+  def default_locale
+    @_default_locale ||= @adapter.default_locale
+  end
+
+  def default_locale_for_hostname
+    @_default_locale_for_hostname ||= begin
+      l = @adapter.default_locale_for_hostname(hostname)
+
+      unless l
+        if locales_for_hostname.include?(default_locale)
+          l = default_locale
+        else
+          l = locales_for_hostname.first
+        end
+      end
+
+      unless l
+        l = default_locale
+      end
+
+      l
+    end
+  end
+
+  def available_locales
+    @_available_locales ||= @adapter.available_locales
+  end
+
+  def locales_for_hostname
+    @_locales_for_hostname ||= @adapter.locales_for_hostname(hostname)
+  end
+
+  def locales_for_hostname_set
+    @_locales_for_hostname_set ||= locales_for_hostname.map(&:to_s)
+  end
+
+  def hostname
+    @_hostname ||= @env['HTTP_HOST'].split(':').first
+  end
+
+  def path_info
+    @_path_info ||= @env['PATH_INFO']
+  end
+
+  def locale_regex
+    @_locale_regex ||= begin
+      locales = locales_for_hostname
+      locales = locales.map do |locale|
+        Regexp.escape(locale.to_s)
+      end
+      locales = locales.join("|")
+
+      %r{^/(#{locales})([/].*)?$}
+    end
+  end
+
+end

data/lib/lalala/ext_rack/page_loader.rb

@@ -0,0 +1,54 @@
+class Lalala::ExtRack::PageLoader
+
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    if %r{^/(lalala|assets)(/|$)} === env['PATH_INFO']
+      return @app.call(env)
+    end
+
+    env   = env
+    chain = find_chain(env)
+
+    if chain.present?
+      update_env(env, chain)
+    end
+
+    @app.call(env)
+  end
+
+protected
+
+  def find_chain(env)
+
+    path_info       = env['PATH_INFO']
+    path_components = path_info.split('/')
+
+    path_components.unshift('') unless path_components.first == ''
+    return ApplicationPage.find_chain_for_path(path_components)
+  end
+
+  def update_env(env, chain)
+    pages       = []
+    script_name = env['SCRIPT_NAME'].to_s
+    path_info   = env['PATH_INFO'].to_s
+
+    chain.each do |(page, path_component)|
+      script_name = File.join(script_name, path_component)
+      path_info   = path_info[(1 + path_component.size)..-1]
+
+      pages.push page
+    end
+
+    env['lalala.page_chain'] = pages
+    env['lalala.page']       = pages.last
+    env['PATH_INFO']         = path_info
+
+    unless script_name == "/" or script_name.blank?
+      env['SCRIPT_NAME'] = script_name
+    end
+  end
+
+end

data/lib/lalala/ext_rack.rb

@@ -0,0 +1,8 @@
+module Lalala::ExtRack
+  extend ActiveSupport::Autoload
+
+  autoload :CanonicalURL
+  autoload :PageLoader
+  autoload :I18nNegotiator
+
+end

data/lib/lalala/markdown/active_model.rb

@@ -0,0 +1,51 @@
+module Lalala::Markdown::ActiveModel
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+
+    def markdown(*columns)
+      options = columns.extract_options!
+      @markdown_transformers ||= {}
+
+      md  = Lalala::Markdown.new(options)
+      mod = Module.new
+
+      columns.each do |column|
+        column = column.to_sym
+
+        @markdown_transformers[column] = md
+
+        mod.class_eval <<-SRC, __FILE__, __LINE__ + 1
+
+          def #{column}_html
+            value = self.#{column} || ""
+            value = self.class.markdown_transformer_for_column(#{column.inspect}).render(value)
+            value.html_safe
+          end
+
+          def #{column}=(value)
+            value = self.class.markdown_transformer_for_column(#{column.inspect}).format(value)
+            super(value)
+          end
+
+        SRC
+      end
+
+      include(mod)
+    end
+
+    def markdown_transformer_for_column(column_name)
+      if @markdown_transformers and @markdown_transformers.key?(column_name)
+        return @markdown_transformers[column_name]
+      end
+
+      if superclass.respond_to?(:markdown_transformer_for_column)
+        return superclass.markdown_transformer_for_column(column_name)
+      end
+
+      raise "Missing markdown transformer for column `#{column_name}`"
+    end
+
+  end
+
+end

data/lib/lalala/markdown/handlers/base.rb

@@ -0,0 +1,17 @@
+class Lalala::Markdown::Handlers::Base
+
+  def image(url, alt=nil, title=nil)
+    ""
+  end
+
+  def link(url, content=url, title=nil)
+    ""
+  end
+
+private
+
+  def helpers
+    ApplicationController.helpers
+  end
+
+end

data/lib/lalala/markdown/handlers/youtube.rb

@@ -0,0 +1,32 @@
+class Lalala::Markdown::Handlers::YouTube < Lalala::Markdown::Handlers::Base
+
+  def initialize(options={})
+    options.assert_valid_keys(:width, :height)
+
+    options = {
+      width:  560,
+      height: 315
+    }.merge(options)
+
+    @options = options
+  end
+
+  def image(url, alt=nil, title=nil)
+    unless %r|^youtube[:]//(.+)$| === url
+      return ""
+    end
+
+    id = $1
+
+    helpers.content_tag(
+      :iframe,
+      "",
+      width:           @options[:width],
+      height:          @options[:height],
+      src:             "http://www.youtube.com/embed/#{id}?rel=0",
+      frameborder:     0,
+      allowfullscreen: true
+    )
+  end
+
+end

data/lib/lalala/markdown/html_renderer.rb

@@ -0,0 +1,109 @@
+class Lalala::Markdown::HtmlRenderer < Redcarpet::Render::HTML
+
+  URI_PATTERN = %r{\A(lalala|youtube|vimeo)[:][/]{2}.+\Z}
+
+  def initialize(options)
+    @options      = options.dup
+    @link_schemes = (options[:link_schemes] || {}).dup
+    super(options)
+  end
+
+  def autolink(link, link_type)
+    if link.blank?
+      return ""
+    end
+
+    if URI_PATTERN === link
+      return enhanced_autolink($1, link, link_type)
+    end
+
+    if @options[:safe_links_only] and !safe_link(link) and type != :email
+      return ""
+    end
+
+    url = link
+    url = "mailto:"+url if type == :email
+
+    helpers.link_to(link, url, @options[:link_attributes])
+  end
+
+  def image(link, title, alt_text)
+    if link.blank?
+      return ""
+    end
+
+    if URI_PATTERN === link
+      return enhanced_image($1, link, title, alt_text)
+    end
+
+    if @options[:safe_links_only] and !safe_link(link)
+      return ""
+    end
+
+    helpers.image_tag(link, alt: alt_text, title: title)
+  end
+
+  def link(link, title, content)
+    if link.blank?
+      link = nil
+    end
+
+    if link and URI_PATTERN === link
+      return enhanced_link($1, link, title, content)
+    end
+
+    if link and @options[:safe_links_only] and !safe_link(link)
+      return ""
+    end
+
+    options = (@options[:link_attributes] || {}).merge(title: title)
+    helpers.link_to(content, link, options)
+  end
+
+  def enhanced_autolink(scheme, link, link_type)
+    handler = @link_schemes[scheme]
+    if handler
+      handler.link(link, nil, nil)
+    else
+      ""
+    end
+  end
+
+  def enhanced_image(scheme, link, title, alt_text)
+    handler = @link_schemes[scheme]
+    if handler
+      handler.image(link, alt_text, title)
+    else
+      ""
+    end
+  end
+
+  def enhanced_link(scheme, link, title, content)
+    handler = @link_schemes[scheme]
+    if handler
+      handler.link(link, content, title)
+    else
+      ""
+    end
+  end
+
+private
+
+  def safe_link(link)
+    case link
+    when %r{^/}
+      return true
+    when %r{^(http|https|ftp)[:]//}
+      return true
+    when %r{^mailto[:]}
+      return true
+    else
+      return false
+    end
+  end
+
+  def helpers
+    ApplicationController.helpers
+  end
+
+end