Methods for Working with the Register

• Substring
• Matched

              # FINDS FIRST `li`
- find:
    path: "li#li1"
    do:
    # USE `parse` TO FILL THE REGISTER WITH TEXT CONTENT OF CURRENT BLOCK, REGISTER VALUE: "Text and text"
    - parse

    # DO SOME NORMALIZATION
    - normalize:
        routine: replace_substring
        args:
            # REPLACE WORD "text" TO "some another text"
            - text: 'some another text'
            # REGISTER VALUE: "Text and some another text"

            # REPLACE WORD "and" TO "or"
            - and: or
            # REGISTER VALUE: "Text or some another text"

            # REPLACE WORD "another" TO "other"
            - another: other

    # REGISTER VALUE: "Text or some other text"
              

              # PLEASE NOTE:
# `replace_matched`, OPPOSITE TO `replace_substring`, WORKS UNTIL FIRST MATCH

# FINDS FIRST `li`
- find:
    path: "li#li1"
    do:
    # PARSE TEXT TO THE REGISTER
    - parse

    # NORMALIZE DATA
    - normalize:
        routine: replace_matched
        args:
            # LETS REPLACE VALUE OF THE REGISTER TO "some another text"
            # IF THERE IS WORD "text" IN THE REGISTER VALUE
            - text: 'some another text'
            # REGISTER VALUE: "some another text"

            # SINCE MATCH HAPPENED, ALL ARGUMENTS BELOW WILL BE IGNORED
            - and: or
            - another: other

    # REGISTER VALUE: "some another text"
              

• increment
• decrement
• capitalize
• upper_first
• upper
• lower

              # TO USE THIS MODE YOU NEED TO HAVE INTEGER VALUE IN THE REGISTER (1,2,158,203040523421 AND SO ON)
# FINDS FIRST `li`
- find:
    path: "li#li1"
    do:
    # GET ATTRIBUTE `id` VALUE AND EXTRACT JUST DIGITS
    - parse:
        attr: id
        filter: (\d+)
    # REGISTER VALUE: "1"

    # USE NORMALIZATION
    - normalize:
        routine: increment

    # REGISTER VALUE: "2"
              

              # TO USE THIS MODE YOU NEED TO HAVE INTEGER VALUE IN THE REGISTER (1,2,158,203040523421 AND SO ON)
# FINDS SECOND `li`
- find:
    path: "li#li2"
    do:
    # GET ATTRIBUTE `id` VALUE AND EXTRACT JUST DIGITS
    - parse:
        attr: id
        filter: (\d+)
    # REGISTER VALUE: "2"

    # DOING DECREMENT
    - normalize:
        routine: decrement

    # REGISTER VALUE: "1"
              

              # LETS CAPITALIZE STRING IN THE REGISTER
# FINDS FIRST `li`
- find:
    path: "li#li1"
    do:
    # PARSE TEXT TO THE REGISTER
    - parse
    # REGISTER VALUE: "Text and text"

    # APPLY CAPITALIZE ROUTINE
    - normalize:
        routine: capitalize

    # REGISTER VALUE: "Text and Text"
              

              # CHANGE ONLY FIRST LETTER OF STRING IN THE REGISTER TO UPPERCASE
# FINDS SECOND `li`
- find:
    path: "li#li2"
    do:
    # PARSE TEXT CONTENT TO THE REGISTER
    - parse
    # REGISTER VALUE: "text and text"

    # NORMALIZE CONTENT OF THE REGISTER
    - normalize:
        routine: upper_first

    # REGISTER VALUE: "Text and text"
              

              # BRING ALL LETTERS OF REGISTER CONTENT TO UPPER CASE
# FINDS SECOND `li`
- find:
    path: "li#li2"
    do:
    # PARSE TEXT TO THE REGISTER
    - parse
    # REGISTER VALUE: "text and text"

    # APPLY NORMALIZATION
    - normalize:
        routine: upper

    # REGISTER VALUE: "TEXT AND TEXT"
              

              # BRING ALL LETTERS OF REGISTER CONTENT TO LOWER CASE
# FINDS FIRST `li`
- find:
    path: "li#li1"
    do:
    # PARSE TEXT
    - parse
    # REGISTER VALUE: "Text and text"

    # NORMALIZE REGISTER
    - normalize:
        routine: lower

    # REGISTER VALUE: "text and text"
              

• url
• escape_html
• unescape_html

              # CHANGING RELATIVE LINKS TO ABSOLUTE
# FINDS `a`
- find:
    path: a
    do:
    # EXTRACT VALUE OF ATTRIBUTE `href`
    - parse:
        attr: href
    # REGISTER VALUE: sandbox.html

    # LETS NORMALIZE URL
    - normalize:
        routine: url

    # REGISTER VALUE: https://www.diggernaut.com/sandbox.html
              

              # CONVERTING SYMBOLS LIKE <, >, " TO HTML ENTITIES
# FINDS FIRST `li`
- find:
    path: "li#li1"
    do:
    # PARSE HTML CONTENT FROM CURRENT BLOCK
    - parse:
        format: html
    # REGISTER VALUE: <li class="item" id="1">Text and text</li>

    # APPLY NORMALIZATION
    - normalize:
        routine: escape_html

    # REGISTER VALUE:: 
                

              # REPLACE ALL HTML ENTITIES TO CORRSPONDING CHARACTERS LIKE <, >, " ETC
# FINDS FIRST `li`
- find:
    path: "li#li1"
    do:
    # LETS PUT LITERAL VALUE TO THE REGISTER
    - register_set:

    # NORMALIZE REGISTER VALUE
    - normalize:
        routine: unescape_html

    # REGISTER VALUE: <li class="item" id="1">Text and text</li>
              

• JSON2XML

              # CONVERTING JSON DOCUMENT TO THE XML BLOCK
# FINDS FIRST `script`
- find:
    path: script
    slice: 0
    do:
    # PARSE TEXT
    - parse
    # REGISTER VALUE: var items = {"items":[{"item": {"somefield1": "text", "somefield2": "another text"}}]};

    # REMOVING STUFF WE DONT NEED
    - normalize:
        routine: replace_substring
        args:
            - \s*var\s*items\s*=\s*: ''
            - \s*;\s*$: '' 
    # REGISTER NOW HAS JSON CONTENT: {"items":[{"item": {"somefield1": "text", "somefield2": "another text"}}]}

    # CONVERT IT TO XML
    - normalize:
        routine: json2xml
    # REGISTER NOW HAS:
    # <body_safe>
    #   <items>
    #     <item>
    #       <somefield1>text</somefield1>
    #       <somefield2>another text</somefield2>
    #     </item>
    #   </items>
    # </body_safe>

    # PARSE XML CONTENT, CONVERT IT TO THE BLOCK AND SWITCH TO THIS NEW BLOCK CONTEXT
    - to_block

    # NOW WE ARE IN THE NEW BLOCK AND CAN TRAVERSE OVER ITS DOM STRUCTURE
    - find:
        path: item > somefield1
        do:
        - parse
        # REGISTER VALUE: "text"
              

• date_format

              # DATES MANIPULATIONS
# FINDS THIRD `li`
- find:
    path: 'li#li3'
    do:
    # PARSE TEXT
    - parse
    # REGISTER VALUE: 01/21/2017

    # CONVERT DATE TO UNIT TIMESTAMP
    - normalize:
        routine: date_format
        args:
            format_in: "%m/%d/%Y"
            format_out: "%s"
    # REGISTER VALUE: 1484956800

    # -----------------------------------------------------
    # LETS PARSE TEXT AGAIN
    - parse
    # REGISTER VALUE: 01/21/2017

    # ADD 2 YEARS TO THE DATE
    - normalize:
        routine: date_format
        args:
            format_in: "%m/%d/%Y"
            add_years: 2
            format_out: "%m/%d/%Y"
    # REGISTER VALUE: 01/21/2019

    # -----------------------------------------------------
    # PARSE TEXT ONE MORE TIME
    - parse

    # SUBSTRACT 1 YEAR AND CHANGE OUTPUT FORMAT
    - normalize:
        routine: date_format
        args:
            format_in: "%m/%d/%Y"
            add_years: -1
            format_out: "%B,%d %Y"
    # REGISTER VALUE: January,21 2016

    # -----------------------------------------------------
    # NOW LETS SET LITERAL VALUE TO THE REGISTER
    - register_set: '01/21/2017 00:00:00 +0400 UTC'

    # CONVERT IT TO THE TIMEZONE: America/New_York
    - normalize:
        routine: date_format
        args:
            format_in: "%m/%d/%Y %T %z %Z"
            timezone: 'America/New_York'
            format_out: "%m/%d/%Y %T %z %Z"
    # REGISTER VALUE: 01/20/2017 19:00:00 -0500 EST

    # -----------------------------------------------------
    # AS WE KNOW add_* HAS VARIATIONS:
    # add_years   - YEARS
    # add_months  - MONTHES
    # add_days    - DAYS
    # add_hours   - HOURS
    # add_minutes - MINUTES
    # add_seconds - SECONDS
    # YOU CAN USE THEM ALL TOGETHER
    - register_set: '01/21/2017 00:00:00 +0400 UTC'
    - normalize:
        routine: date_format
        args:
            format_in: "%m/%d/%Y %T %z %Z"
            add_years: 10
            add_months: 5
            add_days: 1
            add_hours: 6
            add_minutes: 15
            add_seconds: 50
            format_out: "%m/%d/%Y %T %z %Z"
    # REGISTER VALUE: 06/22/2027 06:15:50 +0000 UTC
                

• signature

              # CREATE SIGNATURE
# FINDS FIRST `li`
- find:
    path: 'li#li1'
    do:
    # PARSE TEXT
    - parse

    # REGISTER VALUE: "Text and text"
    - normalize:
        routine: signature
        args:
            algo: HMAC
            cypher: SHA256
            encode: Base64
            secret: A6A7A8A9

    # REGISTER VALUE: eQZxtV7Ae/wu3Enx8C2po9L7j3cefePEwoFZiTmkb7M=
              

• base64
• md5

              # FINDS FIRST `li`
- find:
    path: 'li#li1'
    do:
    # PARSE TEXT
    - parse
    # REGISTER VALUE: "Text and text"

    - normalize:
        routine: base64
    # REGISTER VALUE: VGV4dCBhbmQgdGV4dA==
              

              # FINDS FIRST `li`
- find:
    path: 'li#li1'
    do:
    # PARSE TEXT
    - parse
    # REGISTER VALUE: "Text and text"

    - normalize:
        routine: md5
    # REGISTER VALUE: be8bde1051516b04402f02e00b4687b7
              

• base64zlib_decode

              # LETS SET ENCODED VALUE DIRECTLY TO THE REGISTER
# ITS ENCODED STRING `some text`
- register_set: eJwrzs9NVShJrSgBABHoA5o=

# DECODE VALUE
- normalize:
    routine: Base64ZLIBDecode

# REGISTER VALUE: some text