Wire up our converters for the Intermediate config data structures.

src/convert/flags.rs

@@ -0,0 +1,62 @@
+// Copyright 2017 Jeremy Wall <jeremy@marzhillstudios.com>
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+
+use std::rc::Rc;
+use std::io::Write;
+use std::io::Result;
+
+use build::Val;
+use convert::traits::Converter;
+
+pub struct FlagConverter {}
+
+impl FlagConverter {
+    pub fn new() -> Self {
+        FlagConverter {}
+    }
+}
+
+impl FlagConverter {
+    fn write(&self, v: &Val, w: &mut Write) -> Result<()> {
+        match v {
+            &Val::Float(ref f) => {
+                try!(write!(w, "{} ", f));
+            },
+            &Val::Int(ref i) => {
+                try!(write!(w, "{} ", i));
+            },
+            &Val::String(ref s) => {
+                try!(write!(w, "'{}' ", s));
+            },
+            &Val::Tuple(ref flds) => {
+                for &(ref name, ref val) in flds.iter() {
+                    try!(write!(w, "--{} ", name.val));
+                    // TODO(jwall): What if the value is a tuple?
+                    try!(self.write(&val, w));
+                }
+            },
+            &Val::Macro(ref _def) => {
+                // This is ignored
+                eprintln!("Skipping macro...");
+            }
+        }
+        Ok(())
+    }
+}
+
+impl Converter for FlagConverter {
+    fn convert(&self, v: Rc<Val>, mut w: Box<Write>) -> Result<()> {
+        return self.write(&v, &mut w);
+    }
+}

src/convert/mod.rs

@@ -0,0 +1,40 @@
+// Copyright 2017 Jeremy Wall <jeremy@marzhillstudios.com>
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+pub mod flags;
+pub mod traits;
+
+use std::io;
+use std::io::Write;
+use std::rc::Rc;
+
+use build::Val;
+
+pub struct ConverterRunner {
+    converter: Box<traits::Converter>,
+}
+
+impl ConverterRunner {
+    pub fn new(typ: &str) -> Result<Self, String> {
+        if typ == "flags" {
+            return Ok(ConverterRunner {
+                converter: Box::new(flags::FlagConverter::new()),
+            });
+        }
+        return Err(format!("Unknown Target output type: {}", typ))
+    }
+
+    pub fn convert(&self, v: Rc<Val>, w: Box<Write>) -> io::Result<()> {
+        self.converter.convert(v, w)
+    }
+}

src/convert/traits.rs

@@ -0,0 +1,23 @@
+// Copyright 2017 Jeremy Wall <jeremy@marzhillstudios.com>
+//
+//  Licensed under the Apache License, Version 2.0 (the "License");
+//  you may not use this file except in compliance with the License.
+//  You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+//  Unless required by applicable law or agreed to in writing, software
+//  distributed under the License is distributed on an "AS IS" BASIS,
+//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+//  See the License for the specific language governing permissions and
+//  limitations under the License.
+
+use std::rc::Rc;
+use std::io::Write;
+use std::io::Result;
+
+use build::Val;
+
+pub trait Converter {
+    fn convert(&self, vs: Rc<Val>, w: Box<Write>) -> Result<()>;
+}

src/main.rs

@@ -22,7 +22,6 @@ use std::process;
 
 use ucglib::build::Val;
 use ucglib::build;
-//use ucglib::convert::get_converter;
 use ucglib::convert::ConverterRunner;
 
 // TODO(jwall): List the target output types automatically.