update

Author: admpub

README.md

@@ -34,13 +34,13 @@ go get github.com/coscms/forms
 Forms
 =====
 
-There are two predefined styles for forms: base HTML forms and Bootstrap forms: they have different structures and predefined classes.
+There are two predefined themes for forms: base HTML forms and Bootstrap forms: they have different structures and predefined classes.
 Style aside, forms can be created from scratch or starting from a base instance.
 
 From scratch
 ------------
 
-You can create a form instance by simply deciding its style and providing its method and action:
+You can create a form instance by simply deciding its theme and providing its method and action:
 
 ```go
 form := NewWithConfig(&config.Config{

common/types.go

@@ -35,7 +35,7 @@ import (
 	"golang.org/x/sync/singleflight"
 )
 
-// Available form styles
+// Available form themes
 const (
 	BASE      = "base"
 	BOOTSTRAP = "bootstrap3"
@@ -93,14 +93,14 @@ const (
 	STATIC         = "static"
 )
 
-func SetTmplDir(style, tmplDir string) {
+func SetTmplDir(theme, tmplDir string) {
 	lockTmplDir.Lock()
-	tmplDirs[style] = tmplDir
+	tmplDirs[theme] = tmplDir
 	lockTmplDir.Unlock()
 }
 
-func TmplDir(style string) (tmplDir string) {
-	tmplDir, _ = tmplDirs[style]
+func TmplDir(theme string) (tmplDir string) {
+	tmplDir, _ = tmplDirs[theme]
 	return
 }
 

fields/field.go

@@ -54,7 +54,7 @@ type Field struct {
 	Choices      interface{}             `json:"choices,omitempty" xml:"choices,omitempty"`
 	ChoiceKeys   map[string]ChoiceIndex  `json:"choiceKeys,omitempty" xml:"choiceKeys,omitempty"`
 	AppendData   map[string]interface{}  `json:"appendData,omitempty" xml:"appendData,omitempty"`
-	Style        string                  `json:"style" xml:"style"`
+	Theme        string                  `json:"theme" xml:"theme"`
 	Format       string                  `json:"format,omitempty" xml:"format,omitempty"`
 	Language     string                  `json:"language,omitempty" xml:"language,omitempty"`
 	widget       widgets.WidgetInterface // Public Widget field for widget customization
@@ -81,18 +81,17 @@ func FieldWithType(name, t string) *Field {
 		Choices:      nil,
 		ChoiceKeys:   map[string]ChoiceIndex{},
 		AppendData:   map[string]interface{}{},
-		Style:        "",
 	}
 }
 
-func (f *Field) SetTemplate(tmpl string, style ...string) FieldInterface {
+func (f *Field) SetTemplate(tmpl string, theme ...string) FieldInterface {
 	f.Template = tmpl
 	if len(f.Template) > 0 && f.widget != nil && f.Template != tmpl {
 		var s string
-		if len(style) > 0 {
-			s = style[0]
+		if len(theme) > 0 {
+			s = theme[0]
 		} else {
-			s = f.Style
+			s = f.Theme
 		}
 		f.widget = widgets.BaseWidget(s, f.Type, f.Template)
 	}
@@ -120,10 +119,10 @@ func (f *Field) Lang() string {
 	return f.Language
 }
 
-// SetStyle sets the style (e.g.: BASE, BOOTSTRAP) of the field, correctly populating the Widget field.
-func (f *Field) SetStyle(style string) FieldInterface {
-	f.Style = style
-	f.widget = widgets.BaseWidget(style, f.Type, f.Template)
+// SetTheme sets the theme (e.g.: BASE, BOOTSTRAP) of the field, correctly populating the Widget field.
+func (f *Field) SetTheme(theme string) FieldInterface {
+	f.Theme = theme
+	f.widget = widgets.BaseWidget(theme, f.Type, f.Template)
 	return f
 }
 

fields/field_interface.go

@@ -24,14 +24,14 @@ type FieldInterface interface {
 	DeleteParam(key string) FieldInterface
 	AddCSS(key, value string) FieldInterface
 	RemoveCSS(key string) FieldInterface
-	SetStyle(style string) FieldInterface
+	SetTheme(theme string) FieldInterface
 	SetLabel(label string) FieldInterface
 	AddLabelClass(class string) FieldInterface
 	RemoveLabelClass(class string) FieldInterface
 	SetValue(value string) FieldInterface
 	Disabled() FieldInterface
 	Enabled() FieldInterface
-	SetTemplate(tmpl string, style ...string) FieldInterface
+	SetTemplate(tmpl string, theme ...string) FieldInterface
 	SetHelptext(text string) FieldInterface
 	AddError(err string) FieldInterface
 	MultipleChoice() FieldInterface

fields/field_test.go

@@ -11,7 +11,7 @@ import (
 
 func TestTextField(t *testing.T) {
 	f := FieldWithType(`title`, common.TEXT)
-	f.SetStyle(`base`)
+	f.SetTheme(`base`)
 	f.AddClass(`form-control`).AddClass(`row`)
 
 	assert.Equal(t, common.HTMLAttrValues([]string{`form-control`, `row`}), f.Classes)
@@ -31,7 +31,7 @@ func TestTextField(t *testing.T) {
 
 func TestCheckboxField(t *testing.T) {
 	f := FieldWithType(`title`, common.CHECKBOX)
-	f.SetStyle(`base`)
+	f.SetTheme(`base`)
 	f.AddChoice(`value1`, `text1`)
 	f.AddChoice(`value2`, `text2`, true)
 	f.AddChoice(`value3`, `text3`)
@@ -42,7 +42,7 @@ func TestCheckboxField(t *testing.T) {
 
 func TestSelectField(t *testing.T) {
 	f := FieldWithType(`title`, common.SELECT)
-	f.SetStyle(`base`)
+	f.SetTheme(`base`)
 	f.AddChoice(`value1`, `text1`)
 	f.AddChoice(`value2`, `text2`, true)
 	f.AddChoice(`value3`, `text3`)

fieldset.go

@@ -40,7 +40,7 @@ type FieldSetType struct {
 	Tags       common.HTMLAttrValues   `json:"tags" xml:"tags"`
 	FieldList  []fields.FieldInterface `json:"fieldList" xml:"fieldList"`
 	AppendData map[string]interface{}  `json:"appendData,omitempty" xml:"appendData,omitempty"`
-	FormStyle  string                  `json:"formStyle" xml:"formStyle"`
+	FormTheme  string                  `json:"formTheme" xml:"formTheme"`
 	Language   string                  `json:"language,omitempty" xml:"language,omitempty"`
 	Template   string                  `json:"template" xml:"template"`
 	fieldMap   map[string]int
@@ -89,7 +89,7 @@ func (f *FieldSetType) Data() map[string]interface{} {
 
 func (f *FieldSetType) render() string {
 	buf := bytes.NewBuffer(nil)
-	tpf := common.TmplDir(f.FormStyle) + "/" + f.FormStyle + "/" + f.Template + ".html"
+	tpf := common.TmplDir(f.FormTheme) + "/" + f.FormTheme + "/" + f.Template + ".html"
 	tpl, err := common.GetOrSetCachedTemplate(tpf, func() (*template.Template, error) {
 		return common.ParseFiles(common.LookupPath(tpf))
 	})
@@ -132,7 +132,7 @@ func (f *FieldSetType) SetTemplate(tmpl string) *FieldSetType {
 
 // FieldSet creates and returns a new FieldSetType with the given name and list of fields.
 // Every method for FieldSetType objects returns the object itself, so that call can be chained.
-func FieldSet(name string, label string, style string, elems ...fields.FieldInterface) *FieldSetType {
+func FieldSet(name string, label string, theme string, elems ...fields.FieldInterface) *FieldSetType {
 	ret := &FieldSetType{
 		Template:   "fieldset",
 		CurrName:   name,
@@ -143,7 +143,7 @@ func FieldSet(name string, label string, style string, elems ...fields.FieldInte
 		FieldList:  elems,
 		fieldMap:   map[string]int{},
 		AppendData: map[string]interface{}{},
-		FormStyle:  style,
+		FormTheme:  theme,
 	}
 	for i, elem := range elems {
 		ret.fieldMap[elem.OriginalName()] = i
@@ -183,7 +183,7 @@ func (f *FieldSetType) Elements(elems ...config.FormElement) *FieldSetType {
 }
 
 func (f *FieldSetType) addField(field fields.FieldInterface) *FieldSetType {
-	field.SetStyle(f.FormStyle)
+	field.SetTheme(f.FormTheme)
 	field.SetData(`container`, `fieldset`)
 	f.FieldList = append(f.FieldList, field)
 	f.fieldMap[field.OriginalName()] = len(f.FieldList) - 1

forms.go

@@ -62,7 +62,7 @@ func New() *Form {
 		FieldList:             []config.FormElement{},
 		fieldMap:              make(map[string]int),
 		containerMap:          make(map[string]string),
-		Style:                 common.BASE,
+		Theme:                 common.BASE,
 		Class:                 common.HTMLAttrValues{},
 		ID:                    "",
 		Params:                map[string]string{},
@@ -88,7 +88,7 @@ type Form struct {
 	AppendData map[string]interface{} `json:"appendData,omitempty" xml:"appendData,omitempty"`
 	Model      interface{}            `json:"model" xml:"model"`
 	FieldList  []config.FormElement   `json:"fieldList" xml:"fieldList"`
-	Style      string                 `json:"style" xml:"style"`
+	Theme      string                 `json:"theme" xml:"theme"`
 	Class      common.HTMLAttrValues  `json:"class" xml:"class"`
 	ID         string                 `json:"id" xml:"id"`
 	Params     map[string]string      `json:"params" xml:"params"`
@@ -202,7 +202,7 @@ func (f *Form) Init(c *config.Config, model ...interface{}) *Form {
 	if len(c.Theme) == 0 {
 		c.Theme = common.BASE
 	}
-	f.Style = c.Theme
+	f.Theme = c.Theme
 	f.Method = c.Method
 	f.Action = template.HTML(c.Action)
 	if len(model) > 0 {
@@ -217,8 +217,8 @@ func (f *Form) HTMLTemplate() (*template.Template, error) {
 		tmpl = f.config.Template
 	}
 	if len(tmpl) == 0 {
-		tmpl = common.TmplDir(f.Style) + `/baseform.html`
-		//tmpl = common.TmplDir(f.Style) + `/allfields.html`
+		tmpl = common.TmplDir(f.Theme) + `/baseform.html`
+		//tmpl = common.TmplDir(f.Theme) + `/allfields.html`
 	}
 	return common.GetOrSetCachedTemplate(tmpl, func() (*template.Template, error) {
 		return common.ParseFiles(common.LookupPath(tmpl))
@@ -629,15 +629,15 @@ func (f *Form) Elements(elems ...config.FormElement) {
 }
 
 func (f *Form) addField(field fields.FieldInterface) *Form {
-	field.SetStyle(f.Style)
+	field.SetTheme(f.Theme)
 	f.FieldList = append(f.FieldList, field)
 	f.fieldMap[field.OriginalName()] = len(f.FieldList) - 1
 	return f
 }
 
 func (f *Form) addFieldSet(fs *FieldSetType) *Form {
 	for _, v := range fs.FieldList {
-		v.SetStyle(f.Style)
+		v.SetTheme(f.Theme)
 		v.SetData("container", "fieldset")
 		f.containerMap[v.OriginalName()] = fs.OriginalName()
 	}
@@ -760,7 +760,7 @@ func (f *Form) LangSet(name string) *LangSetType {
 }
 
 func (f *Form) NewLangSet(name string, langs []*config.Language) *LangSetType {
-	return LangSet(name, f.Style, langs...)
+	return LangSet(name, f.Theme, langs...)
 }
 
 // FieldSet returns the fieldset identified by name. It returns an empty field if it is missing.
@@ -780,7 +780,7 @@ func (f *Form) FieldSet(name string) *FieldSetType {
 // NewFieldSet creates and returns a new FieldSetType with the given name and list of fields.
 // Every method for FieldSetType objects returns the object itself, so that call can be chained.
 func (f *Form) NewFieldSet(name string, label string, elems ...fields.FieldInterface) *FieldSetType {
-	return FieldSet(name, label, f.Style, elems...)
+	return FieldSet(name, label, f.Theme, elems...)
 }
 
 // SortAll SortAll("field1,field2") or SortAll("field1","field2")

langset.go

@@ -39,7 +39,7 @@ type LangSetType struct {
 	Tags       common.HTMLAttrValues  `json:"tags" xml:"tags"`
 	AppendData map[string]interface{} `json:"appendData,omitempty" xml:"appendData,omitempty"`
 	Alone      bool                   `json:"alone,omitempty" xml:"alone,omitempty"`
-	FormStyle  string                 `json:"formStyle" xml:"formStyle"`
+	FormTheme  string                 `json:"formTheme" xml:"formTheme"`
 
 	langMap      map[string]int                //{"zh-CN":1}
 	fieldMap     map[string]config.FormElement //{"zh-CN:title":0x344555}
@@ -104,7 +104,7 @@ func (f *LangSetType) Data() map[string]interface{} {
 
 func (f *LangSetType) render() string {
 	buf := bytes.NewBuffer(nil)
-	tpf := common.TmplDir(f.FormStyle) + "/" + f.FormStyle + "/" + f.Template + ".html"
+	tpf := common.TmplDir(f.FormTheme) + "/" + f.FormTheme + "/" + f.Template + ".html"
 	tpl, err := common.GetOrSetCachedTemplate(tpf, func() (*template.Template, error) {
 		return common.ParseFiles(common.LookupPath(tpf))
 	})
@@ -134,7 +134,7 @@ func (f *LangSetType) SetTemplate(tmpl string) *LangSetType {
 
 // FieldSet creates and returns a new FieldSetType with the given name and list of fields.
 // Every method for FieldSetType objects returns the object itself, so that call can be chained.
-func LangSet(name string, style string, languages ...*config.Language) *LangSetType {
+func LangSet(name string, theme string, languages ...*config.Language) *LangSetType {
 	ret := &LangSetType{
 		Languages:    languages,
 		langMap:      map[string]int{},
@@ -146,7 +146,7 @@ func LangSet(name string, style string, languages ...*config.Language) *LangSetT
 		Params:       map[string]interface{}{},
 		Tags:         common.HTMLAttrValues{},
 		AppendData:   map[string]interface{}{},
-		FormStyle:    style,
+		FormTheme:    theme,
 	}
 	for i, language := range languages {
 		ret.langMap[language.ID] = i
@@ -187,7 +187,7 @@ func (f *LangSetType) Elements(elems ...config.FormElement) {
 }
 
 func (f *LangSetType) addField(field fields.FieldInterface) *LangSetType {
-	field.SetStyle(f.FormStyle)
+	field.SetTheme(f.FormTheme)
 	if f.Alone {
 		if ind, ok := f.langMap[field.Lang()]; ok {
 			field.SetLang(f.Languages[ind].ID)
@@ -219,7 +219,7 @@ func (f *LangSetType) addFieldSet(fs *FieldSetType) *LangSetType {
 	if f.Alone {
 		if ind, ok := f.langMap[fs.Lang()]; ok {
 			for _, v := range fs.FieldList {
-				v.SetStyle(f.FormStyle)
+				v.SetTheme(f.FormTheme)
 				v.SetData("container", "langset")
 				v.SetLang(f.Languages[ind].ID)
 				v.SetName(f.Languages[ind].Name(v.OriginalName()))
@@ -239,7 +239,7 @@ func (f *LangSetType) addFieldSet(fs *FieldSetType) *LangSetType {
 		if k == 0 {
 			for _, v := range fs.FieldList {
 				v.SetLang(language.ID)
-				v.SetStyle(f.FormStyle)
+				v.SetTheme(f.FormTheme)
 				v.SetData("container", "langset")
 				key := v.Lang() + `:` + v.OriginalName()
 				f.fieldMap[key] = v
@@ -313,7 +313,7 @@ func (f *LangSetType) FieldSet(name string) *FieldSetType {
 // NewFieldSet creates and returns a new FieldSetType with the given name and list of fields.
 // Every method for FieldSetType objects returns the object itself, so that call can be chained.
 func (f *LangSetType) NewFieldSet(name string, label string, elems ...fields.FieldInterface) *FieldSetType {
-	return FieldSet(name, label, f.FormStyle, elems...)
+	return FieldSet(name, label, f.FormTheme, elems...)
 }
 
 //Sort Sort("field1:1,field2:2") or Sort("field1:1","field2:2")

widgets/widgets.go

@@ -17,7 +17,7 @@
 */
 
 //Package widgets This package contains the base logic for the creation and rendering of field widgets. Base widgets are defined for most input fields,
-// both in classic and Bootstrap3 style; custom widgets can be defined and associated to a field, provided that they implement the
+// both in classic and Bootstrap3 theme; custom widgets can be defined and associated to a field, provided that they implement the
 // WidgetInterface interface.
 package widgets
 
@@ -52,11 +52,11 @@ func (w *Widget) Render(data interface{}) string {
 	return buf.String()
 }
 
-// BaseWidget creates a Widget based on style and inpuType parameters, both defined in the common package.
-func BaseWidget(style, inputType, tmplName string) *Widget {
-	cachedKey := style + ", " + inputType + ", " + tmplName
+// BaseWidget creates a Widget based on theme and inpuType parameters, both defined in the common package.
+func BaseWidget(theme, inputType, tmplName string) *Widget {
+	cachedKey := theme + ", " + inputType + ", " + tmplName
 	tmpl, err := common.GetOrSetCachedTemplate(cachedKey, func() (*template.Template, error) {
-		fpath := common.TmplDir(style) + "/" + style + "/"
+		fpath := common.TmplDir(theme) + "/" + theme + "/"
 		urls := []string{common.LookupPath(fpath + "generic.html")}
 		tpath := widgetTmpl(inputType, tmplName)
 		urls = append(urls, common.LookupPath(fpath+tpath+".html"))