333 lines
10 KiB
Ruby
333 lines
10 KiB
Ruby
require 'padrino-helpers'
|
|
require 'padrino-helpers/asset_tag_helpers'
|
|
require 'padrino-helpers/form_helpers'
|
|
require 'padrino-helpers/format_helpers'
|
|
require 'padrino-helpers/number_helpers'
|
|
require 'padrino-helpers/output_helpers'
|
|
require 'padrino-helpers/render_helpers'
|
|
require 'padrino-helpers/tag_helpers'
|
|
|
|
# Don't fail on invalid locale, that's not what our current
|
|
# users expect.
|
|
::I18n.enforce_available_locales = false
|
|
|
|
class ::Padrino::Helpers::OutputHelpers::ErbHandler
|
|
# Force Erb capture not to use safebuffer
|
|
# rubocop:disable UnderscorePrefixedVariableName
|
|
def capture_from_template(*args, &block)
|
|
self.output_buffer = ''
|
|
_buf_was = output_buffer
|
|
raw = block.call(*args)
|
|
captured = template.instance_variable_get(:@_out_buf)
|
|
self.output_buffer = _buf_was
|
|
engine_matches?(block) && !captured.empty? ? captured : raw
|
|
end
|
|
end
|
|
|
|
class Middleman::CoreExtensions::DefaultHelpers < ::Middleman::Extension
|
|
def initialize(app, options_hash={}, &block)
|
|
super
|
|
|
|
require 'active_support/core_ext/object/to_query'
|
|
|
|
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.config.define_setting :relative_links, false, 'Whether to generate relative links instead of absolute ones'
|
|
end
|
|
|
|
# The helpers
|
|
helpers do
|
|
# Make all block content html_safe
|
|
# rubocop:disable Semicolon
|
|
def content_tag(name, content=nil, options=nil, &block)
|
|
if block_given?
|
|
options = content if content.is_a?(Hash)
|
|
content = capture_html(&block)
|
|
end
|
|
|
|
options = parse_data_options(name, options)
|
|
attributes = tag_attributes(options)
|
|
output = ActiveSupport::SafeBuffer.new
|
|
output.safe_concat "<#{name}#{attributes}>"
|
|
|
|
if content.respond_to?(:each) && !content.is_a?(String)
|
|
content.each { |c| output.safe_concat c; output.safe_concat ::Padrino::Helpers::TagHelpers::NEWLINE }
|
|
else
|
|
output.safe_concat "#{content}"
|
|
end
|
|
output.safe_concat "</#{name}>"
|
|
|
|
block_is_template?(block) ? concat_content(output) : output
|
|
end
|
|
|
|
def capture_html(*args, &block)
|
|
result = if handler = auto_find_proper_handler(&block)
|
|
handler.capture_from_template(*args, &block)
|
|
else
|
|
block.call(*args)
|
|
end
|
|
|
|
ActiveSupport::SafeBuffer.new.safe_concat(result)
|
|
end
|
|
|
|
def auto_find_proper_handler(&block)
|
|
engine = block_given? ? File.extname(block.source_location[0])[1..-1].to_sym : current_engine
|
|
handler_class = ::Padrino::Helpers::OutputHelpers.handlers[engine]
|
|
handler_class && handler_class.new(self)
|
|
end
|
|
|
|
# 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
|
|
|
|
# Override helper to add `relative` opt-out.
|
|
def stylesheet_link_tag(*sources)
|
|
options = {
|
|
rel: 'stylesheet'
|
|
}.update(sources.extract_options!.symbolize_keys)
|
|
|
|
path_options = {}
|
|
path_options[:relative] = options.delete(:relative) if options.key?(:relative)
|
|
|
|
sources.flatten.inject(ActiveSupport::SafeBuffer.new) do |all, source|
|
|
all << tag(:link, {
|
|
href: asset_path(:css, source, path_options)
|
|
}.update(options))
|
|
end
|
|
end
|
|
|
|
# Override helper to add `relative` opt-out.
|
|
def javascript_include_tag(*sources)
|
|
options = sources.extract_options!.symbolize_keys
|
|
|
|
path_options = {}
|
|
path_options[:relative] = options.delete(:relative) if options.key?(:relative)
|
|
|
|
sources.flatten.inject(::ActiveSupport::SafeBuffer.new) do |all, source|
|
|
all << content_tag(:script, nil, {
|
|
src: asset_path(:js, source, path_options)
|
|
}.update(options))
|
|
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
|
|
js_dir
|
|
when :css
|
|
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_resource.path)
|
|
path = path.sub(/#{Regexp.escape(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, options={})
|
|
if path.is_a? Hash
|
|
options = path
|
|
path = current_path.dup
|
|
end
|
|
|
|
path << index_file if path.end_with?('/')
|
|
path = ::Middleman::Util.strip_leading_slash(path)
|
|
|
|
classes = []
|
|
parts = path.split('.').first.split('/')
|
|
parts.each_with_index { |_, i| classes << parts.first(i + 1).join('_') }
|
|
|
|
prefix = options[:numeric_prefix] || 'x'
|
|
classes.map do |c|
|
|
# Replace weird class name characters
|
|
c = c.gsub(/[^a-zA-Z0-9\-_]/, '-')
|
|
|
|
# Class names can't start with a digit
|
|
c = "#{prefix}#{c}" if c =~ /\A\d/
|
|
c
|
|
end.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
|
|
# @param [Hash] options Additional options.
|
|
# @return [String]
|
|
def asset_path(kind, source, options={})
|
|
return source if source.to_s.include?('//') || source.to_s.start_with?('data:')
|
|
asset_folder = case kind
|
|
when :css
|
|
css_dir
|
|
when :js
|
|
js_dir
|
|
when :images
|
|
images_dir
|
|
when :fonts
|
|
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, options)
|
|
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")
|
|
# @param [Hash] options Additional options.
|
|
# @return [String] The fully qualified asset url
|
|
def asset_url(path, prefix='', options={})
|
|
# Don't touch assets which already have a full path
|
|
if path.include?('//') || path.start_with?('data:')
|
|
path
|
|
else # rewrite paths to use their destination path
|
|
result = if resource = sitemap.find_resource_by_destination_path(url_for(path))
|
|
resource.url
|
|
else
|
|
path = File.join(prefix, path)
|
|
|
|
if resource = sitemap.find_resource_by_path(path)
|
|
resource.url
|
|
else
|
|
File.join(config[:http_prefix], path)
|
|
end
|
|
end
|
|
|
|
if options[:relative] != true
|
|
result
|
|
else
|
|
unless current_resource
|
|
raise ArgumentError, "#asset_url must be run in a context with current_resource if relative: true"
|
|
end
|
|
|
|
current_dir = Pathname('/' + current_resource.destination_path)
|
|
Pathname(result).relative_path_from(current_dir.dirname).to_s
|
|
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={})
|
|
options_with_resource = options.dup
|
|
options_with_resource[:current_resource] ||= current_resource
|
|
|
|
::Middleman::Util.url_for(self, path_or_resource, options_with_resource)
|
|
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, 'Too many arguments to link_to(url, options={}, &block)'
|
|
end
|
|
|
|
if url = args[url_arg_index]
|
|
options = args[options_index] || {}
|
|
raise ArgumentError, '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)
|
|
|
|
# Cleanup before passing to Padrino
|
|
options.delete(:relative)
|
|
options.delete(:current_resource)
|
|
options.delete(:find_resource)
|
|
options.delete(:query)
|
|
options.delete(:anchor)
|
|
options.delete(:fragment)
|
|
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
|
|
|
|
# Modified Padrino image_tag so that it finds the paths for srcset
|
|
# using asset_path for the images listed in the srcset param
|
|
def image_tag(path, params={})
|
|
params.symbolize_keys!
|
|
|
|
if params.key?(:srcset)
|
|
images_sources = params[:srcset].split(',').map do |src_def|
|
|
if src_def.include?('//')
|
|
src_def
|
|
else
|
|
image_def, size_def = src_def.strip.split(/\s+/)
|
|
asset_path(:images, image_def) + ' ' + size_def
|
|
end
|
|
end
|
|
|
|
params[:srcset] = images_sources.join(', ')
|
|
end
|
|
|
|
super(path, params)
|
|
end
|
|
end
|
|
end
|