middleman-core-cj 3.3.4

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

@@ -0,0 +1,47 @@
+# CLI Module
+module Middleman::Cli
+  # A thor task for creating new projects
+  class Extension < Thor
+    include Thor::Actions
+
+    check_unknown_options!
+
+    namespace :extension
+
+    # Required path for the new project to be generated
+    argument :name, type: :string
+
+    # Template files are relative to this file
+    # @return [String]
+    def self.source_root
+      File.join(File.dirname(__FILE__), '..', 'templates', 'extension')
+    end
+
+    desc 'extension [options]', 'Create Middleman extension scaffold NAME'
+
+    # The extension task
+    # @param [String] name
+    def extension
+      generate_gitignore!
+      template 'Rakefile', File.join(name, 'Rakefile')
+      template 'gemspec', File.join(name, "#{name}.gemspec")
+      template 'Gemfile', File.join(name, 'Gemfile')
+      template 'lib/middleman_extension.rb', File.join(name, 'lib', 'middleman_extension.rb')
+      template 'lib/lib.rb', File.join(name, 'lib', "#{name}.rb")
+      template 'features/support/env.rb', File.join(name, 'features', 'support', 'env.rb')
+      empty_directory File.join(name, 'fixtures')
+    end
+
+    # Output a .gitignore file
+    class_option :git, type: :boolean, default: true
+
+    no_tasks {
+      # Write a .gitignore file for project
+      # @return [void]
+      def generate_gitignore!
+        return unless options[:git]
+        copy_file 'gitignore', File.join(name, '.gitignore')
+      end
+    }
+  end
+end

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

@@ -0,0 +1,66 @@
+require 'middleman-core/templates'
+
+# CLI Module
+module Middleman::Cli
+  # A thor task for creating new projects
+  class Init < Thor
+    check_unknown_options!
+
+    namespace :init
+
+    desc 'init NAME [options]', 'Create new project NAME'
+    available_templates = ::Middleman::Templates.registered.keys.join(', ')
+    method_option 'template',
+                  aliases: '-T',
+                  default: 'default',
+                  desc: "Use a project template: #{available_templates}"
+    method_option 'css_dir',
+                  # :default => "stylesheets",
+                  desc: 'The path to the css files'
+    method_option 'js_dir',
+                  # :default => "javascripts",
+                  desc: 'The path to the javascript files'
+    method_option 'images_dir',
+                  # :default => "images",
+                  desc: 'The path to the image files'
+    method_option 'rack',
+                  type: :boolean,
+                  default: false,
+                  desc: 'Include a config.ru file'
+    method_option 'skip-gemfile',
+                  type: :boolean,
+                  default: false,
+                  desc: "Don't create a Gemfile"
+    method_option 'skip-bundle',
+                  type: :boolean,
+                  aliases: '-B',
+                  default: false,
+                  desc: "Don't run bundle install"
+    method_option 'skip-git',
+                  type: :boolean,
+                  default: false,
+                  desc: 'Skip Git ignores and keeps'
+    # The init task
+    # @param [String] name
+    def init(name='.')
+      key = options[:template].to_sym
+      unless ::Middleman::Templates.registered.key?(key)
+        raise Thor::Error, "Unknown project template '#{key}'"
+      end
+
+      thor_group = ::Middleman::Templates.registered[key]
+      thor_group.new([name], options).invoke_all
+    end
+  end
+
+  def self.exit_on_failure?
+    true
+  end
+
+  # Map "i", "new" and "n" to "init"
+  Base.map(
+             'i'   => 'init',
+             'new' => 'init',
+             'n'   => 'init'
+  )
+end

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

@@ -0,0 +1,88 @@
+# 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'
+    method_option :reload_paths,
+                  type: :string,
+                  default: false,
+                  desc: 'Additional paths to auto-reload when files change'
+    method_option :force_polling,
+                  type: :boolean,
+                  default: false,
+                  desc: 'Force file watcher into polling mode'
+    method_option :latency,
+                  type: :numeric,
+                  aliases: '-l',
+                  default: 0.25,
+                  desc: 'Set file watcher latency, in seconds'
+
+    # Start the server
+    def server
+      require 'middleman-core'
+      require 'middleman-core/preview_server'
+
+      unless 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'],
+        reload_paths: options['reload_paths'],
+        force_polling: options['force_polling'],
+        latency: options['latency']
+      }
+
+      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/configuration.rb

@@ -0,0 +1,237 @@
+module Middleman
+  module Configuration
+    # Access to a global configuration manager for the whole Middleman project,
+    # plus backwards compatibility mechanisms for older Middleman projects.
+    module Global
+      def self.included(app)
+        app.send :extend, ClassMethods
+      end
+
+      module ClassMethods
+        # Global configuration for the whole Middleman project.
+        # @return [ConfigurationManager]
+        def config
+          @_config ||= ConfigurationManager.new
+        end
+
+        # Set attributes (global variables)
+        #
+        # @deprecated Prefer accessing settings through "config".
+        #
+        # @param [Symbol] key Name of the attribue
+        # @param default Attribute value
+        # @return [void]
+        def set(key, default=nil, &block)
+          config.define_setting(key, default) unless config.defines_setting?(key)
+          @inst.set(key, default, &block) if @inst
+        end
+
+        # Access global settings as methods, to preserve compatibility with
+        # old Middleman.
+        #
+        # @deprecated Prefer accessing settings through "config".
+        def method_missing(method, *args)
+          if config.defines_setting? method
+            config[method]
+          else
+            super
+          end
+        end
+
+        # Needed so that method_missing makes sense
+        def respond_to?(method, include_private=false)
+          super || config.defines_setting?(method)
+        end
+      end
+
+      def config
+        self.class.config
+      end
+
+      # Backwards compatibilty with old Sinatra template interface
+      #
+      # @deprecated Prefer accessing settings through "config".
+      #
+      # @return [ConfigurationManager]
+      alias_method :settings, :config
+
+      # Set attributes (global variables)
+      #
+      # @deprecated Prefer accessing settings through "config".
+      #
+      # @param [Symbol] key Name of the attribue
+      # @param value Attribute value
+      # @return [void]
+      def set(key, value=nil, &block)
+        value = block if block_given?
+        config[key] = value
+      end
+
+      # Access global settings as methods, to preserve compatibility with
+      # old Middleman.
+      #
+      # @deprecated Prefer accessing settings through "config".
+      def method_missing(method, *args)
+        if config.defines_setting? method
+          config[method]
+        else
+          super
+        end
+      end
+
+      # Needed so that method_missing makes sense
+      def respond_to?(method, include_private=false)
+        super || config.defines_setting?(method)
+      end
+    end
+
+    # A class that manages a collection of documented settings.
+    # Can be used by extensions as well as the main Middleman
+    # application. Extensions should probably finalize their instance
+    # after defining all the settings they want to expose.
+    class ConfigurationManager
+      def initialize
+        # A hash from setting key to ConfigSetting instance.
+        @settings = {}
+        @finalized = false
+      end
+
+      # Get all settings, sorted by key, as ConfigSetting objects.
+      # @return [Array<ConfigSetting>]
+      def all_settings
+        @settings.values.sort_by(&:key)
+      end
+
+      # Get a full ConfigSetting object for the setting with the give key.
+      # @return [ConfigSetting]
+      def setting(key)
+        @settings[key]
+      end
+
+      # Get the value of a setting by key. Returns nil if there is no such setting.
+      # @return [Object]
+      def [](key)
+        setting_obj = setting(key)
+        setting_obj ? setting_obj.value : nil
+      end
+
+      # Set the value of a setting by key. Creates the setting if it doesn't exist.
+      # @param [Symbol] key
+      # @param [Object] val
+      # rubocop:disable UselessSetterCall
+      def []=(key, val)
+        setting_obj = setting(key) || define_setting(key)
+        setting_obj.value = val
+      end
+
+      # Allow configuration settings to be read and written via methods
+      def method_missing(method, *args)
+        if defines_setting?(method) && args.size == 0
+          self[method]
+        elsif method.to_s =~ /^(\w+)=$/ && args.size == 1
+          self[$1.to_sym] = args[0]
+        else
+          super
+        end
+      end
+
+      # Needed so that method_missing makes sense
+      def respond_to?(method, include_private=false)
+        super || defines_setting?(method) || (method =~ /^(\w+)=$/ && defines_setting?($1))
+      end
+
+      # Does this configuration manager know about the setting identified by key?
+      # @param [Symbol] key
+      # @return [Boolean]
+      def defines_setting?(key)
+        @settings.key?(key)
+      end
+
+      # Define a new setting, with optional default and user-friendly description.
+      # Once the configuration manager is finalized, no new settings may be defined.
+      #
+      # @param [Symbol] key
+      # @param [Object] default
+      # @param [String] description
+      # @return [ConfigSetting]
+      def define_setting(key, default=nil, description=nil)
+        raise "Setting #{key} doesn't exist" if @finalized
+        raise "Setting #{key} already defined" if @settings.key?(key)
+        raise 'Setting key must be a Symbol' unless key.is_a? Symbol
+
+        @settings[key] = ConfigSetting.new(key, default, description)
+      end
+
+      # Switch the configuration manager is finalized, it switches to read-only
+      # mode and no new settings may be defined.
+      def finalize!
+        @finalized = true
+        self
+      end
+
+      # Deep duplicate of the configuration manager
+      def dup
+        ConfigurationManager.new.tap { |c| c.load_settings(all_settings) }
+      end
+
+      # Load in a list of settings
+      def load_settings(other_settings)
+        other_settings.each do |setting|
+          new_setting = define_setting(setting.key, setting.default, setting.description)
+          new_setting.value = setting.value if setting.value_set?
+        end
+      end
+
+      def to_h
+        hash = {}
+        @settings.each do |key, setting|
+          hash[key] = setting.value
+        end
+        hash
+      end
+
+      def to_s
+        to_h.inspect
+      end
+    end
+
+    # An individual configuration setting, with an optional default and description.
+    # Also models whether or not a value has been set.
+    class ConfigSetting
+      # The name of this setting
+      attr_accessor :key
+
+      # The default value for this setting
+      attr_accessor :default
+
+      # A human-friendly description of the setting
+      attr_accessor :description
+
+      def initialize(key, default, description)
+        @value_set = false
+        self.key = key
+        self.default = default
+        self.description = description
+      end
+
+      # The user-supplied value for this setting, overriding the default
+      def value=(value)
+        @value = value
+        @value_set = true
+      end
+
+      # The effective value of the setting, which may be the default
+      # if the user has not set a value themselves. Note that even if the
+      # user sets the value to nil it will override the default.
+      def value
+        value_set? ? @value : default
+      end
+
+      # Whether or not there has been a value set beyond the default
+      # rubocop:disable TrivialAccessors
+      def value_set?
+        @value_set
+      end
+    end
+  end
+end

data/lib/middleman-core/core_extensions.rb

@@ -0,0 +1,94 @@
+# Rack Request
+require 'middleman-core/core_extensions/request'
+
+# File Change Notifier
+require 'middleman-core/core_extensions/file_watcher'
+
+# Custom Feature API
+require 'middleman-core/core_extensions/extensions'
+
+# Data looks at the data/ folder for YAML files and makes them available
+# to dynamic requests.
+require 'middleman-core/core_extensions/data'
+
+# Parse YAML from templates
+require 'middleman-core/core_extensions/front_matter'
+
+# External helpers looks in the helpers/ folder for helper modules
+require 'middleman-core/core_extensions/external_helpers'
+
+# Extended version of Padrino's rendering
+require 'middleman-core/core_extensions/rendering'
+
+# Pass custom options to views
+require 'middleman-core/core_extensions/routing'
+
+# Catch and show exceptions at the Rack level
+require 'middleman-core/core_extensions/show_exceptions'
+
+# Setup default helpers
+require 'middleman-more/core_extensions/default_helpers'
+
+require 'middleman-more/core_extensions/i18n'
+
+# Compass framework
+begin
+  require 'middleman-more/core_extensions/compass'
+rescue LoadError
+end
+
+###
+# Setup Optional Extensions
+###
+
+# CacheBuster adds a query string to assets in dynamic templates to
+# avoid browser caches failing to update to your new content.
+require 'middleman-more/extensions/cache_buster'
+Middleman::Extensions::CacheBuster.register
+
+# RelativeAssets allow any asset path in dynamic templates to be either
+# relative to the root of the project or use an absolute URL.
+require 'middleman-more/extensions/relative_assets'
+Middleman::Extensions::RelativeAssets.register
+
+# AssetHost allows you to setup multiple domains to host your static
+# assets. Calls to asset paths in dynamic templates will then rotate
+# through each of the asset servers to better spread the load.
+require 'middleman-more/extensions/asset_host'
+Middleman::Extensions::AssetHost.register
+
+# MinifyCss compresses CSS
+require 'middleman-more/extensions/minify_css'
+Middleman::Extensions::MinifyCss.register
+
+# MinifyJavascript compresses JS
+require 'middleman-more/extensions/minify_javascript'
+Middleman::Extensions::MinifyJavascript.register
+
+# GZIP assets and pages during build
+require 'middleman-more/extensions/gzip'
+Middleman::Extensions::Gzip.register
+
+# AssetHash appends a hash of the file contents to the assets filename
+# to avoid browser caches failing to update to your new content.
+require 'middleman-more/extensions/asset_hash'
+Middleman::Extensions::AssetHash.register
+
+# Provide Apache-style index.html files for directories
+require 'middleman-more/extensions/directory_indexes'
+Middleman::Extensions::DirectoryIndexes.register
+
+# Lorem provides a handful of helpful prototyping methods to generate
+# words, paragraphs, fake images, names and email addresses.
+require 'middleman-more/extensions/lorem'
+
+# AutomaticImageSizes inspects the images used in your dynamic templates
+# and automatically adds width and height attributes to their HTML
+# elements.
+require 'middleman-more/extensions/automatic_image_sizes'
+Middleman::Extensions::AutomaticImageSizes.register
+
+# AutomaticAltTags uses the file name of the `image_tag` to generate
+# a default `:alt` value.
+require 'middleman-more/extensions/automatic_alt_tags'
+Middleman::Extensions::AutomaticAltTags.register