middleman-core-x86-mingw32 3.0.1.pre

data/lib/middleman-core/sitemap/extensions/ignores.rb

@@ -0,0 +1,91 @@
+module Middleman
+
+  module Sitemap
+
+    module Extensions
+
+      module Ignores
+
+        # Setup extension
+        class << self
+
+          # Once registered
+          def registered(app)
+            # Include methods
+            app.send :include, InstanceMethods
+
+            ::Middleman::Sitemap::Resource.send :include, ResourceInstanceMethods
+          end
+
+          alias :included :registered
+        end
+
+        # Helpers methods for Resources
+        module ResourceInstanceMethods
+
+          # Whether the Resource is ignored
+          # @return [Boolean]
+          def ignored?
+            @app.ignore_manager.ignored?(path) ||
+            (!proxy? &&
+              @app.ignore_manager.ignored?(source_file.sub("#{@app.source_dir}/", ""))
+            )
+          end
+        end
+
+        # Ignore-related instance methods
+        module InstanceMethods
+          def ignore_manager
+            @_ignore_manager ||= IgnoreManager.new(self)
+          end
+
+          # Ignore a path or add an ignore callback
+          # @param [String, Regexp] path Path glob expression, or path regex
+          # @return [void]
+          def ignore(path=nil, &block)
+            ignore_manager.ignore(path, &block)
+          end
+        end
+
+        # Class to handle managing ignores
+        class IgnoreManager
+          def initialize(app)
+            @app = app
+
+            # Array of callbacks which can ass ignored
+            @ignored_callbacks = []
+          end
+
+          # Ignore a path or add an ignore callback
+          # @param [String, Regexp] path Path glob expression, or path regex
+          # @return [void]
+          def ignore(path=nil, &block)
+            original_callback_size = @ignored_callbacks.size
+
+            if path.is_a? Regexp
+              @ignored_callbacks << Proc.new {|p| p =~ path }
+            elsif path.is_a? String
+              path_clean = ::Middleman::Util.normalize_path(path)
+              if path_clean.include?("*") # It's a glob
+                @ignored_callbacks << Proc.new {|p| File.fnmatch(path_clean, p) }
+              else
+                # Add a specific-path ignore unless that path is already covered
+                @ignored_callbacks << Proc.new {|p| p == path_clean } unless ignored?(path_clean)
+              end
+            elsif block_given?
+              @ignored_callbacks << block
+            end
+          end
+
+          # Whether a path is ignored
+          # @param [String] path
+          # @return [Boolean]
+          def ignored?(path)
+            path_clean = ::Middleman::Util.normalize_path(path)
+            @ignored_callbacks.any? { |b| b.call(path_clean) }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/middleman-core/sitemap/extensions/on_disk.rb

@@ -0,0 +1,84 @@
+require 'set'
+
+module Middleman
+
+  module Sitemap
+
+    module Extensions
+
+      class OnDisk
+
+        attr_accessor :sitemap
+        attr_accessor :waiting_for_ready
+
+        def initialize(sitemap)
+          @sitemap = sitemap
+          @app     = @sitemap.app
+
+          @file_paths_on_disk = Set.new
+
+          scoped_self = self
+          @waiting_for_ready = true
+
+          # Register file change callback
+          @app.files.changed do |file|
+            scoped_self.touch_file(file, !scoped_self.waiting_for_ready)
+          end
+
+          # Register file delete callback
+          @app.files.deleted do |file|
+            scoped_self.remove_file(file, !scoped_self.waiting_for_ready)
+          end
+
+          @app.ready do
+            scoped_self.waiting_for_ready = false
+            scoped_self.sitemap.rebuild_resource_list!(:on_disk_ready)
+          end
+        end
+
+        # Update or add an on-disk file path
+        # @param [String] file
+        # @return [Boolean]
+        def touch_file(file, rebuild=true)
+          return false if File.directory?(file)
+
+          path = @sitemap.file_to_path(file)
+          return false unless path
+
+          ignored = @app.ignored_sitemap_matchers.any? do |name, callback|
+            callback.call(file)
+          end
+
+          @file_paths_on_disk << file unless ignored
+
+          # Rebuild the sitemap any time a file is touched
+          # in case one of the other manipulators
+          # (like asset_hash) cares about the contents of this file,
+          # whether or not it belongs in the sitemap (like a partial)
+          @sitemap.rebuild_resource_list!(:touched_file) if rebuild
+        end
+
+        # Remove a file from the store
+        # @param [String] file
+        # @return [void]
+        def remove_file(file, rebuild=true)
+          if @file_paths_on_disk.delete?(file)
+            @sitemap.rebuild_resource_list!(:removed_file) if rebuild
+          end
+        end
+
+        # Update the main sitemap resource list
+        # @return [void]
+        def manipulate_resource_list(resources)
+          resources + @file_paths_on_disk.map do |file|
+            ::Middleman::Sitemap::Resource.new(
+              @sitemap,
+              @sitemap.file_to_path(file),
+              File.expand_path(file, @app.root)
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/middleman-core/sitemap/extensions/proxies.rb

@@ -0,0 +1,114 @@
+module Middleman
+
+  module Sitemap
+
+    module Extensions
+
+      module Proxies
+
+        # Setup extension
+        class << self
+
+          # Once registered
+          def registered(app)
+            ::Middleman::Sitemap::Resource.send :include, ResourceInstanceMethods
+
+            # Include methods
+            app.send :include, InstanceMethods
+          end
+
+          alias :included :registered
+        end
+
+        module ResourceInstanceMethods
+          # Whether this page is a proxy
+          # @return [Boolean]
+          def proxy?
+            !!@proxied_to
+          end
+
+          # Set this page to proxy to a target path
+          # @param [String] target
+          # @return [void]
+          def proxy_to(target)
+            target = ::Middleman::Util.normalize_path(target)
+            raise "You can't proxy #{path} to itself!" if target == path
+            @proxied_to = target
+          end
+
+          # The path of the page this page is proxied to, or nil if it's not proxied.
+          # @return [String]
+          def proxied_to
+            @proxied_to
+          end
+
+          # Whether this page has a template file
+          # @return [Boolean]
+          def template?
+            if proxy?
+              store.find_resource_by_path(proxied_to).template?
+            else
+              super
+            end
+          end
+
+          def get_source_file
+            if proxy?
+              proxy_resource = store.find_resource_by_path(proxied_to)
+
+              unless proxy_resource
+                raise "Path #{path} proxies to unknown file #{proxied_to}:#{store.resources.map(&:path)}"
+              end
+
+              if proxy_resource.proxy?
+                raise "You can't proxy #{path} to #{proxied_to} which is itself a proxy."
+              end
+
+              proxy_resource.source_file
+            end
+          end
+        end
+
+        module InstanceMethods
+          def proxy_manager
+            @_proxy_manager ||= ProxyManager.new(self)
+          end
+
+          def proxy(*args)
+            proxy_manager.proxy(*args)
+          end
+        end
+
+        class ProxyManager
+          def initialize(app)
+            @app = app
+
+            @proxy_paths = {}
+          end
+
+          # Setup a proxy from a path to a target
+          # @param [String] path
+          # @param [String] target
+          # @return [void]
+          def proxy(path, target)
+            @proxy_paths[::Middleman::Util.normalize_path(path)] = ::Middleman::Util.normalize_path(target)
+            @app.sitemap.rebuild_resource_list!(:added_proxy)
+          end
+
+          # Update the main sitemap resource list
+          # @return [void]
+          def manipulate_resource_list(resources)
+            resources + @proxy_paths.map do |key, value|
+              p = ::Middleman::Sitemap::Resource.new(
+                @app.sitemap,
+                key
+              )
+              p.proxy_to(value)
+              p
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/middleman-core/sitemap/extensions/traversal.rb

@@ -0,0 +1,84 @@
+module Middleman
+
+  module Sitemap
+
+    module Extensions
+
+      module Traversal
+        # This resource's parent resource
+        # @return [Middleman::Sitemap::Resource, nil]
+        def parent
+          parts = path.split("/")
+          parts.pop if path.include?(app.index_file)
+
+          return nil if parts.length < 1
+
+          parts.pop
+          parts << app.index_file
+
+          parent_path = "/" + parts.join("/")
+
+          store.find_resource_by_destination_path(parent_path)
+        end
+
+        # This resource's child resources
+        # @return [Array<Middleman::Sitemap::Resource>]
+        def children
+          return [] unless directory_index?
+
+          if eponymous_directory?
+            base_path = eponymous_directory_path
+            prefix    = %r|^#{base_path.sub("/", "\\/")}|
+          else
+            base_path = path.sub("#{app.index_file}", "")
+            prefix    = %r|^#{base_path.sub("/", "\\/")}|
+          end
+
+          store.resources.select do |sub_resource|
+            if sub_resource.path == self.path || sub_resource.path !~ prefix
+              false
+            else
+              inner_path = sub_resource.path.sub(prefix, "")
+              parts = inner_path.split("/")
+              if parts.length == 1
+                true
+              elsif parts.length == 2
+                parts.last == app.index_file
+              else
+                false
+              end
+            end
+          end
+        end
+
+        # This resource's sibling resources
+        # @return [Array<Middleman::Sitemap::Resource>]
+        def siblings
+          return [] unless parent
+          parent.children.reject { |p| p == self }
+        end
+
+        # Whether this resource either a directory index, or has the same name as an existing directory in the source
+        # @return [Boolean]
+        def directory_index?
+          path.include?(app.index_file) || path =~ /\/$/ || eponymous_directory?
+        end
+
+        # Whether the resource has the same name as a directory in the source
+        # (e.g., if the resource is named 'gallery.html' and a path exists named 'gallery/', this would return true)
+        # @return [Boolean]
+        def eponymous_directory?
+          full_path = File.join(app.source_dir, eponymous_directory_path)
+          !!(File.exists?(full_path) && File.directory?(full_path))
+        end
+
+        # The path for this resource if it were a directory, and not a file
+        # (e.g., for 'gallery.html' this would return 'gallery/')
+        # @return [String]
+        def eponymous_directory_path
+          path.sub(ext, '/').sub(/\/$/, "") + "/"
+        end
+      end
+    end
+  end
+end

data/lib/middleman-core/sitemap/resource.rb

@@ -0,0 +1,149 @@
+require "middleman-core/sitemap/extensions/traversal"
+
+module Middleman
+
+  # Sitemap namespace
+  module Sitemap
+
+    # Sitemap Resource class
+    class Resource
+      include Middleman::Sitemap::Extensions::Traversal
+
+      # @return [Middleman::Application]
+      attr_reader :app
+      delegate :logger, :instrument, :to => :app
+
+      # @return [Middleman::Sitemap::Store]
+      attr_reader :store
+
+      # The source path of this resource (relative to the source directory,
+      # without template extensions)
+      # @return [String]
+      attr_reader :path
+
+      # Set the on-disk source file for this resource
+      # @return [String]
+      # attr_reader :source_file
+
+      def source_file
+        @source_file || get_source_file
+      end
+
+      # Initialize resource with parent store and URL
+      # @param [Middleman::Sitemap::Store] store
+      # @param [String] path
+      # @param [String] source_file
+      def initialize(store, path, source_file=nil)
+        @store       = store
+        @app         = @store.app
+        @path        = path
+        @source_file = source_file
+
+        @destination_paths = [@path]
+
+        @local_metadata = { :options => {}, :locals => {}, :page => {}, :blocks => [] }
+      end
+
+      # Whether this resource has a template file
+      # @return [Boolean]
+      def template?
+        return false if source_file.nil?
+        !::Tilt[source_file].nil?
+      end
+
+      # Get the metadata for both the current source_file and the current path
+      # @return [Hash]
+      def metadata
+        result = store.metadata_for_path(path).dup
+
+        file_meta = store.metadata_for_file(source_file).dup
+        if file_meta.has_key?(:blocks)
+          result[:blocks] << file_meta.delete(:blocks)
+        end
+        result.deep_merge!(file_meta)
+
+        local_meta = @local_metadata.dup
+        if local_meta.has_key?(:blocks)
+          result[:blocks] << local_meta.delete(:blocks)
+        end
+        result.deep_merge!(local_meta)
+
+        result[:blocks] = result[:blocks].flatten.compact
+
+        result
+      end
+
+      # Merge in new metadata specific to this resource.
+      # @param [Hash] metadata A metadata block like provides_metadata_for_path takes
+      def add_metadata(metadata={}, &block)
+        if metadata.has_key?(:blocks)
+          @local_metadata[:blocks] << metadata.delete(:blocks)
+        end
+        @local_metadata.deep_merge!(metadata)
+        @local_metadata[:blocks] << block if block_given?
+      end
+
+      # Get the output/preview URL for this resource
+      # @return [String]
+      def destination_path
+        @destination_paths.last
+      end
+
+      # Set the output/preview URL for this resource
+      # @param [String] path
+      # @return [void]
+      def destination_path=(path)
+        @destination_paths << path
+      end
+
+      # Extension of the path (i.e. '.js')
+      # @return [String]
+      def ext
+        File.extname(path)
+      end
+
+      # Mime type of the path
+      # @return [String]
+      def mime_type
+        app.mime_type ext
+      end
+
+      # Render this resource
+      # @return [String]
+      def render(opts={}, locs={}, &block)
+        return File.open(source_file).read unless template?
+
+        relative_source = Pathname(source_file).relative_path_from(Pathname(app.root))
+
+        instrument "render.resource", :path => relative_source  do
+          md   = metadata.dup
+          opts = md[:options].deep_merge(opts)
+          locs = md[:locals].deep_merge(locs)
+
+          # Forward remaining data to helpers
+          if md.has_key?(:page)
+            app.data.store("page", md[:page])
+          end
+
+          blocks = md[:blocks].dup rescue []
+          blocks << block if block_given?
+
+          app.current_path ||= self.destination_path
+          app.render_template(source_file, locs, opts, blocks)
+        end
+      end
+
+      # A path without the directory index - so foo/index.html becomes
+      # just foo. Best for linking.
+      # @return [String]
+      def url
+        url_path = destination_path
+        if app.strip_index_file
+          url_path = url_path.sub(/(^|\/)#{Regexp.escape(app.index_file)}$/,
+                                  app.trailing_slash ? '/' : '')
+        end
+        File.join(app.respond_to?(:http_prefix) ? app.http_prefix : '/', url_path)
+      end
+    end
+  end
+end