holm/nushell
1
1
Fork 0
forked from extern/nushell
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Replace crate visibility identifier with pub(crate)

Browse Source 
Result of running:

find src -name *.rs -exec sed -i 's/crate /pub(crate) /g' {} \;
This commit is contained in:
est31 2019-08-29 13:08:28 +02:00
parent 6638fe4ab3
commit c87fa14fc8
35 changed files with 339 additions and 339 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/cli.rs
View File

@ -7,7 +7,7 @@ use crate::commands::plugin::JsonRpc;
use crate::commands::plugin::{PluginCommand, PluginSink};
use crate::commands::whole_stream_command;
use crate::context::Context;
crate use crate::errors::ShellError;
pub(crate) use crate::errors::ShellError;
use crate::git::current_branch;
use crate::object::Value;
use crate::parser::registry::Signature;

230
src/commands.rs
View File

@ -1,121 +1,121 @@
#[macro_use]
crate mod macros;
pub(crate) mod macros;
crate mod args;
crate mod autoview;
crate mod cd;
crate mod classified;
crate mod clip;
crate mod command;
crate mod config;
crate mod cp;
crate mod date;
crate mod debug;
crate mod enter;
crate mod exit;
crate mod first;
crate mod from_array;
crate mod from_bson;
crate mod from_csv;
crate mod from_ini;
crate mod from_json;
crate mod from_toml;
crate mod from_tsv;
crate mod from_xml;
crate mod from_yaml;
crate mod get;
crate mod last;
crate mod lines;
crate mod ls;
crate mod mkdir;
crate mod mv;
crate mod next;
crate mod nth;
crate mod open;
crate mod pick;
crate mod plugin;
crate mod prev;
crate mod ps;
crate mod reject;
crate mod reverse;
crate mod rm;
crate mod save;
crate mod shells;
crate mod size;
crate mod skip_while;
crate mod sort_by;
crate mod split_column;
crate mod split_row;
crate mod table;
crate mod tags;
crate mod to_array;
crate mod to_bson;
crate mod to_csv;
crate mod to_json;
crate mod to_toml;
crate mod to_tsv;
crate mod to_yaml;
crate mod trim;
crate mod version;
crate mod vtable;
crate mod where_;
crate mod which_;
pub(crate) mod args;
pub(crate) mod autoview;
pub(crate) mod cd;
pub(crate) mod classified;
pub(crate) mod clip;
pub(crate) mod command;
pub(crate) mod config;
pub(crate) mod cp;
pub(crate) mod date;
pub(crate) mod debug;
pub(crate) mod enter;
pub(crate) mod exit;
pub(crate) mod first;
pub(crate) mod from_array;
pub(crate) mod from_bson;
pub(crate) mod from_csv;
pub(crate) mod from_ini;
pub(crate) mod from_json;
pub(crate) mod from_toml;
pub(crate) mod from_tsv;
pub(crate) mod from_xml;
pub(crate) mod from_yaml;
pub(crate) mod get;
pub(crate) mod last;
pub(crate) mod lines;
pub(crate) mod ls;
pub(crate) mod mkdir;
pub(crate) mod mv;
pub(crate) mod next;
pub(crate) mod nth;
pub(crate) mod open;
pub(crate) mod pick;
pub(crate) mod plugin;
pub(crate) mod prev;
pub(crate) mod ps;
pub(crate) mod reject;
pub(crate) mod reverse;
pub(crate) mod rm;
pub(crate) mod save;
pub(crate) mod shells;
pub(crate) mod size;
pub(crate) mod skip_while;
pub(crate) mod sort_by;
pub(crate) mod split_column;
pub(crate) mod split_row;
pub(crate) mod table;
pub(crate) mod tags;
pub(crate) mod to_array;
pub(crate) mod to_bson;
pub(crate) mod to_csv;
pub(crate) mod to_json;
pub(crate) mod to_toml;
pub(crate) mod to_tsv;
pub(crate) mod to_yaml;
pub(crate) mod trim;
pub(crate) mod version;
pub(crate) mod vtable;
pub(crate) mod where_;
pub(crate) mod which_;
crate use autoview::Autoview;
crate use cd::CD;
crate use command::{
pub(crate) use autoview::Autoview;
pub(crate) use cd::CD;
pub(crate) use command::{
per_item_command, whole_stream_command, Command, PerItemCommand, RawCommandArgs,
UnevaluatedCallInfo, WholeStreamCommand,
};
crate use config::Config;
crate use cp::Cpy;
crate use date::Date;
crate use debug::Debug;
crate use enter::Enter;
crate use exit::Exit;
crate use first::First;
crate use from_array::FromArray;
crate use from_bson::FromBSON;
crate use from_csv::FromCSV;
crate use from_ini::FromINI;
crate use from_json::FromJSON;
crate use from_toml::FromTOML;
crate use from_tsv::FromTSV;
crate use from_xml::FromXML;
crate use from_yaml::FromYAML;
crate use get::Get;
crate use last::Last;
crate use lines::Lines;
crate use ls::LS;
crate use mkdir::Mkdir;
crate use mv::Move;
crate use next::Next;
crate use nth::Nth;
crate use open::Open;
crate use pick::Pick;
crate use prev::Previous;
crate use ps::PS;
crate use reject::Reject;
crate use reverse::Reverse;
crate use rm::Remove;
crate use save::Save;
crate use shells::Shells;
crate use size::Size;
crate use skip_while::SkipWhile;
crate use sort_by::SortBy;
crate use split_column::SplitColumn;
crate use split_row::SplitRow;
crate use table::Table;
crate use tags::Tags;
crate use to_array::ToArray;
crate use to_bson::ToBSON;
crate use to_csv::ToCSV;
crate use to_json::ToJSON;
crate use to_toml::ToTOML;
crate use to_tsv::ToTSV;
crate use to_yaml::ToYAML;
crate use trim::Trim;
crate use version::Version;
crate use vtable::VTable;
crate use where_::Where;
crate use which_::Which;
pub(crate) use config::Config;
pub(crate) use cp::Cpy;
pub(crate) use date::Date;
pub(crate) use debug::Debug;
pub(crate) use enter::Enter;
pub(crate) use exit::Exit;
pub(crate) use first::First;
pub(crate) use from_array::FromArray;
pub(crate) use from_bson::FromBSON;
pub(crate) use from_csv::FromCSV;
pub(crate) use from_ini::FromINI;
pub(crate) use from_json::FromJSON;
pub(crate) use from_toml::FromTOML;
pub(crate) use from_tsv::FromTSV;
pub(crate) use from_xml::FromXML;
pub(crate) use from_yaml::FromYAML;
pub(crate) use get::Get;
pub(crate) use last::Last;
pub(crate) use lines::Lines;
pub(crate) use ls::LS;
pub(crate) use mkdir::Mkdir;
pub(crate) use mv::Move;
pub(crate) use next::Next;
pub(crate) use nth::Nth;
pub(crate) use open::Open;
pub(crate) use pick::Pick;
pub(crate) use prev::Previous;
pub(crate) use ps::PS;
pub(crate) use reject::Reject;
pub(crate) use reverse::Reverse;
pub(crate) use rm::Remove;
pub(crate) use save::Save;
pub(crate) use shells::Shells;
pub(crate) use size::Size;
pub(crate) use skip_while::SkipWhile;
pub(crate) use sort_by::SortBy;
pub(crate) use split_column::SplitColumn;
pub(crate) use split_row::SplitRow;
pub(crate) use table::Table;
pub(crate) use tags::Tags;
pub(crate) use to_array::ToArray;
pub(crate) use to_bson::ToBSON;
pub(crate) use to_csv::ToCSV;
pub(crate) use to_json::ToJSON;
pub(crate) use to_toml::ToTOML;
pub(crate) use to_tsv::ToTSV;
pub(crate) use to_yaml::ToYAML;
pub(crate) use trim::Trim;
pub(crate) use version::Version;
pub(crate) use vtable::VTable;
pub(crate) use where_::Where;
pub(crate) use which_::Which;

40
src/commands/classified.rs
View File

@ -45,27 +45,27 @@ impl Decoder for LinesCodec {
}
}
crate struct ClassifiedInputStream {
crate objects: InputStream,
crate stdin: Option<std::fs::File>,
pub(crate) struct ClassifiedInputStream {
pub(crate) objects: InputStream,
pub(crate) stdin: Option<std::fs::File>,
}
impl ClassifiedInputStream {
crate fn new() -> ClassifiedInputStream {
pub(crate) fn new() -> ClassifiedInputStream {
ClassifiedInputStream {
objects: VecDeque::new().into(),
stdin: None,
}
}
crate fn from_input_stream(stream: impl Into<InputStream>) -> ClassifiedInputStream {
pub(crate) fn from_input_stream(stream: impl Into<InputStream>) -> ClassifiedInputStream {
ClassifiedInputStream {
objects: stream.into(),
stdin: None,
}
}
crate fn from_stdout(stdout: std::fs::File) -> ClassifiedInputStream {
pub(crate) fn from_stdout(stdout: std::fs::File) -> ClassifiedInputStream {
ClassifiedInputStream {
objects: VecDeque::new().into(),
stdin: Some(stdout),
@ -73,11 +73,11 @@ impl ClassifiedInputStream {
}
}
crate struct ClassifiedPipeline {
crate commands: Vec<ClassifiedCommand>,
pub(crate) struct ClassifiedPipeline {
pub(crate) commands: Vec<ClassifiedCommand>,
}
crate enum ClassifiedCommand {
pub(crate) enum ClassifiedCommand {
#[allow(unused)]
Expr(TokenNode),
Internal(InternalCommand),
@ -95,14 +95,14 @@ impl ClassifiedCommand {
}
}
crate struct InternalCommand {
crate command: Arc<Command>,
crate name_span: Span,
crate args: hir::Call,
pub(crate) struct InternalCommand {
pub(crate) command: Arc<Command>,
pub(crate) name_span: Span,
pub(crate) args: hir::Call,
}
impl InternalCommand {
crate async fn run(
pub(crate) async fn run(
self,
context: &mut Context,
input: ClassifiedInputStream,
@ -218,21 +218,21 @@ impl InternalCommand {
}
}
crate struct ExternalCommand {
crate name: String,
pub(crate) struct ExternalCommand {
pub(crate) name: String,
#[allow(unused)]
crate name_span: Span,
crate args: Vec<Tagged<String>>,
pub(crate) name_span: Span,
pub(crate) args: Vec<Tagged<String>>,
}
crate enum StreamNext {
pub(crate) enum StreamNext {
Last,
External,
Internal,
}
impl ExternalCommand {
crate async fn run(
pub(crate) async fn run(
self,
context: &mut Context,
input: ClassifiedInputStream,

2
src/commands/format.rs
View File

@ -3,7 +3,7 @@ use crate::{EntriesListView, GenericView, TreeView};
use futures::stream::{self, StreamExt};
use std::sync::{Arc, Mutex};
crate fn format(input: Vec<Value>, host: &mut dyn Host) {
pub(crate) fn format(input: Vec<Value>, host: &mut dyn Host) {
let last = input.len() - 1;
for (i, item) in input.iter().enumerate() {
let view = GenericView::new(item);

22
src/context.rs
View File

@ -41,13 +41,13 @@ pub struct CommandRegistry {
}
impl CommandRegistry {
crate fn empty() -> CommandRegistry {
pub(crate) fn empty() -> CommandRegistry {
CommandRegistry {
registry: Arc::new(Mutex::new(IndexMap::default())),
}
}
crate fn get_command(&self, name: &str) -> Option<Arc<Command>> {
pub(crate) fn get_command(&self, name: &str) -> Option<Arc<Command>> {
let registry = self.registry.lock().unwrap();
registry.get(name).map(|c| c.clone())
@ -64,7 +64,7 @@ impl CommandRegistry {
registry.insert(name.into(), command);
}
crate fn names(&self) -> Vec<String> {
pub(crate) fn names(&self) -> Vec<String> {
let registry = self.registry.lock().unwrap();
registry.keys().cloned().collect()
}
@ -73,17 +73,17 @@ impl CommandRegistry {
#[derive(Clone)]
pub struct Context {
registry: CommandRegistry,
crate source_map: SourceMap,
pub(crate) source_map: SourceMap,
host: Arc<Mutex<dyn Host + Send>>,
crate shell_manager: ShellManager,
pub(crate) shell_manager: ShellManager,
}
impl Context {
crate fn registry(&self) -> &CommandRegistry {
pub(crate) fn registry(&self) -> &CommandRegistry {
&self.registry
}
crate fn basic() -> Result<Context, Box<dyn Error>> {
pub(crate) fn basic() -> Result<Context, Box<dyn Error>> {
let registry = CommandRegistry::new();
Ok(Context {
registry: registry.clone(),
@ -93,7 +93,7 @@ impl Context {
})
}
crate fn with_host(&mut self, block: impl FnOnce(&mut dyn Host)) {
pub(crate) fn with_host(&mut self, block: impl FnOnce(&mut dyn Host)) {
let mut host = self.host.lock().unwrap();
block(&mut *host)
@ -109,15 +109,15 @@ impl Context {
self.source_map.insert(uuid, span_source);
}
crate fn has_command(&self, name: &str) -> bool {
pub(crate) fn has_command(&self, name: &str) -> bool {
self.registry.has(name)
}
crate fn get_command(&self, name: &str) -> Arc<Command> {
pub(crate) fn get_command(&self, name: &str) -> Arc<Command> {
self.registry.get_command(name).unwrap()
}
crate fn run_command<'a>(
pub(crate) fn run_command<'a>(
&mut self,
command: Arc<Command>,
name_span: Span,

4
src/env.rs
View File

@ -1,3 +1,3 @@
crate mod host;
pub(crate) mod host;
crate use self::host::Host;
pub(crate) use self::host::Host;

2
src/env/host.rs vendored
View File

@ -73,7 +73,7 @@ impl Host for BasicHost {
}
}
crate fn handle_unexpected<T>(
pub(crate) fn handle_unexpected<T>(
host: &mut dyn Host,
func: impl FnOnce(&mut dyn Host) -> Result<T, ShellError>,
) {

28
src/errors.rs
View File

@ -73,7 +73,7 @@ impl serde::de::Error for ShellError {
}
impl ShellError {
crate fn type_error(
pub(crate) fn type_error(
expected: impl Into<String>,
actual: Tagged<impl Into<String>>,
) -> ShellError {
@ -84,21 +84,21 @@ impl ShellError {
.start()
}
crate fn syntax_error(problem: Tagged<impl Into<String>>) -> ShellError {
pub(crate) fn syntax_error(problem: Tagged<impl Into<String>>) -> ShellError {
ProximateShellError::SyntaxError {
problem: problem.map(|p| p.into()),
}
.start()
}
crate fn invalid_command(problem: impl Into<Tag>) -> ShellError {
pub(crate) fn invalid_command(problem: impl Into<Tag>) -> ShellError {
ProximateShellError::InvalidCommand {
command: problem.into(),
}
.start()
}
crate fn coerce_error(
pub(crate) fn coerce_error(
left: Tagged<impl Into<String>>,
right: Tagged<impl Into<String>>,
) -> ShellError {
@ -109,11 +109,11 @@ impl ShellError {
.start()
}
crate fn missing_property(subpath: Description, expr: Description) -> ShellError {
pub(crate) fn missing_property(subpath: Description, expr: Description) -> ShellError {
ProximateShellError::MissingProperty { subpath, expr }.start()
}
crate fn missing_value(span: Option<Span>, reason: impl Into<String>) -> ShellError {
pub(crate) fn missing_value(span: Option<Span>, reason: impl Into<String>) -> ShellError {
ProximateShellError::MissingValue {
span,
reason: reason.into(),
@ -121,7 +121,7 @@ impl ShellError {
.start()
}
crate fn argument_error(
pub(crate) fn argument_error(
command: impl Into<String>,
kind: ArgumentError,
span: Span,
@ -134,7 +134,7 @@ impl ShellError {
.start()
}
crate fn parse_error(
pub(crate) fn parse_error(
error: nom::Err<(nom5_locate::LocatedSpan<&str>, nom::error::ErrorKind)>,
) -> ShellError {
use language_reporting::*;
@ -158,11 +158,11 @@ impl ShellError {
}
}
crate fn diagnostic(diagnostic: Diagnostic<Span>) -> ShellError {
pub(crate) fn diagnostic(diagnostic: Diagnostic<Span>) -> ShellError {
ProximateShellError::Diagnostic(ShellDiagnostic { diagnostic }).start()
}
crate fn to_diagnostic(self) -> Diagnostic<Span> {
pub(crate) fn to_diagnostic(self) -> Diagnostic<Span> {
match self.error {
ProximateShellError::String(StringError { title, .. }) => {
Diagnostic::new(Severity::Error, title)
@ -309,11 +309,11 @@ impl ShellError {
ProximateShellError::String(StringError::new(title.into(), Value::nothing())).start()
}
crate fn unimplemented(title: impl Into<String>) -> ShellError {
pub(crate) fn unimplemented(title: impl Into<String>) -> ShellError {
ShellError::string(&format!("Unimplemented: {}", title.into()))
}
crate fn unexpected(title: impl Into<String>) -> ShellError {
pub(crate) fn unexpected(title: impl Into<String>) -> ShellError {
ShellError::string(&format!("Unexpected: {}", title.into()))
}
}
@ -369,12 +369,12 @@ impl ToDebug for ProximateShellError {
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ShellDiagnostic {
crate diagnostic: Diagnostic<Span>,
pub(crate) diagnostic: Diagnostic<Span>,
}
impl ShellDiagnostic {
#[allow(unused)]
crate fn simple_diagnostic(
pub(crate) fn simple_diagnostic(
span: impl Into<Span>,
source: impl Into<String>,
) -> ShellDiagnostic {

6
src/evaluate/evaluator.rs
View File

@ -16,14 +16,14 @@ pub struct Scope {
}
impl Scope {
crate fn empty() -> Scope {
pub(crate) fn empty() -> Scope {
Scope {
it: Value::nothing().tagged_unknown(),
vars: IndexMap::new(),
}
}
crate fn it_value(value: Tagged<Value>) -> Scope {
pub(crate) fn it_value(value: Tagged<Value>) -> Scope {
Scope {
it: value,
vars: IndexMap::new(),
@ -31,7 +31,7 @@ impl Scope {
}
}
crate fn evaluate_baseline_expr(
pub(crate) fn evaluate_baseline_expr(
expr: &Expression,
registry: &CommandRegistry,
scope: &Scope,

4
src/evaluate/mod.rs
View File

@ -1,3 +1,3 @@
crate mod evaluator;
pub(crate) mod evaluator;
crate use evaluator::{evaluate_baseline_expr, Scope};
pub(crate) use evaluator::{evaluate_baseline_expr, Scope};

22
src/format.rs
View File

@ -1,21 +1,21 @@
crate mod entries;
crate mod generic;
crate mod list;
crate mod table;
crate mod vtable;
pub(crate) mod entries;
pub(crate) mod generic;
pub(crate) mod list;
pub(crate) mod table;
pub(crate) mod vtable;
use crate::prelude::*;
crate use entries::EntriesView;
pub(crate) use entries::EntriesView;
#[allow(unused)]
crate use generic::GenericView;
crate use table::TableView;
crate use vtable::VTableView;
pub(crate) use generic::GenericView;
pub(crate) use table::TableView;
pub(crate) use vtable::VTableView;
crate trait RenderView {
pub(crate) trait RenderView {
fn render_view(&self, host: &mut dyn Host) -> Result<(), ShellError>;
}
crate fn print_view(view: &impl RenderView, host: &mut dyn Host) -> Result<(), ShellError> {
pub(crate) fn print_view(view: &impl RenderView, host: &mut dyn Host) -> Result<(), ShellError> {
view.render_view(host)
}

2
src/format/entries.rs
View File

@ -14,7 +14,7 @@ pub struct EntriesView {
}
impl EntriesView {
crate fn from_value(value: &Value) -> EntriesView {
pub(crate) fn from_value(value: &Value) -> EntriesView {
let descs = value.data_descriptors();
let mut entries = vec![];

22
src/object.rs
View File

@ -1,13 +1,13 @@
crate mod base;
crate mod config;
crate mod dict;
crate mod files;
crate mod into;
crate mod meta;
crate mod process;
crate mod types;
pub(crate) mod base;
pub(crate) mod config;
pub(crate) mod dict;
pub(crate) mod files;
pub(crate) mod into;
pub(crate) mod meta;
pub(crate) mod process;
pub(crate) mod types;
#[allow(unused)]
crate use base::{Block, Primitive, Switch, Value};
crate use dict::{Dictionary, TaggedDictBuilder};
crate use files::dir_entry_dict;
pub(crate) use base::{Block, Primitive, Switch, Value};
pub(crate) use dict::{Dictionary, TaggedDictBuilder};
pub(crate) use files::dir_entry_dict;

54
src/object/base.rs
View File

@ -16,11 +16,11 @@ use std::time::SystemTime;
#[derive(Debug, Clone, Copy, Ord, PartialOrd, Eq, PartialEq, new, Serialize, Deserialize)]
pub struct OF64 {
crate inner: OrderedFloat<f64>,
pub(crate) inner: OrderedFloat<f64>,
}
impl OF64 {
crate fn into_inner(&self) -> f64 {
pub(crate) fn into_inner(&self) -> f64 {
self.inner.into_inner()
}
}
@ -49,7 +49,7 @@ pub enum Primitive {
}
impl Primitive {
crate fn type_name(&self) -> String {
pub(crate) fn type_name(&self) -> String {
use Primitive::*;
match self {
@ -67,7 +67,7 @@ impl Primitive {
.to_string()
}
crate fn debug(&self, f: &mut fmt::Formatter) -> fmt::Result {
pub(crate) fn debug(&self, f: &mut fmt::Formatter) -> fmt::Result {
use Primitive::*;
match self {
@ -130,16 +130,16 @@ impl Primitive {
#[derive(Debug, Ord, PartialOrd, Eq, PartialEq, Clone, new, Serialize)]
pub struct Operation {
crate left: Value,
crate operator: Operator,
crate right: Value,
pub(crate) left: Value,
pub(crate) operator: Operator,
pub(crate) right: Value,
}
#[derive(Debug, Ord, PartialOrd, Eq, PartialEq, Clone, Serialize, Deserialize, new)]
pub struct Block {
crate expressions: Vec<hir::Expression>,
crate source: Text,
crate span: Span,
pub(crate) expressions: Vec<hir::Expression>,
pub(crate) source: Text,
pub(crate) span: Span,
}
impl Block {
@ -209,7 +209,7 @@ impl fmt::Debug for ValueDebug<'a> {
}
impl Tagged<Value> {
crate fn tagged_type_name(&self) -> Tagged<String> {
pub(crate) fn tagged_type_name(&self) -> Tagged<String> {
let name = self.type_name();
Tagged::from_item(name, self.tag())
}
@ -319,13 +319,13 @@ impl std::convert::TryFrom<Option<&'a Tagged<Value>>> for Switch {
}
impl Tagged<Value> {
crate fn debug(&'a self) -> ValueDebug<'a> {
pub(crate) fn debug(&'a self) -> ValueDebug<'a> {
ValueDebug { value: self }
}
}
impl Value {
crate fn type_name(&self) -> String {
pub(crate) fn type_name(&self) -> String {
match self {
Value::Primitive(p) => p.type_name(),
Value::Object(_) => format!("object"),
@ -351,7 +351,7 @@ impl Value {
}
}
crate fn get_data_by_key(&'a self, name: &str) -> Option<&Tagged<Value>> {
pub(crate) fn get_data_by_key(&'a self, name: &str) -> Option<&Tagged<Value>> {
match self {
Value::Object(o) => o.get_data_by_key(name),
Value::List(l) => {
@ -374,7 +374,7 @@ impl Value {
}
#[allow(unused)]
crate fn get_data_by_index(&'a self, idx: usize) -> Option<&Tagged<Value>> {
pub(crate) fn get_data_by_index(&'a self, idx: usize) -> Option<&Tagged<Value>> {
match self {
Value::List(l) => l.iter().nth(idx),
_ => None,
@ -491,7 +491,7 @@ impl Value {
}
}
crate fn format_leaf(&self, desc: Option<&String>) -> String {
pub(crate) fn format_leaf(&self, desc: Option<&String>) -> String {
match self {
Value::Primitive(p) => p.format(desc),
Value::Block(b) => itertools::join(
@ -510,7 +510,7 @@ impl Value {
}
}
crate fn style_leaf(&self) -> &'static str {
pub(crate) fn style_leaf(&self) -> &'static str {
match self {
Value::Primitive(p) => p.style(),
_ => "",
@ -518,7 +518,7 @@ impl Value {
}
#[allow(unused)]
crate fn compare(&self, operator: &Operator, other: &Value) -> Result<bool, (String, String)> {
pub(crate) fn compare(&self, operator: &Operator, other: &Value) -> Result<bool, (String, String)> {
match operator {
_ => {
let coerced = coerce_compare(self, other)?;
@ -545,14 +545,14 @@ impl Value {
}
#[allow(unused)]
crate fn is_string(&self, expected: &str) -> bool {
pub(crate) fn is_string(&self, expected: &str) -> bool {
match self {
Value::Primitive(Primitive::String(s)) if s == expected => true,
other => false,
}
}
// crate fn as_pair(&self) -> Result<(Tagged<Value>, Tagged<Value>), ShellError> {
// pub(crate) fn as_pair(&self) -> Result<(Tagged<Value>, Tagged<Value>), ShellError> {
// match self {
// Value::List(list) if list.len() == 2 => Ok((list[0].clone(), list[1].clone())),
// other => Err(ShellError::string(format!(
@ -562,7 +562,7 @@ impl Value {
// }
// }
crate fn as_string(&self) -> Result<String, ShellError> {
pub(crate) fn as_string(&self) -> Result<String, ShellError> {
match self {
Value::Primitive(Primitive::String(s)) => Ok(s.clone()),
Value::Primitive(Primitive::Boolean(x)) => Ok(format!("{}", x)),
@ -577,7 +577,7 @@ impl Value {
}
}
crate fn as_i64(&self) -> Result<i64, ShellError> {
pub(crate) fn as_i64(&self) -> Result<i64, ShellError> {
match self {
Value::Primitive(Primitive::Int(i)) => Ok(*i),
Value::Primitive(Primitive::Bytes(b)) => Ok(*b as i64),
@ -589,7 +589,7 @@ impl Value {
}
}
crate fn is_true(&self) -> bool {
pub(crate) fn is_true(&self) -> bool {
match self {
Value::Primitive(Primitive::Boolean(true)) => true,
_ => false,
@ -640,7 +640,7 @@ impl Value {
}
impl Tagged<Value> {
crate fn as_path(&self) -> Result<PathBuf, ShellError> {
pub(crate) fn as_path(&self) -> Result<PathBuf, ShellError> {
match self.item() {
Value::Primitive(Primitive::Path(path)) => Ok(path.clone()),
other => Err(ShellError::type_error(
@ -651,7 +651,7 @@ impl Tagged<Value> {
}
}
crate fn select_fields(obj: &Value, fields: &[String], tag: impl Into<Tag>) -> Tagged<Value> {
pub(crate) fn select_fields(obj: &Value, fields: &[String], tag: impl Into<Tag>) -> Tagged<Value> {
let mut out = TaggedDictBuilder::new(tag);
let descs = obj.data_descriptors();
@ -666,7 +666,7 @@ crate fn select_fields(obj: &Value, fields: &[String], tag: impl Into<Tag>) -> T
out.into_tagged_value()
}
crate fn reject_fields(obj: &Value, fields: &[String], tag: impl Into<Tag>) -> Tagged<Value> {
pub(crate) fn reject_fields(obj: &Value, fields: &[String], tag: impl Into<Tag>) -> Tagged<Value> {
let mut out = TaggedDictBuilder::new(tag);
let descs = obj.data_descriptors();
@ -683,7 +683,7 @@ crate fn reject_fields(obj: &Value, fields: &[String], tag: impl Into<Tag>) -> T
}
#[allow(unused)]
crate fn find(obj: &Value, field: &str, op: &Operator, rhs: &Value) -> bool {
pub(crate) fn find(obj: &Value, field: &str, op: &Operator, rhs: &Value) -> bool {
let descs = obj.data_descriptors();
match descs.iter().find(|d| *d == field) {
None => false,

6
src/object/config.rs
View File

@ -22,14 +22,14 @@ struct Config {
extra: IndexMap<String, Tagged<Value>>,
}
crate fn config_path() -> Result<PathBuf, ShellError> {
pub(crate) fn config_path() -> Result<PathBuf, ShellError> {
let location = app_root(AppDataType::UserConfig, &APP_INFO)
.map_err(|err| ShellError::string(&format!("Couldn't open config file:\n{}", err)))?;
Ok(location.join("config.toml"))
}
crate fn write_config(config: &IndexMap<String, Tagged<Value>>) -> Result<(), ShellError> {
pub(crate) fn write_config(config: &IndexMap<String, Tagged<Value>>) -> Result<(), ShellError> {
let location = app_root(AppDataType::UserConfig, &APP_INFO)
.map_err(|err| ShellError::string(&format!("Couldn't open config file:\n{}", err)))?;
@ -45,7 +45,7 @@ crate fn write_config(config: &IndexMap<String, Tagged<Value>>) -> Result<(), Sh
Ok(())
}
crate fn config(span: impl Into<Span>) -> Result<IndexMap<String, Tagged<Value>>, ShellError> {
pub(crate) fn config(span: impl Into<Span>) -> Result<IndexMap<String, Tagged<Value>>, ShellError> {
let span = span.into();
let location = app_root(AppDataType::UserConfig, &APP_INFO)

4
src/object/dict.rs
View File

@ -79,7 +79,7 @@ impl Dictionary {
}
}
crate fn get_data_by_key(&self, name: &str) -> Option<&Tagged<Value>> {
pub(crate) fn get_data_by_key(&self, name: &str) -> Option<&Tagged<Value>> {
match self
.entries
.iter()
@ -90,7 +90,7 @@ impl Dictionary {
}
}
crate fn debug(&self, f: &mut fmt::Formatter) -> fmt::Result {
pub(crate) fn debug(&self, f: &mut fmt::Formatter) -> fmt::Result {
let mut debug = f.debug_struct("Dictionary");
for (desc, value) in self.entries.iter() {

2
src/object/files.rs
View File

@ -9,7 +9,7 @@ pub enum FileType {
Symlink,
}
crate fn dir_entry_dict(
pub(crate) fn dir_entry_dict(
filename: &std::path::Path,
metadata: &std::fs::Metadata,
tag: impl Into<Tag>,

6
src/object/meta.rs
View File

@ -87,7 +87,7 @@ impl<T> Tagged<T> {
Tagged::from_item(mapped, tag.clone())
}
crate fn copy_span<U>(&self, output: U) -> Tagged<U> {
pub(crate) fn copy_span<U>(&self, output: U) -> Tagged<U> {
let span = self.span();
Tagged::from_simple_spanned_item(output, span)
@ -224,8 +224,8 @@ impl Tag {
#[derive(Debug, Clone, Copy, PartialEq, Eq, Ord, PartialOrd, Serialize, Deserialize, Hash)]
pub struct Span {
crate start: usize,
crate end: usize,
pub(crate) start: usize,
pub(crate) end: usize,
}
impl From<Option<Span>> for Span {

2
src/object/process.rs
View File

@ -3,7 +3,7 @@ use crate::prelude::*;
use itertools::join;
use sysinfo::ProcessExt;
crate fn process_dict(proc: &sysinfo::Process, tag: impl Into<Tag>) -> Tagged<Value> {
pub(crate) fn process_dict(proc: &sysinfo::Process, tag: impl Into<Tag>) -> Tagged<Value> {
let mut dict = TaggedDictBuilder::new(tag);
let cmd = proc.cmd();

38
src/parser.rs
View File

@ -1,25 +1,25 @@
crate mod deserializer;
crate mod hir;
crate mod parse;
crate mod parse_command;
crate mod registry;
pub(crate) mod deserializer;
pub(crate) mod hir;
pub(crate) mod parse;
pub(crate) mod parse_command;
pub(crate) mod registry;
use crate::errors::ShellError;
crate use deserializer::ConfigDeserializer;
crate use hir::baseline_parse_tokens::baseline_parse_tokens;
crate use parse::call_node::CallNode;
crate use parse::files::Files;
crate use parse::flag::Flag;
crate use parse::operator::Operator;
crate use parse::parser::{nom_input, pipeline};
crate use parse::pipeline::{Pipeline, PipelineElement};
crate use parse::text::Text;
crate use parse::token_tree::{DelimitedNode, Delimiter, PathNode, TokenNode};
crate use parse::tokens::{RawToken, Token};
crate use parse::unit::Unit;
crate use parse_command::parse_command;
crate use registry::CommandRegistry;
pub(crate) use deserializer::ConfigDeserializer;
pub(crate) use hir::baseline_parse_tokens::baseline_parse_tokens;
pub(crate) use parse::call_node::CallNode;
pub(crate) use parse::files::Files;
pub(crate) use parse::flag::Flag;
pub(crate) use parse::operator::Operator;
pub(crate) use parse::parser::{nom_input, pipeline};
pub(crate) use parse::pipeline::{Pipeline, PipelineElement};
pub(crate) use parse::text::Text;
pub(crate) use parse::token_tree::{DelimitedNode, Delimiter, PathNode, TokenNode};
pub(crate) use parse::tokens::{RawToken, Token};
pub(crate) use parse::unit::Unit;
pub(crate) use parse_command::parse_command;
pub(crate) use registry::CommandRegistry;
pub fn parse(input: &str) -> Result<TokenNode, ShellError> {
let _ = pretty_env_logger::try_init();

42
src/parser/hir.rs
View File

@ -1,9 +1,9 @@
crate mod baseline_parse;
crate mod baseline_parse_tokens;
crate mod binary;
crate mod external_command;
crate mod named;
crate mod path;
pub(crate) mod baseline_parse;
pub(crate) mod baseline_parse_tokens;
pub(crate) mod binary;
pub(crate) mod external_command;
pub(crate) mod named;
pub(crate) mod path;
use crate::parser::{registry, Unit};
use crate::prelude::*;
@ -15,15 +15,15 @@ use std::path::PathBuf;
use crate::evaluate::Scope;
crate use self::baseline_parse::{
pub(crate) use self::baseline_parse::{
baseline_parse_single_token, baseline_parse_token_as_number, baseline_parse_token_as_path,
baseline_parse_token_as_string,
};
crate use self::baseline_parse_tokens::{baseline_parse_next_expr, TokensIterator};
crate use self::binary::Binary;
crate use self::external_command::ExternalCommand;
crate use self::named::NamedArguments;
crate use self::path::Path;
pub(crate) use self::baseline_parse_tokens::{baseline_parse_next_expr, TokensIterator};
pub(crate) use self::binary::Binary;
pub(crate) use self::external_command::ExternalCommand;
pub(crate) use self::named::NamedArguments;
pub(crate) use self::path::Path;
pub use self::baseline_parse_tokens::SyntaxType;
@ -129,51 +129,51 @@ impl RawExpression {
pub type Expression = Tagged<RawExpression>;
impl Expression {
crate fn int(i: impl Into<i64>, span: impl Into<Span>) -> Expression {
pub(crate) fn int(i: impl Into<i64>, span: impl Into<Span>) -> Expression {
Tagged::from_simple_spanned_item(RawExpression::Literal(Literal::Integer(i.into())), span)
}
crate fn size(i: impl Into<i64>, unit: impl Into<Unit>, span: impl Into<Span>) -> Expression {
pub(crate) fn size(i: impl Into<i64>, unit: impl Into<Unit>, span: impl Into<Span>) -> Expression {
Tagged::from_simple_spanned_item(
RawExpression::Literal(Literal::Size(i.into(), unit.into())),
span,
)
}
crate fn synthetic_string(s: impl Into<String>) -> Expression {
pub(crate) fn synthetic_string(s: impl Into<String>) -> Expression {
RawExpression::Synthetic(Synthetic::String(s.into())).tagged_unknown()
}
crate fn string(inner: impl Into<Span>, outer: impl Into<Span>) -> Expression {
pub(crate) fn string(inner: impl Into<Span>, outer: impl Into<Span>) -> Expression {
Tagged::from_simple_spanned_item(
RawExpression::Literal(Literal::String(inner.into())),
outer.into(),
)
}
crate fn file_path(path: impl Into<PathBuf>, outer: impl Into<Span>) -> Expression {
pub(crate) fn file_path(path: impl Into<PathBuf>, outer: impl Into<Span>) -> Expression {
Tagged::from_simple_spanned_item(RawExpression::FilePath(path.into()), outer.into())
}
crate fn bare(span: impl Into<Span>) -> Expression {
pub(crate) fn bare(span: impl Into<Span>) -> Expression {
Tagged::from_simple_spanned_item(RawExpression::Literal(Literal::Bare), span.into())
}
crate fn variable(inner: impl Into<Span>, outer: impl Into<Span>) -> Expression {
pub(crate) fn variable(inner: impl Into<Span>, outer: impl Into<Span>) -> Expression {
Tagged::from_simple_spanned_item(
RawExpression::Variable(Variable::Other(inner.into())),
outer.into(),
)
}
crate fn external_command(inner: impl Into<Span>, outer: impl Into<Span>) -> Expression {
pub(crate) fn external_command(inner: impl Into<Span>, outer: impl Into<Span>) -> Expression {
Tagged::from_simple_spanned_item(
RawExpression::ExternalCommand(ExternalCommand::new(inner.into())),
outer.into(),
)
}
crate fn it_variable(inner: impl Into<Span>, outer: impl Into<Span>) -> Expression {
pub(crate) fn it_variable(inner: impl Into<Span>, outer: impl Into<Span>) -> Expression {
Tagged::from_simple_spanned_item(
RawExpression::Variable(Variable::It(inner.into())),
outer.into(),

2
src/parser/hir/named.rs
View File

@ -19,7 +19,7 @@ pub enum NamedValue {
#[derive(Debug, Clone, Eq, PartialEq, Serialize, Deserialize, new)]
pub struct NamedArguments {
#[new(default)]
crate named: IndexMap<String, NamedValue>,
pub(crate) named: IndexMap<String, NamedValue>,
}
impl ToDebug for NamedArguments {

24
src/parser/parse.rs
View File

@ -1,12 +1,12 @@
crate mod call_node;
crate mod files;
crate mod flag;
crate mod operator;
crate mod parser;
crate mod pipeline;
crate mod text;
crate mod token_tree;
crate mod token_tree_builder;
crate mod tokens;
crate mod unit;
crate mod util;
pub(crate) mod call_node;
pub(crate) mod files;
pub(crate) mod flag;
pub(crate) mod operator;
pub(crate) mod parser;
pub(crate) mod pipeline;
pub(crate) mod text;
pub(crate) mod token_tree;
pub(crate) mod token_tree_builder;
pub(crate) mod tokens;
pub(crate) mod unit;
pub(crate) mod util;

4
src/parser/parse/pipeline.rs
View File

@ -5,8 +5,8 @@ use getset::Getters;
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, new)]
pub struct Pipeline {
crate parts: Vec<PipelineElement>,
crate post_ws: Option<Span>,
pub(crate) parts: Vec<PipelineElement>,
pub(crate) post_ws: Option<Span>,
}
#[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Getters, new)]

2
src/parser/parse/token_tree.rs
View File

@ -157,7 +157,7 @@ impl TokenNode {
}
}
crate fn as_flag(&self, value: &str, source: &Text) -> Option<Tagged<Flag>> {
pub(crate) fn as_flag(&self, value: &str, source: &Text) -> Option<Tagged<Flag>> {
match self {
TokenNode::Flag(
flag @ Tagged {

2
src/parser/parse/unit.rs
View File

@ -24,7 +24,7 @@ impl Unit {
}
}
crate fn compute(&self, size: i64) -> Value {
pub(crate) fn compute(&self, size: i64) -> Value {
Value::int(match self {
Unit::B => size,
Unit::KB => size * 1024,

14
src/parser/registry.rs
View File

@ -1,5 +1,5 @@
// TODO: Temporary redirect
crate use crate::context::CommandRegistry;
pub(crate) use crate::context::CommandRegistry;
use crate::evaluate::{evaluate_baseline_expr, Scope};
use crate::parser::{hir, hir::SyntaxType, parse_command, CallNode};
use crate::prelude::*;
@ -46,7 +46,7 @@ impl PositionalType {
}
#[allow(unused)]
crate fn to_coerce_hint(&self) -> Option<SyntaxType> {
pub(crate) fn to_coerce_hint(&self) -> Option<SyntaxType> {
match self {
PositionalType::Mandatory(_, SyntaxType::Block)
| PositionalType::Optional(_, SyntaxType::Block) => Some(SyntaxType::Block),
@ -54,14 +54,14 @@ impl PositionalType {
}
}
crate fn name(&self) -> &str {
pub(crate) fn name(&self) -> &str {
match self {
PositionalType::Mandatory(s, _) => s,
PositionalType::Optional(s, _) => s,
}
}
crate fn syntax_type(&self) -> SyntaxType {
pub(crate) fn syntax_type(&self) -> SyntaxType {
match *self {
PositionalType::Mandatory(_, t) => t,
PositionalType::Optional(_, t) => t,
@ -276,7 +276,7 @@ impl Iterator for PositionalIter<'a> {
}
impl Signature {
crate fn parse_args(
pub(crate) fn parse_args(
&self,
call: &Tagged<CallNode>,
context: &Context,
@ -290,12 +290,12 @@ impl Signature {
}
#[allow(unused)]
crate fn signature(&self) -> String {
pub(crate) fn signature(&self) -> String {
format!("TODO")
}
}
crate fn evaluate_args(
pub(crate) fn evaluate_args(
call: &hir::Call,
registry: &CommandRegistry,
scope: &Scope,

56
src/prelude.rs
View File

@ -47,37 +47,37 @@ macro_rules! trace_out_stream {
}};
}
crate use crate::cli::MaybeOwned;
crate use crate::commands::command::{
pub(crate) use crate::cli::MaybeOwned;
pub(crate) use crate::commands::command::{
CallInfo, CommandAction, CommandArgs, ReturnSuccess, ReturnValue, RunnableContext,
};
crate use crate::commands::PerItemCommand;
crate use crate::context::CommandRegistry;
crate use crate::context::{Context, SpanSource};
crate use crate::env::host::handle_unexpected;
crate use crate::env::Host;
crate use crate::errors::ShellError;
crate use crate::object::base as value;
crate use crate::object::meta::{Tag, Tagged, TaggedItem};
crate use crate::object::types::ExtractType;
crate use crate::object::{Primitive, Value};
crate use crate::parser::hir::SyntaxType;
crate use crate::parser::registry::Signature;
crate use crate::shell::filesystem_shell::FilesystemShell;
crate use crate::shell::shell_manager::ShellManager;
crate use crate::shell::value_shell::ValueShell;
crate use crate::stream::{InputStream, OutputStream};
crate use crate::traits::{HasSpan, ToDebug};
crate use crate::Span;
crate use crate::Text;
crate use futures::stream::BoxStream;
crate use futures::{FutureExt, Stream, StreamExt};
crate use futures_async_stream::async_stream_block;
pub(crate) use crate::commands::PerItemCommand;
pub(crate) use crate::context::CommandRegistry;
pub(crate) use crate::context::{Context, SpanSource};
pub(crate) use crate::env::host::handle_unexpected;
pub(crate) use crate::env::Host;
pub(crate) use crate::errors::ShellError;
pub(crate) use crate::object::base as value;
pub(crate) use crate::object::meta::{Tag, Tagged, TaggedItem};
pub(crate) use crate::object::types::ExtractType;
pub(crate) use crate::object::{Primitive, Value};
pub(crate) use crate::parser::hir::SyntaxType;
pub(crate) use crate::parser::registry::Signature;
pub(crate) use crate::shell::filesystem_shell::FilesystemShell;
pub(crate) use crate::shell::shell_manager::ShellManager;
pub(crate) use crate::shell::value_shell::ValueShell;
pub(crate) use crate::stream::{InputStream, OutputStream};
pub(crate) use crate::traits::{HasSpan, ToDebug};
pub(crate) use crate::Span;
pub(crate) use crate::Text;
pub(crate) use futures::stream::BoxStream;
pub(crate) use futures::{FutureExt, Stream, StreamExt};
pub(crate) use futures_async_stream::async_stream_block;
#[allow(unused)]
crate use serde::{Deserialize, Serialize};
crate use std::collections::VecDeque;
crate use std::future::Future;
crate use std::sync::{Arc, Mutex};
pub(crate) use serde::{Deserialize, Serialize};
pub(crate) use std::collections::VecDeque;
pub(crate) use std::future::Future;
pub(crate) use std::sync::{Arc, Mutex};
pub trait FromInputStream {
fn from_input_stream(self) -> OutputStream;

14
src/shell.rs
View File

@ -1,8 +1,8 @@
crate mod completer;
crate mod filesystem_shell;
crate mod helper;
crate mod shell;
crate mod shell_manager;
crate mod value_shell;
pub(crate) mod completer;
pub(crate) mod filesystem_shell;
pub(crate) mod helper;
pub(crate) mod shell;
pub(crate) mod shell_manager;
pub(crate) mod value_shell;
crate use helper::Helper;
pub(crate) use helper::Helper;

2
src/shell/completer.rs
View File

@ -3,7 +3,7 @@ use derive_new::new;
use rustyline::completion::{Completer, FilenameCompleter};
#[derive(new)]
crate struct NuCompleter {
pub(crate) struct NuCompleter {
pub file_completer: FilenameCompleter,
pub commands: CommandRegistry,
}

2
src/shell/filesystem_shell.rs
View File

@ -14,7 +14,7 @@ use rustyline::hint::{Hinter, HistoryHinter};
use std::path::{Path, PathBuf};
pub struct FilesystemShell {
crate path: String,
pub(crate) path: String,
completer: NuCompleter,
hinter: HistoryHinter,
}

4
src/shell/helper.rs
View File

@ -11,12 +11,12 @@ use rustyline::highlight::Highlighter;
use rustyline::hint::Hinter;
use std::borrow::Cow::{self, Owned};
crate struct Helper {
pub(crate) struct Helper {
helper: ShellManager,
}
impl Helper {
crate fn new(helper: ShellManager) -> Helper {
pub(crate) fn new(helper: ShellManager) -> Helper {
Helper { helper }
}
}

4
src/shell/shell_manager.rs
View File

@ -14,8 +14,8 @@ use std::sync::{Arc, Mutex};
#[derive(Clone, Debug)]
pub struct ShellManager {
crate current_shell: usize,
crate shells: Arc<Mutex<Vec<Box<dyn Shell + Send>>>>,
pub(crate) current_shell: usize,
pub(crate) shells: Arc<Mutex<Vec<Box<dyn Shell + Send>>>>,
}
impl ShellManager {

4
src/shell/value_shell.rs
View File

@ -11,8 +11,8 @@ use std::path::PathBuf;
#[derive(Clone, Debug)]
pub struct ValueShell {
crate path: String,
crate value: Tagged<Value>,
pub(crate) path: String,
pub(crate) value: Tagged<Value>,
}
impl ValueShell {

4
src/stream.rs
View File

@ -1,7 +1,7 @@
use crate::prelude::*;
pub struct InputStream {
crate values: BoxStream<'static, Tagged<Value>>,
pub(crate) values: BoxStream<'static, Tagged<Value>>,
}
impl InputStream {
@ -49,7 +49,7 @@ impl From<Vec<Tagged<Value>>> for InputStream {
}
pub struct OutputStream {
crate values: BoxStream<'static, ReturnValue>,
pub(crate) values: BoxStream<'static, ReturnValue>,
}
impl OutputStream {