tabry 0.1.0

data/lib/tabry/machine.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require_relative "state"
+require_relative "util"
+
+# The core Tabry state machine / parser which reads tokens, figures out if it's
+# a sub/flag/arg/etc. and advances the state
+#
+# The output is a State object -- the final state of the machine.
+module Tabry
+  class Machine
+    attr_reader :state, :config
+
+    # Returns a state
+    def self.run(config, tokens)
+      machine = new(config)
+      machine.run(tokens)
+      machine.state
+    end
+
+    def initialize(config)
+      @config = config
+      @state = State.new(mode: :subcommand, subcommand_stack: [], args: [], flags: {})
+    end
+
+    def run(tokens)
+      tokens.each do |token|
+        step(token)
+        Tabry::Util.debug "AFTER token #{token.inspect}"
+        Tabry::Util.debug "STATE: #{state.inspect}"
+      end
+    end
+
+    private
+
+    def step(token)
+      send :"step_#{state.mode}", token
+    end
+
+    def current_sub
+      # TODO: a bit of a waste to look this up every time.
+      config.dig_sub(state.subcommand_stack)
+    end
+
+    def step_subcommand(token)
+      step_subcommand_match_subcommand(token) ||
+        step_subcommand_match_dashdash(token) ||
+        step_subcommand_match_flag(token) ||
+        step_subcommand_match_help(token) ||
+        step_subcommand_match_arg(token)
+    end
+
+    def step_subcommand_match_help(token)
+      return false if state.help
+      return false unless state.mode == :subcommand
+
+      if (state.subcommand_stack.empty? && token == "help") ||
+         (!state.dashdash && %w[--help -?].include?(token))
+        state.help = true
+        Tabry::Util.debug "MATCHED help ON token #{token.inspect}"
+        return true
+      end
+      false
+    end
+
+    def step_subcommand_match_subcommand(token)
+      return false unless state.args.empty?
+
+      sub = current_sub.subs.match(token)
+      return false unless sub
+
+      state.subcommand_stack << sub.name
+      Tabry::Util.debug "MATCHED sub #{sub.name} ON token #{token.inspect}"
+      true
+    end
+
+    def step_subcommand_match_dashdash(token)
+      return false if state.dashdash
+      return false unless token == "--"
+
+      state.dashdash = true
+      true
+    end
+
+    def step_subcommand_match_flag(token)
+      return false if state.dashdash
+
+      flag, arg_value = nil
+      # Reverse: most specific sub's flag takes precedence in case of multiple matching
+      config.dig_sub_array(state.subcommand_stack).reverse.each do |sub|
+        flag, arg_value = sub.flags.match(token)
+        break if flag
+      end
+      return false unless flag
+
+      if arg_value
+        state.flags[flag.name] = arg_value
+      elsif flag.arg
+        state.mode = :flagarg
+        state.current_flag = flag.name
+      else
+        state.flags[flag.name] = true
+      end
+
+      Tabry::Util.debug "MATCHED flag #{flag.name} ON token #{token.inspect}"
+      true
+    end
+
+    # this accepts anything, for now...
+    def step_subcommand_match_arg(token)
+      state.args << token
+
+      Tabry::Util.debug "MATCHED arg ON token #{token.inspect}"
+      true
+    end
+
+    # Accepts anything, for now
+    def step_flagarg(token)
+      state.flags[state.current_flag] = token
+      state.mode = :subcommand
+      true
+    end
+  end
+end

data/lib/tabry/models/arg.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require_relative "arg_base"
+require_relative "options_list"
+require_relative "include_arg"
+
+module Tabry
+  module Models
+    class Arg < ArgBase
+      def self.new(**args)
+        if args[:raw]["include"]
+          IncludeArg.new(**args)
+        else
+          super(**args)
+        end
+      end
+
+      FIELDS = {
+        name: :string,
+        options: [:list_object, :OptionsList],
+        optional: :boolean,
+        description: :string,
+        varargs: :boolean,
+        title: :string,
+      }.freeze
+
+      attr_reader(*FIELDS.keys)
+
+      def flatten
+        self
+      end
+
+      # Alias (more clear intention)
+      def varargs?
+        varargs
+      end
+
+      def title
+        @title || name
+      end
+    end
+  end
+end

data/lib/tabry/models/arg_base.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require_relative "config_object"
+
+module Tabry
+  module Models
+    class ArgBase < ConfigObject
+    end
+  end
+end

data/lib/tabry/models/arg_include.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Tabry
+  module Models
+    # TODO: SubBase for both this and Sub, Sub has stuff we don't want
+    class ArgInclude < Sub
+    end
+  end
+end

data/lib/tabry/models/arg_includes.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "config_string_hash"
+require_relative "arg_include"
+
+module Tabry
+  module Models
+    class ArgIncludes < ConfigStringHash
+      def initialize(**args)
+        super(**args, klass: ArgInclude)
+      end
+    end
+  end
+end

data/lib/tabry/models/args_list.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "arg"
+require_relative "config_error"
+
+module Tabry
+  module Models
+    class ArgsList < ConfigList
+      def initialize(**args)
+        super(**args, klass: Arg)
+      end
+
+      def n_passed_in_varargs(n_total_passed_in_args)
+        case to_a.count(&:varargs?)
+        when 0
+          0
+        when 1
+          n_regular_passed_in_args = to_a.length - 1
+          [n_total_passed_in_args - n_regular_passed_in_args, 0].max
+        else
+          arg_names = to_a.map { |a| "#{a.name || "[unnamed]"}#{a.varargs? ? " (varargs)" : ""}" }
+          raise ConfigError, "More than one varargs args in one sub: #{arg_names.join(", ")}"
+        end
+      end
+
+      def varargs_arg
+        to_a.find(&:varargs?)
+      end
+    end
+  end
+end

data/lib/tabry/models/config.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "config_object"
+require_relative "sub"
+require_relative "option_includes"
+require_relative "arg_includes"
+
+module Tabry
+  module Models
+    class Config < ConfigObject
+      FIELDS = {
+        cmd: :string,
+        main: [:object, :Sub],
+        option_includes: [:object, :OptionIncludes],
+        arg_includes: [:object, :ArgIncludes],
+      }.freeze
+
+      attr_reader(*FIELDS.keys)
+
+      def initialize(raw:)
+        super(raw: raw, root: self)
+      end
+
+      def dig_sub(sub_stack)
+        sub_stack.reduce(main) { |sub, sub_name| sub.subs.by_name[sub_name] }
+      end
+
+      def dig_sub_array(sub_stack)
+        subs = [main]
+        sub_stack.each do |sub_name|
+          subs << subs.last.subs.by_name[sub_name]
+        end
+        subs
+      end
+
+      def inspect
+        # TODO: remove hack, but make everything in models have a hack so _root is not shown
+        return "#<Tabry::Config>" if caller.any? { |c| c.include?("in `inspect'") }
+
+        super
+      end
+    end
+  end
+end

data/lib/tabry/models/config_error.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Tabry
+  module Models
+    class ConfigError < StandardError
+    end
+  end
+end

data/lib/tabry/models/config_list.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "config_error"
+
+module Tabry
+  module Models
+    class ConfigList
+      attr_reader :unflattened
+
+      include Enumerable
+
+      def initialize(raw:, root:, klass:)
+        raise "missing root" unless root
+
+        raw ||= []
+        unless raw.is_a?(Array)
+          raise ConfigError, "#{self.class.name} must be an array. Got #{raw.class}"
+        end
+
+        @unflattened = raw.map { |a| klass.new(raw: a, root: root) }
+      end
+
+      def to_a
+        flatten
+      end
+
+      def flatten
+        @flatten ||= unflattened.map(&:flatten).flatten
+      end
+
+      def [](*args)
+        to_a.[](*args)
+      end
+
+      def each(...)
+        to_a.each(...)
+      end
+
+      def length
+        to_a.length
+      end
+
+      def empty?
+        to_a.empty?
+      end
+    end
+  end
+end

data/lib/tabry/models/config_object.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative "config_error"
+
+module Tabry
+  module Models
+    class ConfigObject
+      def to_s
+        inspect
+      end
+
+      def inspect
+        field_strings = self.class::FIELDS.keys.map do |f|
+          val = instance_variable_get(:"@#{f}")
+          if val.nil?
+            nil
+          else
+            "#{f}=#{val.inspect}"
+          end
+        end
+        desc = [self.class.name, *field_strings.compact].join(" ")
+        "#<#{desc}>"
+      end
+
+      attr_reader :_root, :_raw
+
+      def initialize(raw:, root:)
+        @_raw = raw
+        @_root = root or raise "missing root"
+        unknown_fields = @_raw.keys - self.class::FIELDS.keys.map(&:to_s)
+        unless unknown_fields.empty?
+          raise ConfigError, "Unknown field(s) #{unknown_fields.inspect} for #{self.class}"
+        end
+
+        raw.each do |key, val|
+          type, *extra = Array(self.class::FIELDS[key.to_sym])
+          instance_variable_set :"@#{key}", send(:"init_field_#{type}", key, val, *extra)
+        end
+      end
+
+      # Gets fields, asserts is either nil or of given type
+      def assert_of_class(key, val, klasses)
+        unless Array(klasses).any? { |klass| val.is_a?(klass) }
+          raise ConfigError,
+                "Invalid type #{val.class} for #{self.class} field #{key.inspect}, expected #{klasses.inspect}"
+        end
+      end
+
+      def init_field_string(key, val)
+        assert_of_class(key, val, String)
+        val
+      end
+
+      def init_field_string_array(key, vals)
+        assert_of_class(key, vals, Array)
+        vals.each_with_index do |val, i|
+          assert_of_class("#{key}[#{i}]", val, String)
+        end
+        vals
+      end
+
+      def init_field_object(key, val, object_class)
+        assert_of_class(key, val, Hash)
+        Object.const_get("Tabry::Models::#{object_class}").new(raw: val, root: _root)
+      end
+
+      def init_field_list_object(key, val, object_class)
+        assert_of_class(key, val, Array)
+        Object.const_get("Tabry::Models::#{object_class}").new(raw: val, root: _root)
+      end
+
+      def init_field_boolean(key, val)
+        assert_of_class(key, val, [TrueClass, FalseClass])
+        val
+      end
+    end
+  end
+end

data/lib/tabry/models/config_string_hash.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "config_error"
+
+module Tabry
+  module Models
+    class ConfigStringHash
+      attr_reader :to_h, :_raw, :_root
+
+      include Enumerable
+
+      def initialize(raw:, root:, klass:)
+        @_raw = raw
+        @_root = root
+
+        raw ||= {}
+        unless raw.is_a?(Hash)
+          raise ConfigError, "#{self.class.name} must be a Hash. Got #{raw.class}"
+        end
+        unless raw.keys.all? { |k| k.is_a?(String) }
+          raise ConfigError, "#{self.class.name} keys must all be string keys."
+        end
+
+        @to_h = raw.transform_values { |a| klass.new(raw: a, root: root) }
+      end
+
+      def [](*args)
+        to_h.[](*args)
+      end
+
+      def each(...)
+        to_h.each(...)
+      end
+
+      def empty?
+        to_h.empty?
+      end
+
+      def keys
+        to_h.keys
+      end
+    end
+  end
+end

data/lib/tabry/models/const_option.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative "option_base"
+
+module Tabry
+  module Models
+    class ConstOption < OptionBase
+      def options(token)
+        if value.start_with?(token)
+          [value]
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/tabry/models/dir_option.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "config_object"
+
+module Tabry
+  module Models
+    class DirOption < ConfigObject
+      FIELDS = {
+        type: :string,
+      }.freeze
+
+      attr_reader(*FIELDS.keys)
+
+      # Handled by tabru=bash/tabry-bash.sh/shell, we just return a symbol to
+      # communicate to tabry-bash
+      def options(_token)
+        [:directory]
+      end
+
+      def flatten
+        self
+      end
+    end
+  end
+end

data/lib/tabry/models/file_option.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative "config_object"
+
+module Tabry
+  module Models
+    class FileOption < ConfigObject
+      FIELDS = {
+        type: :string,
+      }.freeze
+
+      attr_reader(*FIELDS.keys)
+
+      # Handled by tabru=bash/tabry-bash.sh/shell, we just return a symbol to
+      # communicate to tabry-bash
+      def options(_token)
+        [:file]
+      end
+
+      def flatten
+        self
+      end
+    end
+  end
+end

data/lib/tabry/models/flag.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative "config_object"
+require_relative "options_list"
+require_relative "include_flag"
+
+module Tabry
+  module Models
+    class Flag < ConfigObject
+      def self.new(**args)
+        if args[:raw]["include"]
+          IncludeFlag.new(**args)
+        else
+          super(**args)
+        end
+      end
+
+      FIELDS = {
+        aliases: :string_array,
+        description: :string,
+        name: :string, # TODO: required
+        required: :boolean,
+        arg: :boolean,
+        options: [:list_object, :OptionsList]
+      }.freeze
+
+      def flatten
+        self
+      end
+
+      def match_with_value(token)
+        [name, *aliases].each do |al|
+          if al.length > 1 && token.start_with?("--#{al}=")
+            return token.sub("--#{al}=", "")
+          end
+        end
+        nil
+      end
+
+      def match(token)
+        [name, *aliases].any? { |al| token == alias_with_dash(al) }
+      end
+
+      def name_with_dashes
+        @name_with_dashes ||= alias_with_dash(name)
+      end
+
+      def alias_with_dash(ali)
+        (ali.length == 1) ? "-#{ali}" : "--#{ali}"
+      end
+
+      attr_reader(*FIELDS.keys)
+    end
+  end
+end

data/lib/tabry/models/flags_list.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative "config_list"
+require_relative "flag"
+
+module Tabry
+  module Models
+    class FlagsList < ConfigList
+      def initialize(**args)
+        super(**args, klass: Flag)
+      end
+
+      def first_required_flag(used:)
+        to_a.find do |flag|
+          flag.required && !used[flag.name]
+        end
+      end
+
+      def options(token, used:)
+        to_a.map do |flag|
+          if token&.start_with?("-") && flag.name_with_dashes.start_with?(token) && !used[flag.name]
+            flag.name_with_dashes
+          end
+        end.compact
+      end
+
+      def match(token)
+        to_a.each do |flag|
+          if (arg_value = flag.match_with_value(token))
+            return flag, arg_value
+          elsif flag.match(token)
+            return flag
+          end
+        end
+        false
+      end
+
+      def [](flag_name)
+        if flag_name.is_a?(Integer)
+          to_a[flag_name]
+        else
+          to_a.find { |f| f.name == flag_name }
+        end
+      end
+    end
+  end
+end

data/lib/tabry/models/include_arg.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Tabry
+  module Models
+    class IncludeArg
+      attr_reader :include_name, :_root
+
+      def initialize(raw:, root:)
+        @include_name = raw["include"]
+        @_root = root
+      end
+
+      def flatten
+        _root.arg_includes[include_name].args.flatten
+      end
+    end
+  end
+end

data/lib/tabry/models/include_flag.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Tabry
+  module Models
+    class IncludeFlag
+      attr_reader :include_name, :_root
+
+      def initialize(raw:, root:)
+        @include_name = raw["include"]
+        @_root = root
+      end
+
+      def flatten
+        _root.arg_includes[include_name].flags.flatten
+      end
+    end
+  end
+end

data/lib/tabry/models/include_option.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "option_base"
+
+module Tabry
+  module Models
+    class IncludeOption < OptionBase
+      attr_reader :include_name, :_root
+
+      def options(token)
+        flatten.options(token)
+      end
+
+      def flatten
+        inc = _root.option_includes[value]
+        raise "Bad tabry config: include #{value.inspect} not found" unless inc
+
+        inc.flatten
+      end
+    end
+  end
+end