├── .gitignore
├── CHANGELOG.md
├── LICENSE.md
├── README.md
├── examples
    ├── everything.http
    ├── get.http
    ├── loop.http
    └── test_cookie_and_post.http
├── grammar.txt
├── httplang.py
├── httplang
    ├── __init__.py
    ├── evaluate.py
    ├── global_data.py
    ├── make_request.py
    ├── parse.py
    ├── test.httpl
    └── tokenize.py
├── package-lock.json
├── requirements.txt
├── setup.py
└── test.httpl


/.gitignore:
--------------------------------------------------------------------------------
 1 | *.pyc
 2 | *.swp
 3 | *.swo
 4 | 
 5 | # Byte-compiled / optimized / DLL files
 6 | __pycache__/
 7 | *.py[cod]
 8 | 
 9 | # C extensions
10 | *.so
11 | 
12 | # Distribution / packaging
13 | .Python
14 | env/
15 | build/
16 | develop-eggs/
17 | dist/
18 | downloads/
19 | eggs/
20 | .eggs/
21 | lib/
22 | lib64/
23 | parts/
24 | sdist/
25 | var/
26 | *.egg-info/
27 | .installed.cfg
28 | *.egg
29 | 
30 | # PyInstaller
31 | #  Usually these files are written by a python script from a template
32 | #  before PyInstaller builds the exe, so as to inject date/other infos into it.
33 | *.manifest
34 | *.spec
35 | 
36 | # Installer logs
37 | pip-log.txt
38 | pip-delete-this-directory.txt
39 | 
40 | # Unit test / coverage reports
41 | htmlcov/
42 | .tox/
43 | .coverage
44 | .coverage.*
45 | .cache
46 | nosetests.xml
47 | coverage.xml
48 | *,cover
49 | 
50 | # Translations
51 | *.mo
52 | *.pot
53 | 
54 | # Django stuff:
55 | *.log
56 | 
57 | # Sphinx documentation
58 | docs/_build/
59 | 
60 | # PyBuilder
61 | target/
62 | 
63 | # OS X
64 | *.DS*
65 | 
66 | # Test images
67 | *.jpg


--------------------------------------------------------------------------------
/CHANGELOG.md:
--------------------------------------------------------------------------------
1 | Change Log
2 | ==========
3 | 
4 | v0.1.0
5 | * Introduced loops
6 | * First official version
7 | 


--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2015 Frankie Primerano
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | About
 2 | =====
 3 | 
 4 | HTTPLang is a scripting language that makes writing HTTP request routines simpler.
 5 | 
 6 | Current Version
 7 | ===============
 8 | 
 9 | 0.2.0
10 | 
11 | What could I use it for?
12 | ====
13 | 
14 | - Testing APIs
15 | - Web Scraping
16 | -
17 | 
18 | 
19 | Installation
20 | ====
21 | * Clone the repo
22 | * Run `python setup.py install`
23 | 
24 | Usage
25 | ===
26 | `httplang l<file.http>`
27 | 
28 | Documentation
29 | =============
30 | 
31 | Important Note
32 | --------------
33 | 
34 | HTTPLang is very strict about things like spaces. Make sure that your code matches the spacing and what not exactly as shown in the examples. If not there will be errors.
35 | 
36 | Examples
37 | --------
38 | 
39 | 
40 | ```
41 | 
42 | set URL "http://google.com"
43 | do GET "/
44 | show RESPONSE
45 | 
46 | ``` 
47 | 
48 | ```
49 | set URL "http://google.com"
50 | label "loop"
51 | do GET /
52 | show STATUS
53 | goto "label"
54 | 
55 | ```
56 | 
57 | ```
58 | 
59 | set URL "http://somesite.com"
60 | set POSTDATA "username=myUsername&password=myPassword is this"
61 | do POST "/login"
62 | set COOKIE TMPCOOKIE
63 | do GET "/usercp"
64 | 
65 | ```
66 | 
67 | 


--------------------------------------------------------------------------------
/examples/everything.http:
--------------------------------------------------------------------------------
1 | set URL http://google.com/
2 | do GET /
3 | set URL $URL
4 | set POSTDATA a=1,b=2,c=3,d=4
5 | set COOKIE $TMPCOOKIE
6 | do POST /
7 | 


--------------------------------------------------------------------------------
/examples/get.http:
--------------------------------------------------------------------------------
1 | set URL http://google.com/
2 | do GET /
3 | show $HTML
4 | 


--------------------------------------------------------------------------------
/examples/loop.http:
--------------------------------------------------------------------------------
1 | set URL http://google.com
2 | loop 2
3 | do GET /
4 | show $STATUS
5 | endloop
6 | 


--------------------------------------------------------------------------------
/examples/test_cookie_and_post.http:
--------------------------------------------------------------------------------
1 | set URL http://localhost:5000/
2 | do GET /
3 | set POSTDATA one=1,two=2
4 | do POST /
5 | set COOKIE $TMPCOOKIE
6 | do GET /
7 | 


--------------------------------------------------------------------------------
/grammar.txt:
--------------------------------------------------------------------------------
 1 | <set> := <global_var> <string> 
 2 | <do> := <method> <string>
 3 | <method> := GET | POST | PUT | DELETE | PATCH
 4 | <global_var> := URL | TMPCOOKIE | COOKIE | HTML | POSTDATA | USERAGENT | STATUS | VALUE | LINKS
 5 | <show> := <global_var>
 6 | <condition> := <expr> <goto>
 7 | <expr> := (<global_var> | <string> | <int>) <operator> (<global_var> | <string> | <int> ) 
 8 | <label> := <string>
 9 | <goto> := <int> | <label>
10 | <operator> := "==" | "!=" | ">=" | "<="
11 | <string> := "\"(.*)?\""
12 | <int> := "[0-9]+"
13 | 


--------------------------------------------------------------------------------
/httplang.py:
--------------------------------------------------------------------------------
 1 | from httplang import *
 2 | import sys
 3 | import os
 4 | 
 5 | if len(sys.argv) < 2:
 6 |     sys.exit("Usage: python httplang.py <file>.httpl")
 7 | 
 8 | if not os.path.exists(sys.argv[1]):
 9 |     sys.exit("No file names {}".format(sys.argv[1]))
10 | 
11 | evaluate.evaluate(parse.program(tokenize.getTokens(open(sys.argv[1]))))
12 | 


--------------------------------------------------------------------------------
/httplang/__init__.py:
--------------------------------------------------------------------------------
1 | import evaluate
2 | import global_data
3 | import make_request
4 | import parse
5 | import tokenize
6 | 


--------------------------------------------------------------------------------
/httplang/evaluate.py:
--------------------------------------------------------------------------------
 1 | import operator
 2 | import parse 
 3 | import tokenize
 4 | import global_data
 5 | import make_request
 6 | 
 7 | operators = {
 8 |     "==":operator.eq,
 9 |     "!=":operator.ne,
10 |     ">=":operator.ge,
11 |     "<=":operator.le,
12 |     ">":operator.gt,
13 |     "<":operator.lt
14 | }
15 | 
16 | 
17 | def evaluate(ast):
18 |     ast = list(ast)
19 |     switch = {
20 |         "DO":do,
21 |         "SET":set_,
22 |         "SHOW":show,
23 |         "GOTO":goto,
24 |         "CONDITION":condition
25 |     }
26 |     while global_data.line_on < len(ast):
27 |         on = ast[global_data.line_on]
28 |         tt = on.token_type
29 |         if switch.get(tt):
30 |             switch[tt](on)
31 |         global_data.line_on += 1
32 | 
33 | def do(line):
34 |     method = line.left.lexeme
35 |     path = line.right.lexeme
36 |     switch = {
37 |         "GET":make_request.GET,
38 |         "POST":make_request.POST,
39 |         "PUT":make_request.PUT,
40 |         "DELETE":make_request.DELETE,
41 |         "PATCH":make_request.PATCH
42 |     }
43 |     switch[method](path)
44 | 
45 | def set_(line):
46 |     global_var = line.left.lexeme
47 |     val = line.right.token_type
48 |     if val == "GLOBAL":
49 |         val = global_data.GLOBALS[line.right.lexeme]
50 |     elif val == "STRING":
51 |         val = line.right.lexeme
52 |     global_data.GLOBALS[global_var] = val
53 | 
54 | def show(line):
55 |     if line.left.token_type == "GLOBAL":
56 |         print(global_data.GLOBALS[line.left.lexeme])
57 |     elif line.left.token_type == "STRING":
58 |         print(line.left.lexeme)
59 | 
60 | def goto(line):
61 |     global_data.line_on = global_data.labels[line.left.lexeme]
62 | 
63 | def condition(line):
64 |     condition = line.left.lexeme
65 |     larg = line.left.left
66 |     rarg = line.left.right
67 |     if larg.token_type == "GLOBAL":
68 |         larg = global_data.GLOBALS[larg.lexeme]
69 |     else:
70 |         larg = larg.lexeme
71 |     if rarg.token_type == "GLOBAL":
72 |         rarg = global_data.GLOBALS[rarg.lexeme]
73 |     else:
74 |         rarg = rarg.lexeme
75 |     if operators[condition](str(larg), str(rarg)): # THis is a temp fix, when integers are more important this can't be used.
76 |         goto(line.right)
77 | 
78 | if __name__ == "__main__":
79 |     f = "test.httpl"
80 |     tokens = tokenize.getTokens(open(f))
81 |     evaluate(parse.program(tokens))
82 | 
83 | 


--------------------------------------------------------------------------------
/httplang/global_data.py:
--------------------------------------------------------------------------------
 1 | labels = {}
 2 | 
 3 | line_on = 0
 4 | 
 5 | GLOBALS = {
 6 |     "URL":"",
 7 |     "SETCOOKIE":"",
 8 |     "COOKIE":"",
 9 |     "HTML":"",
10 |     "POSTDATA":"",
11 |     "USERAGENT":"",
12 |     "STATUS":"",
13 |     "LINKS":"",
14 | }
15 | 
16 | 


--------------------------------------------------------------------------------
/httplang/make_request.py:
--------------------------------------------------------------------------------
 1 | try:
 2 |     import urllib2 as urllib
 3 | except:
 4 |     import urllib.request as urllib
 5 | import global_data
 6 | import sys
 7 | from global_data import GLOBALS
 8 | 
 9 | def setValues(response):
10 |     GLOBALS['RESPONSE'] = response.read()
11 |     GLOBALS['STATUS'] = response.code
12 |     GLOBALS['SETCOOKIE'] = response.info()['set-cookie']
13 | 
14 | def getURL():
15 |     url = GLOBALS['URL']
16 |     if not url:
17 |         sys.exit("Variable Error: URL is not set line {}".format(global_data.line_on))
18 |     return url   
19 | 
20 | def getOpener():
21 |     opener = urllib.build_opener()
22 |     opener.addheaders.append(('Cookie', GLOBALS['COOKIE']))
23 |     opener.addheaders.append(("User-Agent", GLOBALS['USERAGENT']))
24 |     return opener
25 | 
26 | def GET(path):
27 |     url = getURL()
28 |     opener = getOpener()
29 |     request = urllib.Request(url)
30 |     response = opener.open(request)
31 |     setValues(response)
32 | 
33 | def POST(path):
34 |     url = getURL()
35 |     opener = getOpener()
36 |     request = urllib.Request(url, GLOBALS['POSTDATA'])
37 |     response = opener.open(request)
38 |     setValues(response)
39 | 
40 | def PATCH(path):
41 |     pass
42 | 
43 | def DELETE(path):
44 |     pass
45 | 
46 | def PUT(path):
47 |     pass
48 | 


--------------------------------------------------------------------------------
/httplang/parse.py:
--------------------------------------------------------------------------------
  1 | import tokenize
  2 | import sys
  3 | import global_data
  4 | import itertools
  5 | 
  6 | global line
  7 | line = 0
  8 | 
  9 | class AST: 
 10 |     def __init__(self, left, right, tt, lexeme, l):
 11 |         self.left = left
 12 |         self.right = right
 13 |         self.token_type = tt
 14 |         self.lexeme = lexeme
 15 |         self.line = l
 16 | 
 17 | def program(tokens):
 18 |     global line
 19 |     switch = {
 20 |         "DO":do,
 21 |         "SET":set_,
 22 |         "SHOW":show,
 23 |         "LABEL":label,
 24 |         "GOTO":goto,
 25 |         "CONDITION":condition
 26 |     }
 27 |     for token in tokens:
 28 |         tt = token['tokenType']
 29 |         if switch.get(tt):
 30 |             line += 1
 31 |             yield switch[tt](tokens) 
 32 |         else:
 33 |             sys.exit("Parse Error: Don't know what to do with {} line {}".format(token, line))
 34 | 
 35 | def condition(tokens):
 36 |     condition_expr = expr(tokens)
 37 |     goto_check = tokens.next()
 38 |     if goto_check['tokenType'] != "GOTO":
 39 |         sys.exit("Parse Error: goto expected after condition line {}".format(line))
 40 |     goto_part = goto(tokens)
 41 |     return AST(condition_expr, goto_part, "CONDITION", None, line)
 42 | 
 43 | def do(tokens):
 44 |     method_val = method(tokens)
 45 |     location = string(tokens)
 46 |     return AST(method_val, location, "DO", None, line)
 47 | 
 48 | def set_(tokens):
 49 |     global_val = global_var(tokens)
 50 |     tokens, copy = itertools.tee(tokens)
 51 |     type_check = copy.next()['tokenType']
 52 |     if type_check == "GLOBAL":
 53 |         location = global_var(tokens)
 54 |     else:
 55 |         location = string(tokens)
 56 |     return AST(global_val, location, "SET", None, line)
 57 | 
 58 | def expr(tokens):
 59 |     left_arg = tokens.next()
 60 |     if left_arg['tokenType'] not in ["GLOBAL", "STRING", "INTEGER"]:
 61 |         sys.exit("Parse Error: Invalid left argument {} line {}".format(left_arg['lexeme'], line))
 62 | 
 63 |     op = tokens.next()
 64 |     if op['tokenType'] != "OPERATOR":
 65 |         sys.exit("Parse Error: Invalid operator {} line {}".format(op['lexeme'], line))
 66 | 
 67 |     right_arg = tokens.next()
 68 |     if right_arg['tokenType'] not in ["GLOBAL", "STRING", "INTEGER"]:
 69 |         sys.exit("Parse Error: Invalid right argument {} line {}".format(right_arg["lexeme"], line))
 70 |     return AST(
 71 |             AST(None, None, left_arg['tokenType'], left_arg['lexeme'], line),
 72 |             AST(None, None, right_arg["tokenType"], right_arg['lexeme'], line),
 73 |             "OPERATOR",
 74 |             op['lexeme'],
 75 |             line)
 76 | 
 77 | def show(tokens):
 78 |     tokens, copy = itertools.tee(tokens)
 79 |     type_check = copy.next()['tokenType']
 80 |     if type_check == "STRING":
 81 |         variable_name = string(tokens)
 82 |     else:
 83 |         variable_name = global_var(tokens)
 84 |     return AST(variable_name, None, "SHOW", None, line)
 85 | 
 86 | def label(tokens):
 87 |     label_name = string(tokens)
 88 |     global_data.labels[label_name.lexeme] = line - 1
 89 |     return AST(label_name, None, "LABEL", None, line)
 90 | 
 91 | def goto(tokens):
 92 |     label_name = string(tokens)
 93 |     return AST(label_name, None, "GOTO", None, line)
 94 | 
 95 | def string(tokens):
 96 |     string_val = tokens.next()
 97 |     if string_val['tokenType'] != "STRING":
 98 |         sys.exit("Parse Error: {} is not a STRING line {}".format(string_val['lexeme'], line))
 99 |     return AST(None, None, string_val['tokenType'], string_val['lexeme'], line)
100 | 
101 | def integer(tokens):
102 |     int_val = tokens.next()
103 |     if int_val['tokenType'] != "INTEGER":
104 |         sys.exit("TypeError: {} is not an INTEGER line {}".format(int_val['lexeme'], line))
105 |     try:
106 |         int_val['lexeme'] = int(int_val['lexeme'])
107 |     except:
108 |         sys.exit("Type Error: {} is not an INTEGER")
109 |                 
110 |     return AST(None, None, int_val['tokenType'], int_val['lexeme'], line)
111 | 
112 | def method(tokens):
113 |     method_val = tokens.next()
114 |     if method_val['tokenType'] != "METHOD":
115 |         sys.exit("Type Error: {} is not a METHOD line {}".format(method_val['lexeme'], line))
116 |     return AST(None, None, method_val['tokenType'], method_val['lexeme'], line)
117 | 
118 | def global_var(tokens):
119 |     variable_val = tokens.next()
120 |     if variable_val['tokenType'] == "GLOBAL_VAR":
121 |         sys.exit("Type Error: {} is not a GLOBAL_VAR line {}".format(variable_val['lexeme'], line))
122 |     return AST(None, None, variable_val['tokenType'], variable_val['lexeme'], line)
123 | 
124 | if __name__ == "__main__":
125 |     print(list(program(tokenize.getTokens(open("test.httpl")))))
126 | 
127 | 


--------------------------------------------------------------------------------
/httplang/test.httpl:
--------------------------------------------------------------------------------
1 | set URL "http://google.com"
2 | do POST "/"
3 | show COOKIE
4 | set COOKIE SETCOOKIE
5 | show COOKIE
6 | 


--------------------------------------------------------------------------------
/httplang/tokenize.py:
--------------------------------------------------------------------------------
 1 | import re
 2 | import sys
 3 | 
 4 | tokens = {
 5 |         "^do$":"DO",
 6 |         "^set$":"SET",
 7 |         "^GET$|^POST$|^PUT$|^DELETE$|^PATCH$":"METHOD",
 8 |         "^URL$|^SETCOOKIE$|^COOKIE$|^RESPONSE$|^POSTDATA$|^USERAGENT$|^STATUS$|^LINKS$":"GLOBAL",
 9 |         "^show$":"SHOW",
10 |         "^if$":"CONDITION",
11 |         "^label$":"LABEL",
12 |         "^goto$":"GOTO",
13 |         ">|<|==|!=|>=|<=":"OPERATOR",
14 |         "\"(.*?)\"":"STRING",
15 |         "[0-9]+":"INTEGER"
16 | }
17 | 
18 | def getTokens(stream):
19 |     token = ""
20 |     line = 1
21 |     for char in stream.read():
22 |         if char == " " or char == "\n":
23 |             for token_check in tokens:
24 |                 check = re.findall(token_check, token)
25 |                 if check:
26 |                     token = ""
27 |                     yield {
28 |                             "lexeme":check[0],
29 |                             "tokenType":tokens[token_check]
30 |                           }
31 |                     break
32 |             else:
33 |                 sys.exit("Invalid Token: {} on line {}".format(token, line))
34 |             if char == "\n":
35 |                 line += 1
36 |         else:
37 |             token += char
38 | 
39 | if __name__ == "__main__":
40 |     print(list(getTokens(open("test.httpl"))))
41 | 


--------------------------------------------------------------------------------
/package-lock.json:
--------------------------------------------------------------------------------
1 | {
2 |   "lockfileVersion": 1
3 | }
4 | 


--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | requests
2 | 
3 | 


--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
 1 | from setuptools import setup
 2 | import sys
 3 | 
 4 | setup(name='HTTPLang',
 5 |       version='2.0.0',
 6 |       author='Frankie Primerano',
 7 |       author_email='max00355@gmail.com',
 8 |       packages=['httplang'],
 9 |       entry_points={
10 |           'console_scripts': ['httplang=httplang:console_main'],
11 |       },
12 |       url='https://github.com/Max00355/HTTPLang',
13 |       description='A scripting language to do HTTP routines.',
14 |       classifiers=[
15 |           'Operating System :: POSIX',
16 |           'Programming Language :: Python',
17 |           'Programming Language :: Python :: 2',
18 |           'Programming Language :: Python :: 2.7',
19 |           'Programming Language :: Python :: 3',
20 |           'Programming Language :: Python :: 3.2',
21 |           'Programming Language :: Python :: 3.3',
22 |           'License :: OSI Approved :: MIT License',
23 |           'Topic :: Utilities'
24 |       ],
25 |       )
26 | 


--------------------------------------------------------------------------------
/test.httpl:
--------------------------------------------------------------------------------
1 | label "start"
2 | set URL "http://google.com"
3 | do GET "/"
4 | show "LOL"
5 | show STATUS
6 | if STATUS == 200 goto "start"
7 | 


--------------------------------------------------------------------------------