middleman-core-cj 3.3.4

data/lib/middleman-core/version.rb

@@ -0,0 +1,5 @@
+module Middleman
+  # Current Version
+  # @return [String]
+  VERSION = '3.3.4' unless const_defined?(:VERSION)
+end

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

@@ -0,0 +1,74 @@
+require 'middleman-core/renderers/sass'
+require 'compass'
+
+class Middleman::CoreExtensions::Compass < ::Middleman::Extension
+  def initialize(app, options_hash={}, &block)
+    super
+
+    # Hooks to manually update the compass config after we're
+    # done with it
+    app.define_hook :compass_config
+
+    # Location of SASS/SCSS files external to source directory.
+    # @return [Array]
+    #   config[:sass_assets_paths] = ["#{root}/assets/sass/", "/path/2/external/sass/repository/"]
+    app.config.define_setting :sass_assets_paths, [], 'Paths to extra SASS/SCSS files'
+  end
+
+  def after_configuration
+    ::Compass.configuration do |compass_config|
+      compass_config.project_path    = app.source_dir
+      compass_config.environment     = :development
+      compass_config.cache           = false
+      compass_config.sass_dir        = app.config[:css_dir]
+      compass_config.css_dir         = app.config[:css_dir]
+      compass_config.javascripts_dir = app.config[:js_dir]
+      compass_config.fonts_dir       = app.config[:fonts_dir]
+      compass_config.images_dir      = app.config[:images_dir]
+      compass_config.http_path       = app.config[:http_prefix]
+
+      app.config[:sass_assets_paths].each do |path|
+        compass_config.add_import_path path
+      end
+
+      # Disable this initially, the cache_buster extension will
+      # re-enable it if requested.
+      compass_config.asset_cache_buster { |_| nil }
+
+      # Disable this initially, the relative_assets extension will
+
+      compass_config.relative_assets = false
+
+      # Default output style
+      compass_config.output_style = :nested
+
+      # No line-comments in test mode (changing paths mess with sha1)
+      compass_config.line_comments = false if ENV['TEST']
+    end
+
+    # Call hook
+    app.run_hook_for :compass_config, app, ::Compass.configuration
+
+    # Tell Tilt to use it as well (for inline sass blocks)
+    ::Tilt.register 'sass', CompassSassTemplate
+    ::Tilt.prefer(CompassSassTemplate)
+
+    # Tell Tilt to use it as well (for inline scss blocks)
+    ::Tilt.register 'scss', CompassScssTemplate
+    ::Tilt.prefer(CompassScssTemplate)
+  end
+
+  # A Compass Sass template for Tilt, adding our options in
+  class CompassSassTemplate < ::Middleman::Renderers::Sass::SassPlusCSSFilenameTemplate
+    def sass_options
+      super.merge(::Compass.configuration.to_sass_engine_options)
+    end
+  end
+
+  # A Compass Scss template for Tilt, adding our options in
+  class CompassScssTemplate < ::Middleman::Renderers::Sass::ScssPlusCSSFilenameTemplate
+    def sass_options
+      super.merge(::Compass.configuration.to_sass_engine_options)
+    end
+  end
+end

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

@@ -0,0 +1,261 @@
+require 'padrino-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 : 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.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
+
+    # 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
+
+    # 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
+    # @return [String]
+    def asset_path(kind, source)
+      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)
+    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.start_with?('data:')
+        path
+      else # rewrite paths to use their destination path
+        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
+      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
+  end
+end

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

@@ -0,0 +1,238 @@
+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
+
+    # TODO
+    # If :directory_indexes is already active,
+    # throw a warning explaining the bug and telling the use
+    # to reverse the order.
+
+    # 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
+    app.files.reload_path(app.config[:locals_dir] || options[:data])
+
+    @locales_glob = File.join(app.config[:locals_dir] || options[:data], '**', '*.{rb,yml,yaml}')
+    @locales_regex = convert_glob_to_regex(@locales_glob)
+
+    @maps = {}
+    @mount_at_root = options[:mount_at_root].nil? ? langs.first : options[:mount_at_root]
+
+    configure_i18n
+
+    unless 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(&method(:metadata_for_path))
+    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 langs
+    @_langs ||= known_languages
+  end
+
+  # Update the main sitemap resource list
+  # @return [void]
+  def manipulate_resource_list(resources)
+    @_localization_data = {}
+
+    new_resources = []
+
+    resources.each do |resource|
+      # If it uses file extension localization
+      if parse_locale_extension(resource.path)
+        result = parse_locale_extension(resource.path)
+        ext_lang, path, page_id = result
+        new_resources << build_resource(path, resource.path, page_id, ext_lang)
+      # If it's a "localizable template"
+      elsif 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
+      end
+    end
+
+    resources + new_resources
+  end
+
+  private
+
+  def on_file_changed(file)
+    return unless @locales_regex =~ file
+
+    @_langs = nil # Clear langs cache
+    ::I18n.reload!
+  end
+
+  def convert_glob_to_regex(glob)
+    # File.fnmatch doesn't support brackets: {rb,yml,yaml}
+    regex = glob.sub(/\./, '\.').sub(File.join('**', '*'), '.*').sub(/\//, '\/').sub('{rb,yml,yaml}', '(rb|ya?ml)')
+    %r{^#{regex}}
+  end
+
+  def configure_i18n
+    ::I18n.load_path += Dir[File.join(app.root, @locales_glob)]
+    ::I18n.reload!
+
+    ::I18n.default_locale = @mount_at_root
+
+    # Reset fallbacks to fall back to our new default
+    ::I18n.fallbacks = ::I18n::Locale::Fallbacks.new if ::I18n.respond_to?(:fallbacks)
+  end
+
+  def metadata_for_path(url)
+    if d = 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 do
+      @lang         = lang
+      @page_id      = page_id
+    end
+
+    locals = {
+      lang: lang,
+      page_id: page_id
+    }
+
+    {
+      blocks: [instance_vars],
+      locals: locals,
+      options: { lang: lang }
+    }
+  end
+
+  def known_languages
+    if options[:langs]
+      Array(options[:langs]).map(&:to_sym)
+    else
+      known_langs = app.files.known_paths.select do |p|
+        p.to_s.match(@locales_regex) && (p.to_s.split(File::SEPARATOR).length == 2)
+      end
+
+      known_langs.map { |p|
+        File.basename(p.to_s).sub(/\.ya?ml$/, '').sub(/\.rb$/, '')
+      }.sort.map(&:to_sym)
+    end
+  end
+
+  def localization_data(path)
+    @_localization_data ||= {}
+    @_localization_data[path]
+  end
+
+  # 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: [])
+
+    prefix = if (options[:mount_at_root] == lang) || (options[:mount_at_root].nil? && langs[0] == lang)
+      '/'
+    else
+      replacement = options[:lang_map].fetch(lang, lang)
+      options[:path].sub(':locale', replacement.to_s)
+    end
+
+    # path needs to be changed if file has a localizable extension. (options[mount_at_root] == lang)
+    path = ::Middleman::Util.normalize_path(
+      File.join(prefix, path.sub(page_id, localized_page_id))
+    )
+
+    path.gsub!(options[:templates_dir] + '/', '')
+
+    @_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
+
+    def locate_partial(partial_name, try_static=false)
+      locals_dir = extensions[:i18n].options[:templates_dir]
+
+      # Try /localizable
+      partials_path = File.join(locals_dir, partial_name)
+
+      lang_suffix = current_resource.metadata[:locals] && current_resource.metadata[:locals][:lang]
+
+      extname = File.extname(partial_name)
+      maybe_static = extname.length > 0
+      suffixed_partial_name = if maybe_static
+        partial_name.sub(extname, ".#{lang_suffix}#{extname}")
+      else
+        "#{partial_name}.#{lang_suffix}"
+      end
+
+      if lang_suffix
+        super(suffixed_partial_name, maybe_static) ||
+        super(File.join(locals_dir, suffixed_partial_name), maybe_static) ||
+        super(partials_path, try_static) ||
+        super
+      else
+        super(partials_path, try_static) ||
+        super
+      end
+    end
+  end
+end