paint-shortcuts 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d57c0fd9ddd3a842fc19ac0ac3d942e70c518c60
-  data.tar.gz: ad2e60a6053be8eee6f7b2f08de0653817b35b32
+  metadata.gz: b53c09f4c5e55c813cc33d28fcc35f056a0ff383
+  data.tar.gz: 35d69459f006be32abfff086afb5977b56b7ebb7
 SHA512:
-  metadata.gz: cd9e902ae80a6968b72caa163a8ae91957342485be45d2f90f9a8c05ca28c72cacd2c204225808a24c228a914e56460475450bb7f7650f007eebb69f86809159
-  data.tar.gz: daa6eaeb4829e3b0de16535e06056c1dd7aef02401af9aa1f3ff5081dda03d449c6f0e26b0b5a3802d090ef7201f44831f5d4da01ca8fae2619f076ecdfb2509
+  metadata.gz: 87c8a5ba0ea8aa71b6eb294e50f514c6bce69b190275d4b426f2b00718c6930886a669bf0469364ced15edc0579ff4eebbe9905140b1bde4a30963c88b8ab589
+  data.tar.gz: a58355d1a5c981af51eef33b179e45b3ac84315d39c4aa1f1b46db3eaeb460a55a3b8135465ab48ebce832042e8281cce6af2a3bf0b20eaa978b15be5084ef61

data/CHANGELOG.md

@@ -0,0 +1,84 @@
+# CHANGELOG
+
+### 2.0.0
+#### Major Changes
+
+*   New default color mode `0xFFFFFF`: 24bit - true color. If this breaks your code, add `Paint.mode = 256` to the beginning of your code
+*   New `Paint%[]` API: Substitution mechanism for nested color strings
+
+#### Minor Changes
+
+*   Smaller gem size (compress RGB color name data)
+*   Remove `Paint.update_rgb_colors` and `Paint.rainbow`
+*   Internal method `.hex` renamed to `.rgb_hex` and does not take "#" prefixed strings anymore
+*   Minor refactorings and documentation updates
+
+### 1.0.1
+
+*   Fix case of string arguments getting mutated (see gh#14)
+
+
+### 1.0.0
+
+*   Improved performance
+*   Option for :random colors removed (see readme)
+*   Seperate Paint::SHORTCUTS into extra gem
+*   Drop support for Ruby 1 (inoffically still support 1.9.3)
+
+
+### 0.9.0
+
+*   Don't colorize strings via shortcuts when Paint.mode == 0
+*   Freeze bundled ascii color data
+
+
+### 0.8.7
+
+*   Fix caching bug for random ansi color
+
+
+### 0.8.6
+
+*   Add missing require 'rbconfig' and travis test everything
+
+
+### 0.8.5
+
+*   Support 256 color on windows' ConEmu
+
+
+### 0.8.4
+
+*   Fix post-install message unicode
+
+
+### 0.8.3
+
+*   Paint.[] also accepts uppercased hex strings (gh#2)
+*   Performance tweaks (thanks to murphy) (gh#4, #5)
+    *   API change: deactivate colorizing with Paint.mode = 0
+
+
+### 0.8.2
+
+*   Paint.[] with only a single string argument does not colorize the string
+    anymore, but returns the plain string
+*   New pseudo color :random - returns a random ansi color
+
+
+### 0.8.1
+
+*   Improve rgb function with better gray scale values
+*   Add Paint.mode:
+    *   Set to 0 to deactivate colorizing
+    *   Set to 16 or 8 and all color generation methods will generate simple
+        ansi colors
+    *   Set to 256 for 256 color support
+    *   Tries to automatically detect your terminal's features
+*   Minor changes
+
+
+### 0.8.0
+
+*   Initial release
+

data/MIT-LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT LICENSE
 
-Copyright (c) 2011-2015 Jan Lelis
+Copyright (c) 2011-2016 Jan Lelis
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -0,0 +1,194 @@
+# Ruby Paint [<img src="https://badge.fury.io/rb/paint.svg" />](http://badge.fury.io/rb/paint) [<img src="https://travis-ci.org/janlelis/paint.svg" />](https://travis-ci.org/janlelis/paint)
+
+Paint creates terminal colors and effects for you. It combines the strengths of **term-ansicolor**, **rainbow**, and similar projects into a simple to use, however still flexible terminal colors gem with no core extensions by default.
+
+## Features
+
+* No string extensions (suitable for library development)
+* Simple API
+* Faster than other terminal color gems ([as of December 2016](https://gist.github.com/janlelis/91413b9295c81ee873dc))
+* Supports *true color* or 256 colors (for capable terminals)
+* Allows you to set any terminal effects
+* `Paint.mode`: Fall-back modes for terminals with less colors, supported modes:
+  * 0xFFFFFF (= 16777215) colors (*true color*)
+  * 256 colors (palette)
+  * 16 colors (only ANSI colors, combined with bright effect)
+  * 8 colors (only ANSI colors)
+  * 0 colors (no colors / deactivate)
+
+## Paint 2.0 | True Color Support
+
+Starting with **Paint 2.0**, *true color* mode is the new default mode, since most major terminals now support 24bit colors. If it happens to not work in your setup:
+
+- Manually set `Paint.mode = 256` at the beginning of your code
+- Please [open a new issue](https://github.com/janlelis/paint/issues/new) so we can figure out how to blacklist the terminal used
+
+## Supported Rubies
+
+* **2.4**, **2.3**, **2.2**, **2.1**
+
+Unsupported, but might still work:
+
+* **2.0**, **1.9**
+
+## Setup
+
+Add to `Gemfile`:
+
+```ruby
+gem 'paint'
+```
+
+and run `bundle install`.
+
+In Ruby do:
+
+```ruby
+require 'paint'
+```
+
+## Usage
+
+The only method you need is: `Paint.[]`
+
+The first argument given to `Paint.[]` is the string to colorize (if the object is not a string, `to_s` will be called on it). The other arguments describe how to modify/colorize the string. Let's learn by example:
+
+```ruby
+Paint['Ruby', :red]           # Sets ANSI color red
+Paint['Ruby', :red, :bright]  # Also applies bright/bold effect
+Paint['Ruby', :bright, :red]  # Does the same as above
+Paint['Ruby', :red, :bright, :underline] # Effects can often be combined
+Paint['Ruby', :red, :blue]    # The second color you define is for background
+Paint['Ruby', nil, :blue]     # Pass a nil before a color to ignore foreground and only set background color
+Paint['Ruby', [100, 255, 5]]  # You can define RGB colors. Depending on your terminal, this will create
+                              # a "true color" or map to 256/16/8 colors.
+Paint['Ruby', "gold", "snow"] # Paint supports rgb.txt color names, note that the arguments are strings
+                              # (:yellow != "yellow")!
+Paint['Ruby', "#123456"]      # HTML like definitions are possible
+Paint['Ruby', "fff"]          # Another HTML hex definition
+Paint['Ruby', :inverse]       # Swaps fore- and background
+Paint['Ruby', :italic, :encircle, :rapid_blink, :overline] # Probably not supported effects
+Paint['Ruby']                 # Don't pass any argument and the string will not be changed
+```
+
+When you pass multiple colors, the first one is taken as foreground color and the second one defines the background color, every following color will be ignored. To only change the background color, you have to pass a `nil` first. Effects can be passed in any order.
+
+[You can find more examples in the specs.](https://github.com/janlelis/paint/blob/master/spec/paint_spec.rb)
+
+[List of rgb.txt colors.](https://en.wikipedia.org/wiki/X11_color_names#Color_name_chart)
+
+## Windows Support
+
+For ANSI support in Windows OS, you can use [ansicon](https://github.com/adoxa/ansicon) or [ConEmu](http://code.google.com/p/conemu-maximus5/).
+
+## `Paint.mode`
+
+You can choose between five ways to use `Paint.[]` by setting `Paint.mode` to one of the following:
+
+* **0xFFFFFF**: Use 16777215 *true colors*
+* **256**:      Use the 256 colors palette
+* **16**:       Use the eight ANSI colors (combined with bright effect)
+* **8**:        Use the eight ANSI colors
+* **0**:        Don't colorize at all
+
+Paint tries to automatically detect the proper value your terminal is capable of, please [open an issue](https://github.com/janlelis/paint/issues/new) if `Paint.detect_mode` yields a wrong value for you.
+
+## More Details About Terminal Colors and Effects
+
+Terminal colors/effects get created by [ANSI escape sequences](http://en.wikipedia.org/wiki/ANSI_escape_code). These are strings that look like this: `\e[X;X;X;X;X]m` where X are integers with some meaning. For example, `0` means *reset*, `31` means *red foreground* and `41` stands for red background. When you tell **Paint** to use one of the eight ANSI base colors as foreground color, it just inserts a number between `30` and `37` into the sequence. The following colors are available:
+
+* `:black`
+* `:red`
+* `:green`
+* `:yellow`
+* `:blue`
+* `:magenta`
+* `:cyan`
+* `:white`
+* (`:default`)
+
+When combined with the `:bright` (= `:bold`) effect, the color in the terminal emulator often differs a little bit, thus it is possible to represent 16 colors.
+
+Through special sequences it's also possible to set 256-colors, or even 16777215 colors, instead of only the 8 ANSI ones. However, this is not supported by all terminals. Paint automatically translates given RGB colors to a suitable color of the supported color spectrum.
+
+When using the `Paint.[]` method, Paint wraps the given string between the calculated escape sequence and an reset sequence (`"\e[0m"`). You can get the raw escape sequence by using the `Paint.color` method.
+
+### Effects
+
+See [en.wikipedia.org/wiki/ANSI_escape_code](http://en.wikipedia.org/wiki/ANSI_escape_code) for a more detailed discussion:
+
+#### Often supported
+
+    0) :reset, :nothing
+    1) :bright, :bold
+    4) :underline
+    7) :inverse, :negative
+    8) :conceal, :hide
+    22) :clean
+    24) :underline_off
+    26) :inverse_off, :positive
+    27) :conceal_off, :show, :reveal
+
+#### Not widely supported
+
+    2) :faint
+    3) :italic
+    5) :blink, :slow_blink
+    6) :rapid_blink
+    9) :crossed, :crossed_out
+    10) :default_font, :font0
+    11-19) :font1, :font2, :font3, :font4, :font5, :font6, :font7, :font8, :font9
+    20) :fraktur
+    21) :bright_off, :bold_off, :double_underline
+    23) :italic_off, :fraktur_off
+    25) :blink_off
+    29) :crossed_off, :crossed_out_off
+    51) :frame
+    52) :encircle
+    53) :overline
+    54) :frame_off, :encircle_off
+    55) :overline_off
+
+## Substitution & Nesting
+
+From time to time, you might find yourself in a situation where you want to colorize a substring differently from the rest of the string. Paint supports this via a simple templating approach using the `%` method with an array argument. Use the `%{var}` notation within a string, and pass the template variables as a hash:
+
+```ruby
+Paint%['Yellow string with a %{blue_text} in it', :yellow,
+  blue_text: ["blue text", :blue]
+]
+# => "\e[33mYellow string with a \e[34mblue text\e[33m in it\e[0m"
+```
+
+## Utilities
+
+The `Paint.random` method generates a random ANSI color you can pass into `Paint.[]`:
+
+```ruby
+Paint['Ruby', Paint.random]        # Get one of eight random ANSI foreground colors
+Paint['Ruby', Paint.random(true)]  # Get one of eight random ANSI background colors
+```
+
+Another helper method is `Paint.unpaint`, which removes any ANSI colors:
+
+```ruby
+Paint.unpaint( Paint['Ruby', :red, :bright] ).should == 'Ruby'
+```
+
+You can get a `p` like alternative for calling `puts Paint.[]`:
+
+```ruby
+require 'paint/pa'
+pa "Ruby", :red, :underline  # same as puts Paint["Ruby", :red, :underline]
+```
+
+## Advanced Usage: Shortcuts
+
+There is an extension gem available which allows you to define custom color definitions, which you can reuse later. See [SHORTCUTS.md](https://github.com/janlelis/paint/blob/master/SHORTCUTS.md) for documentation. This is completely optional.
+
+## J-_-L
+
+Copyright (c) 2011-2016 Jan Lelis <http://janlelis.com>, released under the
+MIT license.
+
+Thank you to [rainbow](https://github.com/sickill/rainbow) and [term-ansicolor](https://github.com/flori/term-ansicolor) for ideas and inspiration. Also, a lot of thanks to all the [contributors](https://github.com/janlelis/paint/contributors)!

data/SHORTCUTS.md

@@ -0,0 +1,64 @@
+# Paint::SHORTCUTS [<img src="https://badge.fury.io/rb/paint-shortcuts.svg" />](http://badge.fury.io/rb/paint-shortcuts)
+
+This is an optional extension gem for [Paint](https://github.com/janlelis/paint)
+
+## Setup
+
+Add to `Gemfile`:
+
+    gem 'paint-shortcuts'
+
+and run `bundle install`.
+
+In Ruby do:
+
+    require 'paint/shortcuts'
+
+## Description
+
+You can create color shortcuts for your gems and scripts! Please note: You don't have to use this feature (and only stick to `Paint.[]` instead)
+
+All you need to do is to setup a hash of symbol keys and escaped color sequences at:
+`Paint::SHORTCUTS[:your_namespace]`:
+
+```ruby
+Paint::SHORTCUTS[:example] = {
+  :white => Paint.color(:black),
+  :red => Paint.color(:red, :bright),
+  :title => Paint.color(:underline),
+}
+```
+
+The methods become "rubymagically" available in a `Paint` child model:
+
+```ruby
+Paint::Example.red 'Ruby' # => "\e[31;1mRuby\e[0m"
+Paint::Example.white      # => "\e[37m"
+```
+
+As you can see, the helper methods look useful and can take either one (wrap string) or none (only color) arguments. You can also include them:
+
+```ruby
+include Paint::Example
+red # => "\e[31;1m"
+white 'Ruby' # => "\e[30m"
+```
+
+All shortcuts, defined in your shortcut namespace at this time, are now (privately) available in your current namespace (without relying a `method_missing` implementation).
+
+Furthermore, there are variations of this approach. You get a different behaviour, when you include the `String` sub-module.
+
+```ruby
+include Paint::Example::String
+"Ruby".title # => "\e[4mRuby\e[0m"
+5.red # => "\e[31;1m5\e[0m"
+```
+
+In this case, `self` will be converted to a string and wrapped with the specific color code. Note, that the helper methods don't take any arguments when using this style of inclusion.
+
+The third way allows you to get a single color helper method to avoid cluttering namespaces:
+
+```ruby
+include Paint::Example::Prefix::ExampleName
+"Ruby".example_name(:red) # => "\e[31;1mRuby\e[0m"
+```

data/lib/paint/shortcuts_version.rb

@@ -1,3 +1,3 @@
 module Paint
-  SHORTCUTS_VERSION = '1.0.0'
+  SHORTCUTS_VERSION = '2.0.0'.freeze
 end

data/paint-shortcuts.gemspec

@@ -17,13 +17,12 @@ Gem::Specification.new do |s|
     lib/paint/shortcuts_version.rb
   ]
   s.extra_rdoc_files = %w[
-    README.rdoc
-    SHORTCUTS.rdoc
-    CHANGELOG.rdoc
+    README.md
+    SHORTCUTS.md
+    CHANGELOG.md
     MIT-LICENSE.txt
   ]
 
   s.required_ruby_version = '>= 1.9.3'
-  s.add_dependency 'paint', '~> 1.0'
-  s.add_development_dependency 'rspec', '~> 3.2'
+  s.add_dependency 'paint', '>= 1.0', '< 3.0'
 end

metadata

@@ -1,57 +1,49 @@
 --- !ruby/object:Gem::Specification
 name: paint-shortcuts
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Jan Lelis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-22 00:00:00.000000000 Z
+date: 2016-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: paint
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.0'
-- !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '3.2'
+        version: '3.0'
 description: Extends the paint gem to support custom color shortcuts.
 email: mail@janlelis.de
 executables: []
 extensions: []
 extra_rdoc_files:
-- README.rdoc
-- SHORTCUTS.rdoc
-- CHANGELOG.rdoc
+- README.md
+- SHORTCUTS.md
+- CHANGELOG.md
 - MIT-LICENSE.txt
 files:
-- CHANGELOG.rdoc
+- CHANGELOG.md
 - MIT-LICENSE.txt
-- README.rdoc
-- SHORTCUTS.rdoc
+- README.md
+- SHORTCUTS.md
 - lib/paint/shortcuts.rb
 - lib/paint/shortcuts_version.rb
 - paint-shortcuts.gemspec
@@ -75,7 +67,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Terminal painter! Shortcut extension.

data/CHANGELOG.rdoc

@@ -1,42 +0,0 @@
-=== 1.0.0
-* Improved performance
-* Option for :random colors removed (see readme)
-* Seperate Paint::SHORTCUTS into extra gem
-* Drop support for Ruby 1 (inoffically still support 1.9.3)
-
-=== 0.9.0
-* Don't colorize strings via shortcuts when Paint.mode == 0
-* Freeze bundled ascii color data
-
-=== 0.8.7
-* Fix caching bug for random ansi color
-
-=== 0.8.6
-* Add missing require 'rbconfig' and travis test everything
-
-=== 0.8.5
-* Support 256 color on windows' ConEmu
-
-=== 0.8.4
-* Fix post-install message unicode
-
-=== 0.8.3
-* Paint.[] also accepts uppercased hex strings (gh#2)
-* Performance tweaks (thanks to murphy) (gh#4, #5)
-  * API change: deactivate colorizing with Paint.mode = 0
-
-=== 0.8.2
-* Paint.[] with only a single string argument does not colorize the string anymore, but returns the plain string
-* New pseudo color :random - returns a random ansi color
-
-=== 0.8.1
-* Improve rgb function with better gray scale values
-* Add Paint.mode:
-  * Set to 0 to deactivate colorizing
-  * Set to 16 or 8 and all color generation methods will generate simple ansi colors
-  * Set to 256 for 256 color support
-  * Tries to automatically detect your terminal's features
-* Minor changes
-
-=== 0.8.0
-* Initial release

data/README.rdoc

@@ -1,137 +0,0 @@
-= Ruby Paint {<img src="https://badge.fury.io/rb/paint.svg" />}[http://badge.fury.io/rb/paint] {<img src="https://travis-ci.org/janlelis/paint.png" />}[https://travis-ci.org/janlelis/paint]
-
-Paint manages terminal colors and effects for you. It combines the strengths of *term-ansicolor*, *rainbow* and other similar projects into a simple to use, however still flexible terminal colorization gem with no core extensions by default.
-
-== Features
-* No string extensions (suitable for library development)
-* Supports setting 256 colors (for capable terminals)
-* Supports setting any effects (although most terminals won't support it)
-* Simple to use
-* Faster than most similar gems due to caching
-* Fall-back modes for non-256-color terminals (<tt>Paint.mode</tt>), supported modes:
-  * 256 colors
-  * 16 colors (only ansi colors, combined with bright effect)
-  * 8 colors (only ansi colors)
-  * 0 colors (deactivate)
-
-== Setup
-Add to Gemfile:
-
-  gem 'paint'
-
-and run `bundle install`
-
-In Ruby do:
-
-  require 'paint'
-
-== Usage
-The only method you need to know to get started is: <tt>Paint.[]</tt>
-
-The first argument given to <tt>Paint.[]</tt> is the string to colorize (if the object is not a string, <tt>to_s</tt> will be called on it). The other arguments describe how to modify/colorize the string. Let's learn by example:
-
-  Paint['Ruby', :red]           # sets ansi color red
-  Paint['Ruby', :red, :bright]  # also applies bright/bold effect
-  Paint['Ruby', :bright, :red]  # does the same as above
-  Paint['Ruby', :red, :bright, :underline] # effects can often be combined
-  Paint['Ruby', :red, :blue]    # the second color you define is for background
-  Paint['Ruby', nil, :blue]     # pass a nil before a color to ignore foreground and only set background color
-  Paint['Ruby', [100, 255, 5]]  # you can define rgb colors that map to one of 256 colors. Only supported on 256-color terminals, of course
-  Paint['Ruby', "gold", "snow"] # Paint supports rgb.txt color names, note that the arguments are strings (:yellow != "yellow")!
-  Paint['Ruby', "#123456"]      # html like definitions are possible.
-  Paint['Ruby', "fff"]          # another html hex definition
-  Paint['Ruby', :inverse]       # swaps fore- and background
-  Paint['Ruby', :italic, :encircle, :rapid_blink, :overline] # probably not supported effects
-  Paint['Ruby']                 # don't pass any argument and the string will not be changed
-
-When you pass multiple colors, the first one is taken as foreground color and the second one defines the background color, every other will be ignored. To only change the background color, you have to pass a <tt>nil</tt> first. Effects can be passed in any order.
-
-You can find more examples in the specs.
-
-== Windows Support
-For ANSI support in Windows OS, you can use {ansicon}[https://github.com/adoxa/ansicon] or {ConEmu}[http://code.google.com/p/conemu-maximus5/].
-
-== More details about terminal colors and effects
-Terminal colors/effects are set by {ansi escape sequences}[http://en.wikipedia.org/wiki/ANSI_escape_code]. These are strings that look like this: <tt>\e[X;X;X;X;X]m</tt> where X are integers with some meaning. For example, 0 means reset, 31 means red foreground and 41 red background. When you tell Paint to use one of the eight ansi base colors as foreground color, it just inserts a number between 30 and 37 in the sequence. The following colors are available:
-
-  :black, :red, :green, :yellow, :blue, :magenta, :cyan, :white, (:default)
-
-When combined with the <tt>:bright</tt> (= <tt>:bold</tt>) effect, the color in the terminal emulator often differs a little bit.
-
-Through special sequences it's also possible to set 256-colors, instead of 8, which is also supported by many - but not all - terminals. Paint automatically translates given rgb colors to a suitable color of the 256 available colors.
-
-When using the <tt>Paint.[]</tt> method, Paint wraps the given string between the calculated escape sequence and an reset sequence (<tt>"\e[0m"</tt>). You can get the raw escape sequence by using the <tt>Paint.color</tt> method.
-
-=== Effects
-Also see {en.wikipedia.org/wiki/ANSI_escape_code}[http://en.wikipedia.org/wiki/ANSI_escape_code]:
-
-==== Often supported
-
-  0) :reset, :nothing
-  1) :bright, :bold
-  4) :underline
-  7) :inverse, :negative
-  8) :conceal, :hide
-  22) :clean
-  24) :underline_off
-  26) :inverse_off, :positive
-  27) :conceal_off, :show, :reveal
-
-==== Not widely supported
-
-  2) :faint
-  3) :italic
-  5) :blink, :slow_blink
-  6) :rapid_blink
-  9) :crossed, :crossed_out
-  10) :default_font, :font0
-  11-19) :font1, :font2, :font3, :font4, :font5, :font6, :font7, :font8, :font9
-  20) :fraktur
-  21) :bright_off, :bold_off, :double_underline
-  23) :italic_off, :fraktur_off
-  25) :blink_off
-  29) :crossed_off, :crossed_out_off
-  51) :frame
-  52) :encircle
-  53) :overline
-  54) :frame_off, :encircle_off
-  55) :overline_off
-
-== Paint.mode
-You can choose between four ways to use <tt>Paint.[]</tt> by setting <tt>Paint.mode</tt> to one of the following:
-* 256:   full support
-* 16:    don't use 256 colors, but the ansi eight ones (combined with bright effect)
-* 8:     don't use 256 colors, but the ansi eight ones
-* 0:     don't colorize at all
-
-Paint tries to automatically detect the proper value, please open an issue if <tt>Paint.detect_mode</tt> yields a wrong value for you.
-
-== Random ANSI colors
-
-With 1.0, the :random feature was removed, because it interfered with the caching mechanism. If you still need it, you will have to workaround by generating random colors yourself, before passing them into the Paint method:
-
-  Paint['Ruby', Paint.random]        # get one of eight random ansi foreground colors
-  Paint['Ruby', Paint.random(true)]  # get one of eight random ansi background colors
-
-== Utilities
-There are some supporting methods available. You can get a <tt>p</tt> like alternative for calling <tt>puts Paint.[]</tt>:
-
-  require 'paint/pa'
-  pa "Ruby", :red, :underline  # same as puts Paint["Ruby", :red, :underline]
-
-Another helper method is <tt>Paint.unpaint</tt>, which removes any ansi colors:
-
-  Paint.unpaint( Paint['Ruby', :red, :bright] ).should == 'Ruby'
-
-== Advanced Usage: Shortcuts
-There is an extension gem available that allows you to define custom color shortcuts. See {SHORTCUTS.rdoc}[https://github.com/janlelis/paint/blob/master/SHORTCUTS.rdoc] for more information.
-
-== J-_-L
-
-Copyright (c) 2011-2015 Jan Lelis <http://janlelis.com>, released under the MIT license.
-
-Mainly influenced by rainbow[https://github.com/sickill/rainbow] and {term-ansicolor}[https://github.com/flori/term-ansicolor]. Contributors[https://github.com/janlelis/paint/contributors]:
-* {CyberShadow}[https://github.com/CyberShadow]
-* {korun}[https://github.com/korun]
-* {mhaylock}[https://github.com/mhaylock]
-* {korny}[https://github.com/rubychan]

data/SHORTCUTS.rdoc

@@ -1,51 +0,0 @@
-= Paint::SHORTCUTS
-
-== Setup
-Add to Gemfile:
-
-  gem 'paint-shortcuts'
-
-and run `bundle install`
-
-In Ruby do:
-
-  require 'paint/shortcuts'
-
-== Description
-Now for the fancy part: You can create color shortcuts for your gems and scripts! Note: You don't have to use this feature (and only stick to <tt>Paint.[]</tt> instead) ;)
-
-It's easy: Just setup a hash of symbol keys and escape string values at: <tt>Paint::SHORTCUTS[:your_namespace]</tt>. They are stored directly as escape sequences for performance reasons (this also means, you need different namespaces for different <tt>Paint.mode</tt>s). Example:
-
-  Paint::SHORTCUTS[:example] = {
-    :white => Paint.color(:black),
-    :red => Paint.color(:red, :bright),
-    :title => Paint.color(:underline),
-  }
-
-The methods become "rubymagically" available in a <tt>Paint</tt> child model:
-
-  Paint::Example.red 'Ruby' # => "\e[31;1mRuby\e[0m"
-  Paint::Example.white      # => "\e[37m"
-
-As you can see, the helper methods look useful and can take either one (wrap string) or none (only color) arguments ...but they aren't really <em>short</em> yet.
-
-Fortunately, you can include them:
-
-  include Paint::Example
-  red # => "\e[31;1m"
-  white 'Ruby' # => "\e[30m"
-
-All shortcuts, defined in your shortcut namespace at this time, are now (privately) available in your current namespace (without using a method_missing implementation).
-
-Furthermore, there are two variations of this approach:
-
-  include Paint::Example::String
-  "Ruby".title # => "\e[4mRuby\e[0m"
-  5.red # => "\e[31;1m5\e[0m"
-
-In this case, <tt>self</tt> will be converted to a string and wrapped with the specific color code. Note, that the helper methods doesn't take any arguments when using this inclusion method.
-
-The third way allows you to get a single color helper method to avoid cluttering namespaces:
-
-  include Paint::Example::Prefix::ExampleName
-  "Ruby".example_name(:red) # => "\e[31;1mRuby\e[0m"