Expose derived lenses as associated constants

Author: Ralith

README.md

@@ -188,7 +188,8 @@ struct AppState {
 ### lens
 
 The [Lens datatype] gives access to a part of a larger data structure. Like
-`Data`, This can be derived.
+`Data`, this can be derived. Derived lenses are accessed as associated constants
+with the same name as the field.
 
 ```rust
 #[derive(Clone, Data, Lens)]
@@ -202,7 +203,7 @@ To use the lens, wrap your widget with `LensWrap` (note the conversion of
 CamelCase to snake_case):
 
 ```rust
-LensWrap::new(WidgetThatExpectsf64::new(), lenses::app_state::value);
+LensWrap::new(WidgetThatExpectsf64::new(), AppState::value);
 ```
 
 ## Using druid

druid-derive/src/lens.rs

@@ -47,32 +47,16 @@ fn derive_struct(input: &syn::DeriveInput) -> Result<proc_macro2::TokenStream, s
         ));
     };
 
-    let twizzled_name = if is_camel_case(&ty.to_string()) {
-        let temp_name = to_snake_case(&ty.to_string());
-        proc_macro2::Ident::new(&temp_name, proc_macro2::Span::call_site())
-    } else {
-        return Err(syn::Error::new(
-            ty.span(),
-            "Lens implementations can only be derived from CamelCase types",
-        ));
-    };
-
-    // Declare a struct for each field
-    let structs = fields.iter().map(|f| {
-        let field_name = &f.ident;
-
-        quote! {
-            #[allow(non_camel_case_types)]
-            pub struct #field_name;
-        }
-    });
+    let mod_name = proc_macro2::Ident::new(&format!("__{}_druid_lenses", &ty), proc_macro2::Span::call_site());
 
     // Impl Lens for each field
     let impls = fields.iter().map(|f| {
         let field_name = &f.ident;
         let field_ty = &f.ty;
 
         quote! {
+            #[allow(non_camel_case_types)]
+            pub struct #field_name;
 
             impl Lens<#ty, #field_ty> for #field_name {
                 fn with<V, F: FnOnce(&#field_ty) -> V>(&self, data: &#ty, f: F) -> V {
@@ -86,69 +70,26 @@ fn derive_struct(input: &syn::DeriveInput) -> Result<proc_macro2::TokenStream, s
         }
     });
 
+    let associated_items = fields.iter().map(|f| {
+        let field_name = &f.ident;
+        quote! {
+            pub const #field_name: #field_name = #field_name;
+        }
+    });
+
     let expanded = quote! {
-        pub mod lenses {
-            pub mod #twizzled_name {
-                use super::super::*;
+        mod #mod_name {
+            use super::*;
+            use druid::Lens;
 
-                use druid::Lens;
-                #(#structs)*
-                #(#impls)*
-            }
+            #(#impls)*
 
+            #[allow(non_upper_case_globals)]
+            impl #ty {
+                #(#associated_items)*
+            }
         }
     };
 
     Ok(expanded)
 }
-
-//I stole these from rustc!
-fn char_has_case(c: char) -> bool {
-    c.is_lowercase() || c.is_uppercase()
-}
-
-fn is_camel_case(name: &str) -> bool {
-    let name = name.trim_matches('_');
-    if name.is_empty() {
-        return true;
-    }
-
-    // start with a non-lowercase letter rather than non-uppercase
-    // ones (some scripts don't have a concept of upper/lowercase)
-    !name.chars().next().unwrap().is_lowercase()
-        && !name.contains("__")
-        && !name.chars().collect::<Vec<_>>().windows(2).any(|pair| {
-            // contains a capitalisable character followed by, or preceded by, an underscore
-            char_has_case(pair[0]) && pair[1] == '_' || char_has_case(pair[1]) && pair[0] == '_'
-        })
-}
-
-fn to_snake_case(mut str: &str) -> String {
-    let mut words = vec![];
-    // Preserve leading underscores
-    str = str.trim_start_matches(|c: char| {
-        if c == '_' {
-            words.push(String::new());
-            true
-        } else {
-            false
-        }
-    });
-    for s in str.split('_') {
-        let mut last_upper = false;
-        let mut buf = String::new();
-        if s.is_empty() {
-            continue;
-        }
-        for ch in s.chars() {
-            if !buf.is_empty() && buf != "'" && ch.is_uppercase() && !last_upper {
-                words.push(buf);
-                buf = String::new();
-            }
-            last_upper = ch.is_uppercase();
-            buf.extend(ch.to_lowercase());
-        }
-        words.push(buf);
-    }
-    words.join("_")
-}

druid/examples/calc.rs

@@ -152,7 +152,7 @@ fn build_calc() -> impl Widget<CalcState> {
     let mut column = Flex::column();
     let display = LensWrap::new(
         DynLabel::new(|data: &String, _env| data.clone()),
-        lenses::calc_state::value,
+        CalcState::value,
     );
     column.add_child(pad(display), 0.0);
     column.add_child(

druid/examples/either.rs

@@ -35,15 +35,12 @@ fn ui_builder() -> impl Widget<AppState> {
 
     let mut col = Flex::column();
     col.add_child(
-        Padding::new(
-            5.0,
-            LensWrap::new(Checkbox::new(), lenses::app_state::which),
-        ),
+        Padding::new(5.0, LensWrap::new(Checkbox::new(), AppState::which)),
         0.0,
     );
     let either = Either::new(
         |data, _env| data.which,
-        Padding::new(5.0, LensWrap::new(Slider::new(), lenses::app_state::value)),
+        Padding::new(5.0, LensWrap::new(Slider::new(), AppState::value)),
         Padding::new(5.0, label),
     );
     col.add_child(either, 0.0);

druid/examples/slider.rs

@@ -31,13 +31,13 @@ fn build_widget() -> impl Widget<DemoState> {
         }
     });
     let mut row = Flex::row();
-    let checkbox = LensWrap::new(Checkbox::new(), lenses::demo_state::double);
+    let checkbox = LensWrap::new(Checkbox::new(), DemoState::double);
     let checkbox_label = Label::new("double the value");
     row.add_child(checkbox, 0.0);
     row.add_child(Padding::new(5.0, checkbox_label), 1.0);
 
-    let bar = LensWrap::new(ProgressBar::new(), lenses::demo_state::value);
-    let slider = LensWrap::new(Slider::new(), lenses::demo_state::value);
+    let bar = LensWrap::new(ProgressBar::new(), DemoState::value);
+    let slider = LensWrap::new(Slider::new(), DemoState::value);
 
     let button_1 = Button::sized(
         "increment ",

druid/examples/switch.rs

@@ -23,7 +23,7 @@ struct DemoState {
 fn build_widget() -> impl Widget<DemoState> {
     let mut col = Flex::column();
     let mut row = Flex::row();
-    let switch = LensWrap::new(Switch::new(), lenses::demo_state::value);
+    let switch = LensWrap::new(Switch::new(), DemoState::value);
     let switch_label = Label::new("Setting label");
 
     row.add_child(Padding::new(5.0, switch_label), 0.0);