Method minificationHTML.parseElements has 222 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (m *minificationHTML) parseElements(node *html.Node) (*html.Node, error) {
    switch node.DataAtom {
    case atom.A:
        return m.openNode(node, false)
    case atom.Abbr:

Method DBWorker.saveMeta has a Cognitive Complexity of 35 (exceeds 20 allowed). Consider refactoring.

Open

func (w *DBWorker) saveMeta(tr *DBrw, meta *proxy.Meta, origin sql.NullInt64) error {
    hostID := meta.GetHostID()
    urlStr := meta.GetURL()
    urlNullID, err := w.getURLIDByStr(tr, urlStr)
    if err != nil {

• Read up
  Read up

Method Logger.Print has a Cognitive Complexity of 28 (exceeds 20 allowed). Consider refactoring.

Open

func (logger Logger) Print(values ...interface{}) {
    if len(values) > 1 {
        level := values[0]
        currentTime := "\n" + gorm.NowFunc().Format("2006-01-02 15:04:05")
        source := fmt.Sprintf("%v:", values[1])

• Read up
  Read up

Method DBWorker.saveMeta has 61 lines of code (exceeds 50 allowed). Consider refactoring.

Open

func (w *DBWorker) saveMeta(tr *DBrw, meta *proxy.Meta, origin sql.NullInt64) error {
    hostID := meta.GetHostID()
    urlStr := meta.GetURL()
    urlNullID, err := w.getURLIDByStr(tr, urlStr)
    if err != nil {

Method DBWorker.saveMeta has 10 return statements (exceeds 4 allowed).

Open

func (w *DBWorker) saveMeta(tr *DBrw, meta *proxy.Meta, origin sql.NullInt64) error {
    hostID := meta.GetHostID()
    urlStr := meta.GetURL()
    urlNullID, err := w.getURLIDByStr(tr, urlStr)
    if err != nil {

Method dictRead.nextGroup has 8 return statements (exceeds 4 allowed).

Open

func (d *dictRead) nextGroup() (*wordGroup, error) {
    if d.done {
        return nil, errors.New("done")
    }
    t, err := d.tokens.nextToken()

Method dictParser.nextWords has 8 return statements (exceeds 4 allowed).

Open

func (p *dictParser) nextWords() ([]string, error) {
    if p.finish {
        return nil, nil
    }
    t, err := p.nextToken()

Similar blocks of code found in 2 locations. Consider refactoring.

Open

func (m *minificationText) parseChildren(node *html.Node) (*html.Node, error) {
    var err error
    for it := node.FirstChild; it != nil; {
        it, err = m.parseNode(it)
        if err != nil {

• Read up
  Read up

Similar blocks of code found in 2 locations. Consider refactoring.

Open

func (m *minificationHTML) parseChildren(node *html.Node) (*html.Node, error) {
    var err error
    for it := node.FirstChild; it != nil; {
        it, err = m.parseNode(it)
        if err != nil {

• Read up
  Read up

Avoid deeply nested control flow statements.

Open

        } else if t.ttype == tokenEmpty {
            break
        } else {
            return nil, errors.New("unknown token")
        }

Method tokenRead.nextToken has 7 return statements (exceeds 4 allowed).

Open

func (t *tokenRead) nextToken() (*token, error) {
    if !t.scanner.Scan() {
        return &token{ttype: tokenEnd}, nil
    }

Method responseParser.processBody has 7 return statements (exceeds 4 allowed).

Open

func (r *responseParser) processBody(body []byte, contentType string) (database.State, error) {
    if !isHTML(body) {
        return database.StateParseError, werrors.New(ErrBodyNotHTML)
    }

Avoid deeply nested control flow statements.

Open

                    } else if b, ok := value.([]byte); ok {
                        formatedValues = append(formatedValues, fmt.Sprintf("'{...}%d'", len(b)))
                        // formatedValues = append(formatedValues, fmt.Sprintf("'%v'", string(b)))
                    } else if r, ok := value.(driver.Valuer); ok {
                        if value, err := r.Value(); err == nil && value != nil {

Method dictParser.nextToken has 6 return statements (exceeds 4 allowed).

Open

func (p *dictParser) nextToken() (token, error) {
    done, data, err := p.nextLine()

    if err != nil {
        return token{}, err

Method minificationHTML.parseElements has 6 return statements (exceeds 4 allowed).

Open

func (m *minificationHTML) parseElements(node *html.Node) (*html.Node, error) {
    switch node.DataAtom {
    case atom.A:
        return m.openNode(node, false)
    case atom.Abbr:

Method responseParser.Run has 5 return statements (exceeds 4 allowed).

Open

func (r *responseParser) Run(response *http.Response) error {
    contentType, contentEncoding, err := r.processMeta(response.StatusCode, &response.Header)
    if err != nil {
        _ = response.Body.Close()
        return err

Method Compressed.Scan has 5 return statements (exceeds 4 allowed).

Open

func (c *Compressed) Scan(value interface{}) error {
    if value == nil {
        var nilResult []byte
        c.Data = nilResult
        return nil

Function readBody has 5 return statements (exceeds 4 allowed).

Open

func readBody(contentEncoding string, body io.Reader) ([]byte, error) {
    var err error
    result := []byte{}
    if contentEncoding == "gzip" {
        reader, err := gzip.NewReader(body)

Method DBrw.AddHost has 5 return statements (exceeds 4 allowed).

Open

func (db *DBrw) AddHost(host *proxy.Host, baseURL string) (int64, error) {
    var id int64
    err := db.Transaction(func(tr *DBrw) error {
        tblHost := host.GetTable()
        err := tr.Create(tblHost).Error

Function Convert has 5 return statements (exceeds 4 allowed).

Open

func Convert(path string) error {
    file, err := os.Open(path)
    if err != nil {
        return err
    }