yosssi/gcss/element_base.go

package gcss

import (
        "bytes"
        "io"
)

// elementBase holds the common fields of an element.
type elementBase struct {
        ln     *line
        parent element
        sels   []*selector
        decs   []*declaration
        mixins []*mixinInvocation
        ctx    *context
}

// AppendChild appends a child element to the element.
func (eBase *elementBase) AppendChild(child element) {
        switch c := child.(type) {
        case *mixinInvocation:
                eBase.mixins = append(eBase.mixins, c)
        case *declaration:
                eBase.decs = append(eBase.decs, c)
        case *selector:
                eBase.sels = append(eBase.sels, c)
        }
}

// Base returns the element base.
func (eBase *elementBase) Base() *elementBase {
        return eBase
}

// SetContext sets the context to the element.
func (eBase *elementBase) SetContext(ctx *context) {
        eBase.ctx = ctx
}

// Context returns the top element's context.
func (eBase *elementBase) Context() *context {
        if eBase.parent != nil {
                return eBase.parent.Context()
        }

        return eBase.ctx
}

// hasMixinDecs returns true if the element has a mixin
// which has declarations.
func (eBase *elementBase) hasMixinDecs() bool {
        for _, mi := range eBase.mixins {
                if decs, _ := mi.decsParams(); len(decs) > 0 {
                        return true
                }
        }

        return false
}

// hasMixinSels returns true if the element has a mixin
// which has selectors.
func (eBase *elementBase) hasMixinSels() bool {
        for _, mi := range eBase.mixins {
                if sels, _ := mi.selsParams(); len(sels) > 0 {
                        return true
                }
        }

        return false
}

// writeDecsTo writes the element's declarations to w.
func (eBase *elementBase) writeDecsTo(w io.Writer, params map[string]string) (int64, error) {
        bf := new(bytes.Buffer)

        // Write the declarations.
        for _, dec := range eBase.decs {
                // Writing to the bytes.Buffer never returns an error.
                dec.writeTo(bf, params)
        }

        // Write the mixin's declarations.
        for _, mi := range eBase.mixins {
                decs, prms := mi.decsParams()

                for _, dec := range decs {
                        // Writing to the bytes.Buffer never returns an error.
                        dec.writeTo(bf, prms)
                }
        }

        n, err := w.Write(bf.Bytes())

        return int64(n), err
}

// newElementBase creates and returns an element base.
func newElementBase(ln *line, parent element) elementBase {
        return elementBase{
                ln:     ln,
                parent: parent,
        }
}
Revision:	1.1
Committed:	Mon Sep 30 00:42:06 2024 UTC (6 weeks, 4 days ago) by yakumo_izuru
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	Mirrored from https://git.chaotic.ninja/git/yakumo_izuru/aya
#	User	Rev	Content
1	yakumo_izuru	1.1	package gcss
2
3			import (
4			"bytes"
5			"io"
6			)
7
8			// elementBase holds the common fields of an element.
9			type elementBase struct {
10			ln *line
11			parent element
12			sels []*selector
13			decs []*declaration
14			mixins []*mixinInvocation
15			ctx *context
16			}
17
18			// AppendChild appends a child element to the element.
19			func (eBase *elementBase) AppendChild(child element) {
20			switch c := child.(type) {
21			case *mixinInvocation:
22			eBase.mixins = append(eBase.mixins, c)
23			case *declaration:
24			eBase.decs = append(eBase.decs, c)
25			case *selector:
26			eBase.sels = append(eBase.sels, c)
27			}
28			}
29
30			// Base returns the element base.
31			func (eBase elementBase) Base() elementBase {
32			return eBase
33			}
34
35			// SetContext sets the context to the element.
36			func (eBase elementBase) SetContext(ctx context) {
37			eBase.ctx = ctx
38			}
39
40			// Context returns the top element's context.
41			func (eBase elementBase) Context() context {
42			if eBase.parent != nil {
43			return eBase.parent.Context()
44			}
45
46			return eBase.ctx
47			}
48
49			// hasMixinDecs returns true if the element has a mixin
50			// which has declarations.
51			func (eBase *elementBase) hasMixinDecs() bool {
52			for _, mi := range eBase.mixins {
53			if decs, _ := mi.decsParams(); len(decs) > 0 {
54			return true
55			}
56			}
57
58			return false
59			}
60
61			// hasMixinSels returns true if the element has a mixin
62			// which has selectors.
63			func (eBase *elementBase) hasMixinSels() bool {
64			for _, mi := range eBase.mixins {
65			if sels, _ := mi.selsParams(); len(sels) > 0 {
66			return true
67			}
68			}
69
70			return false
71			}
72
73			// writeDecsTo writes the element's declarations to w.
74			func (eBase *elementBase) writeDecsTo(w io.Writer, params map[string]string) (int64, error) {
75			bf := new(bytes.Buffer)
76
77			// Write the declarations.
78			for _, dec := range eBase.decs {
79			// Writing to the bytes.Buffer never returns an error.
80			dec.writeTo(bf, params)
81			}
82
83			// Write the mixin's declarations.
84			for _, mi := range eBase.mixins {
85			decs, prms := mi.decsParams()
86
87			for _, dec := range decs {
88			// Writing to the bytes.Buffer never returns an error.
89			dec.writeTo(bf, prms)
90			}
91			}
92
93			n, err := w.Write(bf.Bytes())
94
95			return int64(n), err
96			}
97
98			// newElementBase creates and returns an element base.
99			func newElementBase(ln *line, parent element) elementBase {
100			return elementBase{
101			ln: ln,
102			parent: parent,
103			}
104			}