middleman-core 3.4.1 → 4.0.0.alpha.2

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

@@ -1,99 +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 :server_name,
-                  aliases: '-s',
-                  desc: 'The server name Middleman will use'
-    method_option :bind_address,
-                  aliases: '-b',
-                  desc: 'The bind address 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'] = ::Middleman::Util.current_directory
-        ENV['MM_SOURCE'] = ''
-      end
-
-      params = {
-        port: options['port'],
-        bind_address: options['bind_address'],
-        https: options['https'],
-        server_name: options['server_name'],
-        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/core_extensions/data/file_loader.rb

@@ -1,71 +0,0 @@
-require 'yaml'
-require 'json'
-
-module Middleman
-  module CoreExtensions
-    module Data
-      # Load data files
-      class FileLoader
-        # No parser available
-        class NoFileLoaderFoundError < StandardError; end
-
-        # Load yaml files
-        class YamlFileLoader
-          def match?(file)
-            %w(.yaml .yml).include? File.extname(file)
-          end
-
-          # @param [Pathname] file
-          def load(file)
-            YAML.load_file(file)
-          rescue Psych::SyntaxError, StandardError => e
-            $stderr.puts %(Loading data file "#{file}" failed due to an error: #{e.message})
-            {}
-          end
-        end
-
-        # Load json files
-        class JsonFileLoader
-          def match?(file)
-            '.json' == File.extname(file)
-          end
-
-          # @param [Pathname] file
-          def load(file)
-            JSON.parse(file.read)
-          rescue => e
-            $stderr.puts %(Loading data file "#{file}" failed due to an error: #{e.message})
-            {}
-          end
-        end
-
-        # Default loader
-        #
-        # Always fails
-        class NilFileLoader
-          def match?(file)
-            raise NoFileLoaderFoundError
-          end
-        end
-
-        private
-
-        attr_reader :loaders
-
-        public
-
-        def initialize
-          @loaders = []
-          @loaders << YamlFileLoader.new
-          @loaders << JsonFileLoader.new
-          @loaders << NilFileLoader.new
-        end
-
-        # Load file using loader
-        def load(file)
-          loaders.find { |l| l.match? file }.load(file)
-        end
-      end
-    end
-  end
-end

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

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

@@ -1,312 +0,0 @@
-# Built on Rack
-require 'rack'
-require 'rack/file'
-require 'rack/lint'
-require 'rack/head'
-
-require 'middleman-core/application'
-require 'middleman-core/util'
-
-module Middleman
-  module CoreExtensions
-    # Base helper to manipulate asset paths
-    module Request
-      # Extension registered
-      class << self
-        # @private
-        def registered(app)
-          # CSSPIE HTC File
-          ::Rack::Mime::MIME_TYPES['.htc'] = 'text/x-component'
-
-          # Let's serve all HTML as UTF-8
-          ::Rack::Mime::MIME_TYPES['.html'] = 'text/html; charset=utf-8'
-          ::Rack::Mime::MIME_TYPES['.htm'] = 'text/html; charset=utf-8'
-
-          # Sourcemap format
-          ::Rack::Mime::MIME_TYPES['.map'] = 'application/json; charset=utf-8'
-
-          # Create a MIME type for PHP files (for detection by extensions)
-          ::Rack::Mime::MIME_TYPES['.php'] = 'text/php'
-
-          app.extend ClassMethods
-          app.extend ServerMethods
-
-          Middleman.extend CompatibleClassMethods
-
-          # Include instance methods
-          app.send :include, InstanceMethods
-        end
-        alias_method :included, :registered
-      end
-
-      module ClassMethods
-        # Reset Rack setup
-        #
-        # @private
-        def reset!
-          @rack_app = nil
-        end
-
-        # Get the static instance
-        #
-        # @private
-        # @return [Middleman::Application]
-        def inst(&block)
-          @inst ||= begin
-            mm = new(&block)
-            mm.run_hook :ready
-            mm
-          end
-        end
-
-        # Set the shared instance
-        #
-        # @private
-        # @param [Middleman::Application] inst
-        # @return [void]
-        attr_writer :inst
-
-        # Return built Rack app
-        #
-        # @private
-        # @return [Rack::Builder]
-        def to_rack_app(&block)
-          @rack_app ||= begin
-            app = ::Rack::Builder.new
-            app.use Rack::Lint
-            app.use Rack::Head
-
-            Array(@middleware).each do |klass, options, middleware_block|
-              app.use(klass, *options, &middleware_block)
-            end
-
-            inner_app = inst(&block)
-            app.map('/') { run inner_app }
-
-            Array(@mappings).each do |path, map_block|
-              app.map(path, &map_block)
-            end
-
-            app
-          end
-        end
-
-        # Prototype app. Used in config.ru
-        #
-        # @private
-        # @return [Rack::Builder]
-        def prototype
-          reset!
-          to_rack_app
-        end
-
-        # Call prototype, use in config.ru
-        #
-        # @private
-        def call(env)
-          prototype.call(env)
-        end
-
-        # Use Rack middleware
-        #
-        # @param [Class] middleware Middleware module
-        # @return [void]
-        def use(middleware, *args, &block)
-          @middleware ||= []
-          @middleware << [middleware, args, block]
-        end
-
-        # Add Rack App mapped to specific path
-        #
-        # @param [String] map Path to map
-        # @return [void]
-        def map(map, &block)
-          @mappings ||= []
-          @mappings << [map, block]
-        end
-      end
-
-      module ServerMethods
-        # Create a new Class which is based on Middleman::Application
-        # Used to create a safe sandbox into which extensions and
-        # configuration can be included later without impacting
-        # other classes and instances.
-        #
-        # rubocop:disable ClassVars
-        # @return [Class]
-        def server(&block)
-          @@servercounter ||= 0
-          @@servercounter += 1
-          const_set("MiddlemanApplication#{@@servercounter}", Class.new(Middleman::Application, &block))
-        end
-      end
-
-      module CompatibleClassMethods
-        # Create a new Class which is based on Middleman::Application
-        # Used to create a safe sandbox into which extensions and
-        # configuration can be included later without impacting
-        # other classes and instances.
-        #
-        # @return [Class]
-        def server(&block)
-          ::Middleman::Application.server(&block)
-        end
-      end
-
-      # Methods to be mixed-in to Middleman::Application
-      module InstanceMethods
-        # Backwards-compatibility with old request.path signature
-        def request
-          Thread.current[:legacy_request]
-        end
-
-        # Accessor for current path
-        # @return [String]
-        def current_path
-          Thread.current[:current_path]
-        end
-
-        # Set the current path
-        #
-        # @param [String] path The new current path
-        # @return [void]
-        def current_path=(path)
-          Thread.current[:current_path] = path
-          Thread.current[:legacy_request] = ::Thor::CoreExt::HashWithIndifferentAccess.new(
-            path: path,
-            params: req ? ::Thor::CoreExt::HashWithIndifferentAccess.new(req.params) : {}
-          )
-        end
-
-        delegate :use, to: :"self.class"
-        delegate :map, to: :"self.class"
-
-        # Rack request
-        # @return [Rack::Request]
-        def req
-          Thread.current[:req]
-        end
-
-        def req=(value)
-          Thread.current[:req] = value
-        end
-
-        def call(env)
-          dup.call!(env)
-        end
-
-        # Rack Interface
-        #
-        # @param env Rack environment
-        def call!(env)
-          # Store environment, request and response for later
-          self.req = req = ::Rack::Request.new(env)
-          res = ::Rack::Response.new
-
-          logger.debug "== Request: #{env['PATH_INFO']}"
-
-          # Catch :halt exceptions and use that response if given
-          catch(:halt) do
-            process_request(env, req, res)
-
-            res.status = 404
-
-            res.finish
-          end
-        end
-
-        # Halt the current request and return a response
-        #
-        # @param [String] response Response value
-        def halt(response)
-          throw :halt, response
-        end
-
-        # Core response method. We process the request, check with
-        # the sitemap, and return the correct file, response or status
-        # message.
-        #
-        # @param env
-        # @param [Rack::Request] req
-        # @param [Rack::Response] res
-        def process_request(env, req, res)
-          start_time = Time.now
-          current_path = nil
-
-          request_path = URI.decode(env['PATH_INFO'].dup)
-          if request_path.respond_to? :force_encoding
-            request_path.force_encoding('UTF-8')
-          end
-          request_path = ::Middleman::Util.full_path(request_path, self)
-
-          # Run before callbacks
-          run_hook :before
-
-          # Get the resource object for this path
-          resource = sitemap.find_resource_by_destination_path(request_path)
-
-          # Return 404 if not in sitemap
-          return not_found(res, request_path) unless resource && !resource.ignored?
-
-          # If this path is a binary file, send it immediately
-          return send_file(resource, env) if resource.binary?
-
-          current_path = resource.destination_path
-
-          res['Content-Type'] = resource.content_type || 'text/plain'
-
-          begin
-            # Write out the contents of the page
-            output = resource.render do
-              self.req = req
-              self.current_path = current_path
-            end
-
-            res.write output
-            # Valid content is a 200 status
-            res.status = 200
-          rescue Middleman::CoreExtensions::Rendering::TemplateNotFound => e
-            res.write "Error: #{e.message}"
-            res.status = 500
-          end
-
-          # End the request
-          logger.debug "== Finishing Request: #{current_path} (#{(Time.now - start_time).round(2)}s)"
-          halt res.finish
-        end
-
-        # Add a new mime-type for a specific extension
-        #
-        # @param [Symbol] type File extension
-        # @param [String] value Mime type
-        # @return [void]
-        def mime_type(type, value)
-          type = ".#{type}" unless type.to_s[0] == '.'
-          ::Rack::Mime::MIME_TYPES[type] = value
-        end
-
-        # Halt request and return 404
-        def not_found(res, path)
-          res.status = 404
-          res.write "<html><head></head><body><h1>File Not Found</h1><p>#{path}</p></body></html>"
-          res.finish
-        end
-
-        # Immediately send static file
-        def send_file(resource, env)
-          file      = ::Rack::File.new nil
-          file.path = resource.source_file
-          response = file.serving(env)
-          status = response[0]
-          response[1]['Content-Encoding'] = 'gzip' if %w(.svgz .gz).include?(resource.ext)
-          # Do not set Content-Type if status is 1xx, 204, 205 or 304, otherwise
-          # Rack will throw an error (500)
-          if !(100..199).include?(status) && ![204, 205, 304].include?(status)
-            response[1]['Content-Type'] = resource.content_type || 'application/octet-stream'
-          end
-          halt response
-        end
-      end
-    end
-  end
-end