| Age | Commit message (Collapse) | Author |
|---|
|
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.
|
|
Extract runCommand() in cmd/gt/main.go into separate helpers
following SRP:
- parseFlags(): extract --log flag parsing
- dispatchInput(): route by arg count/content (version, stdin, args)
- handleNoInput(): TTY→REPL or stdin→parse path
- startREPL(): REPL launch with optional log file
- tryParse(): RPN-first with percentage fallback
runCommand() is now a 3-line orchestrator delegating to parseFlags()
and dispatchInput(). No behavioral change; all tests pass.
|
|
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.
|
|
NewOperations() no longer creates a ConstantsProvider internally since
NewRPN() always calls SetConstants() immediately after. Eliminates a
wasted allocation with no behavioral change.
|
|
Deduplicate the repeated stack overflow check in pushLiteral() by
extracting it into a checkStackOverflow() helper method. Replaces
three identical inline checks with calls to the new helper.
|
|
|
|
Document all invocation modes (single-expression, REPL, pipe, stdin),
boolean coercion rules, version/help behavior, exit codes, and practical
use cases for scripts and CI pipelines.
|
|
|
|
|
|
Test and document rational number mode:
- rat on/off/toggle commands (REPL only)
- How big.Rat integration works internally
- Precision comparison examples with actual output
- Known limitation: +, -, % fail for non-dyadic decimals (0.1, 0.2)
due to Rat.Float64() rejecting lossy conversions
- Performance trade-offs vs float64 mode
- Edge cases including metrics, constants, and variables
- When to use rational mode and when to stick with float mode
|
|
Document custom metric commands (define/undefine/list/show) with
syntax, REPL workflow examples, arithmetic usage, practical use cases,
and edge cases including duplicate names, invalid categories, and
factor zero behavior.
|
