consoler 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a3db645fb1a61eee615bf593a5a078320c098081
+  data.tar.gz: 675713207b19a2b6685be32447a79783738bb78d
+SHA512:
+  metadata.gz: 9e021691c53d383d0a9b778116269d58b3b1357abd7dc51bb9e23150498f1046a62b4e0da21cd64a4e2466cc383d86f3ee5db3b3de571b8b2e94b3aca16cc69b
+  data.tar.gz: 410a8cc86d20818a59908a0de6f7e2561e7f8716820b1a198599c2304abae5fe99206d979af336f4527db6141035eef1f9f9b35c5d74d187aa9a81859d987c59

data/lib/consoler/application.rb

@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require_relative 'options'
+require_relative 'arguments'
+
+module Consoler
+
+  # Consoler application
+  #
+  # @example A simple application
+  #   # create a application
+  #   app = Consoler::Application.new description: 'A simple app'
+  #
+  #   # define a command
+  #   app.build 'target [--clean]' do |target, clean|
+  #     # clean contains a boolean
+  #     clean_up if clean
+  #
+  #     # target contains a string
+  #     build_project target
+  #   end
+  #   app.run(['build', 'production', '--clean'])
+  #
+  #   # this does not match, nothing is executed and the usage message is printed
+  #   app.run(['deploy', 'production'])
+  class Application
+
+    # Create a consoler application
+    #
+    # @param options [Hash] Options for the application
+    # @option options [String] :description The description for the application (optional)
+    def initialize(options={})
+      @description = options[:description]
+      @commands = []
+    end
+
+    # Register a command for this app
+    #
+    # @param command_name [Symbol] Name of the command
+    # @param input [String, Consoler::Application] Options definition or a complete subapp
+    # @yield [...] Executed when the action is matched with parameters based on your options
+    # @return [nil]
+    def method_missing(command_name, input = nil, &block)
+      action = nil
+      options_def = ''
+
+      unless block.nil? then
+        action = block
+        options_def = input
+
+        if not options_def.nil? and not options_def.instance_of? String then
+          raise 'Invalid options'
+        end
+      end
+
+      if input.instance_of? Consoler::Application then
+        action = input
+        options_def = ''
+      end
+
+      if action.nil? then
+        raise 'Invalid subapp/block'
+      end
+
+      command = command_name.to_s
+
+      _add_command(command, options_def, action)
+
+      return nil
+    end
+
+    # Run the application with a list of arguments
+    #
+    # @param args [Array] Arguments
+    # @param disable_usage_message [Boolean] Disable the usage message when nothing it matched
+    # @return [mixed] Result of your matched command, <tt>nil</tt> otherwise
+    def run(args = ARGV, disable_usage_message = false)
+      # TODO signal handling of some kind?
+
+      result, matched = _run(args)
+
+      if not matched and not disable_usage_message
+        usage
+      end
+
+      return result
+    end
+
+    # Show the usage message
+    #
+    # Contains all commands and options, including subapps
+    def usage
+      puts "#{@description}\n\n" unless @description.nil?
+      puts 'Usage:'
+
+      _commands_usage $0
+    end
+
+    protected
+
+    def _run(args)
+      arg = args.shift
+      arguments = Consoler::Arguments.new args
+
+      @commands.each do |command|
+        if command.command == arg then
+          if command.action.instance_of? Consoler::Application then
+            result, matched = command.action._run(args)
+
+            if matched then
+              return result, true
+            end
+          else
+            match = arguments.match command.options
+
+            next if match.nil?
+
+            return _dispatch(command.action, match), true
+          end
+        end
+      end
+
+      return nil, false
+    end
+
+    def _commands_usage(prefix='')
+      @commands.each do |command|
+        if command.action.instance_of? Consoler::Application then
+          command.action._commands_usage "#{prefix} #{command.command}"
+        else
+          print "  #{prefix} #{command.command}"
+
+          if command.options.size then
+            print " #{command.options.to_definition}"
+          end
+
+          unless command.options.description.nil? then
+            print "  -- #{command.options.description}"
+          end
+
+          print "\n"
+        end
+      end
+    end
+
+    private
+
+    def _add_command(command, options_def, action)
+      @commands.push(Consoler::Command.new(
+        command: command,
+        options: Consoler::Options.new(options_def),
+        action: action,
+      ))
+    end
+
+    def _dispatch(action, match)
+      arguments = action.parameters.map do |parameter|
+        match[parameter[1].to_s]
+      end
+
+      action.call(*arguments)
+    end
+  end
+end

data/lib/consoler/arguments.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'matcher'
+
+module Consoler
+
+  # Arguments
+  #
+  # @attr_reader [Array<String>] args Raw arguments
+  class Arguments
+    attr_reader :args
+
+    def initialize(args)
+      @args = args
+    end
+
+    # Match arguments against options
+    #
+    # @see Consoler::Matcher#match
+    # @return [Hash, nil] Matched information, or <tt>nil</tt> is returned when there was no match
+    def match(options)
+      matcher = Consoler::Matcher.new self, options
+      matcher.match
+    end
+  end
+end

data/lib/consoler/command.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Consoler
+
+  # Consoler command
+  #
+  # Basically a named hash
+  #
+  # @attr_reader [String] command Name of the command
+  # @attr_reader [Consoler::Options] options List of all options
+  # @attr_reader [Proc] action Action for this command
+  class Command
+    attr_reader :command
+    attr_reader :options
+    attr_reader :action
+
+    # Create a command
+    #
+    # @param [Hash] options
+    # @option options [String] :command Name of the command
+    # @option options [Consoler::Options] :options List of all options
+    # @option options [Proc] :action Action for this command
+    def initialize(options)
+      @command = options[:command]
+      @options = options[:options]
+      @action = options[:action]
+    end
+  end
+end

data/lib/consoler/matcher.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+module Consoler
+
+  # Argument/Options matcher
+  #
+  # Given a list of arguments and a list option try to match them
+  class Matcher
+
+    # Create a matcher
+    #
+    # @param [Consoler::Arguments] arguments List of arguments
+    # @param [Consoler::Options] options List of options
+    def initialize(arguments, options)
+      @arguments = arguments
+      @options = options
+
+      @index = 0
+      @matched_options = {}
+      @argument_values = []
+    end
+
+    # Match arguments against options
+    #
+    # @return [Hash, nil] Matched information, or <tt>nil</tt> is returned when there was no match
+    def match
+      parse_options = true
+
+      loop_args do |arg|
+        unless parse_options then
+          @argument_values.push arg
+          next
+        end
+
+        if arg == '--' then
+          parse_options = false
+          next
+        end
+
+        analyzed = _analyze arg
+
+        if analyzed.nil?
+          return nil
+        end
+      end
+
+      remaining = _match_arguments
+      _fill_defaults
+
+      if @matched_options.size == @options.size then
+        @matched_options['remaining'] = remaining
+        return @matched_options
+      end
+
+      return nil
+    end
+
+    private
+
+    def _analyze(arg)
+      is_long = false
+      is_short = false
+      name = nil
+
+      if arg[0..1] == '--' then
+        is_long = true
+        name = arg[2..-1]
+      elsif arg[0] == '-' then
+        is_short = true
+        name = arg[1..-1]
+      end
+
+      if name.nil?
+        @argument_values.push arg
+        return true
+      end
+
+      unless name.nil? then
+        option_name = if is_short then
+                        name[0]
+                      else
+                        name
+                      end
+
+        option = @options.get option_name
+
+        return nil if option.nil?
+
+        needs_short = option.is_short
+        needs_long = option.is_long
+
+        if needs_long and not is_long then
+          return nil
+        elsif needs_short and not is_short then
+          return nil
+        end
+
+        if is_long then
+          if option.is_value then
+            return nil if peek_next.nil?
+            @matched_options[name] = peek_next
+            skip
+          else
+            @matched_options[name] = true
+          end
+        end
+
+        if is_short then
+          if name.size == 1 and option.is_value then
+            return nil if peek_next.nil?
+            @matched_options[name] = peek_next
+            skip
+          else
+            name.split('').each do |n|
+              if @matched_options[n].nil? then
+                @matched_options[n] = 0
+              end
+
+              @matched_options[n] += 1
+            end
+          end
+        end
+      end
+
+      return true
+    end
+
+    def current
+      @arguments.args[@index]
+    end
+
+    def peek_next
+      @arguments.args[@index + 1]
+    end
+
+    def loop_args
+      @index = 0
+      size = @arguments.args.size
+
+      while @index < size do
+        yield current
+
+        skip
+      end
+    end
+
+    def skip
+      @index += 1
+    end
+
+    def _match_arguments
+      @optionals_before = {}
+      @optionals_before_has_remaining = false
+
+      argument_values_index = 0
+
+      _match_arguments_optionals_before
+
+      @optionals_before.each do |mandatory_arg_name, optionals|
+        optionals.each do |_, optional|
+          optional.each do |before|
+            if before[:included] then
+              @matched_options[before[:name]] = @argument_values[argument_values_index]
+              argument_values_index += 1
+            end
+          end
+        end
+
+        if mandatory_arg_name != :REMAINING then
+          @matched_options[mandatory_arg_name] = @argument_values[argument_values_index]
+          argument_values_index += 1
+        end
+      end
+
+      remaining = []
+
+      while argument_values_index < @argument_values.size do
+        remaining.push @argument_values[argument_values_index]
+        argument_values_index += 1
+      end
+
+      remaining
+    end
+
+    def _match_arguments_optionals_before
+      @optionals_before = {}
+      tracker = {}
+
+      @options.each do |option, key|
+        next unless option.is_argument
+
+        if option.is_optional then
+          tracker[option.is_optional] = [] if tracker[option.is_optional].nil?
+
+          tracker[option.is_optional].push({
+            included: false,
+            name: option.name,
+          })
+        else
+          @optionals_before[option.name] = tracker
+          tracker = {}
+        end
+      end
+
+      if tracker != {} then
+        @optionals_before[:REMAINING] = tracker
+        @optionals_before_has_remaining = true
+      end
+
+      _match_arguments_optoins_before_matcher
+    end
+
+    def _match_arguments_optoins_before_matcher
+      mandatories_matched = @optionals_before.size
+
+      if @optionals_before_has_remaining then
+        mandatories_matched -= 1
+      end
+
+      total = 0
+
+      _each_optional_before_sorted do |before|
+        if (total + before.size + mandatories_matched) <= @argument_values.size then
+          total += before.size
+
+          before.each do |val|
+            val[:included] = true;
+          end
+        end
+      end
+    end
+
+    def _fill_defaults
+      @options.each do |option|
+        if option.is_optional then
+          unless @matched_options.has_key? option.name then
+            @matched_options[option.name] = option.default_value
+          end
+        end
+      end
+    end
+
+    def _each_optional_before_sorted
+      @optionals_before.each do |_, optionals|
+        tmp = []
+        optionals.each do |optional_index, before|
+          tmp.push({
+            count: before.size,
+            index: optional_index,
+          })
+        end
+
+        tmp.sort! { |a, b| b[:count] - a[:count] }.each do |item|
+          yield optionals[item[:index]]
+        end
+      end
+    end
+  end
+end

data/lib/consoler/option.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+module Consoler
+
+  # Represents an option
+  #
+  # @attr_reader [String] name Name of the options
+  # @attr_reader [Boolean] is_long Is the option long (<tt>--option</tt>)
+  # @attr_reader [Boolean] is_short Is the option short (<tt>-o</tt>)
+  # @attr_reader [Boolean] is_argument Is the option an argument
+  # @attr_reader [Boolean] is_value Does the option need a value (<tt>--option=</tt>)
+  # @attr_reader [Integer] is_optional Is the option optional (> 0) (<tt>[option]</tt>)
+  class Option
+    attr_reader :name
+    attr_reader :is_long
+    attr_reader :is_short
+    attr_reader :is_argument
+    attr_reader :is_value
+    attr_reader :is_optional
+
+    # Create a option
+    #
+    # Yields an option for every option detected
+    #
+    # @param option_def [String] Definition of the option
+    # @param tracker [Consoler::OptionalsTracker] optionals tracker
+    def self.create(option_def, tracker)
+      option = Option.new option_def, tracker
+
+      if option.is_short and option.name.size > 1 then
+        old_tracking = tracker.is_tracking
+        old_is_value = option.is_value
+
+        if option.is_optional then
+          tracker.is_tracking = true
+        end
+
+        names = option.name.split('')
+
+        names.each_with_index do |name, i|
+          new_name = "-#{name}"
+
+          if old_is_value and i == names.count - 1 then
+            new_name = "#{new_name}="
+          end
+
+          yield Option.new new_name, tracker
+        end
+
+        tracker.is_tracking = old_tracking
+      else
+        yield option
+      end
+    end
+
+    # Get the definition of the option
+    #
+    # Does not include the optional information, as that is linked to other
+    # options
+    #
+    # @return [String]
+    def to_definition
+      definition = name
+
+      if is_long then
+        definition = "--#{definition}"
+      elsif is_short then
+        definition = "-#{definition}"
+      end
+
+      if is_value then
+        definition = "#{definition}="
+      end
+
+      definition
+    end
+
+    # Get the default value of this option
+    #
+    # @return [nil | 0 | false]
+    def default_value
+      return nil if is_value
+      return 0 if is_short
+      return false if is_long
+
+      return nil
+    end
+
+    protected
+
+    # Create a option
+    #
+    # @param [String] option_def Definition of the option
+    # @param [Consoler::Tracker] tracker tracker
+    def initialize(option_def, tracker)
+      option, @is_optional = _is_optional option_def, tracker
+      option, @is_long = _is_long option
+      option, @is_short = _is_short option
+      @is_argument = (not @is_long and not @is_short)
+      option, @is_value = _value option, @is_argument
+
+      @name = option
+
+      if @name.empty? then
+        raise 'Option must have a name'
+      end
+
+      if @is_long and @is_short
+        raise 'Option can not be a long and a short option'
+      end
+    end
+
+    private
+
+    def _is_optional(option, tracker)
+      if option[0] == '[' then
+        if !tracker.is_tracking then
+          tracker.is_tracking = true
+          tracker.index += 1
+          option = option[1..-1]
+        else
+          raise 'Nested optionals are not allowed'
+        end
+      end
+
+      optional = if tracker.is_tracking then
+                   tracker.index
+                 else
+                   nil
+                 end
+
+      if option[-1] == ']' then
+        if tracker.is_tracking then
+          tracker.is_tracking = false
+          option = option[0..-2]
+        else
+          raise 'Unopened optional'
+        end
+      end
+
+      return option, optional
+    end
+
+    def _is_long(option)
+      if option[0..1] == '--' then
+        long = true
+        option = option[2..-1]
+      else
+        long = false
+      end
+
+      return option, long
+    end
+
+    def _is_short(option)
+      if option[0] == '-' then
+        short = true
+        option = option[1..-1]
+      else
+        short = false
+      end
+
+      return option, short
+    end
+
+    def _value(option, argument)
+      if option[-1] == '=' then
+        if argument then
+          raise 'Arguments can\'t have a value'
+        end
+
+        value = true
+        option = option[0..-2]
+      else
+        value = false
+      end
+
+      return option, value
+    end
+  end
+end

data/lib/consoler/options.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_relative 'option'
+
+module Consoler
+
+  # List of options
+  #
+  # @attr_reader [String] description Description of the options
+  class Options
+    attr_reader :description
+
+    # Create a list of option based on a string definition
+    #
+    # @param options_def [String] A string definition of the desired options
+    def initialize(options_def)
+      @options = []
+      @description = nil
+
+      return if options_def.nil?
+
+      if match = /(^|\s+)-- (?<description>.*)$/.match(options_def) then
+        @description = match[:description]
+        options_def = options_def[0...-match[0].size]
+      end
+
+      options = options_def.split ' '
+      tracker = Consoler::OptionalsTracker.new
+
+      option_names = []
+
+      while option_def = options.shift do
+        Consoler::Option.create option_def, tracker do |option|
+          raise "Duplicate option name: #{option.name}" if option_names.include? option.name
+
+          @options.push option
+          option_names.push option.name
+        end
+      end
+    end
+
+    # Get a options by its name
+    #
+    # @param name [String] Name of the option
+    # @return [Consoler::Option, nil]
+    def get(name)
+      each do |option|
+        if option.name == name then
+          return option
+        end
+      end
+
+      return nil
+    end
+
+    # Loop through all options
+    #
+    # @yield [Consoler::Option, Integer] An option
+    # @return [Consoler::Options]
+    def each
+      @options.each_with_index do |option, i|
+        yield option, i
+      end
+
+      self
+    end
+
+    # Get the number of options
+    #
+    # @return [Integer]
+    def size
+      @options.size
+    end
+
+    def to_definition
+      definition = ''
+      optional = nil
+
+      each do |option, i|
+        definition += ' '
+
+        if optional.nil? and option.is_optional then
+          definition += '['
+          optional = option.is_optional
+        end
+
+        definition += option.to_definition
+
+        if option.is_optional then
+          if @options[i + 1].nil? or optional != @options[i + 1].is_optional then
+            definition += ']'
+            optional = nil
+          end
+        end
+      end
+
+      definition.strip
+    end
+  end
+
+  private
+
+  # Optionals tracker
+  #
+  # @attr [Boolean] is_tracking Is inside optional options
+  # @attr [Integer] index Optional group
+  class OptionalsTracker
+    attr_accessor :is_tracking
+    attr_accessor :index
+
+    # Create an optionals tracker
+    def initialize
+      @is_tracking = nil
+      @index = 0
+    end
+  end
+end

data/lib/consoler/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Consoler
+
+  # Current version number
+  VERSION = '1.0.0'
+end

data/lib/consoler.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative 'consoler/application'
+require_relative 'consoler/command'
+
+# Consoler
+#
+# Sinatra-like application builder for the console
+#
+# See {Consoler::Application} for usage information
+module Consoler
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: consoler
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Tim
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-03-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.12
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.12
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.15.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.15.1
+description: Sinatra-like application builder for the console
+email: me@justim.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/consoler.rb
+- lib/consoler/application.rb
+- lib/consoler/arguments.rb
+- lib/consoler/command.rb
+- lib/consoler/matcher.rb
+- lib/consoler/option.rb
+- lib/consoler/options.rb
+- lib/consoler/version.rb
+homepage: https://github.com/justim/consoler-rb
+licenses:
+- MIT
+metadata:
+  yard.run: yri
+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.11
+signing_key: 
+specification_version: 4
+summary: Consoler
+test_files: []