tty 0.7.0 → 0.8.0

data/appveyor.yml

@@ -9,7 +9,6 @@ test_script:
   - bundle exec rake ci
 environment:
   matrix:
-    - ruby_version: "193"
     - ruby_version: "200"
     - ruby_version: "200-x64"
     - ruby_version: "21"
@@ -18,6 +17,6 @@ environment:
     - ruby_version: "22-x64"
     - ruby_version: "23"
     - ruby_version: "23-x64"
-matrix:
-  allow_failures:
-    - ruby_version: "193"
+    - ruby_version: "24"
+    - ruby_version: "24-x64"
+    - ruby_version: "25-x64"

data/exe/teletype

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+lib_path = File.expand_path('../lib', __dir__)
+$:.unshift(lib_path) if !$:.include?(lib_path)
+require 'tty/cli'
+
+Signal.trap('INT') do
+  warn("\n#{caller.join("\n")}: interrupted")
+  exit(1)
+end
+
+begin
+  TTY::CLI.start
+rescue TTY::CLI::Error => err
+  puts "ERROR: #{err.message}"
+  exit 1 #err.status
+end

data/lib/tty.rb

@@ -1,10 +1,12 @@
 # encoding: utf-8
 
-require 'tty/version'
-require 'tty/plugins'
-require 'tty/plugins/plugin'
+require_relative 'tty/cli'
+require_relative 'tty/plugins'
+require_relative 'tty/version'
 
 module TTY
+  GEMSPEC_PATH = ::File.expand_path("#{::File.dirname(__FILE__)}/../tty.gemspec")
+
   class << self
     def included(base)
       base.send :extend, ClassMethods
@@ -25,4 +27,5 @@ module TTY
   extend ClassMethods
 end # TTY
 
-TTY.plugins.find('tty').load
+TTY.plugins.load_from(TTY::GEMSPEC_PATH, /tty-(.*)|pastel/)
+TTY.plugins.activate

data/lib/tty/cli.rb

@@ -0,0 +1,140 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'thor'
+
+require_relative 'licenses'
+
+module TTY
+  # Main CLI runner
+  # @api public
+  class CLI < Thor
+    extend TTY::Licenses
+
+    # Error raised by this runner
+    Error = Class.new(StandardError)
+
+    no_commands do
+      def self.logo(banner)
+        <<-EOS
+    ┏━━━┓
+ ┏━┳╋┳┳━┻━━┓
+ ┣━┫┗┫┗┳┳┳━┫
+ ┃ ┃┏┫┏┫┃┃★┃  #{banner}
+ ┃ ┗━┻━╋┓┃ ┃
+ ┗━━━━━┻━┻━┛
+EOS
+      end
+
+      def self.top_banner
+        require 'pastel'
+        pastel = Pastel.new
+        pastel.red(logo('Terminal apps toolkit'))
+      end
+
+      def self.executable_name
+        ::File.basename($PROGRAM_NAME)
+      end
+    end
+
+    class_option :"no-color", type: :boolean, default: false,
+                              desc: 'Disable colorization in output'
+    class_option :"dry-run", type: :boolean, aliases: ['-r'],
+                             desc: 'Run but do not make any changes'
+    class_option :debug, type: :boolean, default: false,
+                         desc: 'Run in debug mode'
+
+    def self.help(*)
+      puts top_banner
+      super
+    end
+
+    desc 'add COMMAND [SUBCOMMAND] [OPTIONS]', 'Add a command to the application'
+    long_desc <<-D
+      The `teletype add` will create a new command and place it into
+      appropriate structure in the cli app.
+
+      Example:
+        teletype add config --desc 'Set and get configuration options'
+
+        This generates a command in app/commands/config.rb
+
+      You can also add subcommands
+
+      Example:
+        teletype add config server
+
+        This generates a command in app/commands/config/server.rb
+    D
+    method_option :args, type: :array, aliases: '-a', default: [],
+                         desc: 'List command argument names',
+                         banner: 'arg1 arg2'
+    method_option :desc, aliases: '-d', desc: "Describe command's purpose"
+    method_option :force, type: :boolean, aliases: '-f',
+                          desc: 'Overwrite existing command'
+    method_option :help, type: :boolean,
+                         aliases: '-h', desc: 'Display usage information'
+    method_option :test, type: :string, aliases: '-t',
+                         desc: 'Generate a test setup',
+                         banner: 'rspec', enum: %w(rspec minitest)
+    def add(*names)
+      if options[:help]
+        invoke :help, ['add']
+      elsif names.size < 1
+        fail Error, "'teletype add' was called with no arguments\n" \
+                     "Usage: 'teletype add COMMAND_NAME'"
+      else
+        require_relative 'commands/add'
+        TTY::Commands::Add.new(names, options).execute
+      end
+    end
+
+    desc 'new PROJECT_NAME [OPTIONS]', 'Create a new command line app skeleton'
+    long_desc <<-D
+      The 'teletype new' command creates a new command line application
+      with a default directory structure and configuration at the
+      specified path.
+
+      The PROJECT_NAME will be the name for the directory that includes all the
+      files and be the default binary name.
+
+      Example:
+        teletype new cli_app
+    D
+    method_option :author, type: :array, aliases: '-a',
+                           desc: 'Author(s) of this library',
+                           banner: 'name1 name2'
+    method_option :ext, type: :boolean, default: false,
+                        desc: 'Generate a boilerpalate for C extension'
+    method_option :coc, type: :boolean, default: true,
+                        desc: 'Generate a code of conduct file'
+    method_option :force, type: :boolean, aliases: '-f',
+                          desc: 'Overwrite existing files'
+    method_option :help, aliases: '-h', type: :boolean,
+                         desc: 'Display usage information'
+    method_option :license, type: :string, default: 'mit', banner: 'mit',
+                            aliases: '-l', desc: 'Generate a license file',
+                            enum: licenses.keys.concat(['custom'])
+    method_option :test, type: :string, default: 'rspec',
+                         aliases: '-t', desc: 'Generate a test setup',
+                         banner: 'rspec', enum: %w(rspec minitest)
+    def new(app_name = nil)
+      if options[:help]
+        invoke :help, ['new']
+      elsif app_name.nil?
+        fail Error, "'teletype new' was called with no arguments\n" \
+                     "Usage: 'teletype new PROJECT_NAME'"
+      else
+        require_relative 'commands/new'
+        TTY::Commands::New.new(app_name, options).execute
+      end
+    end
+
+    desc 'version', 'TTY version'
+    def version
+      require_relative 'version'
+      puts "v#{TTY::VERSION}"
+    end
+    map %w(--version -v) => :version
+  end # CLI
+end # TTY

data/lib/tty/cmd.rb

@@ -0,0 +1,132 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'forwardable'
+
+require_relative 'path_helpers'
+
+module TTY
+  class Cmd
+    extend Forwardable
+    include PathHelpers
+
+    def_delegators :command, :run
+
+    def_delegators 'Thor::Util', :snake_case
+
+    # Execute this command
+    #
+    # @api public
+    def execute(*)
+      raise(
+        NotImplementedError,
+        "#{self.class}##{__method__} must be implemented"
+      )
+    end
+
+    # The external commands runner
+    #
+    # @see http://www.rubydoc.info/gems/tty-command
+    #
+    # @api public
+    def command(**options)
+      require 'tty-command'
+      TTY::Command.new(options)
+    end
+
+    # The cursor movement
+    #
+    # @see http://www.rubydoc.info/gems/tty-cursor
+    #
+    # @api public
+    def cursor
+      require 'tty-cursor'
+      TTY::Cursor
+    end
+
+    # Open a file or text in the user's preferred editor
+    #
+    # @see http://www.rubydoc.info/gems/tty-editor
+    #
+    # @api public
+    def editor
+      require 'tty-editor'
+      TTY::Editor
+    end
+
+    # File manipulation utility methods
+    #
+    # @see http://www.rubydoc.info/gems/tty-file
+    #
+    # @api public
+    def generator
+      require 'tty-file'
+      TTY::File
+    end
+
+    # Terminal output paging
+    #
+    # @see http://www.rubydoc.info/gems/tty-pager
+    #
+    # @api public
+    def pager(**options)
+      require 'tty-pager'
+      TTY::Pager.new(options)
+    end
+
+    # Terminal platform and OS properties
+    #
+    # @see http://www.rubydoc.info/gems/tty-pager
+    #
+    # @api public
+    def platform
+      require 'tty-platform'
+      TTY::Platform.new
+    end
+
+    # The interactive prompt
+    #
+    # @see http://www.rubydoc.info/gems/tty-prompt
+    #
+    # @api public
+    def prompt(**options)
+      require 'tty-prompt'
+      TTY::Prompt.new(options)
+    end
+
+    # Get terminal screen properties
+    #
+    # @see http://www.rubydoc.info/gems/tty-screen
+    #
+    # @api public
+    def screen
+      require 'tty-screen'
+      TTY::Screen
+    end
+
+    # The unix which utility
+    #
+    # @see http://www.rubydoc.info/gems/tty-which
+    #
+    # @api public
+    def which(*args)
+      require 'tty-which'
+      TTY::Which.which(*args)
+    end
+
+    # Check if executable exists
+    #
+    # @see http://www.rubydoc.info/gems/tty-which
+    #
+    # @api public
+    def exec_exist?(*args)
+      require 'tty-which'
+      TTY::Which.exist?(*args)
+    end
+
+    def constantinize(str)
+      str.gsub(/-[_-]*(?![_-]|$)/) { "::" }
+         .gsub(/([_-]+|(::)|^)(.|$)/) { $2.to_s + $3.upcase}
+    end
+  end # Cmd
+end # TTY

data/lib/tty/commands/add.rb

@@ -0,0 +1,321 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'ostruct'
+
+require_relative '../cmd'
+require_relative '../templater'
+
+module TTY
+  module Commands
+    class Add < TTY::Cmd
+      include PathHelpers
+
+      attr_reader :app_name
+
+      attr_reader :cmd_name
+
+      attr_reader :subcmd_name
+
+      attr_reader :options
+
+      def initialize(cmd_names, options)
+        @cmd_name = cmd_names[0]
+        @subcmd_name = cmd_names[1]
+        @app_path = relative_path_from(root_path, root_path)
+        @app_name = name_from_path(root_path)
+        @options  = options
+
+        @templater = Templater.new('add', @app_path)
+      end
+
+      def namespaced_path
+        app_name.tr('-', '/')
+      end
+
+      def template_context
+        opts = OpenStruct.new
+        opts[:cmd_options] = cmd_options
+        opts[:cmd_object_parts] = cmd_object_parts
+        opts[:cmd_desc_args] = cmd_desc_args
+        opts[:cmd_desc] = cmd_desc
+        opts[:app_indent] = app_indent
+        opts[:cmd_indent] = cmd_indent
+        opts[:cmd_path] = "#{namespaced_path}/commands/#{cmd_name_path}"
+        opts[:subcmd_path] = subcmd_name &&
+          "#{namespaced_path}/commands/#{cmd_name_path}/#{subcmd_name_path}"
+        opts[:cmd_name_constantinized] = cmd_name_constantinized
+        opts[:subcmd_name_constantinized] = subcmd_name && subcmd_name_constantinized
+        opts[:app_name_underscored] = app_name_underscored
+        opts[:cmd_name_underscored] = cmd_name_underscored
+        opts[:subcmd_name_underscored] = subcmd_name && subcmd_name_underscored
+        opts[:app_constantinized_parts] = app_name_constantinized.split('::')
+        opts[:cmd_constantinized_parts] = cmd_constantinized_parts
+        opts[:cmd_file_path] = cmd_file_path
+        opts
+      end
+
+      def file_options
+        opts = {}
+        opts[:force] = true if options['force']
+        opts[:color] = false if options['no-color']
+        opts
+      end
+
+      def execute(input: $stdin, output: $stdout)
+        validate_cmd_name(cmd_name)
+
+        test_dir = (options["test"] == 'rspec') || ::Dir.exist?('spec') ? 'spec' : 'test'
+        cli_file = "lib/#{namespaced_path}/cli.rb"
+        cli_content = ::File.read(cli_file)
+        cmd_file = "lib/#{namespaced_path}/commands/#{cmd_name_path}.rb"
+        cmd_template_path = "lib/#{namespaced_path}/templates/#{cmd_name_path}"
+
+        cmd_integ_test_file = "#{test_dir}/integration/#{cmd_name_path}_#{test_dir}.rb"
+        cmd_unit_test_file = "#{test_dir}/unit/#{cmd_name_path}_#{test_dir}.rb"
+
+        if !subcmd_present?
+          @templater.add_mapping(
+            "#{test_dir}/integration/command_#{test_dir}.rb.tt",
+            "#{test_dir}/integration/#{cmd_name_path}_#{test_dir}.rb")
+          @templater.add_mapping("#{test_dir}/unit/command_#{test_dir}.rb.tt",
+            "#{test_dir}/unit/#{cmd_name_path}_#{test_dir}.rb")
+          @templater.add_mapping('command.rb.tt', cmd_file)
+          @templater.add_mapping('gitkeep.tt', "#{cmd_template_path}/.gitkeep")
+          @templater.generate(template_context, file_options)
+
+          if !cmd_exists?(cli_content)
+            match = cmd_matches.find { |m| cli_content =~ m }
+            generator.inject_into_file(
+              cli_file, "\n#{cmd_template}",
+              {after: match}.merge(file_options))
+          end
+        else
+          subcmd_file = "lib/#{namespaced_path}/commands/#{cmd_name_path}/#{subcmd_name_path}.rb"
+          subcmd_template_path = "lib/#{namespaced_path}/templates/#{cmd_name_path}/#{subcmd_name_path}"
+          unless ::File.exists?(cmd_integ_test_file)
+            @templater.add_mapping(
+              "#{test_dir}/integration/command_#{test_dir}.rb.tt",
+              cmd_integ_test_file)
+          end
+          unless ::File.exists?(cmd_unit_test_file)
+            @templater.add_mapping(
+              "#{test_dir}/unit/#{cmd_name_path}_#{test_dir}.rb",
+              cmd_unit_test_file
+            )
+          end
+          @templater.add_mapping(
+            "#{test_dir}/integration/sub_command_#{test_dir}.rb.tt",
+            "#{test_dir}/integration/#{cmd_name_path}/#{subcmd_name_path}_#{test_dir}.rb")
+          @templater.add_mapping(
+            "#{test_dir}/unit/sub_command_#{test_dir}.rb.tt",
+            "#{test_dir}/unit/#{cmd_name_path}/#{subcmd_name_path}_#{test_dir}.rb"
+          )
+          unless ::File.exists?(cmd_file) # namespace already present
+            @templater.add_mapping('namespace.rb.tt', cmd_file)
+          end
+          @templater.add_mapping('command.rb.tt', subcmd_file)
+          @templater.add_mapping('gitkeep.tt', "#{subcmd_template_path}/.gitkeep")
+          @templater.generate(template_context, file_options)
+
+          if !subcmd_registered?(cli_content)
+            match = register_subcmd_matches.find { |m| cli_content =~ m }
+            generator.inject_into_file(
+              cli_file, "\n#{register_subcmd_template}",
+              {after: match}.merge(file_options))
+          end
+
+          content = ::File.read(cmd_file)
+          if !subcmd_exists?(content)
+            match = subcmd_matches.find {|m| content =~ m }
+            generator.inject_into_file(
+              cmd_file, "\n#{subcmd_template}",
+              {after: match}.merge(file_options))
+          end
+        end
+      end
+
+      def subcmd_present?
+        !subcmd_name.nil?
+      end
+
+      def subcmd_registered?(content)
+        content =~%r{\s*require_relative 'commands/#{cmd_name_path}'}
+      end
+
+      def subcmd_exists?(content)
+        content =~ %r{\s*def #{subcmd_name_underscored}.*}
+      end
+
+      def cmd_exists?(content)
+        content =~ %r{\s*def #{cmd_name_underscored}.*}
+      end
+
+      # Matches for inlining command defition in template
+      #
+      # @api private
+      def cmd_matches
+        [
+          %r{def version.*?:version\n}m,
+          %r{def version.*?#{app_indent}  end\n}m,
+          %r{class CLI < Thor\n}
+        ]
+      end
+
+      def subcmd_matches
+        [
+          %r{namespace .*?\n},
+          %r{class .*? < Thor\n}
+        ]
+      end
+
+      def register_subcmd_matches
+        [
+          %r{require_relative .*?\nregister .*?\n}m
+        ].concat(cmd_matches)
+      end
+
+      private
+
+      def cmd_template
+<<-EOS
+#{app_indent}#{cmd_indent}desc '#{cmd_name_underscored}#{cmd_desc_args}', '#{cmd_desc}'
+#{app_indent}#{cmd_indent}method_option :help, aliases: '-h', type: :boolean,
+#{app_indent}#{cmd_indent}                     desc: 'Display usage information'
+#{app_indent}#{cmd_indent}def #{cmd_name_underscored}(#{cmd_args.join(', ')})
+#{app_indent}#{cmd_indent}  if options[:help]
+#{app_indent}#{cmd_indent}    invoke :help, ['#{cmd_name_underscored}']
+#{app_indent}#{cmd_indent}  else
+#{app_indent}#{cmd_indent}    require_relative 'commands/#{cmd_name_path}'
+#{app_indent}#{cmd_indent}    #{cmd_object_parts.join('::')}.new(#{cmd_options.join(', ')}).execute
+#{app_indent}#{cmd_indent}  end
+#{app_indent}#{cmd_indent}end
+EOS
+      end
+
+      def register_subcmd_template
+<<-EOS
+#{app_indent}  require_relative 'commands/#{cmd_name_path}'
+#{app_indent}  register #{cmd_object_parts[0..-2].join('::')}, '#{cmd_name_underscored}', '#{cmd_name_underscored} [SUBCOMMAND]', '#{cmd_desc}'
+EOS
+      end
+
+      def subcmd_template
+<<-EOS
+#{app_indent}#{cmd_indent}desc '#{subcmd_name_underscored}#{cmd_desc_args}', '#{cmd_desc}'
+#{app_indent}#{cmd_indent}method_option :help, aliases: '-h', type: :boolean,
+#{app_indent}#{cmd_indent}                     desc: 'Display usage information'
+#{app_indent}#{cmd_indent}def #{subcmd_name_underscored}(#{cmd_args.join(', ')})
+#{app_indent}#{cmd_indent}  if options[:help]
+#{app_indent}#{cmd_indent}    invoke :help, ['#{subcmd_name_underscored}']
+#{app_indent}#{cmd_indent}  else
+#{app_indent}#{cmd_indent}    require_relative '#{cmd_name_path}/#{subcmd_name_path}'
+#{app_indent}#{cmd_indent}    #{cmd_object_parts.join('::')}.new(#{cmd_options.join(', ')}).execute
+#{app_indent}#{cmd_indent}  end
+#{app_indent}#{cmd_indent}end
+EOS
+      end
+
+      def cmd_desc_args
+        return '' unless @options[:args].any?
+        ' ' + @options[:args].map do |arg|
+          if arg.start_with?('*')
+            arg[1..-1].upcase + '...'
+          elsif arg.include?('=')
+            "[#{arg.split('=')[0].strip}]"
+          else
+           arg
+          end.upcase
+        end.join(' ')
+      end
+
+      def cmd_desc
+        @options[:desc].nil? ? 'Command description...' : @options[:desc]
+      end
+
+      def cmd_args
+        @options[:args].empty? ? ['*'] : @options[:args]
+      end
+
+      def cmd_options
+        @options[:args].map do |arg|
+          if arg.start_with?('*')
+            arg[1..-1]
+          elsif arg.include?('=')
+            arg.split('=')[0].strip
+          else
+            arg
+          end
+        end + ['options']
+      end
+
+      def app_indent
+        '  ' * app_name_constantinized.split('::').size
+      end
+
+      def cmd_indent
+        '  ' * cmd_constantinized_parts.size
+      end
+
+      def cmd_object_parts
+        [
+          app_name_constantinized,
+          'Commands',
+          cmd_name && cmd_name_constantinized,
+          subcmd_name && subcmd_name_constantinized
+        ].compact
+      end
+
+      def cmd_constantinized_parts
+        [
+          cmd_name && constantinize(cmd_name),
+          subcmd_name && constantinize(subcmd_name)
+        ].compact
+      end
+
+      def validate_cmd_name(cmd_name)
+        # TODO: check if command has correct name
+      end
+
+      def app_name_constantinized
+        constantinize(app_name)
+      end
+
+      def app_name_underscored
+        snake_case(app_name)
+      end
+
+      def cmd_name_constantinized
+        constantinize(cmd_name)
+      end
+
+      def cmd_name_underscored
+        snake_case(cmd_name)
+      end
+
+      def cmd_name_path
+        cmd_name_underscored.tr('-', '/')
+      end
+
+      def cmd_file_path
+        '../' * cmd_constantinized_parts.size + 'command'
+      end
+
+      def subcmd_name_underscored
+        snake_case(subcmd_name)
+      end
+
+      def subcmd_name_constantinized
+        constantinize(subcmd_name)
+      end
+
+      def subcmd_name_path
+        subcmd_name_underscored.tr('-', '/')
+      end
+
+      def spec_root
+        Pathname.new('spec')
+      end
+    end # Add
+  end # Commands
+end # TTY