From 45df4d0d9b577fecee798d672695fe24ff57fb1b Mon Sep 17 00:00:00 2001 From: mo khan Date: Tue, 15 Jul 2025 16:37:08 -0600 Subject: feat: migrate from Cedar to SpiceDB authorization system This is a major architectural change that replaces the Cedar policy-based authorization system with SpiceDB's relation-based authorization. Key changes: - Migrate from Rust to Go implementation - Replace Cedar policies with SpiceDB schema and relationships - Switch from envoy `ext_authz` with Cedar to SpiceDB permission checks - Update build system and dependencies for Go ecosystem - Maintain Envoy integration for external authorization This change enables more flexible permission modeling through SpiceDB's Google Zanzibar inspired relation-based system, supporting complex hierarchical permissions that were difficult to express in Cedar. Breaking change: Existing Cedar policies and Rust-based configuration will no longer work and need to be migrated to SpiceDB schema. --- vendor/itertools/src/sources.rs | 153 ---------------------------------------- 1 file changed, 153 deletions(-) delete mode 100644 vendor/itertools/src/sources.rs (limited to 'vendor/itertools/src/sources.rs') diff --git a/vendor/itertools/src/sources.rs b/vendor/itertools/src/sources.rs deleted file mode 100644 index c405ffdc..00000000 --- a/vendor/itertools/src/sources.rs +++ /dev/null @@ -1,153 +0,0 @@ -//! Iterators that are sources (produce elements from parameters, -//! not from another iterator). -#![allow(deprecated)] - -use std::fmt; -use std::mem; - -/// Creates a new unfold source with the specified closure as the "iterator -/// function" and an initial state to eventually pass to the closure -/// -/// `unfold` is a general iterator builder: it has a mutable state value, -/// and a closure with access to the state that produces the next value. -/// -/// This more or less equivalent to a regular struct with an [`Iterator`] -/// implementation, and is useful for one-off iterators. -/// -/// ``` -/// // an iterator that yields sequential Fibonacci numbers, -/// // and stops at the maximum representable value. -/// -/// use itertools::unfold; -/// -/// let mut fibonacci = unfold((1u32, 1u32), |(x1, x2)| { -/// // Attempt to get the next Fibonacci number -/// let next = x1.saturating_add(*x2); -/// -/// // Shift left: ret <- x1 <- x2 <- next -/// let ret = *x1; -/// *x1 = *x2; -/// *x2 = next; -/// -/// // If addition has saturated at the maximum, we are finished -/// if ret == *x1 && ret > 1 { -/// None -/// } else { -/// Some(ret) -/// } -/// }); -/// -/// itertools::assert_equal(fibonacci.by_ref().take(8), -/// vec![1, 1, 2, 3, 5, 8, 13, 21]); -/// assert_eq!(fibonacci.last(), Some(2_971_215_073)) -/// ``` -#[deprecated( - note = "Use [std::iter::from_fn](https://doc.rust-lang.org/std/iter/fn.from_fn.html) instead", - since = "0.13.0" -)] -pub fn unfold(initial_state: St, f: F) -> Unfold -where - F: FnMut(&mut St) -> Option, -{ - Unfold { - f, - state: initial_state, - } -} - -impl fmt::Debug for Unfold -where - St: fmt::Debug, -{ - debug_fmt_fields!(Unfold, state); -} - -/// See [`unfold`](crate::unfold) for more information. -#[derive(Clone)] -#[must_use = "iterators are lazy and do nothing unless consumed"] -#[deprecated( - note = "Use [std::iter::FromFn](https://doc.rust-lang.org/std/iter/struct.FromFn.html) instead", - since = "0.13.0" -)] -pub struct Unfold { - f: F, - /// Internal state that will be passed to the closure on the next iteration - pub state: St, -} - -impl Iterator for Unfold -where - F: FnMut(&mut St) -> Option, -{ - type Item = A; - - #[inline] - fn next(&mut self) -> Option { - (self.f)(&mut self.state) - } -} - -/// An iterator that infinitely applies function to value and yields results. -/// -/// This `struct` is created by the [`iterate()`](crate::iterate) function. -/// See its documentation for more. -#[derive(Clone)] -#[must_use = "iterators are lazy and do nothing unless consumed"] -pub struct Iterate { - state: St, - f: F, -} - -impl fmt::Debug for Iterate -where - St: fmt::Debug, -{ - debug_fmt_fields!(Iterate, state); -} - -impl Iterator for Iterate -where - F: FnMut(&St) -> St, -{ - type Item = St; - - #[inline] - fn next(&mut self) -> Option { - let next_state = (self.f)(&self.state); - Some(mem::replace(&mut self.state, next_state)) - } - - #[inline] - fn size_hint(&self) -> (usize, Option) { - (usize::MAX, None) - } -} - -/// Creates a new iterator that infinitely applies function to value and yields results. -/// -/// ``` -/// use itertools::iterate; -/// -/// itertools::assert_equal(iterate(1, |i| i % 3 + 1).take(5), vec![1, 2, 3, 1, 2]); -/// ``` -/// -/// **Panics** if compute the next value does. -/// -/// ```should_panic -/// # use itertools::iterate; -/// let mut it = iterate(25u32, |x| x - 10).take_while(|&x| x > 10); -/// assert_eq!(it.next(), Some(25)); // `Iterate` holds 15. -/// assert_eq!(it.next(), Some(15)); // `Iterate` holds 5. -/// it.next(); // `5 - 10` overflows. -/// ``` -/// -/// You can alternatively use [`core::iter::successors`] as it better describes a finite iterator. -pub fn iterate(initial_value: St, f: F) -> Iterate -where - F: FnMut(&St) -> St, -{ - Iterate { - state: initial_value, - f, - } -} -- cgit v1.2.3