middleman-core 3.3.12 → 4.4.2

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

@@ -1,47 +0,0 @@
-# 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

@@ -1,71 +0,0 @@
-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'
-    method_option 'force',
-                  type: :boolean,
-                  default: false,
-                  desc: 'Overwrite existing files without any question'
-
-    # 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

@@ -1,91 +0,0 @@
-# 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 :port,
-                  aliases: '-p',
-                  desc: 'The port Middleman will listen on'
-    method_option :https,
-                  type: :boolean,
-                  desc: 'Serve the preview server over SSL/TLS'
-    method_option :ssl_certificate,
-                  desc: 'Path to an X.509 certificate to use for the preview server'
-    method_option :ssl_private_key,
-                  desc: "Path to an RSA private key for the preview server's certificate"
-    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'],
-        https: options['https'],
-        ssl_certificate: options['ssl_certificate'],
-        ssl_private_key: options['ssl_private_key'],
-        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/cli.rb

@@ -1,88 +0,0 @@
-# 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
-        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]
-      # rubocop:disable UnusedMethodArgument
-      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: shell)
-        else
-          list = []
-          Thor::Util.thor_classes_in(Middleman::Cli).each do |thor_class|
-            list += thor_class.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
-        meth = self.class.map[meth] if self.class.map.key?(meth)
-
-        klass, task = Thor::Util.find_class_and_task_by_namespace("#{meth}:#{meth}")
-
-        if klass.nil?
-          tasks_dir = File.join(Dir.pwd, 'tasks')
-
-          if File.exist?(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?
-          raise Thor::Error, "There's no '#{meth}' command for Middleman. Try 'middleman help' for a list of commands."
-        else
-          args.unshift(task) if task
-          klass.start(args, shell: shell)
-        end
-      end
-    end
-  end
-end
-
-# Require the Middleman version
-require 'middleman-core/version'
-
-# 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'
-require 'middleman-core/cli/console'

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

@@ -1,197 +0,0 @@
-# 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)
-          app.define_hook :initialized
-          app.define_hook :instance_available
-          app.define_hook :after_configuration
-          app.define_hook :before_configuration
-          app.define_hook :build_config
-          app.define_hook :development_config
-
-          app.config.define_setting :autoload_sprockets, true, 'Automatically load sprockets at startup?'
-          app.config[:autoload_sprockets] = (ENV['AUTOLOAD_SPROCKETS'] == 'true') if ENV['AUTOLOAD_SPROCKETS']
-
-          app.extend ClassMethods
-          app.send :include, InstanceMethods
-          app.delegate :configure, to: :"self.class"
-        end
-        alias_method :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
-
-        # 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)
-          if extension.instance_of?(Class) && extension.ancestors.include?(::Middleman::Extension)
-            extension.new(self, options, &block)
-          else
-            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
-            extension
-          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]
-        # rubocop:disable BlockNesting
-        def activate(ext, options={}, &block)
-          ext_module = if ext.is_a?(Module)
-            ext
-          else
-            ::Middleman::Extensions.load(ext)
-          end
-
-          if ext_module.nil?
-            logger.error "== Unknown Extension: #{ext}"
-          else
-            logger.debug "== Activating: #{ext}"
-
-            if ext_module.instance_of? Module
-              extensions[ext] = self.class.register(ext_module, options, &block)
-            elsif ext_module.instance_of?(Class) && ext_module.ancestors.include?(::Middleman::Extension)
-              if ext_module.supports_multiple_instances?
-                extensions[ext] ||= {}
-                key = "instance_#{extensions[ext].keys.length}"
-                extensions[ext][key] = ext_module.new(self.class, options, &block)
-              else
-                if extensions[ext]
-                  logger.error "== #{ext} already activated."
-                else
-                  extensions[ext] = ext_module.new(self.class, options, &block)
-                end
-              end
-            end
-          end
-        end
-
-        # Access activated extensions
-        #
-        # @return [Hash<Symbol,Middleman::Extension|Module>]
-        def extensions
-          @extensions ||= {}
-        end
-
-        # Load features before starting server
-        def initialize
-          super
-
-          self.class.inst = self
-
-          # Search the root of the project for required files
-          $LOAD_PATH.unshift(root)
-
-          ::Middleman::Extension.clear_after_extension_callbacks
-          run_hook :initialized
-
-          if config[:autoload_sprockets]
-            begin
-              require 'middleman-sprockets'
-              activate(:sprockets)
-            rescue LoadError
-            end
-          end
-
-          run_hook :before_configuration
-
-          # Check for and evaluate local configuration
-          local_config = File.join(root, 'config.rb')
-          if File.exist? local_config
-            logger.debug '== Reading:  Local config'
-            instance_eval File.read(local_config), local_config, 1
-          end
-
-          run_hook :build_config if build?
-          run_hook :development_config if development?
-
-          run_hook :instance_available
-
-          # This is for making the tests work - since the tests
-          # don't completely reload middleman, I18n.load_path can get
-          # polluted with paths from other test app directories that don't
-          # exist anymore.
-          if ENV['TEST']
-            ::I18n.load_path.delete_if { |path| path =~ %r{tmp/aruba} }
-            ::I18n.reload!
-          end
-
-          run_hook :after_configuration
-
-          logger.debug 'Loaded extensions:'
-          extensions.each do |ext, klass|
-            if ext.is_a?(Hash)
-              ext.each do |k, _|
-                logger.debug "== Extension: #{k}"
-              end
-            else
-              logger.debug "== Extension: #{ext}"
-            end
-
-            ::Middleman::Extension.activated_extension(klass) if klass.is_a?(::Middleman::Extension)
-          end
-        end
-      end
-    end
-  end
-end