middleman-core 3.0.0.beta.2 → 3.0.0.beta.3

data/lib/middleman-core/vendor/padrino-core-0.10.6/lib/padrino-core/application/showexceptions.rb

@@ -1,20 +0,0 @@
-module Padrino
-  ##
-  # This module extend Sinatra::ShowExceptions adding Padrino as "Framework".
-  #
-  # @private
-  class ShowExceptions < Sinatra::ShowExceptions
-    private
-      def frame_class(frame)
-        if frame.filename =~ /lib\/sinatra.*\.rb|lib\/padrino.*\.rb/
-          "framework"
-        elsif (defined?(Gem) && frame.filename.include?(Gem.dir)) ||
-              frame.filename =~ /\/bin\/(\w+)$/ ||
-              frame.filename =~ /Ruby\/Gems/
-          "system"
-        else
-          "app"
-        end
-      end
-  end # ShowExceptions
-end # Padrino

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

@@ -1,269 +0,0 @@
-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
-        begun_at = Time.now
-        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)
-        logger.devel :setup, begun_at, base
-        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 #{settings}"
-        reset! # Reset sinatra app
-        reset_router! # Reset all routes
-        Padrino.require_dependencies(settings.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
-        settings.require_dependencies
-        settings.default_filters!
-        settings.default_routes!
-        settings.default_errors!
-        if defined?(I18n)
-          I18n.load_path << settings.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(settings.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(settings.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
-        [
-          'urls.rb', 'config/urls.rb', 'mailers/*.rb', 'mailers.rb',
-          'controllers/**/*.rb', 'controllers.rb', 'helpers/**/*.rb', 'helpers.rb'
-        ].map { |file| Dir[File.join(settings.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, settings.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(settings.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

data/lib/middleman-core/vendor/padrino-core-0.10.6/lib/padrino-core/caller.rb

@@ -1,53 +0,0 @@
-module Padrino
-
-  # List of callers in a Padrino application that should be ignored as part of a stack trace.
-  PADRINO_IGNORE_CALLERS = [
-    %r{lib/padrino-.*$},                             # all padrino code
-    %r{/padrino-.*/(lib|bin)},                       # all padrino code
-    %r{/bin/padrino$},                               # all padrino code
-    %r{/sinatra(/(base|main|showexceptions))?\.rb$}, # all sinatra code
-    %r{lib/tilt.*\.rb$},                             # all tilt code
-    %r{lib/rack.*\.rb$},                             # all rack code
-    %r{lib/mongrel.*\.rb$},                          # all mongrel code
-    %r{lib/shotgun.*\.rb$},                          # all shotgun lib
-    %r{bin/shotgun$},                                # shotgun binary
-    %r{\(.*\)},                                      # generated code
-    %r{shoulda/context\.rb$},                        # shoulda hacks
-    %r{mocha/integration},                           # mocha hacks
-    %r{test/unit},                                   # test unit hacks
-    %r{rake_test_loader\.rb},                        # rake hacks
-    %r{custom_require\.rb$},                         # rubygems require hacks
-    %r{active_support},                              # active_support require hacks
-    %r{/thor}                                        # thor require hacks
-  ] unless defined?(PADRINO_IGNORE_CALLERS)
-
-  ##
-  # Add rubinius (and hopefully other VM implementations) ignore patterns ...
-  #
-  PADRINO_IGNORE_CALLERS.concat(RUBY_IGNORE_CALLERS) if defined?(RUBY_IGNORE_CALLERS)
-
-  private
-    ##
-    # The filename for the file that is the direct caller (first caller).
-    #
-    # @return [String]
-    #   The file the caller method exists in.
-    #
-    def self.first_caller
-      caller_files.first
-    end
-
-    #
-    # Like +Kernel#caller+ but excluding certain magic entries and without
-    # line / method information; the resulting array contains filenames only.
-    #
-    # @return [Array<String>]
-    #   The files of the calling methods.
-    #
-    def self.caller_files
-      caller(1).
-        map    { |line| line.split(/:(?=\d|in )/)[0,2] }.
-        reject { |file,line| PADRINO_IGNORE_CALLERS.any? { |pattern| file =~ pattern } }.
-        map    { |file,line| file }
-    end
-end # Padrino

data/lib/middleman-core/vendor/padrino-core-0.10.6/lib/padrino-core/cli/adapter.rb

@@ -1,24 +0,0 @@
-module Padrino
-  module Cli
-    module Adapter
-      class << self
-        # Start for the given options a rackup handler
-        def start(options)
-          Padrino.run!(options.symbolize_keys)
-        end
-
-        # Method that stop (if exist) a running Padrino.application
-        def stop(options)
-          options.symbolize_keys!
-          if File.exist?(options[:pid])
-            pid = File.read(options[:pid]).to_i
-            print "=> Sending INT to process with pid #{pid} wait "
-            Process.kill(2, pid) rescue nil
-          else
-            puts "=> #{options[:pid]} not found!"
-          end
-        end
-      end # self
-    end # Adapter
-  end # Cli
-end # Padrino

data/lib/middleman-core/vendor/padrino-core-0.10.6/lib/padrino-core/cli/base.rb

@@ -1,150 +0,0 @@
-require 'thor'
-
-module Padrino
-  module Cli
-
-    class Base < Thor
-      include Thor::Actions
-
-      class_option :chdir, :type => :string, :aliases => "-c", :desc => "Change to dir before starting"
-      class_option :environment, :type => :string,  :aliases => "-e", :required => true, :default => :development, :desc => "Padrino Environment"
-      class_option :help, :type => :boolean, :desc => "Show help usage"
-
-      desc "start", "Starts the Padrino application"
-      method_option :server,      :type => :string,  :aliases => "-a", :desc => "Rack Handler (default: autodetect)"
-      method_option :host,        :type => :string,  :aliases => "-h", :required => true, :default => "0.0.0.0", :desc => "Bind to HOST address"
-      method_option :port,        :type => :numeric, :aliases => "-p", :required => true, :default => 3000, :desc => "Use PORT"
-      method_option :daemonize,   :type => :boolean, :aliases => "-d", :desc => "Run daemonized in the background"
-      method_option :pid,         :type => :string,  :aliases => "-i", :desc => "File to store pid"
-      method_option :debug,       :type => :boolean,                   :desc => "Set debugging flags"
-      def start
-        prepare :start
-        require File.expand_path("../adapter", __FILE__)
-        require File.expand_path('config/boot.rb')
-        Padrino::Cli::Adapter.start(options)
-      end
-
-      desc "s", "Starts the Padrino application"
-      def s
-        invoke :start
-      end
-
-      desc "stop", "Stops the Padrino application"
-      method_option :pid, :type => :string,  :aliases => "-p", :desc => "File to store pid", :default => 'tmp/pids/server.pid'
-      def stop
-        prepare :stop
-        require File.expand_path("../adapter", __FILE__)
-        Padrino::Cli::Adapter.stop(options)
-      end
-
-      desc "rake", "Execute rake tasks"
-      method_option :environment, :type => :string,  :aliases => "-e", :required => true, :default => :development
-      method_option :list,        :type => :string,  :aliases => "-T", :desc => "Display the tasks (matching optional PATTERN) with descriptions, then exit."
-      method_option :trace,       :type => :boolean, :aliases => "-t", :desc => "Turn on invoke/execute tracing, enable full backtrace."
-      def rake(*args)
-        prepare :rake
-        args << "-T" if options[:list]
-        args << options[:list]  unless options[:list].nil? || options[:list].to_s == "list"
-        args << "--trace" if options[:trace]
-        args << "--verbose" if options[:verbose]
-        ARGV.clear
-        ARGV.concat(args)
-        puts "=> Executing Rake #{ARGV.join(' ')} ..."
-        load File.expand_path('../rake.rb', __FILE__)
-        require File.expand_path('config/boot.rb')
-        PadrinoTasks.init(true)
-      end
-
-      desc "console", "Boots up the Padrino application irb console"
-      def console
-        prepare :console
-        require File.expand_path("../../version", __FILE__)
-        ARGV.clear
-        require 'irb'
-        require "irb/completion"
-        require File.expand_path('config/boot.rb')
-        puts "=> Loading #{Padrino.env} console (Padrino v.#{Padrino.version})"
-        require File.expand_path('../console', __FILE__)
-        IRB.start
-      end
-
-      desc "generate", "Executes the Padrino generator with given options."
-      def generate(*args)
-        # Build Padrino g as an alias of padrino-gen
-        begin
-          # We try to load the vendored padrino-gen if exist
-          padrino_gen_path = File.expand_path('../../../../../padrino-gen/lib', __FILE__)
-          $:.unshift(padrino_gen_path) if File.directory?(padrino_gen_path) && !$:.include?(padrino_gen_path)
-          require 'padrino-core/command'
-          require 'padrino-gen/command'
-          ARGV.shift
-          ARGV << 'help' if ARGV.empty?
-          Padrino.bin_gen(*ARGV)
-        rescue
-          puts "<= You need padrino-gen! Run: gem install padrino-gen"
-        end
-      end
-
-      desc "g", "Executes the Padrino generator with given options."
-      def g(*args)
-        invoke(:generate, args)
-      end
-
-      desc "gen", "Executes the Padrino generator with given options."
-      def gen(*args)
-        invoke(:generate, args)
-      end
-
-      desc "version", "Show current Padrino Version"
-      map "-v" => :version, "--version" => :version
-      def version
-        require 'padrino-core/version'
-        puts "Padrino v. #{Padrino.version}"
-      end
-
-      private
-        def prepare(task)
-          if options.help?
-            help(task.to_s)
-            raise SystemExit
-          end
-          ENV["PADRINO_ENV"] ||= ENV["RACK_ENV"] ||= options.environment.to_s
-          chdir(options.chdir)
-          unless File.exist?('config/boot.rb')
-            puts "=> Could not find boot file in: #{options.chdir}/config/boot.rb !!!"
-            raise SystemExit
-          end
-        end
-
-      protected
-        def self.banner(task=nil, *args)
-          "padrino #{task.name}"
-        end
-
-        def chdir(dir)
-          return unless dir
-          begin
-            Dir.chdir(dir.to_s)
-          rescue Errno::ENOENT
-            puts "=> Specified Padrino root '#{dir}' does not appear to exist!"
-          rescue Errno::EACCES
-            puts "=> Specified Padrino root '#{dir}' cannot be accessed by the current user!"
-          end
-        end
-
-        def capture(stream)
-          begin
-            stream = stream.to_s
-            eval "$#{stream} = StringIO.new"
-            yield
-            result = eval("$#{stream}").string
-          ensure
-            eval("$#{stream} = #{stream.upcase}")
-          end
-
-          result
-        end
-        alias :silence :capture
-    end # Base
-  end # Cli
-end # Padrino

data/lib/middleman-core/vendor/padrino-core-0.10.6/lib/padrino-core/cli/console.rb

@@ -1,20 +0,0 @@
-# Reloads classes
-def reload!
-  Padrino.reload!
-end
-
-# Show applications
-def applications
-  puts "==== List of Mounted Applications ====\n\n"
-  Padrino.mounted_apps.each do |app|
-    puts " * %-10s mapped to      %s" % [app.name, app.uri_root]
-  end
-  puts
-  Padrino.mounted_apps.map { |app| "#{app.name} => #{app.uri_root}" }
-end
-
-# Load apps
-Padrino.mounted_apps.each do |app|
-  puts "=> Loading Application #{app.app_class}"
-  app.app_obj.setup_application!
-end

data/lib/middleman-core/vendor/padrino-core-0.10.6/lib/padrino-core/cli/rake.rb

@@ -1,24 +0,0 @@
-require File.expand_path('../../tasks', __FILE__)
-require 'rake'
-require 'thor'
-require 'securerandom' unless defined?(SecureRandom)
-
-module PadrinoTasks
-  def self.init(init=false)
-    Padrino::Tasks.files.flatten.uniq.each { |rakefile| Rake.application.add_import(rakefile) rescue puts "<= Failed load #{ext}" }
-    if init
-      Rake.application.init
-      Rake.application.instance_variable_set(:@rakefile, __FILE__)
-      load(File.expand_path('../rake_tasks.rb', __FILE__))
-      Rake.application.load_imports
-      Rake.application.top_level
-    else
-      load(File.expand_path('../rake_tasks.rb', __FILE__))
-      Rake.application.load_imports
-    end
-  end
-end
-
-def shell
-  @_shell ||= Thor::Base.shell.new
-end

data/lib/middleman-core/vendor/padrino-core-0.10.6/lib/padrino-core/cli/rake_tasks.rb

@@ -1,59 +0,0 @@
-# Load rake tasks from common rake task definition locations
-Dir["lib/tasks/**/*.rake"].
-  concat(Dir["tasks/**/*.rake"]).
-  concat(Dir["{test,spec}/*.rake"]).each  { |rake| load(rake) }
-
-# Loads the Padrino applications mounted within the project
-# setting up the required environment for Padrino
-task :environment do
-  Padrino.mounted_apps.each do |app|
-    app.app_obj.setup_application!
-  end
-end
-
-desc "Generate a secret key"
-task :secret do
-  shell.say SecureRandom.hex(32)
-end
-
-# lists all routes of a given app
-def list_app_routes(app, args)
-  app_routes = app.named_routes
-  app_routes.reject! { |r| r.identifier.to_s !~ /#{args.query}/ } if args.query.present?
-  app_routes.map! { |r| [r.verb, r.name, r.path] }
-  return if app_routes.empty?
-  shell.say "\nApplication: #{app.app_class}", :yellow
-  app_routes.unshift(["REQUEST", "URL", "PATH"])
-  max_col_1 = app_routes.max { |a, b| a[0].size <=> b[0].size }[0].size
-  max_col_2 = app_routes.max { |a, b| a[1].size <=> b[1].size }[1].size
-  app_routes.each_with_index do |row, i|
-    message = [row[1].ljust(max_col_2+2), row[0].center(max_col_1+2), row[2]]
-    shell.say("    " + message.join(" "), i==0 ? :bold : nil)
-  end
-end
-
-desc "Displays a listing of the named routes within a project, optionally only those matched by [query]"
-task :routes, [:query] => :environment do |t, args|
-  Padrino.mounted_apps.each do |app|
-    list_app_routes(app, args)
-  end
-end
-
-desc "Displays a listing of the named routes a given app [app]"
-namespace :routes do
-  task :app, [:app] => :environment do |t, args|
-    app = Padrino.mounted_apps.find { |app| app.app_class == args.app }
-    list_app_routes(app, args) if app
-  end
-end
-
-desc "Generate the Rakefile"
-task :gen do
-  File.open(Padrino.root("Rakefile"), "w") do |file|
-    file.puts <<-RUBY.gsub(/^ {6}/, '')
-      require File.expand_path('../config/boot.rb', __FILE__)
-      require 'padrino-core/cli/rake'
-      PadrinoTasks.init
-    RUBY
-  end
-end

data/lib/middleman-core/vendor/padrino-core-0.10.6/lib/padrino-core/command.rb

@@ -1,38 +0,0 @@
-require 'rbconfig'
-
-module Padrino
-  ##
-  # This method return the correct location of padrino bin or
-  # exec it using Kernel#system with the given args
-  #
-  # @param [Array] args
-  #   command or commands to execute
-  #
-  # @return [Boolean]
-  #
-  # @example
-  #   Padrino.bin('start', '-e production')
-  #
-  def self.bin(*args)
-    @_padrino_bin ||= [self.ruby_command, File.expand_path("../../../bin/padrino", __FILE__)]
-    args.empty? ? @_padrino_bin : system(args.unshift(@_padrino_bin).join(" "))
-  end
-
-  ##
-  # Return the path to the ruby interpreter taking into account multiple
-  # installations and windows extensions.
-  #
-  # @return [String]
-  #   path to ruby bin executable
-  #
-  def self.ruby_command
-    @ruby_command ||= begin
-      ruby = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
-      ruby << RbConfig::CONFIG['EXEEXT']
-
-      # escape string in case path to ruby executable contain spaces.
-      ruby.sub!(/.*\s.*/m, '"\&"')
-      ruby
-    end
-  end
-end # Padrino