middleman 2.0.7 → 2.0.8

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

@@ -1,18 +0,0 @@
-module Padrino
-  ##
-  # This module extend Sinatra::ShowExceptions adding Padrino as "Framework"
-  #
-  class ShowExceptions < Sinatra::ShowExceptions
-    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/vendor/padrino-core-0.10.0/lib/padrino-core/caller.rb

@@ -1,45 +0,0 @@
-module Padrino
-  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 impls) ignore patterns ...
-  #
-  PADRINO_IGNORE_CALLERS.concat(RUBY_IGNORE_CALLERS) if defined?(RUBY_IGNORE_CALLERS)
-
-  private
-    ##
-    # Returns the filename for the file that is the direct caller (first caller)
-    #
-    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.
-    #
-    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/vendor/padrino-core-0.10.0/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/vendor/padrino-core-0.10.0/lib/padrino-core/cli/base.rb

@@ -1,152 +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."
-      method_option :verbose,     :type => :boolean, :aliases => "-v", :desc => "Log message to standard output."
-      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(' ')} ..."
-        ENV['PADRINO_LOG_LEVEL'] ||= "test"
-        load File.expand_path('../rake.rb', __FILE__)
-        silence(:stdout) { 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
-        puts "=> Loading #{options.environment} console (Padrino v.#{Padrino.version})"
-        require 'irb'
-        require "irb/completion"
-        require File.expand_path('config/boot.rb')
-        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
-          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"] ||= options.environment.to_s
-          ENV["RACK_ENV"] = ENV["PADRINO_ENV"] # Also set this for middleware
-          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/vendor/padrino-core-0.10.0/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/vendor/padrino-core-0.10.0/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/vendor/padrino-core-0.10.0/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/vendor/padrino-core-0.10.0/lib/padrino-core/command.rb

@@ -1,27 +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
-  #
-  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.
-  #
-  def self.ruby_command
-    @ruby_command ||= begin
-      ruby = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
-      ruby << Config::CONFIG['EXEEXT']
-
-      # escape string in case path to ruby executable contain spaces.
-      ruby.sub!(/.*\s.*/m, '"\&"')
-      ruby
-    end
-  end
-end # Padrino

data/lib/middleman/vendor/padrino-core-0.10.0/lib/padrino-core/loader.rb

@@ -1,182 +0,0 @@
-module Padrino
-  class << self
-
-    ##
-    # Hooks to be called before a load/reload
-    #
-    # ==== Examples
-    #
-    #   before_load do
-    #     pre_initialize_something
-    #   end
-    #
-    #
-    def before_load(&block)
-      @_before_load ||= []
-      @_before_load << block if block_given?
-      @_before_load
-    end
-
-    ##
-    # Hooks to be called after a load/reload
-    #
-    # ==== Examples
-    #
-    #   after_load do
-    #     DataMapper.finalize
-    #   end
-    #
-    #
-    def after_load(&block)
-      @_after_load ||= []
-      @_after_load << block if block_given?
-      @_after_load
-    end
-
-    ##
-    # Returns the used $LOAD_PATHS from padrino
-    #
-    def load_paths
-      @_load_paths_was = %w(lib models shared).map { |path| Padrino.root(path) }
-      @_load_paths ||= @_load_paths_was
-    end
-
-    ##
-    # Requires necessary dependencies as well as application files from root lib and models
-    #
-    def load!
-      return false if loaded?
-      @_called_from = first_caller
-      Padrino.set_encoding
-      Padrino.set_load_paths(*load_paths) # We set the padrino load paths
-      Padrino::Logger.setup! # Initialize our logger
-      Padrino.require_dependencies("#{root}/config/database.rb", :nodeps => true) # Be sure to don't remove constants from dbs.
-      Padrino::Reloader.lock! # Now we can remove constant from here to down
-      Padrino.before_load.each(&:call) # Run before hooks
-      Padrino.dependency_paths.each { |path| Padrino.require_dependencies(path) }
-      Padrino.after_load.each(&:call) # Run after hooks
-      Padrino::Reloader.run!
-      Thread.current[:padrino_loaded] = true
-    end
-
-    ##
-    # Clear the padrino env
-    #
-    def clear!
-      Padrino.clear_middleware!
-      Padrino.mounted_apps.clear
-      @_load_paths = nil
-      @_dependency_paths = nil
-      @_global_configuration = nil
-      Padrino.before_load.clear
-      Padrino.after_load.clear
-      Padrino::Reloader.clear!
-      Thread.current[:padrino_loaded] = nil
-    end
-
-    ##
-    # Method for reloading required applications and their files
-    #
-    def reload!
-      Padrino.before_load.each(&:call) # Run before hooks
-      Padrino::Reloader.reload! # detects the modified files
-      Padrino.after_load.each(&:call) # Run after hooks
-    end
-
-    ##
-    # This adds the ablity to instantiate Padrino.load! after Padrino::Application definition.
-    #
-    def called_from
-      @_called_from || first_caller
-    end
-
-    ##
-    # Return true if Padrino was loaded with Padrino.load!
-    #
-    def loaded?
-      Thread.current[:padrino_loaded]
-    end
-
-    ##
-    # Attempts to require all dependency libs that we need.
-    # If you use this method we can perform correctly a Padrino.reload!
-    # Another good thing that this method are dependency check, for example:
-    #
-    #   models
-    #    \-- a.rb => require something of b.rb
-    #    \-- b.rb
-    #
-    # In the example above if we do:
-    #
-    #   Dir["/models/*.rb"].each { |r| require r }
-    #
-    # we get an error, because we try to require first a.rb that need +something+ of b.rb.
-    #
-    # With +require_dependencies+ we don't have this problem.
-    #
-    # ==== Examples
-    #
-    #   # For require all our app libs we need to do:
-    #   require_dependencies("#{Padrino.root}/lib/**/*.rb")
-    #
-    def require_dependencies(*paths)
-      options = paths.extract_options!
-
-      # Extract all files to load
-      files = paths.flatten.map { |path| Dir[path] }.flatten.uniq.sort
-
-      while files.present?
-        # List of errors and failed files
-        errors, failed = [], []
-
-        # We need a size to make sure things are loading
-        size_at_start = files.size
-
-        # Now we try to require our dependencies, we dup files
-        # so we don't perform delete on the original array during
-        # iteration, this prevent problems with rubinus
-        files.dup.each do |file|
-          begin
-            Padrino::Reloader.safe_load(file, options.dup)
-            files.delete(file)
-          rescue LoadError => e
-            errors << e
-            failed << file
-          rescue NameError => e
-            errors << e
-            failed << file
-          rescue Exception => e
-            raise e
-          end
-        end
-
-        # Stop processing if nothing loads or if everything has loaded
-        raise errors.last if files.size == size_at_start && files.present?
-        break if files.empty?
-      end
-    end
-
-    ##
-    # Returns default list of path globs to load as dependencies
-    # Appends custom dependency patterns to the be loaded for Padrino
-    #
-    # ==== Examples
-    #    Padrino.dependency_paths << "#{Padrino.root}/uploaders/*.rb"
-    #
-    def dependency_paths
-      @_dependency_paths_was = [
-        "#{root}/config/database.rb", "#{root}/lib/**/*.rb", "#{root}/shared/lib/**/*.rb",
-        "#{root}/models/**/*.rb", "#{root}/shared/models/**/*.rb", "#{root}/config/apps.rb"
-      ]
-      @_dependency_paths ||= @_dependency_paths_was
-    end
-
-    ##
-    # Concat to $LOAD_PATH the given paths
-    #
-    def set_load_paths(*paths)
-      $:.concat(paths); load_paths.concat(paths)
-      $:.uniq!; load_paths.uniq!
-    end
-  end # self
-end # Padrino