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

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

@@ -1,12 +1,17 @@
-# Convenience methods to allow config.rb to talk to the Builder
-module Middleman::CoreExtensions::Builder
+module Middleman
+  module CoreExtensions
+    
+    # Convenience methods to allow config.rb to talk to the Builder
+    module Builder
   
-  # Extension registered
-  class << self
-    # @private
-    def registered(app)
-      app.define_hook :after_build
+      # Extension registered
+      class << self
+        # @private
+        def registered(app)
+          app.define_hook :after_build
+        end
+        alias :included :registered
+      end
     end
-    alias :included :registered
   end
-end
+end

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

@@ -1,175 +1,180 @@
-# Data formats
-require "yaml"
-require "active_support/json"
-
-# The data extension parses YAML and JSON files in the data/ directory
-# and makes them available to config.rb, templates and extensions
-module Middleman::CoreExtensions::Data
-  
-  # Extension registered
-  class << self
-    # @private
-    def registered(app)
-      app.set :data_dir, "data"
-      app.send :include, InstanceMethods
-    end
-    alias :included :registered
-  end
+module Middleman
+  module CoreExtensions
+    
+    # The data extension parses YAML and JSON files in the data/ directory
+    # and makes them available to config.rb, templates and extensions
+    module Data
   
-  # Instance methods
-  module InstanceMethods
-    # Setup data files before anything else so they are available when
-    # parsing config.rb
-    def initialize
-      self.files.changed DataStore.matcher do |file|
-        self.data.touch_file(file) if file.match(%r{^#{self.data_dir}\/})
+      # Extension registered
+      class << self
+        # @private
+        def registered(app)
+          # Data formats
+          require "yaml"
+          require "active_support/json"
+      
+          app.set :data_dir, "data"
+          app.send :include, InstanceMethods
+        end
+        alias :included :registered
       end
+  
+      # Instance methods
+      module InstanceMethods
+        # Setup data files before anything else so they are available when
+        # parsing config.rb
+        def initialize
+          self.files.changed DataStore.matcher do |file|
+            self.data.touch_file(file) if file.match(%r{^#{self.data_dir}\/})
+          end
     
-      self.files.deleted DataStore.matcher do |file|
-        self.data.remove_file(file) if file.match(%r{^#{self.data_dir}\/})
-      end
+          self.files.deleted DataStore.matcher do |file|
+            self.data.remove_file(file) if file.match(%r{^#{self.data_dir}\/})
+          end
       
-      super
-    end
+          super
+        end
     
-    # The data object
-    #
-    # @return [DataStore]
-    def data
-      @_data ||= DataStore.new(self)
-    end
-  end
+        # The data object
+        #
+        # @return [DataStore]
+        def data
+          @_data ||= DataStore.new(self)
+        end
+      end
   
-  # The core logic behind the data extension.
-  class DataStore
+      # The core logic behind the data extension.
+      class DataStore
     
-    # Static methods
-    class << self
+        # Static methods
+        class << self
       
-      # The regex which tells Middleman which files are for data
-      #
-      # @return [Regexp]
-      def matcher
-        %r{[\w-]+\.(yml|yaml|json)$}
-      end
-    end
+          # The regex which tells Middleman which files are for data
+          #
+          # @return [Regexp]
+          def matcher
+            %r{[\w-]+\.(yml|yaml|json)$}
+          end
+        end
     
-    # Store static data hash
-    #
-    # @param [Symbol] name Name of the data, used for namespacing
-    # @param [Hash] content The content for this data
-    # @return [void]
-    def store(name=nil, content=nil)
-      @_local_sources ||= {}
-      @_local_sources[name.to_s] = content unless name.nil? || content.nil?
-      @_local_sources
-    end
+        # Store static data hash
+        #
+        # @param [Symbol] name Name of the data, used for namespacing
+        # @param [Hash] content The content for this data
+        # @return [void]
+        def store(name=nil, content=nil)
+          @_local_sources ||= {}
+          @_local_sources[name.to_s] = content unless name.nil? || content.nil?
+          @_local_sources
+        end
 
-    # Store callback-based data
-    #
-    # @param [Symbol] name Name of the data, used for namespacing
-    # @param [Proc] proc The callback which will return data
-    # @return [void]
-    def callbacks(name=nil, proc=nil)
-      @_callback_sources ||= {}
-      @_callback_sources[name.to_s] = proc unless name.nil? || proc.nil?
-      @_callback_sources
-    end
+        # Store callback-based data
+        #
+        # @param [Symbol] name Name of the data, used for namespacing
+        # @param [Proc] proc The callback which will return data
+        # @return [void]
+        def callbacks(name=nil, proc=nil)
+          @_callback_sources ||= {}
+          @_callback_sources[name.to_s] = proc unless name.nil? || proc.nil?
+          @_callback_sources
+        end
     
-    # Setup data store
-    #
-    # @param [Middleman::Application] app The current instance of Middleman
-    def initialize(app)
-      @app = app
-      @local_data = {}
-    end
+        # Setup data store
+        #
+        # @param [Middleman::Application] app The current instance of Middleman
+        def initialize(app)
+          @app = app
+          @local_data = {}
+        end
     
-    # Update the internal cache for a given file path
-    #
-    # @param [String] file The file to be re-parsed
-    # @return [void]
-    def touch_file(file)
-      file = File.expand_path(file, @app.root)
-      extension = File.extname(file)
-      basename  = File.basename(file, extension)
+        # Update the internal cache for a given file path
+        #
+        # @param [String] file The file to be re-parsed
+        # @return [void]
+        def touch_file(file)
+          file = File.expand_path(file, @app.root)
+          extension = File.extname(file)
+          basename  = File.basename(file, extension)
       
-      if %w(.yaml .yml).include?(extension)
-        data = YAML.load_file(file)
-      elsif extension == ".json"
-        data = ActiveSupport::JSON.decode(File.read(file))
-      else
-        return
-      end
+          if %w(.yaml .yml).include?(extension)
+            data = YAML.load_file(file)
+          elsif extension == ".json"
+            data = ActiveSupport::JSON.decode(File.read(file))
+          else
+            return
+          end
 
-      @local_data[basename] = ::Middleman::Util.recursively_enhance(data)
-    end
+          @local_data[basename] = ::Middleman::Util.recursively_enhance(data)
+        end
     
-    # Remove a given file from the internal cache
-    #
-    # @param [String] file The file to be cleared
-    # @return [void]
-    def remove_file(file)
-      extension = File.extname(file)
-      basename  = File.basename(file, extension)
-      @local_data.delete(basename) if @local_data.has_key?(basename)
-    end
+        # Remove a given file from the internal cache
+        #
+        # @param [String] file The file to be cleared
+        # @return [void]
+        def remove_file(file)
+          extension = File.extname(file)
+          basename  = File.basename(file, extension)
+          @local_data.delete(basename) if @local_data.has_key?(basename)
+        end
     
-    # Get a hash hash from either internal static data or a callback
-    #
-    # @param [String, Symbol] path The name of the data namespace
-    # @return [Hash, nil]
-    def data_for_path(path)
-      response = nil
+        # Get a hash hash from either internal static data or a callback
+        #
+        # @param [String, Symbol] path The name of the data namespace
+        # @return [Hash, nil]
+        def data_for_path(path)
+          response = nil
       
-      @@local_sources ||= {}
-      @@callback_sources ||= {}
+          @@local_sources ||= {}
+          @@callback_sources ||= {}
       
-      if self.store.has_key?(path.to_s)
-        response = self.store[path.to_s]
-      elsif self.callbacks.has_key?(path.to_s)
-        response = self.callbacks[path.to_s].call()
-      end
+          if self.store.has_key?(path.to_s)
+            response = self.store[path.to_s]
+          elsif self.callbacks.has_key?(path.to_s)
+            response = self.callbacks[path.to_s].call()
+          end
       
-      response
-    end
+          response
+        end
     
-    # "Magically" find namespaces of data if they exist
-    #
-    # @param [String] path The namespace to search for
-    # @return [Hash, nil]
-    def method_missing(path)
-      if @local_data.has_key?(path.to_s)
-        return @local_data[path.to_s]
-      else
-        result = data_for_path(path)
+        # "Magically" find namespaces of data if they exist
+        #
+        # @param [String] path The namespace to search for
+        # @return [Hash, nil]
+        def method_missing(path)
+          if @local_data.has_key?(path.to_s)
+            return @local_data[path.to_s]
+          else
+            result = data_for_path(path)
       
-        if result
-          return ::Middleman::Util.recursively_enhance(result)
-        end
-      end
+            if result
+              return ::Middleman::Util.recursively_enhance(result)
+            end
+          end
       
-      super
-    end
+          super
+        end
     
-    # Convert all the data into a static hash
-    #
-    # @return [Hash]
-    def to_h
-      data = {}
+        # Convert all the data into a static hash
+        #
+        # @return [Hash]
+        def to_h
+          data = {}
       
-      self.store.each do |k, v|
-        data[k] = data_for_path(k)
-      end
+          self.store.each do |k, v|
+            data[k] = data_for_path(k)
+          end
       
-      self.callbacks.each do |k, v|
-        data[k] = data_for_path(k)
-      end
+          self.callbacks.each do |k, v|
+            data[k] = data_for_path(k)
+          end
       
-      (@local_data || {}).each do |k, v|
-        data[k] = v
-      end
+          (@local_data || {}).each do |k, v|
+            data[k] = v
+          end
       
-      data
+          data
+        end
+      end
     end
   end
 end

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

@@ -1,110 +1,172 @@
-require 'middleman-core/vendor/padrino-helpers-0.10.6/lib/padrino-helpers'
-
-# Built-in helpers
-module Middleman::CoreExtensions::DefaultHelpers
-
-  # Extension registered
-  class << self
-    # @private
-    def registered(app)
-      app.helpers ::Padrino::Helpers::OutputHelpers
-      app.helpers ::Padrino::Helpers::TagHelpers
-      app.helpers ::Padrino::Helpers::AssetTagHelpers
-      app.helpers ::Padrino::Helpers::FormHelpers
-      app.helpers ::Padrino::Helpers::FormatHelpers
-      app.helpers ::Padrino::Helpers::RenderHelpers
-      app.helpers ::Padrino::Helpers::NumberHelpers
-      # app.helpers ::Padrino::Helpers::TranslationHelpers
-
-      app.helpers Helpers
-
-      app.ready do
-        ::I18n.load_path += Dir["#{File.dirname(__FILE__)}/../vendor/padrino-helpers-0.10.6/lib/padrino-helpers/locale/*.yml"]
-      end
-    end
-    alias :included :registered
-  end
+module Middleman
+  module CoreExtensions
+    # Built-in helpers
+    module DefaultHelpers
 
-  # The helpers
-  module Helpers
-    # Output a stylesheet link tag based on the current path
-    #
-    # @param [String] separator How to break up path in parts
-    # @return [String]
-    def auto_stylesheet_link_tag(separator="/")
-      auto_tag(:css, separator) do |path|
-        stylesheet_link_tag path
-      end
-    end
+      # Extension registered
+      class << self
+        # @private
+        def registered(app)
+          require "active_support/core_ext/integer/inflections"
+          require 'padrino-helpers'
+      
+          app.helpers ::Padrino::Helpers::OutputHelpers
+          app.helpers ::Padrino::Helpers::TagHelpers
+          app.helpers ::Padrino::Helpers::AssetTagHelpers
+          app.helpers ::Padrino::Helpers::FormHelpers
+          app.helpers ::Padrino::Helpers::FormatHelpers
+          app.helpers ::Padrino::Helpers::RenderHelpers
+          app.helpers ::Padrino::Helpers::NumberHelpers
+          # app.helpers ::Padrino::Helpers::TranslationHelpers
 
-    # Output a javascript tag based on the current path
-    #
-    # @param [String] separator How to break up path in parts
-    # @return [String]
-    def auto_javascript_include_tag(separator="/")
-      auto_tag(:js, separator) do |path|
-        javascript_include_tag path
-      end
-    end
+          app.helpers Helpers
 
-    # Output a stylesheet link tag based on the current path
-    #
-    # @param [Symbol] asset_ext The type of asset
-    # @param [String] separator How to break up path in parts
-    # @param [String] asset_dir Where to look for assets
-    # @return [void]
-    def auto_tag(asset_ext, separator="/", asset_dir=nil)
-      if asset_dir.nil?
-        asset_dir = case asset_ext
-          when :js  then js_dir
-          when :css then css_dir
+          app.set :relative_links, false
         end
+        alias :included :registered
       end
 
-      # If the basename of the request as no extension, assume we are serving a
-      # directory and join index_file to the path.
-      path = full_path(current_path.dup)
-      path = path.sub(%r{^/}, '')
-      path = path.gsub(File.extname(path), ".#{asset_ext}")
-      path = path.gsub("/", separator)
+      # The helpers
+      module Helpers
+        # Output a stylesheet link tag based on the current path
+        #
+        # @param [String] separator How to break up path in parts
+        # @return [String]
+        def auto_stylesheet_link_tag(separator="/")
+          auto_tag(:css, separator) do |path|
+            stylesheet_link_tag path
+          end
+        end
 
-      yield path if sitemap.find_resource_by_path(File.join(asset_dir, path))
-    end
+        # Output a javascript tag based on the current path
+        #
+        # @param [String] separator How to break up path in parts
+        # @return [String]
+        def auto_javascript_include_tag(separator="/")
+          auto_tag(:js, separator) do |path|
+            javascript_include_tag path
+          end
+        end
 
-    # Generate body css classes based on the current path
-    #
-    # @return [String]
-    def page_classes
-      path = current_path.dup
-      path << index_file if path.match(%r{/$})
-      path = path.gsub(%r{^/}, '')
+        # Output a stylesheet link tag based on the current path
+        #
+        # @param [Symbol] asset_ext The type of asset
+        # @param [String] separator How to break up path in parts
+        # @param [String] asset_dir Where to look for assets
+        # @return [void]
+        def auto_tag(asset_ext, separator="/", asset_dir=nil)
+          if asset_dir.nil?
+            asset_dir = case asset_ext
+              when :js  then js_dir
+              when :css then css_dir
+            end
+          end
 
-      classes = []
-      parts = path.split('.')[0].split('/')
-      parts.each_with_index { |path, i| classes << parts.first(i+1).join('_') }
+          # If the basename of the request as no extension, assume we are serving a
+          # directory and join index_file to the path.
+          path = full_path(current_path.dup)
+          path = path.sub(%r{^/}, '')
+          path = path.gsub(File.extname(path), ".#{asset_ext}")
+          path = path.gsub("/", separator)
 
-      classes.join(' ')
-    end
+          yield path if sitemap.find_resource_by_path(File.join(asset_dir, path))
+        end
 
-    # Get the path of a file of a given type
-    #
-    # @param [Symbol] kind The type of file
-    # @param [String] source The path to the file
-    # @return [String]
-    def asset_path(kind, source)
-       return source if source =~ /^http/
-       asset_folder  = case kind
-         when :css    then css_dir
-         when :js     then js_dir
-         when :images then images_dir
-         else kind.to_s
-       end
-       source = source.to_s.gsub(/\s/, '')
-       ignore_extension = (kind == :images) # don't append extension
-       source << ".#{kind}" unless ignore_extension or source =~ /\.#{kind}/
-       result_path   = source if source =~ %r{^/} # absolute path
-       result_path ||= asset_url(source, asset_folder)
-       "#{result_path}"
-     end
+        # Generate body css classes based on the current path
+        #
+        # @return [String]
+        def page_classes
+          path = current_path.dup
+          path << index_file if path.match(%r{/$})
+          path = path.gsub(%r{^/}, '')
+
+          classes = []
+          parts = path.split('.')[0].split('/')
+          parts.each_with_index { |path, i| classes << parts.first(i+1).join('_') }
+
+          classes.join(' ')
+        end
+
+        # Get the path of a file of a given type
+        #
+        # @param [Symbol] kind The type of file
+        # @param [String] source The path to the file
+        # @return [String]
+        def asset_path(kind, source)
+          return source if source =~ /^http/
+          asset_folder  = case kind
+            when :css    then css_dir
+            when :js     then js_dir
+            when :images then images_dir
+            else kind.to_s
+          end
+          source = source.to_s.gsub(/\s/, '')
+          ignore_extension = (kind == :images) # don't append extension
+          source << ".#{kind}" unless ignore_extension or source =~ /\.#{kind}/
+          result_path   = source if source =~ %r{^/} # absolute path
+          result_path ||= asset_url(source, asset_folder)
+          "#{result_path}"
+        end
+
+        # Overload the regular link_to to be sitemap-aware - if you
+        # reference a source path, either absolutely or relatively,
+        # you'll get that resource's nice URL. Also, there is a
+        # :relative option which, if set to true, will produce
+        # relative URLs instead of absolute URLs. You can also add
+        #
+        # set :relative_links, true
+        #
+        # to config.rb to have all links default to relative.
+        def link_to(*args, &block)
+          url_arg_index = block_given? ? 0 : 1
+          options_index = block_given? ? 1 : 2
+
+          if url = args[url_arg_index]
+            options = args[options_index] || {}
+            relative = options.delete(:relative)
+            
+
+            if url.include? '://'
+              raise "Can't use the relative option with an external URL" if relative
+            else
+              # Handle relative urls
+              current_dir = Pathname('/' + current_resource.path).dirname
+              path = Pathname(url)
+
+              url = current_dir.join(path).to_s if path.relative?
+
+              resource = sitemap.find_resource_by_path(url)
+              
+              # Allow people to turn on relative paths for all links with set :relative_links, true
+              # but still override on a case by case basis with the :relative parameter.
+              effective_relative = relative || false
+              if relative.nil? && relative_links
+                effective_relative = true
+              end
+
+              if resource
+                if effective_relative
+                  resource_url = resource.url
+                  new_url = Pathname(resource_url).relative_path_from(current_dir).to_s
+
+                  # Put back the trailing slash to avoid unnecessary Apache redirects
+                  if resource_url.end_with?('/') && !new_url.end_with?('/')
+                    new_url << '/'
+                  end
+                else
+                  new_url = resource.url
+                end
+
+                args[url_arg_index] = new_url
+              else
+                raise "No resource exists at #{url}" if relative
+              end
+            end
+          end
+
+          super(*args, &block)
+        end
+      end
+    end
   end
 end