tty-file 0.9.0 → 0.10.0

data/lib/tty-file.rb

@@ -1 +1 @@
-require_relative 'tty/file'
+require_relative "tty/file"

data/lib/tty/file.rb

@@ -5,10 +5,10 @@ require "erb"
 require "tempfile"
 require "pathname"
 
+require_relative "file/compare_files"
 require_relative "file/create_file"
 require_relative "file/digest_file"
 require_relative "file/download_file"
-require_relative "file/differ"
 require_relative "file/read_backward_file"
 require_relative "file/version"
 
@@ -56,7 +56,7 @@ module TTY
       buffer = read_to_char(relative_path, bytes, 0)
 
       begin
-        return buffer !~ /\A[\s[[:print:]]]*\z/m
+        buffer !~ /\A[\s[[:print:]]]*\z/m
       rescue ArgumentError => error
         return true if error.message =~ /invalid byte sequence/
         raise
@@ -98,9 +98,8 @@ module TTY
     # @param [File, IO, String, Pathname] source
     #   the source to generate checksum for
     # @param [String] mode
-    # @param [Hash[Symbol]] options
-    # @option options [String] :noop
-    #   No operation
+    # @param [Boolean] noop
+    #   when true skip this action
     #
     # @example
     #   checksum_file("/path/to/file")
@@ -112,21 +111,25 @@ module TTY
     #   the generated hex value
     #
     # @api public
-    def checksum_file(source, *args, **options)
+    def checksum_file(source, *args, noop: false)
       mode     = args.size.zero? ? "sha256" : args.pop
       digester = DigestFile.new(source, mode)
-      digester.call unless options[:noop]
+      digester.call unless noop
     end
     module_function :checksum_file
 
     # Change file permissions
     #
     # @param [String, Pathname] relative_path
+    #   the string or path to a file
     # @param [Integer,String] permisssions
-    # @param [Hash[Symbol]] options
-    # @option options [Symbol] :noop
-    # @option options [Symbol] :verbose
-    # @option options [Symbol] :force
+    #   the string or octal number for permissoins
+    # @param [Boolean] noop
+    #   when true skips this action
+    # @param [Boolean] verbose
+    #   when true displays logging information
+    # @param [Symbol] color
+    #   the name for the color to format display message, :green by default
     #
     # @example
     #   chmod("Gemfile", 0755)
@@ -138,10 +141,9 @@ module TTY
     #   chmod("Gemfile", "u+x,g+x")
     #
     # @api public
-    def chmod(relative_path, permissions, **options)
-      log_status(:chmod, relative_path, options.fetch(:verbose, true),
-                 options.fetch(:color, :green))
-      ::FileUtils.chmod_R(permissions, relative_path) unless options[:noop]
+    def chmod(relative_path, permissions, verbose: true, color: :green, noop: false)
+      log_status(:chmod, relative_path, verbose: verbose, color: color)
+      ::FileUtils.chmod_R(permissions, relative_path) unless noop
     end
     module_function :chmod
 
@@ -149,6 +151,18 @@ module TTY
     #
     # @param [String, Pathname, Hash] destination
     #   the path or data structure describing directory tree
+    # @param [Object] context
+    #   the context for template evaluation
+    # @param [Boolean] quiet
+    #   when true leaves prompt output, otherwise clears
+    # @param [Boolean] force
+    #   when true overwrites existing files, false by default
+    # @param [Boolean] noop
+    #   when true skips this action
+    # @param [Boolean] verbose
+    #   when true displays logging information
+    # @param [Symbol] color
+    #   the name for the color to format display message, :green by default
     #
     # @example
     #   create_directory("/path/to/dir")
@@ -170,7 +184,9 @@ module TTY
     # @return [void]
     #
     # @api public
-    def create_directory(destination, *args, **options)
+    def create_directory(destination, *args, context: nil, verbose: true,
+                         color: :green, noop: false, force: false, skip: false,
+                         quiet: true)
       parent = args.size.nonzero? ? args.pop : nil
       if destination.is_a?(String) || destination.is_a?(Pathname)
         destination = { destination.to_s => [] }
@@ -180,15 +196,18 @@ module TTY
         path = parent.nil? ? dir : ::File.join(parent, dir)
         unless ::File.exist?(path)
           ::FileUtils.mkdir_p(path)
-          log_status(:create, path, options.fetch(:verbose, true),
-                                    options.fetch(:color, :green))
+          log_status(:create, path, verbose: verbose, color: color)
         end
 
         files.each do |filename, contents|
           if filename.respond_to?(:each_pair)
-            create_directory(filename, path, **options)
+            create_directory(filename, path, context: context,
+                             verbose: verbose, color: color, noop: noop,
+                             force: force, skip: skip, quiet: quiet)
           else
-            create_file(::File.join(path, filename), contents, **options)
+            create_file(::File.join(path, filename), contents, context: context,
+                        verbose: verbose, color: color, noop: noop, force: force,
+                        skip: skip, quiet: quiet)
           end
         end
       end
@@ -203,9 +222,20 @@ module TTY
     # @param [String, Pathname] relative_path
     # @param [String|nil] content
     #   the content to add to file
-    # @param [Hash] options
-    # @option options [Symbol] :force
+    # @param [Object] context
+    #   the binding to use for the template
+    # @param [Symbol] color
+    #   the color name to use for logging
+    # @param [Boolean] force
     #   forces ovewrite if conflict present
+    # @param [Boolean] verbose
+    #   when true log the action status to stdout
+    # @param [Boolean] noop
+    #   when true do not execute the action
+    # @param [Boolean] skip
+    #   when true skip the action
+    # @param [Boolean] quiet
+    #   when true leaves prompt output, otherwise clears
     #
     # @example
     #   create_file("doc/README.md", "# Title header")
@@ -216,11 +246,14 @@ module TTY
     #   end
     #
     # @api public
-    def create_file(relative_path, *args, **options, &block)
+    def create_file(relative_path, *args, context: nil, force: false, skip: false,
+                    verbose: true, color: :green, noop: false, quiet: true, &block)
       relative_path = relative_path.to_s
       content = block_given? ? block[] : args.join
 
-      CreateFile.new(self, relative_path, content, options).call
+      CreateFile.new(self, relative_path, content, context: context, force: force,
+                     skip: skip, verbose: verbose, color: color, noop: noop,
+                     quiet: quiet).call
     end
     module_function :create_file
 
@@ -239,29 +272,33 @@ module TTY
     #   copy_file "templates/%name%.rb", "app/%name%.rb", context: vars
     #
     # @param [String, Pathname] source_path
-    # @param [Hash] options
-    # @option options [Symbol] :context
+    #   the file path to copy file from
+    # @param [Object] context
     #   the binding to use for the template
-    # @option options [Symbol] :preserve
-    #   If true, the owner, group, permissions and modified time
-    #   are preserved on the copied file, defaults to false.
-    # @option options [Symbol] :noop
-    #   If true do not execute the action.
-    # @option options [Symbol] :verbose
-    #   If true log the action status to stdout
+    # @param [Boolean] preserve
+    #   when true, the owner, group, permissions and modified time
+    #   are preserved on the copied file, defaults to false
+    # @param [Boolean] noop
+    #   when true does not execute the action
+    # @param [Boolean] verbose
+    #   when true log the action status to stdout
+    # @param [Symbol] color
+    #   the color name to use for logging
     #
     # @api public
-    def copy_file(source_path, *args, **options, &block)
+    def copy_file(source_path, *args, context: nil, force: false, skip: false,
+                  verbose: true, color: :green, noop: false, preserve: nil, &block)
       source_path = source_path.to_s
       dest_path = (args.first || source_path).to_s.sub(/\.erb$/, "")
 
-      ctx = if (vars = options[:context])
-              vars.instance_eval("binding")
+      ctx = if context
+              context.instance_eval("binding")
             else
               instance_eval("binding")
             end
 
-      create_file(dest_path, **options) do
+      create_file(dest_path, context: context, force: force, skip: skip,
+                  verbose: verbose, color: color, noop: noop) do
         version = ERB.version.scan(/\d+\.\d+\.\d+/)[0]
         template = if version.to_f >= 2.2
                     ERB.new(::File.binread(source_path), trim_mode: "-", eoutvar: "@output_buffer")
@@ -272,9 +309,10 @@ module TTY
         content = block[content] if block
         content
       end
-      return unless options[:preserve]
+      return unless preserve
 
-      copy_metadata(source_path, dest_path, **options)
+      copy_metadata(source_path, dest_path, verbose: verbose, noop: noop,
+                    color: color)
     end
     module_function :copy_file
 
@@ -314,38 +352,43 @@ module TTY
     #    command.rb
     #    README
     #
-    # @param [String, Pathname] source_path
-    # @param [Hash[Symbol]] options
-    # @option options [Symbol] :preserve
-    #   If true, the owner, group, permissions and modified time
-    #   are preserved on the copied file, defaults to false.
-    # @option options [Symbol] :recursive
-    #   If false, copies only top level files, defaults to true.
-    # @option options [Symbol] :exclude
-    #   A regex that specifies files to ignore when copying.
-    #
     # @example
     #   copy_directory("app", "new_app", recursive: false)
+    #
+    # @example
     #   copy_directory("app", "new_app", exclude: /docs/)
     #
+    # @param [String, Pathname] source_path
+    #    the source directory to copy files from
+    # @param [Boolean] preserve
+    #   when true, the owner, group, permissions and modified time
+    #   are preserved on the copied file, defaults to false.
+    # @param [Boolean] recursive
+    #   when false, copies only top level files, defaults to true
+    # @param [Regexp] exclude
+    #   a regex that specifies files to ignore when copying
+    #
     # @api public
-    def copy_directory(source_path, *args, **options, &block)
+    def copy_directory(source_path, *args, context: nil, force: false, skip: false,
+                       verbose: true, color: :green, noop: false, preserve: nil,
+                       recursive: true, exclude: nil, &block)
       source_path = source_path.to_s
       check_path(source_path)
       source = escape_glob_path(source_path)
       dest_path = (args.first || source).to_s
-      opts = { recursive: true }.merge(options)
-      pattern = opts[:recursive] ? ::File.join(source, "**") : source
+      pattern = recursive ? ::File.join(source, "**") : source
       glob_pattern = ::File.join(pattern, "*")
 
       Dir.glob(glob_pattern, ::File::FNM_DOTMATCH).sort.each do |file_source|
         next if ::File.directory?(file_source)
-        next if opts[:exclude] && file_source.match(opts[:exclude])
+        next if exclude && file_source.match(exclude)
 
         dest = ::File.join(dest_path, file_source.gsub(source_path, "."))
         file_dest = ::Pathname.new(dest).cleanpath.to_s
 
-        copy_file(file_source, file_dest, **options, &block)
+        copy_file(file_source, file_dest, context: context, force: force,
+                  skip: skip, verbose: verbose, color: color, noop: noop,
+                  preserve: preserve, &block)
       end
     end
     module_function :copy_directory
@@ -356,57 +399,88 @@ module TTY
     # Diff files line by line
     #
     # @param [String, Pathname] path_a
+    #   the path to the original file
     # @param [String, Pathname] path_b
-    # @param [Hash[Symbol]] options
-    # @option options [Symbol] :format
+    #   the path to a new file
+    # @param [Symbol] format
     #   the diffining output format
-    # @option options [Symbol] :context_lines
+    # @param [Intger] lines
     #   the number of extra lines for the context
-    # @option options [Symbol] :threshold
+    # @param [Integer] threshold
     #   maximum file size in bytes
     #
     # @example
     #   diff(file_a, file_b, format: :old)
     #
     # @api public
-    def diff(path_a, path_b, **options)
-      threshold = options[:threshold] || 10_000_000
-      output = []
+    def diff(path_a, path_b, threshold: 10_000_000, format: :unified, lines: 3,
+             header: true, verbose: true, color: :green, noop: false)
+      open_tempfile_if_missing(path_a) do |file_a, temp_a|
+        message = check_binary_or_large(file_a, threshold)
+        return message if message
 
-      open_tempfile_if_missing(path_a) do |file_a|
-        if ::File.size(file_a) > threshold
-          raise ArgumentError, "(file size of #{file_a.path} exceeds #{threshold} bytes, diff output suppressed)"
-        end
-        if binary?(file_a)
-          raise ArgumentError, "(#{file_a.path} is binary, diff output suppressed)"
-        end
-        open_tempfile_if_missing(path_b) do |file_b|
-          if binary?(file_b)
-            raise ArgumentError, "(#{file_a.path} is binary, diff output suppressed)"
-          end
-          if ::File.size(file_b) > threshold
-            return "(file size of #{file_b.path} exceeds #{threshold} bytes, diff output suppressed)"
-          end
+        open_tempfile_if_missing(path_b) do |file_b, temp_b|
+          message = check_binary_or_large(file_b, threshold)
+          return message if message
 
-          log_status(:diff, "#{file_a.path} - #{file_b.path}",
-                     options.fetch(:verbose, true), options.fetch(:color, :green))
-          return output.join if options[:noop]
+          file_a_path, file_b_path = *diff_paths(file_a, file_b, temp_a, temp_b)
+                                      .map { |path| ::File.join(*path) }
 
-          block_size = file_a.lstat.blksize
-          while !file_a.eof? && !file_b.eof?
-            output << Differ.new(file_a.read(block_size),
-                                 file_b.read(block_size),
-                                 options).call
-          end
+          log_status(:diff, "#{file_a_path} and #{file_b_path}",
+                     verbose: verbose, color: color)
+
+          return "" if noop
+
+          diff_files = CompareFiles.new(format: format, context_lines: lines,
+                                        header: header, verbose: verbose,
+                                        color: color, noop: noop,
+                                        diff_colors: diff_colors)
+
+          return diff_files.call(file_a, file_b, file_a_path, file_b_path)
         end
       end
-      output.join
     end
     module_function :diff
 
     alias diff_files diff
     module_function :diff_files
 
+    # @api private
+    def diff_paths(file_a, file_b, temp_a, temp_b)
+      if temp_a && !temp_b
+        [["a", file_b.path], ["b", file_b.path]]
+      elsif !temp_a && temp_b
+        [["a", file_a.path], ["b", file_a.path]]
+      elsif temp_a && temp_b
+        [["a"], ["b"]]
+      else
+        [file_a.path, file_b.path]
+      end
+    end
+    private_module_function :diff_paths
+
+    def diff_colors
+      {
+        green: @pastel.green.detach,
+        red: @pastel.red.detach,
+        cyan: @pastel.cyan.detach
+      }
+    end
+    private_module_function :diff_colors
+
+    # Check if file is binary or exceeds threshold size
+    #
+    # @api private
+    def check_binary_or_large(file, threshold)
+      if binary?(file)
+        "#{file.path} is binary, diff output suppressed"
+      elsif ::File.size(file) > threshold
+        "file size of #{file.path} exceeds #{threshold} bytes, " \
+        " diff output suppressed"
+      end
+    end
+    private_module_function :check_binary_or_large
+
     # Download the content from a given address and
     # save at the given relative destination. If block
     # is provided in place of destination, the content of
@@ -416,9 +490,8 @@ module TTY
     #   the URI address
     # @param [String, Pathname] dest
     #   the relative path to save
-    # @param [Hash[Symbol]] options
-    # @param options [Symbol] :limit
-    #   the limit of redirects
+    # @param [Integer] limit
+    #   the number of maximium redirects
     #
     # @example
     #   download_file("https://gist.github.com/4701967",
@@ -439,7 +512,7 @@ module TTY
         return
       end
 
-      content = DownloadFile.new(uri, dest_path, options).call
+      content = DownloadFile.new(uri, dest_path, limit: options[:limit]).call
 
       if block_given?
         content = (block.arity.nonzero? ? block[content] : block[])
@@ -467,11 +540,11 @@ module TTY
     #   end
     #
     # @api public
-    def prepend_to_file(relative_path, *args, **options, &block)
-      log_status(:prepend, relative_path, options.fetch(:verbose, true),
-                 options.fetch(:color, :green))
-      options.merge!(before: /\A/, verbose: false)
-      inject_into_file(relative_path, *args, **options, &block)
+    def prepend_to_file(relative_path, *args, verbose: true, color: :green,
+                        force: true, noop: false, &block)
+      log_status(:prepend, relative_path, verbose: verbose, color: color)
+      inject_into_file(relative_path, *args, before: /\A/, verbose: false,
+                       color: color, force: force, noop: noop, &block)
     end
     module_function :prepend_to_file
 
@@ -498,11 +571,11 @@ module TTY
     #   end
     #
     # @api public
-    def append_to_file(relative_path, *args, **options, &block)
-      log_status(:append, relative_path, options.fetch(:verbose, true),
-                 options.fetch(:color, :green))
-      options.merge!(after: /\z/, verbose: false)
-      inject_into_file(relative_path, *args, **options, &block)
+    def append_to_file(relative_path, *args, verbose: true, color: :green,
+                       force: true, noop: false, &block)
+      log_status(:append, relative_path, verbose: verbose, color: color)
+      inject_into_file(relative_path, *args, after: /\z/, verbose: false,
+                       force: force, noop: noop, color: color, &block)
     end
     module_function :append_to_file
 
@@ -520,16 +593,18 @@ module TTY
     # Inject content into file at a given location
     #
     # @param [String, Pathname] relative_path
-    #
-    # @param [Hash] options
-    # @option options [Symbol] :before
+    # @param [String] before
     #   the matching line to insert content before
-    # @option options [Symbol] :after
+    # @param [String] after
     #   the matching line to insert content after
-    # @option options [Symbol] :force
+    # @param [Boolean] force
     #   insert content more than once
-    # @option options [Symbol] :verbose
-    #   log status
+    # @param [Boolean] verbose
+    #   when true log status
+    # @param [Symbol] color
+    #  the color name used in displaying this action
+    # @param [Boolean] noop
+    #  when true skip perfomring this action
     #
     # @example
     #   inject_into_file("Gemfile", "gem 'tty'", after: "gem 'rack'\n")
@@ -543,15 +618,12 @@ module TTY
     #   end
     #
     # @api public
-    def inject_into_file(relative_path, *args, **options, &block)
+    def inject_into_file(relative_path, *args, verbose: true, color: :green,
+                         after: nil, before: nil, force: true, noop: false, &block)
       check_path(relative_path)
       replacement = block_given? ? block[] : args.join
 
-      flag, match = if options.key?(:after)
-                      [:after, options.delete(:after)]
-                    else
-                      [:before, options.delete(:before)]
-                    end
+      flag, match = after ? [:after, after] : [:before, before]
 
       match = match.is_a?(Regexp) ? match : Regexp.escape(match)
       content = if flag == :after
@@ -560,10 +632,9 @@ module TTY
                   replacement + '\0'
                 end
 
-      log_status(:inject, relative_path, options.fetch(:verbose, true),
-                                         options.fetch(:color, :green))
-      replace_in_file(relative_path, /#{match}/, content,
-                      **options.merge(verbose: false))
+      log_status(:inject, relative_path, verbose: verbose, color: color)
+      replace_in_file(relative_path, /#{match}/, content, verbose: false,
+                      color: color, force: force, noop: noop)
     end
     module_function :inject_into_file
 
@@ -582,11 +653,14 @@ module TTY
     # when no substitutions were performed, true otherwise.
     #
     # @param [String, Pathname] relative_path
-    # @options [Hash[String]] options
-    # @option options [Symbol] :force
+    # @param [Boolean] force
     #   replace content even if present
-    # @option options [Symbol] :verbose
-    #   log status
+    # @param [Boolean] verbose
+    #   when true log status to stdout
+    # @param [Boolean] noop
+    #   when true skip executing this action
+    # @param [Symbol] color
+    #   the name of the color used for displaying action
     #
     # @example
     #   replace_in_file("Gemfile", /gem 'rails'/, "gem 'hanami'")
@@ -600,18 +674,18 @@ module TTY
     #   true when replaced content, false otherwise
     #
     # @api public
-    def replace_in_file(relative_path, *args, **options, &block)
+    def replace_in_file(relative_path, *args, verbose: true, color: :green,
+                        noop: false, force: true, &block)
       check_path(relative_path)
       contents = ::File.read(relative_path)
       replacement = (block ? block[] : args[1..-1].join).gsub('\0', "")
       match = Regexp.escape(replacement)
       status = nil
 
-      log_status(:replace, relative_path, options.fetch(:verbose, true),
-                                          options.fetch(:color, :green))
-      return false if options[:noop]
+      log_status(:replace, relative_path, verbose: verbose, color: color)
+      return false if noop
 
-      if options.fetch(:force, true) || !(contents =~ /^#{match}(\r?\n)*/m)
+      if force || !(contents =~ /^#{match}(\r?\n)*/m)
         status = contents.gsub!(*args, &block)
         if !status.nil?
           ::File.open(relative_path, "w") do |file|
@@ -629,29 +703,27 @@ module TTY
     # Remove a file or a directory at specified relative path.
     #
     # @param [String, Pathname] relative_path
-    # @param [Hash[:Symbol]] options
-    # @option options [Symbol] :noop
-    #   pretend removing file
-    # @option options [Symbol] :force
-    #   remove file ignoring errors
-    # @option options [Symbol] :verbose
-    #   log status
-    # @option options [Symbol] :secure
-    #   for secure removing
+    # @param [Boolean] noop
+    #   when true pretend to remove file
+    # @param [Boolean] force
+    #   when true remove file ignoring errors
+    # @param [Boolean] verbose
+    #   when true log status
+    # @param [Boolean] secure
+    #   when true check for secure removing
     #
     # @example
     #   remove_file "doc/README.md"
     #
     # @api public
-    def remove_file(relative_path, *args, **options)
+    def remove_file(relative_path, *args, verbose: true, color: :red, noop: false,
+                    force: nil, secure: true)
       relative_path = relative_path.to_s
-      log_status(:remove, relative_path, options.fetch(:verbose, true),
-                                         options.fetch(:color, :red))
+      log_status(:remove, relative_path, verbose: verbose, color: color)
 
-      return if options[:noop] || !::File.exist?(relative_path)
+      return if noop || !::File.exist?(relative_path)
 
-      ::FileUtils.rm_r(relative_path, force: options[:force],
-                       secure: options.fetch(:secure, true))
+      ::FileUtils.rm_r(relative_path, force: force, secure: secure)
     end
     module_function :remove_file
 
@@ -659,44 +731,44 @@ module TTY
     #
     # @param [String, Pathname] relative_path
     #   the relative path to a file
-    #
-    # @param [Integer] num_lines
+    # @param [Integer] lines
     #   the number of lines to return from file
+    # @param [Integer] chunk_size
+    #   the size of the chunk to read
     #
     # @example
     #   tail_file "filename"
     #   # =>  ["line 19", "line20", ... ]
     #
     # @example
-    #   tail_file "filename", 15
+    #   tail_file "filename", lines: 15
     #   # =>  ["line 19", "line20", ... ]
     #
     # @return [Array[String]]
     #
     # @api public
-    def tail_file(relative_path, num_lines = 10, **options, &block)
-      file       = ::File.open(relative_path)
-      chunk_size = options.fetch(:chunk_size, 512)
-      line_sep   = $/
-      lines      = []
+    def tail_file(relative_path, lines: 10, chunk_size: 512, &block)
+      file = ::File.open(relative_path)
+      line_sep = $/
+      output = []
       newline_count = 0
 
       ReadBackwardFile.new(file, chunk_size).each_chunk do |chunk|
         # look for newline index counting from right of chunk
         while (nl_index = chunk.rindex(line_sep, (nl_index || chunk.size) - 1))
           newline_count += 1
-          break if newline_count > num_lines || nl_index.zero?
+          break if newline_count > lines || nl_index.zero?
         end
 
-        if newline_count > num_lines
-          lines.insert(0, chunk[(nl_index + 1)..-1])
+        if newline_count > lines
+          output.insert(0, chunk[(nl_index + 1)..-1])
           break
         else
-          lines.insert(0, chunk)
+          output.insert(0, chunk)
         end
       end
 
-      lines.join.split(line_sep).each(&block).to_a
+      output.join.split(line_sep).each(&block).to_a
     end
     module_function :tail_file
 
@@ -741,7 +813,7 @@ module TTY
     # Log file operation
     #
     # @api private
-    def log_status(cmd, message, verbose, color = false)
+    def log_status(cmd, message, verbose: true, color: false)
       return unless verbose
 
       cmd = cmd.to_s.rjust(12)
@@ -773,7 +845,7 @@ module TTY
         tempfile << object
         tempfile.rewind
 
-        block[tempfile]
+        block[tempfile, ::File.basename(tempfile)]
 
         unless tempfile.nil?
           tempfile.close
@@ -782,5 +854,15 @@ module TTY
       end
     end
     private_module_function :open_tempfile_if_missing
+
+    # Check if IO is attached to a terminal
+    #
+    # return [Boolean]
+    #
+    # @api public
+    def tty?
+      @output.respond_to?(:tty?) && @output.tty?
+    end
+    private_module_function :tty?
   end # File
 end # TTY