ergane 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6f27bb356ea374b87bf0a12ad73bc945e518dee66aa18797b5f9b06a197de896
+  data.tar.gz: 2de58095dd7014c321d13fcac71f9d16019db72cd6feb0896bafea5f9ae19d6e
+SHA512:
+  metadata.gz: 3a3431e9dd63b745dc3765a83c98c0d3ed3d60837373d12b69371f1df05e5718be8b2fd5007808e4383ba8d77c0fd6997ba7dc867e317b5b598fc80921429161
+  data.tar.gz: fa7972b5a4019cff455ca2f0631181cb3ce49192a56ee01eb549c22827fbc8d41b77cc86d089178d04e2b63474626faab18dd3acbe45be12aedaec5a37254955

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2023-04-26
+
+- Initial release

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Dale Stevens
+
+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,18 @@
+# Ergane
+**The patron goddess of craftsmen and artisans**
+
+Library for creating lightweight, yet powerful CLI tools in Ruby.
+Emphasis and priority on load speed and flexibility.
+
+## Requirements
+Ruby 2.7+
+
+May work with older versions.
+
+## Contributing
+
+1. Fork it ( https://github.com/TwilightCoders/ergane/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/app/commands/ergane/console.rb

@@ -0,0 +1,22 @@
+define :console do
+
+  description "Jump into an interactive REPL console"
+
+  requirements inherit: true do
+    require 'colorize'
+
+  end
+
+  switches(inherit: false) do
+    # option(:help, description: "display help")
+  end
+
+  run do
+    Pry.config.prompt_name = "#{Process.argv0.split('/').last.capitalize} #{label} ".light_blue
+    Pry.start
+  end
+
+  def support_method
+
+  end
+end

data/bin/ergane

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+
+profile = nil
+if ARGV.include?('--profile')
+  require 'ruby-prof'
+  profile = RubyProf::Profile.new
+  profile.exclude_common_methods!
+  profile.start
+end
+
+require 'bundler/setup'
+require 'ergane'
+require 'ergane/tool'
+
+tool = Ergane::Tool.new :ergane, 'lib/ergane/commands/**/*.rb', 'app/**/commands/**/*.rb'
+tool.run
+
+if profile
+  result = profile.stop
+  File.open "profile-graph.html", 'w+' do |file|
+    # RubyProf::GraphHtmlPrinter.new(results).print(file)
+    RubyProf::CallStackPrinter.new(result).print(file)
+  end
+end

data/lib/core_ext/option_parser.rb

@@ -0,0 +1,15 @@
+class OptionParser
+
+  # Like order!, but leave any unrecognized --switches alone
+  def order_recognized!(args)
+    extra_opts = []
+    begin
+      order!(args) { |a| extra_opts << a }
+    rescue OptionParser::InvalidOption => e
+      extra_opts << e.args[0]
+      retry
+    end
+    args[0, 0] = extra_opts
+  end
+
+end

data/lib/ergane/command_definition.rb

@@ -0,0 +1,176 @@
+# IDEA: "switches" are just "inline commands".
+#       They share a similar structure to a command.
+#       They have a label, description, and optionally a "run block"
+
+require 'pry'
+require 'helpers/hashall'
+require 'switch_definition'
+
+module Ergane
+
+  class CommandDefinition < Hashall
+
+    attr_reader :label
+    attr_reader :chain
+    attr_reader :description
+    attr_reader :switch_definitions
+    attr_reader :switch_parser
+    attr_reader :requirements_block
+    attr_reader :run_block
+
+    def pretty_print(q)
+      q.text "#{self.class.name} (#{label})"
+      q.text "\n\tCommands:"
+      q.group(1, " {", "}") do
+        self.each_pair do |key, value|
+          q.breakable
+          q.text "#{key}: #{value}"
+        end
+      end
+    end
+
+    def run(*args)
+      if run_block
+        instance_exec(&requirements_block) if requirements_block
+        instance_exec(*args, &run_block) if run_block
+      else
+        puts "show help for this command"
+      end
+    end
+
+    def self.define(label, chain: [], &block)
+      new(label, *chain).tap do |c|
+        c.define(chain: chain, &block)
+      end
+    end
+
+    def define(chain: [], &block)
+      dsl_parse(&block)
+    end
+
+    def commands
+      self.to_h
+    end
+
+    def arguments
+      if commands.any?
+        commands.keys
+      else
+        instance_method(:run).parameters.map { |arg| arg[1] }
+      end
+    end
+
+    def default_switches
+      @default_switches ||= switch_definitions.inject({}) do |collector, (label, switch)|
+        collector[label] = switch.default
+        collector
+      end
+      @default_switches.dup
+    end
+
+    def parse_args(args, path = [])
+      if args.any? && args.first.match(/\A(\w+)\z/) && word = args.first.to_sym
+        case command = self[word]
+        when CommandDefinition
+          path << args.shift
+          command.parse_args(args, path)
+        else
+          puts "no such subcommand #{word} for #{self}"
+        end
+      else
+        # These are args for this command now.
+        Ergane.logger.debug "Now, process these args #{args} for #{label}"
+        switch_parser.order_recognized!(args)
+        [self, args || []]
+      end
+    end
+
+    protected
+
+    def dsl_parse(&block)
+      dsl = DSL.new.tap do |dsl|
+        dsl.instance_eval(&block)
+      end
+      @switch_definitions.merge!(dsl.config.delete(:switch_definitions))
+      dsl.config.each do |k, v|
+        begin
+          instance_variable_set("@#{k}", v)
+        rescue
+          binding.pry
+        end
+      end
+
+      switches = default_switches
+      switch_definitions.values.each do |o|
+        o.attach(@switch_parser, self) do |value|
+          value = case o.kind
+          when TrueClass
+            true
+          when FalseClass
+            false
+          else
+            value.nil? ? true : value
+          end
+          Ergane.logger.debug "Setting switches[#{o.label}] = #{value.inspect}"
+          switches[o.label] = value
+        end
+      end
+    end
+
+    private
+
+    def initialize(label, *chain)
+      super()
+      @chain = chain
+      @label = label
+      @switch_definitions = {}
+      @requirement_options = {
+        inherit: true
+      }
+      @run_options = {
+        inherit: true
+      }
+      @switch_parser = OptionParser.new
+    end
+
+    class DSL
+      attr_reader :config
+
+      def initialize
+        @config = {
+          switch_definitions: {},
+          run_block: nil,
+          requirements_block: nil
+        }
+      end
+
+      def method_missing(k, v)
+        @config[k] = v
+      end
+
+      def switches(inherit: true, drop: [], &block)
+        def option(label, short: nil, kind: nil, description: nil, default: nil, &block)
+          label, argument = case label
+            when Hash
+              [label.keys.first, "=#{label.values.first}"]
+            else
+              [label, nil]
+            end
+          warn "Warning! #{label.inspect} option is being redefined.".red if @config[:switch_definitions][label]
+          @config[:switch_definitions][label] = SwitchDefinition.new(label, argument: argument, short: short, kind: kind, description: description, default: default, &block)
+        end
+        block.call if block_given?
+        @config[:switch_definitions]
+      end
+
+      def requirements(options, &block)
+        @config[:requirements_block] = block
+      end
+
+      def run(&block)
+        # puts "setting run_block"
+        @config[:run_block] = block
+      end
+    end
+  end
+end

data/lib/ergane/debug.rb

@@ -0,0 +1,75 @@
+module Ergane
+  module Debug
+
+    class << self
+
+      @nl = false
+
+      def enable_break!
+        class << self
+          define_method(:break, &binding.method(:pry))
+        end
+      end
+
+      def suppress
+        original_stdout, original_stderr = $stdout.clone, $stderr.clone
+        $stderr.reopen File.new('/dev/null', 'w')
+        $stdout.reopen File.new('/dev/null', 'w')
+        yield
+      ensure
+        $stdout.reopen original_stdout
+        $stderr.reopen original_stderr
+      end
+
+      def break
+        puts "Breakpoints Not Enabled"
+      end
+
+      def format_print(m)
+        case m
+        when String
+          format_print(m.split("\n"))
+        when Array
+          m.join("\n\t")
+        else
+          m
+        end
+      end
+
+      def puts(m=nil, prefix: false, &block)
+        prefix ||= $debug ? 'DEBUG' : false
+        if (prefix)
+          if @nl || m.blank?
+            $stdout.puts format_print(m)
+          else
+            $stdout.print "[#{prefix.upcase.light_magenta}] " unless prefix.blank?
+            $stdout.puts format_print(m)
+          end
+        else
+          yield if block_given?
+        end
+        @nl = false
+      end
+
+      def print(m=nil, prefix: false, &block)
+        @nl = true
+        prefix ||= $debug ? 'DEBUG' : false
+        if (prefix)
+          if (m.blank?)
+            $stdout.print format_print(m)
+          else
+            $stdout.print "[#{prefix.upcase.light_magenta}] " unless prefix.blank?
+            $stdout.print format_print(m)
+          end
+        else
+          yield if block_given?
+        end
+      end
+
+    end
+
+    enable_break! if $debug
+
+  end
+
+end

data/lib/ergane/helpers/hashall.rb

@@ -0,0 +1,8 @@
+module Ergane
+  class Hashall < Hash
+    def initialize(*args)
+      super()
+      self.default_proc = -> (h, k) { h[k] = self.class.new(*args) }
+    end
+  end
+end

data/lib/ergane/switch_definition.rb

@@ -0,0 +1,49 @@
+module Ergane
+  class NamedBlock
+    def self.new(*args, &block)
+      Class.new do
+        args.each do |arg|
+          attr_reader arg.to_sym
+        end
+
+        def initialize(label, args)
+          @label = label.to_sym
+          args.each do |arg, value|
+            instance_variable_set("@#{args}", value)
+          end
+        end
+      end
+    end
+    private :initialize
+  end
+
+  class SwitchDefinition < NamedBlock.new(:short, :kind, :argument, :description, :default)
+    attr_reader :label
+    attr_reader :short
+    attr_reader :kind
+    attr_reader :argument
+    attr_reader :description
+    attr_reader :default
+    attr_reader :run_block
+
+    def initialize(label, short: nil, argument: nil, kind: nil, description: nil, default: nil, &block)
+      @label, @short, @argument, @kind, @description, @default = label.to_sym, short, argument, kind, description, default
+      @run_block = block if block_given?
+    end
+
+    def attach(option_parser, command, &block)
+      flag_arg = argument ? "=#{argument}" : ""
+      args = []
+      args << "-#{short}#{flag_arg}" if short
+      args << "--#{label.to_s.gsub(/_/, '-')}#{flag_arg}"
+      args << kind if kind
+      args << description if description
+
+      option_parser.on(*args, Proc.new { |value|
+        command.instance_exec(value, &block) if block_given?
+        command.instance_exec(value, &run_block) if run_block
+      })
+    end
+
+  end
+end

data/lib/ergane/tool.rb

@@ -0,0 +1,116 @@
+module Ergane
+  class Tool < CommandDefinition
+    attr_reader :title #capitalized :label
+    attr_reader :version
+
+    def initialize(label, *paths)
+      super(label)
+
+      @title = label.capitalize
+      @version = VERSION
+
+      # Dogfood-ing
+      define do
+        description "Basic CLI Tool"
+        switches do
+          switch :help, default: false, kind: TrueClass, description: "Display this help block" do
+            raise Help
+          end
+          switch :version, default: false, kind: TrueClass, description: "Display the version" do
+            # TODO: Push ARGV into a variable at the command level that can be manipulated by flags/switches
+            # NOTE: This would allow a --version to morph into a version command and we could push all this logic to that.
+            # Additional logic for --version would be -1 or --short etc.
+            puts "#{@title} Version: #{Ergane::VERSION}"
+            exit
+          end
+          # switch verbose: FalseClass, short: :v, "Turn on verbose logging"
+        end
+
+        run do
+          begin
+            command, args = self, []
+            Process.setproctitle(label.to_s)
+            command, args = self.parse_args(ARGV.dup)
+
+            command.run(*args)
+            puts "Finished running #{label}"
+          rescue Interrupt
+            puts "\nOkay. Aborting."
+          rescue RuntimeError
+            puts "RuntimeError"
+            binding.pry
+          rescue Help
+            puts help(command, args)
+          ensure
+            system "printf '\033]0;\007'"
+          end
+        end
+      end
+
+      Pry.config.prompt_name = "#{title} ".light_blue
+
+      load_commands(paths)
+    end
+
+    def help(command, args=[])
+      missing_args = command.arguments.product([false]).to_h.merge(args.product([true]).to_h).map do |arg, is_missing|
+        a = arg.to_s.light_black.underline.tap do |b|
+          b.blink if is_missing
+        end
+      end.join(' ')
+
+      command.switch_parser.banner = [].tap do |text|
+        text << "About: #{description}"
+        text << "Version:  #{version.to_s.light_blue}"
+        text << "Usage: #{([label] + chain).join(' ').light_red} #{'[options]'.light_cyan} "
+        if commands.any?
+          text.last << "[subcommand]".light_black.underline
+          text << ("    ┌" + ("─" * (text.last.uncolorize.length - 12)) + "┘").light_black
+          commands.each do |key, command|
+            # text << "    ├─┐".light_black + " #{(klass.terms.join(', ')).ljust(24, ' ')} ".send(Athena::Util.next_color) + klass.description.light_black
+            text << "    ├─┐".light_black + " #{key.to_s.ljust(24, ' ')} " + command.description.light_black
+          end
+          text << ("    └" + "─" * 64).light_black
+        else
+          # text.last << command.arguments(missing_args.keys)
+        end
+        # text << list_examples if examples.any?
+        text << "Options:".light_cyan
+      end.join("\n")
+      switch_parser
+    end
+
+    def self.define(label, chain: [], &block)
+      c = CommandDefinition.define(label, chain: chain, &block)
+
+      parent_command = if chain.any?
+        Ergane.active_tool.dig(*chain)
+      else
+        Ergane.active_tool
+      end
+
+      parent_command[label] = c
+    end
+
+    def load_commands(paths)
+      activate_tool do
+        Ergane.logger.debug "Loading paths:"
+        Array.wrap(paths).each do |path|
+          Ergane.logger.debug "  - #{path}"
+          Dir[path].each do |path|
+            file = path.split('/').last
+            Ergane.logger.debug "  - loading #{path.split('/').last(4).join('/')}"
+            instance_eval(File.read(path), file)
+          end
+        end
+      end
+    end
+
+    private
+
+    def activate_tool(&block)
+      Ergane.activate_tool(self, &block)
+    end
+
+  end
+end

data/lib/ergane/util.rb

@@ -0,0 +1,77 @@
+module Ergane
+  module Util
+
+    def self.colors
+      # @colors = [:red, :yellow, :green, :blue, :cyan, :magenta].cycle
+      @colors ||= [:light_red, :light_yellow, :light_green, :light_blue, :light_cyan, :light_magenta].cycle
+    end
+
+    def self.color_array(array)
+      array.collect do |a|
+        a.to_s.send(colors.next.to_sym).underline
+      end
+    end
+
+    def self.color_array!(array)
+      colors.rewind
+      array.collect do |a|
+        a.to_s.send(colors.next.to_sym).underline
+      end
+    end
+
+    def self.rainbow(string, delimeter=' ')
+      rainbow_a(string.split(delimeter)).join(delimeter)
+    end
+
+    def self.rainbow!(string, delimeter=' ')
+      rainbow_a!(string.split(delimeter)).join(delimeter)
+    end
+
+    def self.rainbow_a(array)
+      array.collect do |a|
+        a.to_s.send(next_color).underline
+      end
+    end
+
+    def self.rainbow_a!(array)
+      rainbow_colors.rewind
+      array.collect do |a|
+        a.to_s.send(next_color).underline
+      end
+    end
+
+    def self.next_color
+      colors.next
+    end
+
+    def self.rainbow_colors
+      @rainbow_colors = [:light_red, :light_yellow, :light_green, :light_blue, :light_cyan, :light_magenta].cycle
+    end
+
+    def self.next_rainbow_color
+      rainbow_colors.cycle
+    end
+
+    def self.full_name
+      @full_name ||= `finger \`whoami\` | grep Name | awk -F 'Name: ' '{print $2}'`.chomp
+    end
+
+    def self.last_name
+      @last_name || begin
+        split_names.last
+      end
+    end
+
+    def self.first_name
+      @first_name || begin
+        split_names.first
+      end
+    end
+
+    private
+
+    def self.split_names
+      @first_name, @last_name = ful_name.split(' ')
+    end
+  end
+end

data/lib/ergane/version.rb

@@ -0,0 +1,3 @@
+module Ergane
+  VERSION = '0.0.1'
+end

data/lib/ergane.rb

@@ -0,0 +1,85 @@
+require 'active_support'
+require 'active_support/core_ext'
+require 'active_support/dependencies'
+require 'optparse'
+require 'colorize'
+require 'notifier'
+require 'pry-byebug'
+
+$LOAD_PATH.unshift File.expand_path("#{__dir__}/ergane")
+
+require 'ergane/version'
+require 'ergane/command_definition'
+require 'ergane/tool'
+
+module Ergane
+
+  Help = Class.new(StandardError)
+  Interrupt = Class.new(StandardError)
+
+  class << self
+    attr_reader :logger
+
+    def root(*args)
+      (@root ||= Pathname.new(File.expand_path('../', __dir__))).join(*args)
+    end
+
+    def logger
+      @logger ||= Logger.new($stdout).tap do |log|
+        log.progname = @@active_tool&.title || self.name
+        log.level = :warn
+      end
+    end
+
+    # def debug(string)
+    #   old_level = logger.level
+    #   logger.level = :debug if $debug
+    #   logger.debug(string)
+    # ensure
+    #   logger.level = old_level
+    # end
+
+    @@active_tool = nil
+
+    def active_tool
+      @@active_tool
+    end
+
+    def activate_tool(tool)
+      previous_tool = @@active_tool
+      @@active_tool = tool
+      yield if block_given?
+    ensure
+      @@active_tool = previous_tool
+    end
+
+    def notify(message, title: nil, sound: nil, icon: nil, group: nil)
+      cmd = ['terminal-notifier']
+      cmd << "-group #{Process.pid}#{group}"
+      cmd << "-title #{active_tool.label}"
+      cmd << "-subtitle #{title}" if title
+      cmd << "-appIcon 'assets/athena md-light-shadow.png'" if icon
+      cmd << "-message '#{message}'"
+      cmd << "-activate 'com.apple.Terminal'" # if macos
+      cmd << "-sound #{sound}" if sound
+      Thread.new { `afplay /System/Library/Sounds/#{sound == true ? 'Blow' : sound}.aiff` } unless sound == false
+
+      `#{cmd.join(' ')}`
+      # Notifier.notify(title: title, message: message, image: 'assets/athena md-light-shadow.png')
+    end
+
+    # Show a list of available extensions to use
+    def extensions
+      Extension.library
+    end
+  end
+end
+
+if ARGV.include?('--debug')
+  $debug = true
+  Ergane.logger.level = :debug
+end
+
+Dir[Ergane.root('lib', 'core_ext', "*.rb")].each do |path|
+  require path
+end

metadata

@@ -0,0 +1,201 @@
+--- !ruby/object:Gem::Specification
+name: ergane
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Dale Stevens
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-05-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: terminal-notifier
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: notifier
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ruby-prof
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Library for creating lightweight, yet powerful CLI tools in Ruby.
+  Emphasis and priority on load speed and flexibility.
+email:
+- dale@twilightcoders.net
+executables:
+- ergane
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- app/commands/ergane/console.rb
+- bin/ergane
+- lib/core_ext/option_parser.rb
+- lib/ergane.rb
+- lib/ergane/command_definition.rb
+- lib/ergane/debug.rb
+- lib/ergane/helpers/hashall.rb
+- lib/ergane/switch_definition.rb
+- lib/ergane/tool.rb
+- lib/ergane/util.rb
+- lib/ergane/version.rb
+homepage: https://github.com/TwilightCoders/ergane
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.7'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key:
+specification_version: 4
+summary: Ergane — The patron goddess of craftsmen and artisans
+test_files: []