middleman-core 3.1.0.beta.3 → 3.1.0.rc.1

data/lib/middleman-more/core_extensions/default_helpers.rb

@@ -0,0 +1,235 @@
+class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
+
+  def initialize(app, options_hash={}, &block)
+    super
+
+    require 'active_support/core_ext/object/to_query'
+    require 'padrino-helpers'
+
+    app.helpers ::Padrino::Helpers::OutputHelpers
+    app.helpers ::Padrino::Helpers::TagHelpers
+    app.helpers ::Padrino::Helpers::AssetTagHelpers
+    app.helpers ::Padrino::Helpers::FormHelpers
+    app.helpers ::Padrino::Helpers::FormatHelpers
+    app.helpers ::Padrino::Helpers::RenderHelpers
+    app.helpers ::Padrino::Helpers::NumberHelpers
+    # app.helpers ::Padrino::Helpers::TranslationHelpers
+    # app.helpers ::Padrino::Helpers::Breadcrumbs
+
+    app.config.define_setting :relative_links, false, 'Whether to generate relative links instead of absolute ones'
+  end
+
+  # The helpers
+  helpers do
+    # Disable Padrino cache buster
+    def asset_stamp
+      false
+    end
+
+    # Output a stylesheet link tag based on the current path
+    #
+    # @return [String]
+    def auto_stylesheet_link_tag
+      auto_tag(:css) do |path|
+        stylesheet_link_tag path
+      end
+    end
+
+    # Output a javascript tag based on the current path
+    #
+    # @return [String]
+    def auto_javascript_include_tag
+      auto_tag(:js) do |path|
+        javascript_include_tag path
+      end
+    end
+
+    # Output a stylesheet link tag based on the current path
+    #
+    # @param [Symbol] asset_ext The type of asset
+    # @param [String] asset_dir Where to look for assets
+    # @return [void]
+    def auto_tag(asset_ext, asset_dir=nil)
+      if asset_dir.nil?
+        asset_dir = case asset_ext
+          when :js  then js_dir
+          when :css then css_dir
+        end
+      end
+
+      # If the basename of the request as no extension, assume we are serving a
+      # directory and join index_file to the path.
+      path = File.join(asset_dir, current_path)
+      path = path.sub(/#{File.extname(path)}$/, ".#{asset_ext}")
+
+      yield path if sitemap.find_resource_by_path(path)
+    end
+
+    # Generate body css classes based on the current path
+    #
+    # @return [String]
+    def page_classes
+      path = current_path.dup
+      path << index_file if path.end_with?('/')
+      path = ::Middleman::Util.strip_leading_slash(path)
+
+      classes = []
+      parts = path.split('.').first.split('/')
+      parts.each_with_index { |path, i| classes << parts.first(i+1).join('_') }
+
+      classes.join(' ')
+    end
+
+    # Get the path of a file of a given type
+    #
+    # @param [Symbol] kind The type of file
+    # @param [String] source The path to the file
+    # @return [String]
+    def asset_path(kind, source)
+      return source if source.to_s.include?('//')
+      asset_folder  = case kind
+        when :css    then css_dir
+        when :js     then js_dir
+        when :images then images_dir
+        when :fonts  then fonts_dir
+        else kind.to_s
+      end
+      source = source.to_s.tr(' ', '')
+      ignore_extension = (kind == :images || kind == :fonts) # don't append extension
+      source << ".#{kind}" unless ignore_extension || source.end_with?(".#{kind}")
+      asset_folder = "" if source.start_with?('/') # absolute path
+
+      asset_url(source, asset_folder)
+    end
+
+    # Get the URL of an asset given a type/prefix
+    #
+    # @param [String] path The path (such as "photo.jpg")
+    # @param [String] prefix The type prefix (such as "images")
+    # @return [String] The fully qualified asset url
+    def asset_url(path, prefix="")
+      # Don't touch assets which already have a full path
+      if path.include?("//")
+        path
+      else # rewrite paths to use their destination path
+        path = File.join(prefix, path)
+        if resource = sitemap.find_resource_by_path(path)
+          resource.url
+        else
+          File.join(config[:http_prefix], path)
+        end
+      end
+    end
+
+    # Given a source path (referenced either absolutely or relatively)
+    # or a Resource, this will produce the nice URL configured for that
+    # path, respecting :relative_links, directory indexes, etc.
+    def url_for(path_or_resource, options={})
+      # Handle Resources and other things which define their own url method
+      url = path_or_resource.respond_to?(:url) ? path_or_resource.url : path_or_resource
+
+      begin
+        uri = URI(url)
+      rescue URI::InvalidURIError
+        # Nothing we can do with it, it's not really a URI
+        return url
+      end
+
+      relative = options.delete(:relative)
+      raise "Can't use the relative option with an external URL" if relative && uri.host
+
+      # Allow people to turn on relative paths for all links with
+      # set :relative_links, true
+      # but still override on a case by case basis with the :relative parameter.
+      effective_relative = relative || false
+      effective_relative = true if relative.nil? && config[:relative_links]
+
+      # Try to find a sitemap resource corresponding to the desired path
+      this_resource = current_resource # store in a local var to save work
+      if path_or_resource.is_a?(::Middleman::Sitemap::Resource)
+        resource = path_or_resource
+        resource_url = url
+      elsif this_resource && uri.path
+        # Handle relative urls
+        url_path = Pathname(uri.path)
+        current_source_dir = Pathname('/' + this_resource.path).dirname
+        url_path = current_source_dir.join(url_path) if url_path.relative?
+        resource = sitemap.find_resource_by_path(url_path.to_s)
+        resource_url = resource.url if resource
+      end
+
+      if resource
+        # Switch to the relative path between this_resource and the given resource
+        # if we've been asked to.
+        if effective_relative
+          # Output urls relative to the destination path, not the source path
+          current_dir = Pathname('/' + this_resource.destination_path).dirname
+          relative_path = Pathname(resource_url).relative_path_from(current_dir).to_s
+
+          # Put back the trailing slash to avoid unnecessary Apache redirects
+          if resource_url.end_with?('/') && !relative_path.end_with?('/')
+            relative_path << '/'
+          end
+
+          uri.path = relative_path
+        else
+          uri.path = resource_url
+        end
+      else
+        # If they explicitly asked for relative links but we can't find a resource...
+        raise "No resource exists at #{url}" if relative
+      end
+
+      # Support a :query option that can be a string or hash
+      if query = options.delete(:query)
+        uri.query = query.respond_to?(:to_param) ? query.to_param : query.to_s
+      end
+
+      # Support a :fragment or :anchor option just like Padrino
+      fragment = options.delete(:anchor) || options.delete(:fragment)
+      uri.fragment = fragment.to_s if fragment
+
+      # Finally make the URL back into a string
+      uri.to_s
+    end
+
+    # Overload the regular link_to to be sitemap-aware - if you
+    # reference a source path, either absolutely or relatively,
+    # you'll get that resource's nice URL. Also, there is a
+    # :relative option which, if set to true, will produce
+    # relative URLs instead of absolute URLs. You can also add
+    #
+    # config[:relative_links] = true
+    #
+    # to config.rb to have all links default to relative.
+    #
+    # There is also a :query option that can be used to append a
+    # query string, which can be expressed as either a String,
+    # or a Hash which will be turned into URL parameters.
+    def link_to(*args, &block)
+      url_arg_index = block_given? ? 0 : 1
+      options_index = block_given? ? 1 : 2
+
+      if block_given? && args.size > 2
+        raise ArgumentError.new("Too many arguments to link_to(url, options={}, &block)")
+      end
+
+      if url = args[url_arg_index]
+        options = args[options_index] || {}
+        raise ArgumentError.new("Options must be a hash") unless options.is_a?(Hash)
+
+        # Transform the url through our magic url_for method
+        args[url_arg_index] = url_for(url, options)
+      end
+
+      super(*args, &block)
+    end
+
+    # Modified Padrino form_for that uses Middleman's url_for
+    # to transform the URL.
+    def form_tag(url, options={}, &block)
+      url = url_for(url, options)
+      super
+    end
+  end
+end

data/lib/middleman-more/core_extensions/i18n.rb

@@ -0,0 +1,182 @@
+class Middleman::CoreExtensions::Internationalization < ::Middleman::Extension
+  option :no_fallbacks, false, "Disable I18n fallbacks"
+  option :langs, nil, "List of langs, will autodiscover by default"
+  option :lang_map, {}, "Language shortname map"
+  option :path, "/:locale/", "URL prefix path"
+  option :templates_dir, "localizable", "Location of templates to be localized"
+  option :mount_at_root, nil, "Mount a specific language at the root of the site"
+  option :data, "locales", "The directory holding your locale configurations"
+
+  def initialize(app, options_hash={}, &block)
+    super
+
+    # See https://github.com/svenfuchs/i18n/wiki/Fallbacks
+    unless options[:no_fallbacks]
+      require "i18n/backend/fallbacks"
+      ::I18n::Backend::Simple.send(:include, ::I18n::Backend::Fallbacks)
+    end
+
+    app.config.define_setting :locales_dir, "locales", 'The directory holding your locale configurations'
+
+    app.send :include, LocaleHelpers
+  end
+
+  def after_configuration
+    @locales_glob = File.join(app.config[:locals_dir] || options[:data], "**", "*.{rb,yml,yaml}")
+
+    # File.fnmatch doesn't support brackets: {rb,yml,yaml}
+    regex = @locales_glob.sub(/\./, '\.').sub(File.join("**", "*"), ".*").sub(/\//, '\/').sub("{rb,yml,yaml}", "rb|ya?ml")
+    @locales_regex = %r{^#{regex}}
+
+    @maps = {}
+
+    ::I18n.load_path += Dir[File.join(app.root, @locales_glob)]
+    ::I18n.reload!
+
+    @mount_at_root = options[:mount_at_root].nil? ? langs.first : options[:mount_at_root]
+
+    ::I18n.default_locale = @mount_at_root
+    # Reset fallbacks to fall back to our new default
+    if ::I18n.respond_to? :fallbacks
+      ::I18n.fallbacks = ::I18n::Locale::Fallbacks.new
+    end
+
+    if !app.build?
+      logger.info "== Locales: #{langs.join(", ")} (Default #{@mount_at_root})"
+    end
+
+    # Don't output localizable files
+    app.ignore File.join(options[:templates_dir], "**")
+
+    app.sitemap.provides_metadata_for_path do |url|
+      if d = get_localization_data(url)
+        lang, page_id = d
+      else
+        # Default to the @mount_at_root lang
+        page_id = nil
+        lang = @mount_at_root
+      end
+
+      instance_vars = Proc.new do
+        @lang         = lang
+        @page_id      = page_id
+      end
+
+      locals = { :lang => lang,
+        :page_id => page_id }
+      { :blocks => [instance_vars],
+        :locals => locals,
+        :options => { :lang => lang } }
+    end
+
+    app.files.changed(&method(:on_file_changed))
+    app.files.deleted(&method(:on_file_changed))
+  end
+
+  helpers do
+    def t(*args)
+      ::I18n.t(*args)
+    end
+  end
+
+  delegate :logger, :to => :app
+
+  def on_file_changed(file)
+    if @locales_regex =~ file
+      ::I18n.reload!
+    end
+  end
+
+  def langs
+    if options[:langs]
+      Array(options[:langs]).map(&:to_sym)
+    else
+      Dir[File.join(app.root, @locales_glob)].map { |file|
+        File.basename(file).sub(/\.ya?ml$/, "").sub(/\.rb$/, "")
+      }.sort.map(&:to_sym)
+    end
+  end
+
+  def get_localization_data(path)
+    @_localization_data ||= {}
+    @_localization_data[path]
+  end
+
+  # Update the main sitemap resource list
+  # @return [void]
+  def manipulate_resource_list(resources)
+    @_localization_data = {}
+
+    new_resources = []
+
+    resources.each do |resource|
+      # If it's a "localizable template"
+      if File.fnmatch?(File.join(options[:templates_dir], "**"), resource.path)
+        page_id = File.basename(resource.path, File.extname(resource.path))
+        langs.each do |lang|
+          # Remove folder name
+          path = resource.path.sub(options[:templates_dir], "")
+          new_resources << build_resource(path, resource.path, page_id, lang)
+        end
+      elsif result = parse_locale_extension(resource.path)
+        lang, path, page_id = result
+        new_resources << build_resource(path, resource.path, page_id, lang)
+      end
+    end
+
+    resources + new_resources
+  end
+
+  private
+
+  # Parse locale extension filename
+  # @return [lang, path, basename]
+  # will return +nil+ if no locale extension
+  def parse_locale_extension(path)
+    path_bits = path.split('.')
+    return nil if path_bits.size < 3
+
+    lang = path_bits.delete_at(-2).to_sym
+    return nil unless langs.include?(lang)
+
+    path = path_bits.join('.')
+    basename = File.basename(path_bits[0..-2].join('.'))
+
+    [lang, path, basename]
+  end
+
+  def build_resource(path, source_path, page_id, lang)
+    old_locale = ::I18n.locale
+    ::I18n.locale = lang
+
+    localized_page_id = ::I18n.t("paths.#{page_id}", :default => page_id, :fallback => [])
+
+    if @mount_at_root == lang
+      prefix = "/"
+    else
+      replacement = options[:lang_map].fetch(lang, lang)
+      prefix = options[:path].sub(":locale", replacement.to_s)
+    end
+
+    path = ::Middleman::Util.normalize_path(
+       File.join(prefix, path.sub(page_id, localized_page_id))
+    )
+
+    @_localization_data[path] = [lang, path, localized_page_id]
+
+    p = ::Middleman::Sitemap::Resource.new(app.sitemap, path)
+    p.proxy_to(source_path)
+
+    ::I18n.locale = old_locale
+
+    p
+  end
+
+  module LocaleHelpers
+    # Access the list of languages supported by this Middleman application
+    # @return [Array<Symbol>]
+    def langs
+      extensions[:i18n].langs
+    end
+  end
+end

data/lib/middleman-more/extensions/asset_hash.rb

@@ -0,0 +1,114 @@
+class Middleman::Extensions::AssetHash < ::Middleman::Extension
+  option :exts, %w(.jpg .jpeg .png .gif .js .css .otf .woff .eot .ttf .svg), "List of extensions that get asset hashes appended to them."
+  option :ignore, [], "Regexes of filenames to skip adding asset hashes to"
+
+  def initialize(app, options_hash={}, &block)
+    super
+
+    require 'digest/sha1'
+    require 'rack/test'
+    require 'uri'
+  end
+
+  def after_configuration
+    # Allow specifying regexes to ignore, plus always ignore apple touch icons
+    @ignore = Array(options.ignore) + [/^apple-touch-icon/]
+
+    app.use Middleware, :exts => options.exts, :middleman_app => app, :ignore => @ignore
+  end
+
+  # Update the main sitemap resource list
+  # @return [void]
+  def manipulate_resource_list(resources)
+    # Process resources in order: binary images and fonts, then SVG, then JS/CSS.
+    # This is so by the time we get around to the text files (which may reference
+    # images and fonts) the static assets' hashes are already calculated.
+    rack_client = ::Rack::Test::Session.new(app.class.to_rack_app)
+    resources.sort_by do |a|
+      if %w(.svg).include? a.ext
+        0
+      elsif %w(.js .css).include? a.ext
+        1
+      else
+        -1
+      end
+    end.each do |resource|
+      next unless options.exts.include? resource.ext
+      next if @ignore.any? { |ignore| Middleman::Util.path_match(ignore, resource.destination_path) }
+
+      # Render through the Rack interface so middleware and mounted apps get a shot
+      response = rack_client.get(URI.escape(resource.destination_path), {}, { "bypass_asset_hash" => "true" })
+      raise "#{resource.path} should be in the sitemap!" unless response.status == 200
+
+      digest = Digest::SHA1.hexdigest(response.body)[0..7]
+
+      resource.destination_path = resource.destination_path.sub(/\.(\w+)$/) { |ext| "-#{digest}#{ext}" }
+    end
+  end
+
+  # The asset hash middleware is responsible for rewriting references to
+  # assets to include their new, hashed name.
+  class Middleware
+    def initialize(app, options={})
+      @rack_app        = app
+      @exts            = options[:exts]
+      @ignore          = options[:ignore]
+      @exts_regex_text = @exts.map {|e| Regexp.escape(e) }.join('|')
+      @middleman_app   = options[:middleman_app]
+    end
+
+    def call(env)
+      status, headers, response = @rack_app.call(env)
+
+      # We don't want to use this middleware when rendering files to figure out their hash!
+      return [status, headers, response] if env["bypass_asset_hash"] == 'true'
+
+      path = @middleman_app.full_path(env["PATH_INFO"])
+      dirpath = Pathname.new(File.dirname(path))
+
+      if path =~ /(^\/$)|(\.(htm|html|php|css|js)$)/
+        body = ::Middleman::Util.extract_response_text(response)
+
+        if body
+          # TODO: This regex will change some paths in plan HTML (not in a tag) - is that OK?
+          body.gsub!(/([=\'\"\(]\s*)([^\s\'\"\)]+(#{@exts_regex_text}))/) do |match|
+            opening_character = $1
+            asset_path = $2
+
+            relative_path = Pathname.new(asset_path).relative?
+
+            asset_path = dirpath.join(asset_path).to_s if relative_path
+
+            if @ignore.any? { |r| asset_path.match(r) }
+              match
+            elsif asset_page = @middleman_app.sitemap.find_resource_by_path(asset_path)
+              replacement_path = "/#{asset_page.destination_path}"
+              replacement_path = Pathname.new(replacement_path).relative_path_from(dirpath).to_s if relative_path
+
+              "#{opening_character}#{replacement_path}"
+            else
+              match
+            end
+          end
+
+          status, headers, response = Rack::Response.new(body, status, headers).finish
+        end
+      end
+      [status, headers, response]
+    end
+  end
+
+end
+
+# =================Temp Generate Test data==============================
+#   ["jpg", "png", "gif"].each do |ext|
+#     [["<p>", "</p>"], ["<p><img src=", " /></p>"], ["<p>background-image:url(", ");</p>"]].each do |outer|
+#       [["",""], ["'", "'"], ['"','"']].each do |inner|
+#         [["", ""], ["/", ""], ["../", ""], ["../../", ""], ["../../../", ""], ["http://example.com/", ""], ["a","a"], ["1","1"], [".", "."], ["-","-"], ["_","_"]].each do |path_parts|
+#           name = 'images/100px.'
+#           puts outer[0] + inner[0] + path_parts[0] + name + ext + path_parts[1] + inner[1] + outer[1]
+#         end
+#       end
+#     end
+#     puts "<br /><br /><br />"
+#   end

data/lib/middleman-more/extensions/asset_host.rb

@@ -0,0 +1,50 @@
+
+# Asset Host module
+class Middleman::Extensions::AssetHost < ::Middleman::Extension
+  option :host, nil, 'The asset host to use, or false for no asset host, or a Proc to determine asset host'
+
+  def initialize(app, options_hash={}, &block)
+    super
+
+    # Backwards compatible API
+    app.config.define_setting :asset_host, nil, 'The asset host to use, or false for no asset host, or a Proc to determine asset host'
+
+    app.compass_config do |config|
+      if asset_host = extensions[:asset_host].host
+        if asset_host.is_a?(Proc)
+          config.asset_host(&asset_host)
+        else
+          config.asset_host do |asset|
+            asset_host
+          end
+        end
+      end
+    end if app.respond_to?(:compass_config)
+  end
+
+  def host
+    app.config[:asset_host] || options[:host]
+  end
+
+  helpers do 
+    # Override default asset url helper to include asset hosts
+    #
+    # @param [String] path
+    # @param [String] prefix
+    # @return [String]
+    def asset_url(path, prefix="")
+      controller = extensions[:asset_host]
+
+      original_output = super
+      return original_output unless controller.host
+
+      asset_prefix = if controller.host.is_a?(Proc)
+        controller.host.call(original_output)
+      elsif controller.host.is_a?(String)
+        controller.host
+      end
+
+      File.join(asset_prefix, original_output)
+    end
+  end
+end