middleman-core 3.0.0.alpha.7

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

@@ -0,0 +1,30 @@
+# Base helper to manipulate asset paths
+module Middleman::CoreExtensions::Assets
+  
+  # Extension registered
+  class << self
+    # @private
+    def registered(app)
+      # Disable Padrino cache buster
+      app.set :asset_stamp, false
+      
+      # Include helpers
+      app.send :include, InstanceMethod
+    end
+    alias :included :registered
+  end
+  
+  # Methods to be mixed-in to Middleman::Base
+  module InstanceMethod
+    
+    # Get the URL of an asset given a type/prefix
+    #
+    # @param [String] path The path (such as "photo.jpg")
+    # @param [String] prefix The type prefix (such as "images")
+    # @return [String] The fully qualified asset url
+    def asset_url(path, prefix="")
+      # Don't touch assets which already have a full path
+      path.include?("://") ? path : File.join(http_prefix, prefix, path)
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+# Convenience methods to allow config.rb to talk to the Builder
+module Middleman::CoreExtensions::Builder
+  
+  # Extension registered
+  class << self
+    # @private
+    def registered(app)
+      app.define_hook :after_build
+      app.extend ClassMethods
+      app.send :include, InstanceMethods
+      app.delegate :build_reroute, :to => :"self.class"
+    end
+    alias :included :registered
+  end
+  
+  # Build Class Methods
+  module ClassMethods
+    # Get a list of callbacks which can modify a files build path
+    #
+    # @return [Array<Proc>]
+    def build_reroute(&block)
+      @build_rerouters ||= []
+      @build_rerouters << block if block_given?
+      @build_rerouters
+    end
+  end
+  
+  # Build Instance Methods
+  module InstanceMethods
+    # Run through callbacks and get the new values
+    #
+    # @param [String] destination The current destination of the built file
+    # @param [String] request_path The current request path of the file
+    # @return [Array<String>] The new values
+    def reroute_builder(destination, request_path)
+      result = [destination, request_path]
+      
+      build_reroute.each do |block|
+        output = instance_exec(destination, request_path, &block)
+        if output
+          result = output
+          break
+        end
+      end
+      
+      result
+    end
+  end
+end

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

@@ -0,0 +1,193 @@
+# 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
+  
+  # Instance methods
+  module InstanceMethods
+    # Setup data files before anything else so they are available when
+    # parsing config.rb
+    def initialize
+      file_changed DataStore.matcher do |file|
+        data.touch_file(file) if file.match(%r{^#{data_dir}\/})
+      end
+    
+      file_deleted DataStore.matcher do |file|
+        data.remove_file(file) if file.match(%r{^#{data_dir}\/})
+      end
+      
+      super
+    end
+    
+    # The data object
+    #
+    # @return [DataStore]
+    def data
+      @data ||= DataStore.new(self)
+    end
+
+    # Makes a hash available on the data var with a given name
+    #
+    # @param [Symbol] name Name of the data, used for namespacing
+    # @param [Hash] content The content for this data
+    # @return [void]
+    def data_content(name, content)
+      DataStore.data_content(name, content)
+    end
+
+    # Makes a hash available on the data var with a given name
+    #
+    # @param [Symbol] name Name of the data, used for namespacing
+    # @return [void]
+    def data_callback(name, &block)
+      DataStore.data_callback(name, block)
+    end
+  end
+  
+  # The core logic behind the data extension.
+  class DataStore
+    
+    # Static methods
+    class << self
+      
+      # The regex which tells Middleman which files are for data
+      #
+      # @return [Regexp]
+      def matcher
+        %r{[\w-]+\.(yml|yaml|json)$}
+      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 data_content(name, content)
+        @@local_sources ||= {}
+        @@local_sources[name.to_s] = content
+      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 data_callback(name, proc)
+        @@callback_sources ||= {}
+        @@callback_sources[name.to_s] = proc
+      end
+    end
+    
+    # Setup data store
+    #
+    # @param [Middleman::Base] 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)
+      
+      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.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
+    
+    # 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 ||= {}
+      
+      if @@local_sources.has_key?(path.to_s)
+        response = @@local_sources[path.to_s]
+      elsif @@callback_sources.has_key?(path.to_s)
+        response = @@callback_sources[path.to_s].call()
+      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)
+      
+        if result
+          return ::Middleman.recursively_enhance(result)
+        end
+      end
+      
+      super
+    end
+    
+    # Convert all the data into a static hash
+    #
+    # @return [Hash]
+    def to_h
+      data = {}
+      
+      @@local_sources ||= {}
+      @@callback_sources ||= {}
+      
+      (@@local_sources || {}).each do |k, v|
+        data[k] = data_for_path(k)
+      end
+      
+      (@@callback_sources || {}).each do |k, v|
+        data[k] = data_for_path(k)
+      end
+      
+      (@local_data || {}).each do |k, v|
+        data[k] = v
+      end
+      
+      data
+    end
+  end
+end

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

@@ -0,0 +1,119 @@
+require "middleman-core/vendor/padrino-core-0.10.5/lib/padrino-core/support_lite"
+# require 'i18n'
+require 'enumerator'
+# require 'active_support/core_ext/string/conversions'  # to_date
+require 'active_support/core_ext/float/rounding'      # round
+require 'active_support/option_merger'                # with_options
+require 'active_support/core_ext/object/with_options' # with_options
+# require 'active_support/inflector'                    # humanize
+
+FileSet.glob_require('../vendor/padrino-helpers-0.10.5/lib/padrino-helpers/**/*.rb', __FILE__)
+
+# 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.join(root, 'locales', '*.yml')}"]
+      # end
+    end
+    alias :included :registered
+  end
+  
+  # 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
+    
+    # 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
+
+    # 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
+      
+      # 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)
+        
+      yield path if sitemap.exists?(File.join(asset_dir, 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
+  end
+end

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

@@ -0,0 +1,148 @@
+# Middleman provides an extension API which allows you to hook into the
+# lifecycle of a page request, or static build, and manipulate the output.
+# Internal to Middleman, these extensions are called "features," but we use
+# the exact same API as is made available to the public.
+#
+# A Middleman extension looks like this:
+#
+#     module MyExtension
+#       class << self
+#         def registered(app)
+#           # My Code
+#         end
+#       end
+#     end
+#
+# In your `config.rb`, you must load your extension (if it is not defined in
+# that file) and call `activate`.
+#
+#     require "my_extension"
+#     activate MyExtension
+#
+# This will call the `registered` method in your extension and provide you
+# with the `app` parameter which is a Middleman::Base context. From here
+# you can choose to respond to requests for certain paths or simply attach
+# Rack middleware to the stack.
+#
+# The built-in features cover a wide range of functions. Some provide helper
+# methods to use in your views. Some modify the output on-the-fly. And some
+# apply computationally-intensive changes to your final build files.
+
+# Using for version parsing
+require "rubygems"
+
+# Namespace extensions module
+module Middleman::CoreExtensions::Extensions
+  
+  # Register extension
+  class << self
+    # @private
+    def included(app)
+      # app.set :default_extensions, []
+      app.define_hook :after_configuration
+      app.define_hook :before_configuration
+      app.define_hook :build_config
+      app.define_hook :development_config
+      
+      app.extend ClassMethods
+      app.send :include, InstanceMethods
+      app.delegate :configure, :to => :"self.class"
+    end
+  end
+
+  # Class methods
+  module ClassMethods
+    # Add a callback to run in a specific environment
+    #
+    # @param [String, Symbol] env The environment to run in
+    # @return [void]
+    def configure(env, &block)
+      send("#{env}_config", &block)
+    end
+    
+    # Alias `extensions` to access registered extensions
+    #
+    # @return [Array<Module]
+    def extensions
+      @extensions ||= []
+    end
+    
+    # Register a new extension
+    # 
+    # @param [Array<Module>] new_extensions Extension modules to register
+    # @return [Array<Module]
+    def register(extension, options={}, &block)
+      @extensions ||= []
+      @extensions += [extension]
+      
+      extend extension
+      if extension.respond_to?(:registered)
+        if extension.method(:registered).arity === 1
+          extension.registered(self, &block)
+        else
+          extension.registered(self, options, &block)
+        end
+      end
+    end
+  end
+  
+  # Instance methods
+  module InstanceMethods
+    # This method is available in the project's `config.rb`.
+    # It takes a underscore-separated symbol, finds the appropriate
+    # feature module and includes it.
+    #
+    #     activate :lorem
+    #
+    # @param [Symbol, Module] ext Which extension to activate
+    # @return [void]
+    def activate(ext, options={}, &block)
+      if !ext.is_a?(Module)
+        ext = ::Middleman::Extensions.load(ext.to_sym)
+      end
+      
+      if ext.nil?
+        puts "== Unknown Extension: #{feature}"
+      elsif ext.is_a?(String)
+        puts ext
+      else
+        puts "== Activating: #{feature}" if logging?
+        self.class.register(ext, options, &block)
+      end
+    end
+    
+    # Load features before starting server
+    def initialize
+      super
+      
+      self.class.inst = self
+      run_hook :before_configuration
+    
+      # Search the root of the project for required files
+      $LOAD_PATH.unshift(root)
+      
+      # Check for and evaluate local configuration
+      local_config = File.join(root, "config.rb")
+      if File.exists? local_config
+        puts "== Reading:  Local config" if logging?
+        instance_eval File.read(local_config)
+      end
+      
+      run_hook :build_config if build?
+      run_hook :development_config if development?
+      
+      run_hook :after_configuration
+      
+      # Add in defaults
+      default_extensions.each do |ext|
+        activate ext
+      end
+      
+      if logging?
+        self.class.extensions.each do |ext|
+          puts "== Extension: #{ext}"
+        end
+      end
+    end
+  end
+end