11 | 12 | The ANSI project is a collection of ANSI escape code related libraries 13 | enabling ANSI code based colorization and stylization of output. 14 | It is very nice for beautifying shell output. 15 | 16 | This collection is based on a set of scripts spun-off from 17 | Ruby Facets. Included are Code (used to be ANSICode), Logger, 18 | ProgressBar and String. In addition the library includes 19 | Terminal which provides information about the current output 20 | device. 21 | 22 | 23 | ## Features 24 | 25 | * ANSI::Code provides ANSI codes as module functions. 26 | * String#ansi makes common usage very easy and elegant. 27 | * ANSI::Mixin provides an alternative mixin (like +colored+ gem). 28 | * Very Good coverage of standard ANSI codes. 29 | * Additional clases for colorized columns, tables, loggers and more. 30 | 31 | 32 | ## Synopsis 33 | 34 | There are a number of modules and classes provided by the ANSI 35 | package. To get a good understanding of them it is best to pursue 36 | the [QED documents](http://github.com/rubyworks/ansi/tree/master/qed/) 37 | or the [API documentation](http://rubyworks.github.com/ansi/api/index.html). 38 | 39 | At the heart of all the provided libraries lies the ANSI::Code module 40 | which defines ANSI codes as constants and methods. For example: 41 | 42 | require 'ansi/code' 43 | 44 | ANSI.red + "Hello" + ANSI.blue + "World" 45 | => "\e[31mHello\e[34mWorld" 46 | 47 | Or in block form. 48 | 49 | ANSI.red{ "Hello" } + ANSI.blue{ "World" } 50 | => "\e[31mHello\e[0m\e[34mWorld\e[0m" 51 | 52 | The methods defined by this module are used throughout the rest of 53 | the system. 54 | 55 | 56 | ## Installation 57 | 58 | ### Bundler 59 | 60 | Add the usual `gem` line to your project's `Gemfile`. 61 | 62 | gem 'ansi' 63 | 64 | And run then `bundle` command. 65 | 66 | ### RubyGems 67 | 68 | To install with RubyGems simply open a console and type: 69 | 70 | $ sudo gem install ansi 71 | 72 | ### Setup.rb (not recommended) 73 | 74 | Local installation requires Setup.rb (gem install setup), 75 | then [download](http://github.com/rubyworks/ansi/download) the tarball package and type: 76 | 77 | $ tar -xvzf ansi-1.0.0.tgz 78 | $ cd ansi-1.0.0 79 | $ sudo setup.rb all 80 | 81 | Windows users use 'ruby setup.rb all'. 82 | 83 | 84 | ## Release Notes 85 | 86 | Please see HISTORY.md file. 87 | 88 | 89 | ## License & Copyrights 90 | 91 | Copyright (c) 2009 Rubyworks 92 | 93 | This program is redistributable under the terms of the *FreeBSD* license. 94 | 95 | Some pieces of the code are copyrighted by others. 96 | 97 | See LICENSE.txt and NOTICE.md files for details. 98 | 99 | -------------------------------------------------------------------------------- /Rakefile: -------------------------------------------------------------------------------- 1 | #/usr/bin/env ruby 2 | 3 | task :default => [:demo] 4 | 5 | desc "run demos" 6 | task :demo do 7 | sh "bundle exec qed" 8 | end 9 | 10 | desc "run unit tests" 11 | task :test do 12 | sh "bundle exec rubytest" 13 | end 14 | 15 | -------------------------------------------------------------------------------- /ansi.gemspec: -------------------------------------------------------------------------------- 1 | # encoding: utf-8 2 | 3 | require 'yaml' 4 | require 'pathname' 5 | 6 | module Indexer 7 | 8 | # Convert index data into a gemspec. 9 | # 10 | # Notes: 11 | # * Assumes all executables are in bin/. 12 | # * Does not yet handle default_executable setting. 13 | # * Does not yet handle platform setting. 14 | # * Does not yet handle required_ruby_version. 15 | # * Support for rdoc entries is weak. 16 | # 17 | class GemspecExporter 18 | 19 | # File globs to include in package --unless a manifest file exists. 20 | FILES = ".index .yardopts alt bin data demo ext features lib man spec test try* [A-Z]*.*" unless defined?(FILES) 21 | 22 | # File globs to omit from FILES. 23 | OMIT = "Config.rb" unless defined?(OMIT) 24 | 25 | # Standard file patterns. 26 | PATTERNS = { 27 | :root => '{.index,Gemfile}', 28 | :bin => 'bin/*', 29 | :lib => 'lib/{**/}*', #.rb', 30 | :ext => 'ext/{**/}extconf.rb', 31 | :doc => '*.{txt,rdoc,md,markdown,tt,textile}', 32 | :test => '{test,spec}/{**/}*.rb' 33 | } unless defined?(PATTERNS) 34 | 35 | # For which revision of indexer spec is this converter intended? 36 | REVISION = 2013 unless defined?(REVISION) 37 | 38 | # 39 | def self.gemspec 40 | new.to_gemspec 41 | end 42 | 43 | # 44 | attr :metadata 45 | 46 | # 47 | def initialize(metadata=nil) 48 | @root_check = false 49 | 50 | if metadata 51 | root_dir = metadata.delete(:root) 52 | if root_dir 53 | @root = root_dir 54 | @root_check = true 55 | end 56 | metadata = nil if metadata.empty? 57 | end 58 | 59 | @metadata = metadata || YAML.load_file(root + '.index') 60 | 61 | if @metadata['revision'].to_i != REVISION 62 | warn "This gemspec exporter was not designed for this revision of index metadata." 63 | end 64 | end 65 | 66 | # 67 | def has_root? 68 | root ? true : false 69 | end 70 | 71 | # 72 | def root 73 | return @root if @root || @root_check 74 | @root_check = true 75 | @root = find_root 76 | end 77 | 78 | # 79 | def manifest 80 | return nil unless root 81 | @manifest ||= Dir.glob(root + 'manifest{,.txt}', File::FNM_CASEFOLD).first 82 | end 83 | 84 | # 85 | def scm 86 | return nil unless root 87 | @scm ||= %w{git hg}.find{ |m| (root + ".#{m}").directory? }.to_sym 88 | end 89 | 90 | # 91 | def files 92 | return [] unless root 93 | @files ||= \ 94 | if manifest 95 | File.readlines(manifest). 96 | map{ |line| line.strip }. 97 | reject{ |line| line.empty? || line[0,1] == '#' } 98 | else 99 | list = [] 100 | Dir.chdir(root) do 101 | FILES.split(/\s+/).each do |pattern| 102 | list.concat(glob(pattern)) 103 | end 104 | OMIT.split(/\s+/).each do |pattern| 105 | list = list - glob(pattern) 106 | end 107 | end 108 | list 109 | end.select{ |path| File.file?(path) }.uniq 110 | end 111 | 112 | # 113 | def glob_files(pattern) 114 | return [] unless root 115 | Dir.chdir(root) do 116 | Dir.glob(pattern).select do |path| 117 | File.file?(path) && files.include?(path) 118 | end 119 | end 120 | end 121 | 122 | def patterns 123 | PATTERNS 124 | end 125 | 126 | def executables 127 | @executables ||= \ 128 | glob_files(patterns[:bin]).map do |path| 129 | File.basename(path) 130 | end 131 | end 132 | 133 | def extensions 134 | @extensions ||= \ 135 | glob_files(patterns[:ext]).map do |path| 136 | File.basename(path) 137 | end 138 | end 139 | 140 | def name 141 | metadata['name'] || metadata['title'].downcase.gsub(/\W+/,'_') 142 | end 143 | 144 | def homepage 145 | page = ( 146 | metadata['resources'].find{ |r| r['type'] =~ /^home/i } || 147 | metadata['resources'].find{ |r| r['name'] =~ /^home/i } || 148 | metadata['resources'].find{ |r| r['name'] =~ /^web/i } 149 | ) 150 | page ? page['uri'] : false 151 | end 152 | 153 | def licenses 154 | metadata['copyrights'].map{ |c| c['license'] }.compact 155 | end 156 | 157 | def require_paths 158 | paths = metadata['paths'] || {} 159 | paths['load'] || ['lib'] 160 | end 161 | 162 | # 163 | # Convert to gemnspec. 164 | # 165 | def to_gemspec 166 | if has_root? 167 | Gem::Specification.new do |gemspec| 168 | to_gemspec_data(gemspec) 169 | to_gemspec_paths(gemspec) 170 | end 171 | else 172 | Gem::Specification.new do |gemspec| 173 | to_gemspec_data(gemspec) 174 | to_gemspec_paths(gemspec) 175 | end 176 | end 177 | end 178 | 179 | # 180 | # Convert pure data settings. 181 | # 182 | def to_gemspec_data(gemspec) 183 | gemspec.name = name 184 | gemspec.version = metadata['version'] 185 | gemspec.summary = metadata['summary'] 186 | gemspec.description = metadata['description'] 187 | 188 | metadata['authors'].each do |author| 189 | gemspec.authors << author['name'] 190 | 191 | if author.has_key?('email') 192 | if gemspec.email 193 | gemspec.email << author['email'] 194 | else 195 | gemspec.email = [author['email']] 196 | end 197 | end 198 | end 199 | 200 | gemspec.licenses = licenses 201 | 202 | requirements = metadata['requirements'] || [] 203 | requirements.each do |req| 204 | next if req['optional'] 205 | next if req['external'] 206 | 207 | name = req['name'] 208 | groups = req['groups'] || [] 209 | 210 | version = gemify_version(req['version']) 211 | 212 | if groups.empty? or groups.include?('runtime') 213 | # populate runtime dependencies 214 | if gemspec.respond_to?(:add_runtime_dependency) 215 | gemspec.add_runtime_dependency(name,*version) 216 | else 217 | gemspec.add_dependency(name,*version) 218 | end 219 | else 220 | # populate development dependencies 221 | if gemspec.respond_to?(:add_development_dependency) 222 | gemspec.add_development_dependency(name,*version) 223 | else 224 | gemspec.add_dependency(name,*version) 225 | end 226 | end 227 | end 228 | 229 | # convert external dependencies into gemspec requirements 230 | requirements.each do |req| 231 | next unless req['external'] 232 | gemspec.requirements << ("%s-%s" % req.values_at('name', 'version')) 233 | end 234 | 235 | gemspec.homepage = homepage 236 | gemspec.require_paths = require_paths 237 | gemspec.post_install_message = metadata['install_message'] 238 | end 239 | 240 | # 241 | # Set gemspec settings that require a root directory path. 242 | # 243 | def to_gemspec_paths(gemspec) 244 | gemspec.files = files 245 | gemspec.extensions = extensions 246 | gemspec.executables = executables 247 | 248 | if Gem::VERSION < '1.7.' 249 | gemspec.default_executable = gemspec.executables.first 250 | end 251 | 252 | gemspec.test_files = glob_files(patterns[:test]) 253 | 254 | unless gemspec.files.include?('.document') 255 | gemspec.extra_rdoc_files = glob_files(patterns[:doc]) 256 | end 257 | end 258 | 259 | # 260 | # Return a copy of this file. This is used to generate a local 261 | # .gemspec file that can automatically read the index file. 262 | # 263 | def self.source_code 264 | File.read(__FILE__) 265 | end 266 | 267 | private 268 | 269 | def find_root 270 | root_files = patterns[:root] 271 | if Dir.glob(root_files).first 272 | Pathname.new(Dir.pwd) 273 | elsif Dir.glob("../#{root_files}").first 274 | Pathname.new(Dir.pwd).parent 275 | else 276 | #raise "Can't find root of project containing `#{root_files}'." 277 | warn "Can't find root of project containing `#{root_files}'." 278 | nil 279 | end 280 | end 281 | 282 | def glob(pattern) 283 | if File.directory?(pattern) 284 | Dir.glob(File.join(pattern, '**', '*')) 285 | else 286 | Dir.glob(pattern) 287 | end 288 | end 289 | 290 | def gemify_version(version) 291 | case version 292 | when /^(.*?)\+$/ 293 | ">= #{$1}" 294 | when /^(.*?)\-$/ 295 | "< #{$1}" 296 | when /^(.*?)\~$/ 297 | "~> #{$1}" 298 | else 299 | version 300 | end 301 | end 302 | 303 | end 304 | 305 | end 306 | 307 | Indexer::GemspecExporter.gemspec -------------------------------------------------------------------------------- /demo/01_ansicode.md: -------------------------------------------------------------------------------- 1 | # ANSI::Code 2 | 3 | Require the library. 4 | 5 | require 'ansi/code' 6 | 7 | ANSI::Code can be used as a functions module. 8 | 9 | str = ANSI::Code.red + "Hello" + ANSI::Code.blue + "World" 10 | str.assert == "\e[31mHello\e[34mWorld" 11 | 12 | If a block is supplied to each method then yielded value will 13 | be wrapped in the ANSI code and clear code. 14 | 15 | str = ANSI::Code.red{ "Hello" } + ANSI::Code.blue{ "World" } 16 | str.assert == "\e[31mHello\e[0m\e[34mWorld\e[0m" 17 | 18 | More conveniently the ANSI::Code module extends ANSI itself. 19 | 20 | str = ANSI.red + "Hello" + ANSI.blue + "World" 21 | str.assert == "\e[31mHello\e[34mWorld" 22 | 23 | str = ANSI.red{ "Hello" } + ANSI.blue{ "World" } 24 | str.assert == "\e[31mHello\e[0m\e[34mWorld\e[0m" 25 | 26 | ANSI also supports XTerm 256 color mode using red, blue and green values 27 | with the `#rgb` method. 28 | 29 | str = ANSI::Code.rgb(0, 255, 0) 30 | str.assert == "\e[38;5;46m" 31 | 32 | Or using CSS style hex codes as well. 33 | 34 | str = ANSI::Code.rgb("#00FF00") 35 | str.assert == "\e[38;5;46m" 36 | 37 | Both of these methods can take blocks to wrap text in the color and clear codes. 38 | 39 | str = ANSI::Code.rgb("#00FF00"){ "Hello" } 40 | str.assert == "\e[38;5;46mHello\e[0m" 41 | 42 | In the appropriate context the ANSI::Code module can also be 43 | included, making its methods directly accessible. 44 | 45 | include ANSI::Code 46 | 47 | str = red + "Hello" + blue + "World" 48 | str.assert == "\e[31mHello\e[34mWorld" 49 | 50 | str = red{ "Hello" } + blue{ "World" } 51 | str.assert == "\e[31mHello\e[0m\e[34mWorld\e[0m" 52 | 53 | Along with the single font colors, the library include background colors. 54 | 55 | str = on_red + "Hello" 56 | str.assert == "\e[41mHello" 57 | 58 | As well as combined color methods. 59 | 60 | str = white_on_red + "Hello" 61 | str.assert == "\e[37m\e[41mHello" 62 | 63 | The ANSI::Code module supports most standard ANSI codes, though 64 | not all platforms support every code, so YMMV. 65 | 66 | -------------------------------------------------------------------------------- /demo/02_core.md: -------------------------------------------------------------------------------- 1 | # String Extensions 2 | 3 | In addition the library offers an extension to String class 4 | called #ansi, which allows some of the ANSI::Code methods 5 | to be called in a more object-oriented fashion. 6 | 7 | require 'ansi/core' 8 | 9 | str = "Hello".ansi(:red) + "World".ansi(:blue) 10 | str.assert == "\e[31mHello\e[0m\e[34mWorld\e[0m" 11 | 12 | -------------------------------------------------------------------------------- /demo/03_logger.md: -------------------------------------------------------------------------------- 1 | # ANSI::Logger 2 | 3 | Require the ANSI::Logger library. 4 | 5 | require 'ansi/logger' 6 | 7 | Create a new ANSI::Logger 8 | 9 | log = ANSI::Logger.new(STDOUT) 10 | 11 | Info logging appears normal. 12 | 13 | log.info{"Info logs are green.\n"} 14 | 15 | Warn logging appears yellow. 16 | 17 | log.warn{"Warn logs are yellow.\n"} 18 | 19 | Debug logging appears cyan. 20 | 21 | log.debug{"Debug logs are cyan.\n"} 22 | 23 | Error logging appears red. 24 | 25 | log.error{"Error logs are red.\n"} 26 | 27 | Fatal logging appears bright red. 28 | 29 | log.fatal{"Fatal logs are bold red!\n"} 30 | 31 | -------------------------------------------------------------------------------- /demo/04_progressbar.md: -------------------------------------------------------------------------------- 1 | # ANSI::Progressbar 2 | 3 | Pretty progress bars are easy to construct. 4 | 5 | require 'ansi/progressbar' 6 | 7 | pbar = ANSI::Progressbar.new("Test Bar", 100) 8 | 9 | Running the bar simply requires calling the #inc method during 10 | a loop and calling `#finish` when done. 11 | 12 | 100.times do |i| 13 | sleep 0.01 14 | pbar.inc 15 | end 16 | pbar.finish 17 | 18 | We will use this same rountine in all the examples below, so lets 19 | make a quick macro for it. Notice we have to use `#reset` first 20 | before reusing the same progress bar. 21 | 22 | def run(pbar) 23 | pbar.reset 24 | 100.times do |i| 25 | sleep 0.01 26 | pbar.inc 27 | end 28 | pbar.finish 29 | puts 30 | end 31 | 32 | The progress bar can be stylized in almost any way. 33 | The `#format` setter provides control over the parts 34 | that appear on the line. For example, by default the 35 | format is: 36 | 37 | pbar.format("%-14s %3d%% %s %s", :title, :percentage, :bar, :stat) 38 | 39 | So lets vary it up to demonstrate the case. 40 | 41 | pbar.format("%-14s %3d%% %s %s", :title, :percentage, :stat, :bar) 42 | run(pbar) 43 | 44 | The progress bar has an extra build in format intended for use with 45 | file downloads called `#transer_mode`. 46 | 47 | pbar.transfer_mode 48 | run(pbar) 49 | 50 | Calling this methods is the same as calling: 51 | 52 | pbar.format("%-14s %3d%% %s %s",:title, :percentage, :bar, :stat_for_file_transfer) 53 | run(pbar) 54 | 55 | The `#style` setter allows each part of the line be modified with ANSI codes. 56 | And the `#bar_mark` writer can be used to change the character used to make the bar. 57 | 58 | pbar.standard_mode 59 | pbar.style(:title => [:red], :bar=>[:blue]) 60 | pbar.bar_mark = "=" 61 | run(pbar) 62 | 63 | -------------------------------------------------------------------------------- /demo/05_mixin.md: -------------------------------------------------------------------------------- 1 | # ANSI::Mixin 2 | 3 | The ANSI::Mixin module is design for including into 4 | String-like classes. It will support any class that defines 5 | a #to_s method. 6 | 7 | require 'ansi/mixin' 8 | 9 | In this demonstration we will simply include it in the 10 | core String class. 11 | 12 | class ::String 13 | include ANSI::Mixin 14 | end 15 | 16 | Now all strings will have access to ANSI's style and color 17 | codes via simple method calls. 18 | 19 | "roses".red.assert == "\e[31mroses\e[0m" 20 | 21 | "violets".blue.assert == "\e[34mviolets\e[0m" 22 | 23 | "sugar".italic.assert == "\e[3msugar\e[0m" 24 | 25 | The method can be combined, of course. 26 | 27 | "you".italic.bold.assert == "\e[1m\e[3myou\e[0m\e[0m" 28 | 29 | The mixin also supports background methods. 30 | 31 | "envy".on_green.assert == "\e[42menvy\e[0m" 32 | 33 | And it also supports the combined foreground-on-background 34 | methods. 35 | 36 | "b&w".white_on_black.assert == "\e[37m\e[40mb&w\e[0m" 37 | 38 | -------------------------------------------------------------------------------- /demo/06_string.md: -------------------------------------------------------------------------------- 1 | # ANSI::String 2 | 3 | The ANSI::String class is a very sophisticated implementation 4 | of Ruby's standard String class, but one that can handle 5 | ANSI codes seamlessly. 6 | 7 | require 'ansi/string' 8 | 9 | flower1 = ANSI::String.new("Roses") 10 | flower2 = ANSI::String.new("Violets") 11 | 12 | Like any other string. 13 | 14 | flower1.to_s.assert == "Roses" 15 | flower2.to_s.assert == "Violets" 16 | 17 | Bet now we can add color. 18 | 19 | flower1.red! 20 | flower2.blue! 21 | 22 | flower1.to_s.assert == "\e[31mRoses\e[0m" 23 | flower2.to_s.assert == "\e[34mViolets\e[0m" 24 | 25 | Despite that the string representation now contains ANSI codes, 26 | we can still manipulate the string in much the same way that 27 | we manipulate an ordinary string. 28 | 29 | flower1.size.assert == 5 30 | flower2.size.assert == 7 31 | 32 | Like ordinary strings we can concatenate the two strings 33 | 34 | flowers = flower1 + ' ' + flower2 35 | flowers.to_s.assert == "\e[31mRoses\e[0m \e[34mViolets\e[0m" 36 | 37 | flowers.size.assert == 13 38 | 39 | Standard case conversion such as #upcase and #downcase work. 40 | 41 | flower1.upcase.to_s.assert == "\e[31mROSES\e[0m" 42 | flower1.downcase.to_s.assert == "\e[31mroses\e[0m" 43 | 44 | Some of the most difficult methods to re-implement were the 45 | substitution methods such as #sub and #gsub. They are still 46 | somewhat more limited than the original string methods, but 47 | their primary functionality should work. 48 | 49 | flower1.gsub('s', 'z').to_s.assert == "\e[31mRozez\e[0m" 50 | 51 | There are still a number of methods that need implementation. 52 | ANSI::String is currently a very partial implementation. But 53 | as you can see from the methods it does currently support, 54 | is it already useful. 55 | 56 | 57 | -------------------------------------------------------------------------------- /demo/07_columns.md: -------------------------------------------------------------------------------- 1 | # ANSI::Columns 2 | 3 | The +Columns+ class makes it easy to create nice looking text columns, 4 | sorted from top to bottom, right to left (as opposed to the other way 5 | around). 6 | 7 | require 'ansi/columns' 8 | 9 | list = %w{a b c d e f g h i j k l} 10 | 11 | columns = ANSI::Columns.new(list) 12 | 13 | columns.to_s(4) 14 | 15 | The output will be: 16 | 17 | a d g j 18 | b e h k 19 | c f i l 20 | 21 | Besides an array of elements, Columns.new can take a string in which 22 | the elements are divided by newlines characters. The default column 23 | size can also be given to the initializer. 24 | 25 | list = "a\nb\nc\nd\ne\nf\ng\nh\ni\nj\nk\nl" 26 | 27 | columns = ANSI::Columns.new(list, :columns=>6) 28 | 29 | columns.to_s 30 | 31 | The output will be: 32 | 33 | a c e g i k 34 | b d f h j l 35 | 36 | If the column count is +nil+, then the number of columns will be calculated 37 | as a best fit for the current terminal window. 38 | 39 | ## Padding 40 | 41 | Columns can adjust the padding between cells. 42 | 43 | list = %w{a b c d e f g h i j k l} 44 | 45 | columns = ANSI::Columns.new(list, :padding=>2) 46 | 47 | columns.to_s(4) 48 | 49 | The output will be: 50 | 51 | a d g j 52 | b e h k 53 | c f i l 54 | 55 | ## Alignment 56 | 57 | Columns can also be aligned either left or right. 58 | 59 | list = %w{xx xx xx yy y yy z zz z} 60 | 61 | columns = ANSI::Columns.new(list, :align=>:right) 62 | 63 | columns.to_s(3) 64 | 65 | The output will be: 66 | 67 | xx yy z 68 | xx y zz 69 | xx yy z 70 | 71 | ## Format 72 | 73 | Lastly, columns can be augmented with ANSI codes. This is done through 74 | a formatting block. The block can take up to three parameters, the cell 75 | content, the column and row numbers, or the cell and the column and row 76 | numbers. 77 | 78 | list = %w{a b c d e f g h i j k l} 79 | 80 | columns = ANSI::Columns.new(list){ |c,r| r % 2 == 0 ? :red : :blue } 81 | 82 | out = columns.to_s(4) 83 | 84 | out.assert == ( 85 | "\e[31ma \e[0m\e[31md \e[0m\e[31mg \e[0m\e[31mj \e[0m\n" + 86 | "\e[34mb \e[0m\e[34me \e[0m\e[34mh \e[0m\e[34mk \e[0m\n" + 87 | "\e[31mc \e[0m\e[31mf \e[0m\e[31mi \e[0m\e[31ml \e[0m\n" 88 | ) 89 | 90 | -------------------------------------------------------------------------------- /demo/08_table.md: -------------------------------------------------------------------------------- 1 | # ANSI::Table 2 | 3 | The ANSI::Table class can be used to output tabular data with nicely 4 | formated ASCII cell borders. 5 | 6 | require 'ansi/table' 7 | 8 | The constructor takes an 2-dimensional array. 9 | 10 | data = [ 11 | [ 10, 20, 30 ], 12 | [ 20, 10, 20 ], 13 | [ 50, 40, 20 ] 14 | ] 15 | 16 | table = ANSI::Table.new(data) 17 | 18 | table.to_s 19 | 20 | The output will be: 21 | 22 | +----+----+----+ 23 | | 10 | 20 | 30 | 24 | | 20 | 10 | 20 | 25 | | 50 | 40 | 20 | 26 | +----+----+----+ 27 | 28 | 29 | -------------------------------------------------------------------------------- /demo/09_diff.md: -------------------------------------------------------------------------------- 1 | # ANSI::Diff 2 | 3 | require 'ansi/diff' 4 | 5 | a = 'abcYefg' 6 | b = 'abcXefg' 7 | 8 | diff = ANSI::Diff.new(a,b) 9 | 10 | diff.to_s.assert == "\e[31mabc\e[0m\e[33mYefg\e[0m\n\e[31mabc\e[0mXefg" 11 | 12 | Try another. 13 | 14 | a = 'abc' 15 | b = 'abcdef' 16 | 17 | diff = ANSI::Diff.new(a,b) 18 | 19 | diff.to_s.assert == "\e[31mabc\e[0m\n\e[31mabc\e[0mdef" 20 | 21 | And another. 22 | 23 | a = 'abcXXXghi' 24 | b = 'abcdefghi' 25 | 26 | diff = ANSI::Diff.new(a,b) 27 | 28 | diff.to_s.assert == "\e[31mabc\e[0m\e[33mXXXghi\e[0m\n\e[31mabc\e[0mdefghi" 29 | 30 | And another. 31 | 32 | a = 'abcXXXdefghi' 33 | b = 'abcdefghi' 34 | 35 | diff = ANSI::Diff.new(a,b) 36 | 37 | diff.to_s.assert == "\e[31mabc\e[0m\e[33mXXX\e[0m\e[35mdefghi\e[0m\n\e[31mabc\e[0m\e[35mdefghi\e[0m" 38 | 39 | Comparison that is mostly different. 40 | 41 | a = 'abcpppz123' 42 | b = 'abcxyzzz43' 43 | 44 | diff = ANSI::Diff.new(a,b) 45 | 46 | diff.to_s.assert == "\e[31mabc\e[0m\e[33mpppz123\e[0m\n\e[31mabc\e[0mxyzzz43" 47 | 48 | -------------------------------------------------------------------------------- /demo/10_bbcode.md: -------------------------------------------------------------------------------- 1 | # ANSI::BBCode 2 | 3 | The BBCode module provides methods for converting between 4 | BBCodes, basic HTML and ANSI codes. 5 | 6 | require 'ansi/bbcode' 7 | 8 | BBCodes are color and style codes in square brackets, quite 9 | popular with on line forums. 10 | 11 | bbcode = "this is [COLOR=red]red[/COLOR], this is [B]bold[/B]" 12 | 13 | We can convert this to ANSI code simply enough: 14 | 15 | ansi = ANSI::BBCode.bbcode_to_ansi(bbcode) 16 | 17 | ansi.assert == "this is \e[0;31mred\e[0m, this is \e[1mbold\e[0m\n" 18 | 19 | In addition the BBCode module supports conversion to simple HTML. 20 | 21 | html = ANSI::BBCode.bbcode_to_html(bbcode) 22 | 23 | html.assert == "this is red, this is bold
\n" 24 | 25 | -------------------------------------------------------------------------------- /demo/11_terminal.md: -------------------------------------------------------------------------------- 1 | # ANSI::Terminal 2 | 3 | We should be ables to get the terminal width via the `terminal_width` method. 4 | 5 | width = ANSI::Terminal.terminal_width 6 | 7 | Fixnum.assert === width 8 | 9 | -------------------------------------------------------------------------------- /demo/applique/ae.rb: -------------------------------------------------------------------------------- 1 | require 'ae' 2 | -------------------------------------------------------------------------------- /demo/applique/output.rb: -------------------------------------------------------------------------------- 1 | When "output will be" do |text| 2 | # how to get result of last block? 3 | @_.strip.assert == text.strip 4 | end 5 | 6 | -------------------------------------------------------------------------------- /etc/qed.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | QED.configure 'cov' do 4 | require 'simplecov' 5 | SimpleCov.command_name 'qed' 6 | SimpleCov.start do 7 | add_filter '/demo/' 8 | coverage_dir 'log/coverage' 9 | #add_group "Label", "lib/qed/directory" 10 | end 11 | end 12 | 13 | -------------------------------------------------------------------------------- /lib/ansi.rb: -------------------------------------------------------------------------------- 1 | # ANSI namespace module contains all the ANSI related classes. 2 | module ANSI 3 | end 4 | 5 | require 'ansi/version' 6 | require 'ansi/core' 7 | require 'ansi/code' 8 | require 'ansi/bbcode' 9 | require 'ansi/columns' 10 | require 'ansi/diff' 11 | require 'ansi/logger' 12 | require 'ansi/mixin' 13 | require 'ansi/progressbar' 14 | require 'ansi/string' 15 | require 'ansi/table' 16 | require 'ansi/terminal' 17 | 18 | # Kernel method 19 | def ansi(string, *codes) 20 | ANSI::Code.ansi(string, *codes) 21 | end 22 | 23 | -------------------------------------------------------------------------------- /lib/ansi.yml: -------------------------------------------------------------------------------- 1 | ../.index -------------------------------------------------------------------------------- /lib/ansi/bbcode.rb: -------------------------------------------------------------------------------- 1 | # BBCode 2 | # 3 | # Copyright (c) 2002 Thomas-Ivo Heinen 4 | # 5 | # This module is free software. You may use, modify, and/or redistribute this 6 | # software under the same terms as Ruby. 7 | # 8 | # This program is distributed in the hope that it will be useful, but WITHOUT 9 | # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 10 | # FOR A PARTICULAR PURPOSE. 11 | 12 | # 13 | module ANSI 14 | 15 | # TODO: Integrate BBCode with Code module. 16 | 17 | # The BBCode module helps ease the separation of core and frontend with the 18 | # core (or submodules) being still able to say, what colors shall be used 19 | # in it's responses. This is achieved by encoding formatting information 20 | # using the BBCode tokens. This enables you to "pipe" layout information 21 | # such as colors, style, font, size and alignment through the core to 22 | # the frontend. 23 | # 24 | # Additionally it converts markups/codes between ANSI, HTML and BBCode 25 | # almost freely ;) 26 | # 27 | # # Converting a bbcode string to ANSI and XHTML 28 | # str = "this is [COLOR=red]red[/COLOR], this is [B]bold[/B]" 29 | # print( BBCode.bbcode_to_ansi(str) ) 30 | # print( BBCode.bbcode_to_html(str) ) 31 | # 32 | module BBCode 33 | 34 | ## ANSIname => ANSIcode LUT 35 | ANSINAME2CODE= { "reset" => "\e[0m", "bold" => "\e[1m", 36 | "underline" => "\e[4m", "blink" => "\e[5m", 37 | "reverse" => "\e[7m", "invisible" => "\e[8m", 38 | "black" => "\e[0;30m", "darkgrey" => "\e[1;30m", 39 | "red" => "\e[0;31m", "lightred" => "\e[1;31m", 40 | "green" => "\e[0;32m", "lightgreen" => "\e[1;32m", 41 | "brown" => "\e[0;33m", "yellow" => "\e[1;33m", 42 | "blue" => "\e[0;34m", "lightblue" => "\e[1;34m", 43 | "purple" => "\e[0;35m", "magenta" => "\e[1;35m", 44 | "cyan" => "\e[1;36m", "lightcyan" => "\e[1;36m", 45 | "grey" => "\e[0;37m", "white" => "\e[1;37m", 46 | "bgblack" => "\e[40m", "bgred" => "\e[41m", 47 | "bggreen" => "\e[42m", "bgyellow" => "\e[43m", 48 | "bgblue" => "\e[44m", "bgmagenta" => "\e[45m", 49 | "bgcyan" => "\e[46m", "bgwhite" => "\e[47m" 50 | } 51 | 52 | ## BBColor => ANSIname LUT 53 | BBCOLOR2ANSI = { "skyblue" => "blue", "royalblue" => "blue", 54 | "blue" => "blue", "darkblue" => "blue", 55 | "orange" => "red", "orangered" => "red", 56 | "crimson" => "red", "red" => "lightred", 57 | "firebrick" => "red", "darkred" => "red", 58 | "green" => "green", "limegreen" => "green", 59 | "seagreen" => "green", "darkgreen" => "green", 60 | "deeppink" => "magenta", "tomato" => "red", 61 | "coral" => "cyan", "purple" => "purple", 62 | "indigo" => "blue", "burlywood" => "red", 63 | "sandybrown"=> "red", "sierra" => "sierra", 64 | "chocolate" => "brown", "teal" => "teal", 65 | "silver" => "white", 66 | "black" => "black", "yellow" => "yellow", 67 | "magenta" => "magenta", "cyan" => "cyan", 68 | "white" => "white" 69 | } 70 | 71 | ## ANSInames => BBCode LUT 72 | ANSINAME2BBCODE = { "bold" => "B", "underline" => "U", "reverse" => "I", 73 | 74 | "red" => "COLOR=red", "blue" => "COLOR=blue", 75 | "green" => "COLOR=green", "cyan" => "COLOR=cyan", 76 | "magenta"=> "COLOR=deeppink", "purple" => "COLOR=purple", 77 | "black" => "COLOR=black", "white" => "COLOR=white", 78 | "yellow" => "COLOR=yellow", "brown" => "COLOR=chocolate" 79 | } 80 | 81 | ## Needed for alignments 82 | @@width = 80 83 | 84 | 85 | # --------------------------- 86 | 87 | # Returns the ANSI sequence for given color, if existant 88 | def BBCode.ansi(colorname) 89 | colorname.strip! 90 | return ANSINAME2CODE[ colorname.downcase ] 91 | end 92 | 93 | # --- strip_bbcode( string ) 94 | # Will strip any BBCode tags from the given string. 95 | def BBCode.strip_bbcode(string) 96 | string.strip! 97 | return string.gsub(/\[[A-Za-z0-9\/=]+\]/, "") 98 | end 99 | 100 | # Returns the string with all ansi escape sequences converted to BBCodes 101 | def BBCode.ansi_to_bbcode(string) 102 | return "" if string.nil? || string.to_s.strip.empty? 103 | result = "" 104 | tagstack = [] 105 | 106 | ## Iterate over input lines 107 | string.split("\n").each do |line| 108 | ## Iterate over found ansi sequences 109 | line.scan(/\e\[[0-9;]+m/).each do |seq| 110 | ansiname = ANSINAME2CODE.invert["#{seq}"] 111 | 112 | ## Pop last tag and form closing tag 113 | if ansiname == "reset" 114 | lasttag = tagstack.pop 115 | bbname = "/" + String.new( lasttag.split("=")[0] ) 116 | 117 | ## Get corresponding BBCode tag + Push to stack 118 | else 119 | bbname = ANSINAME2BBCODE[ansiname] 120 | tagstack.push(bbname) 121 | end 122 | 123 | ## Replace ansi sequence by BBCode tag 124 | replace = sprintf("[%s]", bbname) 125 | line.sub!(seq, replace) 126 | end 127 | 128 | ## Append converted line 129 | result << sprintf("%s\n", line) 130 | end 131 | 132 | 133 | ## Some tags are unclosed 134 | while !tagstack.empty? 135 | result << sprintf("[/%s]", String.new(tagstack.pop.split("=")[0]) ) 136 | end 137 | 138 | return result 139 | end 140 | 141 | # Converts a BBCode string to one with ANSI sequences. 142 | # Returns the string with all formatting instructions in BBCodes converted 143 | # to ANSI code sequences / aligned with spaces to specified width. 144 | def BBCode.bbcode_to_ansi(string, usecolors = true) 145 | return "" if string.nil? || string.to_s.strip.empty? 146 | result = "" 147 | 148 | return BBCode.strip_bbcode(string) if !usecolors 149 | 150 | ## Iterate over lines 151 | string.split("\n").each do |line| 152 | 153 | ## TODO: stacking? other styles! 154 | ANSINAME2BBCODE.each do |key,val| 155 | line.gsub!(/\[#{val}\]/, ANSINAME2CODE[key]) 156 | line.gsub!(/\[\/#{val}\]/, ANSINAME2CODE["reset"]) 157 | end 158 | 159 | ## Fonttypes and sizes not available 160 | line.gsub!(/\[SIZE=\d\]/, "") 161 | line.gsub!(/\[\/SIZE\]/, "") 162 | line.gsub!(/\[FONT=[^\]]*\]/, "") 163 | line.gsub!(/\[\/FONT\]/, "") 164 | 165 | ## Color-mapping 166 | colors = line.scan(/\[COLOR=(.*?)\]/i) 167 | colors = colors.collect{|s| s[0].to_s} if !colors.nil? 168 | colors.each do |col| 169 | name = BBCOLOR2ANSI[col.downcase] 170 | name = BBCOLOR2ANSI["white"] if name.nil? 171 | code = ANSINAME2CODE[name] 172 | 173 | line.gsub!(/\[COLOR=#{col}\]/i, code) 174 | end 175 | line.gsub!(/\[\/COLOR\]/, ANSINAME2CODE["reset"]) 176 | 177 | ## TODO: Alignment 178 | ## TODO: IMGs 179 | ## TODO: EMAILs 180 | ## TODO: URLs 181 | ## TODO: QUOTEs 182 | ## TODO: LISTs 183 | 184 | result << sprintf("%s\n", line) 185 | end 186 | 187 | return result 188 | end 189 | 190 | # Converts a HTML string into one with BBCode markup (TODO) 191 | # Returns the (X)HTML markup string as BBCode 192 | def BBCode.html_to_bbcode(string) 193 | return "" if string.nil? || string.to_s.strip.empty? 194 | result = "" 195 | 196 | ## Iterate over lines 197 | string.split(/
/i).each do |line| 198 | styles = { "strong" => "b", "b" => "b", 199 | "em" => "i", "i" => "i", 200 | "u" => "u" } 201 | 202 | ## preserve B, I, U 203 | styles.each do |html,code| 204 | line.gsub!(/<#{html}>/i, "[#{code.upcase}]") 205 | line.gsub!(/<\/#{html}>/i, "[/#{code.upcase}]") 206 | end 207 | 208 | ## TODO: COLORs 209 | ## TODO: SIZEs 210 | ## TODO: FONTs 211 | 212 | ## EMAIL 213 | line.gsub!(/.*?<\/a>/i, "[EMAIL]\\1[/EMAIL]") 214 | 215 | ## URL 216 | line.gsub!(/(.*?)<\/a>/i, "[URL=\\1]\\2[/URL]") 217 | 218 | ## Other refs + closing tags => throw away 219 | line.gsub!(//i, "") 220 | line.gsub!(/<\/a>/i, "") 221 | 222 | ## IMG 223 | #line.gsub!(/
- /i, "\n[LIST]\n")
236 | line.gsub!(/<\/ul>/i, "\n[/LIST]\n")
237 | line.gsub!(/
- */i, "\n[*] ")
238 |
239 | ## Unkown tags => throw away
240 | line.gsub!(/<.*? *\/?>/, "")
241 |
242 | result << sprintf("%s
\n", line) 243 | end 244 | 245 | return result.gsub!(/
/i, "\n") 246 | end 247 | 248 | # Converts a BBCode string to one with HTML markup. 249 | # Returns the string with all formatting instructions in 250 | # BBCodes converted to XHTML markups. 251 | def BBCode.bbcode_to_html(string) 252 | return "" if string.nil? || string.to_s.strip.empty? 253 | result = "" 254 | quote = 0 255 | 256 | ## Iterate over lines 257 | string.split("\n").each do |line| 258 | styles = { "b" => "strong", "i" => "em", "u" => "u" } 259 | 260 | ## preserve B, I, U 261 | styles.each do |code,html| 262 | line.gsub!(/\[#{code}\]/i, "<#{html}>") 263 | line.gsub!(/\[\/#{code}\]/i, "") 264 | end 265 | 266 | ## COLOR => font color=... (TODO: should be numeric!) 267 | line.gsub!(/\[COLOR=(.*?)\]/i, "") 268 | line.gsub!(/\[\/COLOR\]/i, "") 269 | 270 | ## SIZE => font size=... 271 | line.gsub!(/\[SIZE=(.*?)\]/i, "") 272 | line.gsub!(/\[\/SIZE\]/i, "") 273 | 274 | ## URL 275 | line.gsub!(/\[URL\]([^\[]+?)\[\/URL\]/i, "\\1") 276 | line.gsub!(/\[URL=(.*?)\](.+?)\[\/URL\]/i, "\\2") 277 | 278 | ## IMG 279 | line.gsub!(/\[IMG=(.*?)\]/i, "") 280 | 281 | ## ALIGN=center (TODO: right, left) 282 | line.gsub!(/\[ALIGN=center\]/i, "
") 283 | line.gsub!(/\[ALIGN=right\]/i, " ") 284 | line.gsub!(/\[ALIGN=left\]/i, " ") 285 | line.gsub!(/\[\/ALIGN\]/i, " ") 286 | 287 | ## QUOTE 288 | quote+=1 if line =~ /\[QUOTE\]/i 289 | quote-=1 if (line =~ /\[\/QUOTE\]/i) && (quote > -1) 290 | line.gsub!(/\[QUOTE\]/i, "\n") 291 | line.gsub!(/\[\/QUOTE\]/i, "
\n") 292 | line.gsub!(/^/, ">"*quote) if quote > 0 293 | 294 | ## EMAIL 295 | line.gsub!(/\[EMAIL\](.*?)\[\/EMAIL\]/i, "\\1") 296 | 297 | ## LIST (TODO: LIST=1, LIST=A) 298 | line.gsub!(/\[LIST(?:=(.*?))?\]/i, "\n- \n")
299 | line.gsub!(/\[\/LIST\]/i, "\n
\n", line) 306 | end 307 | 308 | return result 309 | end 310 | 311 | 312 | # -- Transitive methods --------------- 313 | 314 | # Converts an ANSI string to one with HTML markup. 315 | # Returns the string with ANSI code sequences converted to XHTML markup. 316 | def BBCode.ansi_to_html(string) 317 | bbcoded = BBCode.ansi_to_bbcode(string ) 318 | htmled = BBCode.bbcode_to_html(bbcoded) 319 | 320 | return htmled 321 | end 322 | 323 | # Returns the (X)HTML markup code as ANSI sequences 324 | def BBCode.html_to_ansi(string) 325 | bbcoded = BBCode.html_to_bbcode(string ) 326 | ansied = BBCode.bbcode_to_ansi(bbcoded) 327 | 328 | return ansied 329 | end 330 | 331 | end #module BBCode 332 | 333 | end 334 | 335 | -------------------------------------------------------------------------------- /lib/ansi/chain.rb: -------------------------------------------------------------------------------- 1 | require 'ansi/code' 2 | 3 | module ANSI 4 | 5 | # ANSI::Chain was inspired by Kazuyoshi Tlacaelel's Isna library. 6 | # 7 | class Chain 8 | 9 | # 10 | def initialize(string) 11 | @string = string.to_s 12 | @codes = [] 13 | end 14 | 15 | # 16 | attr :string 17 | 18 | # 19 | attr :codes 20 | 21 | # 22 | def method_missing(s, *a, &b) 23 | if ANSI::CHART.key?(s) 24 | @codes << s 25 | self 26 | else 27 | super(s, *a, &b) 28 | end 29 | end 30 | 31 | # 32 | def to_s 33 | if codes.empty? 34 | result = @string 35 | else 36 | result = Code.ansi(@string, *codes) 37 | codes.clear 38 | end 39 | result 40 | end 41 | 42 | # 43 | def to_str 44 | to_s 45 | end 46 | 47 | end 48 | 49 | end 50 | 51 | -------------------------------------------------------------------------------- /lib/ansi/chart.rb: -------------------------------------------------------------------------------- 1 | module ANSI 2 | 3 | # Table of codes used throughout the system. 4 | # 5 | # @see http://en.wikipedia.org/wiki/ANSI_escape_code 6 | CHART = { 7 | :clear => 0, 8 | :reset => 0, 9 | :bright => 1, 10 | :bold => 1, 11 | :faint => 2, 12 | :dark => 2, 13 | :italic => 3, 14 | :underline => 4, 15 | :underscore => 4, 16 | :blink => 5, 17 | :slow_blink => 5, 18 | :rapid => 6, 19 | :rapid_blink => 6, 20 | :invert => 7, 21 | :inverse => 7, 22 | :reverse => 7, 23 | :negative => 7, 24 | :swap => 7, 25 | :conceal => 8, 26 | :concealed => 8, 27 | :hide => 9, 28 | :strike => 9, 29 | 30 | :default_font => 10, 31 | :font_default => 10, 32 | :font0 => 10, 33 | :font1 => 11, 34 | :font2 => 12, 35 | :font3 => 13, 36 | :font4 => 14, 37 | :font5 => 15, 38 | :font6 => 16, 39 | :font7 => 17, 40 | :font8 => 18, 41 | :font9 => 19, 42 | :fraktur => 20, 43 | :bright_off => 21, 44 | :bold_off => 21, 45 | :double_underline => 21, 46 | :clean => 22, 47 | :italic_off => 23, 48 | :fraktur_off => 23, 49 | :underline_off => 24, 50 | :blink_off => 25, 51 | :inverse_off => 26, 52 | :positive => 26, 53 | :conceal_off => 27, 54 | :show => 27, 55 | :reveal => 27, 56 | :crossed_off => 29, 57 | :crossed_out_off => 29, 58 | 59 | :black => 30, 60 | :red => 31, 61 | :green => 32, 62 | :yellow => 33, 63 | :blue => 34, 64 | :magenta => 35, 65 | :cyan => 36, 66 | :white => 37, 67 | 68 | :on_black => 40, 69 | :on_red => 41, 70 | :on_green => 42, 71 | :on_yellow => 43, 72 | :on_blue => 44, 73 | :on_magenta => 45, 74 | :on_cyan => 46, 75 | :on_white => 47, 76 | 77 | :frame => 51, 78 | :encircle => 52, 79 | :overline => 53, 80 | :frame_off => 54, 81 | :encircle_off => 54, 82 | :overline_off => 55, 83 | } 84 | 85 | # 86 | SPECIAL_CHART = { 87 | :save => "\e[s", # Save current cursor positon. 88 | :restore => "\e[u", # Restore saved cursor positon. 89 | :clear_eol => "\e[K", # Clear to the end of the current line. 90 | :clr => "\e[K", # Clear to the end of the current line. 91 | :clear_right => "\e[0K", # Clear to the end of the current line. 92 | :clear_left => "\e[1K", # Clear to the start of the current line. 93 | :clear_line => "\e[2K", # Clear the entire current line. 94 | :clear_screen => "\e[2J", # Clear the screen and move cursor to home. 95 | :cls => "\e[2J", # Clear the screen and move cursor to home. 96 | :cursor_hide => "\e[?25l", # Hide the cursor. 97 | :cursor_show => "\e[?25h" # Show the cursor. 98 | } 99 | 100 | end 101 | -------------------------------------------------------------------------------- /lib/ansi/code.rb: -------------------------------------------------------------------------------- 1 | module ANSI 2 | 3 | # Global variable can be used to prevent ANSI codes 4 | # from being used in ANSI's methods that do so to string. 5 | # 6 | # NOTE: This has no effect on methods that return ANSI codes. 7 | $ansi = true 8 | 9 | if RUBY_PLATFORM =~ /(win32|w32)/ 10 | begin 11 | require 'Win32/Console/ANSI' 12 | rescue LoadError 13 | warn "ansi: 'gem install win32console' to use color on Windows" 14 | $ansi = false 15 | end 16 | end 17 | 18 | require 'ansi/constants' 19 | 20 | # TODO: up, down, right, left, etc could have yielding methods too? 21 | 22 | # ANSI Codes 23 | # 24 | # Ansi::Code module makes it very easy to use ANSI codes. 25 | # These are especially nice for beautifying shell output. 26 | # 27 | # Ansi::Code.red + "Hello" + Ansi::Code.blue + "World" 28 | # => "\e[31mHello\e[34mWorld" 29 | # 30 | # Ansi::Code.red{ "Hello" } + Ansi::Code.blue{ "World" } 31 | # => "\e[31mHello\e[0m\e[34mWorld\e[0m" 32 | # 33 | # IMPORTANT! Do not mixin Ansi::Code, instead use {ANSI::Mixin}. 34 | # 35 | # See {ANSI::CHART} for list of all supported codes. 36 | # 37 | module Code 38 | extend self 39 | 40 | # include ANSI Constants 41 | include Constants 42 | 43 | # Regexp for matching most ANSI codes. 44 | PATTERN = /\e\[(\d+)m/ 45 | 46 | # ANSI clear code. 47 | ENDCODE = "\e[0m" 48 | 49 | # List of primary styles. 50 | def self.styles 51 | %w{bold dark italic underline underscore blink rapid reverse negative concealed strike} 52 | end 53 | 54 | # List of primary colors. 55 | def self.colors 56 | %w{black red green yellow blue magenta cyan white} 57 | end 58 | 59 | # Return ANSI code given a list of symbolic names. 60 | def [](*codes) 61 | code(*codes) 62 | end 63 | 64 | # Dynamically create color on color methods. 65 | # 66 | # @deprecated 67 | # 68 | colors.each do |color| 69 | colors.each do |on_color| 70 | module_eval <<-END, __FILE__, __LINE__ 71 | def #{color}_on_#{on_color}(string=nil) 72 | if string 73 | return string unless $ansi 74 | #warn "use ANSI block notation for future versions" 75 | return #{color.upcase} + ON_#{color.upcase} + string + ENDCODE 76 | end 77 | if block_given? 78 | return yield unless $ansi 79 | #{color.upcase} + ON_#{on_color.upcase} + yield.to_s + ENDCODE 80 | else 81 | #{color.upcase} + ON_#{on_color.upcase} 82 | end 83 | end 84 | END 85 | end 86 | end 87 | 88 | # Use method missing to dispatch ANSI code methods. 89 | def method_missing(code, *args, &blk) 90 | esc = nil 91 | 92 | if CHART.key?(code) 93 | esc = "\e[#{CHART[code]}m" 94 | elsif SPECIAL_CHART.key?(code) 95 | esc = SPECIAL_CHART[code] 96 | end 97 | 98 | if esc 99 | if string = args.first 100 | return string unless $ansi 101 | #warn "use ANSI block notation for future versions" 102 | return "#{esc}#{string}#{ENDCODE}" 103 | end 104 | if block_given? 105 | return yield unless $ansi 106 | return "#{esc}#{yield}#{ENDCODE}" 107 | end 108 | esc 109 | else 110 | super(code, *args, &blk) 111 | end 112 | end 113 | 114 | # TODO: How to deal with position codes when $ansi is false? 115 | # Should we raise an error or just not push the codes? 116 | # For now, we will leave this it as is. 117 | 118 | # Like +move+ but returns to original position after 119 | # yielding the block. 120 | def display(line, column=0) #:yield: 121 | result = "\e[s" 122 | result << "\e[#{line.to_i};#{column.to_i}H" 123 | if block_given? 124 | result << yield 125 | result << "\e[u" 126 | #elsif string 127 | # result << string 128 | # result << "\e[u" 129 | end 130 | result 131 | end 132 | 133 | # Move cursor to line and column. 134 | def move(line, column=0) 135 | "\e[#{line.to_i};#{column.to_i}H" 136 | end 137 | 138 | # Move cursor up a specified number of spaces. 139 | def up(spaces=1) 140 | "\e[#{spaces.to_i}A" 141 | end 142 | 143 | # Move cursor down a specified number of spaces. 144 | def down(spaces=1) 145 | "\e[#{spaces.to_i}B" 146 | end 147 | 148 | # Move cursor left a specified number of spaces. 149 | def left(spaces=1) 150 | "\e[#{spaces.to_i}D" 151 | end 152 | alias :back :left 153 | 154 | # Move cursor right a specified number of spaces. 155 | def right(spaces=1) 156 | "\e[#{spaces.to_i}C" 157 | end 158 | alias :forward :right 159 | 160 | ## 161 | #def position 162 | # "\e[#;#R" 163 | #end 164 | 165 | # Apply ANSI codes to a first argument or block value. 166 | # 167 | # @example 168 | # ansi("Valentine", :red, :on_white) 169 | # 170 | # @example 171 | # ansi(:red, :on_white){ "Valentine" } 172 | # 173 | # @return [String] 174 | # String wrapped ANSI code. 175 | # 176 | def ansi(*codes) #:yield: 177 | if block_given? 178 | string = yield.to_s 179 | else 180 | # first argument must be the string 181 | string = codes.shift.to_s 182 | end 183 | 184 | return string unless $ansi 185 | 186 | c = code(*codes) 187 | 188 | c + string.gsub(ENDCODE, ENDCODE + c) + ENDCODE 189 | end 190 | 191 | # TODO: Allow selective removal using *codes argument? 192 | 193 | # Remove ANSI codes from string or block value. 194 | # 195 | # @param [String] string 196 | # String from which to remove ANSI codes. 197 | # 198 | # @return [String] 199 | # String wrapped ANSI code. 200 | # 201 | def unansi(string=nil) #:yield: 202 | if block_given? 203 | string = yield.to_s 204 | else 205 | string = string.to_s 206 | end 207 | string.gsub(PATTERN, '') 208 | end 209 | 210 | # Alias for #ansi method. 211 | # 212 | # @deprecated 213 | # Here for backward compatibility. 214 | alias_method :style, :ansi 215 | 216 | # Alias for #unansi method. 217 | # 218 | # @deprecated 219 | # Here for backwards compatibility. 220 | alias_method :unstyle, :unansi 221 | 222 | # Alternate term for #ansi. 223 | # 224 | # @deprecated 225 | # May change in future definition. 226 | alias_method :color, :ansi 227 | 228 | # Alias for unansi. 229 | # 230 | # @deprecated 231 | # May change in future definition. 232 | alias_method :uncolor, :unansi 233 | 234 | # Look-up code from chart, or if Integer simply pass through. 235 | # Also resolves :random and :on_random. 236 | # 237 | # @param codes [Array] The two difference strings. 90 | def diff_string(string1, string2) 91 | compare(string1, string2) 92 | end 93 | 94 | # Ensure the object of comparison is a string. If +object+ is not 95 | # an instance of String then it wll be converted to one by calling 96 | # either #to_str, if the object responds to it, or #inspect. 97 | def convert(object) 98 | if String === object 99 | object 100 | elsif object.respond_to?(:to_str) 101 | object.to_str 102 | else 103 | object.inspect 104 | end 105 | end 106 | 107 | # Rotation of colors for diff output. 108 | COLORS = [:red, :yellow, :magenta] 109 | 110 | # Take two plain strings and produce colorized 111 | # versions of each highlighting their differences. 112 | # 113 | # @param [String] x 114 | # First string to compare. 115 | # 116 | # @param [String] y 117 | # Second string to compare. 118 | # 119 | # @return [Array ] The two difference strings. 120 | def compare(x, y) 121 | c = common(x, y) 122 | a = x.dup 123 | b = y.dup 124 | oi = 0 125 | oj = 0 126 | c.each_with_index do |m, q| 127 | i = a.index(m, oi) 128 | j = b.index(m, oj) 129 | a[i,m.size] = ANSI.ansi(m, COLORS[q%3]) if i 130 | b[j,m.size] = ANSI.ansi(m, COLORS[q%3]) if j 131 | oi = i + m.size if i 132 | oj = j + m.size if j 133 | end 134 | return a, b 135 | end 136 | 137 | # Oh, I should have documented this will I knew what the 138 | # hell it was doing ;) 139 | def common(x,y) 140 | c = lcs(x, y) 141 | 142 | i = x.index(c) 143 | j = y.index(c) 144 | 145 | ix = i + c.size 146 | jx = j + c.size 147 | 148 | if i == 0 149 | l = y[0...j] 150 | elsif j == 0 151 | l = x[0...i] 152 | else 153 | l = common(x[0...i], y[0...j]) 154 | end 155 | 156 | if ix == x.size - 1 157 | r = y[jx..-1] 158 | elsif jx = y.size - 1 159 | r = x[ix..-1] 160 | else 161 | r = common(x[ix..-1], y[jx..-1]) 162 | end 163 | 164 | [l, c, r].flatten.reject{ |s| s.empty? } 165 | end 166 | 167 | # Least common string. 168 | def lcs(s1, s2) 169 | res="" 170 | num=Array.new(s1.size){Array.new(s2.size)} 171 | len,ans=0 172 | lastsub=0 173 | s1.scan(/./).each_with_index do |l1,i | 174 | s2.scan(/./).each_with_index do |l2,j | 175 | unless l1==l2 176 | num[i][j]=0 177 | else 178 | (i==0 || j==0)? num[i][j]=1 : num[i][j]=1 + num[i-1][j-1] 179 | if num[i][j] > len 180 | len = ans = num[i][j] 181 | thissub = i 182 | thissub -= num[i-1][j-1] unless num[i-1][j-1].nil? 183 | if lastsub==thissub 184 | res+=s1[i,1] 185 | else 186 | lastsub=thissub 187 | res=s1[lastsub, (i+1)-lastsub] 188 | end 189 | end 190 | end 191 | end 192 | end 193 | res 194 | end 195 | 196 | # Hmm... is this even useful? 197 | def lcs_size(s1, s2) 198 | num=Array.new(s1.size){Array.new(s2.size)} 199 | len,ans=0,0 200 | s1.scan(/./).each_with_index do |l1,i | 201 | s2.scan(/./).each_with_index do |l2,j | 202 | unless l1==l2 203 | num[i][j]=0 204 | else 205 | (i==0 || j==0)? num[i][j]=1 : num[i][j]=1 + num[i-1][j-1] 206 | len = ans = num[i][j] if num[i][j] > len 207 | end 208 | end 209 | end 210 | ans 211 | end 212 | 213 | end 214 | 215 | end 216 | -------------------------------------------------------------------------------- /lib/ansi/hexdump.rb: -------------------------------------------------------------------------------- 1 | module ANSI 2 | 3 | require 'ansi/code' 4 | 5 | # TODO: split dump method into two parts, the first should create a hex table 6 | # then the second, #dump method, will print it out. 7 | 8 | # Create a colorized hex dump of byte string. 9 | # 10 | # Output looks something like the following, but colorized. 11 | # 12 | # 000352c0: ed 33 8c 85 6e cc f6 f7 72 79 1c e3 3a b4 c2 c6 |.3..n...ry..:...| 13 | # 000352d0: c8 8d d6 ee 3e 68 a1 a5 ae b2 b7 97 a4 1d 5f a7 |....>h........_.| 14 | # 000352e0: d8 7d 28 db f6 8a e7 8a 7b 8d 0b bd 35 7d 25 3c |.}(.....{...5}%<| 15 | # 000352f0: 8b 3c c8 9d ec 04 85 54 92 a0 f7 a8 ed cf 05 7d |.<.....T.......}| 16 | # 00035300: b5 e3 9e 35 f0 79 9f 51 74 e3 60 ee 0f 03 8e 3f |...5.y.Qt.`....?| 17 | # 00035310: 05 5b 91 87 e6 48 48 ee a3 77 ae ad 5e 2a 56 a2 |.[...HH..w..^*V.| 18 | # 00035320: b6 96 86 f3 3c 92 b3 c8 62 4a 6f 96 10 5c 9c bb |....<...bJo..\..| 19 | # 20 | # In the future, we will make the colorization more customizable and 21 | # allow the groupings to be selectable at 2, 4, 8 or 16. 22 | # 23 | class HexDump 24 | 25 | # Printable ASCII codes. 26 | ASCII_PRINTABLE = (33..126) 27 | 28 | # 29 | def initialize(options={}) 30 | @offset = 0 31 | 32 | options.each do |k,v| 33 | __send__("#{k}=", v) 34 | end 35 | 36 | @color = true if color.nil? 37 | end 38 | 39 | # Use color? 40 | attr_accessor :color 41 | 42 | # Show index? 43 | attr_accessor :index 44 | 45 | # Offset byte count. 46 | attr_accessor :offset 47 | 48 | # Dump data string as colorized hex table. 49 | # 50 | # @param data [String] 51 | # String to convert to hex and display. 52 | # 53 | def dump(data) 54 | lines = data.to_s.scan(/.{1,16}/m) 55 | max_offset = (offset + data.size) / 256 #16 * 16 56 | max_offset_width = max_offset.to_s.size + 1 57 | max_hex_width = 49 #3 * 16 + 1 58 | 59 | out = template() 60 | off = offset() 61 | 62 | if index? 63 | puts((' ' * max_offset_width) + " 0 1 2 3 4 5 6 7 8 9 A B C D E F\n") 64 | end 65 | 66 | lines.each_with_index do |line, n| 67 | offset = off + n * 16 68 | bytes = line.unpack("C*") 69 | hex = bytes.map{ |c| "%0.2x" % c }.insert(8, '').join(' ') 70 | 71 | plain = bytes.map do |c| 72 | if ASCII_PRINTABLE.include?(c) 73 | c = c.chr 74 | else 75 | color ? Code::WHITE + Code::STRIKE + '.' + Code::CLEAR : '.' 76 | end 77 | end.join('') 78 | 79 | fill = [offset.to_s.rjust(max_offset_width), hex.ljust(max_hex_width), plain] 80 | 81 | puts(out % fill) 82 | end 83 | end 84 | 85 | # Hex dump a random string. 86 | # 87 | def dump_random(size=64) 88 | data = (0..size).map{ rand(255).chr }.join('') 89 | dump(data) 90 | end 91 | 92 | # 93 | def index? 94 | @index 95 | end 96 | 97 | private 98 | 99 | # Hex dump line template. 100 | # 101 | # @return [String] hex dump line template 102 | def template 103 | if color 104 | Code::CYAN + 105 | "%s: " + 106 | Code::YELLOW + 107 | "%s " + 108 | Code::BLUE + 109 | "|" + 110 | Code::CLEAR + 111 | "%s" + 112 | Code::BLUE + 113 | "|" + 114 | Code::CLEAR 115 | else 116 | "%s: %s |%s|" 117 | end 118 | end 119 | 120 | end 121 | 122 | end 123 | -------------------------------------------------------------------------------- /lib/ansi/logger.rb: -------------------------------------------------------------------------------- 1 | # Ansi::Logger 2 | # Copyright (c) 2009 Thomas Sawyer 3 | # Copyright (c) 2005 George Moschovitis 4 | 5 | require "logger" 6 | require "time" 7 | require "ansi/code" 8 | 9 | # = ANSI::Logger 10 | # 11 | # Extended variation of Ruby's standard Logger library that supports 12 | # color output. 13 | # 14 | # log = ANSI::Logger.new 15 | # 16 | # log.formatter do |severity, timestamp, progname, msg| 17 | # ANSI::Logger::SIMPLE_FORMAT % [severity, msg] 18 | # end 19 | # 20 | #-- 21 | # TODO: What's all this about then? 22 | # 23 | # When using debug level logger messages always append 'if $DBG' 24 | # at the end. This hack is needed because Ruby does not support 25 | # lazy evaluation (lisp macros). 26 | #++ 27 | class ANSI::Logger < Logger 28 | 29 | # Some available logging formats. 30 | SIMPLE_FORMAT = "%5s: %s\n" 31 | DETAILED_FORMAT = "%s %5s: %s\n" 32 | 33 | # TODO: Not sure I like this approach. 34 | class ::Logger #:nodoc: 35 | class LogDevice #:nodoc: 36 | attr_writer :ansicolor 37 | 38 | def ansicolor? 39 | @ansicolor.nil? ? true : @ansicolor 40 | end 41 | end 42 | end 43 | 44 | # 45 | def ansicolor? 46 | @logdev.ansicolor? 47 | end 48 | 49 | # 50 | def ansicolor=(on) 51 | @logdev.ansicolor = on 52 | end 53 | 54 | # Dictate the way in which this logger should format the 55 | # messages it displays. This method requires a block. The 56 | # block should return formatted strings given severity, 57 | # timestamp, progname and msg. 58 | # 59 | # === Example 60 | # 61 | # logger = ANSI::Logger.new 62 | # 63 | # logger.formatter do |severity, timestamp, progname, msg| 64 | # "#{progname}@#{timestamp} - #{severity}::#{msg}" 65 | # end 66 | # 67 | def formatter(&block) 68 | self.formatter = block if block 69 | super 70 | end 71 | 72 | def styles(options=nil) 73 | @styles ||= { 74 | :info => [], 75 | :warn => [:yellow], 76 | :debug => [:cyan], 77 | :error => [:red], 78 | :fatal => [:bold, :red] 79 | } 80 | @styles.merge!(options) if options 81 | @styles 82 | end 83 | 84 | # 85 | def info(progname=nil, &block) 86 | return unless info? 87 | @logdev.ansicolor? ? info_with_color{ super } : super 88 | end 89 | 90 | # 91 | def warn(progname=nil, &block) 92 | return unless warn? 93 | @logdev.ansicolor? ? warn_with_color{ super } : super 94 | end 95 | 96 | # 97 | def debug(progname=nil, &block) 98 | return unless debug? 99 | @logdev.ansicolor? ? debug_with_color{ super } : super 100 | end 101 | 102 | # 103 | def error(progname=nil, &block) 104 | return unless error? 105 | @logdev.ansicolor? ? error_with_color{ super } : super 106 | end 107 | 108 | # 109 | def fatal(progname=nil, &block) 110 | return unless error? 111 | @logdev.ansicolor? ? fatal_with_color{ super } : super 112 | end 113 | 114 | private 115 | 116 | def info_with_color #:yield: 117 | styles[:info].each{ |s| self << ANSI::Code.send(s) } 118 | yield 119 | self << ANSI::Code.clear 120 | end 121 | 122 | def warn_with_color #:yield: 123 | styles[:warn].each{ |s| self << ANSI::Code.send(s) } 124 | yield 125 | self << ANSI::Code.clear 126 | end 127 | 128 | def error_with_color #:yield: 129 | styles[:error].each{ |s| self << ANSI::Code.send(s) } 130 | yield 131 | self << ANSI::Code.clear 132 | end 133 | 134 | def debug_with_color #:yield: 135 | styles[:debug].each{ |s| self << ANSI::Code.send(s) } 136 | yield 137 | self << ANSI::Code.clear 138 | end 139 | 140 | def fatal_with_color #:yield: 141 | styles[:fatal].each{ |s| self << ANSI::Code.send(s) } 142 | yield 143 | self << ANSI::Code.clear 144 | end 145 | 146 | end 147 | 148 | 149 | # NOTE: trace is deprecated b/c binding of caller is no longer possible. 150 | =begin 151 | # Prints a trace message to DEBUGLOG (at debug level). 152 | # Useful for emitting the value of variables, etc. Use 153 | # like this: 154 | # 155 | # x = y = 5 156 | # trace 'x' # -> 'x = 5' 157 | # trace 'x ** y' # -> 'x ** y = 3125' 158 | # 159 | # If you have a more complicated value, like an array of 160 | # hashes, then you'll probably want to use an alternative 161 | # output format. For instance: 162 | # 163 | # trace 'value', :yaml 164 | # 165 | # Valid output format values (the _style_ parameter) are: 166 | # 167 | # :p :inspect 168 | # :pp (pretty-print, using 'pp' library) 169 | # :s :to_s 170 | # :y :yaml :to_yaml (using the 'yaml' library') 171 | # 172 | # The default is :p. 173 | # 174 | # CREDITS: 175 | # 176 | # This code comes straight from the dev-utils Gem. 177 | # Author: Gavin Sinclair
\n" 18 | out.assert == ANSI::BBCode.bbcode_to_html(str) 19 | end 20 | end 21 | 22 | class_method :ansi_to_html do 23 | test do 24 | str = "this is \e[0;31mred\e[0m, this is \e[1mbold\e[0m\n" + 25 | "this is a line without any ansi code\n" + 26 | "this is \e[0;31mred\e[0m, this is \e[1mbold\e[0m\n" 27 | out = "this is red, this is bold
\n" + 28 | "this is a line without any ansi code
\n" + 29 | "this is red, this is bold
\n" 30 | out.assert == ANSI::BBCode.ansi_to_html(str) 31 | end 32 | end 33 | 34 | end 35 | 36 | -------------------------------------------------------------------------------- /test/case_mixin.rb: -------------------------------------------------------------------------------- 1 | require 'test_helper' 2 | require 'ansi/mixin' 3 | 4 | testcase ANSI::Mixin do 5 | 6 | # TODO: subclass 7 | class ::String 8 | include ANSI::Mixin 9 | end 10 | 11 | method :red do 12 | test do 13 | str = "Hello".red 14 | out = "\e[31mHello\e[0m" 15 | out.assert == str 16 | end 17 | end 18 | 19 | method :blue do 20 | test do 21 | str = "World".blue 22 | out = "\e[34mWorld\e[0m" 23 | out.assert == str 24 | end 25 | end 26 | 27 | method :display do 28 | test do 29 | str = "Hello".display(4,10) 30 | out = "\e[s\e[4;10HHello\e[u" 31 | out.assert == str 32 | end 33 | end 34 | 35 | end 36 | -------------------------------------------------------------------------------- /test/case_progressbar.rb: -------------------------------------------------------------------------------- 1 | require 'test_helper' 2 | require 'stringio' 3 | require 'ansi/progressbar' 4 | 5 | testcase ANSI::Progressbar do 6 | 7 | method :initialize do 8 | test do 9 | stio = StringIO.new 10 | pbar = ANSI::Progressbar.new("Test Bar", 10, stio) do |b| 11 | b.style(:title => [:red], :bar=>[:blue]) 12 | end 13 | 10.times do |i| 14 | sleep 0.1 15 | pbar.inc 16 | end 17 | true 18 | end 19 | end 20 | 21 | end 22 | -------------------------------------------------------------------------------- /test/test_helper.rb: -------------------------------------------------------------------------------- 1 | require 'lemon' 2 | require 'ae' 3 | 4 | -------------------------------------------------------------------------------- /work/NOTES.md: -------------------------------------------------------------------------------- 1 | = DEVELOPMENT NOTES 2 | 3 | == Tweaks Branch 4 | 5 | The `tweaks` branch needs to be merged into master. 6 | 7 | -------------------------------------------------------------------------------- /work/benchmarks/string_vs_block.rb: -------------------------------------------------------------------------------- 1 | require 'benchmark' 2 | require 'ansi/code' 3 | 4 | n = 50000 5 | Benchmark.bmbm(10) do |x| 6 | x.report("string:"){ n.times{|i| ANSI::Code.red(i.to_s) } } 7 | x.report("block :"){ n.times{|i| ANSI::Code.red{i.to_s} } } 8 | end 9 | 10 | -------------------------------------------------------------------------------- /work/consider/highlight.rb: -------------------------------------------------------------------------------- 1 | require 'ansi/code' 2 | 3 | file = ARGV.first 4 | text = File.read(file) 5 | 6 | close = ANSI::Code.clear 7 | 8 | def uncolored(str) 9 | ANSI::Code.uncolored(str) 10 | end 11 | 12 | colors = { 13 | :dot => ANSI::Code.red, 14 | :cash => ANSI::Code.green, 15 | :at => ANSI::Code.cyan, 16 | :fn => ANSI::Code.bold + ANSI::Code.blue, 17 | :cap => ANSI::Code.blue, 18 | :sharp => ANSI::Code.white, 19 | :quote => ANSI::Code.red, 20 | } 21 | 22 | work = text.dup 23 | 24 | # xxx( 25 | text.gsub!(/(\W)(\w+?)(?=\()/){ $1 + colors[:fn] + $2 + close } 26 | 27 | # .xxx 28 | text.gsub!(/\.(\w+?)(?=\W)/){ colors[:dot] + '.' + $1 + close } 29 | 30 | # $xxx 31 | text.gsub!(/(\$\w+?)(?=\W)/){ colors[:cash] + $1 + close } 32 | 33 | # @xxx 34 | text.gsub!(/(\$\w+?)(?=\W)/){ colors[:at] + $1 + close } 35 | 36 | # #xxx 37 | text.gsub!(/\#(.*?)$/){ colors[:sharp] + '#' + uncolored($1) + close } 38 | 39 | # XXX 40 | text.gsub!(/([A-Z_]+?)(?=\W)/){ colors[:cap] + $1 + close } 41 | 42 | # 'xxx' 43 | text.gsub!(/(['"].*?["'])/){ colors[:quote] + uncolored($1) + close } 44 | 45 | # #xxx 46 | text.gsub!(/^(\s+)(\#.*?)$/){ $1 + colors[:sharp] + '#' + uncolored($2) + close } 47 | 48 | 49 | $stdout << text 50 | 51 | -------------------------------------------------------------------------------- /work/consider/string.rd: -------------------------------------------------------------------------------- 1 | = Clio::String 2 | 3 | This is a unit test specification for the Clio::String class. 4 | This class is intended to provide a very convenient way to 5 | output colorful and aligned text to a shell console. 6 | 7 | Require the Clio String library. 8 | 9 | require 'clio/string' 10 | 11 | Define a few regular strings for comparison. 12 | 13 | @s1 = "Hi how are you." 14 | @s2 = "Fine thanks." 15 | 16 | Define the equivalent Clio strings. 17 | 18 | @c1 = Clio.string("Hi how are you.") 19 | @c2 = Clio.string("Fine thanks.") 20 | 21 | Clio::String#ansi is used to wrap the current string in an 22 | ANSI code *bracket*, ie. prepending with the given ANSI code 23 | and appending with the ANSI escape code. 24 | 25 | y = @c1.ansi(:red) 26 | x = "\e[31mHi how are you.\e[0m" 27 | y.to_s.should == x 28 | 29 | Some methods are delegated directly to the underying string, 30 | as they do not effect any ANSI codes have been applied. 31 | 32 | y = @c1.ansi(:red).upcase 33 | x = "\e[31mHI HOW ARE YOU.\e[0m" 34 | y.to_s.should == x 35 | 36 | Shortcut methods are provided for most ANSI Codes, such as 37 | Clio::String#red. 38 | 39 | y = @c1.red 40 | x = "\e[31mHi how are you.\e[0m" 41 | y.to_s.should == x 42 | 43 | Clio::String#[] will return the character at a gven index. 44 | This works like Ruby 1.9, so no size parameter is needed. 45 | 46 | y = @c1[0] 47 | x = @s1[0,1] 48 | y.to_s.should == x 49 | 50 | But the size parameter can be given too. 51 | 52 | y = @c1[0,3] 53 | x = @s1[0,3] 54 | y.to_s.should == x 55 | 56 | A Range works too. 57 | 58 | y = @c1[0..3] 59 | x = @s1[0..3] 60 | y.to_s.should == x 61 | 62 | Clio::String#+ works just like a regular String. 63 | 64 | y = @c1 + @c2 65 | x = @s1 + @s2 66 | y.to_s.should == x 67 | 68 | Complex cases with ANSI codes work as expected. 69 | 70 | s1 = Clio.string("a").red 71 | s2 = Clio.string("b").blue 72 | y = s1 + s2 73 | x = "\e[31ma\e[0m\e[34mb\e[0m" 74 | y.to_s.should == x 75 | 76 | Method #sub can replace a substring. 77 | 78 | y = @c1.sub('Hi', 'Hello') 79 | x = "Hello how are you." 80 | y.to_s.assert == x 81 | 82 | Method #gsub! can replace many substrings. 83 | 84 | s1 = Clio.string("axax").red 85 | s2 = Clio.string("axax").blue 86 | y = s1 + s2 87 | y.to_s.assert == "\e[31maxax\e[0m\e[34maxax\e[0m" 88 | y.gsub!('x', 'y') 89 | y.to_s.assert == "\e[31mayay\e[0m\e[34mayay\e[0m" 90 | 91 | This specification is not complete, but it is a good start. 92 | 93 | -------------------------------------------------------------------------------- /work/deprecated/ansi.rbz: -------------------------------------------------------------------------------- 1 | # ANSI Module provides a Bezel interface as follows: 2 | # 3 | # ANSI = lib('ansi', '1.2.6') 4 | # 5 | # module MyAPP 6 | # include ANSI 7 | # end 8 | # 9 | # Examples 10 | # 11 | # def hello_world 12 | # puts ansi("Hello World", :red) 13 | # end 14 | # 15 | # # automatically included with ANSI 1.3. 16 | # def ansi(string, *codes) 17 | # ANSI::Code.ansi(string, *codes) 18 | # end 19 | # 20 | # Or 21 | # 22 | # def hello_world 23 | # puts "Hello World".ansi(:red) 24 | # end 25 | # 26 | # NOTE: Core extensions need stable interfaces! 27 | # 28 | module ANSI; end 29 | 30 | import 'ansi/code' 31 | import 'ansi/bbcode' 32 | import 'ansi/columns' 33 | import 'ansi/diff' 34 | import 'ansi/logger' 35 | import 'ansi/mixin' 36 | import 'ansi/progressbar' 37 | import 'ansi/string' 38 | import 'ansi/table' 39 | import 'ansi/terminal' 40 | 41 | -------------------------------------------------------------------------------- /work/deprecated/task/demo.ergo: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | desc "run demos" 4 | 5 | rule "demo/*.md" => :run_demo 6 | rule "lib/**/*.rb" => :run_all 7 | 8 | def run_demo(*demos) 9 | shell "bundle exec qed -Ilib " + demos.join(' ') 10 | end 11 | 12 | def run_all 13 | shell "bundle exec qed -Ilib demo/*.md" 14 | end 15 | 16 | #task("demo") { shell "qed -Ilib qed/" } 17 | 18 | -------------------------------------------------------------------------------- /work/deprecated/task/index.ergo: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | desc "update index file" 4 | 5 | rule 'Index.yml' do 6 | shell "index -u Index.yml" 7 | end 8 | 9 | -------------------------------------------------------------------------------- /work/deprecated/task/syckle-hooks/pre-generate.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | file = "lib/#{project.metadata.name}/version.rb" 3 | 4 | line = [] 5 | line << "module ANSI" 6 | line << " VERSION = '#{project.version}'" 7 | line << " DATE = '#{Time.new.strftime("%Y-%m-%d")}'" 8 | 9 | #project.profile.to_h.each do |key, value| 10 | # next if key == "manifest" 11 | # line << " #{key.upcase} = #{value.inspect}" 12 | #end 13 | 14 | line << "end" 15 | 16 | text = line.join("\n") 17 | 18 | if !exist?(file) || read(file) != text 19 | write(file, text) 20 | report "Updated #{file}" 21 | else 22 | report "Already current #{file}" 23 | end 24 | 25 | -------------------------------------------------------------------------------- /work/deprecated/task/test.ergo: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | desc "run unit tests" 4 | 5 | rule 'test/helper.rb' => :test_all 6 | rule 'test/case_*.rb' => :test 7 | rule /^lib\/(.*?)\.rb$/ => :test_match 8 | rule /^lib\/ansi\/(.*?)\.rb$/ => :test_match 9 | 10 | def test_all 11 | test *Dir['test/test_*.rb'] 12 | end 13 | 14 | def test_match(m) 15 | test "test/case_#{m[1]}" 16 | end 17 | 18 | def test(*paths) 19 | shell "bundle exec rubytest #{gem_opt} -Ilib:test " + paths.flatten.join(' ') 20 | end 21 | 22 | def gem_opt 23 | defined?(::Gem) ? "-rubygems" : "" 24 | end 25 | 26 | #Signal.trap('QUIT') { test tests } # Ctrl-\ 27 | #Signal.trap('INT' ) { abort("\n") } # Ctrl-C 28 | 29 | -------------------------------------------------------------------------------- /work/deprecated/task/test.watchr: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | watch( '^test.*/test_.*\.rb' ) { |m| test m[0] } 4 | watch( '^lib/(.*)\.rb' ) { |m| test "test/case_#{m[1]}.rb" } 5 | watch( '^lib/ansi/(.*)\.rb' ) { |m| test "test/case_#{m[1]}.rb" } 6 | watch( '^test/test_helper\.rb' ) { test tests } 7 | 8 | Signal.trap('QUIT') { test tests } # Ctrl-\ 9 | Signal.trap('INT' ) { abort("\n") } # Ctrl-C 10 | 11 | def test(*paths) 12 | run "ruby-test #{gem_opt} -Ilib:test #{paths.flatten.join(' ')}" 13 | end 14 | 15 | def tests 16 | Dir['test/**/case_*.rb'] 17 | end 18 | 19 | def run(cmd) 20 | puts cmd 21 | system cmd 22 | end 23 | 24 | def gem_opt 25 | defined?(Gem) ? "-rubygems" : "" 26 | end 27 | 28 | -------------------------------------------------------------------------------- /work/reference/ansicode.rb: -------------------------------------------------------------------------------- 1 | # = ANSICode 2 | # 3 | # Module which makes it very easy to use ANSI codes. 4 | # These are esspecially nice for beautifying shell output. 5 | # 6 | # include ANSICode 7 | # 8 | # p red, "Hello", blue, "World" 9 | # => "\e[31mHello\e[34mWorld" 10 | # 11 | # p red { "Hello" } + blue { "World" } 12 | # => "\e[31mHello\e[0m\e[34mWorld\e[0m" 13 | # 14 | # == Supported ANSI Comands 15 | # 16 | # The following is a list of supported codes. 17 | # 18 | # save 19 | # restore 20 | # clear_screen 21 | # cls # synonym for :clear_screen 22 | # clear_line 23 | # clr # synonym for :clear_line 24 | # move 25 | # up 26 | # down 27 | # left 28 | # right 29 | # display 30 | # 31 | # clear 32 | # reset # synonym for :clear 33 | # bold 34 | # dark 35 | # italic # not widely implemented 36 | # underline 37 | # underscore # synonym for :underline 38 | # blink 39 | # rapid_blink # not widely implemented 40 | # negative # no reverse because of String#reverse 41 | # concealed 42 | # strikethrough # not widely implemented 43 | # 44 | # black 45 | # red 46 | # green 47 | # yellow 48 | # blue 49 | # magenta 50 | # cyan 51 | # white 52 | # 53 | # on_black 54 | # on_red 55 | # on_green 56 | # on_yellow 57 | # on_blue 58 | # on_magenta 59 | # on_cyan 60 | # on_white 61 | # 62 | # == Authors 63 | # 64 | # * Florian Frank 65 | # * Thomas Sawyer 66 | # 67 | # == Speical Thanks 68 | # 69 | # Special thanks to Florian Frank. ANSICode is a partial adaptation 70 | # of ANSIColor, Copyright (c) 2002 Florian Frank, LGPL. 71 | # 72 | # == Todo 73 | # 74 | # * Need to add rest of ANSI codes. Include modes? 75 | # * Re-evaluate how color/yielding methods are defined. 76 | # * Maybe up, down, right, left should have yielding methods too? 77 | # 78 | # == Copying 79 | # 80 | # Copyright (c) 2004 Florian Frank, Thomas Sawyer 81 | # 82 | # Ruby License 83 | # 84 | # This module is free software. You may use, modify, and/or redistribute this 85 | # software under the same terms as Ruby. 86 | # 87 | # This program is distributed in the hope that it will be useful, but WITHOUT 88 | # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 89 | # FOR A PARTICULAR PURPOSE. 90 | 91 | 92 | # = ANSICode 93 | # 94 | # Module which makes it very easy to use ANSI codes. 95 | # These are esspecially nice for beautifying shell output. 96 | # 97 | # include ANSICode 98 | # 99 | # p red, "Hello", blue, "World" 100 | # => "\e[31mHello\e[34mWorld" 101 | # 102 | # p red { "Hello" } + blue { "World" } 103 | # => "\e[31mHello\e[0m\e[34mWorld\e[0m" 104 | # 105 | # == Supported ANSI Comands 106 | # 107 | # The following is a list of supported codes. 108 | # 109 | # save 110 | # restore 111 | # clear_screen 112 | # cls # synonym for :clear_screen 113 | # clear_line 114 | # clr # synonym for :clear_line 115 | # move 116 | # up 117 | # down 118 | # left 119 | # right 120 | # display 121 | # 122 | # clear 123 | # reset # synonym for :clear 124 | # bold 125 | # dark 126 | # italic # not widely implemented 127 | # underline 128 | # underscore # synonym for :underline 129 | # blink 130 | # rapid_blink # not widely implemented 131 | # negative # no reverse because of String#reverse 132 | # concealed 133 | # strikethrough # not widely implemented 134 | # 135 | # black 136 | # red 137 | # green 138 | # yellow 139 | # blue 140 | # magenta 141 | # cyan 142 | # white 143 | # 144 | # on_black 145 | # on_red 146 | # on_green 147 | # on_yellow 148 | # on_blue 149 | # on_magenta 150 | # on_cyan 151 | # on_white 152 | # 153 | module ANSICode 154 | 155 | extend self 156 | 157 | # Save current cursor positon. 158 | 159 | def save 160 | "\e[s" 161 | end 162 | 163 | # Restore saved cursor positon. 164 | 165 | def restore 166 | "\e[u" 167 | end 168 | 169 | # Clear the screen and move cursor to home. 170 | 171 | def clear_screen 172 | "\e[2J" 173 | end 174 | alias_method :cls, :clear_screen 175 | 176 | # Clear to the end of the current line. 177 | 178 | def clear_line 179 | "\e[K" 180 | end 181 | alias_method :clr, :clear_line 182 | 183 | #-- 184 | #def position 185 | # "\e[#;#R" 186 | #end 187 | #++ 188 | 189 | # Move curose to line and column. 190 | 191 | def move( line, column=0 ) 192 | "\e[#{line.to_i};#{column.to_i}H" 193 | end 194 | 195 | # Move cursor up a specificed number of spaces. 196 | 197 | def up( spaces=1 ) 198 | "\e[#{spaces.to_i}A" 199 | end 200 | 201 | # Move cursor down a specificed number of spaces. 202 | 203 | def down( spaces=1 ) 204 | "\e[#{spaces.to_i}B" 205 | end 206 | 207 | # Move cursor left a specificed number of spaces. 208 | 209 | def left( spaces=1 ) 210 | "\e[#{spaces.to_i}D" 211 | end 212 | 213 | # Move cursor right a specificed number of spaces. 214 | 215 | def right( spaces=1 ) 216 | "\e[#{spaces.to_i}C" 217 | end 218 | 219 | # Like +move+ but returns to original positon 220 | # after yielding block or adding string argument. 221 | 222 | def display( line, column=0, string=nil ) #:yield: 223 | result = "\e[s" 224 | result << "\e[#{line.to_i};#{column.to_i}H" 225 | if block_given? 226 | result << yield 227 | result << "\e[u" 228 | elsif string 229 | result << string 230 | result << "\e[u" 231 | elsif respond_to?(:to_str) 232 | result << self 233 | result << "\e[u" 234 | end 235 | return result 236 | end 237 | 238 | # Define color codes. 239 | 240 | def self.define_ansicolor_method(name,code) 241 | class_eval <<-HERE 242 | def #{name.to_s}(string = nil) 243 | result = "\e[#{code}m" 244 | if block_given? 245 | result << yield 246 | result << "\e[0m" 247 | elsif string 248 | result << string 249 | result << "\e[0m" 250 | elsif respond_to?(:to_str) 251 | result << self 252 | result << "\e[0m" 253 | end 254 | return result 255 | end 256 | HERE 257 | end 258 | 259 | @@colors = [ 260 | [ :clear , 0 ], 261 | [ :reset , 0 ], # synonym for :clear 262 | [ :bold , 1 ], 263 | [ :dark , 2 ], 264 | [ :italic , 3 ], # not widely implemented 265 | [ :underline , 4 ], 266 | [ :underscore , 4 ], # synonym for :underline 267 | [ :blink , 5 ], 268 | [ :rapid_blink , 6 ], # not widely implemented 269 | [ :negative , 7 ], # no reverse because of String#reverse 270 | [ :concealed , 8 ], 271 | [ :strikethrough, 9 ], # not widely implemented 272 | [ :black , 30 ], 273 | [ :red , 31 ], 274 | [ :green , 32 ], 275 | [ :yellow , 33 ], 276 | [ :blue , 34 ], 277 | [ :magenta , 35 ], 278 | [ :cyan , 36 ], 279 | [ :white , 37 ], 280 | [ :on_black , 40 ], 281 | [ :on_red , 41 ], 282 | [ :on_green , 42 ], 283 | [ :on_yellow , 43 ], 284 | [ :on_blue , 44 ], 285 | [ :on_magenta , 45 ], 286 | [ :on_cyan , 46 ], 287 | [ :on_white , 47 ], 288 | ] 289 | 290 | @@colors.each do |c, v| 291 | define_ansicolor_method(c, v) 292 | end 293 | 294 | ColoredRegexp = /\e\[([34][0-7]|[0-9])m/ 295 | 296 | def uncolored(string = nil) 297 | if block_given? 298 | yield.gsub(ColoredRegexp, '') 299 | elsif string 300 | string.gsub(ColoredRegexp, '') 301 | elsif respond_to?(:to_str) 302 | gsub(ColoredRegexp, '') 303 | else 304 | '' 305 | end 306 | end 307 | 308 | module_function 309 | 310 | def colors 311 | @@colors.map { |c| c[0] } 312 | end 313 | 314 | end 315 | 316 | -------------------------------------------------------------------------------- /work/reference/console/.gitignore: -------------------------------------------------------------------------------- 1 | doc 2 | -------------------------------------------------------------------------------- /work/reference/console/Console.rdoc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rubyworks/ansi/17002348d45ce9298a1a4017dc43d3cf65151bd4/work/reference/console/Console.rdoc -------------------------------------------------------------------------------- /work/reference/console/Console_ANSI.rdoc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rubyworks/ansi/17002348d45ce9298a1a4017dc43d3cf65151bd4/work/reference/console/Console_ANSI.rdoc -------------------------------------------------------------------------------- /work/reference/console/HISTORY.txt: -------------------------------------------------------------------------------- 1 | v1.0 - Added .dup to _printString function to avoid mangling outside 2 | string references. Removed the other (later) .dup call. 3 | Turned of some exceptions that were conflicting with using 4 | the module with pipes or redirections. 5 | v0.8 - Fixed bugs in reading routines, added ruby docs, and 6 | sample test suite. 7 | v0.5 - First public release. 8 | -------------------------------------------------------------------------------- /work/reference/console/INSTALL.txt: -------------------------------------------------------------------------------- 1 | 2 | To compile and install: 3 | 4 | 5 | Open a windows console. 6 | > vcvars32.bat # to set up microsoft's compiling environment 7 | # this is located in the bin/ directory of the MSVC compiler 8 | > ruby extconf.rb # to create a Makefile 9 | > nmake # to compile 10 | > nmake install # to install 11 | 12 | 13 | To test: 14 | 15 | > cd test 16 | > dir # to see available samples 17 | > ruby [anysample] 18 | 19 | -------------------------------------------------------------------------------- /work/reference/console/Makefile: -------------------------------------------------------------------------------- 1 | 2 | SHELL = /bin/sh 3 | 4 | #### Start of system configuration section. #### 5 | 6 | srcdir = C:/ruby/visualc/Console 7 | topdir = $(rubylibdir)/$(arch) 8 | hdrdir = $(rubylibdir)/$(arch) 9 | VPATH = $(srcdir) 10 | 11 | DESTDIR = c: 12 | prefix = $(DESTDIR)/ruby 13 | exec_prefix = $(prefix) 14 | bindir = $(exec_prefix)/bin 15 | sitelibdir = $(sitedir)/$(ruby_version) 16 | datadir = $(prefix)/share 17 | sitedir = $(prefix)/lib/ruby/site_ruby 18 | sharedstatedir = $(DESTDIR)/etc 19 | archdir = $(rubylibdir)/$(arch) 20 | localstatedir = $(DESTDIR)/var 21 | infodir = $(prefix)/info 22 | oldincludedir = $(DESTDIR)/usr/include 23 | libexecdir = $(exec_prefix)/libexec 24 | compile_dir = $(DESTDIR)/WINDOWS/Escritorio/Programacion/ruby/win32 25 | sbindir = $(exec_prefix)/sbin 26 | includedir = $(prefix)/include 27 | sysconfdir = $(prefix)/etc 28 | sitearchdir = $(sitelibdir)/$(sitearch) 29 | mandir = $(prefix)/man 30 | libdir = $(exec_prefix)/lib 31 | rubylibdir = $(libdir)/ruby/$(ruby_version) 32 | 33 | CC = cl -nologo 34 | LIBRUBY = $(RUBY_SO_NAME).lib 35 | LIBRUBY_A = $(RUBY_SO_NAME)-static.lib 36 | LIBRUBYARG_SHARED = $(LIBRUBY) 37 | LIBRUBYARG_STATIC = $(LIBRUBY_A) 38 | 39 | CFLAGS = -MD -Zi -O2b2xg- -G6 40 | CPPFLAGS = -I. -I$(topdir) -I$(hdrdir) -I$(srcdir) -I. -I./.. -I./../missing 41 | CXXFLAGS = $(CFLAGS) 42 | DLDFLAGS = -link -incremental:no -debug -opt:ref -opt:icf -dll $(LIBPATH) -def:$(DEFFILE) 43 | LDSHARED = cl -nologo -LD 44 | AR = lib -nologo 45 | EXEEXT = .exe 46 | 47 | RUBY_INSTALL_NAME = ruby 48 | RUBY_SO_NAME = msvcrt-ruby18 49 | arch = i386-mswin32 50 | sitearch = i386-msvcrt 51 | ruby_version = 1.8 52 | RUBY = ruby 53 | RM = $(RUBY) -run -e rm -- -f 54 | MAKEDIRS = $(RUBY) -run -e mkdir -- -p 55 | INSTALL_PROG = $(RUBY) -run -e install -- -vpm 0755 56 | INSTALL_DATA = $(RUBY) -run -e install -- -vpm 0644 57 | 58 | #### End of system configuration section. #### 59 | 60 | 61 | LIBPATH = -libpath:"$(libdir)" 62 | DEFFILE = $(TARGET)-$(arch).def 63 | 64 | CLEANFILES = 65 | DISTCLEANFILES = $(DEFFILE) 66 | 67 | target_prefix = 68 | LOCAL_LIBS = 69 | LIBS = $(LIBRUBYARG_SHARED) oldnames.lib user32.lib advapi32.lib wsock32.lib 70 | OBJS = Console.obj 71 | TARGET = Console 72 | DLLIB = $(TARGET).so 73 | STATIC_LIB = $(TARGET).lib 74 | 75 | RUBYCOMMONDIR = $(sitedir)$(target_prefix) 76 | RUBYLIBDIR = $(sitelibdir)$(target_prefix) 77 | RUBYARCHDIR = $(sitearchdir)$(target_prefix) 78 | 79 | CLEANLIBS = "$(TARGET).{lib,exp,il?,tds,map}" $(DLLIB) 80 | CLEANOBJS = "*.{obj,lib,s[ol],pdb,bak}" 81 | 82 | all: $(DLLIB) 83 | static: $(STATIC_LIB) 84 | 85 | clean: 86 | @$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES) 87 | 88 | distclean: clean 89 | @$(RM) Makefile extconf.h conftest.* mkmf.log 90 | @$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES) 91 | 92 | realclean: distclean 93 | install: $(RUBYARCHDIR) 94 | install: $(RUBYARCHDIR)/$(DLLIB) 95 | $(RUBYARCHDIR)/$(DLLIB): $(DLLIB) $(RUBYARCHDIR) 96 | @$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR) 97 | install: $(RUBYLIBDIR)/Win32 98 | install: $(RUBYLIBDIR)/Win32/Console.rb 99 | $(RUBYLIBDIR)/Win32/Console.rb: $(srcdir)/lib/Win32/Console.rb $(RUBYLIBDIR)/Win32 100 | @$(INSTALL_DATA) $(srcdir)/lib/Win32/Console.rb $(RUBYLIBDIR)/Win32 101 | install: $(RUBYLIBDIR)/Win32/Console 102 | install: $(RUBYLIBDIR)/Win32/Console/ANSI.rb 103 | $(RUBYLIBDIR)/Win32/Console/ANSI.rb: $(srcdir)/lib/Win32/Console/ANSI.rb $(RUBYLIBDIR)/Win32/Console 104 | @$(INSTALL_DATA) $(srcdir)/lib/Win32/Console/ANSI.rb $(RUBYLIBDIR)/Win32/Console 105 | install: $(RUBYLIBDIR)/Term 106 | install: $(RUBYLIBDIR)/Term/ansicolor.rb 107 | $(RUBYLIBDIR)/Term/ansicolor.rb: $(srcdir)/lib/Term/ansicolor.rb $(RUBYLIBDIR)/Term 108 | @$(INSTALL_DATA) $(srcdir)/lib/Term/ansicolor.rb $(RUBYLIBDIR)/Term 109 | $(RUBYARCHDIR): 110 | @$(MAKEDIRS) $(RUBYARCHDIR) 111 | $(RUBYLIBDIR)/Win32: 112 | @$(MAKEDIRS) $(RUBYLIBDIR)/Win32 113 | $(RUBYLIBDIR)/Win32/Console: 114 | @$(MAKEDIRS) $(RUBYLIBDIR)/Win32/Console 115 | $(RUBYLIBDIR)/Term: 116 | @$(MAKEDIRS) $(RUBYLIBDIR)/Term 117 | 118 | site-install: install 119 | 120 | .SUFFIXES: .c .cc .m .cxx .cpp .C .obj 121 | 122 | {$(srcdir)}.cc{}.obj: 123 | $(CXX) $(CXXFLAGS) $(CPPFLAGS) -c -Tp$(<:\=/) 124 | 125 | .cc.obj: 126 | $(CXX) $(CXXFLAGS) $(CPPFLAGS) -c -Tp$(<:\=/) 127 | 128 | {$(srcdir)}.cpp{}.obj: 129 | $(CXX) $(CXXFLAGS) $(CPPFLAGS) -c -Tp$(<:\=/) 130 | 131 | .cpp.obj: 132 | $(CXX) $(CXXFLAGS) $(CPPFLAGS) -c -Tp$(<:\=/) 133 | 134 | {$(srcdir)}.cxx{}.obj: 135 | $(CXX) $(CXXFLAGS) $(CPPFLAGS) -c -Tp$(<:\=/) 136 | 137 | .cxx.obj: 138 | $(CXX) $(CXXFLAGS) $(CPPFLAGS) -c -Tp$(<:\=/) 139 | 140 | {$(srcdir)}.C{}.obj: 141 | $(CXX) $(CXXFLAGS) $(CPPFLAGS) -c -Tp$(<:\=/) 142 | 143 | .C.obj: 144 | $(CXX) $(CXXFLAGS) $(CPPFLAGS) -c -Tp$(<:\=/) 145 | 146 | {$(srcdir)}.c{}.obj: 147 | $(CC) $(CFLAGS) $(CPPFLAGS) -c -Tc$(<:\=/) 148 | 149 | .c.obj: 150 | $(CC) $(CFLAGS) $(CPPFLAGS) -c -Tc$(<:\=/) 151 | 152 | $(DLLIB): $(OBJS) $(DEFFILE) 153 | @-$(RM) $@ 154 | @-$(RM) $(TARGET).lib 155 | $(LDSHARED) -Fe$(@) $(OBJS) $(LIBS) $(LOCAL_LIBS) $(DLDFLAGS) 156 | 157 | $(STATIC_LIB): $(OBJS) 158 | $(AR) -machine:x86 -out:$@ $(OBJS) 159 | 160 | $(DEFFILE): 161 | $(RUBY) -e "puts 'EXPORTS', 'Init_$(TARGET)'" > $@ 162 | 163 | -------------------------------------------------------------------------------- /work/reference/console/README.txt: -------------------------------------------------------------------------------- 1 | 2 | This file implements a port of Perl's Win32::Console 3 | and Win32::Console::ANSI modules. 4 | 5 | Win32::Console allows controling the windows command line terminal 6 | thru an OO-interface. This allows you to query the terminal (find 7 | its size, characters, attributes, etc). The interface and functionality 8 | should be identical to Perl's. 9 | 10 | Win32::Console consists of a Ruby .rb interface. 11 | For best performance, this library has been also ported to C. 12 | If you lack a C compiler, you can still use the class thru the ruby 13 | interface. If you can compile it, then the ruby interface is not 14 | used and the C functions are called instead. 15 | 16 | Win32::Console::ANSI is a class derived from IO that seamlessly 17 | translates ANSI Esc control character codes into Windows' command.exe 18 | or cmd.exe equivalents. 19 | 20 | These modules allow you to develop command-line tools that can take 21 | advantage of the unix terminal functions while still being portable. 22 | One of the most common uses for this is to allow to color your 23 | output. 24 | The modules are disted with Term/ansicolor.rb, too, as it is a nice 25 | thing to verify it is working properly. 26 | 27 | -------------------------------------------------------------------------------- /work/reference/console/extconf.rb: -------------------------------------------------------------------------------- 1 | ################################################################# 2 | # 3 | # To compile and install, do this: 4 | # 5 | # Make sure your compiling environment is in your path. 6 | # In the case of MSVC, this involves running vcvars32.bat first 7 | # which is located in the bin directory of MS Visual C++. 8 | # 9 | # Then: 10 | # 11 | # > ruby extconf.rb 12 | # > nmake Makefile 13 | # > nmake install 14 | # 15 | # 16 | ################################################################## 17 | require 'mkmf' 18 | create_makefile('Console') 19 | -------------------------------------------------------------------------------- /work/reference/console/lib/Term/ansicolor.rb: -------------------------------------------------------------------------------- 1 | module Term 2 | 3 | module ANSIColor 4 | 5 | @@attributes = [ 6 | [ :clear , 0 ], 7 | [ :reset , 0 ], # synonym for :clear 8 | [ :bold , 1 ], 9 | [ :dark , 2 ], 10 | [ :italic , 3 ], # not widely implemented 11 | [ :underline , 4 ], 12 | [ :underscore , 4 ], # synonym for :underline 13 | [ :blink , 5 ], 14 | [ :rapid_blink , 6 ], # not widely implemented 15 | [ :negative , 7 ], # no reverse because of String#reverse 16 | [ :concealed , 8 ], 17 | [ :strikethrough, 9 ], # not widely implemented 18 | [ :black , 30 ], 19 | [ :red , 31 ], 20 | [ :green , 32 ], 21 | [ :yellow , 33 ], 22 | [ :blue , 34 ], 23 | [ :magenta , 35 ], 24 | [ :cyan , 36 ], 25 | [ :white , 37 ], 26 | [ :on_black , 40 ], 27 | [ :on_red , 41 ], 28 | [ :on_green , 42 ], 29 | [ :on_yellow , 43 ], 30 | [ :on_blue , 44 ], 31 | [ :on_magenta , 45 ], 32 | [ :on_cyan , 46 ], 33 | [ :on_white , 47 ], 34 | ] 35 | 36 | @@attributes.each do |c, v| 37 | eval %Q{ 38 | def #{c.to_s}(string = nil) 39 | result = "\e[#{v}m" 40 | if block_given? 41 | result << yield 42 | result << "\e[0m" 43 | elsif string 44 | result << string 45 | result << "\e[0m" 46 | elsif respond_to?(:to_str) 47 | result << self 48 | result << "\e[0m" 49 | end 50 | return result 51 | end 52 | } 53 | end 54 | 55 | ColoredRegexp = /\e\[([34][0-7]|[0-9])m/ 56 | def uncolored(string = nil) 57 | if block_given? 58 | yield.gsub(ColoredRegexp, '') 59 | elsif string 60 | string.gsub(ColoredRegexp, '') 61 | elsif respond_to?(:to_str) 62 | gsub(ColoredRegexp, '') 63 | else 64 | '' 65 | end 66 | end 67 | 68 | def attributes 69 | @@attributes.map { |c| c[0] } 70 | end 71 | module_function :attributes 72 | 73 | end 74 | 75 | end 76 | # vim: set cin sw=4 ts=4: 77 | -------------------------------------------------------------------------------- /work/reference/console/lib/Win32/Console.rb: -------------------------------------------------------------------------------- 1 | # Win32::Console: an object implementing the Win32 API Console functions 2 | # Copyright (C) 2003 Gonzalo Garramuno (ggarramuno@aol.com) 3 | # 4 | # Original Win32API_Console was: 5 | # Copyright (C) 2001 Michael L. Semon (mlsemon@sega.net) 6 | 7 | begin 8 | # If Console.so is available, use that. Otherwise, we define 9 | # equivalent functions in ruby (a tad slower) 10 | # That dll should define everything in an identical interface 11 | # to all the ruby code that the rescue below defines. 12 | require "Console.so" 13 | STDERR.print "Using faster, DLL Console.so\n" if $DEBUG 14 | 15 | rescue Exception 16 | 17 | STDERR.print "Using slower, non-DLL Console.rb\n" if $DEBUG 18 | 19 | module Win32 20 | class Console 21 | end 22 | end 23 | 24 | # The WINDOWS constants 25 | module Win32::Console::Constants 26 | STD_INPUT_HANDLE = 0xFFFFFFF6 27 | STD_OUTPUT_HANDLE = 0xFFFFFFF5 28 | STD_ERROR_HANDLE = 0xFFFFFFF4 29 | INVALID_HANDLE_VALUE = 0xFFFFFFFF 30 | GENERIC_READ = 0x80000000 31 | GENERIC_WRITE = 0x40000000 32 | FILE_SHARE_READ = 0x00000001 33 | FILE_SHARE_WRITE = 0x00000002 34 | CONSOLE_TEXTMODE_BUFFER = 0x00000001 35 | 36 | FOREGROUND_BLUE = 0x0001 37 | FOREGROUND_GREEN = 0x0002 38 | FOREGROUND_RED = 0x0004 39 | FOREGROUND_INTENSITY = 0x0008 40 | BACKGROUND_BLUE = 0x0010 41 | BACKGROUND_GREEN = 0x0020 42 | BACKGROUND_RED = 0x0040 43 | BACKGROUND_INTENSITY = 0x0080 44 | 45 | ENABLE_PROCESSED_INPUT = 0x0001 46 | ENABLE_LINE_INPUT = 0x0002 47 | ENABLE_ECHO_INPUT = 0x0004 48 | ENABLE_WINDOW_INPUT = 0x0008 49 | ENABLE_MOUSE_INPUT = 0x0010 50 | ENABLE_PROCESSED_OUTPUT = 0x0001 51 | ENABLE_WRAP_AT_EOL_OUTPUT = 0x0002 52 | 53 | KEY_EVENT = 0x0001 54 | MOUSE_EVENT = 0x0002 55 | WINDOW_BUFFER_SIZE_EVENT = 0x0004 56 | MENU_EVENT = 0x0008 57 | FOCUS_EVENT = 0x0010 58 | 59 | CAPSLOCK_ON = 0x0080 60 | ENHANCED_KEY = 0x0100 61 | NUMLOCK_ON = 0x0020 62 | SHIFT_PRESSED = 0x0010 63 | LEFT_CTRL_PRESSED = 0x0008 64 | RIGHT_CTRL_PRESSED = 0x0004 65 | LEFT_ALT_PRESSED = 0x0002 66 | RIGHT_ALT_PRESSED = 0x0001 67 | SCROLLLOCK_ON = 0x0040 68 | 69 | MOUSE_WHEELED = 0x0004 70 | DOUBLE_CLICK = 0x0002 71 | MOUSE_MOVED = 0x0001 72 | 73 | FROM_LEFT_1ST_BUTTON_PRESSED = 0x0001 74 | FROM_LEFT_2ND_BUTTON_PRESSED = 0x0004 75 | FROM_LEFT_3RD_BUTTON_PRESSED = 0x0008 76 | FROM_LEFT_4TH_BUTTON_PRESSED = 0x0010 77 | RIGHTMOST_BUTTON_PRESSED = 0x0002 78 | 79 | CTRL_C_EVENT = 0x0000 80 | CTRL_BREAK_EVENT = 0x0001 81 | CTRL_CLOSE_EVENT = 0x0002 82 | CTRL_LOGOFF_EVENT = 0x0005 83 | CTRL_SHUTDOWN_EVENT = 0x0006 84 | end 85 | 86 | # The actual api to access windows functions 87 | class Win32::Console::API 88 | require 'Win32API' 89 | 90 | private 91 | # This is a class-wide cache that will hold Win32API objects. As each 92 | # Win32API object is about 920 bytes, I didn't want to initialize all of 93 | # them at one time. That would waste about 42 kB for this object because 94 | # it has 47 functions. However, to not have a cache at all would reduce 95 | # the speed of this object by 164%. 96 | @@m_AllocConsole = nil 97 | @@m_CreateConsoleScreenBuffer = nil 98 | @@m_FillConsoleOutputAttribute = nil 99 | @@m_FillConsoleOutputCharacter = nil 100 | @@m_FlushConsoleInputBuffer = nil 101 | @@m_FreeConsole = nil 102 | @@m_GenerateConsoleCtrlEvent = nil 103 | @@m_GetConsoleCP = nil 104 | @@m_GetConsoleCursorInfo = nil 105 | @@m_GetConsoleMode = nil 106 | @@m_GetConsoleOutputCP = nil 107 | @@m_GetConsoleScreenBufferInfo = nil 108 | @@m_GetConsoleTitle = nil 109 | @@m_GetConsoleWindow = nil 110 | @@m_GetLargestConsoleWindowSize = nil 111 | @@m_GetNumberOfConsoleInputEvents = nil 112 | @@m_GetNumberOfConsoleMouseButtons = nil 113 | @@m_GetStdHandle = nil 114 | @@m_PeekConsoleInput = nil 115 | @@m_ReadConsole = nil 116 | @@m_ReadConsoleInput = nil 117 | @@m_ReadConsoleOutput = nil 118 | @@m_ReadConsoleOutputAttribute = nil 119 | @@m_ReadConsoleOutputCharacter = nil 120 | @@m_ScrollConsoleScreenBuffer = nil 121 | @@m_SetConsoleActiveScreenBuffer = nil 122 | @@m_SetConsoleCP = nil 123 | @@m_SetConsoleCursorInfo = nil 124 | @@m_SetConsoleCursorPosition = nil 125 | @@m_SetConsoleMode = nil 126 | @@m_SetConsoleOutputCP = nil 127 | @@m_SetConsoleScreenBufferSize = nil 128 | @@m_SetConsoleTextAttribute = nil 129 | @@m_SetConsoleTitle = nil 130 | @@m_SetConsoleWindowInfo = nil 131 | @@m_SetStdHandle = nil 132 | @@m_WriteConsole = nil 133 | @@m_WriteConsoleInput = nil 134 | @@m_WriteConsoleOutput = nil 135 | @@m_WriteConsoleOutputAttribute = nil 136 | @@m_WriteConsoleOutputCharacter = nil 137 | 138 | public 139 | 140 | class << self 141 | 142 | 143 | def constant(t) 144 | begin 145 | eval "return Win32::Console::Constants::#{t}" 146 | rescue 147 | return nil 148 | end 149 | end 150 | 151 | 152 | def AllocConsole() 153 | if @@m_AllocConsole == nil 154 | @@m_AllocConsole = Win32API.new( "kernel32", "AllocConsole", 155 | [], 'l' ) 156 | end 157 | @@m_AllocConsole.call() 158 | end 159 | 160 | def CreateConsoleScreenBuffer( dwDesiredAccess, dwShareMode, dwFlags ) 161 | if @@m_CreateConsoleScreenBuffer == nil 162 | @@m_CreateConsoleScreenBuffer = Win32API.new( "kernel32", "CreateConsoleScreenBuffer", ['l', 'l', 'p', 'l', 'p'], 'l' ) 163 | end 164 | @@m_CreateConsoleScreenBuffer.call( dwDesiredAccess, dwShareMode, 165 | nil, dwFlags, nil ) 166 | end 167 | 168 | 169 | 170 | def FillConsoleOutputAttribute( hConsoleOutput, wAttribute, nLength, 171 | col, row ) 172 | if @@m_FillConsoleOutputAttribute == nil 173 | @@m_FillConsoleOutputAttribute = Win32API.new( "kernel32", "FillConsoleOutputAttribute", ['l', 'i', 'l', 'l', 'p'], 'l' ) 174 | end 175 | dwWriteCoord = (row << 16) + col 176 | lpNumberOfAttrsWritten = ' ' * 4 177 | @@m_FillConsoleOutputAttribute.call( hConsoleOutput, wAttribute, 178 | nLength, dwWriteCoord, 179 | lpNumberOfAttrsWritten ) 180 | return lpNumberOfAttrsWritten.unpack('L') 181 | end 182 | 183 | 184 | 185 | def FillConsoleOutputCharacter( hConsoleOutput, cCharacter, nLength, 186 | col, row ) 187 | if @@m_FillConsoleOutputCharacter == nil 188 | @@m_FillConsoleOutputCharacter = Win32API.new( "kernel32", "FillConsoleOutputCharacter", ['l', 'i', 'l', 'l', 'p'], 'l' ) 189 | end 190 | dwWriteCoord = (row << 16) + col 191 | lpNumberOfAttrsWritten = ' ' * 4 192 | @@m_FillConsoleOutputCharacter.call( hConsoleOutput, cCharacter, 193 | nLength, dwWriteCoord, 194 | lpNumberOfAttrsWritten ) 195 | return lpNumberOfAttrsWritten.unpack('L') 196 | end 197 | 198 | 199 | def FlushConsoleInputBuffer( hConsoleInput ) 200 | if @@m_FlushConsoleInputBuffer == nil 201 | @@m_FlushConsoleInputBuffer = Win32API.new( "kernel32", 202 | "FillConsoleInputBuffer", 203 | ['l'], 'l' ) 204 | end 205 | @@m_FlushConsoleInputBuffer.call( hConsoleInput ) 206 | end 207 | 208 | 209 | def FreeConsole() 210 | if @@m_FreeConsole == nil 211 | @@m_FreeConsole = Win32API.new( "kernel32", "FreeConsole", [], 'l' ) 212 | end 213 | @@m_FreeConsole.call() 214 | end 215 | 216 | 217 | def GenerateConsoleCtrlEvent( dwCtrlEvent, dwProcessGroupId ) 218 | if @@m_GenerateConsoleCtrlEvent == nil 219 | @@m_GenerateConsoleCtrlEvent = Win32API.new( "kernel32", "GenerateConsoleCtrlEvent", ['l', 'l'], 'l' ) 220 | end 221 | @@m_GenerateConsoleCtrlEvent.call( dwCtrlEvent, dwProcessGroupId ) 222 | end 223 | 224 | def GetConsoleCP() 225 | if @@m_GetConsoleCP == nil 226 | @@m_GetConsoleCP = Win32API.new( "kernel32", "GetConsoleCP", 227 | [], 'l' ) 228 | end 229 | @@m_GetConsoleCP.call() 230 | end 231 | 232 | def GetConsoleCursorInfo( hConsoleOutput ) 233 | if @@m_GetConsoleCursorInfo == nil 234 | @@m_GetConsoleCursorInfo = Win32API.new( "kernel32", 235 | "GetConsoleCursorInfo", 236 | ['l', 'p'], 'l' ) 237 | end 238 | lpConsoleCursorInfo = ' ' * 8 239 | @@m_GetConsoleCursorInfo.call( hConsoleOutput, lpConsoleCursorInfo ) 240 | return lpConsoleCursorInfo.unpack('LL') 241 | end 242 | 243 | def GetConsoleMode( hConsoleHandle ) 244 | if @@m_GetConsoleMode == nil 245 | @@m_GetConsoleMode = Win32API.new( "kernel32", "GetConsoleMode", 246 | ['l', 'p'], 'l' ) 247 | end 248 | lpMode = ' ' * 4 249 | @@m_GetConsoleMode.call( hConsoleHandle, lpMode ) 250 | return lpMode.unpack('L') 251 | end 252 | 253 | def GetConsoleOutputCP() 254 | if @@m_GetConsoleOutputCP == nil 255 | @@m_GetConsoleOutputCP = Win32API.new( "kernel32", 256 | "GetConsoleOutputCP", [], 'l' ) 257 | end 258 | @@m_GetConsoleOutputCP.call() 259 | end 260 | 261 | def GetConsoleScreenBufferInfo( hConsoleOutput ) 262 | if @@m_GetConsoleScreenBufferInfo == nil 263 | @@m_GetConsoleScreenBufferInfo = Win32API.new( "kernel32", "GetConsoleScreenBufferInfo", ['l', 'p'], 'l' ) 264 | end 265 | lpBuffer = ' ' * 22 266 | @@m_GetConsoleScreenBufferInfo.call( hConsoleOutput, lpBuffer ) 267 | return lpBuffer.unpack('SSSSSssssSS') 268 | end 269 | 270 | def GetConsoleTitle() 271 | if @@m_GetConsoleTitle == nil 272 | @@m_GetConsoleTitle = Win32API.new( "kernel32", "GetConsoleTitle", 273 | ['p', 'l'], 'l' ) 274 | end 275 | nSize = 120 276 | lpConsoleTitle = ' ' * nSize 277 | @@m_GetConsoleTitle.call( lpConsoleTitle, nSize ) 278 | return lpConsoleTitle.strip 279 | end 280 | 281 | def GetConsoleWindow() 282 | if @@m_GetConsoleWindow == nil 283 | @@m_GetConsoleWindow = Win32API.new( "kernel32", "GetConsoleWindow", 284 | [], 'l' ) 285 | end 286 | @@m_GetConsoleWindow.call() 287 | end 288 | 289 | def GetLargestConsoleWindowSize( hConsoleOutput ) 290 | if @@m_GetLargestConsoleWindowSize == nil 291 | @@m_GetLargestConsoleWindowSize = Win32API.new( "kernel32", "GetLargestConsoleWindowSize", ['l'], 'l' ) 292 | end 293 | coord = @@m_GetLargestConsoleWindowSize.call( hConsoleOutput ) 294 | x = coord >> 16 295 | y = coord & 0x0000ffff 296 | return [x,y] 297 | end 298 | 299 | def GetNumberOfConsoleInputEvents( hConsoleInput ) 300 | if @@m_GetNumberOfConsoleInputEvents == nil 301 | @@m_GetNumberOfConsoleInputEvents = Win32API.new( "kernel32", "GetNumberOfConsoleInputEvents", ['l', 'p'], 'l' ) 302 | end 303 | lpcNumberOfEvents = 0 304 | @@m_GetNumberOfConsoleInputEvents.call( hConsoleInput, 305 | lpcNumberOfEvents ) 306 | return lpcNumberOfEvents 307 | end 308 | 309 | def GetNumberOfConsoleMouseButtons( ) 310 | if @@m_GetNumberOfConsoleMouseButtons == nil 311 | @@m_GetNumberOfConsoleMouseButtons = Win32API.new( "kernel32", "GetNumberOfConsoleMouseButtons", ['p'], 'l' ) 312 | end 313 | lpNumberOfMouseButtons = 0 314 | @@m_GetNumberOfConsoleMouseButtons.call( lpNumberOfMouseButtons ) 315 | return lpNumberOfMouseButtons 316 | end 317 | 318 | def GetStdHandle( nStdHandle ) 319 | if @@m_GetStdHandle == nil 320 | @@m_GetStdHandle = Win32API.new( "kernel32", "GetStdHandle", 321 | ['l'], 'l' ) 322 | end 323 | @@m_GetStdHandle.call( nStdHandle ) 324 | end 325 | 326 | # <> : This is not an actual API function, just a concept description in the SDK. 327 | 328 | def PeekConsoleInput( hConsoleInput ) 329 | if @@m_PeekConsoleInput == nil 330 | @@m_PeekConsoleInput = Win32API.new( "kernel32", "PeekConsoleInput", 331 | ['l', 'p', 'l', 'p'], 'l' ) 332 | end 333 | lpNumberOfEventsRead = ' ' * 4 334 | lpBuffer = ' ' * 20 335 | nLength = 20 336 | @@m_PeekConsoleInput.call( hConsoleInput, lpBuffer, nLength, 337 | lpNumberOfEventsRead ) 338 | type = lpBuffer.unpack('s')[0] 339 | 340 | case type 341 | when KEY_EVENT 342 | return lpBuffer.unpack('sSSSSCS') 343 | when MOUSE_EVENT 344 | return lpBuffer.unpack('sSSSS') 345 | when WINDOW_BUFFER_SIZE_EVENT 346 | return lpBuffer.unpack('sS') 347 | when MENU_EVENT 348 | return lpBuffer.unpack('sS') 349 | when FOCUS_EVENT 350 | return lpBuffer.unpack('sS') 351 | else 352 | return [] 353 | end 354 | end 355 | 356 | def ReadConsole( hConsoleInput, lpBuffer, nNumberOfCharsToRead ) 357 | if @@m_ReadConsole == nil 358 | @@m_ReadConsole = Win32API.new( "kernel32", "ReadConsole", 359 | ['l', 'p', 'l', 'p', 'p'], 'l' ) 360 | end 361 | lpBuffer = ' ' * nNumberOfCharsToRead unless lpBuffer 362 | lpNumberOfCharsRead = ' ' * 4 363 | lpReserved = ' ' * 4 364 | @@m_ReadConsole.call( hConsoleInput, lpBuffer, nNumberOfCharsToRead, 365 | lpNumberOfCharsRead, lpReserved ) 366 | return lpNumberOfCharsRead.unpack('L') 367 | end 368 | 369 | def ReadConsoleInput( hConsoleInput ) 370 | if @@m_ReadConsoleInput == nil 371 | @@m_ReadConsoleInput = Win32API.new( "kernel32", "ReadConsoleInput", 372 | ['l', 'p', 'l', 'p'], 'l' ) 373 | end 374 | lpNumberOfEventsRead = ' ' * 4 375 | lpBuffer = ' ' * 20 376 | nLength = 20 377 | @@m_ReadConsoleInput.call( hConsoleInput, lpBuffer, nLength, 378 | lpNumberOfEventsRead ) 379 | type = lpBuffer.unpack('s')[0] 380 | 381 | case type 382 | when KEY_EVENT 383 | return lpBuffer.unpack('sSSSSCS') 384 | when MOUSE_EVENT 385 | return lpBuffer.unpack('sSSSS') 386 | when WINDOW_BUFFER_SIZE_EVENT 387 | return lpBuffer.unpack('sS') 388 | when MENU_EVENT 389 | return lpBuffer.unpack('sS') 390 | when FOCUS_EVENT 391 | return lpBuffer.unpack('sS') 392 | else 393 | return [] 394 | end 395 | end 396 | 397 | def ReadConsoleOutput( hConsoleOutput, lpBuffer, cols, rows, 398 | bufx, bufy, left, top, right, bottom ) 399 | if @@m_ReadConsoleOutput == nil 400 | @@m_ReadConsoleOutput = Win32API.new( "kernel32", 401 | "ReadConsoleOutput", 402 | ['l', 'p', 'l', 'l', 'p'], 'l' ) 403 | end 404 | dwBufferSize = cols * rows * 4 405 | lpBuffer = ' ' * dwBufferSize 406 | dwBufferCoord = (bufy << 16) + bufx 407 | lpReadRegion = [ left, top, right, bottom ].pack('ssss') 408 | @@m_ReadConsoleOutput.call( hConsoleOutput, lpBuffer, dwBufferSize, 409 | dwBufferCoord, lpReadRegion ) 410 | end 411 | 412 | def ReadConsoleOutputAttribute( hConsoleOutput, nLength, col, row ) 413 | if @@m_ReadConsoleOutputAttribute == nil 414 | @@m_ReadConsoleOutputAttribute = Win32API.new( "kernel32", "ReadConsoleOutputAttribute", ['l', 'p', 'l', 'l', 'p'], 'l' ) 415 | end 416 | lpAttribute = ' ' * nLength 417 | dwReadCoord = (row << 16) + col 418 | lpNumberOfAttrsRead = ' ' * 4 419 | @@m_ReadConsoleOutputAttribute.call( hConsoleOutput, lpAttribute, 420 | nLength, dwReadCoord, 421 | lpNumberOfAttrsRead ) 422 | return lpAttribute 423 | end 424 | 425 | def ReadConsoleOutputCharacter( hConsoleOutput, lpCharacter, nLength, 426 | col, row ) 427 | if @@m_ReadConsoleOutputCharacter == nil 428 | @@m_ReadConsoleOutputCharacter = Win32API.new( "kernel32", "ReadConsoleOutputCharacter", ['l', 'p', 'l', 'l', 'p'], 'l' ) 429 | end 430 | dwReadCoord = (row << 16) + col 431 | lpNumberOfCharsRead = ' ' * 4 432 | @@m_ReadConsoleOutputCharacter.call( hConsoleOutput, lpCharacter, 433 | nLength, dwReadCoord, 434 | lpNumberOfCharsRead ) 435 | return lpNumberOfCharsRead.unpack('L') 436 | end 437 | 438 | def ScrollConsoleScreenBuffer( hConsoleOutput, 439 | left1, top1, right1, bottom1, 440 | col, row, char, attr, 441 | left2, top2, right2, bottom2 ) 442 | if @@m_ScrollConsoleScreenBuffer == nil 443 | @@m_ScrollConsoleScreenBuffer = Win32API.new( "kernel32", "ScrollConsoleScreenBuffer", ['l', 'p', 'p', 'l', 'p'], 'l' ) 444 | end 445 | lpScrollRectangle = [left1, top1, right1, bottom1].pack('ssss') 446 | lpClipRectangle = [left2, top2, right2, bottom2].pack('ssss') 447 | dwDestinationOrigin = (row << 16) + col 448 | lpFill = [char, attr].pack('ss') 449 | @@m_ScrollConsoleScreenBuffer.call( hConsoleOutput, lpScrollRectangle, 450 | lpClipRectangle, 451 | dwDestinationOrigin, lpFill ) 452 | end 453 | 454 | def SetConsoleActiveScreenBuffer( hConsoleOutput ) 455 | if @@m_SetConsoleActiveScreenBuffer == nil 456 | @@m_SetConsoleActiveScreenBuffer = Win32API.new( "kernel32", "SetConsoleActiveScreenBuffer", ['l'], 'l' ) 457 | end 458 | @@m_SetConsoleActiveScreenBuffer.call( hConsoleOutput ) 459 | end 460 | 461 | # < >: Will probably not be implemented. 462 | 463 | def SetConsoleCP( wCodePageID ) 464 | if @@m_SetConsoleCP == nil 465 | @@m_SetConsoleCP = Win32API.new( "kernel32", "SetConsoleCP", 466 | ['l'], 'l' ) 467 | end 468 | @@m_SetConsoleCP.call( wCodePageID ) 469 | end 470 | 471 | def SetConsoleCursorInfo( hConsoleOutput, col, row ) 472 | if @@m_SetConsoleCursorInfo == nil 473 | @@m_SetConsoleCursorInfo = Win32API.new( "kernel32", 474 | "SetConsoleCursorInfo", 475 | ['l', 'p'], 'l' ) 476 | end 477 | lpConsoleCursorInfo = [size,visi].pack('LL') 478 | @@m_SetConsoleCursorInfo.call( hConsoleOutput, lpConsoleCursorInfo ) 479 | end 480 | 481 | def SetConsoleCursorPosition( hConsoleOutput, col, row ) 482 | if @@m_SetConsoleCursorPosition == nil 483 | @@m_SetConsoleCursorPosition = Win32API.new( "kernel32", "SetConsoleCursorPosition", ['l', 'p'], 'l' ) 484 | end 485 | dwCursorPosition = (row << 16) + col 486 | @@m_SetConsoleCursorPosition.call( hConsoleOutput, dwCursorPosition ) 487 | end 488 | 489 | def SetConsoleMode( hConsoleHandle, lpMode ) 490 | if @@m_SetConsoleMode == nil 491 | @@m_SetConsoleMode = Win32API.new( "kernel32", "SetConsoleMode", 492 | ['l', 'p'], 'l' ) 493 | end 494 | @@m_SetConsoleMode.call( hConsoleHandle, lpMode ) 495 | end 496 | 497 | def SetConsoleOutputCP( wCodePageID ) 498 | if @@m_SetConsoleOutputCP == nil 499 | @@m_SetConsoleOutputCP = Win32API.new( "kernel32", 500 | "GetConsoleOutputCP", 501 | ['l'], 'l' ) 502 | end 503 | @@m_SetConsoleOutputCP.call( wCodePageID ) 504 | end 505 | 506 | def SetConsoleScreenBufferSize( hConsoleOutput, col, row ) 507 | if @@m_SetConsoleScreenBufferSize == nil 508 | @@m_SetConsoleScreenBufferSize = Win32API.new( "kernel32", "SetConsoleScreenBufferSize", ['l', 'l'], 'l' ) 509 | end 510 | dwSize = (row << 16) + col 511 | @@m_SetConsoleScreenBufferSize.call( hConsoleOutput, dwSize ) 512 | end 513 | 514 | def SetConsoleTextAttribute( hConsoleOutput, wAttributes ) 515 | if @@m_SetConsoleTextAttribute == nil 516 | @@m_SetConsoleTextAttribute = Win32API.new( "kernel32", "SetConsoleTextAttribute", ['l', 'i'], 'l' ) 517 | end 518 | @@m_SetConsoleTextAttribute.call( hConsoleOutput, wAttributes ) 519 | end 520 | 521 | def SetConsoleTitle( lpConsoleTitle ) 522 | if @@m_SetConsoleTitle == nil 523 | @@m_SetConsoleTitle = Win32API.new( "kernel32", "SetConsoleTitle", 524 | ['p'], 'l' ) 525 | end 526 | @@m_SetConsoleTitle.call( lpConsoleTitle ) 527 | end 528 | 529 | def SetConsoleWindowInfo( hConsoleOutput, bAbsolute, 530 | left, top, right, bottom ) 531 | if @@m_SetConsoleWindowInfo == nil 532 | @@m_SetConsoleWindowInfo = Win32API.new( "kernel32", 533 | "SetConsoleWindowInfo", 534 | ['l', 'l', 'p'], 'l' ) 535 | end 536 | lpConsoleWindow = [ left, top, right, bottom ].pack('ssss') 537 | @@m_SetConsoleWindowInfo.call( hConsoleOutput, bAbsolute, 538 | lpConsoleWindow ) 539 | end 540 | 541 | def SetStdHandle( nStdHandle, hHandle ) 542 | if @@m_SetStdHandle == nil 543 | @@m_SetStdHandle = Win32API.new( "kernel32", "SetStdHandle", 544 | ['l', 'l'], 'l' ) 545 | end 546 | @@m_SetStdHandle.call( nStdHandle, hHandle ) 547 | end 548 | 549 | def WriteConsole( hConsoleOutput, lpBuffer ) 550 | if @@m_WriteConsole == nil 551 | @@m_WriteConsole = Win32API.new( "kernel32", "WriteConsole", 552 | ['l', 'p', 'l', 'p', 'p'], 'l' ) 553 | end 554 | nNumberOfCharsToWrite = lpBuffer.length() 555 | lpNumberOfCharsWritten = ' ' * 4 556 | lpReserved = ' ' * 4 557 | @@m_WriteConsole.call( hConsoleOutput, lpBuffer, nNumberOfCharsToWrite, 558 | lpNumberOfCharsWritten, lpReserved ) 559 | return lpNumberOfCharsWritten 560 | end 561 | 562 | def WriteConsoleInput( hConsoleInput, lpBuffer ) 563 | if @@m_WriteConsoleInput == nil 564 | @@m_WriteConsoleInput = Win32API.new( "kernel32", "WriteConsoleInput", ['l', 'p', 'l', 'p'], 'l' ) 565 | end 566 | @@m_WriteConsoleInput.call( hConsoleInput, lpBuffer, nLength, 567 | lpNumberOfEventsWritten ) 568 | end 569 | 570 | # @@ Todo: Test this 571 | def WriteConsoleOutput( hConsoleOutput, buffer, cols, rows, 572 | bufx, bufy, left, top, right, bottom ) 573 | if @@m_WriteConsoleOutput == nil 574 | @@m_WriteConsoleOutput = Win32API.new( "kernel32", "WriteConsoleOutput", ['l', 'p', 'l', 'l', 'p'], 'l' ) 575 | end 576 | lpBuffer = buffer.flatten.pack('ss' * buffer.length() * 2) 577 | dwBufferSize = (buffer.length() << 16) + 2 578 | dwBufferCoord = (row << 16) + col 579 | lpWriteRegion = [ left, top, right, bottom ].pack('ssss') 580 | @@m_WriteConsoleOutput.call( hConsoleOutput, lpBuffer, dwBufferSize, 581 | dwBufferCoord, lpWriteRegion ) 582 | end 583 | 584 | def WriteConsoleOutputAttribute( hConsoleOutput, lpAttribute, col, row ) 585 | if @@m_WriteConsoleOutputAttribute == nil 586 | @@m_WriteConsoleOutputAttribute = Win32API.new( "kernel32", "WriteConsoleOutputAttribute", ['l', 'p', 'l', 'l', 'p'], 'l' ) 587 | end 588 | nLength = lpAttribute.length() 589 | dwWriteCoord = (row << 16) + col 590 | lpNumberOfAttrsWritten = ' ' * 4 591 | @@m_WriteConsoleOutputAttribute.call( hConsoleOutput, lpAttribute, 592 | nLength, dwWriteCoord, 593 | lpNumberOfAttrsWritten ) 594 | return lpNumberOfAttrsWritten.unpack('L') 595 | end 596 | 597 | def WriteConsoleOutputCharacter( hConsoleOutput, lpCharacter, col, row ) 598 | if @@m_WriteConsoleOutputCharacter == nil 599 | @@m_WriteConsoleOutputCharacter = Win32API.new( "kernel32", "WriteConsoleOutputCharacter", ['l', 'p', 'l', 'l', 'p'], 'l' ) 600 | end 601 | nLength = lpCharacter.length() 602 | dwWriteCoord = (row << 16) + col 603 | lpNumberOfCharsWritten = ' ' * 4 604 | @@m_WriteConsoleOutputCharacter.call( hConsoleOutput, lpCharacter, 605 | nLength, dwWriteCoord, 606 | lpNumberOfCharsWritten ) 607 | return lpNumberOfCharsWritten.unpack('L') 608 | end 609 | 610 | end 611 | end 612 | 613 | end # rescue 614 | 615 | 616 | 617 | module Win32 618 | class Console 619 | 620 | VERSION = '1.0' 621 | 622 | include Win32::Console::Constants 623 | 624 | def initialize( t = nil ) 625 | if t and ( t == STD_INPUT_HANDLE or t == STD_OUTPUT_HANDLE or 626 | t == STD_ERROR_HANDLE ) 627 | @handle = API.GetStdHandle( t ) 628 | else 629 | param1 = GENERIC_READ | GENERIC_WRITE 630 | param2 = FILE_SHARE_READ | FILE_SHARE_WRITE 631 | @handle = API.CreateConsoleScreenBuffer( param1, param2, 632 | CONSOLE_TEXTMODE_BUFFER ) 633 | end 634 | end 635 | 636 | 637 | def Display 638 | return API.SetConsoleActiveScreenBuffer(@handle) 639 | end 640 | 641 | def Select(type) 642 | return API.SetStdHandle(type,@handle) 643 | end 644 | 645 | def Title(title = nil) 646 | if title 647 | return API.SetConsoleTitle(title) 648 | else 649 | return API.GetConsoleTitle() 650 | end 651 | end 652 | 653 | def WriteChar(s, col, row) 654 | API.WriteConsoleOutputCharacter( @handle, s, col, row ) 655 | end 656 | 657 | def ReadChar(size, col, row) 658 | buffer = ' ' * size 659 | if API.ReadConsoleOutputCharacter( @handle, buffer, size, col, row ) 660 | return buffer 661 | else 662 | return nil 663 | end 664 | end 665 | 666 | def WriteAttr(attr, col, row) 667 | API.WriteConsoleOutputAttribute( @handle, attr, col, row ) 668 | end 669 | 670 | def ReadAttr(size, col, row) 671 | x = API.ReadConsoleOutputAttribute( @handle, size, col, row ) 672 | return x.unpack('c'*size) 673 | end 674 | 675 | 676 | def Cursor(*t) 677 | col, row, size, visi = t 678 | if col 679 | row = -1 if !row 680 | if col < 0 or row < 0 681 | curr_col, curr_row = API.GetConsoleScreenBufferInfo(@handle) 682 | col = curr_col if col < 0 683 | row = curr_row if row < 0 684 | end 685 | API.SetConsoleCursorPosition( @handle, col, row ) 686 | if size and visi 687 | curr_size, curr_visi = API.GetConsoleCursorInfo( @handle ) 688 | size = curr_size if size < 0 689 | visi = curr_visi if visi < 0 690 | size = 1 if size < 1 691 | size = 99 if size > 99 692 | API.SetConsoleCursorInfo( @handle, size, visi ) 693 | end 694 | else 695 | d, d, curr_col, curr_row = API.GetConsoleScreenBufferInfo(@handle) 696 | curr_size, curr_visi = API.GetConsoleCursorInfo( @handle ) 697 | return [ curr_col, curr_row, curr_size, curr_visi ] 698 | end 699 | end 700 | 701 | def Write(s) 702 | API.WriteConsole( @handle, s ) 703 | end 704 | 705 | def ReadRect( left, top, right, bottom ) 706 | col = right - left + 1 707 | row = bottom - top + 1 708 | size = col * row 709 | buffer = ' ' * size * 4 710 | if API.ReadConsoleOutput( @handle, buffer, col, row, 0, 0, 711 | left, top, right, bottom ) 712 | #return buffer.unpack('US'*size) # for unicode 713 | return buffer.unpack('axS'*size) # for ascii 714 | else 715 | return nil 716 | end 717 | end 718 | 719 | def WriteRect( buffer, left, top, right, bottom ) 720 | col = right - left + 1 721 | row = bottom - top + 1 722 | API.WriteConsoleOutput( @handle, buffer, col, row, 0, 0, 723 | left, top, right, bottom ) 724 | end 725 | 726 | 727 | 728 | def Scroll( left1, top1, right1, bottom1, 729 | col, row, char, attr, 730 | left2, top2, right2, bottom2 ) 731 | API.ScrollConsoleScreenBuffer(@handle, left1, top1, right1, bottom1, 732 | col, row, char, attr, 733 | left2, top2, right2, bottom2) 734 | end 735 | 736 | 737 | def MaxWindow(flag = nil) 738 | if !flag 739 | info = API.GetConsoleScreenBufferInfo(@handle) 740 | return info[9], info[10] 741 | else 742 | return API.GetLargestConsoleWindowSize(@handle) 743 | end 744 | end 745 | 746 | 747 | def Info() 748 | return API.GetConsoleScreenBufferInfo( @handle ) 749 | end 750 | 751 | 752 | def GetEvents() 753 | return API.GetNumberOfConsoleInputEvents(@handle) 754 | end 755 | 756 | 757 | def Flush() 758 | return API.FlushConsoleInputBuffer(@handle) 759 | end 760 | 761 | def InputChar(number = nil) 762 | number = 1 unless number 763 | buffer = ' ' * number 764 | if API.ReadConsole(@handle, buffer, number) == number 765 | return buffer 766 | else 767 | return nil 768 | end 769 | end 770 | 771 | 772 | def Input() 773 | API.ReadConsoleInput(@handle) 774 | end 775 | 776 | 777 | def PeekInput() 778 | API.PeekConsoleInput(@handle) 779 | end 780 | 781 | 782 | def Mode(mode = nil) 783 | if mode 784 | mode = mode.pack('L') if mode === Array 785 | API.SetConsoleMode(@handle, mode) 786 | else 787 | return API.GetConsoleMode(@handle) 788 | end 789 | end 790 | 791 | def WriteInput(*t) 792 | API.WriteConsoleInput(@handle, *t) 793 | end 794 | 795 | def Attr(*attr) 796 | if attr.size > 0 797 | API.SetConsoleTextAttribute( @handle, attr[0] ) 798 | else 799 | info = API.GetConsoleScreenBufferInfo( @handle ) 800 | return info[4] 801 | end 802 | end 803 | 804 | 805 | def Size(*t) 806 | if t.size == 0 807 | col, row = API.GetConsoleScreenBufferInfo(@handle ) 808 | return [col, row] 809 | else 810 | row = -1 if !t[1] 811 | col = -1 if !t[0] 812 | if col < 0 or row < 0 813 | curr_col, curr_row = Size() 814 | col = curr_col if col < 0 815 | row = curr_row if row < 0 816 | end 817 | API.SetConsoleScreenBufferSize(@handle, row, col) 818 | end 819 | end 820 | 821 | def Window(*t) 822 | if t.size != 5 823 | info = API.GetConsoleScreenBufferInfo( @handle ) 824 | return info[5..8] 825 | else 826 | API.SetConsoleWindowInfo(@handle, t[0], t[1], t[2], t[3], t[4]) 827 | end 828 | end 829 | 830 | def FillAttr(attr, number = 1, col = -1, row = -1) 831 | if col < 0 or row < 0 832 | d, d, curr_col, curr_row = API.GetConsoleScreenBufferInfo(@handle) 833 | col = curr_col if col < 0 834 | row = curr_row if row < 0 835 | end 836 | API.FillConsoleOutputAttribute(@handle, attr, number, col, row) 837 | end 838 | 839 | def FillChar(char, number, col = -1, row = -1) 840 | if col < 0 or row < 0 841 | d, d, curr_col, curr_row = API.GetConsoleScreenBufferInfo(@handle) 842 | col = curr_col if col < 0 843 | row = curr_row if row < 0 844 | end 845 | API.FillConsoleOutputCharacter(@handle, char[0], number, col, row) 846 | end 847 | 848 | def Cls() 849 | attr = ATTR_NORMAL 850 | x, y = Size() 851 | left, top, right , bottom = Window() 852 | vx = right - left 853 | vy = bottom - top 854 | FillChar(' ', x*y, 0, 0) 855 | FillAttr(attr, x*y, 0, 0) 856 | Cursor(0,0) 857 | Window(1,0,0,vx,vy) 858 | end 859 | 860 | def Console.Free() 861 | API.FreeConsole() 862 | end 863 | 864 | def Console.Alloc() 865 | API.AllocConsole() 866 | end 867 | 868 | def Console.MouseButtons() 869 | API.GetNumberOfConsoleMouseButtons() 870 | end 871 | 872 | def Console.InputCP(codepage=nil) 873 | if codepage 874 | API.SetConsoleCP(codepage) 875 | else 876 | return API.GetConsoleCP() 877 | end 878 | end 879 | 880 | def Console.OutputCP(codepage=nil) 881 | if codepage 882 | API.SetConsoleOutputCP(codepage) 883 | else 884 | return API.GetConsoleOutputCP() 885 | end 886 | end 887 | 888 | def Console.GenerateCtrlEvent( type=nil, pid=nil ) 889 | type = API.constant('CTRL_C_EVENT') if type == nil 890 | pid = 0 if pid == nil 891 | API.GenerateConsoleCtrlEvent(type, pid) 892 | end 893 | 894 | end 895 | end 896 | 897 | 898 | 899 | 900 | 901 | FG_BLACK = 0 902 | FG_BLUE = Win32::Console::API.constant("FOREGROUND_BLUE") 903 | FG_LIGHTBLUE = Win32::Console::API.constant("FOREGROUND_BLUE")| 904 | Win32::Console::API.constant("FOREGROUND_INTENSITY") 905 | FG_RED = Win32::Console::API.constant("FOREGROUND_RED") 906 | FG_LIGHTRED = Win32::Console::API.constant("FOREGROUND_RED")| 907 | Win32::Console::API.constant("FOREGROUND_INTENSITY") 908 | FG_GREEN = Win32::Console::API.constant("FOREGROUND_GREEN") 909 | FG_LIGHTGREEN = Win32::Console::API.constant("FOREGROUND_GREEN")| 910 | Win32::Console::API.constant("FOREGROUND_INTENSITY") 911 | FG_MAGENTA = Win32::Console::API.constant("FOREGROUND_RED")| 912 | Win32::Console::API.constant("FOREGROUND_BLUE") 913 | FG_LIGHTMAGENTA = Win32::Console::API.constant("FOREGROUND_RED")| 914 | Win32::Console::API.constant("FOREGROUND_BLUE")| 915 | Win32::Console::API.constant("FOREGROUND_INTENSITY") 916 | FG_CYAN = Win32::Console::API.constant("FOREGROUND_GREEN")| 917 | Win32::Console::API.constant("FOREGROUND_BLUE") 918 | FG_LIGHTCYAN = Win32::Console::API.constant("FOREGROUND_GREEN")| 919 | Win32::Console::API.constant("FOREGROUND_BLUE")| 920 | Win32::Console::API.constant("FOREGROUND_INTENSITY") 921 | FG_BROWN = Win32::Console::API.constant("FOREGROUND_RED")| 922 | Win32::Console::API.constant("FOREGROUND_GREEN") 923 | FG_YELLOW = Win32::Console::API.constant("FOREGROUND_RED")| 924 | Win32::Console::API.constant("FOREGROUND_GREEN")| 925 | Win32::Console::API.constant("FOREGROUND_INTENSITY") 926 | FG_GRAY = Win32::Console::API.constant("FOREGROUND_RED")| 927 | Win32::Console::API.constant("FOREGROUND_GREEN")| 928 | Win32::Console::API.constant("FOREGROUND_BLUE") 929 | FG_WHITE = Win32::Console::API.constant("FOREGROUND_RED")| 930 | Win32::Console::API.constant("FOREGROUND_GREEN")| 931 | Win32::Console::API.constant("FOREGROUND_BLUE")| 932 | Win32::Console::API.constant("FOREGROUND_INTENSITY") 933 | 934 | BG_BLACK = 0 935 | BG_BLUE = Win32::Console::API.constant("BACKGROUND_BLUE") 936 | BG_LIGHTBLUE = Win32::Console::API.constant("BACKGROUND_BLUE")| 937 | Win32::Console::API.constant("BACKGROUND_INTENSITY") 938 | BG_RED = Win32::Console::API.constant("BACKGROUND_RED") 939 | BG_LIGHTRED = Win32::Console::API.constant("BACKGROUND_RED")| 940 | Win32::Console::API.constant("BACKGROUND_INTENSITY") 941 | BG_GREEN = Win32::Console::API.constant("BACKGROUND_GREEN") 942 | BG_LIGHTGREEN = Win32::Console::API.constant("BACKGROUND_GREEN")| 943 | Win32::Console::API.constant("BACKGROUND_INTENSITY") 944 | BG_MAGENTA = Win32::Console::API.constant("BACKGROUND_RED")| 945 | Win32::Console::API.constant("BACKGROUND_BLUE") 946 | BG_LIGHTMAGENTA = Win32::Console::API.constant("BACKGROUND_RED")| 947 | Win32::Console::API.constant("BACKGROUND_BLUE")| 948 | Win32::Console::API.constant("BACKGROUND_INTENSITY") 949 | BG_CYAN = Win32::Console::API.constant("BACKGROUND_GREEN")| 950 | Win32::Console::API.constant("BACKGROUND_BLUE") 951 | BG_LIGHTCYAN = Win32::Console::API.constant("BACKGROUND_GREEN")| 952 | Win32::Console::API.constant("BACKGROUND_BLUE")| 953 | Win32::Console::API.constant("BACKGROUND_INTENSITY") 954 | BG_BROWN = Win32::Console::API.constant("BACKGROUND_RED")| 955 | Win32::Console::API.constant("BACKGROUND_GREEN") 956 | BG_YELLOW = Win32::Console::API.constant("BACKGROUND_RED")| 957 | Win32::Console::API.constant("BACKGROUND_GREEN")| 958 | Win32::Console::API.constant("BACKGROUND_INTENSITY") 959 | BG_GRAY = Win32::Console::API.constant("BACKGROUND_RED")| 960 | Win32::Console::API.constant("BACKGROUND_GREEN")| 961 | Win32::Console::API.constant("BACKGROUND_BLUE") 962 | BG_WHITE = Win32::Console::API.constant("BACKGROUND_RED")| 963 | Win32::Console::API.constant("BACKGROUND_GREEN")| 964 | Win32::Console::API.constant("BACKGROUND_BLUE")| 965 | Win32::Console::API.constant("BACKGROUND_INTENSITY") 966 | 967 | ATTR_NORMAL = FG_GRAY | BG_BLACK 968 | ATTR_INVERSE = FG_BLACK | BG_GRAY 969 | 970 | include Win32::Console::Constants 971 | -------------------------------------------------------------------------------- /work/reference/console/lib/Win32/Console/ANSI.rb: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/rubyworks/ansi/17002348d45ce9298a1a4017dc43d3cf65151bd4/work/reference/console/lib/Win32/Console/ANSI.rb -------------------------------------------------------------------------------- /work/reference/console/test/test_cursor.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | require "Win32/Console" 4 | 5 | 6 | a = Win32::Console.new(STD_OUTPUT_HANDLE) 7 | 8 | puts "Setting cursor to visible and 100% fat" 9 | a.Cursor(-1,-1,100,1) 10 | -------------------------------------------------------------------------------- /work/reference/console/test/test_mouse.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | require "Win32/Console" 4 | 5 | a = Win32::Console.new() 6 | puts "# of Mouse buttons: #{Win32::Console.MouseButtons}" 7 | -------------------------------------------------------------------------------- /work/reference/console/test/test_readinput.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | require "Win32/Console" 4 | 5 | include Win32::Console::Constants 6 | a = Win32::Console.new(STD_INPUT_HANDLE) 7 | 8 | puts "InputChar: Type a phrase then ENTER, please:" 9 | 10 | x1 = a.InputChar(1) 11 | puts "Your phrase starts with the character #{x1}" 12 | 13 | 14 | fdwMode = ENABLE_WINDOW_INPUT | ENABLE_MOUSE_INPUT 15 | 16 | a.Mode(fdwMode) 17 | 18 | puts 19 | puts "PeekInput: Type a character without ENTER or do something, please:" 20 | 21 | while (x1 = a.PeekInput()).size < 1 22 | end 23 | 24 | if x1[0] == KEY_EVENT 25 | puts "You typed #{x1[5]}='#{x1[5].chr}'" 26 | else 27 | print "You did not typed, but " 28 | case x1[0] 29 | when MOUSE_EVENT 30 | puts "used mouse" 31 | when WINDOW_BUFFER_SIZE_EVENT 32 | puts "resize window" 33 | when MENU_EVENT 34 | puts "called menu" 35 | when FOCUS_EVENT 36 | puts "changed focus" 37 | else 38 | puts "...should never get here" 39 | end 40 | end 41 | 42 | puts 43 | puts "Input (as PeekInput keeps event, this reuses PeekInput value):" 44 | x1 = a.Input() 45 | if x1[0] == KEY_EVENT 46 | puts "You typed #{x1[5]}='#{x1[5].chr}'" 47 | else 48 | print "You did not typed, but " 49 | case x1[0] 50 | when MOUSE_EVENT 51 | puts "used mouse" 52 | when WINDOW_BUFFER_SIZE_EVENT 53 | puts "resize window" 54 | when MENU_EVENT 55 | puts "called menu" 56 | when FOCUS_EVENT 57 | puts "changed focus" 58 | else 59 | puts "...should never get here" 60 | end 61 | end 62 | 63 | -------------------------------------------------------------------------------- /work/reference/console/test/test_readoutput.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | require "Win32/Console" 4 | 5 | include Win32::Console::Constants 6 | a = Win32::Console.new(STD_OUTPUT_HANDLE) 7 | 8 | puts <<'EOF' 9 | This is a simple 10 | test of test to grab 11 | from the console. 12 | Hopefully this will work 13 | easily and merrily. 14 | This is a simple 15 | test of test to grab 16 | from the console. 17 | Hopefully this will work 18 | easily and merrily. 19 | This is a simple 20 | test of test to grab 21 | from the console. 22 | Hopefully this will work 23 | easily and merrily. 24 | EOF 25 | 26 | x1 = a.ReadChar(10,10,10) 27 | x2 = a.ReadAttr(10,10,10) 28 | x3 = a.ReadRect(10,10,20,10) 29 | puts "ReadChar .#{x1}." 30 | puts x2.class, x2.size 31 | print "ReadAttr ." 32 | for i in x2 33 | print "#{i}|" 34 | end 35 | print "\nReadRect ." 36 | 37 | i = 0 38 | while i < x3.length-1 39 | print "#{x3[i]}" 40 | i += 2 41 | end 42 | print "\n " 43 | i = 1 44 | while i < x3.length-1 45 | print "#{x3[i]}|" 46 | i += 2 47 | end 48 | print "\n" 49 | 50 | #puts "read=",x1 51 | #print "Attributes:",x2 52 | 53 | -------------------------------------------------------------------------------- /work/reference/console/test/test_sendevent.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | require "Win32/Console" 4 | 5 | 6 | i = 0 7 | begin 8 | while i < 99 9 | if i == 10 10 | Win32::Console::GenerateCtrlEvent() 11 | end 12 | i = i.next 13 | end 14 | rescue Exception 15 | end 16 | 17 | puts "if i=10, then OK! i=#{i}" 18 | -------------------------------------------------------------------------------- /work/reference/console/test/test_title.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | require "Win32/Console" 4 | 5 | a = Win32::Console.new() 6 | 7 | title = a.Title() 8 | puts "Old title: \"#{title}\"" 9 | 10 | a.Title("This is a new title") 11 | title = a.Title() 12 | puts "I just changed the title to '#{title}'" 13 | 14 | sleep(5) 15 | -------------------------------------------------------------------------------- /work/reference/console/test/test_write.rb: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env ruby 2 | 3 | if $0 == __FILE__ 4 | require "Term/ANSIColor" 5 | include Term::ANSIColor 6 | 7 | require "benchmark" 8 | include Benchmark 9 | 10 | require "Win32/Console/ANSI" 11 | 12 | bm do |x| 13 | num = 100 14 | x.report("#{num} times") { 15 | 0.upto(num) { 16 | print "\e[2J" 17 | 18 | print red, bold, "Usage as constants:", reset, "\n" 19 | 20 | print clear, "clear", reset, reset, "reset", reset, 21 | bold, "bold", reset, dark, "dark", reset, 22 | underscore, "underscore", reset, blink, "blink", reset, 23 | negative, "negative", reset, concealed, "concealed", reset, "|\n", 24 | black, "black", reset, red, "red", reset, green, "green", reset, 25 | yellow, "yellow", reset, blue, "blue", reset, magenta, "magenta", reset, 26 | cyan, "cyan", reset, white, "white", reset, "|\n", 27 | on_black, "on_black", reset, on_red, "on_red", reset, 28 | on_green, "on_green", reset, on_yellow, "on_yellow", reset, 29 | on_blue, "on_blue", reset, on_magenta, "on_magenta", reset, 30 | on_cyan, "on_cyan", reset, on_white, "on_white", reset, "|\n\n" 31 | print "\e[s\e[20P.................." 32 | } 33 | } 34 | end 35 | end 36 | 37 | -------------------------------------------------------------------------------- /work/reference/heuristics.rb: -------------------------------------------------------------------------------- 1 | def guess_color_availability 2 | return false unless @output.tty? 3 | case ENV["TERM"] 4 | when /term(?:-color)?\z/, "screen" 5 | true 6 | else 7 | return true if ENV["EMACS"] == "t" 8 | false 9 | end 10 | end 11 | 12 | def guess_progress_row_max 13 | term_width = guess_term_width 14 | if term_width.zero? 15 | if ENV["EMACS"] == "t" 16 | -1 17 | else 18 | 79 19 | end 20 | else 21 | term_width 22 | end 23 | end 24 | 25 | def guess_term_width 26 | Integer(ENV["COLUMNS"] || ENV["TERM_WIDTH"] || 0) 27 | rescue ArgumentError 28 | 0 29 | end 30 | 31 | --------------------------------------------------------------------------------