| Age | Commit message (Collapse) | Author |
|---|
|
|
|
Idiomatic Go uses struct{} for zero-allocation sets. Two locations:
- GetCompletionTopics: seen deduplication map
- init(): seenCat category deduplication map
|
|
Add a Render func() string field to HelpTopic that overrides the
default formatTopic rendering. Use it to register 'categories' as a
normal HelpTopic entry instead of a hardcoded if-branch in GetHelp.
- Remove hardcoded if topic == "categories" from GetHelp
- Remove hardcoded 'categories' from GetCompletionTopics
- Remove dead getCategoriesHelp function from help.go
- 'categories' now discovered through normal helpByTopic lookup
|
|
The original help.go was 657 lines mixing data, indexing, and lookup
logic. Split into:
- help_topics.go (489 lines): HelpTopic struct, helpTopics data slice,
index variables, and init() that builds the lookup maps.
- help.go (171 lines): GetHelp, GetAllTopics, GetCompletionTopics,
getGeneralHelp, getCategoriesHelp, and formatTopic.
All tests pass. No behavioral changes.
|
|
Per the readline AutoCompleter docs, Do() should return suffixes
(the characters AFTER the common prefix), not full matches. The
length parameter indicates how many characters are shared.
This fixes the bug where readline appended the full match to the
typed input (e.g. 'he' + 'help' = 'hehelp') because commonLen
was 0 and readline had no idea what to replace.
Now 'he<TAB>' returns suffix 'lp' with commonLen=2, so readline
correctly replaces 'he' with 'help'.
|
|
When the typed word already exactly matches a command (e.g. 'help'),
return no completions. Readline would append the match, producing
'helphelp'. Partial matches still work normally (e.g. 'he' → 'help').
|
|
When user types 'help ' (with trailing space), the completer now
offers help topic completions (+, dup, swap, etc.). Just 'help'
without a space still completes the command normally.
Also skip 'help' itself from GetCompletionTopics to avoid
suggesting 'help help'.
|
|
'help <TAB>' was suggesting 'help help'. Skip 'help' itself
in GetCompletionTopics so tab completion offers actual topics.
|
|
Replace the old static help text with a data-driven help system that
provides one help entry per operator, function, or REPL command, each
with category, description, usage, and examples.
- help.go: 35+ help topics covering all operators (arithmetic,
comparison, stack, hyper, variables, constants, REPL commands)
- GetHelp(topic) returns formatted help; GetHelp("") returns overview
- help categories lists all topics grouped by category
- Aliases supported (e.g. help gt shows help for > operator)
- Auto-completion for help topics when typing 'help <TAB>'
- REPL entries take priority in helpByTopic (e.g. 'help clear' shows
screen clear, not RPN variable clear)
- Comprehensive tests for all public functions
|
|
|
|
MetricReader (task ok)
|
|
(task nk)
|
|
|
|
CommandOpProvider (task fk)
|
|
interfaces (task ek)
|
|
|
|
|
|
|
|
|
|
|
|
(task 5k)
|
|
|
|
|
|
|
|
|
|
|
|
|
|
assertion (task yj)
|
|
All operator registry keys are lowercase, so strings.ToLower(token)
was a no-op. Removing the unnecessary lowercasing and the unused
op variable, passing the original token directly to
IsStandardOperator/IsHyperOperator/EvalOperator.
|
|
Extract the duplicated type switch on StackValue in AssignLeft()
and AssignRight() into a single extractVarName() helper, closing
the OCP violation — adding a new StackValue subtype as a valid
variable name now only requires editing one function.
|
|
Add variadic preChecks parameter to binaryMetricOp, allowing callers to
run a validation on the right operand before metric resolution. This
eliminates the full pipeline duplication in Divide() — it now delegates
to binaryMetricOp with a preCheck that guards against division by zero.
|
|
Add var _ Interface assertions to verify implementations at compile
time:
- internal/rpn/variables.go: assert *Variables against
VariableReader, VariableWriter, VariablePersistence, and
VariableStore
- internal/repl/handlers.go: assert *BuiltInCommandHandler,
*RPNHandler, *PercentageHandler, and *ErrorHandler against
CommandHandler (BaseHandler intentionally excluded as it lacks a
Handle method and is only meant for embedding)
- internal/repl/completer.go: assert *AutoCompleteAdapter against
readline.AutoCompleter (adds readline import)
Note: internal/rpn/constants.go already had assertions in place.
|
|
Replace the hardcoded strings.HasPrefix check for "rpn " and "calc "
with a loop over a package-level rpnPrefixes slice. Adding a new prefix
now only requires appending to the slice, satisfying the Open/Closed
Principle.
|
|
responsibility (sj)
Move built-in constants into a package-level builtInConstants map so
loadBuiltInConstants() only copies from it (no return value). Reload
and Clear now simply clear and copy from the source map, removing the
maps.DeleteFunc dance and the unused maps import.
|
|
OCP violation: adding a new Category required editing the String()
method. Use a parallel categoryNames slice indexed by Category value
instead, so adding a new category only requires appending to the
slice. _sentinel already bounds the range.
|
|
Move the inline logic for the 'd' (delete variable) operator into a
proper Operations.Delete method, following the same registration pattern
as all other operators. Adds Delete to the StackOperator interface.
|
|
interface (nj)
Accept the OperatorProvider interface instead of concrete *Operations in
NewOperatorRegistry() and all register* methods. OperatorProvider embeds
ArithmeticOperator, PowerIntOperator, LogarithmicOperator, BooleanOperator,
StackOperator, VariableOperator, ConstantOperator, MetricOperator, and
HyperOperator, allowing mocking or alternative implementations.
|
|
sub-interfaces (#wj)
Follows the same ISP-compliant pattern as VariableStore (VariableReader,
VariableWriter, VariablePersistence). The fat 7-method ConstantsProvider
is now split into:
- ConstantsReader: GetConstant, ListConstants, Count, HasConstant
- ConstantsWriter: SetConstant
- ConstantsAdmin: ClearConstants, ReloadBuiltInConstants
- ConstantsProvider: embeds all three for convenience
RPN.consts narrowed to ConstantsReader since RPN only reads constants;
GetConstants() asserts to ConstantsProvider for callers that need full access.
Added compile-time satisfaction checks for all sub-interfaces.
|
|
If stack.Pop() errors midway through the loop, already-popped values
are pushed back in reverse order before returning the error, preventing
stack corruption from concurrent modification or unexpected failures.
|
|
Replace hardcoded switch statements in resultMetricForMul and
resultMetricForDiv with package-level maps (multiplicationInference,
divisionInference). Adding new category pairs now only requires
appending to the maps instead of editing control flow, satisfying
OCP.
|
|
Handlers accessed repl.rpnState.rpnCalc — three levels of concrete types
violating DIP and Law of Demeter. Define an RPNCalculator interface
capturing only the methods handlers actually need, and expose it via
REPL.RpnCalculator() so handlers depend on the interface, not the
concrete chain of *rpn.RPN.
|
|
The dispatchToken guard for standalone "=" always fires before the
registry lookup, making the "=" registration in operator_registry.go
dead code. Assignment with "=" is handled at the expression level by
handleStandardAssign, not via the stack-level operator registry.
Also update related tests:
- TestAssignmentOperatorRegistry: remove "=" from registered operators
- TestResultStackErrors: "=" is no longer an operator, expects
"unknown token" instead of "insufficient operands"
|
|
NewOperatorRegistry() was 60+ lines of registration calls. Split into six
category-specific helpers: registerArithmeticOperators,
registerComparisonOperators, registerStackOperators,
registerVariableOperators, registerCommandOperators, and
registerHyperOperators.
NewOperatorRegistry() is now a thin ~13-line orchestrator.
|
|
Replace stack.Values() with direct Pop() calls in Swap().
Previously created a full stack copy just to read the top two values.
Behavior is unchanged — ensureStackLength guard guarantees pops succeed.
|
|
Deduplicate identical VariableInfo sorting logic across
ListVariables(), formatVariablesUnsafe(), and Save(). All three
callers now use a single unexported sortVariableInfos helper.
|
|
Factor out the repeated save-restore-evaluate pattern from
RPNHandler.Handle() into a single helper method so the stack
is always restored on parse errors, across all call sites.
|
|
Define OperationsProvider interface composed of focused sub-interfaces
(ModeController, MetricCommander, CustomMetricManager) plus the existing
StackOperator. Change RPN.ops from *Operations to OperationsProvider so the
high-level RPN module depends on abstractions, not the concrete type (DIP).
Add compile-time assertions for the new interfaces in operations.go.
|
|
The ArithmeticOperator interface bundled basic arithmetic (+, -, *, /, ^, %),
logarithmic operations (Log2, Log10, Ln), and metric conversion (Convert) into
a single interface, violating ISP and LSP.
Split into:
- ArithmeticOperator — Add, Subtract, Multiply, Divide, Power, Modulo
- LogarithmicOperator — Log2, Log10, Ln
- MetricOperator — Convert
Updated compile-time interface checks in operations.go and the trailing
comment in operations_interfaces.go. No behavioral change.
|
|
Extract inline helper methods to bring dispatchToken,
handleMetricCommand, and handleCustomCommand under 50 lines:
- handleInlineAssignment: extracts := / =: stack assignment logic
- handleMetricPrefix: handles metric binary/decimal prefix mode switching
- handleCustomDefine: handles 'custom define' subcommand
- handleCustomUndefine: handles 'custom undefine' subcommand
dispatchToken: 55 -> 47 lines
handleMetricCommand: 40 -> 38 lines
handleCustomCommand: 43 -> 31 lines
|
|
(task 5j)
The loop checking remaining characters was dead code — the final
check meant any token longer than 1 char was rejected
regardless of what the loop found. Replace the entire function with a
simple single-char check.
|
