middleman-core-x86-mingw32 3.0.1.pre

data/lib/middleman-core/templates/shared/config.tt

@@ -0,0 +1,92 @@
+###
+# Compass
+###
+
+# Susy grids in Compass
+# First: gem install susy --pre
+# require 'susy'
+
+# Change Compass configuration
+# compass_config do |config|
+#   config.output_style = :compact
+# end
+
+###
+# Page options, layouts, aliases and proxies
+###
+
+# Per-page layout changes:
+#
+# With no layout
+# page "/path/to/file.html", :layout => false
+#
+# With alternative layout
+# page "/path/to/file.html", :layout => :otherlayout
+#
+# A path which all have the same layout
+# with_layout :admin do
+#   page "/admin/*"
+# end
+
+# Proxy (fake) files
+# page "/this-page-has-no-template.html", :proxy => "/template-file.html" do
+#   @which_fake_page = "Rendering a fake page with a variable"
+# end
+
+###
+# Helpers
+###
+
+# Automatic image dimensions on image_tag helper
+# activate :automatic_image_sizes
+
+# Methods defined in the helpers block are available in templates
+# helpers do
+#   def some_helper
+#     "Helping"
+#   end
+# end
+
+<% if options[:css_dir] -%>
+set :css_dir, '<%= options[:css_dir] -%>'
+<% else -%>
+# Change the CSS directory
+# set :css_dir, "alternative_css_directory"
+<% end -%>
+
+<% if options[:js_dir] -%>
+set :js_dir, '<%= options[:js_dir] -%>'
+<% else -%>
+# Change the JS directory
+# set :js_dir, "alternative_js_directory"
+<% end -%>
+
+<% if options[:images_dir] -%>
+set :images_dir, '<%= options[:images_dir] -%>'
+<% else -%>
+# Change the images directory
+# set :images_dir, "alternative_image_directory"
+<% end -%>
+
+# Build-specific configuration
+configure :build do
+  # For example, change the Compass output style for deployment
+  # activate :minify_css
+
+  # Minify Javascript on build
+  # activate :minify_javascript
+
+  # Enable cache buster
+  # activate :cache_buster
+
+  # Use relative URLs
+  # activate :relative_assets
+
+  # Compress PNGs after build
+  # First: gem install middleman-smusher
+  # require "middleman-smusher"
+  # activate :smusher
+
+  # Or use a different image path
+  # set :http_path, "/Content/images/"
+end

data/lib/middleman-core/templates/shared/gitignore

@@ -0,0 +1,14 @@
+# See http://help.github.com/ignore-files/ for more about ignoring files.
+#
+# If you find yourself ignoring temporary files generated by your text editor
+# or operating system, you probably want to add a global ignore instead:
+# git config --global core.excludesfile ~/.gitignore_global
+
+# Ignore bundler config
+/.bundle
+
+# Ignore the build directory
+/build
+
+# Ignore Sass' cache
+/.sass-cache

data/lib/middleman-core/templates.rb

@@ -0,0 +1,85 @@
+# Use thor for template generation
+require "thor"
+require "thor/group"
+
+# Templates namespace
+module Middleman::Templates
+
+  # Static methods
+  class << self
+
+    # Get list of registered templates and add new ones
+    #
+    #     Middleman::Templates.register(:ext_name, klass)
+    #
+    # @param [Symbol] name The name of the template
+    # @param [Class] klass The class to be executed for this template
+    # @return [Hash] List of registered templates
+    def register(name=nil, klass=nil)
+      @_template_mappings ||= {}
+      @_template_mappings[name] = klass if name && klass
+      @_template_mappings
+    end
+
+    # Middleman::Templates.register(name, klass)
+    alias :registered :register
+  end
+
+  # Base Template class. Handles basic options and paths.
+  class Base < ::Thor::Group
+    include Thor::Actions
+
+    def initialize(names, options)
+      super
+      source_paths << File.join(File.dirname(__FILE__), 'templates')
+    end
+
+    # Required path for the new project to be generated
+    argument :location, :type => :string
+
+    # Name of the template being used to generate the project.
+    class_option :template, :default => "default"
+
+    # Output a config.ru file for Rack if --rack is passed
+    class_option :rack, :type => :boolean, :default => false
+
+    # Write a Rack config.ru file for project
+    # @return [void]
+    def generate_rack!
+      return unless options[:rack]
+      template "shared/config.ru", File.join(location, "config.ru")
+    end
+
+    # Write a Bundler Gemfile file for project
+    # @return [void]
+    def generate_bundler!
+      template "shared/Gemfile.tt", File.join(location, "Gemfile")
+
+      inside(location) do
+        ::Middleman::Cli::Bundle.new.invoke(:bundle)
+      end unless ENV["TEST"]
+    end
+
+    # Output a .gitignore file
+    class_option :git, :type => :boolean, :default => true
+
+    # Write a .gitignore file for project
+    # @return [void]
+    def generate_gitignore!
+      return unless options[:git]
+      copy_file "shared/gitignore", File.join(location, ".gitignore")
+    end
+  end
+end
+
+# Default template
+require "middleman-core/templates/default"
+
+# HTML5 template
+require "middleman-core/templates/html5"
+
+# HTML5 Mobile template
+require "middleman-core/templates/mobile"
+
+# Local templates
+require "middleman-core/templates/local"

data/lib/middleman-core/util.rb

@@ -0,0 +1,174 @@
+# Our custom logger
+require "middleman-core/logger"
+
+# For instrumenting
+require "active_support/notifications"
+
+# Using Thor's indifferent hash access
+require "thor"
+
+# Core Pathname library used for traversal
+require "pathname"
+
+module Middleman
+
+  module Util
+
+    # The logger
+    #
+    # @return [Middleman::Logger] The logger
+    def self.logger(*args)
+      if !@_logger || args.length > 0
+        @_logger = ::Middleman::Logger.new(*args)
+      end
+
+      @_logger
+    end
+
+    # Facade for ActiveSupport/Notification
+    def self.instrument(name, payload={}, &block)
+      name << ".middleman" unless name =~ /\.middleman$/
+      ::ActiveSupport::Notifications.instrument(name, payload, &block)
+    end
+
+    # Recursively convert a normal Hash into a HashWithIndifferentAccess
+    #
+    # @private
+    # @param [Hash] data Normal hash
+    # @return [Thor::CoreExt::HashWithIndifferentAccess]
+    def self.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
+
+    # Normalize a path to not include a leading slash
+    # @param [String] path
+    # @return [String]
+    def self.normalize_path(path)
+      # The tr call works around a bug in Ruby's Unicode handling
+      path.sub(/^\//, "").tr('','')
+    end
+
+    # Extract the text of a Rack response as a string.
+    # Useful for extensions implemented as Rack middleware.
+    # @param response The response from #call
+    # @return [String] The whole response as a string.
+    def self.extract_response_text(response)
+      case(response)
+      when String
+        response
+      when Array
+        response.join
+      when Rack::Response
+        response.body.join
+      when Rack::File
+        File.read(response.path)
+      else
+        response.to_s
+      end
+    end
+
+    # Takes a matcher, which can be a literal string
+    # or a string containing glob expressions, or a
+    # regexp, or a proc, or anything else that responds
+    # to #match or #call, and returns whether or not the
+    # given path matches that matcher.
+    #
+    # @param matcher A matcher string/regexp/proc/etc
+    # @param path A path as a string
+    # @return [Boolean] Whether the path matches the matcher
+    def self.path_match(matcher, path)
+      if matcher.respond_to? :match
+        matcher.match path
+      elsif matcher.respond_to? :call
+        matcher.call path
+      else
+        File.fnmatch(matcher.to_s, path)
+      end
+    end
+
+    # Get a recusive list of files inside a set of paths.
+    # Works with symlinks.
+    #
+    # @param path A path string or Pathname
+    # @return [Array] An array of filenames
+    def self.all_files_under(*paths)
+      paths.flatten!
+      paths.map! { |p| Pathname(p) }
+      files = paths.select { |p| p.file? }
+      paths.select {|p| p.directory? }.each do |dir|
+        files << all_files_under(dir.children)
+      end
+      files.flatten
+    end
+
+    # Simple shared cache implementation
+    class Cache
+      # Initialize
+      def initialize
+        self.clear
+      end
+
+      # Either get the cached key or save the contents of the block
+      #
+      # @param key Anything Hash can use as a key
+      def fetch(*key)
+        @cache[key] ||= yield
+      end
+
+      # Whether the key is in the cache
+      #
+      # @param key Anything Hash can use as a key
+      # @return [Boolean]
+      def has_key?(key)
+        @cache.has_key?(key)
+      end
+
+      # Get a specific key
+      #
+      # @param key Anything Hash can use as a key
+      def get(key)
+        @cache[key]
+      end
+
+      # Array of keys
+      # @return [Array]
+      def keys
+        @cache.keys
+      end
+
+      # Clear the entire cache
+      # @return [void]
+      def clear
+        @cache = {}
+      end
+
+      # Set a specific key
+      #
+      # @param key Anything Hash can use as a key
+      # @param value Cached value
+      # @return [void]
+      def set(key, value)
+        @cache[key] = value
+      end
+
+      # Remove a specific key
+      # @param key Anything Hash can use as a key
+      def remove(*key)
+        @cache.delete(key)
+      end
+    end
+  end
+end

data/lib/middleman-core/vendor/hooks-0.2.0/CHANGES.textile

@@ -0,0 +1,9 @@
+h2. 0.2.0
+
+h3. Changes
+  * Callback blocks are now executed on the instance using @instance_exec@. If you need to access the class (former context) use @self.class@.
+
+h2. 0.1.4
+
+h3. Bugfixes
+  * An uninitialized @inheritable_attr@ doesn't crash since it is not cloned anymore. Note that an uncloneable attribute value still causes an exception.

data/lib/middleman-core/vendor/hooks-0.2.0/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/lib/middleman-core/vendor/hooks-0.2.0/README.rdoc

@@ -0,0 +1,107 @@
+= Hooks
+
+<em>Generic hooks with callbacks for Ruby.</em>
+
+
+== Introduction
+
+_Hooks_ lets you define hooks declaratively in your ruby class. You can add callbacks to your hook, which will be run as soon as _you_ run the hook!
+
+It's almost like ActiveSupport::Callbacks but 76,6% less complex. Instead, it is not more than 60 lines of code, one method compilation, no +method_missing+ and no magic.
+
+Also, you may pass additional arguments to your callbacks when invoking a hook.
+
+== Example
+
+Let's take... a cat.
+  
+  require 'hooks'
+
+  class Cat
+    include Hooks
+
+    define_hook :after_dinner
+
+Now you can add callbacks to your hook declaratively in your class.
+
+    after_dinner do
+      puts "Ice cream for #{self}!"
+    end
+
+    after_dinner :have_a_desert   # => refers to Cat#have_a_desert
+
+    def have_a_desert
+      puts "Hell, yeah!"
+    end
+
+This will run the block and <tt>#have_a_desert</tt> from above.
+
+  cat.run_hook :after_dinner
+  # => Ice cream for #<Cat:0x8df9d84>!
+       Hell, yeah!
+
+Callback blocks and methods will be executed with instance context. Note how +self+ in the block refers to the Cat instance.
+
+
+== Inheritance
+
+Hooks are inherited, here's a complete example to put it all together.
+  
+  class Garfield < Cat
+    
+    after_dinner :want_some_more
+
+    def want_some_more
+      puts "Is that all?"
+    end
+  end
+
+
+  Garfield.new.run_hook :after_dinner
+  # => Ice cream for #<Cat:0x8df9d84>!
+       Hell, yeah!
+       Is that all?
+  
+Note how the callbacks are invoked in the order they were inherited.
+
+
+== Options for Callbacks
+
+You're free to pass any number of arguments to #run_callback, those will be passed to the callbacks.
+
+  cat.run_hook :before_dinner, cat, Time.now
+
+The callbacks should be ready for receiving parameters.
+
+  before_dinner :wash_pawns
+  before_dinner do |who, when|
+    ...
+  end
+
+  def wash_pawns(who, when)
+
+
+Not sure why a cat should have ice cream for dinner. Beside that, I was tempted naming this gem _hooker_.
+
+
+== Installation
+
+  gem install hooks
+
+
+== Anybody using it?
+
+* Hooks is already used in [Apotomo:http://github.com/apotonick/apotomo], a hot widget framework for Rails. Look at +lib/apotomo/widget.rb+ for examples and into +lib/apotomo/tree_node.rb+ to learn how modules-driven code might benefit from hooks.
+
+== Similar libraries
+
+* http://github.com/nakajima/aspectory
+* http://github.com/auser/backcall
+* http://github.com/mmcgrana/simple_callbacks
+
+
+== License
+
+Copyright (c) 2010, Nick Sutterer
+
+Released under the MIT License.

data/lib/middleman-core/vendor/hooks-0.2.0/Rakefile

@@ -0,0 +1,12 @@
+require 'rake'
+require 'rake/testtask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the hooks plugin.'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'test'
+  test.test_files = FileList['test/*_test.rb']
+  test.verbose = true
+end

data/lib/middleman-core/vendor/hooks-0.2.0/hooks.gemspec

@@ -0,0 +1,22 @@
+lib = File.expand_path('../lib/', __FILE__)
+$:.unshift lib unless $:.include?(lib)
+
+require 'hooks'
+
+Gem::Specification.new do |s|
+  s.name        = "hooks"
+  s.version     = Hooks::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Nick Sutterer"]
+  s.email       = ["apotonick@gmail.com"]
+  s.homepage    = "http://nicksda.apotomo.de/tag/hooks"
+  s.summary     = %q{Generic hooks with callbacks for Ruby.}
+  s.description = %q{Declaratively define hooks, add callbacks and run them with the options you like.}
+  
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_paths = ["lib"]
+  
+  s.add_development_dependency "shoulda"
+  s.add_development_dependency "rake"
+end

data/lib/middleman-core/vendor/hooks-0.2.0/lib/hooks/inheritable_attribute.rb

@@ -0,0 +1,33 @@
+module Hooks
+  module InheritableAttribute
+    # Creates an inheritable attribute with accessors in the singleton class. Derived classes inherit the
+    # attributes. This is especially helpful with arrays or hashes that are extended in the inheritance
+    # chain. Note that you have to initialize the inheritable attribute.
+    #
+    # Example:
+    #
+    #   class Cat
+    #     inheritable_attr :drinks
+    #     self.drinks = ["Becks"]
+    #
+    #   class Garfield < Cat
+    #     self.drinks << "Fireman's 4"
+    #
+    # and then, later
+    #
+    #   Cat.drinks      #=> ["Becks"]
+    #   Garfield.drinks #=> ["Becks", "Fireman's 4"]
+    def inheritable_attr(name)
+      instance_eval %Q{
+        def #{name}=(v)
+          @#{name} = v
+        end
+
+        def #{name}
+          return @#{name} unless superclass.respond_to?(:#{name}) and value = superclass.#{name}
+          @#{name} ||= value.clone # only do this once.
+        end
+      }
+    end
+  end
+end

data/lib/middleman-core/vendor/hooks-0.2.0/lib/hooks.rb

@@ -0,0 +1,109 @@
+require File.join(File.dirname(__FILE__), "hooks/inheritable_attribute")
+
+# Almost like ActiveSupport::Callbacks but 76,6% less complex.
+#
+# Example:
+#
+#   class CatWidget < Apotomo::Widget
+#     define_hook :after_dinner
+#
+# Now you can add callbacks to your hook declaratively in your class.
+#
+#     after_dinner do puts "Ice cream!" end
+#     after_dinner :have_a_desert   # => refers to CatWidget#have_a_desert
+#
+# Running the callbacks happens on instances. It will run the block and #have_a_desert from above.
+#
+#   cat.run_hook :after_dinner
+module Hooks
+  VERSION = "0.2.0"
+
+  def self.included(base)
+    base.extend InheritableAttribute
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    def define_hook(name)
+      accessor_name = "_#{name}_callbacks"
+
+      setup_hook_accessors(accessor_name)
+      define_hook_writer(name, accessor_name)
+    end
+
+    # Like Hooks#run_hook but for the class. Note that +:callbacks+ must be class methods.
+    #
+    # Example:
+    #
+    # class Cat
+    #   after_eight :grab_a_beer
+    #
+    #   def self.grab_a_beer(*) # and so on...
+    #
+    # where <tt>Cat.run_hook :after_eight</tt> will call the class method +grab_a_beer+.
+    def run_hook(name, *args)
+      run_hook_for(name, self, *args)
+    end
+
+    def run_hook_for(name, scope, *args)
+      callbacks_for_hook(name).each do |callback|
+        if callback.kind_of? Symbol
+          scope.send(callback, *args)
+        else
+          scope.instance_exec(*args, &callback)
+        end
+      end
+    end
+
+    # Returns the callbacks for +name+. Handy if you want to run the callbacks yourself, say when
+    # they should be executed in another context.
+    #
+    # Example:
+    #
+    #   def initialize
+    #     self.class.callbacks_for_hook(:after_eight).each do |callback|
+    #       instance_exec(self, &callback)
+    #     end
+    #
+    # would run callbacks in the object _instance_ context, passing +self+ as block parameter.
+    def callbacks_for_hook(name)
+      send("_#{name}_callbacks")
+    end
+
+  private
+
+    def define_hook_writer(hook, accessor_name)
+      self.send(:define_method, hook.to_sym) do |&block|
+        if self.class.respond_to?(hook)
+          self.class.send(hook.to_sym, &block)
+        end
+      end
+
+      instance_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+        def #{hook}(method=nil, &block)
+          #{accessor_name} << (block || method)
+        end
+      RUBY_EVAL
+    end
+
+    def setup_hook_accessors(accessor_name)
+      inheritable_attr(accessor_name)
+      send("#{accessor_name}=", [])  # initialize ivar.
+    end
+  end
+
+  # Runs the callbacks (method/block) for the specified hook +name+. Additional arguments will
+  # be passed to the callback.
+  #
+  # Example:
+  #
+  #   cat.run_hook :after_dinner, "i want ice cream!"
+  #
+  # will invoke the callbacks like
+  #
+  #   desert("i want ice cream!")
+  #   block.call("i want ice cream!")
+  def run_hook(name, *args)
+    self.class.run_hook_for(name, self, *args)
+  end
+end