middleman 2.0.9.pre-x86-mswin32

data/lib/middleman/core_extensions/assets.rb

@@ -0,0 +1,57 @@
+module Middleman::CoreExtensions::Assets
+  class << self
+    def registered(app)
+      # Disable Padrino cache buster until explicitly enabled
+      app.set :asset_stamp, false
+      
+      app.extend ClassMethods
+      
+      app.helpers Helpers
+      
+      app.register_asset_handler :base do |path, prefix, request|
+        path.include?("://") ? path : File.join(app.http_prefix || "/", prefix, path)
+      end
+    end
+    alias :included :registered
+  end
+  
+  module ClassMethods    
+    def register_asset_handler(handler_name, &block)
+      @asset_handler_map   ||= []
+      @asset_handler_stack ||= []
+      
+      if block_given?
+        @asset_handler_stack << block
+        @asset_handler_map   << handler_name
+      end
+    end
+    
+    def asset_handler_get_url(path, prefix="", request=nil)
+      @asset_handler_map   ||= []
+      @asset_handler_stack ||= []
+      
+      @asset_handler_stack.last.call(path, prefix, request)
+    end
+    
+    def before_asset_handler(position, *args)
+      @asset_handler_map   ||= []
+      @asset_handler_stack ||= []
+      
+      current_index = @asset_handler_map.index(position)
+      return nil unless current_index
+
+      previous = current_index - 1
+      if (previous >= 0) && (previous < @asset_handler_map.length)
+        @asset_handler_stack[previous].call(*args)
+      else
+        nil
+      end
+    end
+  end
+  
+  module Helpers
+    def asset_url(path, prefix="")
+      self.class.asset_handler_get_url(path, prefix, request)
+    end
+  end
+end

data/lib/middleman/core_extensions/builder.rb

@@ -0,0 +1,41 @@
+module Middleman::CoreExtensions::Builder
+  class << self
+    def registered(app)
+      app.extend ClassMethods
+    end
+  end
+  
+  module ClassMethods
+    # Add a block/proc to be run after features have been setup
+    def after_build(&block)
+      @run_after_build ||= []
+      @run_after_build << block
+    end
+
+    def after_build_callbacks
+      @run_after_build ||= []
+      @run_after_build
+    end
+    
+    def build_reroute(&block)
+      @build_rerouters ||= []
+      @build_rerouters << block
+    end
+    
+    def reroute_builder(desination, request_path)
+      @build_rerouters ||= []
+      
+      result = [desination, request_path]
+      
+      @build_rerouters.each do |block|
+        output = block.call(desination, request_path)
+        if output
+          result = output
+          break
+        end
+      end
+      
+      result
+    end
+  end
+end

data/lib/middleman/core_extensions/compass.rb

@@ -0,0 +1,102 @@
+module Middleman::CoreExtensions::Compass
+  class << self
+    def registered(app)
+      app.extend ClassMethods
+        
+      require "compass"
+      
+      # Susy grids
+      begin
+        require "susy"
+      rescue LoadError
+      end
+
+      app.after_configuration do
+        # Support a stand-alone compass config file
+        # Many options are overwritten by Middleman, but the config is a good
+        # place to add:
+        # * output_style
+        # * disable_warnings
+        # * sass_options
+        # * line_comments
+        # * sprite_engine
+        # * chunky_png_options
+        compass_config_file = File.join(app.root, "compass.config")
+        if File.exists?(compass_config_file)
+          ::Compass.add_project_configuration(compass_config_file)
+        end
+        
+        ::Compass.configuration do |config|
+          config.project_path          = app.root
+          config.environment           = :development
+          config.cache_path            = File.join(app.root, ".sass-cache")
+          
+          views_root = File.basename(app.views)
+          config.sass_dir              = File.join(views_root, app.css_dir)
+          config.css_dir               = File.join(views_root, app.css_dir)
+          config.javascripts_dir       = File.join(views_root, app.js_dir)
+          config.fonts_dir             = File.join(views_root, app.fonts_dir)
+          config.images_dir            = File.join(views_root, app.images_dir)
+          
+          config.http_images_path = if app.respond_to? :http_images_path
+            app.http_images_path
+          else
+            File.join(app.http_prefix || "/", app.images_dir)
+          end
+          
+          config.http_stylesheets_path = if app.respond_to? :http_css_path
+            app.http_css_path
+          else
+            File.join(app.http_prefix || "/", app.css_dir)
+          end
+          
+          config.http_javascripts_path = if app.respond_to? :http_js_path
+            app.http_js_path
+          else
+            File.join(app.http_prefix || "/", app.js_dir)
+          end
+
+          config.http_javascripts_path = if app.respond_to? :http_fonts_path
+            app.http_js_path
+          else
+            File.join(app.http_prefix || "/", app.fonts_dir)
+          end
+          
+          config.asset_cache_buster :none
+          config.output_style = :nested
+
+          config.add_import_path(config.sass_dir)
+        end
+        
+        # Required for relative paths
+        configure :build do
+          ::Compass.configuration do |config|
+            config.environment = :production
+             
+            build_root = File.basename(self.build_dir)
+            config.css_dir     = File.join(build_root, self.css_dir)
+            config.images_dir  = File.join(build_root, self.images_dir)
+          end
+        end
+        
+        app.execute_after_compass_init!
+        
+        app.set :sass, ::Compass.configuration.to_sass_engine_options
+      end
+    end
+    alias :included :registered
+  end
+  
+  module ClassMethods
+    # Add a block/proc to be run after features have been setup
+    def compass_config(&block)
+      @run_after_compass ||= []
+      @run_after_compass << block
+    end
+    
+    def execute_after_compass_init!
+      @run_after_compass ||= []
+      @run_after_compass.each { |block| block.call(::Compass.configuration) }
+    end
+  end
+end

data/lib/middleman/core_extensions/data.rb

@@ -0,0 +1,120 @@
+require "yaml"
+require "thor"
+
+module Middleman::CoreExtensions::Data
+  class << self
+    def registered(app)
+      app.set :data_dir, "data"
+      app.extend ClassMethods
+      app.helpers Helpers
+    end
+    alias :included :registered
+  end
+  
+  module Helpers
+    def data
+      self.class.data
+    end
+  end
+  
+  class DataObject
+    def initialize(app)
+      @app = app
+    end
+    
+    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()
+      else
+        file_path = File.join(@app.root, @app.data_dir, "#{path}.yml")
+        if File.exists? file_path
+          response = YAML.load_file(file_path)
+        end
+      end
+    end
+    
+    def method_missing(path)
+      result = data_for_path(path)
+      
+      if result
+        recursively_enhance(result)
+      else
+        super
+      end
+    end
+    
+    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
+      
+      yaml_path = File.join(@app.root, @app.data_dir, "*.yml")
+      Dir[yaml_path].each do |f|
+        p = f.split("/").last.gsub(".yml", "")
+        data[p] = data_for_path(p)
+      end
+      
+      data
+    end
+
+    def self.data_content(name, content)
+      @@local_sources ||= {}
+      @@local_sources[name.to_s] = content
+    end
+    
+    def self.data_callback(name, proc)
+      @@callback_sources ||= {}
+      @@callback_sources[name.to_s] = proc
+    end
+  
+  private
+    def recursively_enhance(data)
+      if data.is_a? Hash
+        data = Thor::CoreExt::HashWithIndifferentAccess.new(data)
+        data.each do |key, val|
+          data[key] = recursively_enhance(val)
+        end
+        data
+      elsif data.is_a? Array
+        data.each_with_index do |val, i|
+          data[i] = recursively_enhance(val)
+        end
+        data
+      else
+        data
+      end
+    end
+  end
+  
+  module ClassMethods
+    def data
+      @data ||= DataObject.new(self)
+    end
+    
+    # Makes a hash available on the data var with a given name
+    def data_content(name, content)
+      DataObject.data_content(name, content)
+    end
+    
+    # Makes a hash available on the data var with a given name
+    def data_callback(name, &block)
+      DataObject.data_callback(name, block)
+    end
+  end
+end

data/lib/middleman/core_extensions/default_helpers.rb

@@ -0,0 +1,77 @@
+require "padrino-helpers"
+
+module Middleman::CoreExtensions::DefaultHelpers
+  class << self
+    def registered(app)
+      # Use Padrino Helpers
+      app.register Padrino::Helpers
+      
+      # Middleman Helpers
+      app.helpers Helpers
+    end
+    alias :included :registered
+  end
+  
+  module Helpers
+    def auto_stylesheet_link_tag(separator="/")
+      auto_tag(:css, separator) do |path|
+        stylesheet_link_tag path
+      end
+    end
+    
+    def auto_javascript_include_tag(separator="/")
+      auto_tag(:js, separator) do |path|
+        javascript_include_tag path
+      end
+    end
+
+    def auto_tag(asset_ext, separator="/", asset_dir=nil)
+      if asset_dir.nil?
+        asset_dir = case asset_ext
+          when :js  then self.class.js_dir
+          when :css then self.class.css_dir
+        end
+      end
+      path = request.path_info.dup
+      # If the basename of the request as no extension, assume we are serving a
+      # directory and join index_file to the path.
+      path = File.join(path, self.class.index_file) if File.extname(path).empty?
+      path = path.gsub(%r{^/}, '')
+      path = path.gsub(File.extname(path), ".#{asset_ext}")
+      path = path.gsub("/", separator)
+
+      view = File.join(self.class.views, asset_dir, path)
+      yield path if File.exists?(view) or Dir["#{view}.*"].any?
+    end
+
+    def page_classes
+      path = request.path_info.dup
+      path << settings.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
+    
+    # Padrino's asset handling needs to pass through ours
+    def asset_path(kind, source)
+       return source if source =~ /^http/
+       asset_folder  = case kind
+         when :css    then settings.css_dir
+         when :js     then settings.js_dir
+         when :images then settings.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)
+       timestamp = asset_timestamp(result_path)
+       "#{result_path}#{timestamp}"
+     end
+  end
+end

data/lib/middleman/core_extensions/features.rb

@@ -0,0 +1,102 @@
+# 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::Server 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.
+
+module Middleman::CoreExtensions::Features
+  
+  # The Feature API is itself a Feature. Mind blowing!
+  class << self
+    def registered(app)
+      app.set :default_features, []
+      app.extend ClassMethods
+    end
+    alias :included :registered
+  end
+
+  module ClassMethods
+    # 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
+    #
+    # Alternatively, you can pass in a Middleman feature module directly.
+    #
+    #     activate MyFeatureModule
+    def activate(feature)
+      if feature.is_a? Symbol
+        feature = feature.to_s 
+      end
+
+      if feature.is_a? String
+        feature = feature.camelize
+        feature = Middleman::Features.const_get(feature)
+      end
+      
+      $stderr.puts "== Activating:  #{feature}" if logging?
+      register feature
+    end
+    
+    # Add a block/proc to be run after features have been setup
+    def after_configuration(&block)
+      @run_after_features ||= []
+      @run_after_features << block
+    end
+    
+    def run_after_features
+      @run_after_features || []
+    end
+    
+    # Load features before starting server
+    def new
+      # Check for and evaluate local configuration
+      local_config = File.join(self.root, "config.rb")
+      if File.exists? local_config
+        $stderr.puts "== Reading:  Local config" if logging?
+        class_eval File.read(local_config)
+        set :app_file, File.expand_path(local_config)
+      end
+      
+      # Add in defaults
+      default_features.each do |ext|
+        activate ext
+      end
+      
+      run_after_features.each { |block| class_eval(&block) }
+      
+      if logging?
+        extensions.each do |ext|
+          $stderr.puts "== Extension: #{ext}"
+        end
+      end
+      
+      super
+    end
+  end
+end