hylite 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: '029f1390d68bcdad670b11ba3c3bd1c7688745dd'
+  data.tar.gz: 5e1a2079b48cc1fbe2b501c36f155611647402a1
+SHA512:
+  metadata.gz: 525bf92d906fc94f8eb4891162c1cf7d21aaea4d75b9ec8b04e73309674131d43d98c1f1382c505579e7fd8aa42acdb4f1b4d99d18b48955311e96172a6159c0
+  data.tar.gz: 21175e7b41dff749412da917726f9045a3651a308188b2f3cfe44a82e4197bd4811ad8d439f21a5bf689d406a407f5f0e2fb8cf6b62bf7c1861f4d9f524b38a6

data/.gitignore

@@ -0,0 +1,5 @@
+# don't commit the lock deps on gems, it should work for any versions that satisfy the Gemfile
+Gemfile.lock
+
+# don't commit the .gem file, it's big, binary, and can be generated
+*.gem

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Readme.md

@@ -0,0 +1,71 @@
+Hylite
+======
+
+Syntax Highlighting for scripters.
+
+It has a simple binary-interface and Ruby interface that tries to find a
+syntax highlighting tool on your machine and then highlight your code using that tool.
+
+The intent:
+
+1. Allow a script to find and use an existing syntax highlighter without needing
+   to add one as a dependency.
+2. All syntax highlighting that I've seen have stupidly difficult interfaces
+   (often buggy, difficult to discover, the obvious use case requires non-obvious
+   configuration which is difficult to discover and has mediocre defaults),
+   the intent here is to improve discoverability, have it do the obvious thing
+   by default, and choose reasonable defaults so that you rarely have to configure it.
+3. If you find ways that it doesn't do this, let me know. Eg I didn't test the
+   themes on a light background to make sure they look good there. That might make
+   the defaults only work well on dark backgrounds.
+
+If you're not scripting, you'll want to use one of the libraries this tool wraps:
+
+* [Rouge](http://rouge.jneen.net)
+* [Coderay](http://coderay.rubychan.de)
+* [Pygments](http://pygments.org)
+
+
+Todo
+----
+
+* Allow user to pass a filename as that's a pretty obvious way to use it,
+  and that's probably a nicer interface for non-Ruby projects.
+* Possibly allow it to guess the default (eg Rouge will do this)
+
+
+Interface
+---------
+
+```sh
+# Simplest interface
+$ cat my_code.rb | hylite
+
+# Highlight other languages
+$ cat my_code.c | hylite --lang c
+```
+
+
+Development
+-----------
+
+Assuming a working Ruby development environment (try [chruby](https://github.com/postmodern/chruby) if you don't have one).
+
+```sh
+# Install Bundler for dependency management, if you don't already have it
+$ gem install bundler
+
+# Tell bundler to install the dev dependencies
+$ bundle install
+
+# Run the tests
+$ mrspec
+```
+
+
+License
+-------
+
+[WTFPL](http://www.wtfpl.net/about/), Just do what the fuck you want to.
+
+NO WARRANTY.

data/bin/hilight_syntax

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+# this is here to improve discoverability
+$stderr.puts "Use the `hylite` binary (`#{$PROGRAM_NAME}` exists for discoverability)"
+load File.join(__dir__, 'hylite')

data/bin/hylite

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('../lib', __dir__)
+require 'hylite/cli'
+
+cli = Hylite::CLI.new($stdin, ARGV)
+if cli.success?
+  $stdout.puts cli.result
+else
+  $stderr.puts cli.errors
+end
+exit cli.success?

data/bin/syntax_hilight

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+# this is here to improve discoverability
+$stderr.puts "Use the `hylite` binary (`#{$PROGRAM_NAME}` exists for discoverability)"
+load File.join(__dir__, 'hylite')

data/hylite.gemspec

@@ -0,0 +1,23 @@
+$:.push File.expand_path("lib", __dir__)
+require "hylite/version"
+
+Gem::Specification.new do |s|
+  s.name        = "hylite"
+  s.version     = Hylite::VERSION
+  s.authors     = ["Josh Cheek"]
+  s.email       = ["josh.cheek@gmail.com"]
+  s.homepage    = "https://github.com/JoshCheek/hylite"
+  s.summary     = %q{Syntax Highlighting for scripters}
+  s.description = %q{Provides a simple binary interface and Ruby interface to highlight your code using whatever tools you already have on your machine.}
+  s.license     = "WTFPL"
+
+  s.files         = `git ls-files`.split("\n") - Dir['mascots/*']
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = ['hylite', 'syntax_hilight', 'hilight_syntax']
+  s.require_paths = ['lib']
+
+  s.add_development_dependency "rspec",       "~> 3.0"
+  s.add_development_dependency "rouge",       "~> 2.0"
+  s.add_development_dependency "coderay",     "~> 1.0"
+  s.add_development_dependency "ultraviolet", "~> 1.0"
+end

data/lib/hylite.rb

@@ -0,0 +1,34 @@
+require 'hylite/choose_hyliter'
+
+class Hylite
+  def self.call(*args)
+    new(*args).call
+  end
+
+  attr_reader :lang
+
+  def initialize(to_highlight, options={})
+    self.to_highlight = to_highlight
+    options.each do |key, value|
+      if key =~ /^l/
+        self.lang = value
+      end
+    end
+    self.lang ||= 'ruby'
+  end
+
+  def call
+    code = to_highlight
+    code = code.read if code.respond_to? :read
+    hyliter(code, lang).call
+  end
+
+  private
+
+  attr_accessor :to_highlight
+  attr_writer   :lang
+
+  def hyliter(code, lang)
+    ChooseHyliter.call(code, lang)
+  end
+end

data/lib/hylite/choose_hyliter.rb

@@ -0,0 +1,36 @@
+require 'open3'
+require 'hylite/hyliters'
+
+class Hylite
+  module ChooseHyliter
+    extend self
+
+    def call(code, lang)
+      case
+      when rouge_available?    then Rouge.new(code, lang)
+      when pygments_available? then Pygments.new(code, lang)
+      when coderay_available?  then CodeRay.new(code, lang)
+      end
+    end
+
+    def rouge_available?
+      require 'rouge'
+      true
+    rescue LoadError
+      false
+    end
+
+    def pygments_available?
+      ENV['PATH'].split(File::PATH_SEPARATOR).any? do |dir|
+        File.exist? File.join(dir, 'pygmentize')
+      end
+    end
+
+    def coderay_available?
+      require 'rouge'
+      true
+    rescue LoadError
+      false
+    end
+  end
+end

data/lib/hylite/cli.rb

@@ -0,0 +1,64 @@
+require 'hylite'
+
+class Hylite
+  class CLI
+    def initialize(stdin, argv)
+      self.stdin = stdin
+      self.argv = argv
+    end
+
+    def errors
+      config.errors
+    end
+
+    def result
+      ensure_evaluated
+      @result
+    end
+
+    def success?
+      ensure_evaluated
+      errors.none?
+    end
+
+    def errors
+      config.fetch :errors
+    end
+
+    def config
+      @config ||= parse(argv)
+    end
+
+    private
+
+    attr_accessor :stdin, :argv
+
+    def ensure_evaluated
+      return if @evaluated
+      @evaluated = true
+      @success   = true
+      @result    = Hylite.call(stdin, config)
+    end
+
+    def parse(args)
+      config = {errors: [], help: false, lang: nil}
+      args   = args.dup
+      while args.any?
+        arg = args.shift
+        case arg
+        when '-h', '--help'
+          config[:help] = true
+        when '-l', /^--l.*/
+          if lang = args.shift
+            config[:lang] = lang
+          else
+            config[:errors] << "Expected a language after #{arg.inspect}"
+          end
+        else
+          config[:errors] << "Unknown argument #{arg.inspect}"
+        end
+      end
+      config
+    end
+  end
+end

data/lib/hylite/hyliters.rb

@@ -0,0 +1,56 @@
+require 'open3'
+
+class Hylite
+  class Hyliter
+    attr_reader :code, :lang
+    def initialize(code, lang)
+      @code, @lang = code, lang
+    end
+    def type
+      raise NotImplementedError, 'Subclass should define'
+    end
+  end
+
+  class Rouge < Hyliter
+    def type
+      :rouge
+    end
+    def call
+      # From Fish, you can see all styles with:
+      # for style in (rougify help style | tail -1 | tr -d ' ' | tr , \n); echo \n===== $style =====; rougify highlight -t $style -l ruby bin/hylite   ; end
+      theme     = ::Rouge::Theme.find 'monokai'
+      formatter = ::Rouge::Formatters::Terminal256.new theme
+      lexer     = ::Rouge::Lexer.find @lang
+      tokens    = lexer.lex @code
+      formatter.format(tokens)
+    end
+  end
+
+  class Pygments < Hyliter
+    def type
+      :pygments
+    end
+    def call
+      # From Fish, you can see all styles with:
+      # for style in (pygmentize -L styles | sed -n '/\*/s/[*: ]//gp'); echo \n===== $style =====; pygmentize -f terminal256 -O style=$style -l ruby < lib/hylite.rb ; end
+      out, err, status = Open3.capture3(
+        'pygmentize',
+        '-f', 'terminal256',
+        '-O', 'style=monokai',
+        '-l', lang,
+        stdin_data: code
+      )
+      return out if status.success? && err.empty?
+      raise "Uhhh, what led to this, I want to test it but don't know what can cause it / how to mimic it (and therefore what it should do)"
+    end
+  end
+
+  class CodeRay < Hyliter
+    def type
+      :coderay
+    end
+    def call
+      ::CodeRay.encode(code, lang, :terminal)
+    end
+  end
+end

data/lib/hylite/version.rb

@@ -0,0 +1,3 @@
+class Hylite
+  VERSION = '1.0.0'
+end

data/notes

@@ -0,0 +1,121 @@
+#!/usr/bin/env ruby
+
+# Rouge
+# * cat lib/hylite.rb | time rougify highlight -l ruby
+# * slower (0.24s, sometimes 2x that)
+# * 121 languages (coderay has 31, rouge 121)
+# * Has 15 themes
+
+  # require 'rouge'
+  #
+  # # See all styles (from fish)
+  # # for style in (rougify help style | tail -1 | tr -d ' ' | tr , \n); echo \n===== $style =====; rougify highlight -t $style -l ruby bin/rougify ; end
+  # Rouge::Theme.registry.keys
+  #
+  # # Using the lib
+  # formatter = Rouge::Formatters::Terminal256.new theme: 'colorful'
+  # lexer     = Rouge::Lexers::Ruby.new
+  # tokens    = lexer.lex raw_code
+  # formatter.format(tokens)
+  #
+  # # Number of languages
+  # Rouge::Lexer.all.length # => 113
+  #
+  # # Inferring the language (supports a mimetype, too, but not useful for this)
+  # Rouge::Lexer.guesses(filename: 'file.rb')                  # => [Rouge::Lexers::Ruby]
+  # Rouge::Lexer.guesses(filename: 'file.py')                  # => [Rouge::Lexers::Python]
+  # Rouge::Lexer.guesses(source: "#!/usr/bin/env ruby\n1+1")   # => [Rouge::Lexers::Ruby]
+  # Rouge::Lexer.guesses(source: "#!/usr/bin/env python\n1+1") # => [Rouge::Lexers::Python]
+  # Rouge::Lexer.guesses(source: "1+1")                        # => []
+  #
+  # Rouge.constants
+
+# CodeRay
+# * cat lib/hylite.rb | time coderay -ruby
+# * 3-4x faster (0.07s)
+# * 31 languages
+# * Has the nicest default theme
+# * Has only theme
+
+  # require 'coderay'
+  #
+  # # Using the lib
+  # CodeRay.encode '1+1', :ruby, :terminal # => "\e[1;34m1\e[0m+\e[1;34m1\e[0m"
+  #
+  # # Number of languages
+  # CodeRay::Scanners.list.length # => 27
+  #
+  # # Inferring language from filename (true means it should try checking the shebang)
+  # CodeRay::FileType.fetch 'somefile.zomg', :default_type, true # => :default_type
+  # CodeRay::FileType.fetch 'somefile.rb',   :default_type, true # => :ruby
+
+# Pygmentize
+# * $ cat lib/hylite.rb | time pygmentize -l ruby
+# * $ cat lib/hylite.rb | time ruby -e 'system "pygmentize -l ruby"'
+# * slow (0.18s, occasionallly 0.30s, but 0.24 when shelling out from Ruby)
+# * 402 languages (pygmentize -L lexers | ag '^\*' | wc -l)
+# * 26 themes (pygmentize -L styles | ag '^\*' | wc -l)
+  # $ pygmentize -L styles
+  # $ pygmentize -L formatters
+
+# Vim
+# * http://superuser.com/questions/554047/export-vim-syntax-highlighting-to-output-to-shell
+# * http://www.vim.org/scripts/script.php?script_id=4325
+# * http://unix.stackexchange.com/questions/90990/less-command-and-syntax-highlighting
+
+
+# ---------------------------------------------------------
+# How to control which libraries it can see:
+
+require 'rubygems'
+require 'open3'
+
+coderay       = Gem::Specification.find_by_name('coderay')
+coderay_paths = coderay.full_require_paths.join(":")
+
+rouge       = Gem::Specification.find_by_name('rouge')
+rouge_paths = rouge.full_require_paths.join(":")
+
+[ ['CodeRay',  ['-I', coderay_paths]],
+  ['Rouge',    ['-I', rouge_paths]],
+  ['Pygments', []],
+].each do |name, args|
+  puts "====  #{name}  ====="
+  system 'ruby', '--disable-gem', *args, '-e', <<-'RUBY'
+    which = 'pygments'
+
+    begin
+      require 'rouge'
+      which = 'rouge'
+    rescue LoadError
+      puts "\e[31mCould not load rouge\e[0m"
+    end
+
+    begin
+      require 'coderay'
+      which = 'coderay'
+    rescue LoadError
+      puts "\e[31mCould not load coderay\e[0m"
+    end
+
+    case which
+    when 'coderay'
+      puts "\e[32mUsing CodeRay\e[0m", CodeRay.encode("1+1", :ruby, :terminal)
+    when 'rouge'
+      theme     = Rouge::Theme.find 'tulip'
+      formatter = Rouge::Formatters::Terminal256.new theme
+      lexer     = Rouge::Lexers::Ruby.new
+      tokens    = lexer.lex "1+1"
+      puts "\e[32mUsing Rouge\e[0m", formatter.format(tokens)
+    when 'pygments'
+      require 'open3'
+      out, err, status = Open3.capture3 'pygmentize', '-f', 'terminal256', '-O', 'style=fruity', '-l', 'ruby', stdin_data: '1+1'
+      raise [status, err.inspect] unless status.success?
+      raise err unless err.empty?
+      puts "\e[32mUsing pygments\e[0m", out
+    else
+      raise "What!? #{which.inspect}"
+    end
+  RUBY
+end
+

data/spec/binary_spec.rb

@@ -0,0 +1,108 @@
+require 'open3'
+require 'hylite/cli'
+require 'spec_helpers'
+
+bin_dir     = File.expand_path '../bin', __dir__
+ENV["PATH"] = bin_dir + ":" + ENV["PATH"]
+
+RSpec.describe 'binaries' do
+  describe 'hylite' do
+    it 'reads code from stdin, highlights it, prints it to stdout' do
+      stdout, stderr, status = Open3.capture3 'hylite', stdin_data: '1+1'
+      expect(stderr).to be_empty
+      expect(status).to be_success
+      tokens = highlighted_tokens(stdout)
+      expect(tokens).to include :color
+      expect(tokens.select { |t| t.kind_of? String }).to eq %W[1 + 1 \n]
+    end
+
+    context 'when it has an error' do
+      it 'prints the error to stderr and exits with a failure code' do
+        stdout, stderr, status = Open3.capture3 'hylite -notanarg', stdin_data: '1+1'
+        expect(stderr).to include "notanarg"
+        expect(status).to_not be_success
+        expect(stdout).to be_empty
+      end
+    end
+
+    describe 'arguments' do
+      def unset
+        @unset ||= Object.new
+      end
+
+      def assert_parses(argv, key, value=unset)
+        cli = Hylite::CLI.new("", argv)
+        expect(cli.config[key]).to eq value unless value == unset
+        cli.config[key]
+      end
+
+      it 'prints a help screen for -h / --help and exits successfully' do
+        assert_parses [], :help, false
+        assert_parses [], :errors, []
+
+        assert_parses ['-h'], :help, true
+        assert_parses ['-h'], :errors, []
+
+        assert_parses ['--help'], :help, true
+        assert_parses ['--help'], :errors, []
+      end
+
+      describe 'language' do
+        it 'is not set by default (uses the lib\'s default of Ruby)' do
+          assert_parses [], :lang, nil
+        end
+
+        it 'can be specified with -l, --language, or --lmisspelled' do
+          assert_parses ['-l',           'java'], :lang, 'java'
+          assert_parses ['-l',            'cpp'], :lang, 'cpp'
+          assert_parses ['--lang',        'cpp'], :lang, 'cpp'
+          assert_parses ['--lmisspelled', 'cpp'], :lang, 'cpp'
+        end
+
+        it 'sets an error if it sees a language arg without a language' do
+          assert_parses ["-l", "cpp"], :errors, []
+          errors = assert_parses ["-l"], :errors
+          expect(errors.length).to eq 1
+          expect(errors[0]).to match /language/
+        end
+
+        it 'highlights according to the provided language' do
+          ruby = Hylite.call '1', lang: 'ruby'
+          css  = Hylite.call '1', lang: 'css'
+          expect(ruby).to_not eq css
+        end
+      end
+
+      it 'sets an error if it sees an arg it doesn\'t understand' do
+        errors = assert_parses ["asdf"], :errors
+        expect(errors.length).to eq 1
+        expect(errors[0]).to match /asdf/
+      end
+
+      it 'passes the config, parsed from the arguments, down to the lib' do
+        ruby_stdout, ruby_stderr, ruby_status = Open3.capture3 'hylite -l ruby', stdin_data: '1+1'
+        css_stdout,  css_stderr,  css_status  = Open3.capture3 'hylite -l css', stdin_data: '1+1'
+
+        expect(ruby_stderr).to     eq css_stderr
+        expect(ruby_status).to     eq css_status
+        expect(ruby_stdout).to_not eq css_stdout
+      end
+    end
+  end
+
+  describe 'binaries that exist for discoverability' do
+    specify 'syntax_hilight: warns you to use hylite, but still works' do
+      stdout, stderr, status = Open3.capture3 'syntax_hilight', stdin_data: '1+1'
+      expect(stderr).to match /hylite/
+      expect(status).to be_success
+      expect(stdout).to_not be_empty
+    end
+
+    specify 'highlight_syntax: warns you to use hylite, but still works' do
+      stdout, stderr, status = Open3.capture3 'highlight_syntax', stdin_data: '1+1'
+      expect(stderr).to match /hylite/
+      expect(status).to be_success
+      expect(stdout).to_not be_empty
+    end
+  end
+end

data/spec/choose_hyliter.rb

@@ -0,0 +1,48 @@
+require 'hylite/choose_hyliter'
+require 'rouge'
+
+RSpec.describe 'ChooseHyliter' do
+  # ugh, might be better to inject require than this nonsense >.<
+
+  it 'uses rouge if available' do
+    hyliter = Hylite::ChooseHyliter.call("#a { color: #FFF; }" , "css")
+    expect(hyliter.type).to eq :rouge
+
+    hylited = hyliter.call
+    expect(hyliter.call).to include 'FFF'
+    expect(hyliter.call).to include "\e[" # an escape sequence in there somewhere
+  end
+
+
+  it 'does not use rouge if it does not support the requested language'
+
+
+  it 'uses pygments if rouge, isn\'t available' do
+    allow(Hylite::ChooseHyliter).to receive(:require).with('rouge').and_raise(LoadError)
+
+    hyliter = Hylite::ChooseHyliter.call("#a { color: #FFF; }" , "css")
+    expect(hyliter.type).to eq :pygments
+
+    hylited = hyliter.call
+    expect(hyliter.call).to include 'FFF'
+    expect(hyliter.call).to include "\e[" # an escape sequence in there somewhere
+  end
+
+
+  it 'uses coderay if rouge and pygmentize aren\'t available' do
+    require 'coderay'
+    allow(File).to receive(:exist?).and_return(false)
+    allow(Hylite::ChooseHyliter).to receive(:require).with('rouge').and_raise(LoadError)
+    allow(Hylite::ChooseHyliter).to receive(:require).with('coderay').and_return(true)
+
+    hyliter = Hylite::ChooseHyliter.call("#a { color: #FFF; }" , "css")
+    expect(hyliter.type).to eq :coderay
+
+    hylited = hyliter.call
+    expect(hyliter.call).to include 'FFF'
+    expect(hyliter.call).to include "\e[" # an escape sequence in there somewhere
+  end
+
+
+  it 'tells you how to install these other libs if none of them are available'
+end

data/spec/hylite_spec.rb

@@ -0,0 +1,40 @@
+require 'stringio'
+require 'spec_helpers'
+require 'hylite'
+
+RSpec.describe 'hylite' do
+  it 'invokes whichever hyliter "ChooseHyliter" returns', t:true do
+    expect(Hylite::ChooseHyliter).to receive(:call).with("to hylite", 'some lang').and_return(-> { "hylited" })
+    hylited = Hylite.new("to hylite", l: "some lang").call
+    expect(hylited).to eq "hylited"
+  end
+
+  it 'defaults the language to Ruby' do
+    expect(Hylite.new(''          ).lang).to     eq 'ruby'
+    expect(Hylite.new('', l:   nil).lang).to     eq 'ruby'
+    expect(Hylite.new('', l: 'css').lang).to_not eq 'ruby'
+  end
+
+
+  it 'can be overridden with the :l, :language, or :lmisspelled keywords' do
+    h = Hylite.new '', l: 'forth'
+    expect(h.lang).to eq 'forth'
+
+    h = Hylite.new '', lang: 'forth'
+    expect(h.lang).to eq 'forth'
+
+    h = Hylite.new '', lmisspelled: 'forth'
+    expect(h.lang).to eq 'forth'
+  end
+
+  it 'accepts strings or streams to highlight' do
+    # Based on CodeRay's formatting of "1":
+    #                 ["\e[1;34m", "1", "\e[0m"]
+    expected_tokens = [:color,     "1", :color]
+    string          = '1'.freeze
+    stream          = StringIO.new string
+
+    expect(highlighted_tokens Hylite.call string).to eq expected_tokens
+    expect(highlighted_tokens Hylite.call stream).to eq expected_tokens
+  end
+end

data/spec/spec_helpers.rb

@@ -0,0 +1,13 @@
+module SpecHelpers
+  def highlighted_tokens(ansi_string)
+    ansi_string.scan(/\e.*?m|[^\e]+/).map do |token|
+      token[0] == "\e" ? :color : token
+    end
+  end
+end
+
+RSpec.configure do |config|
+  config.include SpecHelpers
+  config.fail_fast = true
+  config.color     = true
+end

metadata

@@ -0,0 +1,125 @@
+--- !ruby/object:Gem::Specification
+name: hylite
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Josh Cheek
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-12-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rouge
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: coderay
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: ultraviolet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Provides a simple binary interface and Ruby interface to highlight your
+  code using whatever tools you already have on your machine.
+email:
+- josh.cheek@gmail.com
+executables:
+- hylite
+- syntax_hilight
+- hilight_syntax
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Readme.md
+- bin/hilight_syntax
+- bin/hylite
+- bin/syntax_hilight
+- hylite.gemspec
+- lib/hylite.rb
+- lib/hylite/choose_hyliter.rb
+- lib/hylite/cli.rb
+- lib/hylite/hyliters.rb
+- lib/hylite/version.rb
+- notes
+- spec/binary_spec.rb
+- spec/choose_hyliter.rb
+- spec/hylite_spec.rb
+- spec/spec_helpers.rb
+homepage: https://github.com/JoshCheek/hylite
+licenses:
+- WTFPL
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: Syntax Highlighting for scripters
+test_files:
+- spec/binary_spec.rb
+- spec/choose_hyliter.rb
+- spec/hylite_spec.rb
+- spec/spec_helpers.rb