middleman-core 3.0.0.beta.2 → 3.0.0.beta.3

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

@@ -1,214 +1,194 @@
-# Parsing YAML frontmatter
-require "yaml"
-
-# Looking up Tilt extensions
-require "tilt"
-
-# Frontmatter namespace
-module Middleman::CoreExtensions::FrontMatter
+# Extensions namespace
+module Middleman::CoreExtensions
   
-  # Setup extension
-  class << self
-    
-    # Once registered
-    def registered(app)
-      app.set :frontmatter_extensions, %w(.htm .html .php)
-      app.extend ClassMethods
-      app.send :include, InstanceMethods
-      app.delegate :frontmatter_changed, :to => :"self.class"
-      
-      ::Middleman::Sitemap::Resource.send :include, ResourceInstanceMethods
-    end
-    alias :included :registered
-  end
+  # Frontmatter namespace
+  module FrontMatter
   
-  # Frontmatter class methods
-  module ClassMethods
+    # Setup extension
+    class << self
     
-    # Register callback on frontmatter updates
-    # @param [Regexp] matcher
-    # @return [Array<Array<Proc, Regexp>>]
-    def frontmatter_changed(matcher=nil, &block)
-      @_frontmatter_changed ||= []
-      @_frontmatter_changed << [block, matcher] if block_given?
-      @_frontmatter_changed
-    end
-  end
-  
-  module ResourceInstanceMethods
+      # 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
 
-    # This page's frontmatter
-    # @return [Hash]
-    def data
-      app.frontmatter(relative_path).first
+          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] if fmdata[opt]
+            end
+          
+            { :options => data, :page => fmdata }
+          end
+        end
+      end
+      alias :included :registered
     end
-    
-  end
   
-  # Frontmatter instance methods
-  module InstanceMethods
-    
-    # Override init
-    def initialize
-      exts = frontmatter_extensions.join("|").gsub(".", "\.")
-      
-      static_path = source_dir.sub(root, "").sub(/^\//, "").sub(/\/$/, "") + "/"
-
-      matcher = %r{#{static_path}.*(#{exts})}
+    class FrontmatterManager
+      def initialize(app)
+        @app = app
+        @cache = {}
+      end
       
-      files.changed matcher do |file|
-        frontmatter_extension.touch_file(file)
+      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, "")
 
-      files.deleted matcher do |file|
-        frontmatter_extension.remove_file(file)
+        @cache.delete(path)
       end
+      
+      # Parse YAML frontmatter out of a string
+      # @param [String] content
+      # @return [Array<Hash, String>]
+      def parse_yaml_front_matter(content)
+        yaml_regex = /^(---\s*\n.*?\n?)^(---\s*$\n?)/m
+        if content =~ yaml_regex
+          content = content.sub(yaml_regex, "")
 
-      sitemap.provides_metadata matcher do |path|
-        relative_path = path.sub(self.source_dir, "")
+          begin
+            data = YAML.load($1)
+          rescue => e
+            puts "YAML Exception: #{e.message}"
+            return false
+          end
 
-        fmdata = if self.frontmatter_extension.has_data?(relative_path)
-          self.frontmatter(relative_path)[0]
         else
-          {}
-        end
-
-        data = {}
-        %w(layout layout_engine).each do |opt|
-          data[opt.to_sym] = fmdata[opt] if fmdata.has_key?(opt)
+          return false
         end
 
-        { :options => data, :page => fmdata }
+        [data, content]
+      rescue
+        [{}, content]
       end
+      
+      def parse_json_front_matter(content)
+        json_regex = /^(\{\{\{\s*\n.*?\n?)^(\}\}\}\s*$\n?)/m
+        
+        if content =~ json_regex
+          content = content.sub(json_regex, "")
 
-      # Initialize class
-      frontmatter_extension
+          begin
+            json = ($1+$2).sub("{{{", "{").sub("}}}", "}")
+            data = ActiveSupport::JSON.decode(json)
+          rescue => e
+            puts "JSON Exception: #{e.message}"
+            return false
+          end
 
-      super
-    end
+        else
+          return false
+        end
 
-    # Notify callbacks that the frontmatter changed
-    # @param [String] path
-    # @return [void]
-    def frontmatter_did_change(path)
-      frontmatter_changed.each do |callback, matcher|
-        next if path.match(%r{^#{build_dir}/})
-        next if !matcher.nil? && !path.match(matcher)
-        instance_exec(path, &callback)
+        [data, content]
+      rescue
+        [{}, content]
       end
-    end
-    
-    # Get the frontmatter object
-    # @return [Middleman::CoreExtensions::FrontMatter::FrontMatter]
-    def frontmatter_extension
-      @_frontmatter_extension ||= FrontMatter.new(self)
-    end
-    
-    # Get the frontmatter for the given params
-    # @param [String] path
-    # @return [Hash, nil]
-    def frontmatter(*args)
-      frontmatter_extension.data(*args)
-    end
-  end
-  
-  # Core Frontmatter class
-  class FrontMatter
-    
-    # Initialize frontmatter with current app
-    # @param [Middleman::Application] app
-    def initialize(app)
-      @app = app
-      @source = File.expand_path(@app.source, @app.root)
-      @local_data = {}
       
-      # Setup ignore callback
-      @app.ignore do |path|
-        if p = @app.sitemap.find_resource_by_path(path)
-          !p.proxy? && p.data && p.data["ignored"] == true
+      # 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)
+
+        if result = parse_yaml_front_matter(content)
+          data, content = result
+        elsif result = parse_json_front_matter(content)
+          data, content = result
         else
-          false
+          data = {}
         end
+
+        [::Middleman::Util.recursively_enhance(data).freeze, content]
       end
-    end
-    
-    # Whether the frontmatter knows about a path
-    # @param [String] path
-    # @return [Boolean]
-    def has_data?(path)
-      @local_data.has_key?(path.to_s)
-    end
-    
-    # Update frontmatter if a file changes
-    # @param [String] file
-    # @return [void]
-    def touch_file(file)
-      extension = File.extname(file).sub(/\./, "")
-      return unless ::Tilt.mappings.has_key?(extension)
       
-      file = File.expand_path(file, @app.root)
-      content = File.read(file)
+      def normalize_path(path)
+        path.sub(@app.source_dir, "").sub(/^\//, "")
+      end
       
-      result = parse_front_matter(content)
+      # 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
         
-      if result
-        data, content = result
-
-        data = ::Middleman::Util.recursively_enhance(data).freeze
-        file = file.sub(@app.source_dir, "")
-        @local_data[file] = [data, content]
-        path = File.join(@app.source_dir, file)
-        @app.cache.set([:raw_template, path], result[1])
-        @app.frontmatter_did_change(path)
+        resources
       end
     end
-    
-    # Update frontmatter if a file is delted
-    # @param [String] file
-    # @return [void]
-    def remove_file(file)
-      file = File.expand_path(file, @app.root)
-      file = file.sub(@app.source_dir, "")
+  
+    module ResourceInstanceMethods
       
-      if @local_data.has_key?(file)
-        path = File.join(@app.source_dir, file)
-        @app.cache.remove(:raw_template, path)
-        @local_data.delete(file) 
+      def frontmatter_ignored?
+        @_frontmatter_ignored || false
       end
-    end
-    
-    # Get the frontmatter for a given path
-    # @param [String] path
-    # @return [Hash]
-    def data(path)
-      if @local_data.has_key?(path.to_s)
-        @local_data[path.to_s]
-      else
-        {}.freeze
+      
+      def frontmatter_ignored=(v)
+        @_frontmatter_ignored = v
       end
-    end
-    
-  private
-    # Parse frontmatter out of a string
-    # @param [String] content
-    # @return [Array<Hash, String>]
-    def parse_front_matter(content)
-      yaml_regex = /^(---\s*\n.*?\n?)^(---\s*$\n?)/m
-      if content =~ yaml_regex
-        content = content[($1.size + $2.size)..-1]
-        
-        begin
-          data = YAML.load($1)
-        rescue => e
-          puts "YAML Exception: #{e.message}"
-          return false
+      
+      def ignored?
+        if frontmatter_ignored?
+          true
+        else
+          super
         end
+      end
 
-      else
-        return false
+      # This page's frontmatter
+      # @return [Hash]
+      def data
+        app.frontmatter_manager.data(source_file).first
       end
 
-      [data, content]
+    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

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

@@ -1,136 +1,145 @@
 # i18n Namespace
-module Middleman::CoreExtensions::I18n
+module Middleman
+  module CoreExtensions
+    module I18n
 
-  # Setup extension
-  class << self
+      # Setup extension
+      class << self
     
-    # Once registerd
-    def registered(app)
-      app.set :locales_dir, "locales"
+        # Once registerd
+        def registered(app)
+          app.set :locales_dir, "locales"
 
-      app.send :include, InstanceMethods
+          app.send :include, InstanceMethods
       
-      # Needed for helpers as well
-      app.after_configuration do
-        ::I18n.load_path = [Dir[File.join(root, locales_dir, "*.yml")]]
-        ::I18n.reload!
+          # Needed for helpers as well
+          app.after_configuration do
+            # This is for making the tests work - since the tests
+            # don't completely reload middleman, I18n.load_path can get
+            # polluted with paths from other test app directories that don't 
+            # exist anymore.
+            ::I18n.load_path.delete_if {|path| path =~ %r{tmp/aruba}}
+            ::I18n.load_path += Dir[File.join(root, locales_dir, "*.yml")]
+            ::I18n.reload!
+          end
+        end
+        alias :included :registered
       end
-    end
-    alias :included :registered
-  end
   
-  class Localizer
-    def initialize(app)
-      @app = app
-      @maps = {}
-    end
+      class Localizer
+        def initialize(app)
+          @app = app
+          @maps = {}
+        end
     
-    def setup(options)
-      @options = options
+        def setup(options)
+          @options = options
       
-      @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
+          @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
       
-      if !@app.build?
-        puts "== Locales: #{langs.join(", ")}"
-      end
+          if !@app.build?
+            puts "== Locales: #{langs.join(", ")}"
+          end
       
-      # Don't output localizable files
-      @app.ignore File.join(@templates_dir, "**")
+          # 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
-          instance_vars = Proc.new {
-            ::I18n.locale = lang
-            @lang         = lang
-            @page_id      = page_id
-          }
-          { :blocks => [instance_vars] }
-        else
-          {}
-        end
-      end
+          @app.sitemap.provides_metadata_for_path do |url|
+            if d = get_localization_data(url)
+              lang, page_id = d
+              instance_vars = Proc.new {
+                ::I18n.locale = lang
+                @lang         = lang
+                @page_id      = page_id
+              }
+              { :blocks => [instance_vars] }
+            else
+              {}
+            end
+          end
       
-      @app.sitemap.register_resource_list_manipulator(
-        :i18n,
-        @app.i18n
-      )
-    end
+          @app.sitemap.register_resource_list_manipulator(
+            :i18n,
+            @app.i18n
+          )
+        end
     
-    def langs
-      @options[:langs] || begin
-        Dir[File.join(@app.root, @app.locales_dir, "*.yml")].map { |file| 
-          File.basename(file).gsub(".yml", "") 
-        }.sort.map(&:to_sym)
-      end
-    end
+        def langs
+          @options[:langs] || begin
+            Dir[File.join(@app.root, @app.locales_dir, "*.yml")].map { |file| 
+              File.basename(file).gsub(".yml", "") 
+            }.sort.map(&:to_sym)
+          end
+        end
     
-    def get_localization_data(path)
-      @_localization_data ||= {}
-      @_localization_data[path]
-    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 = {}
+        # Update the main sitemap resource list
+        # @return [void]
+        def manipulate_resource_list(resources)
+          @_localization_data = {}
       
-      new_resources = []
+          new_resources = []
       
-      resources.each do |resource|
-        next unless File.fnmatch(File.join(@templates_dir, "**"), resource.path)
+          resources.each do |resource|
+            next unless File.fnmatch(File.join(@templates_dir, "**"), resource.path)
         
-        page_id = File.basename(resource.path, File.extname(resource.path))
+            page_id = File.basename(resource.path, File.extname(resource.path))
       
-        langs.map do |lang|
-          ::I18n.locale = lang
+            langs.map do |lang|
+              ::I18n.locale = lang
         
-          localized_page_id = ::I18n.t("paths.#{page_id}", :default => page_id)
-          path = resource.path.sub(@templates_dir, "")
+              localized_page_id = ::I18n.t("paths.#{page_id}", :default => page_id)
+              path = resource.path.sub(@templates_dir, "")
           
-          # 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
+              # 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
           
-          path = ::Middleman::Util.normalize_path(
-            File.join(prefix, path.sub(page_id, localized_page_id))
-          )
+              path = ::Middleman::Util.normalize_path(
+                File.join(prefix, path.sub(page_id, localized_page_id))
+              )
           
-          @_localization_data[path] = [lang, path, localized_page_id]
+              @_localization_data[path] = [lang, path, localized_page_id]
           
-          p = ::Middleman::Sitemap::Resource.new(
-            @app.sitemap,
-            path
-          )
-          p.proxy_to(resource.path)
+              p = ::Middleman::Sitemap::Resource.new(
+                @app.sitemap,
+                path
+              )
+              p.proxy_to(resource.path)
           
-          new_resources << p
+              new_resources << p
+            end
+          end
+      
+          resources + new_resources
         end
       end
-      
-      resources + new_resources
-    end
-  end
   
-  # Frontmatter class methods
-  module InstanceMethods
+      # Frontmatter class methods
+      module InstanceMethods
     
-    # Initialize the i18n
-    def i18n
-      @_i18n ||= Localizer.new(self)
-    end
+        # Initialize the i18n
+        def i18n
+          @_i18n ||= Localizer.new(self)
+        end
     
-    # Main i18n API
-    def localize(options={})
-      settings.after_configuration do
-        i18n.setup(options)
+        # Main i18n API
+        def localize(options={})
+          settings.after_configuration do
+            i18n.setup(options)
+          end
+        end
       end
     end
   end