ergane 0.0.1 → 0.2.0

data/lib/ergane/command_definition.rb

@@ -1,176 +0,0 @@
-# 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

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

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

@@ -1,49 +0,0 @@
-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/util.rb

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