middleman-core 3.2.2 → 3.3.0

data/lib/vendored-middleman-deps/padrino-core-0.11.4/lib/padrino-core/application/showexceptions.rb

@@ -1,21 +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
-end

data/lib/vendored-middleman-deps/padrino-core-0.11.4/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-.*$},
-    %r{/padrino-.*/(lib|bin)},
-    %r{/bin/padrino$},
-    %r{/sinatra(/(base|main|showexceptions))?\.rb$},
-    %r{lib/tilt.*\.rb$},
-    %r{lib/rack.*\.rb$},
-    %r{lib/mongrel.*\.rb$},
-    %r{lib/shotgun.*\.rb$},
-    %r{bin/shotgun$},
-    %r{\(.*\)},
-    %r{shoulda/context\.rb$},
-    %r{mocha/integration},
-    %r{test/unit},
-    %r{rake_test_loader\.rb},
-    %r{custom_require\.rb$},
-    %r{active_support},
-    %r{/thor}
-  ] 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

data/lib/vendored-middleman-deps/padrino-core-0.11.4/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
-    end
-  end
-end

data/lib/vendored-middleman-deps/padrino-core-0.11.4/lib/padrino-core/cli/base.rb

@@ -1,159 +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 (alternatively use 's')."
-      map "s" => :start
-      method_option :server,    :type => :string,  :aliases => "-a", :desc => "Rack Handler (default: autodetect)"
-      method_option :host,      :type => :string,  :aliases => "-h", :required => true, :default => '127.0.0.1', :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 "stop", "Stops the Padrino application (alternatively use 'st')."
-      map "st" => :stop
-      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__)
-        Rake.application.init
-        Rake.application.instance_variable_set(:@rakefile, __FILE__)
-        load File.expand_path('Rakefile')
-        Rake.application.top_level
-      end
-
-      desc "console", "Boots up the Padrino application irb console (alternatively use 'c')."
-      map "c" => :console
-      def console(*args)
-        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 (alternatively use 'gen' or 'g')."
-      map ["gen", "g"] => :generate
-      def generate(*args)
-        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 "version", "Show current Padrino version."
-      map ["-v", "--version"] => :version
-      def version
-        require 'padrino-core/version'
-        puts "Padrino v. #{Padrino.version}"
-      end
-
-      desc "runner", "Run a piece of code in the Padrino application environment (alternatively use 'run' or 'r')."
-      map ["run", "r"] => :runner
-      def runner(*args)
-        prepare :runner
-
-        code_or_file = args.shift
-        abort "Please specify code or file" if code_or_file.nil?
-
-        require File.expand_path('config/boot.rb')
-
-        if File.exist?(code_or_file)
-          eval(File.read(code_or_file), nil, code_or_file)
-        else
-          eval(code_or_file)
-        end
-      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
-  end
-end

data/lib/vendored-middleman-deps/padrino-core-0.11.4/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/vendored-middleman-deps/padrino-core-0.11.4/lib/padrino-core/cli/rake.rb

@@ -1,47 +0,0 @@
-require File.expand_path('../../tasks', __FILE__)
-require 'rake'
-require 'rake/dsl_definition'
-require 'thor'
-require 'securerandom' unless defined?(SecureRandom)
-require 'padrino-gen'
-
-module PadrinoTasks
-  def self.init(init=false)
-    $LOAD_PATH.unshift(File.expand_path("lib"))
-    Padrino::Tasks.files.flatten.uniq.each { |rakefile| Rake.application.add_import(rakefile) rescue puts "<= Failed load #{ext}" }
-    load(File.expand_path('../rake_tasks.rb', __FILE__))
-    Rake.application.load_imports
-  end
-
-  def self.use(task)
-    tasks << task
-  end
-
-  def self.tasks
-    @tasks ||= []
-  end
-
-  def self.load?(task, constant_present)
-    if constant_present && !PadrinoTasks.tasks.include?(task)
-      warn <<-WARNING.undent
-        Loading #{task} tasks automatically.
-        This functionality will be disabled in future versions. Please put
-
-          PadrinoTasks.use(#{task.inspect})
-          PadrinoTasks.init
-
-        and remove
-
-          require File.expand_path('../config/boot.rb', __FILE__)
-
-        in you Rakefile instead.
-      WARNING
-    end
-
-    constant_present || PadrinoTasks.tasks.include?(task)
-  end
-end
-
-def shell
-  @_shell ||= Thor::Base.shell.new
-end

data/lib/vendored-middleman-deps/padrino-core-0.11.4/lib/padrino-core/cli/rake_tasks.rb

@@ -1,52 +0,0 @@
-Dir["{lib/tasks/**,tasks/**,test,spec}/*.rake"].each do |file|
-  begin
-    load(file)
-  rescue LoadError => e
-    warn "#{file}: #{e.message}"
-  end
-end
-
-# Loads the Padrino applications mounted within the project.
-# Setting up the required environment for Padrino.
-task :environment do
-  require File.expand_path('config/boot.rb', Rake.application.original_dir)
-
-  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
-
-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

data/lib/vendored-middleman-deps/padrino-core-0.11.4/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

data/lib/vendored-middleman-deps/padrino-core-0.11.4/lib/padrino-core/loader.rb

@@ -1,224 +0,0 @@
-module Padrino
-  class << self
-    ##
-    # Hooks to be called before a load/reload.
-    #
-    # @yield []
-    #   The given block will be called before Padrino was loaded/reloaded.
-    #
-    # @return [Array<Proc>]
-    #   The load/reload before hooks.
-    #
-    # @example
-    #   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.
-    #
-    # @yield []
-    #   The given block will be called after Padrino was loaded/reloaded.
-    #
-    # @return [Array<Proc>]
-    #   The load/reload hooks.
-    #
-    # @example
-    #   after_load do
-    #     DataMapper.finalize
-    #   end
-    #
-    def after_load(&block)
-      @_after_load ||= []
-      @_after_load << block if block_given?
-      @_after_load
-    end
-
-    ##
-    # The used +$LOAD_PATHS+ from Padrino.
-    #
-    # @return [Array<String>]
-    #   The load paths used by 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.
-    #
-    # @return [Boolean]
-    #   returns true if Padrino is not already bootstraped otherwise else.
-    #
-    def load!
-      return false if loaded?
-      t = Time.now
-
-      @_called_from = first_caller
-      Padrino.set_encoding
-      Padrino.set_load_paths(*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
-
-      Padrino.logger.devel "Loaded Padrino in #{Time.now - t} seconds"
-    end
-
-    ##
-    # Clear the padrino env.
-    #
-    # @return [NilClass]
-    #
-    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!
-      return unless Padrino::Reloader.changed?
-      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 ability to instantiate {Padrino.load!} after
-    # {Padrino::Application} definition.
-    #
-    def called_from
-      @_called_from || first_caller
-    end
-
-    ##
-    # Determines whether Padrino was loaded with {Padrino.load!}.
-    #
-    # @return [Boolean]
-    #   Specifies whether Padrino was loaded.
-    #
-    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 this method we don't have this problem.
-    #
-    # @param [Array<String>] paths
-    #   The paths to require.
-    #
-    # @example 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?
-        errors, failed = [], []
-
-        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 NameError, LoadError => e
-            Padrino.logger.devel "Problem while loading #{file}: #{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.
-    #
-    # @return [Array<String>]
-    #   The dependencey paths.
-    #
-    # @example
-    #   Padrino.dependency_paths << "#{Padrino.root}/uploaders/*.rb"
-    #
-    def dependency_paths
-      @_dependency_paths ||= (dependency_paths_was + Array(module_paths))
-    end
-
-    ##
-    # Concat to +$LOAD_PATH+ the given paths.
-    #
-    # @param [Array<String>] paths
-    #   The paths to concat.
-    #
-    def set_load_paths(*paths)
-      $:.concat(paths); load_paths.concat(paths)
-      $:.uniq!; load_paths.uniq!
-    end
-
-    private
-
-    def module_paths
-      Padrino.modules.map(&:dependency_paths).flatten!
-    end
-
-    def 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"
-      ]
-    end
-  end
-end