automerge-rb 0.1.1

data/vendor/automerge-rust/hexane/src/slab.rs

@@ -0,0 +1,224 @@
+use super::aggregate::{Acc, Agg};
+use super::cursor::{ColumnCursor, HasAcc, HasPos, RunIter};
+use super::Cow;
+
+pub mod tree;
+pub(crate) mod writer;
+
+pub(crate) use super::columndata::normalize_range;
+pub(crate) use tree::SpanTreeIterState;
+pub use tree::{SpanTree, SpanTreeIter, SpanWeight};
+pub use writer::{SlabWriter, WriteOp};
+
+pub type SlabTree<W> = SpanTree<Slab, W>;
+
+use std::fmt::Debug;
+use std::ops::{Index, Range};
+use std::sync::Arc;
+
+#[derive(Debug, Default, Clone, PartialEq)]
+pub struct Slab {
+    data: Arc<Vec<u8>>,
+    //data: Vec<u8>,
+    len: usize,
+    acc: Acc,
+    min: Agg,
+    max: Agg,
+    abs: i64,
+}
+
+impl Index<Range<usize>> for Slab {
+    type Output = [u8];
+
+    fn index(&self, index: Range<usize>) -> &Self::Output {
+        &self.data[index]
+    }
+}
+
+impl Slab {
+    pub(crate) fn new(data: Vec<u8>, len: usize, acc: Acc, abs: i64) -> Self {
+        let data = Arc::new(data);
+        Slab {
+            data,
+            len,
+            acc,
+            abs,
+            min: Agg::default(),
+            max: Agg::default(),
+        }
+    }
+
+    pub fn set_min_max(&mut self, new_min: Agg, new_max: Agg) {
+        self.min = new_min;
+        self.max = new_max;
+    }
+
+    pub fn abs(&self) -> i64 {
+        self.abs
+    }
+
+    pub fn max(&self) -> Agg {
+        self.max
+    }
+
+    pub fn min(&self) -> Agg {
+        self.min
+    }
+
+    pub fn first_value<C: ColumnCursor>(&self) -> Option<Cow<'_, C::Item>> {
+        let mut cursor = C::new(self);
+        let run = cursor.next(self.as_slice())?;
+        run.value
+    }
+
+    pub fn run_iter<C: ColumnCursor>(&self) -> RunIter<'_, C> {
+        let weight = <C::SlabIndex>::alloc(self);
+        RunIter {
+            slab: self.as_slice(),
+            cursor: C::new(self),
+            pos_left: weight.pos(),
+            acc_left: weight.acc(),
+        }
+    }
+
+    pub fn as_slice(&self) -> &[u8] {
+        &self.data
+    }
+
+    pub fn byte_len(&self) -> usize {
+        self.data.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    pub fn len(&self) -> usize {
+        self.len
+    }
+
+    pub fn acc(&self) -> Acc {
+        self.acc
+    }
+}
+
+#[derive(Debug, PartialEq, Clone, Copy, Default)]
+pub struct SlabWeight {
+    pub(crate) pos: usize,
+    pub(crate) acc: Acc,
+    pub(crate) min: Agg,
+    pub(crate) max: Agg,
+}
+
+impl SpanWeight<Slab> for SlabWeight {
+    fn alloc(span: &Slab) -> Self {
+        SlabWeight {
+            pos: span.len(),
+            acc: span.acc(),
+            min: span.min(),
+
+            max: span.max(),
+        }
+    }
+
+    fn and(self, b: &Self) -> Self {
+        Self {
+            pos: self.pos + b.pos,
+            acc: self.acc + b.acc,
+            max: self.max.maximize(b.max),
+            min: self.min.minimize(b.min),
+        }
+    }
+
+    fn union(&mut self, other: &Self) {
+        self.pos += other.pos;
+        self.acc += other.acc;
+        self.max = self.max.maximize(other.max);
+        self.min = self.min.minimize(other.min);
+    }
+
+    fn maybe_sub(&mut self, other: &Self) -> bool {
+        let max_ok = other.max.is_none() || self.max > other.max;
+        let min_ok = other.min.is_none() || self.min.is_some() && self.min < other.min;
+        if max_ok && min_ok {
+            self.pos -= other.pos;
+            self.acc -= other.acc;
+            true
+        } else {
+            false
+        }
+    }
+}
+
+#[cfg(test)]
+pub(crate) mod tests {
+    use super::*;
+
+    #[test]
+    fn test_maybe_sub() {
+        let baseline = SlabWeight {
+            pos: 100,
+            acc: Acc::from(100),
+            min: Agg::from(2),
+            max: Agg::from(20),
+        };
+
+        let max_eq = SlabWeight {
+            pos: 50,
+            acc: Acc::from(50),
+            min: Agg::from(3),
+            max: Agg::from(20),
+        };
+        let max_gr = SlabWeight {
+            pos: 50,
+            acc: Acc::from(50),
+            min: Agg::from(3),
+            max: Agg::from(21),
+        };
+        let max_lt = SlabWeight {
+            pos: 50,
+            acc: Acc::from(50),
+            min: Agg::from(3),
+            max: Agg::from(19),
+        };
+        let max_none = SlabWeight {
+            pos: 50,
+            acc: Acc::from(50),
+            min: Agg::from(3),
+            max: Agg::from(0),
+        };
+        assert!(!baseline.clone().maybe_sub(&max_eq));
+        assert!(!baseline.clone().maybe_sub(&max_gr));
+        assert!(baseline.clone().maybe_sub(&max_lt));
+        assert!(baseline.clone().maybe_sub(&max_none));
+
+        let min_eq = SlabWeight {
+            pos: 50,
+            acc: Acc::from(50),
+            min: Agg::from(2),
+            max: Agg::from(19),
+        };
+        let min_gr = SlabWeight {
+            pos: 50,
+            acc: Acc::from(50),
+            min: Agg::from(3),
+            max: Agg::from(19),
+        };
+        let min_lt = SlabWeight {
+            pos: 50,
+            acc: Acc::from(50),
+            min: Agg::from(1),
+            max: Agg::from(19),
+        };
+        let min_none = SlabWeight {
+            pos: 50,
+            acc: Acc::from(50),
+            min: Agg::from(0),
+            max: Agg::from(19),
+        };
+        assert!(!baseline.clone().maybe_sub(&min_eq));
+        assert!(baseline.clone().maybe_sub(&min_gr));
+        assert!(!baseline.clone().maybe_sub(&min_lt));
+        assert!(baseline.clone().maybe_sub(&min_none));
+    }
+}

data/vendor/automerge-rust/hexane/src/test.rs

@@ -0,0 +1,108 @@
+use super::boolean::BooleanCursorInternal;
+use super::cursor::{ColumnCursor, Run};
+use super::delta::DeltaCursorInternal;
+use super::pack::Packable;
+use super::raw::RawCursorInternal;
+use super::rle::RleCursor;
+use crate::ColumnData;
+use std::borrow::Borrow;
+
+pub(crate) trait TestDumpable<T: Packable + ?Sized> {
+    fn test_dump(data: &[u8]) -> Vec<ColExport<T>>;
+}
+
+impl<const B: usize, P: Packable + ?Sized> TestDumpable<P> for RleCursor<B, P> {
+    fn test_dump(data: &[u8]) -> Vec<ColExport<P>> {
+        let mut cursor = Self::default();
+        let mut current = None;
+        let mut result = vec![];
+        while let Some(run) = cursor.next(data) {
+            match run {
+                Run { count, value: None } => {
+                    if let Some(run) = current.take() {
+                        result.push(ColExport::litrun(run))
+                    }
+                    result.push(ColExport::Null(count))
+                }
+                Run {
+                    count: 1,
+                    value: Some(v),
+                } => {
+                    if cursor.num_left() == 0 {
+                        let mut run = current.take().unwrap_or_default();
+                        run.push(v);
+                        result.push(ColExport::litrun(run))
+                    } else if let Some(run) = &mut current {
+                        run.push(v);
+                    } else {
+                        current = Some(vec![v]);
+                    }
+                }
+                Run {
+                    count,
+                    value: Some(v),
+                } => {
+                    if let Some(run) = current.take() {
+                        result.push(ColExport::litrun(run))
+                    }
+                    result.push(ColExport::run(count, v))
+                }
+            }
+        }
+        if let Some(run) = current.take() {
+            result.push(ColExport::litrun(run))
+        }
+        result
+    }
+}
+
+impl<const B: usize> TestDumpable<bool> for BooleanCursorInternal<B> {
+    fn test_dump(data: &[u8]) -> Vec<ColExport<bool>> {
+        let mut result = vec![];
+        let mut cursor = Self::default();
+        while let Ok(Some(Run { count, value })) = cursor.try_next(data) {
+            if count > 0 {
+                result.push(ColExport::Run(count, *value.unwrap()))
+            }
+        }
+        result
+    }
+}
+impl<const B: usize> TestDumpable<i64> for DeltaCursorInternal<B> {
+    fn test_dump(data: &[u8]) -> Vec<ColExport<i64>> {
+        super::delta::SubCursor::<B>::test_dump(data)
+    }
+}
+
+impl<const B: usize> TestDumpable<[u8]> for RawCursorInternal<B> {
+    fn test_dump(data: &[u8]) -> Vec<ColExport<[u8]>> {
+        vec![ColExport::Raw(data.to_vec())]
+    }
+}
+
+#[allow(private_bounds)]
+impl<C: ColumnCursor + TestDumpable<<C as ColumnCursor>::Item>> ColumnData<C> {
+    pub(crate) fn test_dump(&self) -> Vec<Vec<ColExport<C::Item>>> {
+        self.slabs
+            .iter()
+            .map(|s| <C as TestDumpable<C::Item>>::test_dump(s.as_slice()))
+            .collect()
+    }
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) enum ColExport<P: Packable + ?Sized> {
+    LitRun(Vec<P::Owned>),
+    Run(usize, P::Owned),
+    Raw(Vec<u8>),
+    Null(usize),
+}
+
+impl<P: Packable + ?Sized> ColExport<P> {
+    pub(crate) fn litrun<X: Borrow<P>>(items: Vec<X>) -> Self {
+        Self::LitRun(items.into_iter().map(|i| i.borrow().to_owned()).collect())
+    }
+    pub(crate) fn run<X: Borrow<P>>(count: usize, item: X) -> Self {
+        Self::Run(count, item.borrow().to_owned())
+    }
+}

data/vendor/bundle/ruby/3.3.0/bin/rake

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by RubyGems.
+#
+# The application 'rake' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'rubygems'
+
+Gem.use_gemdeps
+
+version = ">= 0.a"
+
+str = ARGV.first
+if str
+  str = str.b[/\A_(.*)_\z/, 1]
+  if str and Gem::Version.correct?(str)
+    version = str
+    ARGV.shift
+  end
+end
+
+if Gem.respond_to?(:activate_bin_path)
+load Gem.activate_bin_path('rake', 'rake', version)
+else
+gem "rake", version
+load Gem.bin_path("rake", "rake", version)
+end

data/vendor/bundle/ruby/3.3.0/bin/rake-compiler

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by RubyGems.
+#
+# The application 'rake-compiler' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'rubygems'
+
+Gem.use_gemdeps
+
+version = ">= 0.a"
+
+str = ARGV.first
+if str
+  str = str.b[/\A_(.*)_\z/, 1]
+  if str and Gem::Version.correct?(str)
+    version = str
+    ARGV.shift
+  end
+end
+
+if Gem.respond_to?(:activate_bin_path)
+load Gem.activate_bin_path('rake-compiler', 'rake-compiler', version)
+else
+gem "rake-compiler", version
+load Gem.bin_path("rake-compiler", "rake-compiler", version)
+end

data/vendor/bundle/ruby/3.3.0/bin/rake-compiler-dock

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+#
+# This file was generated by RubyGems.
+#
+# The application 'rake-compiler-dock' is installed as part of a gem, and
+# this file is here to facilitate running it.
+#
+
+require 'rubygems'
+
+Gem.use_gemdeps
+
+version = ">= 0.a"
+
+str = ARGV.first
+if str
+  str = str.b[/\A_(.*)_\z/, 1]
+  if str and Gem::Version.correct?(str)
+    version = str
+    ARGV.shift
+  end
+end
+
+if Gem.respond_to?(:activate_bin_path)
+load Gem.activate_bin_path('rake-compiler-dock', 'rake-compiler-dock', version)
+else
+gem "rake-compiler-dock", version
+load Gem.bin_path("rake-compiler-dock", "rake-compiler-dock", version)
+end