pakyow-core 0.11.3 → 1.0.0.rc1

data/lib/pakyow/cli.rb

@@ -0,0 +1,199 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "optparse"
+
+require "pakyow/support/cli/style"
+
+require "pakyow/error"
+require "pakyow/environment"
+
+module Pakyow
+  # The Pakyow command line interface.
+  #
+  # @api private
+  class CLI
+    class InvalidInput < Error; end
+
+    GLOBAL_OPTIONS = {
+      app: {
+        description: "The app to run the command on",
+        global: true
+      },
+      env: {
+        description: "What environment to use",
+        global: true
+      }
+    }
+
+    def initialize(argv = ARGV.dup)
+      @argv = argv
+      @options = {}
+      @task = nil
+      @command = nil
+
+      parse_global_options
+
+      if project_context?
+        setup_environment
+      end
+
+      load_tasks
+
+      if @command
+        find_task_for_command
+        set_app_for_command
+        call_task
+      else
+        puts_help
+      end
+    rescue StandardError => error
+      if $stdout.isatty
+        puts_error(error)
+
+        if @task
+          puts @task.help(describe: false)
+        else
+          puts_help(banner: false)
+        end
+
+        ::Process.exit(0)
+      else
+        raise error
+      end
+    end
+
+    private
+
+    def tasks
+      Pakyow.tasks.select { |task|
+        (task.global? && !project_context?) || (!task.global? && project_context?)
+      }
+    end
+
+    def project_context?
+      File.exist?(Pakyow.config.environment_path + ".rb")
+    end
+
+    def parse_global_options
+      parse_with_unknown_args do
+        OptionParser.new do |opts|
+          opts.on("-eENV", "--env=ENV") do |e|
+            @options[:env] = e
+          end
+
+          opts.on("-aAPP", "--app=APP") do |a|
+            @options[:app] = a
+          end
+
+          opts.on("-h", "--help") do
+            @options[:help] = true
+          end
+        end
+      end
+
+      @options[:env] ||= ENV["APP_ENV"] || ENV["RACK_ENV"] || "development"
+      ENV["APP_ENV"] = ENV["RACK_ENV"] = @options[:env]
+    end
+
+    def parse_with_unknown_args
+      parser, unknown, original, unparsed = yield, Array.new, @argv.dup, Array.new
+
+      begin
+        parser.order!(@argv) do |arg|
+          if @command
+            unparsed << arg
+          else
+            @command = arg
+          end
+        end
+      rescue OptionParser::InvalidOption => error
+        unknown.concat(error.args); retry
+      end
+
+      @argv = (original & (@argv | unknown)) + unparsed
+    end
+
+    def setup_environment
+      Pakyow.setup(env: @options[:env])
+    end
+
+    def load_tasks
+      Pakyow.load_tasks
+    end
+
+    def find_task_for_command
+      unless @task = tasks.find { |task| task.name == @command }
+        raise UnknownCommand.new_with_message(
+          command: @command
+        )
+      end
+    end
+
+    def set_app_for_command
+      if @task.app?
+        Pakyow.boot
+        @options[:app] = if @options.key?(:app)
+          Pakyow.app(@options[:app]) || raise("`#{@options[:app]}' is not a known app")
+        elsif Pakyow.apps.count == 1
+          Pakyow.apps.first
+        elsif Pakyow.apps.count > 0
+          raise "multiple apps were found; please specify one with the --app option"
+        else
+          raise "couldn't find an app to run this command for"
+        end
+      elsif @options.key?(:app)
+        puts_warning "app was ignored by command #{Support::CLI.style.blue(@command)}"
+      end
+    end
+
+    def call_task
+      if @options[:help]
+        puts @task.help
+      else
+        @task.call(@options.select { |key, _|
+          (key == :app && @task.app?) || key != :app
+        }, @argv.dup)
+      end
+    rescue InvalidInput => error
+      puts_error(error)
+      puts @task.help(describe: false)
+    end
+
+    def puts_error(error)
+      puts "  #{Support::CLI.style.red("›")} #{Error::CLIFormatter.format(error.to_s)}"
+    end
+
+    def puts_warning(warning)
+      puts "  #{Support::CLI.style.yellow("›")} #{warning}"
+    end
+
+    def puts_help(banner: true)
+      if banner
+        puts_banner
+      end
+
+      puts_usage
+      puts_commands
+    end
+
+    def puts_banner
+      puts Support::CLI.style.blue.bold("Pakyow Command Line Interface")
+    end
+
+    def puts_usage
+      puts
+      puts Support::CLI.style.bold("USAGE")
+      puts "  $ pakyow [COMMAND]"
+    end
+
+    def puts_commands
+      puts
+      puts Support::CLI.style.bold("COMMANDS")
+      longest_name_length = tasks.map(&:name).max_by(&:length).length
+      tasks.sort { |a, b| a.name <=> b.name }.each do |task|
+        puts "  #{task.name}".ljust(longest_name_length + 4) + Support::CLI.style.yellow(task.description) + "\n"
+      end
+    end
+  end
+end

data/lib/pakyow/connection/multipart_input.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "delegate"
+
+module Pakyow
+  class Connection
+    class MultipartInput < SimpleDelegator
+      attr_reader :filename, :headers, :type
+
+      def initialize(filename:, headers:, type:)
+        @filename, @headers, @type = filename, headers, type
+        __setobj__(Tempfile.new(["PakyowMultipart", File.extname(filename)]))
+      end
+
+      alias media_type type
+
+      # Fixes an issue using pp inside a delegator.
+      #
+      def pp(*args)
+        Kernel.pp(*args)
+      end
+    end
+  end
+end

data/lib/pakyow/connection/multipart_parser.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "multipart_parser/reader"
+require "protocol/http/headers"
+
+require "pakyow/error"
+
+require "pakyow/connection/multipart_input"
+
+module Pakyow
+  class Connection
+    class MultipartParser
+      class LimitExceeded < Error; end
+      class ParseError < Error; end
+
+      DEFAULT_MULTIPART_LIMIT = 100
+
+      attr_reader :values
+
+      def initialize(params, boundary:)
+        @params, @boundary = params, boundary.to_s.gsub(/[\"\']/, "")
+        @reader = ::MultipartParser::Reader.new(@boundary)
+        @reader.on_part(&method(:on_part))
+        @reader.on_error(&method(:on_error))
+        @values = []
+        @size = 0
+      end
+
+      def parse(input)
+        while data = input.read
+          @reader.write(data)
+        end
+
+        finalize
+        @params
+      rescue StandardError => error
+        ensure_closed
+        if error.is_a?(LimitExceeded)
+          raise error
+        else
+          raise ParseError.build(error)
+        end
+      end
+
+      private
+
+      def finalize
+        @values.select { |value|
+          value.is_a?(MultipartInput)
+        }.each(&:rewind)
+      end
+
+      def add(value)
+        @values << value
+
+        if value.is_a?(MultipartInput)
+          @size += 1
+        end
+
+        if @size > DEFAULT_MULTIPART_LIMIT
+          raise LimitExceeded, "multipart limit (#{DEFAULT_MULTIPART_LIMIT}) exceeded"
+        end
+
+        value
+      end
+
+      def on_part(part)
+        headers = Protocol::HTTP::Headers.new(part.headers).to_h
+        disposition = QueryParser.new.tap { |parser|
+          parser.parse(headers["content-disposition"].to_s)
+        }.params
+        content_type = QueryParser.new.tap { |parser|
+          parser.parse(headers["content-type"].to_s)
+        }.params
+
+        if filename = disposition["filename"]
+          value = add(MultipartInput.new(filename: filename, headers: headers, type: part.mime))
+
+          part.on_data do |data|
+            value << data
+          end
+        else
+          value = add(String.new)
+          encoding = if charset = content_type["charset"]
+            Encoding.find(charset.gsub(/[^a-zA-Z0-9\-_]/, ""))
+          else
+            Encoding::UTF_8
+          end
+
+          value.force_encoding(encoding)
+
+          part.on_data do |data|
+            value << data
+          end
+        end
+
+        @params.add_value_for_key(value, part.name || disposition["filename"])
+      end
+
+      def on_error(error)
+        ensure_closed
+        raise ParseError, error
+      end
+
+      def ensure_closed
+        @values.each do |value|
+          value.close if value.is_a?(MultipartInput)
+        end
+      end
+    end
+  end
+end

data/lib/pakyow/connection/params.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "delegate"
+require "forwardable"
+
+require "pakyow/support/indifferentize"
+
+require "pakyow/connection/query_parser"
+
+module Pakyow
+  class Connection
+    class Params < DelegateClass(Support::IndifferentHash)
+      extend Forwardable
+      def_delegators :@parser, :parse, :add, :add_value_for_key
+
+      def initialize
+        params = Support::IndifferentHash.new
+        @parser = QueryParser.new(params: params)
+        super(params)
+      end
+
+      # Fixes an issue using pp inside a delegator.
+      #
+      def pp(*args)
+        Kernel.pp(*args)
+      end
+    end
+  end
+end

data/lib/pakyow/connection/query_parser.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require "cgi"
+
+require "pakyow/error"
+
+module Pakyow
+  class Connection
+    # Parses one or more query strings, building up a params hash. Supports nested query strings,
+    # and enforces limits for key space size and total nested parameter depth.
+    #
+    # Aspects of this were inspired by Rack's query parser, including key space and depth limits. We
+    # decided it was worth writing our own for several reasons:
+    #
+    #   1) Avoid Rack as a dependency for the majority use-case.
+    #
+    #   2) Improve the interface so you don't have to know ahead of time if you're dealing with a
+    #      nested query string or not, and to allow for params to be built up from many strings.
+    #
+    #   3) Improve performance (up to 90% faster for a simple query string, 10% for nested).
+    #
+    # @api private
+    class QueryParser
+      class InvalidParameter < Error; end
+      class KeySpaceLimitExceeded < Error; end
+      class DepthLimitExceeded < Error; end
+
+      DEFAULT_DELIMETER = /[&;,]/
+      DEFAULT_KEY_SPACE_LIMIT = 102_400
+      DEFAULT_DEPTH_LIMIT = 100
+
+      attr_reader :params, :key_space_limit, :depth_limit
+
+      def initialize(key_space_limit: DEFAULT_KEY_SPACE_LIMIT, depth_limit: DEFAULT_DEPTH_LIMIT, params: {})
+        @params = params
+        @key_space_limit = key_space_limit
+        @key_space_size = 0
+        @depth_limit = depth_limit
+      end
+
+      def parse(input, delimiter = DEFAULT_DELIMETER)
+        input.to_s.split(delimiter).each do |part|
+          key, value = part.split("=", 2)
+          key = unescape(key).strip if key
+          value = unescape(value).strip if value
+          add_value_for_key(value, key)
+        end
+
+        @params
+      end
+
+      def add(key, value, params = @params)
+        unless params.key?(key)
+          @key_space_size += key.size
+        end
+
+        if @key_space_size > @key_space_limit
+          raise KeySpaceLimitExceeded, "key space limit (#{@key_space_limit}) exceeded by `#{key}'"
+        else
+          params[key] = value
+        end
+      end
+
+      def add_value_for_key(value, key, params = @params, depth = 0)
+        if depth > @depth_limit
+          raise DepthLimitExceeded, "depth limit (#{@depth_limit}) exceeded by `#{key}'"
+        end
+
+        if key && key.include?("[") && key.include?("]")
+          opened = false
+          read, nested = String.new, nil
+
+          key.length.times do |i|
+            char = key[i]
+
+            if char == "["
+              opened = true
+            elsif char == "]" && opened
+              opened = false
+
+              case params
+              when Array
+                nested_value = if nested
+                  if current_nested_value = params.last
+                    unless current_nested_value.is_a?(@params.class)
+                      raise InvalidParameter, "expected `#{read}' to be #{@params.class} (got #{current_nested_value.class})"
+                    end
+
+                    if current_nested_value.key?(nested)
+                      (params << @params.class.new).last
+                    else
+                      current_nested_value
+                    end
+                  else
+                    (params << @params.class.new).last
+                  end
+                else
+                  if current_nested_value = params[read]
+                    unless current_nested_value.is_a?(Array)
+                      raise InvalidParameter, "expected `#{read}' to be Array (got #{current_nested_value.class})"
+                    end
+
+                    current_nested_value
+                  else
+                    (params << []).last
+                  end
+                end
+              when @params.class
+                nested_value = if nested
+                  if current_nested_value = params[read]
+                    unless current_nested_value.is_a?(@params.class)
+                      raise InvalidParameter, "expected `#{read}' to be #{@params.class} (got #{current_nested_value.class})"
+                    end
+
+                    current_nested_value
+                  else
+                    @params.class.new
+                  end
+                else
+                  if current_nested_value = params[read]
+                    unless current_nested_value.is_a?(Array)
+                      raise InvalidParameter, "expected `#{read}' to be Array (got #{current_nested_value.class})"
+                    end
+
+                    current_nested_value
+                  else
+                    []
+                  end
+                end
+
+                add(read, nested_value, params)
+              end
+
+              j = i + 1
+              if (next_char = key[j]) && next_char != "["
+                raise InvalidParameter, "expected `#{nested}' to be #{params.class} (got String)"
+              else
+                add_value_for_key(value, (nested || String.new) << key[j..-1], nested_value, depth + 1); break
+              end
+            elsif opened
+              (nested ||= String.new) << char
+            else
+              read << char
+            end
+          end
+        else
+          case params
+          when Array
+            params << value
+          when @params.class
+            if depth == 0 && (current_value = params[key]) && !(current_value.is_a?(Array) || current_value.is_a?(@params.class))
+              if current_value.is_a?(Array)
+                current_value << value
+              else
+                current_value = [current_value, value]
+                add(key, current_value, params)
+              end
+            else
+              if key && !key.empty?
+                add(key, value, params)
+              end
+            end
+          end
+        end
+      end
+
+      private
+
+      def unescape(string)
+        CGI.unescape(string)
+      end
+    end
+  end
+end

data/lib/pakyow/connection/statuses.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Pakyow
+  class Connection
+    # @api private
+    class Statuses
+      CODE_TO_DESCRIPTION = {
+        100 => "Continue",
+        101 => "Switching Protocols",
+        102 => "Processing",
+        103 => "Early Hints",
+
+        200 => "OK",
+        201 => "Created",
+        202 => "Accepted",
+        203 => "Non-Authoritative Information",
+        204 => "No Content",
+        205 => "Reset Content",
+        206 => "Partial Content",
+        207 => "Multi-Status",
+        208 => "Already Reported",
+        226 => "IM Used",
+
+        300 => "Multiple Choices",
+        301 => "Moved Permanently",
+        302 => "Found",
+        303 => "See Other",
+        304 => "Not Modified",
+        305 => "Use Proxy",
+        # no longer used, but included for completeness
+        306 => "Switch Proxy",
+        307 => "Temporary Redirect",
+        308 => "Permanent Redirect",
+
+        400 => "Bad Request",
+        401 => "Unauthorized",
+        402 => "Payment Required",
+        403 => "Forbidden",
+        404 => "Not Found",
+        405 => "Method Not Allowed",
+        406 => "Not Acceptable",
+        407 => "Proxy Authentication Required",
+        408 => "Request Timeout",
+        409 => "Conflict",
+        410 => "Gone",
+        411 => "Length Required",
+        412 => "Precondition Failed",
+        413 => "Payload Too Large",
+        414 => "URI Too Long",
+        415 => "Unsupported Media Type",
+        416 => "Range Not Satisfiable",
+        417 => "Expectation Failed",
+        421 => "Misdirected Request",
+        422 => "Unprocessable Entity",
+        423 => "Locked",
+        424 => "Failed Dependency",
+        426 => "Upgrade Required",
+        428 => "Precondition Required",
+        429 => "Too Many Requests",
+        431 => "Request Header Fields Too Large",
+        451 => "Unavailable for Legal Reasons",
+
+        500 => "Internal Server Error",
+        501 => "Not Implemented",
+        502 => "Bad Gateway",
+        503 => "Service Unavailable",
+        504 => "Gateway Timeout",
+        505 => "HTTP Version Not Supported",
+        506 => "Variant Also Negotiates",
+        507 => "Insufficient Storage",
+        508 => "Loop Detected",
+        510 => "Not Extended",
+        511 => "Network Authentication Required"
+      }.freeze
+
+      SYMBOL_TO_CODE = Hash[CODE_TO_DESCRIPTION.map { |code, message|
+        [message.downcase.gsub(/[^a-z]/, "_").to_sym, code]
+      }].freeze
+
+      class << self
+        # Returns the string representation for a status code or symbolized status name.
+        #
+        # @example
+        #   Pakyow::Connection::Statuses.describe(200)
+        #   => "OK"
+        #
+        #   Pakyow::Connection::Statuses.describe(:ok)
+        #   => "OK"
+        #
+        def describe(code_or_symbol)
+          CODE_TO_DESCRIPTION[code(code_or_symbol)] || "?"
+        end
+
+        # Returns the status code for the symbolized status name.
+        #
+        # @example
+        #   Pakyow::Connection::Statuses.code(:ok)
+        #   => 200
+        #
+        #   Pakyow::Connection::Statuses.code(200)
+        #   => 200
+        #
+        def code(code_or_symbol)
+          case code_or_symbol
+          when Symbol
+            SYMBOL_TO_CODE[code_or_symbol]
+          else
+            code_or_symbol = code_or_symbol.to_i
+            if CODE_TO_DESCRIPTION.key?(code_or_symbol)
+              code_or_symbol
+            else
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end