paint-shortcuts 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d57c0fd9ddd3a842fc19ac0ac3d942e70c518c60
+  data.tar.gz: ad2e60a6053be8eee6f7b2f08de0653817b35b32
+SHA512:
+  metadata.gz: cd9e902ae80a6968b72caa163a8ae91957342485be45d2f90f9a8c05ca28c72cacd2c204225808a24c228a914e56460475450bb7f7650f007eebb69f86809159
+  data.tar.gz: daa6eaeb4829e3b0de16535e06056c1dd7aef02401af9aa1f3ff5081dda03d449c6f0e26b0b5a3802d090ef7201f44831f5d4da01ca8fae2619f076ecdfb2509

data/CHANGELOG.rdoc

@@ -0,0 +1,42 @@
+=== 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

@@ -0,0 +1,22 @@
+The MIT LICENSE
+
+Copyright (c) 2011-2015 Jan Lelis
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,137 @@
+= 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

@@ -0,0 +1,51 @@
+= 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"

data/lib/paint/shortcuts.rb

@@ -0,0 +1,98 @@
+require_relative 'shortcuts_version'
+
+require 'paint'
+
+module Paint
+  # Hash for defining color/effect shortcuts
+  SHORTCUTS = {
+    # :example => {                    # would create a Paint::Example constant...
+    #   :light_red     => "\e[31;1m",  # with a method .light_red
+    # }
+  }
+  SHORTCUTS.default = {}
+
+  class << self
+    # Paint::SomeModule --> Paint::SHORTCUTS[:some_module]
+    def const_missing(mod_name)
+      # get shortcuts
+      shortcuts = SHORTCUTS[mod_name.to_s.gsub(/[A-Z]/,'_\0').downcase[1..-1].to_sym] || []
+
+      # create module
+      class_eval "module #{mod_name}; end"
+      mod = const_get(mod_name)
+
+      # define direct behaviour, class methods
+      mod.define_singleton_method :method_missing do |color_name, *args|
+        if color_code = shortcuts[color_name]
+          string = Array(args).join
+          return string if Paint.mode.zero?
+
+          if args.empty?
+            color_code
+          else
+            color_code + string + NOTHING
+          end
+        else
+          nil
+        end
+      end
+
+      mod.define_singleton_method :respond_to_missing? do |color_name, *args|
+        shortcuts.include?(color_name) || super(color_name, *args)
+      end
+
+      # define include behaviour, instance methods
+      mod.define_singleton_method :included do |_|
+        shortcuts.each{ |color_name, color_code|
+          define_method color_name do |*args|
+            string = Array(args).join
+            return string if Paint.mode.zero?
+
+            if args.empty?
+              color_code
+            else
+              color_code + string + NOTHING
+            end
+          end
+        }
+        private(*shortcuts.keys) unless shortcuts.empty?
+      end
+
+      # include variations, defined in child modules
+      mod.class_eval "module String; end"
+      string = mod.const_get(:String)
+      string.define_singleton_method :included do |_|
+        shortcuts.each{ |color_name, color_code|
+          define_method color_name do
+            if Paint.mode.zero?
+              to_s
+            else
+              color_code + to_s + NOTHING
+            end
+          end
+        }
+      end
+
+      # OK, let's take it one level further ;)
+      mod.class_eval "module Prefix; end"
+      prefix_prefix = mod.const_get(:Prefix)
+      prefix_prefix.define_singleton_method :const_missing do |prefix_name|
+        class_eval "module #{prefix_name}; end"
+        prefix = const_get(prefix_name)
+
+        prefix.define_singleton_method :included do |_|
+          define_method prefix_name.to_s.gsub(/[A-Z]/,'_\0').downcase[1..-1].to_sym do |color_name|
+            if color_code = shortcuts[color_name]
+              return to_s if Paint.mode.zero?
+              color_code + to_s + NOTHING
+            end
+          end
+        end
+
+        prefix
+      end
+
+      mod
+    end
+  end
+end

data/lib/paint/shortcuts_version.rb

@@ -0,0 +1,3 @@
+module Paint
+  SHORTCUTS_VERSION = '1.0.0'
+end

data/paint-shortcuts.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+
+require File.dirname(__FILE__) + "/lib/paint/shortcuts_version"
+
+Gem::Specification.new do |s|
+  s.name        = "paint-shortcuts"
+  s.version     = Paint::SHORTCUTS_VERSION
+  s.authors     = ["Jan Lelis"]
+  s.email       = "mail@janlelis.de"
+  s.homepage    = "https://github.com/janlelis/paint"
+  s.summary     = "Terminal painter! Shortcut extension."
+  s.description = "Extends the paint gem to support custom color shortcuts."
+  s.license = 'MIT'
+  s.files = %w[
+    paint-shortcuts.gemspec
+    lib/paint/shortcuts.rb
+    lib/paint/shortcuts_version.rb
+  ]
+  s.extra_rdoc_files = %w[
+    README.rdoc
+    SHORTCUTS.rdoc
+    CHANGELOG.rdoc
+    MIT-LICENSE.txt
+  ]
+
+  s.required_ruby_version = '>= 1.9.3'
+  s.add_dependency 'paint', '~> 1.0'
+  s.add_development_dependency 'rspec', '~> 3.2'
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: paint-shortcuts
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Jan Lelis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-22 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'
+  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'
+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
+- MIT-LICENSE.txt
+files:
+- CHANGELOG.rdoc
+- MIT-LICENSE.txt
+- README.rdoc
+- SHORTCUTS.rdoc
+- lib/paint/shortcuts.rb
+- lib/paint/shortcuts_version.rb
+- paint-shortcuts.gemspec
+homepage: https://github.com/janlelis/paint
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Terminal painter! Shortcut extension.
+test_files: []