middleman 2.0.16.1 → 3.0.0.alpha.2

data/lib/middleman/vendor/padrino-core-0.10.5/Rakefile

@@ -0,0 +1,5 @@
+# coding:utf-8
+RAKE_ROOT = __FILE__
+
+require 'rubygems'
+require File.expand_path(File.dirname(__FILE__) + '/../gem_rake_helper')

data/lib/middleman/vendor/padrino-core-0.10.5/bin/padrino

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require 'rubygems' unless defined?(Gem)
+require 'bundler/setup' if %w(Gemfile .components).all? { |f| File.exist?(f) }
+
+padrino_core_path = File.expand_path('../../lib', __FILE__)
+$:.unshift(padrino_core_path) if File.directory?(padrino_core_path) && !$:.include?(padrino_core_path)
+
+require 'padrino-core/cli/base'
+Padrino::Cli::Base.start(ARGV)

data/lib/middleman/vendor/padrino-core-0.10.5/lib/padrino-core.rb

@@ -0,0 +1,167 @@
+require 'sinatra/base'
+require 'padrino-core/support_lite' unless defined?(SupportLite)
+
+FileSet.glob_require('padrino-core/application/*.rb', __FILE__)
+FileSet.glob_require('padrino-core/*.rb', __FILE__)
+
+# The Padrino environment (falls back to the rack env or finally develop)
+PADRINO_ENV  = ENV["PADRINO_ENV"]  ||= ENV["RACK_ENV"] ||= "development"  unless defined?(PADRINO_ENV)
+# The Padrino project root path (falls back to the first caller)
+PADRINO_ROOT = ENV["PADRINO_ROOT"] ||= File.dirname(Padrino.first_caller) unless defined?(PADRINO_ROOT)
+
+module Padrino
+  class ApplicationLoadError < RuntimeError # @private
+  end
+
+  class << self
+    ##
+    # Helper method for file references.
+    #
+    # @param [Array<String>] args
+    #   The directories to join to {PADRINO_ROOT}.
+    #
+    # @return [String]
+    #   The absolute path.
+    #
+    # @example
+    #   # Referencing a file in config called settings.yml
+    #   Padrino.root("config", "settings.yml")
+    #   # returns PADRINO_ROOT + "/config/setting.yml"
+    #
+    def root(*args)
+      File.expand_path(File.join(PADRINO_ROOT, *args))
+    end
+
+    ##
+    # Helper method that return {PADRINO_ENV}.
+    #
+    # @return [Symbol]
+    #   The Padrino Environment.
+    #
+    def env
+      @_env ||= PADRINO_ENV.to_s.downcase.to_sym
+    end
+
+    ##
+    # The resulting rack builder mapping each 'mounted' application.
+    #
+    # @return [Padrino::Router]
+    #   The router for the application.
+    #
+    # @raise [ApplicationLoadError]
+    #   No applications were mounted.
+    #
+    def application
+      raise ApplicationLoadError, "At least one app must be mounted!" unless Padrino.mounted_apps && Padrino.mounted_apps.any?
+      router = Padrino::Router.new
+      Padrino.mounted_apps.each { |app| app.map_onto(router) }
+
+      if middleware.present?
+        builder = Rack::Builder.new
+        middleware.each { |c,a,b| builder.use(c, *a, &b) }
+        builder.run(router)
+        builder.to_app
+      else
+        router
+      end
+    end
+
+    ##
+    # Configure Global Project Settings for mounted apps. These can be overloaded
+    # in each individual app's own personal configuration. This can be used like:
+    #
+    # @yield []
+    #   The given block will be called to configure each application.
+    #
+    # @example
+    #   Padrino.configure_apps do
+    #     enable  :sessions
+    #     disable :raise_errors
+    #   end
+    #
+    def configure_apps(&block)
+      @_global_configuration = block if block_given?
+    end
+
+    ##
+    # Returns project-wide configuration settings defined in
+    # {configure_apps} block.
+    #
+    def apps_configuration
+      @_global_configuration
+    end
+
+    ##
+    # Set +Encoding.default_internal+ and +Encoding.default_external+
+    # to +Encoding::UFT_8+.
+    #
+    # Please note that in +1.9.2+ with some template engines like +haml+
+    # you should turn off Encoding.default_internal to prevent problems.
+    #
+    # @see https://github.com/rtomayko/tilt/issues/75
+    #
+    # @return [NilClass]
+    #
+    def set_encoding
+      if RUBY_VERSION < '1.9'
+        $KCODE='u'
+      else
+        Encoding.default_external = Encoding::UTF_8
+        Encoding.default_internal = Encoding::UTF_8
+      end
+      nil
+    end
+
+    ##
+    # Determines whether the dependencies are locked by Bundler.
+    # otherwise return nil
+    #
+    # @return [:locked, :unlocked, nil]
+    #   Returns +:locked+ if the +Gemfile.lock+ file exists, or +:unlocked+
+    #   if only the +Gemfile+ exists.
+    #
+    # @deprecated Will be removed in 1.0.0
+    #
+    def bundle
+      return :locked   if File.exist?(root('Gemfile.lock'))
+      return :unlocked if File.exist?(root("Gemfile"))
+    end
+
+    ##
+    # A Rack::Builder object that allows to add middlewares in front of all
+    # Padrino applications.
+    #
+    # @return [Array<Array<Class, Array, Proc>>]
+    #   The middleware classes.
+    #
+    def middleware
+      @middleware ||= []
+    end
+
+    ##
+    # Clears all previously configured middlewares.
+    #
+    # @return [Array]
+    #   An empty array
+    #
+    def clear_middleware!
+      @middleware = []
+    end
+
+    ##
+    # Convenience method for adding a Middleware to the whole padrino app.
+    #
+    # @param [Class] m
+    #   The middleware class.
+    #
+    # @param [Array] args
+    #   The arguments for the middleware.
+    #
+    # @yield []
+    #   The given block will be passed to the initialized middleware.
+    #
+    def use(m, *args, &block)
+      middleware << [m, args, block]
+    end
+  end # self
+end # Padrino

data/lib/middleman/vendor/padrino-core-0.10.5/lib/padrino-core/application.rb

@@ -0,0 +1,270 @@
+module Padrino
+  class ApplicationSetupError < RuntimeError # @private
+  end
+
+  ##
+  # Subclasses of this become independent Padrino applications (stemming from Sinatra::Application)
+  # These subclassed applications can be easily mounted into other Padrino applications as well.
+  #
+  class Application < Sinatra::Base
+    # Support for advanced routing, controllers, url_for
+    register Padrino::Routing
+
+    ##
+    # Returns the logger for this application.
+    #
+    # @return [Padrino::Logger] Logger associated with this app.
+    #
+    def logger
+      Padrino.logger
+    end
+
+    class << self
+
+      def inherited(base) # @private
+        logger.devel "Setup #{base}"
+        CALLERS_TO_IGNORE.concat(PADRINO_IGNORE_CALLERS)
+        base.default_configuration!
+        base.prerequisites.concat([
+          File.join(base.root, "/models.rb"),
+          File.join(base.root, "/models/**/*.rb"),
+          File.join(base.root, "/lib.rb"),
+          File.join(base.root, "/lib/**/*.rb")
+        ]).uniq!
+        Padrino.require_dependencies(base.prerequisites)
+        super(base) # Loading the subclass inherited method
+      end
+
+      ##
+      # Reloads the application files from all defined load paths
+      #
+      # This method is used from our Padrino Reloader during development mode
+      # in order to reload the source files.
+      #
+      # @return [TrueClass]
+      #
+      # @example
+      #   MyApp.reload!
+      #
+      def reload!
+        logger.devel "Reloading #{self}"
+        @_dependencies = nil # Reset dependencies
+        reset! # Reset sinatra app
+        reset_router! # Reset all routes
+        Padrino.require_dependencies(self.app_file, :force => true) # Reload the app file
+        require_dependencies # Reload dependencies
+        default_filters!     # Reload filters
+        default_routes!      # Reload default routes
+        default_errors!      # Reload our errors
+        I18n.reload! if defined?(I18n) # Reload also our translations
+        true
+      end
+
+      ##
+      # Resets application routes to only routes not defined by the user
+      #
+      # @return [TrueClass]
+      #
+      # @example
+      #   MyApp.reset_routes!
+      #
+      def reset_routes!
+        reset_router!
+        default_routes!
+        true
+      end
+
+      ##
+      # Returns the routes of our app.
+      #
+      # @example
+      #   MyApp.routes
+      #
+      def routes
+        router.routes
+      end
+
+      ##
+      # Setup the application by registering initializers, load paths and logger
+      # Invoked automatically when an application is first instantiated
+      #
+      # @return [TrueClass]
+      #
+      def setup_application!
+        return if @_configured
+        self.require_dependencies
+        self.default_filters!
+        self.default_routes!
+        self.default_errors!
+        if defined?(I18n)
+          I18n.load_path << self.locale_path
+          I18n.reload!
+        end
+        @_configured = true
+        @_configured
+      end
+
+      ##
+      # Run the Padrino app as a self-hosted server using
+      # Thin, Mongrel or WEBrick (in that order)
+      #
+      # @see Padrino::Server#start
+      #
+      def run!(options={})
+        return unless Padrino.load!
+        Padrino.mount(self.to_s).to("/")
+        Padrino.run!(options)
+      end
+
+      ##
+      # @return [Array]
+      #   directory that need to be added to +$LOAD_PATHS+ from this application
+      #
+      def load_paths
+        @_load_paths ||= %w(models lib mailers controllers helpers).map { |path| File.join(self.root, path) }
+      end
+
+      ##
+      # Returns default list of path globs to load as dependencies
+      # Appends custom dependency patterns to the be loaded for your Application
+      #
+      # @return [Array]
+      #   list of path globs to load as dependencies
+      #
+      # @example
+      #   MyApp.dependencies << "#{Padrino.root}/uploaders/**/*.rb"
+      #   MyApp.dependencies << Padrino.root('other_app', 'controllers.rb')
+      #
+      def dependencies
+        @_dependencies ||= [
+          "urls.rb", "config/urls.rb", "mailers/*.rb", "mailers.rb",
+          "controllers/**/*.rb", "controllers.rb", "helpers/**/*.rb", "helpers.rb"
+        ].map { |file| Dir[File.join(self.root, file)] }.flatten
+      end
+
+      ##
+      # An array of file to load before your app.rb, basically are files wich our app depends on.
+      #
+      # By default we look for files:
+      #
+      #   # List of default files that we are looking for:
+      #   yourapp/models.rb
+      #   yourapp/models/**/*.rb
+      #   yourapp/lib.rb
+      #   yourapp/lib/**/*.rb
+      #
+      # @example Adding a custom perequisite
+      #   MyApp.prerequisites << Padrino.root('my_app', 'custom_model.rb')
+      #
+      def prerequisites
+        @_prerequisites ||= []
+      end
+
+      protected
+        ##
+        # Defines default settings for Padrino application
+        #
+        def default_configuration!
+          # Overwriting Sinatra defaults
+          set :app_file, File.expand_path(caller_files.first || $0) # Assume app file is first caller
+          set :environment, Padrino.env
+          set :reload, Proc.new { development? }
+          set :logging, Proc.new { development? }
+          set :method_override, true
+          set :sessions, false
+          set :public_folder, Proc.new { Padrino.root('public', uri_root) }
+          set :views, Proc.new { File.join(root,   "views") }
+          set :images_path, Proc.new { File.join(public, "images") }
+          set :protection, false
+          # Padrino specific
+          set :uri_root, "/"
+          set :app_name, self.to_s.underscore.to_sym
+          set :default_builder, 'StandardFormBuilder'
+          set :flash, defined?(Sinatra::Flash) || defined?(Rack::Flash)
+          set :authentication, false
+          # Padrino locale
+          set :locale_path, Proc.new { Dir[File.join(self.root, "/locale/**/*.{rb,yml}")] }
+          # Load the Global Configurations
+          class_eval(&Padrino.apps_configuration) if Padrino.apps_configuration
+        end
+
+        ##
+        # We need to add almost __sinatra__ images.
+        #
+        def default_routes!
+          configure :development do
+            get '*__sinatra__/:image.png' do
+              content_type :png
+              filename = File.dirname(__FILE__) + "/images/#{params[:image]}.png"
+              send_file filename
+            end
+          end
+        end
+
+        ##
+        # This filter it's used for know the format of the request, and automatically set the content type.
+        #
+        def default_filters!
+          before do
+            unless @_content_type
+              @_content_type = :html
+              response['Content-Type'] = 'text/html;charset=utf-8'
+            end
+          end
+        end
+
+        ##
+        # This log errors for production environments
+        #
+        def default_errors!
+          configure :production do
+            error ::Exception do
+              boom = env['sinatra.error']
+              logger.error ["#{boom.class} - #{boom.message}:", *boom.backtrace].join("\n ")
+              response.status = 500
+              content_type 'text/html'
+              '<h1>Internal Server Error</h1>'
+            end unless errors.has_key?(::Exception)
+          end
+        end
+
+        ##
+        # Requires all files within the application load paths
+        #
+        def require_dependencies
+          Padrino.set_load_paths(*load_paths)
+          Padrino.require_dependencies(dependencies, :force => true)
+        end
+
+      private
+
+        # Overrides the default middleware for Sinatra based on Padrino conventions
+        # Also initializes the application after setting up the middleware
+        def setup_default_middleware(builder)
+          setup_sessions builder
+          setup_flash builder
+          builder.use Padrino::ShowExceptions         if show_exceptions?
+          builder.use Padrino::Logger::Rack, uri_root if Padrino.logger && logging?
+          builder.use Padrino::Reloader::Rack         if reload?
+          builder.use Rack::MethodOverride            if method_override?
+          builder.use Rack::Head
+          setup_protection builder
+          setup_application!
+        end
+
+         # TODO Remove this in a few versions (rack-flash deprecation)
+         # Move register Sinatra::Flash into setup_default_middleware
+         # Initializes flash using sinatra-flash or rack-flash
+        def setup_flash(builder)
+          register Sinatra::Flash if flash? && defined?(Sinatra::Flash)
+          if defined?(Rack::Flash) && !defined?(Sinatra::Flash)
+            logger.warn %Q{
+              [Deprecation] In Gemfile, 'rack-flash' should be replaced with 'sinatra-flash'!
+              Rack-Flash is not compatible with later versions of Rack and should be replaced.
+            }
+            builder.use Rack::Flash, :sweep => true     if flash?
+          end
+        end
+    end # self
+  end # Application
+end # Padrino