middleman-core-x86-mingw32 3.0.1.pre

data/lib/middleman-core/cli/server.rb

@@ -0,0 +1,73 @@
+# CLI Module
+module Middleman::Cli
+
+  # Server thor task
+  class Server < Thor
+    check_unknown_options!
+
+    namespace :server
+
+    desc "server [options]", "Start the preview server"
+    method_option :environment,
+      :aliases => "-e",
+      :default => ENV['MM_ENV'] || ENV['RACK_ENV'] || 'development',
+      :desc    => "The environment Middleman will run under"
+    method_option :host,
+      :type    => :string,
+      :aliases => "-h",
+      :default => "0.0.0.0",
+      :desc    => "Bind to HOST address"
+    method_option :port,
+      :aliases => "-p",
+      :default => "4567",
+      :desc    => "The port Middleman will listen on"
+    method_option :verbose,
+      :type    => :boolean,
+      :default => false,
+      :desc    => 'Print debug messages'
+    method_option :instrument,
+      :type    => :string,
+      :default => false,
+      :desc    => 'Print instrument messages'
+    method_option "disable-watcher",
+      :type    => :boolean,
+      :default => false,
+      :desc    => 'Disable the file change and delete watcher process'
+    method_option :profile,
+      :type    => :boolean,
+      :default => false,
+      :desc    => 'Generate profiling report for server startup'
+
+    # Start the server
+    def server
+      require "middleman-core"
+      require "middleman-core/preview_server"
+
+      if !ENV["MM_ROOT"]
+        puts "== Could not find a Middleman project config.rb"
+        puts "== Treating directory as a static site to be served"
+        ENV["MM_ROOT"] = Dir.pwd
+        ENV["MM_SOURCE"] = ""
+      end
+
+      params = {
+        :port              => options["port"],
+        :host              => options["host"],
+        :environment       => options["environment"],
+        :debug             => options["verbose"],
+        :instrumenting     => options["instrument"],
+        :"disable-watcher" => options["disable-watcher"]
+      }
+
+      puts "== The Middleman is loading"
+      ::Middleman::PreviewServer.start(params)
+    end
+  end
+
+  def self.exit_on_failure?
+    true
+  end
+
+  # Map "s" to "server"
+  Base.map({ "s" => "server" })
+end

data/lib/middleman-core/cli.rb

@@ -0,0 +1,89 @@
+# Require thor since that's what the who CLI is built around
+require 'thor'
+require "thor/group"
+
+# CLI Module
+module Middleman
+
+  module Cli
+
+    # The base task from which everything else etends
+    class Base < Thor
+      class << self
+        def start(*args)
+          # Change flag to a module
+          ARGV.unshift("help") if ARGV.delete("--help")
+
+          # Default command is server
+          if ARGV[0] != "help" && (ARGV.length < 1 || ARGV.first.include?("-"))
+            ARGV.unshift("server")
+          end
+
+          super
+        end
+      end
+
+      desc "version", "Show version"
+      def version
+        require 'middleman-core/version'
+        say "Middleman #{Middleman::VERSION}"
+      end
+
+      # Override the Thor help method to find help for subtasks
+      # @param [Symbol, String, nil] meth
+      # @param [Boolean] subcommand
+      # @return [void]
+      def help(meth = nil, subcommand = false)
+        if meth && !self.respond_to?(meth)
+          klass, task = Thor::Util.find_class_and_task_by_namespace("#{meth}:#{meth}")
+          klass.start(["-h", task].compact, :shell => self.shell)
+        else
+          list = []
+          Thor::Util.thor_classes_in(Middleman::Cli).each do |klass|
+            list += klass.printable_tasks(false)
+          end
+          list.sort!{ |a,b| a[0] <=> b[0] }
+
+          shell.say "Tasks:"
+          shell.print_table(list, :ident => 2, :truncate => true)
+          shell.say
+        end
+      end
+
+      # Intercept missing methods and search subtasks for them
+      # @param [Symbol] meth
+      def method_missing(meth, *args)
+        meth = meth.to_s
+
+        if self.class.map.has_key?(meth)
+          meth = self.class.map[meth]
+        end
+
+        klass, task = Thor::Util.find_class_and_task_by_namespace("#{meth}:#{meth}")
+
+        if klass.nil?
+          tasks_dir = File.join(Dir.pwd, "tasks")
+
+          if File.exists?(tasks_dir)
+            Dir[File.join(tasks_dir, "**/*_task.rb")].each { |f| require f }
+            klass, task = Thor::Util.find_class_and_task_by_namespace("#{meth}:#{meth}")
+          end
+        end
+
+        if klass.nil?
+          super
+        else
+          args.unshift(task) if task
+          klass.start(args, :shell => self.shell)
+        end
+      end
+    end
+  end
+end
+
+# Include the core CLI items
+require "middleman-core/cli/init"
+require "middleman-core/cli/bundler"
+require "middleman-core/cli/extension"
+require "middleman-core/cli/server"
+require "middleman-core/cli/build"

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

@@ -0,0 +1,17 @@
+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
+        end
+        alias :included :registered
+      end
+    end
+  end
+end

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

@@ -0,0 +1,180 @@
+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
+
+      # 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
+
+          super
+        end
+
+        # The data object
+        #
+        # @return [DataStore]
+        def data
+          @_data ||= DataStore.new(self)
+        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
+        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
+
+        # 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)
+
+          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
+
+        # 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 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
+
+        # "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
+
+          super
+        end
+
+        # 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.callbacks.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
+  end
+end

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

@@ -0,0 +1,161 @@
+# 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::Application 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.
+
+# Namespace extensions module
+module Middleman
+  module CoreExtensions
+    module Extensions
+
+      # Register extension
+      class << self
+        # @private
+        def registered(app)
+          # Using for version parsing
+          require "rubygems"
+
+          app.define_hook :after_configuration
+          app.define_hook :before_configuration
+          app.define_hook :build_config
+          app.define_hook :development_config
+
+          if ENV["AUTOLOAD_SPROCKETS"]
+            app.set :autoload_sprockets, (ENV["AUTOLOAD_SPROCKETS"] == "true")
+          else
+            app.set :autoload_sprockets, true
+          end
+
+          app.extend ClassMethods
+          app.send :include, InstanceMethods
+          app.delegate :configure, :to => :"self.class"
+        end
+        alias :included :registered
+      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 [Module] extension Extension modules to register
+        # @param [Hash] options Per-extension options hash
+        # @return [void]
+        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)
+          ext_module = if ext.is_a?(Module)
+            ext
+          else
+            ::Middleman::Extensions.load(ext.to_sym)
+          end
+
+          if ext_module.nil?
+            logger.warning "== Unknown Extension: #{ext}"
+          else
+            logger.debug "== Activating: #{ext}"
+            self.class.register(ext_module, 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
+            logger.debug "== Reading:  Local config"
+            instance_eval File.read(local_config), local_config, 1
+          end
+
+          if autoload_sprockets
+            begin
+              require "middleman-sprockets"
+              activate(:sprockets)
+            rescue LoadError
+            end
+          end
+
+          run_hook :build_config if build?
+          run_hook :development_config if development?
+
+          run_hook :after_configuration
+
+          logger.debug "Loaded extensions:"
+          self.class.extensions.each do |ext|
+            logger.debug "== Extension: #{ext}"
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+# Load helpers in helpers/
+module Middleman
+  module CoreExtensions
+    module ExternalHelpers
+
+      # Setup extension
+      class << self
+
+        # once registered
+        def registered(app)
+          # Setup a default helpers paths
+          app.set :helpers_dir, "helpers"
+          app.set :helpers_filename_glob, "**{,/*/**}/*.rb"
+          app.set :helpers_filename_to_module_name_proc, Proc.new { |filename|
+            basename = File.basename(filename, File.extname(filename))
+            basename.camelcase
+          }
+
+          # After config
+          app.after_configuration do
+            helpers_path = File.expand_path(helpers_dir, root)
+            next unless File.exists?(helpers_path)
+
+            Dir[File.join(helpers_path, helpers_filename_glob)].each do |filename|
+              module_name = helpers_filename_to_module_name_proc.call(filename)
+              next unless module_name
+
+              require filename
+              next unless Object.const_defined?(module_name.to_sym)
+
+              helpers Object.const_get(module_name.to_sym)
+            end
+          end
+        end
+        alias :included :registered
+      end
+    end
+  end
+end