Simplify context

src/components/transform.rs

@@ -1,8 +1,8 @@
 use crate::core::AdaptFilter;
 use crate::core::AdaptMap;
 use crate::core::AdaptTransform;
-use crate::core::BufProduce;
 use crate::core::Filter;
+use crate::core::LastProduced;
 use crate::core::Map;
 use crate::core::Produce;
 use crate::core::Transform;
@@ -23,7 +23,7 @@ impl<P: Produce, M: Map> Transform<P> for MapTransform<M> {
     }
 }
 
-impl<P: BufProduce, F: Filter> Transform<P> for FilterTransform<F> {
+impl<P: Produce + LastProduced, F: Filter> Transform<P> for FilterTransform<F> {
     fn transform<'a>(&'a mut self, producer: &'a mut P) -> Result<Option<&'a BStr>> {
         while let Some(value) = producer.produce()? {
             if self.0.filter(value)? {

src/core/produce.rs

@@ -24,10 +24,6 @@ pub trait LastProduced {
     fn last_produced(&self) -> Option<&BStr>;
 }
 
-pub trait BufProduce: Produce + LastProduced {}
-
-impl<T: Produce + LastProduced> BufProduce for T {}
-
 impl<'a, T: AsRef<[u8]>> Produce for slice::Iter<'a, T> {
     fn produce(&mut self) -> Result<Option<&'a BStr>> {
         Ok(self.next().map(bstr))

src/exec/context.rs

@@ -5,8 +5,8 @@ use crate::components::RecordWriter;
 use crate::components::ToBuffer;
 use crate::core::AdaptConsumeTo;
 use crate::core::AdaptProduceFromTo;
-use crate::core::BufProduce;
 use crate::core::Consume;
+use crate::core::LastProduced;
 use crate::core::Produce;
 use crate::exec::GlobalArgs;
 use std::io;
@@ -16,51 +16,33 @@ use std::io::StdinLock;
 use std::io::StdoutLock;
 use std::io::Write;
 
-pub trait GetReader {
+pub trait Context {
     type Reader: BufRead;
-    fn reader(&self) -> Self::Reader;
-}
-
-pub trait GetWriter {
     type Writer: Write;
-    fn writer(&self) -> Self::Writer;
-}
+    type Producer: Produce + LastProduced;
+    type Consumer: Consume;
 
-pub trait GetProducer {
-    type Producer: Produce;
+    fn reader(&self) -> Self::Reader;
+    fn writer(&self) -> Self::Writer;
     fn producer(&self) -> Self::Producer;
-}
-
-pub trait GetBufProducer {
-    type Producer: BufProduce;
-    fn buf_producer(&self) -> Self::Producer;
-}
-
-pub trait GetConsumer {
-    type Consumer: Consume;
     fn consumer(&self) -> Self::Consumer;
 }
 
-impl GetReader for GlobalArgs {
+impl Context for GlobalArgs {
     type Reader = StdinLock<'static>;
+    type Writer = BufWriter<StdoutLock<'static>>;
+    type Producer = ProduceFromRead<Self::Reader, ToBuffer<RecordReader>>;
+    type Consumer = ConsumeToWrite<RecordWriter, Self::Writer>;
 
     fn reader(&self) -> Self::Reader {
         io::stdin().lock()
     }
-}
-
-impl GetWriter for GlobalArgs {
-    type Writer = BufWriter<StdoutLock<'static>>;
 
     fn writer(&self) -> Self::Writer {
         BufWriter::new(io::stdout().lock())
     }
-}
 
-impl GetBufProducer for GlobalArgs {
-    type Producer = ProduceFromRead<<Self as GetReader>::Reader, ToBuffer<RecordReader>>;
-
-    fn buf_producer(&self) -> Self::Producer {
+    fn producer(&self) -> Self::Producer {
         let separator = self.separator();
         let max_line = self.max_line.clone();
 
@@ -69,18 +51,6 @@ impl GetBufProducer for GlobalArgs {
             .attach_reader(self.reader())
             .into_inner()
     }
-}
-
-impl GetProducer for GlobalArgs {
-    type Producer = <Self as GetBufProducer>::Producer;
-
-    fn producer(&self) -> Self::Producer {
-        self.buf_producer()
-    }
-}
-
-impl GetConsumer for GlobalArgs {
-    type Consumer = ConsumeToWrite<RecordWriter, <Self as GetWriter>::Writer>;
 
     fn consumer(&self) -> Self::Consumer {
         let separator = self.separator();

src/exec/fixtures.rs

@@ -1,10 +1,6 @@
 use crate::components::IterProduce;
 use crate::core::Consume;
-use crate::exec::GetBufProducer;
-use crate::exec::GetConsumer;
-use crate::exec::GetProducer;
-use crate::exec::GetReader;
-use crate::exec::GetWriter;
+use crate::exec::Context;
 use bstr::BStr;
 use bstr::BString;
 use std::io::Cursor;
@@ -28,47 +24,30 @@ impl TestContext {
     }
 }
 
-impl GetBufProducer for TestContext {
+impl Context for TestContext {
+    type Reader = Cursor<Vec<u8>>;
+    type Writer = TestWriter;
     type Producer = IterProduce<IntoIter<String>, String>;
+    type Consumer = TestConsumer;
 
-    fn buf_producer(&self) -> Self::Producer {
-        let vec = ["a", "bc", "D", "EF"].map(String::from).to_vec();
-        IterProduce::new(vec.into_iter())
+    fn reader(&self) -> Self::Reader {
+        Cursor::new(b"a\nbc\nD\nEF".to_vec())
     }
-}
 
-impl GetProducer for TestContext {
-    type Producer = <Self as GetBufProducer>::Producer;
+    fn writer(&self) -> Self::Writer {
+        self.writer.clone()
+    }
 
     fn producer(&self) -> Self::Producer {
-        self.buf_producer()
+        let vec = ["a", "bc", "D", "EF"].map(String::from).to_vec();
+        IterProduce::new(vec.into_iter())
     }
-}
-
-impl GetConsumer for TestContext {
-    type Consumer = TestConsumer;
 
     fn consumer(&self) -> Self::Consumer {
         self.consumer.clone()
     }
 }
 
-impl GetReader for TestContext {
-    type Reader = Cursor<Vec<u8>>;
-
-    fn reader(&self) -> Self::Reader {
-        Cursor::new(b"a\nbc\nD\nEF".to_vec())
-    }
-}
-
-impl GetWriter for TestContext {
-    type Writer = TestWriter;
-
-    fn writer(&self) -> Self::Writer {
-        self.writer.clone()
-    }
-}
-
 #[derive(Clone)]
 pub struct TestConsumer {
     inner: Arc<Mutex<Vec<BString>>>,

src/exec/run.rs

@@ -20,11 +20,7 @@ use crate::core::ProduceFrom;
 use crate::core::ProduceFromTo;
 use crate::core::ProduceTo;
 use crate::core::Transform;
-use crate::exec::GetBufProducer;
-use crate::exec::GetConsumer;
-use crate::exec::GetProducer;
-use crate::exec::GetReader;
-use crate::exec::GetWriter;
+use crate::exec::Context;
 use anyhow::Result;
 use std::panic;
 use std::thread;
@@ -33,29 +29,29 @@ pub trait Run<X> {
     fn run(self, context: &X) -> Result<()>;
 }
 
-impl<P: Produce, X: GetConsumer> Run<X> for AdaptProduce<P> {
+impl<P: Produce, X: Context> Run<X> for AdaptProduce<P> {
     fn run(self, context: &X) -> Result<()> {
         self.attach_consumer(context.consumer()).run()
     }
 }
 
-impl<P: ProduceFrom<X::Reader>, X: GetReader + GetConsumer> Run<X> for AdaptProduceFrom<P> {
+impl<P: ProduceFrom<X::Reader>, X: Context> Run<X> for AdaptProduceFrom<P> {
     fn run(self, context: &X) -> Result<()> {
         self.attach_reader(context.reader())
             .attach_consumer(context.consumer())
             .run()
     }
 }
 
-impl<P: ProduceTo, X: GetConsumer> Run<X> for AdaptProduceTo<P> {
+impl<P: ProduceTo, X: Context> Run<X> for AdaptProduceTo<P> {
     fn run(self, context: &X) -> Result<()> {
         self.attach_buffer()
             .attach_consumer(context.consumer())
             .run()
     }
 }
 
-impl<P: ProduceFromTo<X::Reader>, X: GetReader + GetConsumer> Run<X> for AdaptProduceFromTo<P> {
+impl<P: ProduceFromTo<X::Reader>, X: Context> Run<X> for AdaptProduceFromTo<P> {
     fn run(self, context: &X) -> Result<()> {
         self.attach_buffer()
             .attach_reader(context.reader())
@@ -64,15 +60,15 @@ impl<P: ProduceFromTo<X::Reader>, X: GetReader + GetConsumer> Run<X> for AdaptPr
     }
 }
 
-impl<T: Transform<X::Producer>, X: GetProducer + GetConsumer> Run<X> for AdaptTransform<T> {
+impl<T: Transform<X::Producer>, X: Context> Run<X> for AdaptTransform<T> {
     fn run(self, context: &X) -> Result<()> {
         self.attach_producer(context.producer())
             .attach_consumer(context.consumer())
             .run()
     }
 }
 
-impl<M: Map, X: GetProducer + GetConsumer> Run<X> for AdaptMap<M> {
+impl<M: Map, X: Context> Run<X> for AdaptMap<M> {
     fn run(self, context: &X) -> Result<()> {
         self.into_transform()
             .attach_producer(context.producer())
@@ -81,7 +77,7 @@ impl<M: Map, X: GetProducer + GetConsumer> Run<X> for AdaptMap<M> {
     }
 }
 
-impl<M: MapTo, X: GetProducer + GetConsumer> Run<X> for AdaptMapTo<M> {
+impl<M: MapTo, X: Context> Run<X> for AdaptMapTo<M> {
     fn run(self, context: &X) -> Result<()> {
         self.attach_buffer()
             .into_transform()
@@ -91,30 +87,30 @@ impl<M: MapTo, X: GetProducer + GetConsumer> Run<X> for AdaptMapTo<M> {
     }
 }
 
-impl<F: Filter, X: GetBufProducer + GetConsumer> Run<X> for AdaptFilter<F> {
+impl<F: Filter, X: Context> Run<X> for AdaptFilter<F> {
     fn run(self, context: &X) -> Result<()> {
         self.into_transform()
-            .attach_producer(context.buf_producer())
+            .attach_producer(context.producer())
             .attach_consumer(context.consumer())
             .run()
     }
 }
 
-impl<C: Consume, X: GetProducer> Run<X> for AdaptConsume<C> {
+impl<C: Consume, X: Context> Run<X> for AdaptConsume<C> {
     fn run(self, context: &X) -> Result<()> {
         self.attach_producer(context.producer()).run()
     }
 }
 
-impl<C: ConsumeTo<X::Writer>, X: GetProducer + GetWriter> Run<X> for AdaptConsumeTo<C> {
+impl<C: ConsumeTo<X::Writer>, X: Context> Run<X> for AdaptConsumeTo<C> {
     fn run(self, context: &X) -> Result<()> {
         self.attach_writer(context.writer())
             .attach_producer(context.producer())
             .run()
     }
 }
 
-impl<P: Channel, X: GetProducer + GetConsumer + Send + Sync + 'static> Run<X> for AdaptChannel<P> {
+impl<P: Channel, X: Context + Send + Sync + 'static> Run<X> for AdaptChannel<P> {
     fn run(self, context: &X) -> Result<()> {
         let (consumer, producer) = self.into_inner().open()?;
         thread::scope(|scope| {