pakyow-core 0.11.3 → 1.0.0.rc1

data/lib/pakyow/task.rb

@@ -0,0 +1,315 @@
+# frozen_string_literal: true
+
+require "rake"
+require "forwardable"
+require "optparse"
+
+require "pakyow/support/deep_freeze"
+require "pakyow/support/cli/style"
+
+require "pakyow/cli"
+
+module Pakyow
+  # Base task class that extends rake with additional functionality.
+  #
+  class Task
+    include Rake::DSL
+
+    extend Forwardable
+    def_delegators :@rake, :name
+
+    extend Support::DeepFreeze
+    unfreezable :rake
+
+    attr_reader :description
+
+    def initialize(namespace: [], description: nil, arguments: {}, options: {}, flags: {}, task_args: [], global: false, &block)
+      @description, @arguments, @options, @flags, @global = description, arguments, options, flags, global
+      @short_names = determine_short_names
+
+      if namespace.any?
+        send(:namespace, namespace.join(":")) do
+          define_task(task_args, block)
+        end
+      else
+        define_task(task_args, block)
+      end
+    end
+
+    def call(options = {}, argv = [])
+      parse_options(argv, options)
+      parse_arguments(argv, options)
+      check_options(options)
+
+      @rake.invoke(*args.map { |arg|
+        options[arg]
+      })
+    end
+
+    def help(describe: true)
+      required_arguments = sorted_arguments.select { |_, argument|
+        argument[:required]
+      }.map { |key, _|
+        "[#{key.to_s.upcase}]"
+      }.join(" ")
+
+      required_options = sorted_options.select { |_, option|
+        option[:required]
+      }.map { |key, _|
+        "--#{key}=#{key}"
+      }.join(" ")
+
+      text = String.new
+
+      if describe
+        text << Support::CLI.style.blue.bold(@description) + "\n"
+      end
+
+      text += <<~HELP
+
+        #{Support::CLI.style.bold("USAGE")}
+          $ pakyow #{[name, required_arguments, required_options].reject(&:empty?).join(" ")}
+      HELP
+
+      if @arguments.any?
+        text += <<~HELP
+
+          #{Support::CLI.style.bold("ARGUMENTS")}
+        HELP
+
+        longest_length = @arguments.keys.map(&:to_s).max_by(&:length).length
+        sorted_arguments.each do |key, argument|
+          description = Support::CLI.style.yellow(argument[:description])
+          if argument[:required]
+            description += Support::CLI.style.red(" (required)")
+          end
+          text += "  #{key.upcase}".ljust(longest_length + 4) + description + "\n"
+        end
+      end
+
+      if @options.any?
+        text += <<~HELP
+
+          #{Support::CLI.style.bold("OPTIONS")}
+        HELP
+
+        longest_length = (@options.keys + @flags.keys).map(&:to_s).max_by(&:length).length
+        sorted_options_and_flags.each do |key, option|
+          description = Support::CLI.style.yellow(option[:description])
+
+          if option[:required]
+            description += Support::CLI.style.red(" (required)")
+          end
+
+          prefix = if @flags.key?(key)
+            "      --#{key}"
+          else
+            if @short_names.key?(key)
+              "  -#{key.to_s[0]}, --#{key}=#{key}"
+            else
+              "      --#{key}=#{key}"
+            end
+          end
+
+          text += prefix.ljust(longest_length * 2 + 11) + description + "\n"
+        end
+      end
+
+      text
+    end
+
+    def app?
+      args.include?(:app)
+    end
+
+    def global?
+      @global == true
+    end
+
+    private
+
+    def sorted_arguments
+      @arguments.sort_by { |key, _| args.index(key) }
+    end
+
+    def sorted_options
+      @options.sort
+    end
+
+    def sorted_options_and_flags
+      @options.merge(@flags).sort
+    end
+
+    def define_task(task_args, task_block)
+      @rake = task(*task_args) { |task, args|
+        instance_exec(task, args, &task_block)
+      }
+    end
+
+    def args
+      @args ||= @rake.arg_names.map(&:to_sym)
+    end
+
+    def parse_options(argv, options)
+      unparsed = Array.new
+      OptionParser.new { |opts|
+        @flags.keys.each do |flag|
+          opts.on("--#{flag}") do |v|
+            options[flag] = v
+          end
+        end
+
+        @options.keys.each do |option|
+          match = ["--#{option}=VAL"]
+          if @short_names.key?(option)
+            match.unshift("-#{@short_names[option]}VAL")
+          end
+
+          opts.on(*match) do |v|
+            options[option] = v
+          end
+        end
+      }.order!(argv) do |arg|
+        unparsed << arg
+      end
+
+      argv.concat(unparsed)
+    rescue OptionParser::InvalidOption => error
+      raise CLI::InvalidInput, "`#{error.args.first}' is not a supported option"
+    end
+
+    def parse_arguments(argv, options)
+      sorted_arguments.each do |key, argument|
+        if argv.any?
+          options[key] = argv.shift
+        elsif argument[:required]
+          raise CLI::InvalidInput, "`#{key}' is a required argument"
+        end
+      end
+
+      if argv.any?
+        raise CLI::InvalidInput, "`#{argv.shift}' is not a supported argument"
+      end
+    end
+
+    def check_options(options)
+      @options.each do |key, option|
+        if option[:required] && !options.key?(key)
+          raise CLI::InvalidInput, "`#{key}' is a required option"
+        end
+      end
+
+      options.keys.each do |key|
+        unless global_options.key?(key) || args.include?(key)
+          raise CLI::InvalidInput, "`#{key}' is not a supported option"
+        end
+      end
+    end
+
+    def global_options
+      Hash[@options.select { |_, option|
+        option[:global]
+      }]
+    end
+
+    UNAVAILABLE_SHORT_NAMES = %w(a e h).freeze
+    def determine_short_names
+      short_names = {
+        env: "e"
+      }
+
+      @options.each do |name, opts|
+        if short = opts[:short]
+          short = name[0] if short == :default
+          unless short_names.value?(short) || UNAVAILABLE_SHORT_NAMES.include?(short)
+            short_names[name] = short
+          end
+        end
+      end
+
+      @flags.each do |name, opts|
+        if short = opts[:short]
+          unless short_names.value?(short) || UNAVAILABLE_SHORT_NAMES.include?(short)
+            short_names[name] = short
+          end
+        end
+      end
+
+      short_names
+    end
+
+    class Loader
+      attr_reader :__namespace, :__description, :__arguments, :__options, :__flags, :__tasks, :__global
+
+      def initialize(path)
+        @__namespace = []
+        @__description = nil
+        @__arguments = {}
+        @__options = {}
+        @__flags = {}
+        @__tasks = []
+        @__global = false
+
+        eval(File.read(path), binding, path)
+      end
+
+      def namespace(name, &block)
+        @__namespace << name.to_sym
+        instance_exec(&block)
+        @__namespace.pop
+      end
+
+      def describe(description)
+        @__description = description
+      end
+      alias :desc :describe
+
+      def argument(name, description, required: false)
+        @__arguments[name.to_sym] = {
+          description: description,
+          required: required
+        }
+      end
+
+      def option(name, description, required: false, short: :default)
+        @__options[name.to_sym] = {
+          description: description,
+          required: required,
+          short: short
+        }
+      end
+
+      def flag(name, description, short: nil)
+        @__flags[name.to_sym] = {
+          description: description,
+          short: short
+        }
+      end
+
+      def task(*args, &block)
+        @__tasks << Task.new(
+          namespace: @__namespace,
+          description: @__description,
+          arguments: @__arguments,
+          options: CLI::GLOBAL_OPTIONS.select { |key, _|
+            key == :env || args[1].to_a.include?(key)
+          }.merge(@__options),
+          flags: @__flags,
+          task_args: args,
+          global: @__global,
+          &block
+        )
+
+        @__description = nil
+        @__arguments = {}
+        @__options = {}
+        @__global = false
+      end
+
+      def global_task(*args, &block)
+        @__global = true
+        task(*args, &block)
+      end
+    end
+  end
+end

data/lib/pakyow/tasks/boot.rake

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+desc "Boot the environment"
+option :host, "The host the server runs on (default: #{Pakyow.config.server.host})"
+option :port, "The port the server runs on (default: #{Pakyow.config.server.port})"
+flag :standalone, "Disable automatic reloading of changes"
+task :boot, [:host, :port, :standalone] do |_, args|
+  if host = args[:host]
+    Pakyow.config.server.host = host
+  end
+
+  if port = args[:port]
+    Pakyow.config.server.port = port
+  end
+
+  if args[:standalone]
+    Pakyow.config.server.proxy = false
+  end
+
+  Pakyow.run
+end

data/lib/pakyow/tasks/create.rake

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+desc "Create a new project"
+argument :path, "Where to create the project", required: true
+global_task :create, [:path] do |_, args|
+  require "pakyow/support/inflector"
+
+  project_name = Pakyow::Support.inflector.underscore(
+    File.basename(args[:path]).downcase
+  )
+
+  project_name.gsub!("  ", " ")
+  project_name.gsub!(" ", "_")
+
+  human_project_name = Pakyow::Support.inflector.humanize(project_name)
+
+  require "pakyow/generators/project"
+  Pakyow::Generators::Project.new(
+    File.expand_path("../../generators/project/default", __FILE__)
+  ).generate(args[:path], project_name: project_name, human_project_name: human_project_name)
+
+  require "pakyow/support/cli/style"
+  puts <<~OUTPUT
+
+    #{Pakyow::Support::CLI.style.bold "You're all set! Go to your new project:"}
+      $ cd #{args[:path]}
+
+    #{Pakyow::Support::CLI.style.bold "Then boot it up:"}
+      $ pakyow boot
+
+  OUTPUT
+end

data/lib/pakyow/tasks/help.rake

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+desc "Get help for the command line interface"
+argument :command, "The command to get help for"
+task :help, [:command] do |_, args|
+  # FIXME: Without this condition the command runs infinitely. The reason isn't
+  # obvious and needs to be revisited at some point in the future.
+  #
+  unless defined?($helping) && $helping
+    $helping = true
+    if args.key?(:command)
+      Pakyow::CLI.new([args[:command], "-h"])
+    else
+      Pakyow::CLI.new(["-h"])
+    end
+  end
+end

data/lib/pakyow/tasks/info/endpoints.rake

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "pakyow/support/cli/style"
+require "pakyow/support/dependencies"
+
+desc "Show defined endpoints for an app"
+namespace :info do
+  task :endpoints, [:app] do |_, args|
+    endpoint_methods = args[:app].endpoints.map { |endpoint|
+      endpoint.method.to_s.upcase
+    }
+
+    longest_endpoint_method = endpoint_methods.max { |a, b|
+      a.length <=> b.length
+    }
+
+    endpoint_names = args[:app].endpoints.map { |endpoint|
+      endpoint.name
+    }
+
+    longest_endpoint_name = endpoint_names.max { |a, b|
+      a.to_s.length <=> b.to_s.length
+    }
+
+    endpoint_paths = args[:app].endpoints.map { |endpoint|
+      endpoint.path
+    }
+
+    longest_endpoint_path = endpoint_paths.max { |a, b|
+      a.to_s.length <=> b.to_s.length
+    }
+
+    endpoint_sources = args[:app].endpoints.map { |endpoint|
+      source_location = endpoint.source_location.join(":")
+      if source_location.empty?
+        "unknown"
+      else
+        Pakyow::Support::Dependencies.library_name(source_location) ||
+          Pakyow::Support::Dependencies.strip_path_prefix(source_location)
+      end
+    }
+
+    longest_endpoint_source = endpoint_sources.max { |a, b|
+      a.to_s.length <=> b.to_s.length
+    }
+
+    puts endpoint_names.map(&:to_s).each_with_index.map { |endpoint_name, i|
+      if endpoint_name.start_with?("@") || endpoint_name.end_with?("_default")
+        nil
+      else
+        source = endpoint_sources[i]
+
+        source = if source.start_with?("pakyow-")
+          Pakyow::Support::CLI.style.blue(
+            "pakyow/#{source.split("pakyow-", 2)[1]}"
+          )
+        elsif source == "unknown"
+          Pakyow::Support::CLI.style.italic(source)
+        else
+          source
+        end
+
+        [
+          ":#{endpoint_name.ljust(longest_endpoint_name.length)}",
+          endpoint_methods[i].ljust(longest_endpoint_method.length),
+          endpoint_paths[i].ljust(longest_endpoint_path.length),
+          source.ljust(longest_endpoint_source.length)
+        ].join("  ")
+      end
+    }.compact.sort
+  end
+end

data/lib/pakyow/tasks/info.rake

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "pakyow/info"
+
+require "pakyow/support/inflector"
+require "pakyow/support/cli/style"
+
+desc "Show details about the current project"
+task :info do
+  info = Pakyow.info
+  longest_key_length = info.values.flat_map { |value|
+    value.is_a?(Hash) ? value.keys : value
+  }.max_by(&:length).length
+
+  puts Pakyow::Support::CLI.style.bold("Library Versions".upcase)
+  info[:versions].each do |key, value|
+    puts "  #{Pakyow::Support.inflector.humanize(key).ljust(longest_key_length + 8)}#{value}"
+  end
+
+  info[:apps].each do |app|
+    header = app[:class]
+    header += " [#{app[:reference]}]" if app.key?(:reference)
+    puts
+    puts Pakyow::Support::CLI.style.bold(header)
+    app.delete(:class)
+    app.delete(:reference)
+    app.each do |key, value|
+      puts "  #{Pakyow::Support.inflector.humanize(key).ljust(longest_key_length + 8)}#{value}"
+    end
+  end
+end

data/lib/pakyow/tasks/irb.rake

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+desc "Start an interactive session"
+task :irb do
+  Pakyow.boot
+
+  require "#{Pakyow.config.cli.repl.to_s.downcase}"
+
+  ARGV.clear
+  Pakyow.config.cli.repl.start
+end

data/lib/pakyow/tasks/prelaunch.rake

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+desc "Run the prelaunch tasks"
+task :prelaunch do
+  def find_task(task_name)
+    Pakyow.tasks.find { |task|
+      task.name == task_name.to_s
+    } || raise("#{Pakyow::Support::CLI.style.blue(task_name)} is not a prelaunch task")
+  end
+
+  def run_task(task_name, task_options)
+    task_options[:env] = Pakyow.env
+    task = find_task(task_name)
+
+    Pakyow.logger.info "[prelaunch] running: #{task_name}, #{task_options}"
+    task.call(task_options)
+  end
+
+  Pakyow.boot(unsafe: true)
+
+  # Run prelaunch tasks registered with the environment.
+  #
+  Pakyow.config.tasks.prelaunch.each do |task_name, task_options = {}|
+    run_task(task_name, task_options)
+  end
+
+  # Run prelaunch tasks registered with each pakyow app.
+  #
+  Pakyow.apps.each do |app|
+    if app.is_a?(Pakyow::App)
+      app.config.tasks.prelaunch.each do |task_name, task_options = {}|
+        task_options[:app] = app
+        run_task(task_name, task_options)
+      end
+    end
+  end
+end

data/lib/pakyow/types.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "dry-types"
+
+module Pakyow
+  module Types
+    include Dry.Types(default: :nominal)
+
+    MAPPING = {
+      string: Coercible::String,
+      boolean: Params::Bool,
+      date: Params::Date,
+      time: Params::Time,
+      datetime: Params::Time,
+      integer: Params::Integer,
+      float: Params::Float,
+      decimal: Params::Decimal
+    }.freeze
+
+    def self.type_for(type)
+      if type.is_a?(Dry::Types::Type)
+        type
+      else
+        MAPPING.fetch(type.to_sym)
+      end
+    rescue KeyError => error
+      raise UnknownType.build(error, type: type, context: {
+        type: type, types: MAPPING.keys
+      })
+    end
+  end
+end

data/lib/pakyow/validations/acceptance.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require "pakyow/support/core_refinements/array/ensurable"
+
+require "pakyow/validator"
+
+module Pakyow
+  module Validations
+    # Ensures that the given value matches an acceptance value. By default, the value must equal
+    # +true+. Use the `accepts` keyword argument to pass one or more comparison values.
+    #
+    # @example
+    #   validate :acceptance
+    #
+    # @example
+    #   validate :acceptance, accepts: ["yes", "y"]
+    #
+    # @api public
+    module Acceptance
+      using Support::Refinements::Array::Ensurable
+
+      def self.name
+        :acceptance
+      end
+
+      def self.message(**)
+        "must be accepted"
+      end
+
+      def self.valid?(value, accepts: true, **)
+        Array.ensure(accepts).include?(value)
+      end
+    end
+
+    Validator.register_validation(Acceptance)
+  end
+end

data/lib/pakyow/validations/email.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "pakyow/validator"
+
+module Pakyow
+  module Validations
+    # Validates that the value is a valid email address.
+    #
+    # @api public
+    module Email
+      REGEX = /\A[A-Z0-9._%+-]+@(?:[A-Z0-9-]+\.)+[A-Z]{2,4}\z/i
+
+      def self.name
+        :email
+      end
+
+      def self.message(**)
+        "must be a valid email address"
+      end
+
+      def self.valid?(value, **)
+        value.to_s.match?(REGEX)
+      end
+    end
+
+    Validator.register_validation(Email)
+  end
+end

data/lib/pakyow/validations/inline.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module Pakyow
+  module Validations
+    # Wraps an inline validation proc so that we know its given name.
+    #
+    # @api private
+    class Inline
+      extend Forwardable
+
+      attr_reader :name
+
+      def initialize(name, block)
+        @name, @block = name, block
+      end
+
+      def message(**)
+        "is invalid"
+      end
+
+      def valid?(value, context: nil, **)
+        if context
+          context.instance_exec(value, &@block)
+        else
+          @block.call(value)
+        end
+      end
+    end
+  end
+end