) => {
46 | if (
47 | (event.key === 'k' && event.metaKey !== event.ctrlKey && !event.altKey) ||
48 | (event.key === 'l' && event.ctrlKey && !event.metaKey && !event.altKey)
49 | ) {
50 | // Cmd+K, Ctrl+K or Ctrl+L to clear the buffer
51 | setOutput(null);
52 | return;
53 | }
54 | if (event.key === 'ArrowUp') {
55 | event.preventDefault();
56 | upArrow();
57 | return;
58 | }
59 | if (event.key === 'ArrowDown') {
60 | event.preventDefault();
61 | downArrow();
62 | return;
63 | }
64 |
65 | // allow multiple lines to be entered if shift, ctrl
66 | // or meta is held, otherwise evaluate the expression
67 | if (!(event.key === 'Enter' && !event.shiftKey && !event.ctrlKey && !event.metaKey && !event.altKey)) {
68 | return;
69 | }
70 | event.preventDefault();
71 | if (currentInput.trim() === 'clear') {
72 | onInput('');
73 | setOutput(null);
74 | return;
75 | }
76 |
77 | startTransition(async () => {
78 | const request = {`> ${currentInput}`}
;
79 | submit();
80 | const fendResult = await evaluate(currentInput);
81 | if (!fendResult.ok && fendResult.message === 'cancelled') {
82 | return;
83 | }
84 | onInput('');
85 | const result = {fendResult.ok ? fendResult.result : `Error: ${fendResult.message}`}
;
86 | setOutput(o => (
87 | <>
88 | {o}
89 | {request}
90 | {result}
91 |
92 | ));
93 | setTimeout(() => {
94 | pendingOutput.current?.scrollIntoView({ behavior: 'smooth' });
95 | }, 50);
96 | });
97 | };
98 | useEffect(() => {
99 | const focus = () => {
100 | // allow the user to select text for copying and
101 | // pasting, but if text is deselected (collapsed)
102 | // refocus the input field
103 | if (document.activeElement !== inputText.current && document.getSelection()?.isCollapsed) {
104 | inputText.current?.focus();
105 | }
106 | };
107 | document.addEventListener('click', focus);
108 | return () => {
109 | document.removeEventListener('click', focus);
110 | };
111 | }, []);
112 | return (
113 |
114 | {!widget && (
115 |
116 | fend is an arbitrary-precision
117 | unit-aware calculator.
118 |
119 | )}
120 | {output}
121 |
139 |
140 | );
141 | }
142 |
--------------------------------------------------------------------------------
/core/src/scope.rs:
--------------------------------------------------------------------------------
1 | use crate::ident::Ident;
2 | use crate::result::FResult;
3 | use crate::serialize::{Deserialize, Serialize};
4 | use crate::value::Value;
5 | use crate::{Attrs, Context, Span};
6 | use crate::{ast::Expr, error::Interrupt};
7 | use std::io;
8 | use std::sync::Arc;
9 |
10 | #[derive(Debug, Clone)]
11 | enum ScopeValue {
12 | LazyVariable(Expr, Option>),
13 | }
14 |
15 | impl ScopeValue {
16 | pub(crate) fn compare(
17 | &self,
18 | other: &Self,
19 | ctx: &mut Context,
20 | int: &I,
21 | ) -> FResult {
22 | let Self::LazyVariable(a1, a2) = self;
23 | let Self::LazyVariable(b1, b2) = other;
24 | Ok(a1.compare(b1, ctx, int)?
25 | && compare_option_arc_scope(a2.as_ref(), b2.as_ref(), ctx, int)?)
26 | }
27 |
28 | fn eval(
29 | &self,
30 | attrs: Attrs,
31 | spans: &mut Vec,
32 | context: &mut crate::Context,
33 | int: &I,
34 | ) -> FResult {
35 | match self {
36 | Self::LazyVariable(expr, scope) => {
37 | let value =
38 | crate::ast::evaluate(expr.clone(), scope.clone(), attrs, spans, context, int)?;
39 | Ok(value)
40 | }
41 | }
42 | }
43 |
44 | pub(crate) fn serialize(&self, write: &mut impl io::Write) -> FResult<()> {
45 | match self {
46 | Self::LazyVariable(e, s) => {
47 | e.serialize(write)?;
48 | match s {
49 | None => false.serialize(write)?,
50 | Some(s) => {
51 | true.serialize(write)?;
52 | s.serialize(write)?;
53 | }
54 | }
55 | }
56 | }
57 | Ok(())
58 | }
59 |
60 | pub(crate) fn deserialize(read: &mut impl io::Read) -> FResult {
61 | Ok(Self::LazyVariable(Expr::deserialize(read)?, {
62 | if bool::deserialize(read)? {
63 | None
64 | } else {
65 | Some(Arc::new(Scope::deserialize(read)?))
66 | }
67 | }))
68 | }
69 | }
70 |
71 | #[derive(Debug, Clone)]
72 | pub(crate) struct Scope {
73 | ident: Ident,
74 | value: ScopeValue,
75 | inner: Option>,
76 | }
77 |
78 | pub(crate) fn compare_option_arc_scope(
79 | a: Option<&Arc>,
80 | b: Option<&Arc>,
81 | ctx: &mut Context,
82 | int: &I,
83 | ) -> FResult {
84 | Ok(match (a, b) {
85 | (None, None) => true,
86 | (Some(a), Some(b)) => a.compare(b, ctx, int)?,
87 | _ => false,
88 | })
89 | }
90 |
91 | impl Scope {
92 | pub(crate) fn compare(
93 | &self,
94 | other: &Self,
95 | ctx: &mut Context,
96 | int: &I,
97 | ) -> FResult {
98 | Ok(self.ident == other.ident
99 | && self.value.compare(&other.value, ctx, int)?
100 | && compare_option_arc_scope(self.inner.as_ref(), other.inner.as_ref(), ctx, int)?)
101 | }
102 |
103 | pub(crate) fn serialize(&self, write: &mut impl io::Write) -> FResult<()> {
104 | self.ident.serialize(write)?;
105 | self.value.serialize(write)?;
106 | match &self.inner {
107 | None => false.serialize(write)?,
108 | Some(s) => {
109 | true.serialize(write)?;
110 | s.serialize(write)?;
111 | }
112 | }
113 | Ok(())
114 | }
115 |
116 | pub(crate) fn deserialize(read: &mut impl io::Read) -> FResult {
117 | Ok(Self {
118 | ident: Ident::deserialize(read)?,
119 | value: ScopeValue::deserialize(read)?,
120 | inner: {
121 | if bool::deserialize(read)? {
122 | None
123 | } else {
124 | Some(Arc::new(Self::deserialize(read)?))
125 | }
126 | },
127 | })
128 | }
129 |
130 | const fn with_scope_value(ident: Ident, value: ScopeValue, inner: Option>) -> Self {
131 | Self {
132 | ident,
133 | value,
134 | inner,
135 | }
136 | }
137 |
138 | pub(crate) fn with_variable(
139 | name: Ident,
140 | expr: Expr,
141 | scope: Option>,
142 | inner: Option>,
143 | ) -> Self {
144 | Self::with_scope_value(name, ScopeValue::LazyVariable(expr, scope), inner)
145 | }
146 |
147 | pub(crate) fn get(
148 | &self,
149 | ident: &Ident,
150 | attrs: Attrs,
151 | spans: &mut Vec,
152 | context: &mut crate::Context,
153 | int: &I,
154 | ) -> FResult> {
155 | if self.ident.as_str() == ident.as_str() {
156 | let value = self.value.eval(attrs, spans, context, int)?;
157 | Ok(Some(value))
158 | } else {
159 | self.inner.as_ref().map_or_else(
160 | || Ok(None),
161 | |inner| inner.get(ident, attrs, spans, context, int),
162 | )
163 | }
164 | }
165 | }
166 |
--------------------------------------------------------------------------------
/core/src/num/base.rs:
--------------------------------------------------------------------------------
1 | use std::{fmt, io};
2 |
3 | use crate::{
4 | error::FendError,
5 | result::FResult,
6 | serialize::{Deserialize, Serialize},
7 | };
8 |
9 | #[derive(Copy, Clone, PartialEq, Eq)]
10 | pub(crate) struct Base(BaseEnum);
11 |
12 | #[derive(Copy, Clone, PartialEq, Eq)]
13 | enum BaseEnum {
14 | /// Binary with 0b prefix
15 | Binary,
16 | /// Octal with 0o prefix
17 | Octal,
18 | /// Hex with 0x prefix
19 | Hex,
20 | /// Custom base between 2 and 36 (inclusive), written as base#number
21 | Custom(u8),
22 | /// Plain (no prefix)
23 | Plain(u8),
24 | }
25 |
26 | impl Base {
27 | pub(crate) const HEX: Self = Self(BaseEnum::Hex);
28 |
29 | pub(crate) const fn base_as_u8(self) -> u8 {
30 | match self.0 {
31 | BaseEnum::Binary => 2,
32 | BaseEnum::Octal => 8,
33 | BaseEnum::Hex => 16,
34 | BaseEnum::Custom(b) | BaseEnum::Plain(b) => b,
35 | }
36 | }
37 |
38 | pub(crate) const fn from_zero_based_prefix_char(ch: char) -> FResult {
39 | Ok(match ch {
40 | 'x' => Self(BaseEnum::Hex),
41 | 'o' => Self(BaseEnum::Octal),
42 | 'b' => Self(BaseEnum::Binary),
43 | _ => return Err(FendError::InvalidBasePrefix),
44 | })
45 | }
46 |
47 | pub(crate) const fn from_plain_base(base: u8) -> FResult {
48 | if base < 2 {
49 | return Err(FendError::BaseTooSmall);
50 | } else if base > 36 {
51 | return Err(FendError::BaseTooLarge);
52 | }
53 | Ok(Self(BaseEnum::Plain(base)))
54 | }
55 |
56 | pub(crate) const fn from_custom_base(base: u8) -> FResult {
57 | if base < 2 {
58 | return Err(FendError::BaseTooSmall);
59 | } else if base > 36 {
60 | return Err(FendError::BaseTooLarge);
61 | }
62 | Ok(Self(BaseEnum::Custom(base)))
63 | }
64 |
65 | pub(crate) fn write_prefix(self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
66 | match self.0 {
67 | BaseEnum::Binary => write!(f, "0b")?,
68 | BaseEnum::Octal => write!(f, "0o")?,
69 | BaseEnum::Hex => write!(f, "0x")?,
70 | BaseEnum::Custom(b) => write!(f, "{b}#")?,
71 | BaseEnum::Plain(_) => (),
72 | }
73 | Ok(())
74 | }
75 |
76 | pub(crate) const fn has_prefix(self) -> bool {
77 | !matches!(self.0, BaseEnum::Plain(_))
78 | }
79 |
80 | pub(crate) const fn digit_as_char(digit: u64) -> Option {
81 | Some(match digit {
82 | 0 => '0',
83 | 1 => '1',
84 | 2 => '2',
85 | 3 => '3',
86 | 4 => '4',
87 | 5 => '5',
88 | 6 => '6',
89 | 7 => '7',
90 | 8 => '8',
91 | 9 => '9',
92 | 10 => 'a',
93 | 11 => 'b',
94 | 12 => 'c',
95 | 13 => 'd',
96 | 14 => 'e',
97 | 15 => 'f',
98 | 16 => 'g',
99 | 17 => 'h',
100 | 18 => 'i',
101 | 19 => 'j',
102 | 20 => 'k',
103 | 21 => 'l',
104 | 22 => 'm',
105 | 23 => 'n',
106 | 24 => 'o',
107 | 25 => 'p',
108 | 26 => 'q',
109 | 27 => 'r',
110 | 28 => 's',
111 | 29 => 't',
112 | 30 => 'u',
113 | 31 => 'v',
114 | 32 => 'w',
115 | 33 => 'x',
116 | 34 => 'y',
117 | 35 => 'z',
118 | _ => return None,
119 | })
120 | }
121 |
122 | pub(crate) fn serialize(self, write: &mut impl io::Write) -> FResult<()> {
123 | match self.0 {
124 | BaseEnum::Binary => 1u8.serialize(write)?,
125 | BaseEnum::Octal => 2u8.serialize(write)?,
126 | BaseEnum::Hex => 3u8.serialize(write)?,
127 | BaseEnum::Custom(b) => {
128 | 4u8.serialize(write)?;
129 | b.serialize(write)?;
130 | }
131 | BaseEnum::Plain(b) => {
132 | 5u8.serialize(write)?;
133 | b.serialize(write)?;
134 | }
135 | }
136 | Ok(())
137 | }
138 |
139 | pub(crate) fn deserialize(read: &mut impl io::Read) -> FResult {
140 | Ok(Self(match u8::deserialize(read)? {
141 | 1 => BaseEnum::Binary,
142 | 2 => BaseEnum::Octal,
143 | 3 => BaseEnum::Hex,
144 | 4 => BaseEnum::Custom(u8::deserialize(read)?),
145 | 5 => BaseEnum::Plain(u8::deserialize(read)?),
146 | _ => {
147 | return Err(FendError::DeserializationError(
148 | "number base is out of range",
149 | ));
150 | }
151 | }))
152 | }
153 | }
154 |
155 | impl Default for Base {
156 | fn default() -> Self {
157 | Self(BaseEnum::Plain(10))
158 | }
159 | }
160 |
161 | impl fmt::Debug for Base {
162 | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
163 | match self.0 {
164 | BaseEnum::Binary => write!(f, "binary"),
165 | BaseEnum::Octal => write!(f, "octal"),
166 | BaseEnum::Hex => write!(f, "hex"),
167 | BaseEnum::Custom(b) => write!(f, "base {b} (with prefix)"),
168 | BaseEnum::Plain(b) => write!(f, "base {b}"),
169 | }
170 | }
171 | }
172 |
--------------------------------------------------------------------------------
/cli/src/default_config.toml:
--------------------------------------------------------------------------------
1 | # Choose whether or not colors should be enabled. Possible
2 | # values are 'never', 'auto' (default) or 'always'
3 | enable-colors = 'auto'
4 |
5 | # Maximum number of calculations to store in fend's
6 | # history file
7 | max-history-size = 1000
8 |
9 | # The characters that are shown as the prompt when
10 | # using fend interactively
11 | prompt = '> '
12 |
13 | # Change 'C' and 'F' to refer to coulomb and farad
14 | # instead of degrees celsius and degrees fahrenheit
15 | coulomb-and-farad = false
16 |
17 | # What to do if this configuration file contains unknown
18 | # settings. These are the possible values:
19 | # * 'warn': print a warning on startup if there are any
20 | # unknown config settings (default)
21 | # * 'ignore': ignore any unknown configuration settings
22 | unknown-settings = 'warn'
23 |
24 | # Whether to enable internet access. This is required for
25 | # currency conversions, where fend makes a request to
26 | # the UN treasury or the European Central Bank website
27 | # to download up-to-date exchange rates.
28 | enable-internet-access = true
29 |
30 | # Data source for currency exchange rates. fend supports
31 | # the following options:
32 | # * `auto` retrieves data from both sources in parallel
33 | # * `UN` retrieves data from the UN treasury
34 | # (endpoint: https://treasury.un.org/operationalrates/xsql2XML.php)
35 | # * `EU` retrieves data from the EU central bank
36 | # (endpoint: https://www.ecb.europa.eu/stats/eurofxref/eurofxref-daily.xml)
37 | # * 'disabled' will disable loading of exchange rate data
38 | exchange-rate-source = "auto"
39 |
40 | # Maximum age of cached exchange rates in seconds.
41 | # If the cached data is older than this value, it will be refreshed.
42 | exchange-rate-max-age = 259200
43 |
44 | # Decimal and thousands separator style. This can be used to switch
45 | # between e.g. 1,234.56 and 1.234,56.
46 | #
47 | # Possible values:
48 | # * `default`: uses the default
49 | # * `dot`: uses dots as decimal separator and commas as the thousands
50 | # separator. This is commonly used in English.
51 | # * `comma`: uses commas as decimal separator and dots as the thousands
52 | # separator. This is common in European languages.
53 | decimal-separator-style = "default"
54 |
55 | # This section controls the colors that are used by
56 | # fend. Make sure the `enable-colors` setting is
57 | # turned on for this to work.
58 | #
59 | # Color options:
60 | # foreground: the foreground color to use
61 | # bold: whether or not to show text in bold font
62 | # underline: whether or not to underline text
63 | #
64 | # Valid colors are:
65 | # * 'black', 'red', 'green', 'yellow', 'blue',
66 | # 'magenta', 'cyan' or 'white'
67 | # * '256:n' (where `n` is a number between 0 and 255).
68 | #
69 | [colors]
70 | number = {}
71 | string = {}
72 | identifier = { foreground = 'white' }
73 | keyword = { foreground = 'blue', bold = true }
74 | built-in-function = { foreground = 'blue', bold = true }
75 | date = {}
76 | other = {}
77 |
78 | # You can define custom units via a `custom-units` array. If there's
79 | # a unit you would like to see added to fend, please consider making
80 | # a pull request to add it to the built-in unit definitions.
81 | #
82 | # Example syntax:
83 | # ```
84 | # [[custom-units]]
85 | # singular = 'mile'
86 | # plural = 'miles' # plural name can be omitted if it is
87 | # # the same as the singular name
88 | # definition = '1609.344 meters'
89 | # attribute = 'allow_long_prefix'
90 | # ```
91 | #
92 | # If the singular and plural names are the same, you can omit
93 | # the `plural` setting.
94 | #
95 | # The `attribute` setting is optional. It can be set
96 | # to one of these values:
97 | # * 'none': this unit cannot be used with prefixes (default)
98 | # * 'allow-long-prefix': allow prefixes like
99 | # 'milli-' or 'giga-' with this unit
100 | # * 'allow-short-prefix': allow abbreviated
101 | # prefixes like 'm' or 'G' (for 'milli' and 'giga' respectively)
102 | # * 'is-long-prefix': allow using this unit
103 | # as a long prefix with another unit
104 | # * 'alias': always expand this unit to its definition
105 | #
106 | # Here are some more examples of how you could define custom units:
107 | #
108 | # ```
109 | # [[custom-units]]
110 | # singular = 'milli'
111 | # definition = '0.001'
112 | # attribute = 'is_long_prefix'
113 | #
114 | # [[custom-units]]
115 | # singular = 'byte'
116 | # plural = 'bytes'
117 | # definition = '!' # an exclamation mark defines a new base unit
118 | # attribute = 'allow_long_prefix'
119 | # ```
120 |
--------------------------------------------------------------------------------
/core/src/num/unit/unit_exponent.rs:
--------------------------------------------------------------------------------
1 | use std::cmp::Ordering;
2 | use std::{collections::HashMap, fmt, io};
3 |
4 | use crate::interrupt::test_int;
5 | use crate::num::complex::{self, Complex, UseParentheses};
6 | use crate::num::{Base, Exact, FormattingStyle};
7 | use crate::result::FResult;
8 | use crate::serialize::{CborValue, Deserialize, Serialize};
9 | use crate::{DecimalSeparatorStyle, Interrupt};
10 |
11 | use super::{base_unit::BaseUnit, named_unit::NamedUnit};
12 |
13 | #[derive(Clone)]
14 | pub(crate) struct UnitExponent {
15 | pub(crate) unit: NamedUnit,
16 | pub(crate) exponent: Complex,
17 | }
18 |
19 | impl UnitExponent {
20 | pub(crate) fn new(unit: NamedUnit, exponent: impl Into) -> Self {
21 | Self {
22 | unit,
23 | exponent: exponent.into(),
24 | }
25 | }
26 |
27 | pub(crate) fn serialize(&self, write: &mut impl io::Write) -> FResult<()> {
28 | self.unit.serialize(write)?;
29 | self.exponent.serialize().serialize(write)?;
30 | Ok(())
31 | }
32 |
33 | pub(crate) fn deserialize(read: &mut impl io::Read) -> FResult {
34 | Ok(Self {
35 | unit: NamedUnit::deserialize(read)?,
36 | exponent: Complex::deserialize(CborValue::deserialize(read)?)?,
37 | })
38 | }
39 |
40 | pub(crate) fn is_alias(&self) -> bool {
41 | self.unit.is_alias()
42 | }
43 |
44 | pub(crate) fn is_percentage_unit(&self) -> bool {
45 | let (prefix, name) = self.unit.prefix_and_name(false);
46 | prefix.is_empty() && ["%", "percent"].contains(&name)
47 | }
48 |
49 | pub(crate) fn add_to_hashmap(
50 | &self,
51 | hashmap: &mut HashMap,
52 | scale: &mut Complex,
53 | exact: &mut bool,
54 | int: &I,
55 | ) -> FResult<()> {
56 | test_int(int)?;
57 | let overall_exp = &Exact::new(self.exponent.clone(), true);
58 | for (base_unit, base_exp) in &self.unit.base_units {
59 | test_int(int)?;
60 | let base_exp = Exact::new(base_exp.clone(), true);
61 | let product = overall_exp.clone().mul(&base_exp, int)?;
62 | if let Some(exp) = hashmap.get_mut(base_unit) {
63 | let new_exp = Exact::new(exp.clone(), true).add(product, int)?;
64 | *exact = *exact && new_exp.exact;
65 | if new_exp.value.compare(&0.into(), int)? == Some(Ordering::Equal) {
66 | hashmap.remove(base_unit);
67 | } else {
68 | *exp = new_exp.value;
69 | }
70 | } else {
71 | *exact = *exact && product.exact;
72 | if product.value.compare(&0.into(), int)? != Some(Ordering::Equal) {
73 | let adj_exp = overall_exp.clone().mul(&base_exp, int)?;
74 | hashmap.insert(base_unit.clone(), adj_exp.value);
75 | *exact = *exact && adj_exp.exact;
76 | }
77 | }
78 | }
79 | let pow_result = self
80 | .unit
81 | .scale
82 | .clone()
83 | .pow(overall_exp.value.clone(), int)?;
84 | *scale = Exact::new(scale.clone(), true).mul(&pow_result, int)?.value;
85 | *exact = *exact && pow_result.exact;
86 | Ok(())
87 | }
88 |
89 | pub(crate) fn format(
90 | &self,
91 | base: Base,
92 | format: FormattingStyle,
93 | plural: bool,
94 | invert_exp: bool,
95 | decimal_separator: DecimalSeparatorStyle,
96 | int: &I,
97 | ) -> FResult>> {
98 | let (prefix, name) = self.unit.prefix_and_name(plural);
99 | let exp = if invert_exp {
100 | -self.exponent.clone()
101 | } else {
102 | self.exponent.clone()
103 | };
104 | let (exact, exponent) = if exp.compare(&1.into(), int)? == Some(Ordering::Equal) {
105 | (true, None)
106 | } else {
107 | let formatted = exp.format(
108 | true,
109 | format,
110 | base,
111 | UseParentheses::IfComplexOrFraction,
112 | decimal_separator,
113 | int,
114 | )?;
115 | (formatted.exact, Some(formatted.value))
116 | };
117 | Ok(Exact::new(
118 | FormattedExponent {
119 | prefix,
120 | name,
121 | number: exponent,
122 | },
123 | exact,
124 | ))
125 | }
126 | }
127 |
128 | impl fmt::Debug for UnitExponent {
129 | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
130 | write!(f, "{:?}", self.unit)?;
131 | if !self.exponent.is_definitely_one() {
132 | write!(f, "^{:?}", self.exponent)?;
133 | }
134 | Ok(())
135 | }
136 | }
137 |
138 | #[derive(Debug)]
139 | pub(crate) struct FormattedExponent<'a> {
140 | prefix: &'a str,
141 | name: &'a str,
142 | number: Option,
143 | }
144 |
145 | impl fmt::Display for FormattedExponent<'_> {
146 | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
147 | write!(f, "{}{}", self.prefix, self.name)?;
148 | if let Some(number) = &self.number {
149 | write!(f, "^{number}")?;
150 | }
151 | Ok(())
152 | }
153 | }
154 |
--------------------------------------------------------------------------------
/core/src/value/built_in_function.rs:
--------------------------------------------------------------------------------
1 | use crate::FendError;
2 | use crate::result::FResult;
3 | use crate::value::Expr;
4 | use crate::value::Ident;
5 | use crate::value::Scope;
6 | use crate::{Deserialize, Serialize};
7 | use std::{fmt, io};
8 |
9 | use std::sync::Arc;
10 |
11 | use crate::value::Value;
12 |
13 | #[derive(Copy, Clone, Eq, PartialEq, Debug)]
14 | pub(crate) enum BuiltInFunction {
15 | Approximately,
16 | Abs,
17 | Sin,
18 | Cos,
19 | Tan,
20 | Asin,
21 | Acos,
22 | Atan,
23 | Sinh,
24 | Cosh,
25 | Tanh,
26 | Asinh,
27 | Acosh,
28 | Atanh,
29 | Ln,
30 | Log2,
31 | Log10,
32 | Base,
33 | Sample,
34 | Mean,
35 | Not,
36 | Conjugate,
37 | Real,
38 | Imag,
39 | Arg,
40 | Floor,
41 | Ceil,
42 | Round,
43 | Fibonacci,
44 | Print,
45 | Println,
46 | }
47 |
48 | impl BuiltInFunction {
49 | pub(crate) fn wrap_with_expr(
50 | self,
51 | lazy_fn: impl FnOnce(Box) -> Expr,
52 | scope: Option>,
53 | ) -> Value {
54 | Value::Fn(
55 | Ident::new_str("x"),
56 | Box::new(lazy_fn(Box::new(Expr::ApplyFunctionCall(
57 | Box::new(Expr::Ident(Ident::new_str(self.as_str()))),
58 | Box::new(Expr::Ident(Ident::new_str("x"))),
59 | )))),
60 | scope,
61 | )
62 | }
63 |
64 | pub(crate) fn invert(self) -> FResult {
65 | Ok(match self {
66 | Self::Sin => Value::BuiltInFunction(Self::Asin),
67 | Self::Cos => Value::BuiltInFunction(Self::Acos),
68 | Self::Tan => Value::BuiltInFunction(Self::Atan),
69 | Self::Asin => Value::BuiltInFunction(Self::Sin),
70 | Self::Acos => Value::BuiltInFunction(Self::Cos),
71 | Self::Atan => Value::BuiltInFunction(Self::Tan),
72 | Self::Sinh => Value::BuiltInFunction(Self::Asinh),
73 | Self::Cosh => Value::BuiltInFunction(Self::Acosh),
74 | Self::Tanh => Value::BuiltInFunction(Self::Atanh),
75 | Self::Asinh => Value::BuiltInFunction(Self::Sinh),
76 | Self::Acosh => Value::BuiltInFunction(Self::Cosh),
77 | Self::Atanh => Value::BuiltInFunction(Self::Tanh),
78 | _ => return Err(FendError::UnableToInvertFunction(self.as_str())),
79 | })
80 | }
81 |
82 | pub(crate) const fn as_str(self) -> &'static str {
83 | match self {
84 | Self::Approximately => "approximately",
85 | Self::Abs => "abs",
86 | Self::Sin => "sin",
87 | Self::Cos => "cos",
88 | Self::Tan => "tan",
89 | Self::Asin => "asin",
90 | Self::Acos => "acos",
91 | Self::Atan => "atan",
92 | Self::Sinh => "sinh",
93 | Self::Cosh => "cosh",
94 | Self::Tanh => "tanh",
95 | Self::Asinh => "asinh",
96 | Self::Acosh => "acosh",
97 | Self::Atanh => "atanh",
98 | Self::Ln => "ln",
99 | Self::Log2 => "log2",
100 | Self::Log10 => "log10",
101 | Self::Base => "base",
102 | Self::Sample => "sample",
103 | Self::Mean => "mean",
104 | Self::Not => "not",
105 | Self::Conjugate => "conjugate",
106 | Self::Real => "real",
107 | Self::Imag => "imag",
108 | Self::Arg => "arg",
109 | Self::Floor => "floor",
110 | Self::Ceil => "ceil",
111 | Self::Round => "round",
112 | Self::Fibonacci => "fibonacci",
113 | Self::Print => "print",
114 | Self::Println => "println",
115 | }
116 | }
117 |
118 | fn try_from_str(s: &str) -> FResult {
119 | Ok(match s {
120 | "approximately" => Self::Approximately,
121 | "abs" => Self::Abs,
122 | "sin" => Self::Sin,
123 | "cos" => Self::Cos,
124 | "tan" => Self::Tan,
125 | "asin" => Self::Asin,
126 | "acos" => Self::Acos,
127 | "atan" => Self::Atan,
128 | "sinh" => Self::Sinh,
129 | "cosh" => Self::Cosh,
130 | "tanh" => Self::Tanh,
131 | "asinh" => Self::Asinh,
132 | "acosh" => Self::Acosh,
133 | "atanh" => Self::Atanh,
134 | "ln" => Self::Ln,
135 | "log2" => Self::Log2,
136 | "log10" => Self::Log10,
137 | "base" => Self::Base,
138 | "sample" => Self::Sample,
139 | "not" => Self::Not,
140 | "conjugate" => Self::Conjugate,
141 | "real" => Self::Real,
142 | "imag" => Self::Imag,
143 | "fibonacci" => Self::Fibonacci,
144 | "print" => Self::Print,
145 | "prinln" => Self::Println,
146 | _ => {
147 | return Err(FendError::DeserializationError(
148 | "built-in function type is out of range",
149 | ));
150 | }
151 | })
152 | }
153 |
154 | pub(crate) fn serialize(self, write: &mut impl io::Write) -> FResult<()> {
155 | self.as_str().serialize(write)
156 | }
157 |
158 | pub(crate) fn deserialize(read: &mut impl io::Read) -> FResult {
159 | Self::try_from_str(String::deserialize(read)?.as_str())
160 | }
161 | }
162 |
163 | impl fmt::Display for BuiltInFunction {
164 | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
165 | write!(f, "{}", self.as_str())
166 | }
167 | }
168 |
--------------------------------------------------------------------------------
/documentation/index.md:
--------------------------------------------------------------------------------
1 | # Welcome to the fend Manual!
2 |
3 | fend is an arbitrary-precision unit-aware calculator. If you haven't already, head to [https://printfn.github.io/fend](https://printfn.github.io/fend) to use the online version, or click [here](#installation) to learn how to install fend on your computer.
4 |
5 | You can check your version of fend at any time by typing `version`. If you are using the command-line interface, you can also run `fend --version`.
6 |
7 | # Table of Contents
8 | 1. [Installation](#installation)
9 | 1. [Windows](#windows)
10 | 1. [macOS](#macos)
11 | 1. [Arch Linux](#arch-linux)
12 | 1. [Void Linux](#void-linux)
13 | 1. [AOSC OS](#aosc-os)
14 | 1. [NixOS / Nix package manager](#nixos-nix-package-manager)
15 | 1. [Pre-built binaries](#pre-built-binaries)
16 | 1. [Install via crates.io](#install-via-crates-io)
17 | 1. [Numbers](#numbers)
18 | 1. [Arithmetic](#arithmetic)
19 | 1. [Units](#units)
20 | 1. [Temperature](#temperature)
21 | 1. [Dice](#dice)
22 | 1. [Functions and constants](#functions-and-constants)
23 | 1. [Number formats](#number-formats)
24 | 1. [Strings](#strings)
25 | 1. [Debug Representation](#debug-representation)
26 | 1. [Configuration](#configuration)
27 | 1. [Scripting](#scripting)
28 | 1. [Changelog](#changelog)
29 |
30 | ## Installation
31 |
32 | You can use fend without installing by visiting [https://printfn.github.io/fend](https://printfn.github.io/fend).
33 |
34 | If you want to install the fend command-line application, you have the following options:
35 |
36 | ### Windows
37 |
38 | On Windows, you can install fend with a standard Windows installer package (MSI),
39 | which you can download [here](https://github.com/printfn/fend/releases/latest).
40 |
41 | Alternatively you can install fend via
42 | [`winget`](https://docs.microsoft.com/en-us/windows/package-manager/winget/):
43 |
44 | ```ps1
45 | winget install fend
46 | ```
47 |
48 | Or using [Chocolatey](https://chocolatey.org/):
49 |
50 | ```ps1
51 | choco install fend
52 | ```
53 |
54 | ### macOS
55 |
56 | fend is available on [Homebrew](https://brew.sh):
57 |
58 | ```bash
59 | brew install fend
60 | ```
61 |
62 | fend can also be installed via [MacPorts](https://www.macports.org):
63 |
64 | ```bash
65 | sudo port install fend
66 | ```
67 |
68 | ### Arch Linux
69 |
70 | fend is available on the [AUR](https://aur.archlinux.org/packages/fend-bin/):
71 |
72 | ```bash
73 | yay -Syu aur/fend-bin
74 | ```
75 |
76 | You can also [build it from source](https://aur.archlinux.org/packages/fend/) with:
77 |
78 | ```bash
79 | yay -Syu aur/fend
80 | ```
81 |
82 | ### Void Linux
83 |
84 | fend is available in the official Void Linux package repository:
85 |
86 | ```bash
87 | xbps-install fend
88 | ```
89 |
90 | ### AOSC OS
91 |
92 | fend is available in the official AOSC OS package repository:
93 |
94 | ```bash
95 | oma install fend
96 | ```
97 |
98 | ### PKGX
99 |
100 | fend is available on [pkgx](https://pkgx.dev/pkgs/printfn.github.io/fend/):
101 |
102 | ```bash
103 | pkgx fend
104 | ```
105 |
106 | ### NixOS / Nix package manager
107 |
108 | fend is available in [nixpkgs](https://github.com/NixOS/nixpkgs/blob/master/pkgs/tools/misc/fend/default.nix):
109 |
110 | ```bash
111 | nix-env -iA nixpkgs.fend
112 | ```
113 |
114 | Or using `nix-shell`:
115 |
116 | ```bash
117 | nix-shell -p fend
118 | ```
119 |
120 | ### Pre-built binaries
121 |
122 | You can download the latest stable binaries for Windows, macOS and Linux [here](https://github.com/printfn/fend/releases/latest).
123 |
124 | Binaries are available for:
125 |
126 | * Linux (aarch64)
127 | * Linux (x86-64)
128 | * macOS (64-bit Intel)
129 | * macOS (Apple Silicon)
130 | * Windows (64-bit)
131 |
132 | ### Install via crates.io
133 |
134 | If you have an up-to-date installation of Rust, you can install `fend` like so:
135 |
136 | ```bash
137 | rustup update
138 | cargo install fend
139 | ```
140 |
141 | If you already have an older version of fend installed, this will automatically update to the latest version.
142 |
143 | Once you have installed fend, you can launch an interactive REPL by typing `fend` in your terminal:
144 |
145 | ```
146 | $ fend
147 | > 1 ft to cm
148 | 30.48 cm
149 | >
150 | ```
151 |
152 | ```{.include format=commonmark+attributes+pipe_tables}
153 | chapters/expressions.md
154 | ```
155 |
156 | ## Configuration
157 |
158 | ```{.include format=commonmark+attributes+pipe_tables}
159 | chapters/configuration.md
160 | ```
161 |
162 | ```{.toml include="../cli/src/default_config.toml"}
163 | ```
164 |
165 | ## Scripting
166 |
167 | ```{.include format=commonmark+attributes+pipe_tables}
168 | chapters/scripting.md
169 | ```
170 |
171 | ```{.include format=commonmark+attributes+pipe_tables}
172 | ../CHANGELOG.md
173 | ```
174 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # [fend](https://printfn.github.io/fend)
2 |
3 | [](https://github.com/printfn/fend)
4 | [](https://codecov.io/gh/printfn/fend)
5 | [](https://crates.io/crates/fend)
6 | [](https://crates.io/crates/fend)
7 |
8 | 
9 |
10 | [fend](https://printfn.github.io/fend) is an arbitrary-precision unit-aware calculator.
11 |
12 | Unique features:
13 |
14 | * Arbitrary-precision arithmetic using rational numbers
15 | * Full support for complex numbers
16 | * D&D-style dice rolls
17 | * Variables
18 | * Binary, octal, hexadecimal and all other bases between 2 and 36
19 | * Keep track of units, with support for SI, US and UK customary and many historical units
20 | * Emacs-style CLI shortcuts
21 | * Trigonometric functions
22 | * Lambda calculus
23 |
24 | See the [manual](https://printfn.github.io/fend/documentation/) for more information.
25 |
26 | ## [Web Interface](https://printfn.github.io/fend)
27 |
28 | fend is available on the web at [printfn.github.io/fend](https://printfn.github.io/fend).
29 |
30 | ## Installation
31 |
32 | The easiest way to install fend locally is via your package manager:
33 |
34 | | Package Manager | Command |
35 | | ----------------------- | -------------------------- |
36 | | Homebrew | `brew install fend` |
37 | | MacPorts | `sudo port install fend` |
38 | | AUR (Arch Linux) | `yay -S aur/fend-bin` |
39 | | AOSC OS | `oma install fend` |
40 | | Xbps (Void Linux) | `xbps-install fend` |
41 | | Nix | Add `nixpkgs.fend` to your config, or install ephemerally using `nix-shell -p fend`. |
42 | | Cargo | `cargo install fend` |
43 | | Windows Package Manager | `winget install fend` |
44 | | Chocolatey | `choco install fend` |
45 | | Scoop | `scoop install fend` |
46 | | Pkgx | `pkgx fend` |
47 |
48 | Alternatively, you can manually download the latest stable binaries
49 | [here](https://github.com/printfn/fend/releases/latest).
50 |
51 | Once fend is installed, run `fend` to start a REPL session:
52 |
53 | ```
54 | $ fend
55 | > 1 ft to cm
56 | 30.48 cm
57 | >
58 | ```
59 |
60 | ### Packages
61 |
62 | * [Homebrew](https://github.com/Homebrew/homebrew-core/blob/HEAD/Formula/f/fend.rb)
63 | * [MacPorts](https://ports.macports.org/port/fend/)
64 | * [AUR (built from source)](https://aur.archlinux.org/packages/fend/)
65 | * [AUR (pre-built binary)](https://aur.archlinux.org/packages/fend-bin/)
66 | * [xbps](https://github.com/void-linux/void-packages/tree/master/srcpkgs/fend)
67 | * [AOSC OS](https://github.com/AOSC-Dev/aosc-os-abbs/tree/stable/app-utils/fend)
68 | * [nixpkgs](https://github.com/NixOS/nixpkgs/blob/master/pkgs/tools/misc/fend/default.nix)
69 | * [Windows Package Manager](https://github.com/microsoft/winget-pkgs/tree/master/manifests/p/printfn/fend)
70 | * [Chocolatey](https://community.chocolatey.org/packages/fend)
71 | * [NPM fend-wasm package](https://www.npmjs.com/package/fend-wasm)
72 | * [NPM fend-wasm-web package](https://www.npmjs.com/package/fend-wasm-web)
73 | * [NPM fend-wasm-nodejs package](https://www.npmjs.com/package/fend-wasm-nodejs)
74 | * [Telegram Bot](https://t.me/fend_calc_bot)
75 | * [Pkgx](https://pkgx.dev/pkgs/printfn.github.io/fend/)
76 |
77 | ## [Manual](https://printfn.github.io/fend/documentation/)
78 |
79 | You can find the fend manual [here](https://printfn.github.io/fend/documentation/).
80 |
81 | ## Examples
82 |
83 | ```
84 | > 5'10" to cm
85 | 177.8 cm
86 | ```
87 |
88 | ```
89 | > cos (pi/4) + i * (sin (pi/4))
90 | approx. 0.7071067811 + 0.7071067811i
91 | ```
92 |
93 | ```
94 | > 0b1001 + 3
95 | 0b1100
96 | ```
97 |
98 | ```
99 | > 0xffff to decimal
100 | 65535
101 | ```
102 |
103 | ```
104 | > 100 C to F
105 | 210 °F
106 | ```
107 |
108 | ```
109 | > temperature = 30 °C
110 | 30 °C
111 | > temperature to °F
112 | 86 °F
113 | ```
114 |
115 | ```
116 | > roll d20
117 | 8
118 | > roll 4d6
119 | 17
120 | ```
121 |
122 | ## Projects using fend
123 |
124 | These are some projects making use of fend:
125 |
126 | * [MicroPad](https://getmicropad.com)
127 | * [Fendesk](https://github.com/SekoiaTree/fendesk)
128 | * [metasearch2](https://github.com/mat-1/metasearch2)
129 | * [FendApp](https://github.com/JadedBlueEyes/fendapp)
130 | * [Asleh](https://github.com/jossephus/asleh)
131 |
132 | Feel free to make a pull request to add your own!
133 |
134 | ## License
135 |
136 | fend is available under the MIT license. See [LICENSE.md](LICENSE.md)
137 | for more information.
138 |
--------------------------------------------------------------------------------
/telegram-bot/index.ts:
--------------------------------------------------------------------------------
1 | import { evaluateFendWithTimeout, substituteInlineFendExpressions } from 'fend-wasm';
2 |
3 | const two = evaluateFendWithTimeout('1+1', 500);
4 | if (two !== '2') {
5 | throw new Error(`could not execute webassembly: got '${two}' instead of '2'`);
6 | }
7 |
8 | const TELEGRAM_BOT_API_TOKEN = process.env.TELEGRAM_BOT_API_TOKEN;
9 |
10 | /*
11 | Setting a webhook:
12 | TELEGRAM_BOT_API_TOKEN="..."
13 | LAMBDA_URL="..."
14 | curl "https://api.telegram.org/bot${TELEGRAM_BOT_API_TOKEN}/setWebhook" --form-string "url=${LAMBDA_URL}"
15 | */
16 |
17 | type Message = {
18 | message_id: number;
19 | text: string;
20 | chat: {
21 | type: string;
22 | id: number;
23 | };
24 | };
25 |
26 | type Update = {
27 | update_id: number;
28 | message?: Message;
29 | edited_message?: Message;
30 | inline_query?: {
31 | query: string;
32 | id: number;
33 | };
34 | };
35 |
36 | function processInput(input: string, chatType: string) {
37 | if (input == '/start' || input == '/help') {
38 | return "fend is an arbitrary-precision unit-aware calculator.\n\nYou can send maths questions like '1+1', 'sin(pi)' or 'sqrt(5)'. In group chats, you'll need to enclose your input in [[double square brackets]] like this: [[1+1]].";
39 | }
40 |
41 | if (chatType == 'private' || chatType == 'inline') {
42 | return evaluateFendWithTimeout(input, 500);
43 | } else if (chatType == 'group' || chatType == 'supergroup' || chatType == 'channel') {
44 | let response = JSON.parse(substituteInlineFendExpressions(input, 500));
45 | let result = '';
46 | let foundCalculation = false;
47 | for (let part of response) {
48 | if (part.type == 'fend_output' || part.type == 'fend_error') {
49 | foundCalculation = true;
50 | }
51 | result += part.contents;
52 | }
53 | if (!foundCalculation) {
54 | return null;
55 | }
56 | return result;
57 | }
58 | };
59 |
60 | async function processMessage(message: Message) {
61 | let text = message.text;
62 | let result = processInput(text, message.chat.type);
63 | if (result != null && result != '') {
64 | await postJSON('sendChatAction', {
65 | chat_id: message.chat.id,
66 | action: 'typing',
67 | });
68 | await postJSON('sendMessage', {
69 | chat_id: message.chat.id,
70 | text: result,
71 | disable_web_page_preview: true,
72 | disable_notification: true,
73 | reply_parameters: { message_id: message.message_id }
74 | });
75 | }
76 | };
77 |
78 | type InlineQueryResultArticle = {
79 | type: 'article';
80 | id: string;
81 | title: string;
82 | input_message_content: {
83 | message_text: string;
84 | };
85 | };
86 | type InlineQueryResult = InlineQueryResultArticle;
87 |
88 | async function processUpdate(update: Update) {
89 | console.log('Update: ' + JSON.stringify(update));
90 | if (update.message && update.message.text) {
91 | await processMessage(update.message);
92 | } else if (update.edited_message && update.edited_message.text) {
93 | await processMessage(update.edited_message);
94 | } else if (update.inline_query) {
95 | let input = update.inline_query.query;
96 | let result = processInput(input, 'inline');
97 | let results: InlineQueryResult[] = [];
98 | if (result != null && result != '') {
99 | results.push({
100 | type: 'article',
101 | title: result,
102 | id: '1',
103 | input_message_content: {
104 | message_text: result,
105 | },
106 | });
107 | }
108 | await postJSON('answerInlineQuery', {
109 | inline_query_id: update.inline_query.id,
110 | results,
111 | });
112 | }
113 | };
114 |
115 | async function pollUpdates() {
116 | try {
117 | var highestOffet = 441392434;
118 | while (true) {
119 | console.log('Polling getUpdates (30s)...')
120 | let updates: Update[] = await postJSON('getUpdates', {
121 | timeout: 30,
122 | offset: highestOffet + 1,
123 | });
124 | for (let update of updates) {
125 | highestOffet = Math.max(highestOffet, update.update_id);
126 | await processUpdate(update);
127 | }
128 | }
129 | } catch (error) {
130 | console.log(error);
131 | }
132 | };
133 |
134 | async function postJSON(endpoint: string, body: unknown) {
135 | let response = await fetch(`https://api.telegram.org/bot${TELEGRAM_BOT_API_TOKEN}/${endpoint}`, {
136 | method: 'POST',
137 | headers: {
138 | 'Content-Type': 'application/json ; charset=UTF-8',
139 | },
140 | body: JSON.stringify(body),
141 | });
142 | let responseObject = await response.json();
143 | if (responseObject.ok) {
144 | return responseObject.result;
145 | } else {
146 | const msg = 'Error: ' + JSON.stringify(responseObject);
147 | console.log(msg);
148 | throw new Error(msg);
149 | }
150 | }
151 |
152 | export async function handler(event: { body: string; }) {
153 | let update = JSON.parse(event.body);
154 | try {
155 | await processUpdate(update);
156 | } catch (error) {
157 | console.log(error);
158 | }
159 | return { statusCode: 200, body: 'ok' };
160 | }
161 |
162 | if (!process.env.AWS_REGION) {
163 | // running locally
164 | pollUpdates();
165 | }
166 |
--------------------------------------------------------------------------------
/cli/src/args.rs:
--------------------------------------------------------------------------------
1 | use crate::Error;
2 | use std::{env, fs};
3 |
4 | /// Which action should be executed?
5 | ///
6 | /// This implements [`FromIterator`] and can be `collect`ed from
7 | /// the [`env::args()`]`.skip(1)` iterator.
8 | #[derive(Debug, PartialEq, Eq, Clone)]
9 | pub enum Action {
10 | /// Print the help message (without quitting explanation).
11 | Help,
12 | /// Print the current version.
13 | Version,
14 | /// Enter the REPL.
15 | Repl,
16 | /// Evaluate the arguments.
17 | Eval { exprs: Vec },
18 | /// Show the default config file
19 | DefaultConfig,
20 | }
21 |
22 | impl Action {
23 | pub fn from_args(args: &[String]) -> Result {
24 | let mut print_help = false;
25 | let mut print_version = false;
26 | let mut print_default_config = false;
27 | let mut before_double_dash = true;
28 | let mut exprs = vec![];
29 | let mut expr = String::new();
30 | let mut idx = 0;
31 |
32 | while idx < args.len() {
33 | let arg = &args[idx];
34 | match (before_double_dash, arg.as_str()) {
35 | (true, "help" | "--help" | "-h") => print_help = true,
36 | // NOTE: 'version' is already handled by fend itself
37 | (true, "--version" | "-v" | "-V") => print_version = true,
38 | (true, "--default-config" | "--print-default-config") => {
39 | print_default_config = true;
40 | }
41 | (true, "-f" | "--file") => {
42 | idx += 1;
43 | let filename = args.get(idx).ok_or("expected a filename")?;
44 | let contents = fs::read_to_string(filename)?;
45 | if !expr.is_empty() {
46 | exprs.push(expr);
47 | expr = String::new();
48 | }
49 | exprs.push(contents);
50 | }
51 | (true, "-e" | "--eval") => {
52 | idx += 1;
53 | let e = args.get(idx).ok_or("expected an expression")?;
54 | if !expr.is_empty() {
55 | exprs.push(expr);
56 | expr = String::new();
57 | }
58 | exprs.push(e.clone());
59 | }
60 | (true, "--") => before_double_dash = false,
61 | (_, arg) => {
62 | let mut read_file = false;
63 | if before_double_dash && let Ok(contents) = fs::read_to_string(arg) {
64 | if !expr.is_empty() {
65 | exprs.push(expr);
66 | expr = String::new();
67 | }
68 | exprs.push(contents);
69 | read_file = true;
70 | }
71 | if !read_file && !arg.trim().is_empty() {
72 | if !expr.is_empty() {
73 | expr.push(' ');
74 | }
75 | expr.push_str(arg);
76 | }
77 | }
78 | }
79 | idx += 1;
80 | }
81 |
82 | Ok(if print_help {
83 | // If any argument is shouting for help, print help!
84 | Self::Help
85 | } else if print_version {
86 | // If no help is requested, but the version, print the version
87 | Self::Version
88 | } else if print_default_config {
89 | Self::DefaultConfig
90 | } else if exprs.is_empty() && expr.is_empty() {
91 | Self::Repl
92 | } else {
93 | // If neither help nor version is requested, evaluate the arguments
94 | if !expr.is_empty() {
95 | exprs.push(expr);
96 | }
97 | Self::Eval { exprs }
98 | })
99 | }
100 |
101 | pub fn get() -> Result {
102 | let args: Vec<_> = env::args().skip(1).collect();
103 | Self::from_args(args.as_slice())
104 | }
105 | }
106 |
107 | #[cfg(test)]
108 | mod tests {
109 | use super::Action;
110 |
111 | macro_rules! action {
112 | ($( $arg:literal ),*) => {
113 | Action::from_args(&[ $( $arg.to_string() ),* ]).unwrap()
114 | }
115 | }
116 |
117 | fn eval(expr: &str) -> Action {
118 | Action::Eval {
119 | exprs: vec![expr.to_string()],
120 | }
121 | }
122 |
123 | #[test]
124 | fn help_argument_works() {
125 | // The --help argument wins!
126 | assert_eq!(Action::Help, action!["-h"]);
127 | assert_eq!(Action::Help, action!["--help"]);
128 | assert_eq!(Action::Help, action!["help"]);
129 | assert_eq!(Action::Help, action!["1", "+ 1", "help"]);
130 | assert_eq!(Action::Help, action!["--version", "1!", "--help"]);
131 | assert_eq!(Action::Help, action!["-h", "some", "arguments"]);
132 | }
133 |
134 | #[test]
135 | fn version_argument_works() {
136 | // --version wins over normal arguments
137 | assert_eq!(Action::Version, action!["-v"]);
138 | assert_eq!(Action::Version, action!["-V"]);
139 | assert_eq!(Action::Version, action!["--version"]);
140 | // `version` is handled by the eval
141 | assert_eq!(eval("version"), action!["version"]);
142 | assert_eq!(Action::Version, action!["before", "-v", "and", "after"]);
143 | assert_eq!(Action::Version, action!["-V", "here"]);
144 | assert_eq!(Action::Version, action!["--version", "-v", "+1", "version"]);
145 | }
146 |
147 | #[test]
148 | fn normal_arguments_are_collected_correctly() {
149 | assert_eq!(eval("1 + 1"), action!["1", "+", "1"]);
150 | assert_eq!(eval("1 + 1"), action!["1 + 1"]);
151 | assert_eq!(eval("1 '+' 1 "), action!["1 '+' 1 "]);
152 | }
153 |
154 | #[test]
155 | fn empty_arguments() {
156 | assert_eq!(Action::Repl, action![]);
157 | assert_eq!(Action::Repl, action![""]);
158 | assert_eq!(Action::Repl, action!["", ""]);
159 | assert_eq!(Action::Repl, action!["\t", " "]);
160 | assert_eq!(eval("1"), action!["\t", " ", "1"]);
161 | }
162 | }
163 |
--------------------------------------------------------------------------------
/core/src/inline_substitutions.rs:
--------------------------------------------------------------------------------
1 | use crate::{Context, Interrupt};
2 |
3 | pub enum InlineFendResultComponent {
4 | Unprocessed(String),
5 | FendOutput(String),
6 | FendError(String),
7 | }
8 |
9 | impl InlineFendResultComponent {
10 | pub fn get_contents(&self) -> &str {
11 | match self {
12 | Self::Unprocessed(s) | Self::FendOutput(s) | Self::FendError(s) => s.as_str(),
13 | }
14 | }
15 |
16 | fn to_json(&self, out: &mut String) {
17 | out.push_str("{\"type\": ");
18 | match self {
19 | Self::Unprocessed(_) => out.push_str("\"unprocessed\""),
20 | Self::FendOutput(_) => out.push_str("\"fend_output\""),
21 | Self::FendError(_) => out.push_str("\"fend_error\""),
22 | }
23 | out.push_str(", \"contents\": \"");
24 | crate::json::escape_string(self.get_contents(), out);
25 | out.push_str("\"}");
26 | }
27 | }
28 |
29 | pub struct InlineFendResult {
30 | parts: Vec,
31 | }
32 |
33 | impl InlineFendResult {
34 | pub fn get_parts(&self) -> &[InlineFendResultComponent] {
35 | self.parts.as_slice()
36 | }
37 |
38 | pub fn to_json(&self) -> String {
39 | let mut res = String::new();
40 | res.push('[');
41 | for (i, part) in self.get_parts().iter().enumerate() {
42 | if i > 0 {
43 | res.push(',');
44 | }
45 | part.to_json(&mut res);
46 | }
47 | res.push(']');
48 | res
49 | }
50 | }
51 |
52 | /// Evaluates fend syntax embedded in Markdown or similarly-formatted strings.
53 | ///
54 | /// Any calculations in `[[` and `]]` are evaluated and replaced with their
55 | /// results.
56 | ///
57 | /// This function implements a subset of markdown parsing, ensuring that
58 | /// backtick-escaped notation will not be evaluated.
59 | ///
60 | /// # Examples
61 | /// ```
62 | /// let mut ctx = fend_core::Context::new();
63 | /// struct NeverInterrupt;
64 | /// impl fend_core::Interrupt for NeverInterrupt {
65 | /// fn should_interrupt(&self) -> bool {
66 | /// false
67 | /// }
68 | /// }
69 | /// let int = NeverInterrupt;
70 | ///
71 | /// let result = fend_core::substitute_inline_fend_expressions(
72 | /// "The answer is [[1+1]].", &mut ctx, &int);
73 | ///
74 | /// assert_eq!(result.get_parts().len(), 3);
75 | /// assert_eq!(result.get_parts()[0].get_contents(), "The answer is ");
76 | /// assert_eq!(result.get_parts()[1].get_contents(), "2");
77 | /// assert_eq!(result.get_parts()[2].get_contents(), ".");
78 | /// ```
79 | pub fn substitute_inline_fend_expressions(
80 | input: &str,
81 | context: &mut Context,
82 | int: &impl Interrupt,
83 | ) -> InlineFendResult {
84 | let mut result = InlineFendResult { parts: vec![] };
85 | let mut current_component = String::new();
86 | let mut inside_fend_expr = false;
87 | let mut inside_backticks = false;
88 | for ch in input.chars() {
89 | current_component.push(ch);
90 | if ch == '`' {
91 | inside_backticks = !inside_backticks;
92 | }
93 | if !inside_fend_expr && !inside_backticks && current_component.ends_with("[[") {
94 | current_component.truncate(current_component.len() - 2);
95 | result
96 | .parts
97 | .push(InlineFendResultComponent::Unprocessed(current_component));
98 | current_component = String::new();
99 | inside_fend_expr = true;
100 | } else if inside_fend_expr && !inside_backticks && current_component.ends_with("]]") {
101 | current_component.truncate(current_component.len() - 2);
102 | match crate::evaluate_with_interrupt(¤t_component, context, int) {
103 | Ok(res) => result.parts.push(InlineFendResultComponent::FendOutput(
104 | res.get_main_result().to_string(),
105 | )),
106 | Err(msg) => result.parts.push(InlineFendResultComponent::FendError(msg)),
107 | }
108 | current_component = String::new();
109 | inside_fend_expr = false;
110 | }
111 | }
112 | if inside_fend_expr {
113 | current_component.insert_str(0, "[[");
114 | }
115 | result
116 | .parts
117 | .push(InlineFendResultComponent::Unprocessed(current_component));
118 | result
119 | }
120 |
121 | #[cfg(test)]
122 | mod tests {
123 | use super::*;
124 |
125 | #[track_caller]
126 | fn simple_test(input: &str, expected: &str) {
127 | let mut ctx = crate::Context::new();
128 | let int = crate::interrupt::Never;
129 | let mut result = String::new();
130 | for part in substitute_inline_fend_expressions(input, &mut ctx, &int).parts {
131 | result.push_str(part.get_contents());
132 | }
133 | if expected == "=" {
134 | assert_eq!(result, input);
135 | } else {
136 | assert_eq!(result, expected);
137 | }
138 | }
139 |
140 | #[test]
141 | fn trivial_tests() {
142 | simple_test("", "");
143 | simple_test("a", "a");
144 | }
145 |
146 | #[test]
147 | fn longer_unprocessed_test() {
148 | simple_test(
149 | "auidhwiaudb \n\naiusdfba!!! `code`\n\n\n```rust\nfn foo() {}\n```",
150 | "=",
151 | );
152 | }
153 |
154 | #[test]
155 | fn simple_fend_expr() {
156 | simple_test("[[1+1]]", "2");
157 | simple_test("[[2+2]][[6*6]]", "436");
158 | simple_test("[[a = 5; 3a]]\n[[6a]]", "15\n30");
159 | simple_test("[[2+\n\r\n2\n\n\r\n]][[1]]", "41");
160 | simple_test(
161 | "The answer is [[\n # let's work out 40 + 2:\n 40+2\n]].",
162 | "The answer is 42.",
163 | );
164 | simple_test("[[]]", "");
165 | simple_test("[[", "[[");
166 | simple_test("]]", "]]");
167 | }
168 |
169 | #[test]
170 | fn escaped_exprs() {
171 | simple_test("`[[1+1]]` = [[1+1]]", "`[[1+1]]` = 2");
172 | simple_test("`[[1+1]]` = [[1+1\n\n]]", "`[[1+1]]` = 2");
173 | simple_test("```\n[[2+2]]\n```", "=");
174 | }
175 | }
176 |
--------------------------------------------------------------------------------
/cli/src/file_paths.rs:
--------------------------------------------------------------------------------
1 | use std::{env, error, ffi, fmt, fs, io, path};
2 |
3 | #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
4 | pub enum DirMode {
5 | Create,
6 | DontCreate,
7 | }
8 |
9 | #[derive(Debug)]
10 | pub struct HomeDirError;
11 |
12 | impl fmt::Display for HomeDirError {
13 | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14 | write!(f, "unable to find home directory")
15 | }
16 | }
17 |
18 | impl error::Error for HomeDirError {}
19 |
20 | impl From for io::Error {
21 | fn from(e: HomeDirError) -> Self {
22 | io::Error::other(e)
23 | }
24 | }
25 |
26 | fn get_home_dir() -> Result {
27 | #[allow(deprecated)]
28 | let Some(home_dir) = env::home_dir() else {
29 | return Err(HomeDirError);
30 | };
31 | Ok(home_dir)
32 | }
33 |
34 | fn get_config_dir() -> Result {
35 | // first try $FEND_CONFIG_DIR
36 | if let Some(env_var_config_dir) = env::var_os("FEND_CONFIG_DIR") {
37 | return Ok(path::PathBuf::from(env_var_config_dir));
38 | }
39 |
40 | // otherwise try $XDG_CONFIG_HOME/fend/
41 | if let Some(env_var_xdg_config_dir) = env::var_os("XDG_CONFIG_HOME") {
42 | let mut res = path::PathBuf::from(env_var_xdg_config_dir);
43 | res.push("fend");
44 | return Ok(res);
45 | }
46 |
47 | // otherwise use $HOME/.config/fend/
48 | let mut res = get_home_dir()?;
49 | res.push(".config");
50 | res.push("fend");
51 | Ok(res)
52 | }
53 |
54 | pub fn get_config_file_location() -> Result {
55 | let mut config_path = get_config_dir()?;
56 | config_path.push("config.toml");
57 | Ok(config_path)
58 | }
59 |
60 | pub fn get_state_dir(mode: DirMode) -> Result {
61 | // first try $FEND_STATE_DIR
62 | if let Some(env_var_history_dir) = env::var_os("FEND_STATE_DIR") {
63 | let res = path::PathBuf::from(env_var_history_dir);
64 | if mode == DirMode::Create {
65 | fs::create_dir_all(&res)?;
66 | }
67 | return Ok(res);
68 | }
69 |
70 | // otherwise try $XDG_STATE_HOME/fend/
71 | if let Some(env_var_xdg_state_dir) = env::var_os("XDG_STATE_HOME") {
72 | let mut res = path::PathBuf::from(env_var_xdg_state_dir);
73 | if mode == DirMode::Create {
74 | fs::create_dir_all(&res)?;
75 | mark_dir_as_hidden(&res);
76 | }
77 | res.push("fend");
78 | if mode == DirMode::Create {
79 | fs::create_dir_all(&res)?;
80 | }
81 | return Ok(res);
82 | }
83 |
84 | // otherwise use $HOME/.local/state/fend/
85 | let mut res = get_home_dir()?;
86 | res.push(".local");
87 | if mode == DirMode::Create {
88 | fs::create_dir_all(&res)?;
89 | mark_dir_as_hidden(&res);
90 | }
91 | res.push("state");
92 | res.push("fend");
93 | if mode == DirMode::Create {
94 | fs::create_dir_all(&res)?;
95 | }
96 | Ok(res)
97 | }
98 |
99 | pub fn get_history_file_location(mode: DirMode) -> Result {
100 | let mut history_path = get_state_dir(mode)?;
101 | history_path.push("history");
102 | Ok(history_path)
103 | }
104 |
105 | pub fn get_cache_dir(mode: DirMode) -> Result {
106 | // first try $FEND_CACHE_DIR
107 | if let Some(env_var_cache_dir) = env::var_os("FEND_CACHE_DIR") {
108 | let res = path::PathBuf::from(env_var_cache_dir);
109 | if mode == DirMode::Create {
110 | fs::create_dir_all(&res)?;
111 | }
112 | return Ok(res);
113 | }
114 |
115 | // otherwise try $XDG_CACHE_HOME/fend/
116 | if let Some(env_var_xdg_cache_dir) = env::var_os("XDG_CACHE_HOME") {
117 | let mut res = path::PathBuf::from(env_var_xdg_cache_dir);
118 | if mode == DirMode::Create {
119 | fs::create_dir_all(&res)?;
120 | mark_dir_as_hidden(&res);
121 | }
122 | res.push("fend");
123 | if mode == DirMode::Create {
124 | fs::create_dir_all(&res)?;
125 | }
126 | return Ok(res);
127 | }
128 |
129 | // otherwise use $HOME/.cache/fend/
130 | let mut res = get_home_dir()?;
131 | res.push(".cache");
132 | if mode == DirMode::Create {
133 | fs::create_dir_all(&res)?;
134 | mark_dir_as_hidden(&res);
135 | }
136 | res.push("fend");
137 | if mode == DirMode::Create {
138 | fs::create_dir_all(&res)?;
139 | }
140 | Ok(res)
141 | }
142 |
143 | fn mark_dir_as_hidden(path: &path::Path) {
144 | let Ok(metadata) = fs::metadata(path) else {
145 | return;
146 | };
147 |
148 | if !metadata.is_dir() {
149 | return;
150 | }
151 |
152 | let path = {
153 | let mut p = ffi::OsString::from("\\\\?\\");
154 | p.push(path.as_os_str());
155 | p
156 | };
157 |
158 | match mark_dir_as_hidden_impl(path.as_os_str()) {
159 | Ok(()) => (),
160 | Err(e) => {
161 | eprintln!("failed to set cache directory as hidden: error code: {e}");
162 | }
163 | }
164 | }
165 |
166 | #[cfg(windows)]
167 | #[allow(unsafe_code)]
168 | fn mark_dir_as_hidden_impl(path: &ffi::OsStr) -> Result<(), u32> {
169 | use std::os::windows::ffi::OsStrExt;
170 | use windows_sys::Win32::{
171 | Foundation::GetLastError,
172 | Storage::FileSystem::{FILE_ATTRIBUTE_HIDDEN, SetFileAttributesW},
173 | };
174 |
175 | let path = path.encode_wide().chain(Some(0)).collect::>();
176 |
177 | unsafe {
178 | // https://learn.microsoft.com/en-us/windows/win32/api/fileapi/nf-fileapi-setfileattributesw
179 | let return_code = SetFileAttributesW(path.as_slice().as_ptr(), FILE_ATTRIBUTE_HIDDEN);
180 | if return_code == 0 {
181 | return Err(GetLastError());
182 | }
183 | }
184 | Ok(())
185 | }
186 |
187 | #[cfg(not(windows))]
188 | #[allow(clippy::unnecessary_wraps)]
189 | fn mark_dir_as_hidden_impl(_path: &ffi::OsStr) -> Result<(), u32> {
190 | Ok(())
191 | }
192 |
--------------------------------------------------------------------------------
/cli/src/custom_units.rs:
--------------------------------------------------------------------------------
1 | use std::fmt;
2 |
3 | #[derive(Clone, PartialEq, Eq, Debug, Hash, Default)]
4 | pub enum CustomUnitAttribute {
5 | #[default]
6 | None,
7 | AllowLongPrefix,
8 | AllowShortPrefix,
9 | IsLongPrefix,
10 | Alias,
11 | }
12 |
13 | struct CustomUnitAttributeVisitor;
14 |
15 | impl serde::de::Visitor<'_> for CustomUnitAttributeVisitor {
16 | type Value = CustomUnitAttribute;
17 |
18 | fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
19 | formatter.write_str(
20 | "`none`, `allow-long-prefix`, `allow-short-prefix`, `is-long-prefix` or `alias`",
21 | )
22 | }
23 |
24 | fn visit_str(self, v: &str) -> Result {
25 | Ok(match v {
26 | "none" => CustomUnitAttribute::None,
27 | "allow-long-prefix" => CustomUnitAttribute::AllowLongPrefix,
28 | "allow-short-prefix" => CustomUnitAttribute::AllowShortPrefix,
29 | "is-long-prefix" => CustomUnitAttribute::IsLongPrefix,
30 | "alias" => CustomUnitAttribute::Alias,
31 | unknown => {
32 | return Err(serde::de::Error::unknown_variant(
33 | unknown,
34 | &[
35 | "none",
36 | "allow-long-prefix",
37 | "allow-short-prefix",
38 | "is-long-prefix",
39 | "alias",
40 | ],
41 | ));
42 | }
43 | })
44 | }
45 | }
46 |
47 | impl<'de> serde::Deserialize<'de> for CustomUnitAttribute {
48 | fn deserialize>(deserializer: D) -> Result {
49 | deserializer.deserialize_str(CustomUnitAttributeVisitor)
50 | }
51 | }
52 |
53 | impl CustomUnitAttribute {
54 | pub fn to_fend_core(&self) -> fend_core::CustomUnitAttribute {
55 | match self {
56 | CustomUnitAttribute::None => fend_core::CustomUnitAttribute::None,
57 | CustomUnitAttribute::AllowLongPrefix => fend_core::CustomUnitAttribute::AllowLongPrefix,
58 | CustomUnitAttribute::AllowShortPrefix => {
59 | fend_core::CustomUnitAttribute::AllowShortPrefix
60 | }
61 | CustomUnitAttribute::IsLongPrefix => fend_core::CustomUnitAttribute::IsLongPrefix,
62 | CustomUnitAttribute::Alias => fend_core::CustomUnitAttribute::Alias,
63 | }
64 | }
65 | }
66 |
67 | #[derive(Debug, Eq, PartialEq)]
68 | pub struct CustomUnitDefinition {
69 | pub singular: String,
70 | pub plural: String,
71 | pub definition: String,
72 | pub attribute: CustomUnitAttribute,
73 | }
74 |
75 | impl<'de> serde::Deserialize<'de> for CustomUnitDefinition {
76 | fn deserialize>(deserializer: D) -> Result {
77 | const FIELDS: &[&str] = &["singular", "plural", "definition", "attribute"];
78 |
79 | struct CustomUnitDefinitionVisitor;
80 |
81 | impl<'de> serde::de::Visitor<'de> for CustomUnitDefinitionVisitor {
82 | type Value = CustomUnitDefinition;
83 |
84 | fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
85 | formatter.write_str(
86 | "a custom unit definition, with properties `singular`, `plural`, `definition` and `attribute`",
87 | )
88 | }
89 |
90 | fn visit_map>(
91 | self,
92 | mut map: V,
93 | ) -> Result {
94 | let mut result = CustomUnitDefinition {
95 | attribute: CustomUnitAttribute::None,
96 | definition: String::new(),
97 | singular: String::new(),
98 | plural: String::new(),
99 | };
100 | let mut seen_singular = false;
101 | let mut seen_plural = false;
102 | let mut seen_definition = false;
103 | let mut seen_attribute = false;
104 | while let Some(key) = map.next_key::()? {
105 | match key.as_str() {
106 | "singular" => {
107 | if seen_singular {
108 | return Err(serde::de::Error::duplicate_field("singular"));
109 | }
110 | result.singular = map.next_value()?;
111 | seen_singular = true;
112 | }
113 | "plural" => {
114 | if seen_plural {
115 | return Err(serde::de::Error::duplicate_field("plural"));
116 | }
117 | result.plural = map.next_value()?;
118 | if result.plural.is_empty() {
119 | return Err(serde::de::Error::invalid_value(
120 | serde::de::Unexpected::Str(&result.plural),
121 | &"a non-empty string describing the plural form of this unit",
122 | ));
123 | }
124 | seen_plural = true;
125 | }
126 | "definition" => {
127 | if seen_definition {
128 | return Err(serde::de::Error::duplicate_field("definition"));
129 | }
130 | result.definition = map.next_value()?;
131 | if result.definition.is_empty() {
132 | return Err(serde::de::Error::invalid_value(
133 | serde::de::Unexpected::Str(&result.definition),
134 | &"a non-empty string that contains the definition of this unit",
135 | ));
136 | }
137 | seen_definition = true;
138 | }
139 | "attribute" => {
140 | if seen_attribute {
141 | return Err(serde::de::Error::duplicate_field("attribute"));
142 | }
143 | result.attribute = map.next_value()?;
144 | seen_attribute = true;
145 | }
146 | unknown_key => {
147 | map.next_value::()?;
148 | return Err(serde::de::Error::unknown_field(unknown_key, FIELDS));
149 | }
150 | }
151 | }
152 | if result.singular.is_empty() {
153 | return Err(serde::de::Error::missing_field("singular"));
154 | }
155 | if result.definition.is_empty() {
156 | return Err(serde::de::Error::missing_field("definition"));
157 | }
158 | Ok(result)
159 | }
160 | }
161 |
162 | deserializer.deserialize_struct("CustomUnitDefinition", FIELDS, CustomUnitDefinitionVisitor)
163 | }
164 | }
165 |
--------------------------------------------------------------------------------
/CODE_OF_CONDUCT.md:
--------------------------------------------------------------------------------
1 |
2 | # Contributor Covenant Code of Conduct
3 |
4 | ## Our Pledge
5 |
6 | We as members, contributors, and leaders pledge to make participation in our
7 | community a harassment-free experience for everyone, regardless of age, body
8 | size, visible or invisible disability, ethnicity, sex characteristics, gender
9 | identity and expression, level of experience, education, socio-economic status,
10 | nationality, personal appearance, race, caste, color, religion, or sexual
11 | identity and orientation.
12 |
13 | We pledge to act and interact in ways that contribute to an open, welcoming,
14 | diverse, inclusive, and healthy community.
15 |
16 | ## Our Standards
17 |
18 | Examples of behavior that contributes to a positive environment for our
19 | community include:
20 |
21 | * Demonstrating empathy and kindness toward other people
22 | * Being respectful of differing opinions, viewpoints, and experiences
23 | * Giving and gracefully accepting constructive feedback
24 | * Accepting responsibility and apologizing to those affected by our mistakes,
25 | and learning from the experience
26 | * Focusing on what is best not just for us as individuals, but for the overall
27 | community
28 |
29 | Examples of unacceptable behavior include:
30 |
31 | * The use of sexualized language or imagery, and sexual attention or advances of
32 | any kind
33 | * Trolling, insulting or derogatory comments, and personal or political attacks
34 | * Public or private harassment
35 | * Publishing others' private information, such as a physical or email address,
36 | without their explicit permission
37 | * Other conduct which could reasonably be considered inappropriate in a
38 | professional setting
39 |
40 | ## Enforcement Responsibilities
41 |
42 | Community leaders are responsible for clarifying and enforcing our standards of
43 | acceptable behavior and will take appropriate and fair corrective action in
44 | response to any behavior that they deem inappropriate, threatening, offensive,
45 | or harmful.
46 |
47 | Community leaders have the right and responsibility to remove, edit, or reject
48 | comments, commits, code, wiki edits, issues, and other contributions that are
49 | not aligned to this Code of Conduct, and will communicate reasons for moderation
50 | decisions when appropriate.
51 |
52 | ## Scope
53 |
54 | This Code of Conduct applies within all community spaces, and also applies when
55 | an individual is officially representing the community in public spaces.
56 | Examples of representing our community include using an official e-mail address,
57 | posting via an official social media account, or acting as an appointed
58 | representative at an online or offline event.
59 |
60 | ## Enforcement
61 |
62 | Instances of abusive, harassing, or otherwise unacceptable behavior may be
63 | reported to the community leaders responsible for enforcement at
64 | [@printfn:matrix.org](https://matrix.to/#/@printfn:matrix.org).
65 | All complaints will be reviewed and investigated promptly and fairly.
66 |
67 | All community leaders are obligated to respect the privacy and security of the
68 | reporter of any incident.
69 |
70 | ## Enforcement Guidelines
71 |
72 | Community leaders will follow these Community Impact Guidelines in determining
73 | the consequences for any action they deem in violation of this Code of Conduct:
74 |
75 | ### 1. Correction
76 |
77 | **Community Impact**: Use of inappropriate language or other behavior deemed
78 | unprofessional or unwelcome in the community.
79 |
80 | **Consequence**: A private, written warning from community leaders, providing
81 | clarity around the nature of the violation and an explanation of why the
82 | behavior was inappropriate. A public apology may be requested.
83 |
84 | ### 2. Warning
85 |
86 | **Community Impact**: A violation through a single incident or series of
87 | actions.
88 |
89 | **Consequence**: A warning with consequences for continued behavior. No
90 | interaction with the people involved, including unsolicited interaction with
91 | those enforcing the Code of Conduct, for a specified period of time. This
92 | includes avoiding interactions in community spaces as well as external channels
93 | like social media. Violating these terms may lead to a temporary or permanent
94 | ban.
95 |
96 | ### 3. Temporary Ban
97 |
98 | **Community Impact**: A serious violation of community standards, including
99 | sustained inappropriate behavior.
100 |
101 | **Consequence**: A temporary ban from any sort of interaction or public
102 | communication with the community for a specified period of time. No public or
103 | private interaction with the people involved, including unsolicited interaction
104 | with those enforcing the Code of Conduct, is allowed during this period.
105 | Violating these terms may lead to a permanent ban.
106 |
107 | ### 4. Permanent Ban
108 |
109 | **Community Impact**: Demonstrating a pattern of violation of community
110 | standards, including sustained inappropriate behavior, harassment of an
111 | individual, or aggression toward or disparagement of classes of individuals.
112 |
113 | **Consequence**: A permanent ban from any sort of public interaction within the
114 | community.
115 |
116 | ## Attribution
117 |
118 | This Code of Conduct is adapted from the [Contributor Covenant][homepage],
119 | version 2.1, available at
120 | [https://www.contributor-covenant.org/version/2/1/code_of_conduct.html][v2.1].
121 |
122 | Community Impact Guidelines were inspired by
123 | [Mozilla's code of conduct enforcement ladder][Mozilla CoC].
124 |
125 | For answers to common questions about this code of conduct, see the FAQ at
126 | [https://www.contributor-covenant.org/faq][FAQ]. Translations are available at
127 | [https://www.contributor-covenant.org/translations][translations].
128 |
129 | [homepage]: https://www.contributor-covenant.org
130 | [v2.1]: https://www.contributor-covenant.org/version/2/1/code_of_conduct.html
131 | [Mozilla CoC]: https://github.com/mozilla/diversity
132 | [FAQ]: https://www.contributor-covenant.org/faq
133 | [translations]: https://www.contributor-covenant.org/translations
134 |
135 |
--------------------------------------------------------------------------------
/core/src/num/unit/named_unit.rs:
--------------------------------------------------------------------------------
1 | use std::cmp::Ordering;
2 | use std::{borrow::Cow, collections::HashMap, fmt, io};
3 |
4 | use super::base_unit::BaseUnit;
5 | use crate::Interrupt;
6 | use crate::num::complex::Complex;
7 | use crate::result::FResult;
8 | use crate::serialize::{CborValue, Deserialize, Serialize};
9 |
10 | /// A named unit, like kilogram, megabyte or percent.
11 | #[derive(Clone)]
12 | pub(crate) struct NamedUnit {
13 | prefix: Cow<'static, str>,
14 | pub(super) singular_name: Cow<'static, str>,
15 | plural_name: Cow<'static, str>,
16 | alias: bool,
17 | pub(super) base_units: HashMap,
18 | pub(super) scale: Complex,
19 | }
20 |
21 | pub(crate) fn compare_hashmaps(
22 | a: &HashMap,
23 | b: &HashMap,
24 | int: &I,
25 | ) -> FResult {
26 | if a.len() != b.len() {
27 | return Ok(false);
28 | }
29 | for (k, v) in a {
30 | match b.get(k) {
31 | None => return Ok(false),
32 | Some(o) => {
33 | if v.compare(o, int)? != Some(Ordering::Equal) {
34 | return Ok(false);
35 | }
36 | }
37 | }
38 | }
39 | Ok(true)
40 | }
41 |
42 | impl NamedUnit {
43 | pub(crate) fn new(
44 | prefix: Cow<'static, str>,
45 | singular_name: Cow<'static, str>,
46 | plural_name: Cow<'static, str>,
47 | alias: bool,
48 | base_units: HashMap,
49 | scale: impl Into,
50 | ) -> Self {
51 | Self {
52 | prefix,
53 | singular_name,
54 | plural_name,
55 | alias,
56 | base_units,
57 | scale: scale.into(),
58 | }
59 | }
60 |
61 | pub(crate) fn serialize(&self, write: &mut impl io::Write) -> FResult<()> {
62 | self.prefix.as_ref().serialize(write)?;
63 | self.singular_name.as_ref().serialize(write)?;
64 | self.plural_name.as_ref().serialize(write)?;
65 | self.alias.serialize(write)?;
66 |
67 | self.base_units.len().serialize(write)?;
68 | for (a, b) in &self.base_units {
69 | a.serialize(write)?;
70 | b.serialize().serialize(write)?;
71 | }
72 |
73 | self.scale.serialize().serialize(write)?;
74 | Ok(())
75 | }
76 |
77 | pub(crate) fn deserialize(read: &mut impl io::Read) -> FResult {
78 | let prefix = String::deserialize(read)?;
79 | let singular_name = String::deserialize(read)?;
80 | let plural_name = String::deserialize(read)?;
81 | let alias = bool::deserialize(read)?;
82 |
83 | let len = usize::deserialize(read)?;
84 | let mut hashmap = HashMap::with_capacity(len);
85 | for _ in 0..len {
86 | let k = BaseUnit::deserialize(read)?;
87 | let v = Complex::deserialize(CborValue::deserialize(read)?)?;
88 | hashmap.insert(k, v);
89 | }
90 | Ok(Self {
91 | prefix: Cow::Owned(prefix),
92 | singular_name: Cow::Owned(singular_name),
93 | plural_name: Cow::Owned(plural_name),
94 | alias,
95 | base_units: hashmap,
96 | scale: Complex::deserialize(CborValue::deserialize(read)?)?,
97 | })
98 | }
99 |
100 | pub(crate) fn compare(&self, other: &Self, int: &I) -> FResult {
101 | Ok(self.prefix == other.prefix
102 | && self.singular_name == other.singular_name
103 | && self.plural_name == other.plural_name
104 | && self.alias == other.alias
105 | && self.scale.compare(&other.scale, int)? == Some(Ordering::Equal)
106 | && compare_hashmaps(&self.base_units, &other.base_units, int)?)
107 | }
108 |
109 | pub(crate) fn new_from_base(base_unit: BaseUnit) -> Self {
110 | Self {
111 | prefix: "".into(),
112 | singular_name: base_unit.name().to_string().into(),
113 | plural_name: base_unit.name().to_string().into(),
114 | alias: false,
115 | base_units: {
116 | let mut base_units = HashMap::new();
117 | base_units.insert(base_unit, 1.into());
118 | base_units
119 | },
120 | scale: 1.into(),
121 | }
122 | }
123 |
124 | pub(crate) fn prefix_and_name(&self, plural: bool) -> (&str, &str) {
125 | (
126 | self.prefix.as_ref(),
127 | if plural {
128 | self.plural_name.as_ref()
129 | } else {
130 | self.singular_name.as_ref()
131 | },
132 | )
133 | }
134 |
135 | pub(crate) fn has_no_base_units(&self) -> bool {
136 | self.base_units.is_empty()
137 | }
138 |
139 | pub(crate) fn is_alias(&self) -> bool {
140 | self.alias && self.has_no_base_units()
141 | }
142 |
143 | /// Returns whether or not this unit should be printed with a
144 | /// space (between the number and the unit). This should be true for most
145 | /// units like kg or m, but not for % or °
146 | pub(crate) fn print_with_space(&self) -> bool {
147 | // Alphabetic names like kg or m should have a space,
148 | // while non-alphabetic names like % or ' shouldn't.
149 | // Empty names shouldn't really exist, but they might as well have a space.
150 |
151 | // degree symbol
152 | if self.singular_name == "\u{b0}" {
153 | return false;
154 | }
155 |
156 | // if it starts with a quote and is more than one character long, print it with a space
157 | if (self.singular_name.starts_with('\'') || self.singular_name.starts_with('\"'))
158 | && self.singular_name.len() > 1
159 | {
160 | return true;
161 | }
162 |
163 | self.singular_name
164 | .chars()
165 | .next()
166 | .is_none_or(|first_char| char::is_alphabetic(first_char) || first_char == '\u{b0}')
167 | }
168 | }
169 |
170 | impl fmt::Debug for NamedUnit {
171 | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
172 | if self.prefix.is_empty() {
173 | write!(f, "{}", self.singular_name)?;
174 | } else {
175 | write!(f, "{}-{}", self.prefix, self.singular_name)?;
176 | }
177 | write!(f, " (")?;
178 | if self.plural_name != self.singular_name {
179 | if self.prefix.is_empty() {
180 | write!(f, "{}, ", self.plural_name)?;
181 | } else {
182 | write!(f, "{}-{}, ", self.prefix, self.plural_name)?;
183 | }
184 | }
185 | write!(f, "= {:?}", self.scale)?;
186 | let mut it = self.base_units.iter().collect::>();
187 | it.sort_by_key(|(k, _v)| k.name());
188 | for (base_unit, exponent) in &it {
189 | write!(f, " {base_unit:?}")?;
190 | if !exponent.is_definitely_one() {
191 | write!(f, "^{exponent:?}")?;
192 | }
193 | }
194 | write!(f, ")")?;
195 | Ok(())
196 | }
197 | }
198 |
--------------------------------------------------------------------------------
/windows-wix/main.wxs:
--------------------------------------------------------------------------------
1 |
2 |
3 |
18 |
19 |
20 |
21 |
23 |
25 |
26 |
31 |
33 |
34 |
35 |
37 |
38 |
39 |
40 |
41 |
42 |
43 |
46 |
47 |
48 |
49 |
50 |
51 |
54 |
55 |
56 |
57 |
58 |
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
70 |
71 |
72 |
73 |
74 |
75 |
77 |
79 |
81 |
82 |
83 |
84 |
86 |
87 |
104 |
105 |
106 |
107 |
108 |
110 |
111 |
112 |
113 |
115 |
116 |
117 |
119 |
120 |
121 |
122 |
123 |
124 |
125 |
126 |
127 |
130 |
131 |
133 |
134 |
135 |
136 |
137 |
138 |
--------------------------------------------------------------------------------
/wasm/src/lib.rs:
--------------------------------------------------------------------------------
1 | use std::collections::HashMap;
2 | use std::fmt::Write;
3 | use std::sync::OnceLock;
4 | use std::{error, fmt};
5 | use wasm_bindgen::prelude::*;
6 | use web_time::Instant;
7 |
8 | static CURRENCY_DATA: OnceLock> = OnceLock::new();
9 |
10 | struct TimeoutInterrupt {
11 | start: Instant,
12 | timeout: u128,
13 | }
14 |
15 | impl TimeoutInterrupt {
16 | fn new_with_timeout(timeout: u128) -> Self {
17 | Self {
18 | start: Instant::now(),
19 | timeout,
20 | }
21 | }
22 | }
23 |
24 | impl fend_core::Interrupt for TimeoutInterrupt {
25 | fn should_interrupt(&self) -> bool {
26 | Instant::now().duration_since(self.start).as_millis() > self.timeout
27 | }
28 | }
29 |
30 | pub fn initialise() {}
31 |
32 | #[wasm_bindgen(typescript_custom_section)]
33 | const _: &'static str = r#"
34 | /** Initialise currency data. The provided `currencyData` map should contain
35 | * currency names mapped to their relative values.
36 | *
37 | * For example:
38 | * ```typescript
39 | * const currencyData = new Map();
40 | * currencyData.set('USD', 1);
41 | * currencyData.set('EUR', 0.9);
42 | * initialiseWithHandlers(currencyData);
43 | * ``` */
44 | export function initialiseWithHandlers(currencyData: Map): void;
45 | "#;
46 |
47 | #[wasm_bindgen(js_name = initialiseWithHandlers, skip_typescript)]
48 | pub fn initialise_with_handlers(currency_data: js_sys::Map) {
49 | initialise();
50 | CURRENCY_DATA.get_or_init(|| {
51 | let mut rust_data = HashMap::new();
52 | currency_data.for_each(&mut |value, key| {
53 | rust_data.insert(key.as_string().unwrap(), value.as_f64().unwrap());
54 | });
55 | rust_data
56 | });
57 | }
58 |
59 | fn random_u32() -> u32 {
60 | let random_f64 = js_sys::Math::random();
61 | (random_f64 * f64::from(u32::MAX)) as u32
62 | }
63 |
64 | #[derive(Debug, Clone)]
65 | struct UnknownExchangeRate(String);
66 |
67 | impl fmt::Display for UnknownExchangeRate {
68 | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
69 | write!(f, "currency exchange rate for {} is unknown", self.0)
70 | }
71 | }
72 |
73 | impl error::Error for UnknownExchangeRate {}
74 |
75 | impl From for JsValue {
76 | fn from(err: UnknownExchangeRate) -> Self {
77 | JsValue::from(format!("{err}"))
78 | }
79 | }
80 |
81 | struct CurrencyHandler;
82 | impl fend_core::ExchangeRateFnV2 for CurrencyHandler {
83 | fn relative_to_base_currency(
84 | &self,
85 | currency: &str,
86 | _options: &fend_core::ExchangeRateFnV2Options,
87 | ) -> Result> {
88 | match CURRENCY_DATA.get().and_then(|x| x.get(currency)) {
89 | None => Err(Box::new(UnknownExchangeRate(currency.to_string()))
90 | as Box),
91 | Some(rate) => Ok(*rate),
92 | }
93 | }
94 | }
95 |
96 | fn create_context() -> fend_core::Context {
97 | let mut ctx = fend_core::Context::new();
98 | let date = js_sys::Date::new_0();
99 | ctx.set_current_time_v1(
100 | date.get_time() as u64,
101 | date.get_timezone_offset() as i64 * 60,
102 | );
103 | ctx.set_random_u32_fn(random_u32);
104 | if CURRENCY_DATA.get().is_some_and(|x| !x.is_empty()) {
105 | ctx.set_exchange_rate_handler_v2(CurrencyHandler);
106 | }
107 | ctx
108 | }
109 |
110 | /// @deprecated use `evaluateFendWithTimeout` instead
111 | #[wasm_bindgen(js_name = evaluate_fend_with_timeout, skip_typescript)]
112 | pub fn evaluate_fend_with_timeout_2(input: &str, timeout: u32) -> String {
113 | evaluate_fend_with_timeout(input, timeout)
114 | }
115 |
116 | #[wasm_bindgen(js_name = evaluateFendWithTimeout)]
117 | pub fn evaluate_fend_with_timeout(input: &str, timeout: u32) -> String {
118 | let mut ctx = create_context();
119 | let interrupt = TimeoutInterrupt::new_with_timeout(u128::from(timeout));
120 | match fend_core::evaluate_with_interrupt(input, &mut ctx, &interrupt) {
121 | Ok(res) => {
122 | if res.output_is_empty() {
123 | return "".to_string();
124 | }
125 | res.get_main_result().to_string()
126 | }
127 | Err(msg) => format!("Error: {msg}"),
128 | }
129 | }
130 |
131 | /// Takes a '\0'-separated string of inputs, and returns a '\0'-separated string of results
132 | #[wasm_bindgen(js_name = evaluateFendWithTimeoutMultiple)]
133 | pub fn evaluate_fend_with_timeout_multiple(inputs: &str, timeout: u32) -> String {
134 | let mut ctx = create_context();
135 | let mut result = String::new();
136 | for input in inputs.split('\0') {
137 | if !result.is_empty() {
138 | result.push('\0');
139 | }
140 | let interrupt = TimeoutInterrupt::new_with_timeout(u128::from(timeout));
141 | match fend_core::evaluate_with_interrupt(input, &mut ctx, &interrupt) {
142 | Ok(res) => {
143 | if !res.output_is_empty() {
144 | result.push_str(res.get_main_result());
145 | }
146 | }
147 | Err(msg) => {
148 | result.push_str("Error: ");
149 | result.push_str(&msg);
150 | }
151 | };
152 | }
153 | result
154 | }
155 |
156 | fn decode_hex(s: &str) -> Result, String> {
157 | (0..s.len())
158 | .step_by(2)
159 | .map(|i| u8::from_str_radix(&s[i..i + 2], 16))
160 | .collect::, std::num::ParseIntError>>()
161 | .map_err(|e| e.to_string())
162 | }
163 |
164 | #[wasm_bindgen(js_name = evaluateFendWithVariablesJson)]
165 | pub fn evaluate_fend_with_variables_json(input: &str, timeout: u32, variables: &str) -> String {
166 | let mut ctx = create_context();
167 | if !variables.is_empty()
168 | && let Ok(variables) = decode_hex(variables)
169 | {
170 | let _ = ctx.deserialize_variables(&mut variables.as_slice());
171 | }
172 | let interrupt = TimeoutInterrupt::new_with_timeout(u128::from(timeout));
173 | match fend_core::evaluate_with_interrupt(input, &mut ctx, &interrupt) {
174 | Ok(res) => {
175 | let escaped_result = {
176 | let mut escaped_result = String::new();
177 | if !res.output_is_empty() {
178 | fend_core::json::escape_string(res.get_main_result(), &mut escaped_result);
179 | }
180 | escaped_result
181 | };
182 | let variables = {
183 | let mut vars_vec = vec![];
184 | // if we can't serialize variables just ignore it and return an empty string
185 | let _ = ctx.serialize_variables(&mut vars_vec);
186 | let mut hex = String::new();
187 | for b in &vars_vec {
188 | write!(hex, "{b:02x}").unwrap();
189 | }
190 | hex
191 | };
192 | format!(r#"{{"ok":true,"result":"{escaped_result}","variables":"{variables}"}}"#)
193 | }
194 | Err(msg) => {
195 | let mut escaped = String::new();
196 | fend_core::json::escape_string(&msg, &mut escaped);
197 | format!(r#"{{"ok":false,"message":"{escaped}"}}"#)
198 | }
199 | }
200 | }
201 |
202 | #[wasm_bindgen(js_name = substituteInlineFendExpressions)]
203 | pub fn substitute_inline_fend_expressions(input: &str, timeout: u32) -> String {
204 | let mut ctx = create_context();
205 | let interrupt = TimeoutInterrupt::new_with_timeout(u128::from(timeout));
206 | let res = fend_core::substitute_inline_fend_expressions(input, &mut ctx, &interrupt);
207 | res.to_json()
208 | }
209 |
--------------------------------------------------------------------------------
/cli/src/main.rs:
--------------------------------------------------------------------------------
1 | #![deny(unsafe_code)]
2 | #![deny(clippy::all)]
3 | #![deny(clippy::pedantic)]
4 | #![deny(elided_lifetimes_in_paths)]
5 |
6 | use std::fmt::Write;
7 | use std::{error, io, process};
8 |
9 | mod args;
10 | mod color;
11 | mod config;
12 | mod context;
13 | mod custom_units;
14 | mod exchange_rates;
15 | mod file_paths;
16 | mod helper;
17 | mod interrupt;
18 | mod terminal;
19 |
20 | use args::Action as ArgsAction;
21 | use context::Context;
22 | use process::ExitCode;
23 | use tokio::sync::RwLock;
24 |
25 | type Error = Box;
26 |
27 | enum EvalResult {
28 | Ok,
29 | Err,
30 | NoInput,
31 | }
32 |
33 | fn print_spans(spans: Vec>, config: &config::Config) -> String {
34 | let mut result = String::new();
35 | for span in spans {
36 | let style = config.colors.get_color(span.kind());
37 | write!(result, "{style}{}\x1b[0m", span.string()).unwrap();
38 | }
39 | result
40 | }
41 |
42 | async fn eval_and_print_res(
43 | line: &str,
44 | context: &mut Context<'_>,
45 | print_res: bool,
46 | int: &impl fend_core::Interrupt,
47 | config: &config::Config,
48 | ) -> EvalResult {
49 | match context.eval(line, print_res, int).await {
50 | Ok(res) => {
51 | let result: Vec<_> = res.get_main_result_spans().collect();
52 | if result.is_empty() || res.output_is_empty() {
53 | return EvalResult::NoInput;
54 | }
55 | let string_result = if config.enable_colors {
56 | print_spans(result, config)
57 | } else {
58 | res.get_main_result().to_string()
59 | };
60 | print!("{string_result}");
61 | if res.has_trailing_newline() && !res.get_main_result().ends_with('\n') {
62 | println!();
63 | }
64 | EvalResult::Ok
65 | }
66 | Err(msg) => {
67 | eprintln!("Error: {msg}");
68 | EvalResult::Err
69 | }
70 | }
71 | }
72 |
73 | fn print_help(explain_quitting: bool) {
74 | println!("For more information on how to use fend, please take a look at the manual:");
75 | println!("https://printfn.github.io/fend/documentation/");
76 | println!();
77 | println!("Version: {}", fend_core::get_version());
78 | if let Ok(config_path) = file_paths::get_config_file_location() {
79 | println!("Config file: {}", config_path.to_string_lossy());
80 | } else {
81 | println!("Failed to get config file location");
82 | }
83 | if let Ok(history_path) = file_paths::get_history_file_location(file_paths::DirMode::DontCreate)
84 | {
85 | println!("History file: {}", history_path.to_string_lossy());
86 | } else {
87 | println!("Failed to get history file location");
88 | }
89 | if let Ok(cache_path) = file_paths::get_cache_dir(file_paths::DirMode::DontCreate) {
90 | println!("Cache directory: {}", cache_path.to_string_lossy());
91 | } else {
92 | println!("Failed to get cache directory location");
93 | }
94 | if explain_quitting {
95 | println!("\nTo quit, type `quit`.");
96 | }
97 | }
98 |
99 | async fn repl_loop(config: &config::Config) -> ExitCode {
100 | let core_context = RwLock::new(context::InnerCtx::new(config));
101 | let mut context = Context::new(&core_context);
102 | let mut prompt_state = match terminal::init_prompt(config, &context) {
103 | Ok(prompt_state) => prompt_state,
104 | Err(err) => {
105 | println!("Error: {err}");
106 | return ExitCode::FAILURE;
107 | }
108 | };
109 | let mut initial_run = true; // set to false after first successful command
110 | let mut last_command_success = true;
111 | let interrupt = interrupt::register_handler();
112 | loop {
113 | match prompt_state.read_line() {
114 | Ok(line) => match line.as_str() {
115 | "exit" | "exit()" | ".exit" | ":exit" | "quit" | "quit()" | ":quit" | ":q"
116 | | ":wq" | ":q!" | ":wq!" | ":qa" | ":wqa" | ":qa!" | ":wqa!" => break,
117 | "help" | "?" => {
118 | print_help(true);
119 | }
120 | "!serialize" => match context.serialize().await {
121 | Ok(res) => {
122 | for b in res {
123 | print!("{b:02x}");
124 | }
125 | println!();
126 | }
127 | Err(e) => eprintln!("{e}"),
128 | },
129 | line => {
130 | interrupt.reset();
131 | match eval_and_print_res(line, &mut context, true, &interrupt, config).await {
132 | EvalResult::Ok => {
133 | last_command_success = true;
134 | initial_run = false;
135 | }
136 | EvalResult::NoInput => {
137 | last_command_success = true;
138 | }
139 | EvalResult::Err => {
140 | last_command_success = false;
141 | }
142 | }
143 | }
144 | },
145 | Err(terminal::ReadLineError::Interrupted) => {
146 | match (initial_run, context.get_input_typed().await) {
147 | (_, true) => {
148 | // input has been typed => do nothing
149 | }
150 | (true, false) => {
151 | // initial run, no input => terminate
152 | break;
153 | }
154 | (false, false) => {
155 | // later run, no input => show message
156 | println!("Use Ctrl-D (i.e. EOF) to exit");
157 | }
158 | }
159 | }
160 | Err(terminal::ReadLineError::Eof) => break,
161 | Err(terminal::ReadLineError::Error(err)) => {
162 | println!("Error: {err}");
163 | break;
164 | }
165 | }
166 | }
167 | if last_command_success {
168 | ExitCode::SUCCESS
169 | } else {
170 | ExitCode::FAILURE
171 | }
172 | }
173 |
174 | async fn eval_exprs(exprs: &[String]) -> ExitCode {
175 | let config = config::read();
176 | let core_context = RwLock::new(context::InnerCtx::new(&config));
177 | for (i, expr) in exprs.iter().enumerate() {
178 | let print_res = i == exprs.len() - 1;
179 | match eval_and_print_res(
180 | expr.as_str(),
181 | &mut Context::new(&core_context),
182 | print_res,
183 | &interrupt::Never::default(),
184 | &config,
185 | )
186 | .await
187 | {
188 | EvalResult::Ok | EvalResult::NoInput => (),
189 | EvalResult::Err => return ExitCode::FAILURE,
190 | }
191 | }
192 | ExitCode::SUCCESS
193 | }
194 |
195 | async fn real_main() -> ExitCode {
196 | // Assemble the action from all but the first argument.
197 | let action = match ArgsAction::get() {
198 | Ok(action) => action,
199 | Err(e) => {
200 | eprintln!("Error: {e}");
201 | return ExitCode::FAILURE;
202 | }
203 | };
204 | match action {
205 | ArgsAction::Help => {
206 | print_help(false);
207 | }
208 | ArgsAction::Version => {
209 | println!("{}", fend_core::get_version());
210 | }
211 | ArgsAction::DefaultConfig => {
212 | println!("{}", config::DEFAULT_CONFIG_FILE);
213 | }
214 | ArgsAction::Eval { exprs } => {
215 | return eval_exprs(&exprs).await;
216 | }
217 | ArgsAction::Repl => {
218 | if terminal::is_terminal_stdin() {
219 | let config = config::read();
220 | return repl_loop(&config).await;
221 | }
222 | let mut input = String::new();
223 | match io::Read::read_to_string(&mut io::stdin(), &mut input) {
224 | Ok(_) => (),
225 | Err(e) => {
226 | eprintln!("Error: {e}");
227 | return ExitCode::FAILURE;
228 | }
229 | }
230 | return eval_exprs(&[input]).await;
231 | }
232 | }
233 | ExitCode::SUCCESS
234 | }
235 |
236 | #[tokio::main]
237 | async fn main() -> process::ExitCode {
238 | real_main().await
239 | }
240 |
--------------------------------------------------------------------------------
/core/src/date.rs:
--------------------------------------------------------------------------------
1 | use std::{fmt, io};
2 |
3 | mod day;
4 | mod day_of_week;
5 | mod month;
6 | mod parser;
7 | mod year;
8 |
9 | use day::Day;
10 | pub(crate) use day_of_week::DayOfWeek;
11 | pub(crate) use month::Month;
12 | use year::Year;
13 |
14 | use crate::{Interrupt, error::FendError, ident::Ident, result::FResult, value::Value};
15 |
16 | #[derive(Copy, Clone, Eq, PartialEq)]
17 | pub(crate) struct Date {
18 | year: Year,
19 | month: Month,
20 | day: Day,
21 | }
22 |
23 | impl Date {
24 | pub(crate) fn today(context: &crate::Context) -> FResult {
25 | let Some(current_time_info) = &context.current_time else {
26 | return Err(FendError::UnableToGetCurrentDate);
27 | };
28 | let mut ms_since_epoch: i64 = current_time_info.elapsed_unix_time_ms.try_into().unwrap();
29 | ms_since_epoch -= current_time_info.timezone_offset_secs * 1000;
30 | let mut days = ms_since_epoch / 86_400_000; // no leap seconds
31 | let mut year = Year::new(1970);
32 | while days >= year.number_of_days().into() {
33 | year = year.next();
34 | days -= i64::from(year.number_of_days());
35 | }
36 | let mut month = Month::January;
37 | while days >= month.number_of_days(year).into() {
38 | month = month.next();
39 | days -= i64::from(month.number_of_days(year));
40 | }
41 | Ok(Self {
42 | year,
43 | month,
44 | day: Day::new(days.try_into().unwrap()),
45 | })
46 | }
47 |
48 | fn day_of_week(self) -> DayOfWeek {
49 | let d1 = (1
50 | + 5 * ((self.year.value() - 1) % 4)
51 | + 4 * ((self.year.value() - 1) % 100)
52 | + 6 * ((self.year.value() - 1) % 400))
53 | % 7;
54 | let ms = match self.month {
55 | Month::January => (0, 0),
56 | Month::February => (3, 3),
57 | Month::March | Month::November => (3, 4),
58 | Month::April | Month::July => (6, 0),
59 | Month::May => (1, 2),
60 | Month::June => (4, 5),
61 | Month::August => (2, 3),
62 | Month::September | Month::December => (5, 6),
63 | Month::October => (0, 1),
64 | };
65 | let m = if self.year.is_leap_year() { ms.1 } else { ms.0 };
66 | match (d1 + m + i32::from(self.day.value() - 1)) % 7 {
67 | 0 => DayOfWeek::Sunday,
68 | 1 => DayOfWeek::Monday,
69 | 2 => DayOfWeek::Tuesday,
70 | 3 => DayOfWeek::Wednesday,
71 | 4 => DayOfWeek::Thursday,
72 | 5 => DayOfWeek::Friday,
73 | 6 => DayOfWeek::Saturday,
74 | _ => unreachable!(),
75 | }
76 | }
77 |
78 | pub(crate) fn next(self) -> Self {
79 | if self.day.value() < Month::number_of_days(self.month, self.year) {
80 | Self {
81 | day: Day::new(self.day.value() + 1),
82 | month: self.month,
83 | year: self.year,
84 | }
85 | } else if self.month == Month::December {
86 | Self {
87 | day: Day::new(1),
88 | month: Month::January,
89 | year: self.year.next(),
90 | }
91 | } else {
92 | Self {
93 | day: Day::new(1),
94 | month: self.month.next(),
95 | year: self.year,
96 | }
97 | }
98 | }
99 |
100 | pub(crate) fn prev(self) -> Self {
101 | if self.day.value() > 1 {
102 | Self {
103 | day: Day::new(self.day.value() - 1),
104 | month: self.month,
105 | year: self.year,
106 | }
107 | } else if self.month == Month::January {
108 | Self {
109 | day: Day::new(31),
110 | month: Month::December,
111 | year: self.year.prev(),
112 | }
113 | } else {
114 | let month = self.month.prev();
115 | Self {
116 | day: Day::new(Month::number_of_days(month, self.year)),
117 | month,
118 | year: self.year,
119 | }
120 | }
121 | }
122 |
123 | pub(crate) fn diff_months(self, mut months: i64) -> FResult {
124 | let mut result = self;
125 | while months >= 12 {
126 | result.year = result.year.next();
127 | months -= 12;
128 | }
129 | while months <= -12 {
130 | result.year = result.year.prev();
131 | months += 12;
132 | }
133 | while months > 0 {
134 | if result.month == Month::December {
135 | result.month = Month::January;
136 | result.year = result.year.next();
137 | } else {
138 | result.month = result.month.next();
139 | }
140 | months -= 1;
141 | }
142 | while months < 0 {
143 | if result.month == Month::January {
144 | result.month = Month::December;
145 | result.year = result.year.prev();
146 | } else {
147 | result.month = result.month.prev();
148 | }
149 | months += 1;
150 | }
151 | if result.day.value() > Month::number_of_days(result.month, result.year) {
152 | let mut before = result;
153 | before.day = Day::new(Month::number_of_days(before.month, before.year));
154 | let mut after = result;
155 | if after.month == Month::December {
156 | after.month = Month::January;
157 | after.year = after.year.next();
158 | } else {
159 | after.month = after.month.next();
160 | }
161 | after.day = Day::new(1);
162 | return Err(FendError::NonExistentDate {
163 | year: result.year.value(),
164 | month: result.month,
165 | expected_day: result.day.value(),
166 | before,
167 | after,
168 | });
169 | }
170 | Ok(result)
171 | }
172 |
173 | pub(crate) fn parse(s: &str) -> FResult {
174 | parser::parse_date(s)
175 | }
176 |
177 | pub(crate) fn serialize(self, write: &mut impl io::Write) -> FResult<()> {
178 | self.year.serialize(write)?;
179 | self.month.serialize(write)?;
180 | self.day.serialize(write)?;
181 | Ok(())
182 | }
183 |
184 | pub(crate) fn deserialize(read: &mut impl io::Read) -> FResult {
185 | Ok(Self {
186 | year: Year::deserialize(read)?,
187 | month: Month::deserialize(read)?,
188 | day: Day::deserialize(read)?,
189 | })
190 | }
191 |
192 | pub(crate) fn get_object_member(self, key: &Ident) -> FResult {
193 | Ok(match key.as_str() {
194 | "month" => Value::Month(self.month),
195 | "day_of_week" => Value::DayOfWeek(self.day_of_week()),
196 | _ => return Err(FendError::CouldNotFindKey(key.to_string())),
197 | })
198 | }
199 |
200 | pub(crate) fn add(self, rhs: Value, int: &I) -> FResult {
201 | let rhs = rhs.expect_num()?;
202 | if rhs.unit_equal_to("day", int)? {
203 | let num_days = rhs.try_as_usize_unit(int)?;
204 | let mut result = self;
205 | for _ in 0..num_days {
206 | result = result.next();
207 | }
208 | Ok(Value::Date(result))
209 | } else {
210 | Err(FendError::ExpectedANumber)
211 | }
212 | }
213 |
214 | pub(crate) fn sub(self, rhs: Value, int: &I) -> FResult {
215 | let rhs = rhs.expect_num()?;
216 |
217 | if rhs.unit_equal_to("day", int)? {
218 | let num_days = rhs.try_as_usize_unit(int)?;
219 | let mut result = self;
220 | for _ in 0..num_days {
221 | result = result.prev();
222 | }
223 | Ok(Value::Date(result))
224 | } else if rhs.unit_equal_to("week", int)? {
225 | let num_weeks = rhs.try_as_usize_unit(int)?;
226 | let mut result = self;
227 | for _ in 0..num_weeks {
228 | for _ in 0..7 {
229 | result = result.prev();
230 | }
231 | }
232 | Ok(Value::Date(result))
233 | } else if rhs.unit_equal_to("month", int)? {
234 | let num_months = rhs.try_as_usize_unit(int)?;
235 | let result = self
236 | .diff_months(-i64::try_from(num_months).map_err(|_| FendError::ValueTooLarge)?)?;
237 | Ok(Value::Date(result))
238 | } else if rhs.unit_equal_to("year", int)? {
239 | let num_years = rhs.try_as_usize_unit(int)?;
240 | let num_months = num_years * 12;
241 | let result = self
242 | .diff_months(-i64::try_from(num_months).map_err(|_| FendError::ValueTooLarge)?)?;
243 | Ok(Value::Date(result))
244 | } else {
245 | Err(FendError::ExpectedANumber)
246 | }
247 | }
248 | }
249 |
250 | impl fmt::Debug for Date {
251 | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
252 | write!(
253 | f,
254 | "{}, {} {} {}",
255 | self.day_of_week(),
256 | self.day,
257 | self.month,
258 | self.year
259 | )
260 | }
261 | }
262 |
263 | impl fmt::Display for Date {
264 | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
265 | write!(f, "{self:?}")
266 | }
267 | }
268 |
--------------------------------------------------------------------------------
/contrib/deploy.sh:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 | set -euo pipefail
3 | cd "$(dirname "$0")"
4 | cd ..
5 |
6 | USAGE="Usage: ./deploy.sh [flags]
7 |
8 | should be the new version number to release, e.g. 0.1.0
9 |
10 | Flags:
11 | -h --help show this help screen"
12 |
13 | NEW_VERSION=""
14 | while [[ "$#" != 0 ]]; do
15 | arg="$1"
16 | if [[ "$arg" == "-h" || "$arg" == "--help" ]]; then
17 | echo "$USAGE"
18 | exit
19 | elif [[ "$arg" =~ ^- ]]; then
20 | echo "error: unknown option '$arg'" >&2
21 | exit 1
22 | elif [[ "$NEW_VERSION" == "" ]]; then
23 | NEW_VERSION="$arg"
24 | else
25 | echo "error: too many arguments" >&2
26 | exit 1
27 | fi
28 | shift
29 | done
30 |
31 | if [[ "$NEW_VERSION" == "" ]] ; then
32 | echo "$USAGE" >&2
33 | exit 1
34 | fi
35 |
36 | fail() {
37 | echo "$1"
38 | exit 1
39 | }
40 |
41 | checkversion() {
42 | echo "$1" | grep "^[0-9]\+\.[0-9]\+\.[0-9]\+$" >/dev/null \
43 | || fail "Invalid version"
44 | }
45 |
46 | confirm() {
47 | echo "$1"
48 | read -r -p "Press enter to confirm, or Ctrl-C to cancel"
49 | echo
50 | }
51 |
52 | manualstep() {
53 | echo
54 | echo "Manual step:"
55 | confirm "$1"
56 | }
57 |
58 | gitdiff() {
59 | local gitdir="$1"
60 | local expected_add_count="$2"
61 | local expected_del_count="$3"
62 | # checks the expected number of lines + files are different
63 | local added_lines
64 | added_lines="$(git -C "$gitdir" --no-pager diff|grep -c '^+')"
65 | if [[ "$added_lines" != "$expected_add_count" ]]; then
66 | fail "Expected $expected_add_count lines+files to be different (+)"
67 | fi
68 | local removed_lines
69 | removed_lines="$(git -C "$gitdir" --no-pager diff|grep -c '^-')"
70 | if [[ "$removed_lines" != "$expected_del_count" ]]; then
71 | fail "Expected $expected_del_count lines+files to be different (-)"
72 | fi
73 | }
74 |
75 | checkversion "$NEW_VERSION"
76 |
77 | current_branch="$(git rev-parse --abbrev-ref HEAD)"
78 | if [[ "$current_branch" != "main" ]]; then
79 | echo "Error: not on main branch"
80 | fi
81 |
82 | OLD_VERSION="$(cargo run --package fend --quiet -- version)"
83 |
84 | if ! command -v "wasm-pack" >/dev/null; then
85 | fail "Please install wasm-pack"
86 | fi
87 |
88 | confirm "Releasing update $OLD_VERSION -> $NEW_VERSION. \
89 | Update the README file and other documentation if necessary."
90 |
91 | echo "Updating Cargo.lock" # also ensures the internet connection works
92 | cargo update
93 |
94 | echo "Running cargo fmt..."
95 | cargo fmt -- --check
96 |
97 | echo "Making sure we are logged in to npm..."
98 | npm adduser # `npm whoami` returns success even if the auth token is invalid/expired
99 |
100 | echo "Making sure we are logged in to crates.io..."
101 | cargo owner --list fend >/dev/null
102 |
103 | PATH="${XDG_DATA_HOME-$HOME/.local/share}/cargo/bin:$PATH"
104 | echo "Ensure that we are using Rustup"
105 | rustc_cmd=$(command -v rustc)
106 | if [[ ! "$rustc_cmd" =~ .(cargo|rustup)/bin/rustc$ ]]; then
107 | fail "Using $rustc_cmd which does not seem to be from Rustup"
108 | fi
109 |
110 | echo "Making sure the git repository is clean..."
111 | # from https://stackoverflow.com/a/5143914
112 | git update-index --refresh &>/dev/null || true
113 | if ! git diff-index --quiet HEAD --; then
114 | fail "The local repository has uncommitted changes"
115 | fi
116 |
117 | echo "Bumping version numbers..."
118 |
119 | # fend workspace Cargo.toml x2
120 | sed "s/^version = \"$OLD_VERSION\"$/version = \"$NEW_VERSION\"/" \
121 | Cargo.toml | \
122 | sed "s/^fend-core = { version = \"$OLD_VERSION\"/fend-core = { version = \"$NEW_VERSION\"/" >temp
123 | mv temp Cargo.toml
124 |
125 | gitdiff "" 3 3
126 |
127 | manualstep "Add changelog to CHANGELOG.md"
128 |
129 | echo "Extracted changelog:"
130 | CHANGELOG=$(tr "\n" "\1" &1)|grep "total files:"|grep 6
181 | echo "Publishing npm package"
182 | (cd wasm/pkg && npm publish)
183 |
184 | echo "Building NPM package fend-wasm-web"
185 | rm -rfv wasm/pkgweb
186 | (cd wasm && wasm-pack build --target web --out-dir pkgweb)
187 | echo "Renaming package to 'fend-wasm-web' and removing 'sideEffects: false'..."
188 | jq "setpath([\"name\"]; \"fend-wasm-web\") | del(.sideEffects)" \
189 | wasm/pkgweb/package.json >temp
190 | mv temp wasm/pkgweb/package.json
191 | (cd wasm/pkgweb && npm publish)
192 |
193 | TMPDIR="$(mktemp -d)"
194 | if [[ ! -d "$TMPDIR" ]]; then
195 | >&2 echo "Failed to create temp directory"
196 | exit 1
197 | fi
198 | echo "Created temporary directory $TMPDIR"
199 |
200 | manualstep "Ensure GitHub CI has finished and all artifacts are available"
201 |
202 | echo "Downloading Github artifacts..."
203 | gh run download "$GH_RUN_ID" --dir "$TMPDIR/artifacts"
204 |
205 | echo "Zipping artifacts..."
206 | # --junk-paths prevents directory names from being stored in the zip file,
207 | # so the binary is stored at the top level
208 | zip --junk-paths "$TMPDIR/artifacts/fend-$NEW_VERSION-linux-x86_64-gnu.zip" \
209 | "$TMPDIR/artifacts/fend-$NEW_VERSION-linux-x86_64-gnu/fend"
210 | zip --junk-paths "$TMPDIR/artifacts/fend-$NEW_VERSION-linux-aarch64-gnu.zip" \
211 | "$TMPDIR/artifacts/fend-$NEW_VERSION-linux-aarch64-gnu/fend"
212 | zip --junk-paths "$TMPDIR/artifacts/fend-$NEW_VERSION-linux-x86_64-musl.zip" \
213 | "$TMPDIR/artifacts/fend-$NEW_VERSION-linux-x86_64-musl/fend"
214 | zip --junk-paths "$TMPDIR/artifacts/fend-$NEW_VERSION-macos-aarch64.zip" \
215 | "$TMPDIR/artifacts/fend-$NEW_VERSION-macos-aarch64/fend"
216 | zip --junk-paths "$TMPDIR/artifacts/fend-$NEW_VERSION-windows-x64-exe.zip" \
217 | "$TMPDIR/artifacts/fend-$NEW_VERSION-windows-x64-exe/fend.exe"
218 | cp "$TMPDIR/artifacts/fend-$NEW_VERSION-windows-x64-msi/fend-windows-x64.msi" \
219 | "$TMPDIR/artifacts/fend-$NEW_VERSION-windows-x64.msi"
220 | cp "$TMPDIR/artifacts/man-page/fend.1" \
221 | "$TMPDIR/artifacts/fend.1"
222 |
223 | echo "Creating GitHub release..."
224 | CHANGELOG2=$'Changes in this version:\n\n'"$CHANGELOG"
225 | gh release --repo printfn/fend \
226 | create "v$NEW_VERSION" --title "Version $NEW_VERSION" \
227 | --notes "$CHANGELOG2" \
228 | --draft \
229 | "$TMPDIR/artifacts/fend-$NEW_VERSION-linux-x86_64-gnu.zip" \
230 | "$TMPDIR/artifacts/fend-$NEW_VERSION-linux-aarch64-gnu.zip" \
231 | "$TMPDIR/artifacts/fend-$NEW_VERSION-linux-x86_64-musl.zip" \
232 | "$TMPDIR/artifacts/fend-$NEW_VERSION-macos-aarch64.zip" \
233 | "$TMPDIR/artifacts/fend-$NEW_VERSION-windows-x64-exe.zip" \
234 | "$TMPDIR/artifacts/fend-$NEW_VERSION-windows-x64.msi" \
235 | "$TMPDIR/artifacts/fend.1"
236 |
237 | manualstep "Open https://github.com/printfn/fend/releases and check \
238 | that the new release is correct. If it is, go ahead and publish it."
239 |
240 | HASH=$(curl -L -o - "https://github.com/printfn/fend/archive/refs/tags/v$NEW_VERSION.tar.gz" \
241 | | shasum -a 256 - \
242 | | grep -o '[a-f0-9]\{64\}')
243 |
244 | # AUR release
245 | git clone ssh://aur@aur.archlinux.org/fend.git "$TMPDIR/fend-aur"
246 | git -C "$TMPDIR/fend-aur" config user.name printfn
247 | git -C "$TMPDIR/fend-aur" config user.email printfn@users.noreply.github.com
248 | sed "s/$OLD_VERSION/$NEW_VERSION/g" "$TMPDIR/fend-aur/.SRCINFO" \
249 | | sed "s/[a-f0-9]\{64\}/$HASH/" >"$TMPDIR/fend-aur/.SRCINFO_NEW"
250 | sed "s/$OLD_VERSION/$NEW_VERSION/" "$TMPDIR/fend-aur/PKGBUILD" \
251 | | sed "s/[a-f0-9]\{64\}/$HASH/" >"$TMPDIR/fend-aur/PKGBUILD_NEW"
252 | mv "$TMPDIR/fend-aur/.SRCINFO_NEW" "$TMPDIR/fend-aur/.SRCINFO"
253 | mv "$TMPDIR/fend-aur/PKGBUILD_NEW" "$TMPDIR/fend-aur/PKGBUILD"
254 | gitdiff "$TMPDIR/fend-aur" 7 7 # 5 lines in 2 files
255 | TZ=UTC git -C "$TMPDIR/fend-aur" commit -am "fend $OLD_VERSION -> $NEW_VERSION"
256 | git -C "$TMPDIR/fend-aur" --no-pager log --pretty=full HEAD~.. \
257 | | grep '^Author: printfn $'
258 | git -C "$TMPDIR/fend-aur" --no-pager log --pretty=full HEAD~.. \
259 | | grep '^Commit: printfn $'
260 | git -C "$TMPDIR/fend-aur" push origin master
261 |
262 | rm -rf "$TMPDIR"
263 |
--------------------------------------------------------------------------------