geny 0.1.0

data/lib/geny/actions/ui.rb

@@ -0,0 +1,59 @@
+require "tty-prompt"
+
+module Geny
+  module Actions
+    # Utillities for printing to the console.
+    # @see https://rubydoc.info/github/piotrmurach/tty-prompt/TTY/Prompt TTY::Prompt
+    class UI < TTY::Prompt
+      attr_reader :color
+
+      # Create a new UI
+      # @param color [Pastel]
+      def initialize(color:, **opts)
+        super(opts)
+        @color = color
+      end
+
+      # Print a heading
+      # @param message [String]
+      #
+      # @example
+      #   ui.heading "Files"
+      def heading(message)
+        say "#{@color.dim("==")} #{@color.bold(message)}"
+      end
+
+      # Print a status
+      # @param label [String]
+      # @param message [String]
+      # @param color [Symbol]
+      #
+      # @example
+      #   ui.status "create", "hello.txt"
+      #   ui.status "remove", "hello.txt", color: :red
+      def status(label, message, color: :green)
+        say "#{@color.send(color, label.rjust(12))}  #{message}"
+      end
+
+      # Print an error
+      # @param message [String]
+      #
+      # @example
+      #   ui.error "the world is ending"
+      def error(message)
+        stderr.puts "#{@color.red("ERROR:")} #{message}"
+      end
+
+      # Print and error and abort
+      # @param message [String]
+      # @raise [SystemExit]
+      #
+      # @example
+      #   ui.abort! "command failed, exiting"
+      def abort!(message)
+        error(message)
+        exit 1
+      end
+    end
+  end
+end

data/lib/geny/cli.rb

@@ -0,0 +1,99 @@
+require "argy"
+require "geny"
+require "geny/registry"
+require "geny/version"
+require "geny/actions/ui"
+
+module Geny
+  class CLI
+    # The registry used for locating commands
+    # @return [Registry]
+    attr_reader :registry
+
+    # The version of your program
+    # @return [String]
+    attr_reader :version
+
+    # The name of your program
+    # @return [String]
+    attr_reader :program_name
+
+    # A description for your program
+    # @return [String]
+    attr_reader :description
+
+    # The column width for help information
+    # @return [Integer]
+    attr_reader :column
+
+    # Create a new CLI
+    # @param registry [Registry]
+    # @param version [String]
+    # @param program_name [String]
+    # @param description [String]
+    # @param column [Integer]
+    def initialize(
+      registry: Registry.new,
+      version: VERSION,
+      program_name: "geny",
+      description: nil,
+      column: 20
+    )
+      @registry = registry
+      @version = version
+      @program_name = program_name
+      @description = description
+      @column = column
+    end
+
+    # Parse arguments and invoke a command
+    # @param argv [Array<String>]
+    def run(argv)
+      opts = parser.parse(argv, strategy: :order)
+      help! unless opts.command?
+
+      command = registry.find!(opts.command)
+      command.run(opts.unused_args)
+    end
+
+    # Print an error and abort the program.
+    # @param message [String] error message
+    # @raise [SystemExit]
+    def abort!(message)
+      color = Pastel.new(enabled: $stdout.tty?)
+      ui = Actions::UI.new(color: color)
+      ui.abort!(message)
+    end
+
+    private
+
+    def parser
+      @parser ||= Argy.new do |o|
+        o.usage "#{program_name} [COMMAND]"
+        o.description description
+        o.argument :command, desc: "generator to run"
+
+        o.on "-v", "--version", "print version and exit" do
+          puts version
+          exit
+        end
+
+        o.on "-h", "--help", "show this help and exit" do
+          help!
+        end
+      end
+    end
+
+    def help!
+      help = parser.help(column: column)
+      puts help
+      puts help.section("COMMANDS")
+
+      registry.scan.each do |cmd|
+        puts help.entry(cmd.name, desc: cmd.description)
+      end
+
+      exit
+    end
+  end
+end

data/lib/geny/command.rb

@@ -0,0 +1,119 @@
+require "geny/dsl"
+require "geny/context/invoke"
+
+module Geny
+  class Command
+    # The filename for a generator, relative to the root
+    FILENAME = "generator.rb"
+
+    # The directory where templates are stored, relative to the root
+    TEMPLATES = "templates"
+
+    # The name of the command
+    # @return [String]
+    attr_reader :name
+
+    # The root directory for the command
+    # @return [String]
+    attr_reader :root
+
+    # Create a new command
+    # @param name [String] name of the command
+    # @param root [String] name of the command
+    def initialize(name:, root:)
+      @name = name
+      @root = root
+    end
+
+    # The path where the command is located
+    # @return [String]
+    def file
+      File.join(root, FILENAME)
+    end
+
+    # The path where templates are located
+    # @return [String]
+    def templates_path
+      File.join(root, TEMPLATES)
+    end
+
+    # The command's option parser
+    # @return [Argy::Parser]
+    def parser
+      dsl.parser
+    end
+
+    # The command's helper modules
+    # @return [Array<Module>]
+    def helpers
+      dsl.helpers
+    end
+
+    # The description for a command
+    # @return [String]
+    def description
+      parser.description
+    end
+
+    # Parse command-line options
+    # @param argv [Array<String>]
+    # @return [Argy::Options]
+    def parse(argv)
+      parser.parse(argv)
+    end
+
+    # Parse command-line options and run the command
+    # @param argv [Array<String>]
+    def run(argv)
+      options = parse(argv)
+      invoke!(options.to_h)
+    end
+
+    # Invoke a command with options
+    # @param options [Hash{Symbol => Object}]
+    def invoke(**options)
+      options = parser.default_values.merge(options)
+      parser.validate!(options)
+      invoke!(options)
+    end
+
+    # Defines the behavior of a command. The block is evaluated
+    # within the context of a DSL.
+    #
+    # @example
+    #   command = Commmand.new(name: "foo", root: "path/to/root")
+    #   command.define do
+    #     parse {}
+    #     invoke {}
+    #   end
+    def define(&block)
+      @dsl = DSL.new
+      @dsl.instance_eval(&block)
+      self
+    end
+
+    private
+
+    def invoke!(options)
+      context = Context::Invoke.new(
+        command: self,
+        locals: extend_with_queries(options)
+      )
+
+      context.instance_eval(&dsl.invoke)
+    end
+
+    def extend_with_queries(options)
+      queries = options.map { |k, v| [:"#{k}?", !!v] }
+      options.merge(queries.to_h)
+    end
+
+    def dsl
+      return @dsl if @dsl
+
+      @dsl = DSL.new
+      @dsl.instance_eval File.read(file)
+      @dsl
+    end
+  end
+end

data/lib/geny/context/base.rb

@@ -0,0 +1,30 @@
+module Geny
+  module Context
+    # @api private
+    class Base
+      attr_reader :command, :locals
+
+      def initialize(command:, locals: {})
+        @locals = locals
+        @command = command
+        @command.helpers.each { |h| extend h }
+      end
+
+      private
+
+      def respond_to_missing?(meth, *)
+        locals.key?(meth) || super
+      end
+
+      def method_missing(meth, *args)
+        return super unless locals.key?(meth)
+
+        unless args.empty?
+          raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 0)"
+        end
+
+        locals[meth]
+      end
+    end
+  end
+end

data/lib/geny/context/invoke.rb

@@ -0,0 +1,56 @@
+require "pastel"
+require "geny/context/base"
+require "geny/actions/ui"
+require "geny/actions/git"
+require "geny/actions/shell"
+require "geny/actions/files"
+require "geny/actions/templates"
+
+module Geny
+  module Context
+    # The `invoke` behavior for all commands is evaluated in
+    # the context of this class. All methods that are defined
+    # here are available inside `invoke`.
+    class Invoke < Base
+      # A utility for colored output
+      # @return [Pastel]
+      # @see https://github.com/piotrmurach/pastel
+      def color
+        Pastel.new(enabled: $stdout.tty?)
+      end
+
+      # A utility for printing messages to the console
+      # @return [Actions::UI]
+      def ui
+        Actions::UI.new(color: color)
+      end
+
+      # A utility for interacting with files
+      # @return [Actions::Files]
+      def files
+        Actions::Files.new
+      end
+
+      # A utility for running shell commands
+      # @return [Actions::Shell]
+      def shell
+        Actions::Shell.new(ui: ui)
+      end
+
+      # A utility for interacting with git repositories
+      # @return [Actions::Git]
+      def git
+        Actions::Git.new(shell: shell)
+      end
+
+      # A utility for rendering and copying templates
+      # @return [Actions::Templates]
+      def templates
+        Actions::Templates.new(
+          root: command.templates_path,
+          view: View.new(command: command, locals: locals)
+        )
+      end
+    end
+  end
+end

data/lib/geny/context/view.rb

@@ -0,0 +1,15 @@
+require "geny/context/base"
+
+module Geny
+  module Context
+    # All templates are evaluated in the context of a View.
+    # All command-line options, locals, and helper methods
+    # wil be available in templates.
+    class View < Base
+      # @private
+      def merge(updates)
+        View.new(command: command, locals: locals.merge(updates))
+      end
+    end
+  end
+end

data/lib/geny/dsl.rb

@@ -0,0 +1,44 @@
+require "argy"
+require "pathname"
+
+module Geny
+  # The top-level command file is evaulated in the context
+  # of this class.
+  class DSL
+    # @private
+    def initialize
+      @helpers = []
+      @invoke = proc { warn "I don't know what to do!" }
+    end
+
+    # Define arguments and options that the command accepts.
+    # The block is evaluated in the context of an {https://rubydoc.info/github/rzane/argy/Argy/Parser Argy::Parser}.
+    def parse(&block)
+      parser.instance_eval(&block)
+    end
+
+    # Define the behavior for when the command runs. The block is
+    # evaluated in the context of a {Context::Invoke}.
+    def invoke(&block)
+      @invoke = block if block_given?
+      @invoke
+    end
+
+    # Define helper methods. These methods are available within
+    # the {#invoke} block and all templates.
+    def helpers(&block)
+      @helpers << Module.new(&block) if block_given?
+      @helpers
+    end
+
+    # @private
+    def parser
+      @parser ||= Argy.new do |o|
+        o.on "-h", "--help", "show this help and exit" do
+          puts o.help
+          exit
+        end
+      end
+    end
+  end
+end

data/lib/geny/error.rb

@@ -0,0 +1,20 @@
+module Geny
+  # A base class for all errors
+  class Error < StandardError
+  end
+
+  # Raised when a command cannot be found.
+  class NotFoundError < Error
+  end
+
+  # Raised when a shell command exits with a non-zero status.
+  class ExitError < Error
+    attr_reader :code, :command
+
+    def initialize(code:, command:)
+      @code = code
+      @command = command
+      super "Command `#{command}` failed (exit code: #{code})"
+    end
+  end
+end

data/lib/geny/registry.rb

@@ -0,0 +1,71 @@
+require "pathname"
+require "geny/error"
+require "geny/command"
+
+module Geny
+  class Registry
+    # The default load path. By default, Geny
+    # will search
+    LOAD_PATH = [
+      File.join(Dir.pwd, ".geny"),
+      *ENV.fetch("CODE_HEN_PATH", "").split(":"),
+      File.expand_path("../generators", __dir__)
+    ]
+
+    # The directories to search for commands in
+    # @return [Array<String>]
+    attr_reader :load_path
+
+    # Create a new registry
+    # @param load_path [Array<String>]
+    def initialize(load_path: LOAD_PATH)
+      @load_path = load_path
+    end
+
+    # Iterate over all load paths and find all commands
+    # @return [Array<Command>]
+    def scan
+      glob = File.join("**", Command::FILENAME)
+
+      commands = load_path.flat_map do |path|
+        path = Pathname.new(path)
+
+        path.glob(glob).map do |file|
+          root = file.dirname
+          name = root.relative_path_from(path)
+          name = name.to_s.tr(File::SEPARATOR, ":")
+          Command.new(name: name, root: root.to_s)
+        end
+      end
+
+      commands.sort_by(&:name)
+    end
+
+    # Find a command by name
+    # @param name [String] name of the command
+    # @return [Command,nil]
+    def find(name)
+      load_path.each do |path|
+        file = File.join(path, *name.split(":"), Command::FILENAME)
+        root = File.dirname(file)
+        return Command.new(name: name, root: root) if File.exist?(file)
+      end
+
+      nil
+    end
+
+    # Find a command by name or raise an error
+    # @param name [String] name of the command
+    # @raise [NotFoundError] when the command is not found
+    # @return [Command]
+    def find!(name)
+      find(name) || command_not_found!(name)
+    end
+
+    private
+
+    def command_not_found!(name)
+      raise NotFoundError, "There doesn't appear to be a generator named '#{name}'"
+    end
+  end
+end

data/lib/geny/version.rb

@@ -0,0 +1,3 @@
+module Geny
+  VERSION = "0.1.0"
+end

data/lib/geny.rb

@@ -0,0 +1,4 @@
+require "geny/version"
+
+module Geny
+end