rename set_x functions with just x

README.md

@@ -25,16 +25,16 @@ hial 'http://api.github.com^http^json/rate_limit_url^http^json/resources/core'
 
 ```bash
 hial './myfile.json^json/question[count(/answer_entities/*)==0]'
-# 🚧 wip: functions: sum, count, min, max
+# 🚧 todo: functions: sum, count, min, max
 ``` -->
 
 Print all services with inaccessible images in a Docker compose file:
 
 ```bash
 # shell
 hial './config.yaml^yaml/services/*[ /image^split[":"]/[0]^http[HEAD]@status/code>=400 ]'
-# 🚧 wip: split interpretation (regex[( ([^:]*): )*]
-# 🚧 wip: HEAD param for http
+# 🚧 todo: split interpretation (regex[( ([^:]*): )*]
+# 🚧 todo: HEAD param for http
 ```
 
 ```rust
@@ -54,38 +54,38 @@ Print the structure of a rust file (struct, enum, type, functions) as a tree:
 
 ```bash
 hial './src/tests/rust.rs^rust/**[#type^split["_"]/[-1]=="item"]/*[name|parameters|return_type]'
-# 🚧 wip: search results as tree
+# 🚧 todo: search results as tree
 ```
 
 ##### 2. Modify data selected as above.
 
 Change the default mysql port systemwide:
 ```bash
 # shell
-hial '/etc/mysql/my.cnf^fs[rw]^ini/mysqld/port = 3307'
-# 🚧 wip: rw parameter for fs interpretation
+hial '/etc/mysql/my.cnf^fs[w]^ini/mysqld/port = 3307'
+# 🚧 todo: rw parameter for fs interpretation
 ```
 
 ```bash
 // rust
 Cell::from("/etc/mysql/my.cnf")
-    .to("^fs[rw]^ini/mysqld/port")
+    .to("^fs[w]^ini/mysqld/port")
     .write()
-    .set_value(3307)?;
+    .value(3307)?;
 ```
 
 Change the user's docker configuration:
 ```bash
 # shell
 hial '~/.docker/config.json^json/auths/docker.io/username = "newuser"'
-# 🚧 wip: support ~
+# 🚧 todo: support ~
 ```
 ```rust
 // rust
 Cell::from("~/.docker/config.json")
-    .to("^fs[rw]^json/auths/docker.io/username")
+    .to("^fs[w]^json/auths/docker.io/username")
     .write()
-    .set_value("newuser")?;
+    .value("newuser")?;
 ```
 
 ##### 3. Copy pieces of data from one place to another.
@@ -94,19 +94,20 @@ Copy a string from some json object entry which is embedded in a zip file, into
 
 ```bash
 # shell
-hial 'copy( ./assets.zip^zip/data.json^json/meshes/sphere  ./src/assets/sphere.rs^rust/**[:let_declaration][/pattern=sphere]/value )'
-# 🚧 wip: support copy
-# 🚧 wip: support zip
-# 🚧 wip: support :type filter
-# 🚧 wip: /**[filter] should match leaves only
+hial 'copy ./assets.zip^zip/data.json^json/meshes/sphere  ./src/assets/sphere.rs^rust/**[#type=="let_declaration"][/pattern=sphere]/value'
+# 🚧 todo: support copy
+# 🚧 todo: support zip
+# 🚧 todo: /**[filter] should match leaves only
 ```
 
 Split a markdown file into sections and put each in a separate file:
 
 ```bash
 # shell
-`hial 'copy  ./book.md^md/*[:heading1][as x]  ./{label(x)}.md'
-# 🚧 wip: support markdown
+`hial 'copy  ./book.md^md/*[#type=="heading1"][as x]  ./{label(x)}.md'
+# 🚧 todo: support copy
+# 🚧 todo: support markdown
+# 🚧 todo: support interpolation in destination
 ```
 
 ##### 4. Transform data from one format or shape into another.
@@ -116,7 +117,8 @@ Transform a json file into an xml file with the same format and vice versa:
 ```bash
 hial 'copy  file.json^json^tree^xml  ./file.xml'
 hial 'copy  file.xml^xml^tree^json  ./file.json'
-# 🚧 wip: support tree implementation and conversion
+# 🚧 todo: support copy
+# 🚧 todo: support tree implementation and conversion
 ```
 
 ##### 5. Structured diffs
@@ -125,7 +127,8 @@ Compare two files in different formats and print the resulting diff tree:
 
 ```bash
 hial 'diff  ./file.json^json^tree  ./file.xml^xml^tree'
-# 🚧 wip: support diff
+# 🚧 todo: support diff
+# 🚧 todo: support tree implementation and conversion
 ```
 
 ## Installation and usage
@@ -154,7 +157,7 @@ Cell: value = String("{\"a\":1}"),
 
 3. a json object which is represented by a tree of cells, the root cell being the json object `{}` with a sub cell with label `a` and value `1`:
 
-```json
+```yaml
 Cell:
     type: "object",
     sub:

doc/issues.md

@@ -1,23 +1,21 @@
 # List of Todos and other Issues
 
-- replace set_value(x) with value(x)
+- support type selector: `hial './src/tests/rust.rs^rust/*[:function_item]'`
 - add split(":") and regex interpretations
-- /*[type().ends_with()] ?? -> or not, just replace it with #type^split("_")/[-1]=="xx"
 - /*[name|parameters|return_type] ??
-- ^fs[rw] ??
-- should blobs/bytes be part of value? they are only useful by reinterpretation
+- ^fs[w] ??
 - set value on the command line: '/username = "newuser"'
 - https://raw.githubusercontent.com/rust-lang/rust/master/src/tools/rustfmt/src/lib.rs^http^rust does not work
 - support zip, markdown
 - support 'copy source destination'
 - support ^json^tree^xml
 - support diff  ./file.json^json^tree  ./file.xml^xml^tree
 - '**[filter]' must be work as '**/*[filter]' (filter to be applied only on leaves)
-- support type selector: `hial './src/tests/rust.rs^rust/*[:function_item]'`
 - support rust/ts write: `hial './src/tests/rust.rs^rust/*[:function_item].label = "modified_fn_name"'`
 - new structure: /api, /api/impl, /interpretations/api, /interpretations/*, /search
 - add http interpretation params: method=HEAD, accept=""
 - functions
+- should blobs/bytes be part of value? they are only useful by reinterpretation
 
 - release first minimal version:
     - interpretations: path+fs, json+yaml+toml+xml, rust+js, url?+http

src/base/elevation.rs

@@ -90,8 +90,8 @@ fn elevation_map(interpretation: &str) -> Res<Arc<IndexMap<&'static str, Elevate
     nores()
 }
 
-pub(crate) fn top_interpretation(cell: &Cell) -> Option<&str> {
-    if cell.interpretation() == "fs" && cell.read().ty().ok()? == "fs" {
+pub(crate) fn auto_interpretation(cell: &Cell) -> Option<&str> {
+    if cell.interpretation() == "fs" && cell.read().ty().ok()? == "file" {
         if let Ok(reader) = cell.read().err() {
             if let Ok(Value::Str(name)) = reader.label() {
                 if name.ends_with(".c") {
@@ -158,7 +158,7 @@ impl ElevationGroup {
     pub fn get(&self, key: Value) -> Res<Cell> {
         let old_interp = self.0.interpretation();
         let interp = match key {
-            Value::None => guard_some!(top_interpretation(&self.0), {
+            Value::None => guard_some!(auto_interpretation(&self.0), {
                 return nores();
             }),
             Value::Str(k) => k,

src/base/error.rs

@@ -245,7 +245,7 @@ impl CellReaderTrait for HErr {
 }
 
 impl CellWriterTrait for HErr {
-    fn set_value(&mut self, value: OwnValue) -> Res<()> {
+    fn value(&mut self, value: OwnValue) -> Res<()> {
         Err(self.clone())
     }
 }

src/base/extra.rs

@@ -268,14 +268,14 @@ impl CellReader {
 }
 
 impl CellWriterTrait for CellWriter {
-    fn set_label(&mut self, value: OwnValue) -> Res<()> {
+    fn label(&mut self, value: OwnValue) -> Res<()> {
         self.domain.dirty.set(true);
-        dispatch_dyn_cell_writer!(&mut self.dyn_cell_writer, |x| { x.set_label(value) })
+        dispatch_dyn_cell_writer!(&mut self.dyn_cell_writer, |x| { x.label(value) })
     }
 
-    fn set_value(&mut self, ov: OwnValue) -> Res<()> {
+    fn value(&mut self, ov: OwnValue) -> Res<()> {
         self.domain.dirty.set(true);
-        dispatch_dyn_cell_writer!(&mut self.dyn_cell_writer, |x| { x.set_value(ov) })
+        dispatch_dyn_cell_writer!(&mut self.dyn_cell_writer, |x| { x.value(ov) })
     }
 }
 impl CellWriter {
@@ -372,11 +372,11 @@ impl Cell {
         }
     }
 
-    pub fn top_interpretation(&self) -> Option<&str> {
+    pub fn auto_interpretation(&self) -> Option<&str> {
         if let DynCell::Error(_) = self.dyn_cell {
             return None;
         }
-        elevation::top_interpretation(self)
+        elevation::auto_interpretation(self)
     }
 
     pub fn elevate(&self) -> Group {
@@ -666,7 +666,7 @@ impl Cell {
 
     fn save_from_to(dyn_cell: &DynCell, target: &Cell) -> Res<()> {
         let serial = dispatch_dyn_cell!(dyn_cell, |x| { x.read()?.serial()? });
-        target.write().set_value(OwnValue::String(serial))
+        target.write().value(OwnValue::String(serial))
     }
 }
 

src/base/field.rs

@@ -185,10 +185,10 @@ impl CellReaderTrait for FieldReader {
 }
 
 impl CellWriterTrait for FieldWriter {
-    fn set_value(&mut self, value: OwnValue) -> Res<()> {
+    fn value(&mut self, value: OwnValue) -> Res<()> {
         match self.ty {
-            FieldType::Value => self.writer.set_value(value),
-            FieldType::Label => self.writer.set_label(value),
+            FieldType::Value => self.writer.value(value),
+            FieldType::Label => self.writer.label(value),
             FieldType::Type => userres("cannot change cell type"),
             FieldType::Index => self.writer.set_index(value),
             FieldType::Serial => self.writer.set_serial(value),

src/base/intra.rs

@@ -44,11 +44,11 @@ pub trait CellWriterTrait: Debug {
         todo!() // TODO: remove this default implementation
     }
 
-    fn set_label(&mut self, value: OwnValue) -> Res<()> {
+    fn label(&mut self, value: OwnValue) -> Res<()> {
         todo!() // TODO: remove this default implementation
     }
 
-    fn set_value(&mut self, value: OwnValue) -> Res<()>;
+    fn value(&mut self, value: OwnValue) -> Res<()>;
 
     fn set_serial(&mut self, value: OwnValue) -> Res<()> {
         todo!() // TODO: remove this default implementation

src/base/value.rs

@@ -6,6 +6,7 @@ use core::{
 use std::borrow::{Borrow, Cow};
 
 pub const DISPLAY_VALUE_NONE: &str = "ø"; // ❍•⸰·
+pub const DISPLAY_BYTES_VALUE_LEN: usize = 72;
 
 #[derive(Copy, Clone, Debug)]
 pub enum Int {
@@ -174,7 +175,11 @@ impl<'a> Display for Value<'a> {
             Value::Float(x) => write!(buf, "{}", x),
             Value::Str(x) => write!(buf, "{}", x),
             // Value::OsStr(x) => write!(buf, "{}", x.to_string_lossy()),
-            Value::Bytes(x) => write!(buf, "{}", String::from_utf8_lossy(x)),
+            Value::Bytes(x) => {
+                write!(buf, "⟨")?;
+                write_bytes(buf, x)?;
+                write!(buf, "⟩")
+            }
         }
     }
 }
@@ -189,18 +194,32 @@ impl<'a> fmt::Debug for Value<'a> {
             Value::Str(x) => write!(buf, "Value::Str({:?})", x),
             // Value::OsStr(x) => write!(buf, "{}", x.to_string_lossy()),
             Value::Bytes(x) => {
-                let sb = String::from_utf8_lossy(x);
-                let s = sb.as_ref();
-                if s.len() > 120 {
-                    write!(buf, "Value::Bytes(len {}, \"{}\"...)", s.len(), &s[..120])
-                } else {
-                    write!(buf, "Value::Bytes(len {}, \"{}\")", s.len(), s)
-                }
+                write!(buf, "Value::Bytes(len {}, \"", x.len())?;
+                write_bytes(buf, x)?;
+                write!(buf, "\")")
             }
         }
     }
 }
 
+fn write_bytes(buf: &mut fmt::Formatter, x: &[u8]) -> fmt::Result {
+    let sb = String::from_utf8_lossy(x);
+    let s = sb.as_ref();
+    let not_ascii = |c| !(' '..='~').contains(&c);
+    if s.contains(not_ascii) {
+        let s = s.replace(not_ascii, ".");
+        if s.len() > DISPLAY_BYTES_VALUE_LEN {
+            write!(buf, "{}", &s[..DISPLAY_BYTES_VALUE_LEN])
+        } else {
+            write!(buf, "{}", s)
+        }
+    } else if s.len() > DISPLAY_BYTES_VALUE_LEN {
+        write!(buf, "{}", &s[..DISPLAY_BYTES_VALUE_LEN])
+    } else {
+        write!(buf, "{}", s)
+    }
+}
+
 impl<T> PartialEq<T> for Value<'_>
 where
     T: Borrow<str>,

src/interpretations/fs.rs

@@ -34,7 +34,7 @@ pub(crate) struct CellReader {
     files: ReadRc<FileList>,
     ty: GroupType,
     pos: u32,
-    cached_value: OnceCell<String>,
+    cached_value: OnceCell<Box<[u8]>>,
 }
 
 #[derive(Debug)]
@@ -129,12 +129,13 @@ impl CellReaderTrait for CellReader {
                     let content = std::fs::read(&fe.path).map_err(|e| {
                         caused(HErrKind::IO, format!("cannot read file: {:?}", fe.path), e)
                     })?;
-                    let content = String::from_utf8_lossy(&content);
+                    // let content = String::from_utf8_lossy(&content);
                     self.cached_value
-                        .set(content.into_owned())
+                        .set(content.into_boxed_slice())
                         .map_err(|_| faulterr("cannot set cached value, it is already set"))?;
                 }
-                Ok(Value::Str(self.cached_value.get().unwrap()))
+                // Ok(Value::Str(self.cached_value.get().unwrap()))
+                Ok(Value::Bytes(self.cached_value.get().unwrap()))
             }
             GroupType::FileAttributes(fpos) => {
                 if self.pos != 0 {
@@ -171,7 +172,7 @@ impl CellReader {
 }
 
 impl CellWriterTrait for CellWriter {
-    fn set_value(&mut self, value: OwnValue) -> Res<()> {
+    fn value(&mut self, value: OwnValue) -> Res<()> {
         let string_value = value.to_string();
         let fe = self.fileentry()?;
         let md = fe.metadata.as_ref().map_err(|e| e.clone())?;

src/interpretations/http.rs

@@ -244,7 +244,7 @@ impl CellReaderTrait for CellReader {
 }
 
 impl CellWriterTrait for CellWriter {
-    fn set_value(&mut self, value: OwnValue) -> Res<()> {
+    fn value(&mut self, value: OwnValue) -> Res<()> {
         fault("set_value not yet implemented for http")
     }
 }

src/interpretations/json.rs

@@ -285,7 +285,7 @@ impl CellReaderTrait for CellReader {
 }
 
 impl CellWriterTrait for CellWriter {
-    fn set_label(&mut self, label: OwnValue) -> Res<()> {
+    fn label(&mut self, label: OwnValue) -> Res<()> {
         match self.nodes {
             WriteNodeGroup::Array(_) => {
                 return userres("cannot set label on array object");
@@ -300,7 +300,7 @@ impl CellWriterTrait for CellWriter {
         };
         Ok(())
     }
-    fn set_value(&mut self, value: OwnValue) -> Res<()> {
+    fn value(&mut self, value: OwnValue) -> Res<()> {
         match self.nodes {
             WriteNodeGroup::Array(ref mut a) => {
                 a[self.pos] = Node::Scalar(ownvalue_to_serde(value));

src/interpretations/ownvalue.rs

@@ -48,7 +48,7 @@ impl CellReaderTrait for CellReader {
 }
 
 impl CellWriterTrait for CellWriter {
-    fn set_value(&mut self, value: OwnValue) -> Res<()> {
+    fn value(&mut self, value: OwnValue) -> Res<()> {
         *self.0 = value;
         Ok(())
     }

src/interpretations/path.rs

@@ -87,7 +87,7 @@ impl CellReader {
 }
 
 impl CellWriterTrait for CellWriter {
-    fn set_value(&mut self, value: OwnValue) -> Res<()> {
+    fn value(&mut self, value: OwnValue) -> Res<()> {
         match value {
             OwnValue::String(s) => {
                 *(self.0) = PathBuf::from(s);