Añade módulo User y componentes para formularios

src/base/component/chunck.rs

@@ -37,14 +37,12 @@ impl PageComponent for Chunck {
 
 impl Chunck {
 
-    // Chunck BUILDER.
-
     pub fn markup(markup: Markup) -> Self {
-        let mut chunck = Chunck::prepare();
-        chunck.markup.push(markup);
-        chunck
+        Chunck::prepare().add_markup(markup)
     }
 
+    // Chunck BUILDER.
+
     pub fn with_renderable(mut self, renderable: fn() -> bool) -> Self {
         self.renderable = renderable;
         self

src/base/component/container.rs

@@ -48,8 +48,6 @@ impl PageComponent for Container {
 
 impl Container {
 
-    // Container BUILDER.
-
     pub fn row() -> Self {
         let mut grid = Container::prepare();
         grid.container = ContainerType::Row;
@@ -62,6 +60,8 @@ impl Container {
         grid
     }
 
+    // Container BUILDER.
+
     pub fn with_renderable(mut self, renderable: fn() -> bool) -> Self {
         self.renderable = renderable;
         self

src/base/component/form/button.rs

@@ -0,0 +1,174 @@
+use crate::prelude::*;
+
+enum ButtonType {Button, Reset, Submit}
+
+pub struct Button {
+    renderable : fn() -> bool,
+    weight     : i8,
+    button_type: ButtonType,
+    name       : Option<String>,
+    value      : Option<String>,
+    autofocus  : Option<String>,
+    disabled   : Option<String>,
+    template   : String,
+}
+
+impl PageComponent for Button {
+
+    fn prepare() -> Self {
+        Button {
+            renderable : always,
+            weight     : 0,
+            button_type: ButtonType::Button,
+            name       : None,
+            value      : None,
+            autofocus  : None,
+            disabled    : None,
+            template   : "default".to_string(),
+        }
+    }
+
+    fn is_renderable(&self) -> bool {
+        (self.renderable)()
+    }
+
+    fn weight(&self) -> i8 {
+        self.weight
+    }
+
+    fn default_render(&self, _: &mut PageAssets) -> Markup {
+        let (button_type, button_class) = match &self.button_type {
+            ButtonType::Button => ("button", "btn btn-primary form-button"),
+            ButtonType::Reset  => ("reset",  "btn btn-primary form-reset" ),
+            ButtonType::Submit => ("submit", "btn btn-primary form-submit")
+        };
+        let id_item = match &self.name {
+            Some(name) => Some(format!("edit-{}", name)),
+            _ => None
+        };
+        html! {
+            button
+                type=(button_type)
+                id=[&id_item]
+                class=(button_class)
+                name=[&self.name]
+                value=[&self.value]
+                autofocus=[&self.autofocus]
+                disabled=[&self.disabled]
+            {
+                @match &self.value {
+                    Some(value) => (value),
+                    _ => ""
+                };
+            }
+        }
+    }
+}
+
+impl Button {
+
+    pub fn button(value: &str) -> Self {
+        Button::prepare().with_value(value)
+    }
+
+    pub fn reset(value: &str) -> Self {
+        let mut button = Button::prepare().with_value(value);
+        button.button_type = ButtonType::Reset;
+        button
+    }
+
+    pub fn submit(value: &str) -> Self {
+        let mut button = Button::prepare().with_value(value);
+        button.button_type = ButtonType::Submit;
+        button
+    }
+
+    // Button BUILDER.
+
+    pub fn with_renderable(mut self, renderable: fn() -> bool) -> Self {
+        self.renderable = renderable;
+        self
+    }
+
+    pub fn with_weight(mut self, weight: i8) -> Self {
+        self.weight = weight;
+        self
+    }
+
+    pub fn with_name(mut self, name: &str) -> Self {
+        self.name = if name.is_empty() {
+            None
+        } else {
+            Some(name.replace(" ", "_"))
+        };
+        self
+    }
+
+    pub fn with_value(mut self, value: &str) -> Self {
+        self.value = if value.is_empty() {
+            None
+        } else {
+            Some(value.to_string())
+        };
+        self
+    }
+
+    pub fn autofocus(mut self, toggle: bool) -> Self {
+        self.autofocus = match toggle {
+            true => Some("autofocus".to_string()),
+            false => None
+        };
+        self
+    }
+
+    pub fn disabled(mut self, toggle: bool) -> Self {
+        self.disabled = match toggle {
+            true => Some("disabled".to_string()),
+            false => None
+        };
+        self
+    }
+
+    pub fn using_template(mut self, template: &str) -> Self {
+        self.template = template.to_string();
+        self
+    }
+
+    // Button GETTERS.
+
+    pub fn name(&self) -> &str {
+        match &self.name {
+            Some(name) => name.as_str(),
+            _ => ""
+        }
+    }
+
+    pub fn value(&self) -> &str {
+        match &self.value {
+            Some(value) => value.as_str(),
+            _ => ""
+        }
+    }
+
+    pub fn has_autofocus(&self) -> bool {
+        match &self.autofocus {
+            Some(_) => true,
+            _ => false
+        }
+    }
+
+    pub fn is_disabled(&self) -> bool {
+        match &self.disabled {
+            Some(_) => true,
+            _ => false
+        }
+    }
+
+    pub fn template(&self) -> &str {
+        self.template.as_str()
+    }
+}
+
+fn always() -> bool {
+    true
+}

src/base/component/form/date.rs

@@ -0,0 +1,264 @@
+use crate::prelude::*;
+
+pub struct Date {
+    renderable  : fn() -> bool,
+    weight      : i8,
+    name        : Option<String>,
+    value       : Option<String>,
+    label       : String,
+    placeholder : Option<String>,
+    autofocus   : Option<String>,
+    autocomplete: Option<String>,
+    disabled    : Option<String>,
+    readonly    : Option<String>,
+    required    : Option<String>,
+    help_text   : String,
+    template    : String,
+}
+
+impl PageComponent for Date {
+
+    fn prepare() -> Self {
+        Date {
+            renderable  : always,
+            weight      : 0,
+            name        : None,
+            value       : None,
+            label       : "".to_string(),
+            placeholder : None,
+            autofocus   : None,
+            autocomplete: None,
+            disabled    : None,
+            readonly    : None,
+            required    : None,
+            help_text   : "".to_string(),
+            template    : "default".to_string(),
+        }
+    }
+
+    fn is_renderable(&self) -> bool {
+        (self.renderable)()
+    }
+
+    fn weight(&self) -> i8 {
+        self.weight
+    }
+
+    fn default_render(&self, _: &mut PageAssets) -> Markup {
+        let (class_item, id_item) = match &self.name {
+            Some(name) => (
+                format!("form-item form-item-{} form-type-date", name),
+                Some(format!("edit-{}", name))
+            ),
+            None => (
+                "form-item form-type-date".to_string(),
+                None
+            )
+        };
+        html! {
+            div class=(class_item) {
+                @if !self.label.is_empty() {
+                    label class="form-label" for=[&id_item] {
+                        (self.label) " "
+                        @if self.required != None {
+                            span
+                                class="form-required"
+                                title="Este campo es obligatorio."
+                            {
+                                "*"
+                            } " "
+                        }
+                    }
+                }
+                input
+                    type="date"
+                    id=[&id_item]
+                    class="form-control"
+                    name=[&self.name]
+                    value=[&self.value]
+                    placeholder=[&self.placeholder]
+                    autofocus=[&self.autofocus]
+                    autocomplete=[&self.autocomplete]
+                    readonly=[&self.readonly]
+                    required=[&self.required]
+                    disabled=[&self.disabled];
+                @if !self.help_text.is_empty() {
+                    div class="form-text" {
+                        (self.help_text)
+                    }
+                }
+            }
+        }
+    }
+}
+
+impl Date {
+
+    // Date BUILDER.
+
+    pub fn with_renderable(mut self, renderable: fn() -> bool) -> Self {
+        self.renderable = renderable;
+        self
+    }
+
+    pub fn with_weight(mut self, weight: i8) -> Self {
+        self.weight = weight;
+        self
+    }
+
+    pub fn with_name(mut self, name: &str) -> Self {
+        self.name = if name.is_empty() {
+            None
+        } else {
+            Some(name.replace(" ", "_"))
+        };
+        self
+    }
+
+    pub fn with_value(mut self, value: &str) -> Self {
+        self.value = if value.is_empty() {
+            None
+        } else {
+            Some(value.to_string())
+        };
+        self
+    }
+
+    pub fn with_label(mut self, label: &str) -> Self {
+        self.label = label.to_string();
+        self
+    }
+
+    pub fn with_placeholder(mut self, placeholder: &str) -> Self {
+        self.placeholder = if placeholder.is_empty() {
+            None
+        } else {
+            Some(placeholder.to_string())
+        };
+        self
+    }
+
+    pub fn autofocus(mut self, toggle: bool) -> Self {
+        self.autofocus = match toggle {
+            true => Some("autofocus".to_string()),
+            false => None
+        };
+        self
+    }
+
+    pub fn autocomplete(mut self, toggle: bool) -> Self {
+        self.autocomplete = match toggle {
+            true => None,
+            false => Some("off".to_string())
+        };
+        self
+    }
+
+    pub fn disabled(mut self, toggle: bool) -> Self {
+        self.disabled = match toggle {
+            true => Some("disabled".to_string()),
+            false => None
+        };
+        self
+    }
+
+    pub fn readonly(mut self, toggle: bool) -> Self {
+        self.readonly = match toggle {
+            true => Some("readonly".to_string()),
+            false => None
+        };
+        self
+    }
+
+    pub fn required(mut self, toggle: bool) -> Self {
+        self.required = match toggle {
+            true => Some("required".to_string()),
+            false => None
+        };
+        self
+    }
+
+    pub fn with_help_text(mut self, help_text: &str) -> Self {
+        self.help_text = help_text.to_string();
+        self
+    }
+
+    pub fn using_template(mut self, template: &str) -> Self {
+        self.template = template.to_string();
+        self
+    }
+
+    // Date GETTERS.
+
+    pub fn name(&self) -> &str {
+        match &self.name {
+            Some(name) => name.as_str(),
+            _ => ""
+        }
+    }
+
+    pub fn value(&self) -> &str {
+        match &self.value {
+            Some(value) => value.as_str(),
+            _ => ""
+        }
+    }
+
+    pub fn label(&self) -> &str {
+        self.label.as_str()
+    }
+
+    pub fn placeholder(&self) -> &str {
+        match &self.placeholder {
+            Some(placeholder) => placeholder.as_str(),
+            _ => ""
+        }
+    }
+
+    pub fn has_autofocus(&self) -> bool {
+        match &self.autofocus {
+            Some(_) => true,
+            _ => false
+        }
+    }
+
+    pub fn has_autocomplete(&self) -> bool {
+        match &self.autocomplete {
+            Some(_) => false,
+            _ => true
+        }
+    }
+
+    pub fn is_disabled(&self) -> bool {
+        match &self.disabled {
+            Some(_) => true,
+            _ => false
+        }
+    }
+
+    pub fn is_readonly(&self) -> bool {
+        match &self.readonly {
+            Some(_) => true,
+            _ => false
+        }
+    }
+
+    pub fn is_required(&self) -> bool {
+        match &self.required {
+            Some(_) => true,
+            _ => false
+        }
+    }
+
+    pub fn help_text(&self) -> &str {
+        self.help_text.as_str()
+    }
+
+    pub fn template(&self) -> &str {
+        self.template.as_str()
+    }
+}
+
+fn always() -> bool {
+    true
+}

src/base/component/form/form.rs

@@ -0,0 +1,152 @@
+use crate::prelude::*;
+
+pub enum FormMethod {Get, Post}
+
+pub struct Form {
+    renderable: fn() -> bool,
+    weight    : i8,
+    id        : Option<String>,
+    action    : Option<String>,
+    method    : FormMethod,
+    charset   : Option<String>,
+    elements  : PageContainer,
+    template  : String,
+}
+
+impl PageComponent for Form {
+
+    fn prepare() -> Self {
+        Form {
+            renderable: always,
+            weight    : 0,
+            id        : None,
+            action    : None,
+            method    : FormMethod::Post,
+            charset   : Some("UTF-8".to_string()),
+            elements  : PageContainer::new(),
+            template  : "default".to_string(),
+        }
+    }
+
+    fn is_renderable(&self) -> bool {
+        (self.renderable)()
+    }
+
+    fn weight(&self) -> i8 {
+        self.weight
+    }
+
+    fn default_render(&self, assets: &mut PageAssets) -> Markup {
+        let method = match self.method {
+            FormMethod::Get => None,
+            FormMethod::Post => Some("post".to_string())
+        };
+        html! {
+            form
+                id=[&self.id]
+                action=[&self.action]
+                method=[method]
+                accept-charset=[&self.charset]
+            {
+                div {
+                    (self.elements.render(assets))
+                }
+            }
+        }
+    }
+}
+
+impl Form {
+
+    // Form BUILDER.
+
+    pub fn with_renderable(mut self, renderable: fn() -> bool) -> Self {
+        self.renderable = renderable;
+        self
+    }
+
+    pub fn with_weight(mut self, weight: i8) -> Self {
+        self.weight = weight;
+        self
+    }
+
+    pub fn with_id(mut self, id: &str) -> Self {
+        self.id = if id.is_empty() {
+            None
+        } else {
+            Some(id.replace(" ", "_"))
+        };
+        self
+    }
+
+    pub fn with_action(mut self, action: &str) -> Self {
+        self.action = if action.is_empty() {
+            None
+        } else {
+            Some(action.to_string())
+        };
+        self
+    }
+
+    pub fn with_method(mut self, method: FormMethod) -> Self {
+        self.method = method;
+        self
+    }
+
+    pub fn with_charset(mut self, charset: &str) -> Self {
+        self.charset = if charset.is_empty() {
+            None
+        } else {
+            Some(charset.to_string())
+        };
+        self
+    }
+
+    pub fn add(mut self, element: impl PageComponent) -> Self {
+        self.elements.add(element);
+        self
+    }
+
+    pub fn using_template(mut self, template: &str) -> Self {
+        self.template = template.to_string();
+        self
+    }
+
+    // Form GETTERS.
+
+    pub fn id(&self) -> &str {
+        match &self.id {
+            Some(id) => id.as_str(),
+            _ => ""
+        }
+    }
+
+    pub fn action(&self) -> &str {
+        match &self.action {
+            Some(action) => action.as_str(),
+            _ => ""
+        }
+    }
+
+    pub fn method(&self) -> &str {
+        match &self.method {
+            FormMethod::Get => "get",
+            FormMethod::Post => "post"
+        }
+    }
+
+    pub fn charset(&self) -> &str {
+        match &self.charset {
+            Some(charset) => charset.as_str(),
+            _ => ""
+        }
+    }
+
+    pub fn template(&self) -> &str {
+        self.template.as_str()
+    }
+}
+
+fn always() -> bool {
+    true
+}

src/base/component/form/hidden.rs

@@ -0,0 +1,110 @@
+use crate::prelude::*;
+
+pub struct Hidden {
+    renderable  : fn() -> bool,
+    weight      : i8,
+    name        : Option<String>,
+    value       : Option<String>,
+    template    : String,
+}
+
+impl PageComponent for Hidden {
+
+    fn prepare() -> Self {
+        Hidden {
+            renderable  : always,
+            weight      : 0,
+            name        : None,
+            value       : None,
+            template    : "default".to_string(),
+        }
+    }
+
+    fn is_renderable(&self) -> bool {
+        (self.renderable)()
+    }
+
+    fn weight(&self) -> i8 {
+        self.weight
+    }
+
+    fn default_render(&self, _: &mut PageAssets) -> Markup {
+        let id_item = match &self.name {
+            Some(name) => Some(format!("value-{}", name)),
+            _ => None
+        };
+        html! {
+            input
+                type="hidden"
+                id=[&id_item]
+                name=[&self.name]
+                value=[&self.value];
+        }
+    }
+}
+
+impl Hidden {
+
+    pub fn set(name: &str, value: &str) -> Self {
+        Hidden::prepare().with_name(name).with_value(value)
+    }
+
+    // Hidden BUILDER.
+
+    pub fn with_renderable(mut self, renderable: fn() -> bool) -> Self {
+        self.renderable = renderable;
+        self
+    }
+
+    pub fn with_weight(mut self, weight: i8) -> Self {
+        self.weight = weight;
+        self
+    }
+
+    pub fn with_name(mut self, name: &str) -> Self {
+        self.name = if name.is_empty() {
+            None
+        } else {
+            Some(name.replace(" ", "_"))
+        };
+        self
+    }
+
+    pub fn with_value(mut self, value: &str) -> Self {
+        self.value = if value.is_empty() {
+            None
+        } else {
+            Some(value.to_string())
+        };
+        self
+    }
+
+    pub fn using_template(mut self, template: &str) -> Self {
+        self.template = template.to_string();
+        self
+    }
+
+    // Hidden GETTERS.
+
+    pub fn name(&self) -> &str {
+        match &self.name {
+            Some(name) => name.as_str(),
+            _ => ""
+        }
+    }
+
+    pub fn value(&self) -> &str {
+        match &self.value {
+            Some(value) => value.as_str(),
+            _ => ""
+        }
+    }
+
+    pub fn template(&self) -> &str {
+        self.template.as_str()
+    }
+}
+
+fn always() -> bool {
+    true
+}

src/base/component/form/input.rs

@@ -0,0 +1,346 @@
+use crate::prelude::*;
+
+enum InputType {Email, Password, Search, Telephone, Textfield, Url}
+
+pub struct Input {
+    renderable  : fn() -> bool,
+    weight      : i8,
+    input_type  : InputType,
+    name        : Option<String>,
+    value       : Option<String>,
+    label       : String,
+    size        : Option<u16>,
+    minlength   : Option<u16>,
+    maxlength   : Option<u16>,
+    placeholder : Option<String>,
+    autofocus   : Option<String>,
+    autocomplete: Option<String>,
+    disabled    : Option<String>,
+    readonly    : Option<String>,
+    required    : Option<String>,
+    help_text   : String,
+    template    : String,
+}
+
+impl PageComponent for Input {
+
+    fn prepare() -> Self {
+        Input {
+            renderable  : always,
+            weight      : 0,
+            input_type  : InputType::Textfield,
+            name        : None,
+            value       : None,
+            label       : "".to_string(),
+            size        : Some(60),
+            minlength   : None,
+            maxlength   : Some(128),
+            placeholder : None,
+            autofocus   : None,
+            autocomplete: None,
+            disabled    : None,
+            readonly    : None,
+            required    : None,
+            help_text   : "".to_string(),
+            template    : "default".to_string(),
+        }
+    }
+
+    fn is_renderable(&self) -> bool {
+        (self.renderable)()
+    }
+
+    fn weight(&self) -> i8 {
+        self.weight
+    }
+
+    fn default_render(&self, _: &mut PageAssets) -> Markup {
+        let (input_type, class_type) = match &self.input_type {
+            InputType::Email     => ("email",    "form-type-email"),
+            InputType::Password  => ("password", "form-type-password"),
+            InputType::Search    => ("search",   "form-type-search"),
+            InputType::Telephone => ("tel",      "form-type-telephone"),
+            InputType::Textfield => ("text",     "form-type-textfield"),
+            InputType::Url       => ("url",      "form-type-url")
+        };
+        let (class_item, id_item) = match &self.name {
+            Some(name) => (
+                format!("form-item form-item-{} {}", name, class_type),
+                Some(format!("edit-{}", name))
+            ),
+            None => (
+                format!("form-item {}", class_type),
+                None
+            )
+        };
+        html! {
+            div class=(class_item) {
+                @if !self.label.is_empty() {
+                    label class="form-label" for=[&id_item] {
+                        (self.label) " "
+                        @if self.required != None {
+                            span
+                                class="form-required"
+                                title="Este campo es obligatorio."
+                            {
+                                "*"
+                            } " "
+                        }
+                    }
+                }
+                input
+                    type=(input_type)
+                    id=[&id_item]
+                    class="form-control"
+                    name=[&self.name]
+                    value=[&self.value]
+                    size=[self.size]
+                    minlength=[self.minlength]
+                    maxlength=[self.maxlength]
+                    placeholder=[&self.placeholder]
+                    autofocus=[&self.autofocus]
+                    autocomplete=[&self.autocomplete]
+                    readonly=[&self.readonly]
+                    required=[&self.required]
+                    disabled=[&self.disabled];
+                @if !self.help_text.is_empty() {
+                    div class="form-text" {
+                        (self.help_text)
+                    }
+                }
+            }
+        }
+    }
+}
+
+impl Input {
+
+    pub fn textfield() -> Self {
+        Input::prepare()
+    }
+
+    pub fn password() -> Self {
+        let mut input = Input::prepare();
+        input.input_type = InputType::Password;
+        input
+    }
+
+    pub fn search() -> Self {
+        let mut input = Input::prepare();
+        input.input_type = InputType::Search;
+        input
+    }
+
+    pub fn email() -> Self {
+        let mut input = Input::prepare();
+        input.input_type = InputType::Email;
+        input
+    }
+
+    pub fn telephone() -> Self {
+        let mut input = Input::prepare();
+        input.input_type = InputType::Telephone;
+        input
+    }
+
+    pub fn url() -> Self {
+        let mut input = Input::prepare();
+        input.input_type = InputType::Url;
+        input
+    }
+
+    // Input BUILDER.
+
+    pub fn with_renderable(mut self, renderable: fn() -> bool) -> Self {
+        self.renderable = renderable;
+        self
+    }
+
+    pub fn with_weight(mut self, weight: i8) -> Self {
+        self.weight = weight;
+        self
+    }
+
+    pub fn with_name(mut self, name: &str) -> Self {
+        self.name = if name.is_empty() {
+            None
+        } else {
+            Some(name.replace(" ", "_"))
+        };
+        self
+    }
+
+    pub fn with_value(mut self, value: &str) -> Self {
+        self.value = if value.is_empty() {
+            None
+        } else {
+            Some(value.to_string())
+        };
+        self
+    }
+
+    pub fn with_label(mut self, label: &str) -> Self {
+        self.label = label.to_string();
+        self
+    }
+
+    pub fn with_size(mut self, size: Option<u16>) -> Self {
+        self.size = size;
+        self
+    }
+
+    pub fn with_minlength(mut self, minlength: Option<u16>) -> Self {
+        self.minlength = minlength;
+        self
+    }
+
+    pub fn with_maxlength(mut self, maxlength: Option<u16>) -> Self {
+        self.maxlength = maxlength;
+        self
+    }
+
+    pub fn with_placeholder(mut self, placeholder: &str) -> Self {
+        self.placeholder = if placeholder.is_empty() {
+            None
+        } else {
+            Some(placeholder.to_string())
+        };
+        self
+    }
+
+    pub fn autofocus(mut self, toggle: bool) -> Self {
+        self.autofocus = match toggle {
+            true => Some("autofocus".to_string()),
+            false => None
+        };
+        self
+    }
+
+    pub fn autocomplete(mut self, toggle: bool) -> Self {
+        self.autocomplete = match toggle {
+            true => None,
+            false => Some("off".to_string())
+        };
+        self
+    }
+
+    pub fn disabled(mut self, toggle: bool) -> Self {
+        self.disabled = match toggle {
+            true => Some("disabled".to_string()),
+            false => None
+        };
+        self
+    }
+
+    pub fn readonly(mut self, toggle: bool) -> Self {
+        self.readonly = match toggle {
+            true => Some("readonly".to_string()),
+            false => None
+        };
+        self
+    }
+
+    pub fn required(mut self, toggle: bool) -> Self {
+        self.required = match toggle {
+            true => Some("required".to_string()),
+            false => None
+        };
+        self
+    }
+
+    pub fn with_help_text(mut self, help_text: &str) -> Self {
+        self.help_text = help_text.to_string();
+        self
+    }
+
+    pub fn using_template(mut self, template: &str) -> Self {
+        self.template = template.to_string();
+        self
+    }
+
+    // Input GETTERS.
+
+    pub fn name(&self) -> &str {
+        match &self.name {
+            Some(name) => name.as_str(),
+            _ => ""
+        }
+    }
+
+    pub fn value(&self) -> &str {
+        match &self.value {
+            Some(value) => value.as_str(),
+            _ => ""
+        }
+    }
+
+    pub fn label(&self) -> &str {
+        self.label.as_str()
+    }
+
+    pub fn size(&self) -> Option<u16> {
+        self.size
+    }
+
+    pub fn minlength(&self) -> Option<u16> {
+        self.minlength
+    }
+
+    pub fn maxlength(&self) -> Option<u16> {
+        self.maxlength
+    }
+
+    pub fn placeholder(&self) -> &str {
+        match &self.placeholder {
+            Some(placeholder) => placeholder.as_str(),
+            _ => ""
+        }
+    }
+
+    pub fn has_autofocus(&self) -> bool {
+        match &self.autofocus {
+            Some(_) => true,
+            _ => false
+        }
+    }
+
+    pub fn has_autocomplete(&self) -> bool {
+        match &self.autocomplete {
+            Some(_) => false,
+            _ => true
+        }
+    }
+
+    pub fn is_disabled(&self) -> bool {
+        match &self.disabled {
+            Some(_) => true,
+            _ => false
+        }
+    }
+
+    pub fn is_readonly(&self) -> bool {
+        match &self.readonly {
+            Some(_) => true,
+            _ => false
+        }
+    }
+
+    pub fn is_required(&self) -> bool {
+        match &self.required {
+            Some(_) => true,
+            _ => false
+        }
+    }
+
+    pub fn help_text(&self) -> &str {
+        self.help_text.as_str()
+    }
+
+    pub fn template(&self) -> &str {
+        self.template.as_str()
+    }
+}
+
+fn always() -> bool {
+    true
+}

src/base/component/form/mod.rs

@@ -0,0 +1,11 @@
+mod form;
+pub use form::{Form, FormMethod};
+
+mod input;
+pub use input::Input;
+mod hidden;
+pub use hidden::Hidden;
+mod date;
+pub use date::Date;
+mod button;
+pub use button::Button;

src/base/component/mod.rs

@@ -1,2 +1,7 @@
-pub mod container;
-pub mod chunck;
+mod container;
+pub use container::Container;
+mod chunck;
+pub use chunck::Chunck;
+
+pub mod form;
+pub use form::{Form, FormMethod};