middleman-core 3.3.12 → 4.4.2

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

data/lib/middleman-core/renderers/asciidoc.rb

@@ -1,58 +0,0 @@
-require 'asciidoctor'
-
-module Middleman
-  module Renderers
-    module AsciiDoc
-      class << self
-        def registered(app)
-          app.config.define_setting :asciidoc, {
-            safe: :safe,
-            backend: :html5,
-            attributes: %W(showtitle env=middleman env-middleman middleman-version=#{::Middleman::VERSION})
-          }, 'AsciiDoc engine options (Hash)'
-          app.config.define_setting :asciidoc_attributes, [], 'AsciiDoc custom attributes (Array)'
-          app.before_configuration do
-            template_extensions adoc: :html
-          end
-
-          app.after_configuration do
-            # QUESTION should base_dir be equal to docdir instead?
-            config[:asciidoc][:base_dir] = source_dir
-            config[:asciidoc][:attributes].concat(config[:asciidoc_attributes] || [])
-            config[:asciidoc][:attributes] << %(imagesdir=#{File.join((config[:http_prefix] || '/').chomp('/'), config[:images_dir])})
-            sitemap.provides_metadata(/\.adoc$/) do |path|
-              # read the AsciiDoc header only to set page options and data
-              # header values can be accessed via app.data.page.<name> in the layout
-              doc = Asciidoctor.load_file path, safe: :safe, parse_header_only: true
-
-              opts = {}
-              if doc.attr? 'page-layout'
-                case (layout = (doc.attr 'page-layout'))
-                when '', 'false'
-                  opts[:layout] = false
-                else
-                  opts[:layout] = layout
-                end
-              end
-              opts[:layout_engine] = (doc.attr 'page-layout-engine') if doc.attr? 'page-layout-engine'
-              # TODO: override attributes to set docfile, docdir, docname, etc
-              # alternative is to set :renderer_options, which get merged into options by the rendering extension
-              # opts[:attributes] = config[:asciidoc][:attributes].dup
-              # opts[:attributes].concat %W(docfile=#{path} docdir=#{File.dirname path} docname=#{(File.basename path).sub(/\.adoc$/, '')})
-
-              page = {}
-              page[:title] = doc.doctitle
-              page[:date] = (doc.attr 'date') unless (doc.attr 'date').nil?
-              # TODO: grab all the author information
-              page[:author] = (doc.attr 'author') unless (doc.attr 'author').nil?
-
-              { options: opts, page: ::Middleman::Util.recursively_enhance(page) }
-            end
-          end
-        end
-
-        alias_method :included, :registered
-      end
-    end
-  end
-end

data/lib/middleman-core/renderers/stylus.rb

@@ -1,24 +0,0 @@
-require 'stylus'
-require 'stylus/tilt'
-
-module Middleman
-  module Renderers
-    # Sass renderer
-    module Stylus
-      # Setup extension
-      class << self
-        # Once registered
-        def registered(app)
-          # Default less options
-          app.set :styl, {}
-
-          app.before_configuration do
-            template_extensions styl: :css
-          end
-        end
-
-        alias_method :included, :registered
-      end
-    end
-  end
-end

data/lib/middleman-core/sitemap/extensions/content_type.rb

@@ -1,16 +0,0 @@
-require 'rack'
-
-module Middleman::Sitemap::Extensions
-  # Content type is implemented as a module so it can be overridden by other sitemap extensions
-  module ContentType
-    # The preferred MIME content type for this resource
-    def content_type
-      # Allow explcitly setting content type from page/proxy options
-      meta_type = metadata[:options][:content_type]
-      return meta_type if meta_type
-
-      # Look up mime type based on extension
-      ::Rack::Mime.mime_type(ext, nil)
-    end
-  end
-end

data/lib/middleman-core/sitemap/queryable.rb

@@ -1,150 +0,0 @@
-require 'active_support/core_ext/object/inclusion'
-
-module Middleman
-  module Sitemap
-    # Code adapted from https://github.com/ralph/document_mapper/
-    module Queryable
-      OPERATOR_MAPPING = {
-        'equal'   => :==,
-        'gt'      => :>,
-        'gte'     => :>=,
-        'in'      => :in?,
-        'include' => :include?,
-        'lt'      => :<,
-        'lte'     => :<=
-      }
-
-      VALID_OPERATORS = OPERATOR_MAPPING.keys
-
-      FileNotFoundError = Class.new StandardError
-      OperatorNotSupportedError = Class.new StandardError
-
-      module API
-        def select(options={})
-          documents = resources.select { |r| !r.raw_data.empty? }
-          options[:where].each do |selector, selector_value|
-            documents = documents.select do |document|
-              next unless document.raw_data.key? selector.attribute
-              document_value = document.raw_data[selector.attribute]
-              operator = OPERATOR_MAPPING[selector.operator]
-              document_value.send operator, selector_value
-            end
-          end
-
-          if options[:order_by].present?
-            order_attribute = options[:order_by].keys.first
-            asc_or_desc = options[:order_by].values.first
-            documents = documents.select do |document|
-              document.raw_data.include? order_attribute
-            end
-            documents = documents.sort_by do |document|
-              document.raw_data[order_attribute]
-            end
-            documents.reverse! if asc_or_desc == :desc
-          end
-
-          documents
-        end
-
-        def where(hash)
-          Query.new(self).where(hash)
-        end
-
-        def order_by(field)
-          Query.new(self).order_by(field)
-        end
-
-        def offset(number)
-          Query.new(self).offset(number)
-        end
-
-        def limit(number)
-          Query.new(self).limit(number)
-        end
-      end
-
-      class Query
-        def initialize(model, opts={})
-          @model = model
-          @where = opts[:where] || {}
-          @order_by = opts[:order_by]
-          @offset = opts[:offset]
-          @limit = opts[:limit]
-        end
-
-        def where(constraints_hash)
-          selector_hash = constraints_hash.reject { |key, _| !key.is_a? Selector }
-          symbol_hash = constraints_hash.reject { |key, _| key.is_a? Selector }
-          symbol_hash.each do |attribute, value|
-            selector = Selector.new(attribute: attribute, operator: 'equal')
-            selector_hash.update(selector => value)
-          end
-          Query.new @model, opts(where: @where.merge(selector_hash))
-        end
-
-        def opts(new_opts)
-          { where: {}.merge(@where),
-            order_by: @order_by,
-            offset: @offset,
-            limit: @limit
-          }.merge(new_opts)
-        end
-
-        def order_by(field)
-          Query.new @model, opts(order_by: field.is_a?(Symbol) ? { field => :asc } : field)
-        end
-
-        def offset(number)
-          Query.new @model, opts(offset: number)
-        end
-
-        def limit(number)
-          Query.new @model, opts(limit: number)
-        end
-
-        def first
-          all.first
-        end
-
-        def last
-          all.last
-        end
-
-        def all
-          result = @model.select(where: @where, order_by: @order_by)
-          result = result.last([result.size - @offset, 0].max) if @offset.present?
-          result = result.first(@limit) if @limit.present?
-          result
-        end
-      end
-
-      class Selector
-        attr_reader :attribute, :operator
-
-        def initialize(opts={})
-          unless VALID_OPERATORS.include? opts[:operator]
-            raise OperatorNotSupportedError
-          end
-          @attribute, @operator = opts[:attribute], opts[:operator]
-        end
-      end
-    end
-  end
-end
-
-# Add operators to symbol objects
-class Symbol
-  Middleman::Sitemap::Queryable::VALID_OPERATORS.each do |operator|
-    class_eval <<-OPERATORS
-      def #{operator}
-        Middleman::Sitemap::Queryable::Selector.new(:attribute => self, :operator => '#{operator}')
-      end
-    OPERATORS
-  end
-
-  unless method_defined?(:"<=>")
-    def <=>(other)
-      to_s <=> other.to_s
-    end
-  end
-end

data/lib/middleman-core/sitemap.rb

@@ -1,76 +0,0 @@
-require 'middleman-core/sitemap/store'
-require 'middleman-core/sitemap/resource'
-
-require 'middleman-core/sitemap/extensions/on_disk'
-require 'middleman-core/sitemap/extensions/redirects'
-require 'middleman-core/sitemap/extensions/request_endpoints'
-require 'middleman-core/sitemap/extensions/proxies'
-require 'middleman-core/sitemap/extensions/ignores'
-
-# Core Sitemap Extensions
-module Middleman
-  module Sitemap
-    # Setup Extension
-    class << self
-      # Once registered
-      def registered(app)
-        app.register Middleman::Sitemap::Extensions::RequestEndpoints
-        app.register Middleman::Sitemap::Extensions::Proxies
-        app.register Middleman::Sitemap::Extensions::Ignores
-        app.register Middleman::Sitemap::Extensions::Redirects
-
-        # Set to automatically convert some characters into a directory
-        app.config.define_setting :automatic_directory_matcher, nil, 'Set to automatically convert some characters into a directory'
-
-        # Setup callbacks which can exclude paths from the sitemap
-        app.config.define_setting :ignored_sitemap_matchers, {
-          # dotfiles and folders in the root
-          root_dotfiles: proc { |file| file.start_with?('.') },
-
-          # Files starting with an dot, but not .htaccess
-          source_dotfiles: proc { |file|
-            file =~ %r{/\.} && file !~ %r{/\.(htaccess|htpasswd|nojekyll)}
-          },
-
-          # Files starting with an underscore, but not a double-underscore
-          partials: proc { |file| file =~ %r{/_[^_]} },
-
-          layout: proc { |file, sitemap_app|
-            file.start_with?(File.join(sitemap_app.config[:source], 'layout.')) || file.start_with?(File.join(sitemap_app.config[:source], 'layouts/'))
-          }
-        }, 'Callbacks that can exclude paths from the sitemap'
-
-        # Include instance methods
-        app.send :include, InstanceMethods
-
-        # Initialize Sitemap
-        app.before_configuration do
-          sitemap
-        end
-      end
-      alias_method :included, :registered
-    end
-
-    # Sitemap instance methods
-    module InstanceMethods
-      # Get the sitemap class instance
-      # @return [Middleman::Sitemap::Store]
-      def sitemap
-        @_sitemap ||= Store.new(self)
-      end
-
-      # Get the resource object for the current path
-      # @return [Middleman::Sitemap::Resource]
-      def current_page
-        current_resource
-      end
-
-      # Get the resource object for the current path
-      # @return [Middleman::Sitemap::Resource]
-      def current_resource
-        return nil unless current_path
-        sitemap.find_resource_by_destination_path(current_path)
-      end
-    end
-  end
-end

data/lib/middleman-core/templates/default/source/index.html.erb

@@ -1,10 +0,0 @@
----
-title: Welcome to Middleman
----
-
-<div class="welcome">
-  <h1>Middleman is Watching</h1>
-  <p class="doc">
-    <%= link_to "Read Online Documentation", "http://middlemanapp.com/" %>
-  </p><!-- .doc -->
-</div><!-- .welcome -->

data/lib/middleman-core/templates/default/source/javascripts/all.js

@@ -1 +0,0 @@
-//= require_tree .

data/lib/middleman-core/templates/default/source/layouts/layout.erb

@@ -1,19 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <meta charset="utf-8">
-
-    <!-- Always force latest IE rendering engine or request Chrome Frame -->
-    <meta content="IE=edge,chrome=1" http-equiv="X-UA-Compatible">
-
-    <!-- Use title if it's in the page YAML frontmatter -->
-    <title><%= current_page.data.title || "The Middleman" %></title>
-
-    <%= stylesheet_link_tag "normalize", "all" %>
-    <%= javascript_include_tag  "all" %>
-  </head>
-
-  <body class="<%= page_classes %>">
-    <%= yield %>
-  </body>
-</html>