middleman-more 3.1.0.beta.3 → 3.1.0.rc.2

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

@@ -1,182 +0,0 @@
-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

@@ -1,114 +0,0 @@
-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

@@ -1,50 +0,0 @@
-
-# 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
-  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

data/lib/middleman-more/extensions/automatic_image_sizes/fastimage.rb

@@ -1,287 +0,0 @@
-# FastImage finds the size or type of an image given its uri.
-# It is careful to only fetch and parse as much of the image as is needed to determine the result.
-# It does this by using a feature of Net::HTTP that yields strings from the resource being fetched
-# as soon as the packets arrive.
-#
-# No external libraries such as ImageMagick are used here, this is a very lightweight solution to
-# finding image information.
-#
-# FastImage knows about GIF, JPEG, BMP and PNG files.
-#
-# FastImage can also read files from the local filesystem by supplying the path instead of a uri.
-# In this case FastImage uses the open-uri library to read the file in chunks of 256 bytes until
-# it has enough. This is possibly a useful bandwidth-saving feature if the file is on a network
-# attached disk rather than truly local.
-#
-# === Examples
-#   require 'fastimage'
-#
-#   FastImage.size("http://stephensykes.com/images/ss.com_x.gif")
-#   => [266, 56]
-#   FastImage.type("http://stephensykes.com/images/pngimage")
-#   => :png
-#   FastImage.type("/some/local/file.gif")
-#   => :gif
-#
-# === References
-# * http://snippets.dzone.com/posts/show/805
-# * http://www.anttikupila.com/flash/getting-jpg-dimensions-with-as3-without-loading-the-entire-file/
-# * http://pennysmalls.com/2008/08/19/find-jpeg-dimensions-fast-in-ruby/
-# * http://imagesize.rubyforge.org/
-#
-require 'net/https'
-require 'open-uri'
-
-class FastImage
-  attr_reader :size, :type
-
-  class FastImageException < StandardError # :nodoc:
-  end
-  class MoreCharsNeeded < FastImageException # :nodoc:
-  end
-  class UnknownImageType < FastImageException # :nodoc:
-  end
-  class ImageFetchFailure < FastImageException # :nodoc:
-  end
-  class SizeNotFound < FastImageException # :nodoc:
-  end
-
-  DefaultTimeout = 2
-
-  LocalFileChunkSize = 256
-
-  # Returns an array containing the width and height of the image.
-  # It will return nil if the image could not be fetched, or if the image type was not recognised.
-  #
-  # By default there is a timeout of 2 seconds for opening and reading from a remote server.
-  # This can be changed by passing a :timeout => number_of_seconds in the options.
-  #
-  # If you wish FastImage to raise if it cannot size the image for any reason, then pass
-  # :raise_on_failure => true in the options.
-  #
-  # FastImage knows about GIF, JPEG, BMP and PNG files.
-  #
-  # === Example
-  #
-  #   require 'fastimage'
-  #
-  #   FastImage.size("http://stephensykes.com/images/ss.com_x.gif")
-  #   => [266, 56]
-  #   FastImage.size("http://stephensykes.com/images/pngimage")
-  #   => [16, 16]
-  #   FastImage.size("http://farm4.static.flickr.com/3023/3047236863_9dce98b836.jpg")
-  #   => [500, 375]
-  #   FastImage.size("http://www-ece.rice.edu/~wakin/images/lena512.bmp")
-  #   => [512, 512]
-  #   FastImage.size("test/fixtures/test.jpg")
-  #   => [882, 470]
-  #   FastImage.size("http://pennysmalls.com/does_not_exist")
-  #   => nil
-  #   FastImage.size("http://pennysmalls.com/does_not_exist", :raise_on_failure=>true)
-  #   => raises FastImage::ImageFetchFailure
-  #   FastImage.size("http://stephensykes.com/favicon.ico", :raise_on_failure=>true)
-  #   => raises FastImage::UnknownImageType
-  #   FastImage.size("http://stephensykes.com/favicon.ico", :raise_on_failure=>true, :timeout=>0.01)
-  #   => raises FastImage::ImageFetchFailure
-  #   FastImage.size("http://stephensykes.com/images/faulty.jpg", :raise_on_failure=>true)
-  #   => raises FastImage::SizeNotFound
-  #
-  # === Supported options
-  # [:timeout]
-  #   Overrides the default timeout of 2 seconds.  Applies both to reading from and opening the http connection.
-  # [:raise_on_failure]
-  #   If set to true causes an exception to be raised if the image size cannot be found for any reason.
-  #
-  def self.size(uri, options={})
-    new(uri, options).size
-  end
-
-  # Returns an symbol indicating the image type fetched from a uri.
-  # It will return nil if the image could not be fetched, or if the image type was not recognised.
-  #
-  # By default there is a timeout of 2 seconds for opening and reading from a remote server.
-  # This can be changed by passing a :timeout => number_of_seconds in the options.
-  #
-  # If you wish FastImage to raise if it cannot find the type of the image for any reason, then pass
-  # :raise_on_failure => true in the options.
-  #
-  # === Example
-  #
-  #   require 'fastimage'
-  #
-  #   FastImage.type("http://stephensykes.com/images/ss.com_x.gif")
-  #   => :gif
-  #   FastImage.type("http://stephensykes.com/images/pngimage")
-  #   => :png
-  #   FastImage.type("http://farm4.static.flickr.com/3023/3047236863_9dce98b836.jpg")
-  #   => :jpeg
-  #   FastImage.type("http://www-ece.rice.edu/~wakin/images/lena512.bmp")
-  #   => :bmp
-  #   FastImage.type("test/fixtures/test.jpg")
-  #   => :jpeg
-  #   FastImage.type("http://pennysmalls.com/does_not_exist")
-  #   => nil
-  #
-  # === Supported options
-  # [:timeout]
-  #   Overrides the default timeout of 2 seconds.  Applies both to reading from and opening the http connection.
-  # [:raise_on_failure]
-  #   If set to true causes an exception to be raised if the image type cannot be found for any reason.
-  #
-  def self.type(uri, options={})
-    new(uri, options.merge(:type_only=>true)).type
-  end
-
-  def initialize(uri, options={})
-    @property = options[:type_only] ? :type : :size
-    @timeout = options[:timeout] || DefaultTimeout
-    @uri = uri
-    begin
-      @parsed_uri = URI.parse(uri)
-    rescue URI::InvalidURIError
-      fetch_using_open_uri
-    else
-      if @parsed_uri.scheme == "http" || @parsed_uri.scheme == "https"
-        fetch_using_http
-      else
-        fetch_using_open_uri
-      end
-    end
-    raise SizeNotFound if options[:raise_on_failure] && @property == :size && !@size
-  rescue Timeout::Error, SocketError, Errno::ECONNREFUSED, Errno::EHOSTUNREACH, Errno::ECONNRESET,
-    ImageFetchFailure, Net::HTTPBadResponse, EOFError, Errno::ENOENT
-    raise ImageFetchFailure if options[:raise_on_failure]
-  rescue NoMethodError  # 1.8.7p248 can raise this due to a net/http bug
-    raise ImageFetchFailure if options[:raise_on_failure]
-  rescue UnknownImageType
-    raise UnknownImageType if options[:raise_on_failure]
-  end
-
-  private
-
-  def fetch_using_http
-    setup_http
-    @http.request_get(@parsed_uri.request_uri) do |res|
-      raise ImageFetchFailure unless res.is_a?(Net::HTTPSuccess)
-      res.read_body do |str|
-        break if parse_packet(str)
-      end
-    end
-  end
-
-  def setup_http
-    @http = Net::HTTP.new(@parsed_uri.host, @parsed_uri.port)
-    @http.use_ssl = (@parsed_uri.scheme == "https")
-    @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-    @http.open_timeout = @timeout
-    @http.read_timeout = @timeout
-  end
-
-  def fetch_using_open_uri
-    open(@uri) do |s|
-      while str = s.read(LocalFileChunkSize)
-        break if parse_packet(str)
-      end
-    end
-  end
-
-  # returns true once result is achieved
-  #
-  def parse_packet(str)
-    @str = (@unused_str || "") + str
-    @strpos = 0
-    begin
-      result = send("parse_#{@property}")
-      if result
-        instance_variable_set("@#{@property}", result)
-        true
-      end
-    rescue MoreCharsNeeded
-      false
-    end
-  end
-
-  def parse_size
-    @type = parse_type unless @type
-    @strpos = 0
-    send("parse_size_for_#{@type}")
-  end
-
-  def get_chars(n)
-    if @strpos + n - 1 >= @str.size
-      @unused_str = @str[@strpos..-1]
-      raise MoreCharsNeeded
-    else
-      result = @str[@strpos..(@strpos + n - 1)]
-      @strpos += n
-      result
-    end
-  end
-
-  def get_byte
-    get_chars(1).unpack("C")[0]
-  end
-
-  def read_int(str)
-    size_bytes = str.unpack("CC")
-    (size_bytes[0] << 8) + size_bytes[1]
-  end
-
-  def parse_type
-    case get_chars(2)
-    when "BM"
-      :bmp
-    when "GI"
-      :gif
-    when 0xff.chr + 0xd8.chr
-      :jpeg
-    when 0x89.chr + "P"
-      :png
-    else
-      raise UnknownImageType
-    end
-  end
-
-  def parse_size_for_gif
-    get_chars(11)[6..10].unpack('SS')
-  end
-
-  def parse_size_for_png
-    get_chars(25)[16..24].unpack('NN')
-  end
-
-  def parse_size_for_jpeg
-    loop do
-      @state = case @state
-      when nil
-        get_chars(2)
-        :started
-      when :started
-        get_byte == 0xFF ? :sof : :started
-      when :sof
-        c = get_byte
-        if (0xe0..0xef).include?(c)
-          :skipframe
-        elsif [0xC0..0xC3, 0xC5..0xC7, 0xC9..0xCB, 0xCD..0xCF].detect {|r| r.include? c}
-          :readsize
-        else
-          :skipframe
-        end
-      when :skipframe
-        @skip_chars = read_int(get_chars(2)) - 2
-        :do_skip
-      when :do_skip
-        get_chars(@skip_chars)
-        :started
-      when :readsize
-        s = get_chars(7)
-        return [read_int(s[5..6]), read_int(s[3..4])]
-      end
-    end
-  end
-
-  def parse_size_for_bmp
-    d = get_chars(29)[14..28]
-    d.unpack("C")[0] == 40 ? d[4..-1].unpack('LL') : d[4..8].unpack('SS')
-  end
-end

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

@@ -1,42 +0,0 @@
-# Automatic Image Sizes extension
-class Middleman::Extensions::AutomaticImageSizes < ::Middleman::Extension
-
-  def initialize(app, options_hash={}, &block)
-    super
-
-    # Include 3rd-party fastimage library
-    require "middleman-more/extensions/automatic_image_sizes/fastimage"
-  end
-
-  helpers do
-    # Override default image_tag helper to automatically calculate and include
-    # image dimensions.
-    #
-    # @param [String] path
-    # @param [Hash] params
-    # @return [String]
-    def image_tag(path, params={})
-      if !params.has_key?(:width) && !params.has_key?(:height) && !path.include?("://")
-        params[:alt] ||= ""
-
-        real_path = path
-        real_path = File.join(images_dir, real_path) unless real_path.start_with?('/')
-        full_path = File.join(source_dir, real_path)
-
-        if File.exists?(full_path)
-          begin
-            width, height = ::FastImage.size(full_path, :raise_on_failure => true)
-            params[:width]  = width
-            params[:height] = height
-          rescue FastImage::UnknownImageType
-            # No message, it's just not supported
-          rescue
-            warn "Couldn't determine dimensions for image #{path}: #{$!.message}"
-          end
-        end
-      end
-
-      super(path, params)
-    end
-  end
-end