middleman-core-x86-mingw32 3.0.1.pre

data/lib/middleman-core/core_extensions/file_watcher.rb

@@ -0,0 +1,167 @@
+require "pathname"
+require "set"
+
+# API for watching file change events
+module Middleman
+  module CoreExtensions
+    module FileWatcher
+
+      IGNORE_LIST = [
+        /^\.bundle\//,
+        /^\.sass-cache\//,
+        /^\.git\//,
+        /^\.gitignore$/,
+        /^\.DS_Store$/,
+        /^build\//,
+        /^\.rbenv-.*$/,
+        /^Gemfile$/,
+        /^Gemfile\.lock$/,
+        /~$/,
+        /(^|\/)\.?#/
+      ]
+
+      # Setup extension
+      class << self
+
+        # Once registered
+        def registered(app)
+          app.send :include, InstanceMethods
+
+          # Before parsing config, load the data/ directory
+          app.before_configuration do
+            files.reload_path(data_dir)
+          end
+
+          # After config, load everything else
+          app.ready do
+            files.reload_path('.')
+          end
+        end
+        alias :included :registered
+      end
+
+      # Instance methods
+      module InstanceMethods
+
+        # Access the file api
+        # @return [Middleman::CoreExtensions::FileWatcher::API]
+        def files
+          @_files_api ||= API.new(self)
+        end
+      end
+
+      # Core File Change API class
+      class API
+
+        attr_reader :app
+        delegate :logger, :to => :app
+
+        # Initialize api and internal path cache
+        def initialize(app)
+          @app = app
+          @known_paths = Set.new
+
+          @_changed = []
+          @_deleted = []
+        end
+
+        # Add callback to be run on file change
+        #
+        # @param [nil,Regexp] matcher A Regexp to match the change path against
+        # @return [Array<Proc>]
+        def changed(matcher=nil, &block)
+          @_changed << [block, matcher] if block_given?
+          @_changed
+        end
+
+        # Add callback to be run on file deletion
+        #
+        # @param [nil,Regexp] matcher A Regexp to match the deleted path against
+        # @return [Array<Proc>]
+        def deleted(matcher=nil, &block)
+          @_deleted << [block, matcher] if block_given?
+          @_deleted
+        end
+
+        # Notify callbacks that a file changed
+        #
+        # @param [Pathname] path The file that changed
+        # @return [void]
+        def did_change(path)
+          return if ignored?(path)
+          logger.debug "== File Change: #{path}"
+          @known_paths << path
+          self.run_callbacks(path, :changed)
+        end
+
+        # Notify callbacks that a file was deleted
+        #
+        # @param [Pathname] path The file that was deleted
+        # @return [void]
+        def did_delete(path)
+          return if ignored?(path)
+          logger.debug "== File Deletion: #{path}"
+          @known_paths.delete(path)
+          self.run_callbacks(path, :deleted)
+        end
+
+        # Manually trigger update events
+        #
+        # @param [Pathname] path The path to reload
+        # @param [Boolean] only_new Whether we only look for new files
+        # @return [void]
+        def reload_path(path, only_new=false)
+          # chdir into the root directory so Pathname can work with relative paths
+          Dir.chdir @app.root_path do
+            path = Pathname(path)
+            return unless path.exist?
+
+            glob = (path + "**/*").to_s
+            subset = @known_paths.select { |p| p.fnmatch(glob) }
+
+            ::Middleman::Util.all_files_under(path).each do |filepath|
+              if only_new
+                next if subset.include?(filepath)
+              else
+                subset.delete(filepath)
+              end
+
+              self.did_change(filepath)
+            end
+
+            subset.each(&method(:did_delete)) unless only_new
+          end
+        end
+
+        # Like reload_path, but only triggers events on new files
+        #
+        # @param [Pathname] path The path to reload
+        # @return [void]
+        def find_new_files(path)
+          reload_path(path, true)
+        end
+
+      protected
+        # Whether this path is ignored
+        # @param [Pathname] path
+        # @return [Boolean]
+        def ignored?(path)
+          IGNORE_LIST.any? { |r| path.to_s.match(r) }
+        end
+
+        # Notify callbacks for a file given an array of callbacks
+        #
+        # @param [Pathname] path The file that was changed
+        # @param [Symbol] callbacks_name The name of the callbacks method
+        # @return [void]
+        def run_callbacks(path, callbacks_name)
+          path = path.to_s
+          self.send(callbacks_name).each do |callback, matcher|
+            next unless matcher.nil? || path.match(matcher)
+            @app.instance_exec(path, &callback)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/middleman-core/core_extensions/front_matter.rb

@@ -0,0 +1,213 @@
+# Extensions namespace
+module Middleman::CoreExtensions
+
+  # Frontmatter namespace
+  module FrontMatter
+
+    # Setup extension
+    class << self
+
+      # Once registered
+      def registered(app)
+        # Parsing YAML frontmatter
+        require "yaml"
+
+        # Parsing JSON frontmatter
+        require "active_support/json"
+
+        app.send :include, InstanceMethods
+
+        app.before_configuration do
+          files.changed { |file| frontmatter_manager.clear_data(file) }
+          files.deleted { |file| frontmatter_manager.clear_data(file) }
+        end
+
+        app.after_configuration do
+          ::Middleman::Sitemap::Resource.send :include, ResourceInstanceMethods
+
+          sitemap.register_resource_list_manipulator(
+            :frontmatter,
+            frontmatter_manager
+          )
+
+          sitemap.provides_metadata do |path|
+            fmdata = frontmatter_manager.data(path).first
+
+            data = {}
+            %w(layout layout_engine).each do |opt|
+              data[opt.to_sym] = fmdata[opt] unless fmdata[opt].nil?
+            end
+
+            { :options => data, :page => fmdata }
+          end
+        end
+      end
+      alias :included :registered
+    end
+
+    class FrontmatterManager
+      attr_reader :app
+      delegate :logger, :to => :app
+
+      def initialize(app)
+        @app = app
+        @cache = {}
+      end
+
+      def data(path)
+        p = normalize_path(path)
+        @cache[p] ||= frontmatter_and_content(p)
+      end
+
+      def clear_data(file)
+        # Copied from Sitemap::Store#file_to_path, but without
+        # removing the file extension
+        file = File.expand_path(file, @app.root)
+        prefix = @app.source_dir.sub(/\/$/, "") + "/"
+        return unless file.include?(prefix)
+        path = file.sub(prefix, "")
+
+        @cache.delete(path)
+      end
+
+      YAML_ERRORS = [ Exception, ArgumentError ]
+
+      if defined?(Psych) && defined?(Psych::SyntaxError)
+        YAML_ERRORS << Psych::SyntaxError
+      end
+
+      # Parse YAML frontmatter out of a string
+      # @param [String] content
+      # @return [Array<Hash, String>]
+      def parse_yaml_front_matter(content)
+        yaml_regex = /\A(---\s*\n.*?\n?)^(---\s*$\n?)/m
+        if content =~ yaml_regex
+          content = content.sub(yaml_regex, "")
+
+          begin
+            data = YAML.load($1)
+          rescue *YAML_ERRORS => e
+            logger.error "YAML Exception: #{e.message}"
+            return false
+          end
+
+        else
+          return false
+        end
+
+        [data, content]
+      rescue
+        [{}, content]
+      end
+
+      def parse_json_front_matter(content)
+        json_regex = /\A(;;;\s*\n.*?\n?)^(;;;\s*$\n?)/m
+
+        if content =~ json_regex
+          content = content.sub(json_regex, "")
+
+          begin
+            json = ($1+$2).sub(";;;", "{").sub(";;;", "}")
+            data = ActiveSupport::JSON.decode(json)
+          rescue => e
+            logger.error "JSON Exception: #{e.message}"
+            return false
+          end
+
+        else
+          return false
+        end
+
+        [data, content]
+      rescue
+        [{}, content]
+      end
+
+      # Get the frontmatter and plain content from a file
+      # @param [String] path
+      # @return [Array<Thor::CoreExt::HashWithIndifferentAccess, String>]
+      def frontmatter_and_content(path)
+        full_path = File.expand_path(path, @app.source_dir)
+
+        content = File.read(full_path)
+        data = {}
+
+        begin
+          if content =~ /\A.*coding:/
+            lines = content.split(/\n/)
+            lines.shift
+            content = lines.join("\n")
+          end
+
+          if result = parse_yaml_front_matter(content)
+            data, content = result
+          elsif result = parse_json_front_matter(content)
+            data, content = result
+          end
+        rescue => e
+          # Probably a binary file, move on
+        end
+
+        [::Middleman::Util.recursively_enhance(data).freeze, content]
+      end
+
+      def normalize_path(path)
+        path.sub(@app.source_dir, "").sub(/^\//, "")
+      end
+
+      # Update the main sitemap resource list
+      # @return [void]
+      def manipulate_resource_list(resources)
+        resources.each do |r|
+          if !r.proxy? && r.data["ignored"] == true
+            r.frontmatter_ignored = true
+          end
+        end
+
+        resources
+      end
+    end
+
+    module ResourceInstanceMethods
+
+      def frontmatter_ignored?
+        @_frontmatter_ignored || false
+      end
+
+      def frontmatter_ignored=(v)
+        @_frontmatter_ignored = v
+      end
+
+      def ignored?
+        if frontmatter_ignored?
+          true
+        else
+          super
+        end
+      end
+
+      # This page's frontmatter
+      # @return [Hash]
+      def data
+        app.frontmatter_manager.data(source_file).first
+      end
+
+    end
+
+    module InstanceMethods
+
+      # Access the Frontmatter API
+      def frontmatter_manager
+        @_frontmatter_manager ||= FrontmatterManager.new(self)
+      end
+
+      # Get the template data from a path
+      # @param [String] path
+      # @return [String]
+      def template_data_for_file(path)
+        frontmatter_manager.data(path).last
+      end
+
+    end
+  end
+end