rbcat 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7cf26b222d1b203aca1a1a0fe57e6888d4c9443c89ed2e9357f094adeb5114f7
+  data.tar.gz: f32f88be4960c79ca91eebf320ff9b010ed47bd4e7bebb939d2e1bf78a4c44f0
+SHA512:
+  metadata.gz: aecdbfac200a6845ce384a7c4e1386bf328427c00332914ee54a74e4050b11dc96b77a6bb5bcf1fa1fc2e044af7bdab7af122ad15f9259cb5ea9d2a5a469b11f
+  data.tar.gz: ecc9501e91a5ad25885c140edb90fd1784719135924920b96728b9e0998836780483b59d06c7f9447b200987088dfa22cd71066d5e780aab0507bd906ad24fd5

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rubocop.yml

@@ -0,0 +1,2 @@
+AllCops:
+  TargetRubyVersion: 2.3.0

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in rbcat.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Victor Afanasev
+
+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.md

@@ -0,0 +1,386 @@
+# Rbcat
+
+### Introduction
+
+Rbcat it's a CLI tool written in ruby which reads from standard input (STDIN), colorizes content by set of regex rules from a config file, and then writes it to standard output. Inspired by [grcat](https://github.com/garabik/grc).
+You can use rbcat in your ruby/ROR projects or as a standalone CLI tool (similar to grcat).
+
+**Install rbcat first:** `gem install rbcat`
+
+```ruby
+# rbcat_example.rb
+
+description = <<~HEREDOC
+  Rbcat it's a CLI tool written in ruby which reads from standard input (stdin),
+  colorizes content by set of regex rules from a config file, and then writes it
+  to standard output.
+  You can use rbcat in your ruby/ROR projects or as a standalone CLI tool (similar to grcat).
+HEREDOC
+
+rules = {
+  ruby_word: {
+    regexp: /ruby/m,
+    color: :red
+  },
+  upcase_words: {
+    regexp: /[A-Z]{2,}/m,
+    color: :bold
+  },
+  inside_round_brackets: {
+    regexp: /\(.*?\)/m,
+    color: :cyan
+  },
+  gem_name: {
+    regexp: /rbcat/mi,
+    color: :green
+  }
+}
+
+require "rbcat"
+colorizer = Rbcat::Colorizer.new(rules: rules)
+puts colorizer.colorize(description)
+
+```
+
+![](https://hsto.org/webt/qp/pp/nb/qpppnbvennx7yp5nxpye5qrgt_c.png)
+
+
+
+**Same using CLI:**
+
+```yaml
+# rbcat_config.yaml
+---
+:ruby_word:
+  :regexp: !ruby/regexp /ruby/m
+  :color: :red
+:upcase_words:
+  :regexp: !ruby/regexp /[A-Z]{2,}/m
+  :color: :bold
+:inside_round_brackets:
+  :regexp: !ruby/regexp /\(.*?\)/m
+  :color: :cyan
+:gem_name:
+  :regexp: !ruby/regexp /rbcat/mi
+  :color: :green
+```
+```bash
+$ echo "Rbcat it's a CLI tool written in ruby which reads from standard input (stdin),
+colorizes content by set of regex rules from a config file, and then writes it
+to standard output.
+You can use rbcat in your ruby/ROR projects or as a standalone CLI tool (similar to grcat)." > description.txt
+
+$ cat description.txt | rbcat --rules=rbcat_config.yaml # or
+$ rbcat --rules=rbcat_config.yaml < description.txt
+```
+
+![](https://hsto.org/webt/_u/5o/vu/_u5ovumrklgtx-akeqd_lbdpkys.png)
+
+
+
+### Configuration
+
+##### Configure
+
+You can configure Rbcat this way:
+
+```ruby
+require "rbcat"
+
+Rbcat.configure do |config|
+  require "yaml"
+  config.rules = YAML.load_file(File.expand_path("rbcat_config.yaml"))
+  config.predefined = [:logger]
+end
+```
+
+And then everywhere in the ruby code just:
+
+```ruby
+colorizer = Rbcat::Colorizer.new
+puts colorizer.colorize("String to colorize")
+```
+
+
+
+##### Regex rules and colors
+
+Config contains rules. Each rule has options. Example:
+
+```ruby
+config = {
+  ruby_word: {
+    regexp: /ruby/m, # Regex mask (required)
+    color: :red, # Color (required)
+    once: true # Colorize only first occurrence, then skip others (optional, defalut value is false)
+  }
+}
+```
+
+
+
+##### Predefined color sets
+
+There are predefined sets of rules: **jsonhash** (colorizes strings that contain _json_ or _ruby hash_) and **logger** (colorizes _DEBUG_, _INFO_, _WARN_ and _ERROR_).
+
+Usage: `--predefined=jsonhash,logger` (CLI), or `Rbcat::Colorizer.new(predefined: [:jsonhash, logger])` (ruby)
+
+Let's see:
+
+![](https://hsto.org/webt/ko/ui/dw/kouidw7sm_wcsitt-nfz88ydpf4.png)
+
+![](https://hsto.org/webt/18/6g/wj/186gwj7o9rvsqipo2rspwbe958q.png)
+
+![](https://hsto.org/webt/yv/vg/jv/yvvgjvjpobcyjziwcv1vyxln3u4.png)
+
+You can use both custom and predefined rules in the same time.
+
+
+
+##### Colors
+
+To print all available colors: `$ rbcat --print_colors`
+
+
+
+##### Yaml config
+
+Correct yaml config should be convertible to the Ruby hash. Here is an example of Rbcat config in both Ruby hash and yaml:
+
+```yaml
+# rbcat_config.yaml
+
+---
+:ruby_word:
+  :regexp: !ruby/regexp /ruby/m
+  :color: :red
+:upcase_words:
+  :regexp: !ruby/regexp /[A-Z]{2,}/m
+  :color: :bold
+:inside_round_brackets:
+  :regexp: !ruby/regexp /\(.*?\)/m
+  :color: :cyan
+:gem_name:
+  :regexp: !ruby/regexp /rbcat/mi
+  :color: :green
+  :once: true
+```
+
+```ruby
+# ruby hash
+
+{
+  ruby_word: {
+    regexp: /ruby/m,
+    color: :red
+  },
+  upcase_words: {
+    regexp: /[A-Z]{2,}/m,
+    color: :bold
+  },
+  inside_round_brackets: {
+    regexp: /\(.*?\)/m,
+    color: :cyan
+  },
+  gem_name: {
+    regexp: /rbcat/mi,
+    color: :green
+    once: true
+  }
+}
+```
+
+
+
+### Using inside ruby project
+
+It's a good idea to use rbcat with logger, so you can configure logger with colorizer once and then use it to print info to the console everywhere in the ruby code.
+
+What we need to do is to [define formatter](http://ruby-doc.org/stdlib-2.5.0/libdoc/logger/rdoc/Logger.html#class-Logger-label-Format) for the logger, while creating one.
+
+
+
+##### Using with a default ruby logger
+
+Here is the simple example:
+
+```ruby
+require "logger"
+require "rbcat"
+
+# configure rbcat first
+Rbcat.configure do |config|
+  require "yaml"
+  config.rules = YAML.load_file(File.expand_path("rbcat_config.yaml"))
+end
+
+# define formatter
+formatter = proc do |severity, datetime, progname, msg|
+  # default ruby logger layout:
+  output = "%s, [%s#%d] %5s -- %s: %s\n".freeze % [severity[0..0], datetime, $$, severity, progname, msg]
+  colorizer = Rbcat::Colorizer.new
+  colorizer.colorize(output)
+end
+
+# logger instance
+logger = ::Logger.new(STDOUT, formatter: formatter)
+
+logger.info "Message to colorize"
+```
+
+This is a nice example but almost isn't usable.  In the normal ruby project, there are many classes and we need somehow have access to ours colorized logger instance from everywhere.
+
+One of possible solutions is to use logger module and then include it to every class where we need it:
+
+```ruby
+require "logger"
+
+module Log
+  def logger
+    @logger ||= begin
+      ::Logger.new(STDOUT, formatter: proc { |severity, datetime, progname, msg|
+        # default ruby logger layout
+        output = "%s, [%s#%d] %5s -- %s: %s\n".freeze % [severity[0..0], datetime, $$, severity, progname, msg]
+        colorizer = Rbcat::Colorizer.new
+        colorizer.colorize(output)
+      })
+    end
+  end
+end
+
+class SomeClass
+  include Log
+
+  def print_message(msg)
+    logger.info msg
+  end
+end
+
+SomeClass.new.print_message("Colorized message")
+```
+
+
+
+In the example above, we still need every time include Log module for every class. **There is another more convenient way**, using Log class with class logger methods:
+
+```ruby
+require "logger"
+require "forwardable"
+
+class Log
+  class << self
+    extend Forwardable
+    delegate [:debug, :info, :warn, :error, :fatal] => :logger
+
+    def logger
+      @logger ||= begin
+        ::Logger.new(STDOUT, formatter: proc { |severity, datetime, progname, msg|
+          # default ruby logger layout
+          output = "%s, [%s#%d] %5s -- %s: %s\n".freeze % [severity[0..0], datetime, $$, severity, progname, msg]
+          colorizer = Rbcat::Colorizer.new(predefined: [:logger])
+          colorizer.colorize(output)
+        })
+      end
+    end
+  end
+end
+```
+
+![](https://hsto.org/webt/1f/vr/bc/1fvrbc5mlez-kmgromeidhky700.png)
+
+With this approach, you can use colorized logger everywhere in the code.
+
+
+
+##### Using with other logger libraries
+
+[Logstash:](https://github.com/dwbutler/logstash-logger)
+
+```ruby
+require "logstash-logger"
+require "rbcat"
+
+logger = begin
+  formatter = proc { |severity, datetime, progname, msg|
+    output = "%s, [%s#%d] %5s -- %s: %s\n".freeze % [severity[0..0], datetime, $$, severity, progname, msg]
+    colorizer = Colorizer.new
+    colorizer.colorize(output)
+  }
+
+  LogStashLogger.new(type: :stdout, formatter: formatter)
+end
+
+logger.info "Info message to colorize"
+```
+
+
+
+##### Write clear log to the file and print colorized output to the console at the same time
+
+Suddenly, default ruby logger can't output info to the several sources at the same time. But it can do [Logstash](https://github.com/dwbutler/logstash-logger) for example:
+
+```ruby
+require "logstash-logger"
+require "rbcat"
+
+logger = begin
+  formatter = proc { |severity, datetime, progname, msg|
+    output = "%s, [%s#%d] %5s -- %s: %s\n".freeze % [severity[0..0], datetime, $$, severity, progname, msg]
+    colorizer = Colorizer.new
+    colorizer.colorize(output)
+  }
+
+  outputs = [
+    { type: :stdout, formatter: formatter },
+    { type: :file, formatter: ::Logger::Formatter }
+  ]
+
+  LogStashLogger.new(type: :multi_logger, formatter: formatter, outputs: outputs)
+end
+```
+
+
+
+### Q&A
+
+##### I have a problem with a printing delay to the console using rbcat CLI
+
+The same problem has [grcat](https://github.com/garabik/grc).
+
+Example:
+
+```bash
+$ ruby -e "loop { puts 'INFO: This is info message'; sleep 0.1 }" | rbcat --predefined=logger
+```
+
+This code should print _"INFO: This is info message"_ to the console every 0.1 seconds. But its don't, because of nature of STDOUT buffering. [Here is a great article](https://eklitzke.org/stdout-buffering) about it.
+
+One of possible solutions is to use **[unbuffer](https://linux.die.net/man/1/unbuffer)** tool (`sudo apt install expect` for ubuntu):
+
+```bash
+$ unbuffer ruby -e "loop { puts 'INFO: This is info message'; sleep 0.1 }" | rbcat --predefined=logger
+```
+
+Now message prints to the console every 0.1 seconds without any delay.
+
+
+
+##### I don't like colors which colorizer prints
+
+Colorizer uses [standard ANSI escape color codes](https://en.wikipedia.org/wiki/ANSI_escape_code#Colors), but each terminal can have an individual color palette. You can install additional color schemes, [here](https://github.com/Mayccoll/Gogh) for example [themes](https://github.com/denysdovhan/one-gnome-terminal) for Gnome terminal.
+
+
+
+##### I want to temporary disable colorizer
+
+Define environment variable `RBCAT_COLORIZER` with value `false`. Or use `RBCAT_COLORIZER=false` as the first parameter of command:
+
+```bash
+$ RBCAT_COLORIZER=false ruby grcat_example.rb
+```
+
+
+
+### License
+
+MIT

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rbcat"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/rbcat

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require "rbcat"
+Rbcat::CLI.start(ARGV)

data/lib/rbcat.rb

@@ -0,0 +1,7 @@
+require "rbcat/version"
+require "rbcat/configuration_error"
+require "rbcat/configuration"
+require "rbcat/colors"
+require "rbcat/rules"
+require "rbcat/colorizer"
+require "rbcat/cli"

data/lib/rbcat/cli.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "optparse"
+
+module Rbcat
+  class CLI
+    def self.start(args)
+      options = parse_options(args)
+      colorizer = create_colorizer(options)
+
+      while input = STDIN.gets
+        input.each_line do |line|
+          begin
+            puts colorizer.colorize(line)
+          rescue Errno::EPIPE
+            exit(74)
+          end
+        end
+      end
+    end
+
+    private_class_method
+
+    def self.create_colorizer(options)
+      rules =
+        if options[:rules]
+          file_path = File.expand_path(options[:rules])
+          unless File.exist? file_path
+            raise ConfigurationError, "Config file not found: #{file_path}."
+          else
+            require "yaml"
+            YAML.load_file(file_path)
+          end
+        end
+
+      predefined = options[:predefined]
+      order = options[:order]
+
+      Colorizer.new(predefined: predefined, rules: rules, order: order)
+    end
+
+    def self.parse_options(args)
+      options = {}
+
+      args.push("-h") if args.empty?
+
+      OptionParser.new do |opts|
+        opts.banner = <<~HEREDOC
+          Rbcat it's a CLI tool which reads from standard input (STDIN),
+          colorizes content by set of regex rules from a config file,
+          and then writes it to standard output.
+        HEREDOC
+        opts.separator ""
+
+        predefined_desc = "Colorize input by set of predefined rules. " \
+          "Currently there are json/hash 'jsonhash' and ruby's logger 'logger'. " \
+          "Example: --predefined=jsonhash,logger"
+        opts.on("-p", "--predefined GROUPS", Array, predefined_desc) do |arg|
+          options[:predefined] = arg
+        end
+
+        rules_desc = "Path to the custom yaml config for rbcat."
+        opts.on("-r", "--rules PATH", rules_desc) do |arg|
+          options[:rules] = arg
+        end
+
+        order_desc = "Specify order for predefined and custom rules." \
+          "Avaiable options: 'predefined_first' (default) or 'predefined_last'."
+        opts.on("-o", "--order ORDER", order_desc) do |arg|
+          options[:order] = arg
+        end
+
+        opts.on("-c", "--print_colors", "Print all avaiable colors.") do
+          Rbcat::Colorizer.print_colors
+          exit
+        end
+
+        opts.on_tail("-v", "--version", "Show version") do
+          puts Rbcat::VERSION
+          exit
+        end
+      end.parse!(args)
+
+      options
+    end
+  end
+end

data/lib/rbcat/colorizer.rb

@@ -0,0 +1,96 @@
+module Rbcat
+  class Colorizer
+    def self.print_colors
+      Rbcat::Colors::DEFAULT.each do |key, value|
+        puts "#{value}#{key}\e[0m"
+      end
+    end
+
+    def initialize(predefined: nil, rules: nil, order: nil)
+      @config = create_config(predefined, rules, order)
+    end
+
+    def colorize(string)
+      return string if ENV["RBCAT_COLORIZER"] == "false"
+
+      colors = Rbcat::Colors::DEFAULT
+      @config.each_value do |settings|
+        if settings[:once]
+          string.sub!(settings[:regexp]) do |match|
+            colors[settings[:color]] + match + colors[:default]
+          end
+        elsif settings[:colors]
+          string.gsub!(settings[:regexp]) do
+            str = ""
+            Regexp.last_match.captures.each_with_index do |match, i|
+              str << colors[settings[:colors][i]] + match + colors[:default]
+            end
+
+            str
+          end
+        else
+          string.gsub!(settings[:regexp]) do |match|
+            colors[settings[:color]] + match + colors[:default]
+          end
+        end
+      end
+
+      string
+    end
+
+    def uncolorize(string)
+      pattern = /\033\[([0-9]+);([0-9]+)m|\033\[([0-9]+)m/m
+      string.gsub(pattern, "")
+    end
+
+    private
+
+    def create_config(predefined, rules, order)
+      predefined_rules = predefined ? predefined : Rbcat.configuration&.predefined
+      rules ||= Rbcat.configuration&.rules
+
+      raise ConfigurationError, "No config defined." unless predefined_rules || rules
+      if rules && rules.class != Hash
+        raise ConfigurationError, "Incorrect configuration. " \
+          "There is error while converting yaml config into Ruby's hash of rules."
+      end
+
+      config = {}
+      order ||= Rbcat.configuration&.order || :predefined_first
+
+      case order
+      when :predefined_first
+        predefined_rules&.each do |group|
+          config.merge!(Object.const_get "Rbcat::Rules::#{group.to_s.upcase}")
+        end
+
+        rules ? deep_merge(config, rules) : config
+      when :predefined_last
+        config.merge!(rules) if rules
+
+        predefined_rules&.each do |group|
+          config.merge!(Object.const_get "Rbcat::Rules::#{group.to_s.upcase}")
+        end
+
+        config
+      else
+        raise ConfigurationError, "Wrong type of order: #{order}. " \
+          "Define :predefined_first (default) or :predefined_last"
+      end
+    end
+
+    def deep_merge(hash, other_hash)
+      other_hash.each_pair do |current_key, other_value|
+        this_value = hash[current_key]
+        hash[current_key] =
+          if this_value.is_a?(Hash) && other_value.is_a?(Hash)
+            deep_merge(this_value, other_value)
+          else
+            other_value
+          end
+      end
+
+      hash
+    end
+  end
+end

data/lib/rbcat/colors.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Rbcat
+  module Colors
+    DEFAULT = {
+      default:    "\033[0m",
+      bold:       "\033[1m",
+      underline:  "\033[4m",
+      blink:      "\033[5m",
+      reverse:    "\033[7m",
+      concealed:  "\033[8m",
+
+      black:      "\033[30m",
+      red:        "\033[31m",
+      green:      "\033[32m",
+      yellow:     "\033[33m",
+      blue:       "\033[34m",
+      magenta:    "\033[35m",
+      cyan:       "\033[36m",
+      white:      "\033[37m",
+
+      on_black:   "\033[40m",
+      on_red:     "\033[41m",
+      on_green:   "\033[42m",
+      on_yellow:  "\033[43m",
+      on_blue:    "\033[44m",
+      on_magenta: "\033[45m",
+      on_cyan:    "\033[46m",
+      on_white:   "\033[47m",
+
+      bright_black:      "\033[30;90m",
+      bright_red:        "\033[31;91m",
+      bright_green:      "\033[32;92m",
+      bright_yellow:     "\033[33;93m",
+      bright_blue:       "\033[34;94m",
+      bright_magenta:    "\033[35;95m",
+      bright_cyan:       "\033[36;96m",
+      bright_white:      "\033[37;97m",
+
+      on_bright_black:   "\033[40;100m",
+      on_bright_red:     "\033[41;101m",
+      on_bright_green:   "\033[42;102m",
+      on_bright_yellow:  "\033[43;103m",
+      on_bright_blue:    "\033[44;104m",
+      on_bright_magenta: "\033[45;105m",
+      on_bright_cyan:    "\033[46;106m",
+      on_bright_white:   "\033[47;107m"
+    }.freeze
+  end
+end

data/lib/rbcat/configuration.rb

@@ -0,0 +1,20 @@
+module Rbcat
+  class << self
+    attr_accessor :configuration
+  end
+
+  def self.configure
+    self.configuration ||= Configuration.new
+    yield(configuration)
+  end
+
+  class Configuration
+    attr_accessor :predefined, :rules, :order
+
+    def initialize
+      @predefined = nil
+      @rules = nil
+      @order = nil
+    end
+  end
+end

data/lib/rbcat/configuration_error.rb

@@ -0,0 +1,3 @@
+module Rbcat
+  ConfigurationError = Class.new(StandardError)
+end

data/lib/rbcat/rules.rb

@@ -0,0 +1,53 @@
+module Rbcat
+  module Rules
+    JSONHASH = {
+      value_integer: {
+        regexp: /(?<=\"\:)\d+|(?<=\=\>)\d+/m,
+        color: :cyan
+      },
+      key_string: {
+        regexp: /\"[^\"]*\"(?=\:)/m,
+        color: :green
+      },
+      key_symbol: {
+        regexp: /\:[\p{L}\_\d]*(?=\=\>)|\:\"[^\"]*\"(?=\=\>)/m,
+        color: :magenta
+      },
+      value_string: {
+        regexp: /\"(?:[^"\\]|\\.)*\"(?=[\,\n\}\]])/m,
+        color: :yellow
+      },
+      value_null_nil: {
+        regexp: /(?<=\:)null|(?<=\=\>)nil/m,
+        color: :magenta
+      },
+      value_true_false: {
+        regexp: /(?<=\:)(false|true)|(?<=\=\>)(false|true)/m,
+        color: :magenta
+      }
+    }.freeze
+
+    LOGGER = {
+      info_logger: {
+        regexp: /INFO(\s--\s:|)/m,
+        color: :cyan,
+        once: true
+      },
+      error_logger: {
+        regexp: /ERROR(\s--\s:|)/m,
+        color: :red,
+        once: true
+      },
+      warn_logger: {
+        regexp: /WARN(\s--\s:|)/m,
+        color: :yellow,
+        once: true
+      },
+      debug_logger: {
+        regexp: /DEBUG(\s--\s:|)/m,
+        color: :green,
+        once: true
+      }
+    }.freeze
+  end
+end

data/lib/rbcat/version.rb

@@ -0,0 +1,3 @@
+module Rbcat
+  VERSION = "0.1.0"
+end

data/rbcat.gemspec

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "rbcat/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "rbcat"
+  spec.version       = Rbcat::VERSION
+
+  spec.authors       = ["Victor Afanasev"]
+  spec.email         = ["vicfreefly@gmail.com"]
+
+  spec.summary       = "Colorize output by defined set of regex rules"
+  spec.description   = "Colorize output by defined set of regex rules"
+  spec.homepage      = "https://github.com/vfreefly/rbcat"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = "rbcat"
+  spec.require_paths = ["lib"]
+  spec.required_ruby_version = ">= 2.3.0"
+
+  spec.add_development_dependency "bundler", "~> 1.16"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: rbcat
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Victor Afanasev
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-03-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Colorize output by defined set of regex rules
+email:
+- vicfreefly@gmail.com
+executables:
+- rbcat
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/rbcat
+- lib/rbcat.rb
+- lib/rbcat/cli.rb
+- lib/rbcat/colorizer.rb
+- lib/rbcat/colors.rb
+- lib/rbcat/configuration.rb
+- lib/rbcat/configuration_error.rb
+- lib/rbcat/rules.rb
+- lib/rbcat/version.rb
+- rbcat.gemspec
+homepage: https://github.com/vfreefly/rbcat
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Colorize output by defined set of regex rules
+test_files: []