argstring 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 372c89e811880ac8fcf4c3d27720d01b83c17a2d
+  data.tar.gz: c75d279c3a11f1a7ed355c814bf2ef3d108bf91c
+SHA512:
+  metadata.gz: 85cc4207cb9b70d18e4074719c6a54335ed0804efb14296821c855e071be2b6f763ad82aa47f25b475e9e1a4163f293ea31b457b318a1b4baebbd63edc8ee625
+  data.tar.gz: d58aa2cf20b1074e076cf21bb0d94342cccb71826f1af34e36111a3460623b642ea4a3b967ec2f683e092149570fd3f16d06a0ecdc2124a6441b90b6a39d8621

data/lib/argstring/config.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+module Argstring
+	class Config
+		DEFAULT_ENCLOSERS = [{ open: '"', close: '"' }, { open: "'", close: "'" }].freeze
+		WHITESPACE_SEPARATOR_SENTINEL = /\s/
+
+		attr_reader :separator, :escape, :assignment, :enclosers, :duplicates, :flags_enabled, :positional_enabled
+
+		def initialize(separator: WHITESPACE_SEPARATOR_SENTINEL, escape: "\\", assignment: ["="], enclosers: DEFAULT_ENCLOSERS, duplicates: :last, flags: true, positional: true)
+			@separator = separator
+			@escape = escape
+			@assignment = assignment
+			@enclosers = enclosers
+			@duplicates = duplicates
+			@flags_enabled = flags
+			@positional_enabled = positional
+
+			validate!
+		end
+
+		def whitespace_separator?
+			@separator.is_a?(Regexp) && @separator == WHITESPACE_SEPARATOR_SENTINEL
+		end
+
+		def escape_enabled?
+			@escape && @escape != ""
+		end
+
+		def whitespace_char?(ch)
+			!!(ch =~ /\s/)
+		end
+
+		def encloser_open_pair_for(ch)
+			@enclosers.find { |pair| pair[:open] == ch }
+		end
+
+		def separator_boundary_at?(string, index)
+			ch = string[index]
+			return whitespace_char?(ch) if whitespace_separator?
+			ch == @separator
+		end
+
+		private
+
+		def validate!
+			validate_separator!
+			validate_escape!
+			validate_assignment!
+			validate_enclosers!
+			validate_duplicates!
+			validate_character_uniqueness!
+		end
+
+		def validate_separator!
+			if @separator.is_a?(Regexp)
+				unless @separator == WHITESPACE_SEPARATOR_SENTINEL
+					raise ConfigurationError, "separator only supports the exact regex /\\s/ or a single character string"
+				end
+			else
+				validate_single_char!("separator", @separator)
+				if whitespace_char?(@separator)
+					raise ConfigurationError, "separator cannot be whitespace unless it is the exact regex /\\s/"
+				end
+			end
+		end
+
+		def validate_escape!
+			return if @escape.nil? || @escape == ""
+			validate_single_char!("escape", @escape)
+		end
+
+		def validate_assignment!
+			unless @assignment.is_a?(Array)
+				raise ConfigurationError, "assignment must be an array of single-character strings"
+			end
+			@assignment.each { |ch| validate_single_char!("assignment operator", ch) }
+		end
+
+		def validate_enclosers!
+			unless @enclosers.is_a?(Array)
+				raise ConfigurationError, "enclosers must be an array of {open:, close:} hashes"
+			end
+
+			@enclosers.each do |pair|
+				unless pair.is_a?(Hash) && pair.key?(:open) && pair.key?(:close)
+					raise ConfigurationError, "each encloser must be a hash with keys :open and :close"
+				end
+				validate_single_char!("encloser open", pair[:open])
+				validate_single_char!("encloser close", pair[:close])
+				if pair[:open] == "" || pair[:close] == ""
+					raise ConfigurationError, "encloser open/close cannot be empty"
+				end
+			end
+		end
+
+		def validate_duplicates!
+			unless [:first, :last].include?(@duplicates)
+				raise ConfigurationError, "duplicates must be :first or :last"
+			end
+		end
+
+		def validate_single_char!(label, value)
+			unless value.is_a?(String) && value.length == 1
+				raise ConfigurationError, "#{label} must be a single-character string"
+			end
+		end
+
+		def validate_character_uniqueness!
+			chars = []
+			chars << @separator if @separator.is_a?(String)
+			chars << @escape if escape_enabled?
+			chars.concat(@assignment)
+
+			encloser_chars = []
+			@enclosers.each do |pair|
+				encloser_chars << pair[:open]
+				encloser_chars << pair[:close] unless pair[:close] == pair[:open]
+			end
+
+			all = chars + encloser_chars
+			if all.uniq.length != all.length
+				raise ConfigurationError, "separator/escape/assignment/enclosers must use unique characters (except open==close within an encloser pair)"
+			end
+		end
+	end
+end

data/lib/argstring/errors.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Argstring
+	class ConfigurationError < StandardError; end
+
+	# Structured parse error.
+	class ParseError
+		attr_reader :code, :message, :raw
+
+		# code: symbol identifying the error type
+		# message: human-readable explanation
+		# raw: raw input or segment associated with the error (may be nil)
+		def initialize(code:, message:, raw: nil)
+			@code = code
+			@message = message
+			@raw = raw
+		end
+
+		def to_s
+			return @message unless @raw
+			"#{@message} (#{@raw.inspect})"
+		end
+	end
+end

data/lib/argstring/lexer/assignment_finder.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Argstring
+	module Lexer
+		class AssignmentFinder
+			def initialize(config)
+				@config = config
+			end
+
+			# Find all top-level assignment operators in the segment.
+			# Returns array of indices into the segment string.
+			def indices(segment, errors:)
+				indices = []
+
+				i = 0
+				in_enclosure = false
+				current_encloser = nil
+
+				while i < segment.length
+					ch = segment[i]
+
+					if in_enclosure
+						if @config.escape_enabled? && ch == @config.escape
+							i = advance_past_escape(segment, i)
+							next
+						end
+
+						if ch == current_encloser[:close]
+							in_enclosure = false
+							current_encloser = nil
+						end
+						i += 1
+						next
+					end
+
+					pair = @config.encloser_open_pair_for(ch)
+					if pair
+						in_enclosure = true
+						current_encloser = pair
+						i += 1
+						next
+					end
+
+					if @config.escape_enabled? && ch == @config.escape
+						i = advance_past_escape(segment, i)
+						next
+					end
+
+					if @config.assignment.include?(ch)
+						indices << i
+					end
+
+					i += 1
+				end
+
+				if in_enclosure
+					errors << ParseError.new(
+						code: :unterminated_enclosure,
+						message: "Unterminated enclosure in segment",
+						raw: segment
+					)
+					return []
+				end
+
+				indices
+			end
+
+			private
+
+			def advance_past_escape(string, index)
+				return index + 1 if index + 1 >= string.length
+				index + 2
+			end
+		end
+	end
+end

data/lib/argstring/lexer/segmenter.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Argstring
+	module Lexer
+		class Segmenter
+			def initialize(config)
+				@config = config
+			end
+
+			# Split argstring into raw segments using the configured separator.
+			# Enclosures and escapes prevent splitting.
+			def split(argstring, errors:)
+				# Always strip leading/trailing whitespace globally in all modes.
+				# Users who want leading/trailing whitespace must enclose it.
+				argstring = argstring.to_s.strip
+				
+				segments = []
+				buffer = +""
+
+				i = 0
+				in_enclosure = false
+				current_encloser = nil
+
+				while i < argstring.length
+					ch = argstring[i]
+
+					if in_enclosure
+						# Escape inside enclosure consumes next character literally.
+						if @config.escape_enabled? && ch == @config.escape
+							if i + 1 < argstring.length
+								buffer << ch
+								buffer << argstring[i + 1]
+								i += 2
+							else
+								buffer << ch
+								i += 1
+							end
+							next
+						end
+
+						buffer << ch
+						if ch == current_encloser[:close]
+							in_enclosure = false
+							current_encloser = nil
+						end
+						i += 1
+						next
+					end
+
+					# Start enclosure if configured.
+					pair = @config.encloser_open_pair_for(ch)
+					if pair
+						in_enclosure = true
+						current_encloser = pair
+						buffer << ch
+						i += 1
+						next
+					end
+
+					# Escape outside enclosure.
+					if @config.escape_enabled? && ch == @config.escape
+						# If separator is whitespace, escaping whitespace separators is not allowed.
+						if @config.whitespace_separator? && i + 1 < argstring.length && @config.whitespace_char?(argstring[i + 1])
+							i += 1
+							next
+						end
+
+						if i + 1 < argstring.length
+							buffer << ch
+							buffer << argstring[i + 1]
+							i += 2
+						else
+							buffer << ch
+							i += 1
+						end
+						next
+					end
+
+					# Separator handling.
+					if @config.separator_boundary_at?(argstring, i)
+						flush_segment!(segments, buffer)
+
+						if @config.whitespace_separator?
+							# Collapse whitespace runs.
+							while i < argstring.length && @config.whitespace_char?(argstring[i])
+								i += 1
+							end
+						else
+							# Non-whitespace separator does not collapse.
+							i += 1
+						end
+						next
+					end
+
+					buffer << ch
+					i += 1
+				end
+
+				if in_enclosure
+					errors << ParseError.new(
+						code: :unterminated_enclosure,
+						message: "Unterminated enclosure in input"
+					)
+					return []
+				end
+
+				flush_segment!(segments, buffer)
+				segments
+			end
+
+			private
+
+			def flush_segment!(segments, buffer)
+				segments << buffer.dup
+				buffer.clear
+			end
+		end
+	end
+end

data/lib/argstring/lexer/token_parser.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Argstring
+	module Lexer
+		class TokenParser
+			def initialize(config)
+				@config = config
+			end
+
+			def parse_name(slice, raw:, errors:)
+				parse_token(slice, raw: raw, errors: errors, token_class: Name)
+			end
+
+			def parse_value(slice, raw:, errors:)
+				parse_token(slice, raw: raw, errors: errors, token_class: Value)
+			end
+
+			private
+
+			def parse_token(slice, raw:, errors:, token_class:)
+				# For non-whitespace separators, the segment itself is trimmed. For safety, trim token edges too.
+				unless @config.whitespace_separator?
+					slice = slice.strip
+				end
+
+				if slice == ""
+					return token_class.new(text: "", raw: raw, enclosed: false, enclosure: nil)
+				end
+
+				pair = @config.encloser_open_pair_for(slice[0])
+				if pair
+					return parse_enclosed_token(slice, raw: raw, pair: pair, errors: errors, token_class: token_class)
+				end
+
+				text = unescape_text(slice)
+				token_class.new(text: text, raw: raw, enclosed: false, enclosure: nil)
+			end
+
+			def parse_enclosed_token(slice, raw:, pair:, errors:, token_class:)
+				open_ch = pair[:open]
+				close_ch = pair[:close]
+
+				i = 1
+				text_buffer = +""
+				found_close = false
+
+				while i < slice.length
+					ch = slice[i]
+
+					if @config.escape_enabled? && ch == @config.escape
+						if i + 1 < slice.length
+							text_buffer << slice[i + 1]
+							i += 2
+							next
+						end
+						# Trailing escape disappears.
+						i += 1
+						next
+					end
+
+					if ch == close_ch
+						found_close = true
+						i += 1
+						break
+					end
+
+					text_buffer << ch
+					i += 1
+				end
+
+				unless found_close
+					errors << ParseError.new(
+						code: :unterminated_enclosure,
+						message: "Unterminated enclosed token",
+						raw: raw
+					)
+					return nil
+				end
+
+				trailing = slice[i..-1] || ""
+				unless trailing.strip == ""
+					errors << ParseError.new(
+						code: :trailing_after_enclosure,
+						message: "Unexpected trailing characters after enclosure",
+						raw: raw
+					)
+					return nil
+				end
+
+				token_class.new(text: text_buffer, raw: raw, enclosed: true, enclosure: { open: open_ch, close: close_ch })
+			end
+
+			def unescape_text(text)
+				return text.dup unless @config.escape_enabled?
+
+				out = +""
+				i = 0
+				while i < text.length
+					ch = text[i]
+					if ch == @config.escape
+						# In whitespace-separator mode, escaping whitespace separators is not allowed.
+						if @config.whitespace_separator? && i + 1 < text.length && @config.whitespace_char?(text[i + 1])
+							i += 1
+							next
+						end
+
+						if i + 1 < text.length
+							out << text[i + 1]
+							i += 2
+						else
+							# Trailing escape disappears.
+							i += 1
+						end
+						next
+					end
+
+					out << ch
+					i += 1
+				end
+				out
+			end
+		end
+	end
+end

data/lib/argstring/models/argument.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Argstring
+	class Argument
+		# kind: :positional, :named, :flag
+		attr_reader :kind, :position, :name, :value, :values
+
+		def initialize(kind:, position: nil, name: nil, value: nil, values: nil)
+			@kind = kind
+			@position = position
+			@name = name
+			@value = value
+			@values = values || (value ? [value] : [])
+		end
+	end
+end

data/lib/argstring/models/arguments.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Argstring
+	class Arguments
+		attr_reader :valid, :errors, :all, :positional, :named, :flags
+		attr_reader :position, :name, :flag
+
+		def initialize(valid:, errors:, all:, positional:, named:, flags:, position:, name:, flag:)
+			@valid = valid
+			@errors = errors
+			@all = all
+			@positional = positional
+			@named = named
+			@flags = flags
+			@position = position
+			@name = name
+			@flag = flag
+		end
+
+		def valid?
+			@valid
+		end
+
+		# Human-readable errors
+		def error_messages
+			@errors.map(&:to_s)
+		end
+	end
+end

data/lib/argstring/models/name.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Argstring
+	class Name < Token
+	end
+end

data/lib/argstring/models/token.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Argstring
+	class Token
+		attr_reader :text, :raw, :enclosed, :enclosure
+
+		# enclosure is a hash {open:, close:} or nil
+		def initialize(text:, raw:, enclosed: false, enclosure: nil)
+			@text = text
+			@raw = raw
+			@enclosed = enclosed
+			@enclosure = enclosure
+		end
+
+		def enclosed?
+			@enclosed
+		end
+	end
+end

data/lib/argstring/models/value.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Argstring
+	class Value < Token
+	end
+end

data/lib/argstring/parser.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+
+module Argstring
+	class Parser
+		def initialize(separator: Config::WHITESPACE_SEPARATOR_SENTINEL, escape: "\\", assignment: ["="], enclosers: Config::DEFAULT_ENCLOSERS, duplicates: :last, flags: true, positional: true)
+			@config = Config.new(
+				separator: separator,
+				escape: escape,
+				assignment: assignment,
+				enclosers: enclosers,
+				duplicates: duplicates,
+				flags: flags,
+				positional: positional
+			)
+
+			@segmenter = Lexer::Segmenter.new(@config)
+			@assignment_finder = Lexer::AssignmentFinder.new(@config)
+			@token_parser = Lexer::TokenParser.new(@config)
+		end
+
+		def parse(argstring)
+			result = parse_internal(argstring.to_s)
+			unless result.valid?
+				warn("Argstring: #{result.error_messages.join('; ')}")
+			end
+			result
+		end
+
+		private
+
+		def parse_internal(argstring)
+			errors = []
+			all_args = []
+			positional_args = []
+			named_args = []
+			flag_args = []
+
+			position_hash = {}
+			name_hash = {}
+			flag_hash = {}
+
+			segments = @segmenter.split(argstring, errors: errors)
+			return build_invalid(errors) if errors.any?
+
+			pos_index = 0
+
+			segments.each do |segment_raw|
+				segment = segment_raw
+
+				# Non-whitespace separator: ignore leading/trailing whitespace around segments.
+				segment = segment.strip unless @config.whitespace_separator?
+
+				# Empty segment is allowed when separator is non-collapsing.
+				if segment == ""
+					if @config.positional_enabled
+						pos_index += 1
+						value_token = Value.new(text: "", raw: segment_raw, enclosed: false, enclosure: nil)
+						pos_arg = Argument.new(kind: :positional, position: pos_index, value: value_token, values: [value_token])
+						all_args << pos_arg
+						positional_args << pos_arg
+						position_hash[pos_index] = value_token
+
+						add_flag_for_positional!(all_args, flag_args, flag_hash, value_token) if @config.flags_enabled
+					end
+					next
+				end
+
+				parsed = parse_segment(segment, raw_segment: segment_raw, errors: errors)
+				return build_invalid(errors) if errors.any?
+
+				if parsed[:kind] == :named
+					upsert_named_argument!(
+						all_args: all_args,
+						named_args: named_args,
+						name_hash: name_hash,
+						name_token: parsed[:name_token],
+						value_token: parsed[:value_token]
+					)
+					next
+				end
+
+				# Positional
+				if @config.positional_enabled
+					pos_index += 1
+					value_token = parsed[:value_token]
+					pos_arg = Argument.new(kind: :positional, position: pos_index, value: value_token, values: [value_token])
+					all_args << pos_arg
+					positional_args << pos_arg
+					position_hash[pos_index] = value_token
+				end
+
+				add_flag_for_positional!(all_args, flag_args, flag_hash, parsed[:value_token]) if @config.flags_enabled
+			end
+
+			Arguments.new(
+				valid: true,
+				errors: [],
+				all: all_args,
+				positional: positional_args,
+				named: named_args,
+				flags: flag_args,
+				position: position_hash,
+				name: name_hash,
+				flag: flag_hash
+			)
+		end
+
+		def build_invalid(errors)
+			Arguments.new(
+				valid: false,
+				errors: errors,
+				all: [],
+				positional: [],
+				named: [],
+				flags: [],
+				position: {},
+				name: {},
+				flag: {}
+			)
+		end
+
+		def parse_segment(segment, raw_segment:, errors:)
+			assignment_indices = @assignment_finder.indices(segment, errors: errors)
+			return nil if errors.any?
+
+			# No assignment operators => positional
+			if assignment_indices.length == 0
+				value_token = @token_parser.parse_value(segment, raw: raw_segment, errors: errors)
+				return nil if errors.any?
+				return { kind: :positional, value_token: value_token }
+			end
+
+			# More than one assignment operator in a single segment is always invalid
+			if assignment_indices.length > 1
+				errors << ParseError.new(
+					code: :multiple_assignment,
+					message: "Multiple assignment operators in one argument",
+					raw: segment
+				)
+				return nil
+			end
+
+			# Exactly one assignment operator
+			idx = assignment_indices[0]
+
+			# If the entire segment is just the assignment operator, treat it as a positional literal.
+			# This allows '=' (or other configured assignment chars) to be used as a positional/flag.
+			if segment.length == 1 && @config.assignment.include?(segment)
+				value_token = @token_parser.parse_value(segment, raw: raw_segment, errors: errors)
+				return nil if errors.any?
+				return { kind: :positional, value_token: value_token }
+			end
+
+			left_raw = segment[0...idx]
+			right_raw = segment[(idx + 1)..-1] || ""
+
+			# Non-whitespace separator: ignore whitespace immediately around '=' (outside enclosures).
+			unless @config.whitespace_separator?
+				left_raw = left_raw.rstrip
+				right_raw = right_raw.lstrip
+			end
+
+			if left_raw == ""
+				errors << ParseError.new(
+					code: :missing_name,
+					message: "Missing name before assignment operator",
+					raw: segment
+				)
+				return nil
+			end
+
+			if right_raw == ""
+				errors << ParseError.new(
+					code: :missing_value,
+					message: "Missing value after assignment operator",
+					raw: segment
+				)
+				return nil
+			end
+
+			name_token = @token_parser.parse_name(left_raw, raw: left_raw, errors: errors)
+			return nil if errors.any?
+
+			value_token = @token_parser.parse_value(right_raw, raw: right_raw, errors: errors)
+			return nil if errors.any?
+
+			{ kind: :named, name_token: name_token, value_token: value_token }
+		end
+
+		def add_flag_for_positional!(all_args, flag_args, flag_hash, positional_value_token)
+			flag_name = Name.new(
+				text: positional_value_token.text,
+				raw: positional_value_token.raw,
+				enclosed: positional_value_token.enclosed?,
+				enclosure: positional_value_token.enclosure
+			)
+			flag_value = Value.new(text: "true", raw: "true", enclosed: false, enclosure: nil)
+			flag_arg = Argument.new(kind: :flag, name: flag_name, value: flag_value, values: [flag_value])
+			all_args << flag_arg
+			flag_args << flag_arg
+			flag_hash[flag_name.text] = true
+		end
+
+		def upsert_named_argument!(all_args:, named_args:, name_hash:, name_token:, value_token:)
+			key = name_token.text
+			existing = named_args.find { |a| a.name.text == key }
+
+			if existing.nil?
+				arg = Argument.new(kind: :named, name: name_token, value: value_token, values: [value_token])
+				all_args << arg
+				named_args << arg
+				name_hash[key] = value_token
+				return arg
+			end
+
+			if @config.duplicates == :first
+				existing.values << value_token
+				name_hash[key] = existing.value
+				return existing
+			end
+
+			# :last
+			existing.values.unshift(value_token)
+			existing.instance_variable_set(:@value, value_token)
+			name_hash[key] = existing.value
+			existing
+		end
+	end
+end

data/lib/argstring/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Argstring
+	VERSION = "0.1.0"
+end

data/lib/argstring.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+# version must come first so errors, etc. have a version constant available
+require_relative "argstring/version"
+require_relative "argstring/errors"
+require_relative "argstring/config"
+
+require_relative "argstring/models/token"
+require_relative "argstring/models/name"
+require_relative "argstring/models/value"
+require_relative "argstring/models/argument"
+require_relative "argstring/models/arguments"
+
+require_relative "argstring/lexer/segmenter"
+require_relative "argstring/lexer/assignment_finder"
+require_relative "argstring/lexer/token_parser"
+
+require_relative "argstring/parser"

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: argstring
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Convincible Media
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-01-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+- !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'
+description: Configurable parser for single-line argument strings, returning a structured
+  set of sub-strings representing positional arguments, named arguments and flags.
+email:
+- development@convincible.media
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/argstring.rb
+- lib/argstring/config.rb
+- lib/argstring/errors.rb
+- lib/argstring/lexer/assignment_finder.rb
+- lib/argstring/lexer/segmenter.rb
+- lib/argstring/lexer/token_parser.rb
+- lib/argstring/models/argument.rb
+- lib/argstring/models/arguments.rb
+- lib/argstring/models/name.rb
+- lib/argstring/models/token.rb
+- lib/argstring/models/value.rb
+- lib/argstring/parser.rb
+- lib/argstring/version.rb
+homepage: https://github.com/ConvincibleMedia/ruby-gem-argstring
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.4'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14.4
+signing_key: 
+specification_version: 4
+summary: Parses argument strings into structured substrings.
+test_files: []