middleman-more 3.1.0.beta.1 → 3.1.0.beta.2

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

@@ -1,174 +1,150 @@
-require "i18n"
-require "i18n/backend/fallbacks"
+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
 
-module Middleman
-  module CoreExtensions
+    app.config.define_setting :locales_dir, "locales", 'The directory holding your locale configurations'
+  end
 
-    # i18n Namespace
-    module Internationalization
+  def after_configuration
+    @locales_glob = File.join(app.config[:locals_dir] || options[:data], "**", "*.{rb,yml,yaml}")
 
-      # Setup extension
-      class << self
+    # 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}}
 
-        # Once registerd
-        def registered(app, options={})
-          app.config.define_setting :locales_dir, "locales", 'The directory holding your locale configurations'
+    @maps = {}
 
-          # Needed for helpers as well
-          app.after_configuration do
-            Localizer.new(self, options)
-          end
+    ::I18n.load_path += Dir[File.join(app.root, @locales_glob)]
+    ::I18n.reload!
 
-          app.helpers do
-            def t(*args)
-              ::I18n.t(*args)
-            end
-          end
+    @mount_at_root = options[:mount_at_root].nil? ? langs.first : options[:mount_at_root]
 
-          # See https://github.com/svenfuchs/i18n/wiki/Fallbacks
-          unless options[:no_fallbacks]
-            ::I18n::Backend::Simple.send(:include, I18n::Backend::Fallbacks)
-          end
-        end
-        alias :included :registered
-      end
+    ::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
 
-      # Central class for managing i18n extension
-      class Localizer
-        attr_reader :app
-        delegate :logger, :to => :app
-
-        def initialize(app, options={})
-          @app = app
-          @locales_glob = File.join(app.locales_dir, "**", "*.{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 = {}
-          @options = options
-
-          ::I18n.load_path += Dir[File.join(app.root, @locales_glob)]
-          ::I18n.reload!
-
-          @lang_map      = @options[:lang_map]      || {}
-          @path          = @options[:path]          || "/:locale/"
-          @templates_dir = @options[:templates_dir] || "localizable"
-          @mount_at_root = @options.has_key?(:mount_at_root) ? @options[:mount_at_root] : langs.first
-
-          ::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(@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.sitemap.register_resource_list_manipulator(
-            :i18n,
-            self
-          )
-
-          @app.files.changed(&method(:on_file_changed))
-          @app.files.deleted(&method(:on_file_changed))
-        end
+    if !app.build?
+      logger.info "== Locales: #{langs.join(", ")} (Default #{@mount_at_root})"
+    end
 
-        def on_file_changed(file)
-          if @locales_regex =~ file
-            ::I18n.reload!
-          end
-        end
+    # Don't output localizable files
+    app.ignore File.join(options[:templates_dir], "**")
 
-        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
+    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
 
-        def get_localization_data(path)
-          @_localization_data ||= {}
-          @_localization_data[path]
-        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
 
-        # Update the main sitemap resource list
-        # @return [void]
-        def manipulate_resource_list(resources)
-          @_localization_data = {}
+    app.files.changed(&method(:on_file_changed))
+    app.files.deleted(&method(:on_file_changed))
+  end
 
-          new_resources = []
+  helpers do 
+    def t(*args)
+      ::I18n.t(*args)
+    end
+  end
 
-          resources.each do |resource|
-            next unless File.fnmatch(File.join(@templates_dir, "**"), resource.path)
+  delegate :logger, :to => :app
 
-            page_id = File.basename(resource.path, File.extname(resource.path))
+  def on_file_changed(file)
+    if @locales_regex =~ file
+      ::I18n.reload!
+    end
+  end
 
-            old_locale = ::I18n.locale
-            langs.map do |lang|
-              ::I18n.locale = lang
+  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
 
-              localized_page_id = ::I18n.t("paths.#{page_id}", :default => page_id, :fallback => [])
-              path = resource.path.sub(@templates_dir, "")
+  def get_localization_data(path)
+    @_localization_data ||= {}
+    @_localization_data[path]
+  end
 
-              # Build lang path
-              if @mount_at_root == lang
-                prefix = "/"
-              else
-                replacement = @lang_map.has_key?(lang) ? @lang_map[lang] : lang
-                prefix = @path.sub(":locale", replacement.to_s)
-              end
+  # Update the main sitemap resource list
+  # @return [void]
+  def manipulate_resource_list(resources)
+    @_localization_data = {}
 
-              path = ::Middleman::Util.normalize_path(
-                File.join(prefix, path.sub(page_id, localized_page_id))
-              )
+    new_resources = []
 
-              @_localization_data[path] = [lang, path, localized_page_id]
+    resources.each do |resource|
+      next unless File.fnmatch(File.join(options[:templates_dir], "**"), resource.path)
 
-              p = ::Middleman::Sitemap::Resource.new(
-                @app.sitemap,
-                path
-              )
-              p.proxy_to(resource.path)
+      page_id = File.basename(resource.path, File.extname(resource.path))
 
-              new_resources << p
-            end
-            ::I18n.locale = old_locale
+      old_locale = ::I18n.locale
+      langs.map do |lang|
+        ::I18n.locale = lang
 
-          end
+        localized_page_id = ::I18n.t("paths.#{page_id}", :default => page_id, :fallback => [])
+        path = resource.path.sub(options[:templates_dir], "")
 
-          resources + new_resources
+        # Build lang path
+        if @mount_at_root == lang
+          prefix = "/"
+        else
+          replacement = options[:lang_map].has_key?(lang) ? options[:lang_map][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(resource.path)
+
+        new_resources << p
       end
+      ::I18n.locale = old_locale
+
     end
+
+    resources + new_resources
   end
 end

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

@@ -1,124 +1,104 @@
-module Middleman
-  module Extensions
-    module AssetHash
-      class Extension < ::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={})
-          super
-
-          require 'digest/sha1'
-          require 'rack/test'
-          require 'uri'
-        end
+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 after_configuration
-          # Allow specifying regexes to ignore, plus always ignore apple touch icons
-          ignore = Array(options.ignore) + [/^apple-touch-icon/]
+  def initialize(app, options_hash={}, &block)
+    super
 
-          app.sitemap.register_resource_list_manipulator(
-            :asset_hash,
-            AssetHashManager.new(app, options.exts, ignore)
-          )
+    require 'digest/sha1'
+    require 'rack/test'
+    require 'uri'
+  end
 
-          app.use Middleware, :exts => options.exts, :middleman_app => app, :ignore => ignore
-        end
-      end
+  def after_configuration
+    # Allow specifying regexes to ignore, plus always ignore apple touch icons
+    @ignore = Array(options.ignore) + [/^apple-touch-icon/]
 
-      # Central class for managing asset_hash extension
-      class AssetHashManager
-        def initialize(app, exts, ignore)
-          @app = app
-          @exts = exts
-          @ignore = ignore
-        end
+    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 @exts.include? resource.ext
-            next if @ignore.any? { |ignore| Middleman::Util.path_match(ignore, resource.destination_path) }
+  # 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
+      # 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]
+      digest = Digest::SHA1.hexdigest(response.body)[0..7]
 
-            resource.destination_path = resource.destination_path.sub(/\.(\w+)$/) { |ext| "-#{digest}#{ext}" }
-          end
-        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
+      resource.destination_path = resource.destination_path.sub(/\.(\w+)$/) { |ext| "-#{digest}#{ext}" }
+    end
+  end
 
-        def call(env)
-          status, headers, response = @rack_app.call(env)
+  # 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
 
-          # 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'
+    def call(env)
+      status, headers, response = @rack_app.call(env)
 
-          path = @middleman_app.full_path(env["PATH_INFO"])
-          dirpath = Pathname.new(File.dirname(path))
+      # 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'
 
-          if path =~ /(^\/$)|(\.(htm|html|php|css|js)$)/
-            body = ::Middleman::Util.extract_response_text(response)
+      path = @middleman_app.full_path(env["PATH_INFO"])
+      dirpath = Pathname.new(File.dirname(path))
 
-            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
+      if path =~ /(^\/$)|(\.(htm|html|php|css|js)$)/
+        body = ::Middleman::Util.extract_response_text(response)
 
-                relative_path = Pathname.new(asset_path).relative?
+        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
 
-                asset_path = dirpath.join(asset_path).to_s if relative_path
+            relative_path = Pathname.new(asset_path).relative?
 
-                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
+            asset_path = dirpath.join(asset_path).to_s if relative_path
 
-                  "#{opening_character}#{replacement_path}"
-                else
-                  match
-                end
-              end
+            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
 
-              status, headers, response = Rack::Response.new(body, status, headers).finish
+              "#{opening_character}#{replacement_path}"
+            else
+              match
             end
           end
-          [status, headers, response]
+
+          status, headers, response = Rack::Response.new(body, status, headers).finish
         end
       end
+      [status, headers, response]
     end
   end
-end
 
+end
 
 # =================Temp Generate Test data==============================
 #   ["jpg", "png", "gif"].each do |ext|

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

@@ -1,49 +1,50 @@
-# Extensions namespace
-module Middleman
-  module Extensions
 
-    # Asset Host module
-    module AssetHost
+# 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'
 
-      # Setup extension
-      class << self
+  def initialize(app, options_hash={}, &block)
+    super
 
-        # Once registered
-        def registered(app, options={})
-          app.config.define_setting :asset_host, false, 'The asset host to use, or false for no asset host, or a Proc to determine asset host'
+    # 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'
 
-          if options[:host]
-            config[:asset_host] = options[: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
-
-          # Include methods
-          app.send :include, InstanceMethods
         end
-
-        alias :included :registered
       end
+    end
+  end
 
-      # Asset Host Instance Methods
-      module InstanceMethods
-
-        # Override default asset url helper to include asset hosts
-        #
-        # @param [String] path
-        # @param [String] prefix
-        # @return [String]
-        def asset_url(path, prefix="")
-          original_output = super
-          return original_output unless config[:asset_host]
-
-          asset_prefix = if config[:asset_host].is_a?(Proc)
-            config[:asset_host].call(original_output)
-          elsif config[:asset_host].is_a?(String)
-            config[:asset_host]
-          end
+  def host
+    app.config[:asset_host] || options[:host]
+  end
 
-          File.join(asset_prefix, original_output)
-        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