创建项目

Author: liguifa

autumn-mvc/__init__.py

@@ -0,0 +1,4 @@
+from .config import config # NOQA
+from .base import application as autumn # NOQA
+from .base import controller # NOQA
+from .base import content_type # NOQA

autumn-mvc/base/__init__.py

@@ -0,0 +1,3 @@
+from .application import application # NOQA
+from .controller import controller # NOQA
+from .controller import content_type # NOQA

autumn-mvc/base/application.py

@@ -0,0 +1,44 @@
+from wsgiref.simple_server import make_server
+from .. import config
+from .guid import guid
+import sys
+import os
+
+
+class context:
+    def __init__(self, environ, write):
+        self.environ = environ
+        self.write = write
+        self.messages = None
+
+
+class application:
+    def __init__(self):
+        self.app = None
+        self.middlewares = []
+        self.guid = guid
+
+    def start(self):
+        self._print_info()
+        sys.path.insert(0, config["middleware"]["path"])
+        for middleware in config["middleware"]["list"]:
+            self.middleware(getattr(__import__(middleware), middleware)) # NOQA
+        make_server('', config["port"], self._run).serve_forever()
+
+    def middleware(self, middleware):
+        self.middlewares.append(middleware)
+
+    def _print_info(self):
+        print("---------------------------------------------------")
+        print(" port | {port} ".format(port=config["port"]))
+        print(" url  | http://localhost:{port} ".format(port=config["port"]))
+        print(" path | {path} ".format(path=os.getcwd()))
+        print("---------------------------------------------------")
+
+    def _run(self, environ, start_response):
+        request = context(environ, None)
+        response = context(environ, start_response)
+        for middleware in self.middlewares:
+            if not middleware(self, request, response, config):
+                break
+        return response.messages

autumn-mvc/base/controller.py

@@ -0,0 +1,49 @@
+import pickle
+
+
+class content_type:
+    html = 1
+    json = 2
+    string = 3
+
+
+class controller:
+    def __init__(self):
+        self.config = {}
+        self.request = None
+        self.response = None
+
+    def html(self, input):
+        return {
+            "template": input,
+            "type": content_type.html
+        }
+
+    def view(self):
+        path = self.config["view"]["path"] # NOQA
+        action = self.request.router.action # NOQA
+        suffix = self.config["view"]["suffix"] # NOQA
+        file = "{path}/{action}.{suffix}".format(**locals())
+        template = None 
+        with open(file, 'r') as f:
+            template = f.read()
+        return self.html(template)
+
+    def json(self, input):
+        return {
+            "template": str(pickle.dumps(input)),
+            "type": content_type.json
+        }
+
+    def assign(self, key, value):
+        if not hasattr(self.response, "views"):
+            self.response.views = {}
+        self.response.views[key] = value
+
+    @property
+    def cookie(self):
+        return self.response.cookie
+
+    @property
+    def session(self):
+        return self.response.session

autumn-mvc/base/guid.py

@@ -0,0 +1,18 @@
+import threading
+import os
+import uuid
+
+
+def guid():
+    def get_mac_address():
+        node = uuid.getnode()
+        return uuid.UUID(int=node).hex[-12:]
+    threadId = threading.currentThread().ident
+    processId = os.getpid()
+    mac = get_mac_address()
+    random = list("{threadId}{processId}{mac}".format(**locals()))[0:32] # NOQA
+    random.insert(19, "-")
+    random.insert(15, "-")
+    random.insert(11, "-")
+    random.insert(7, '-')
+    return "".join(random)

autumn-mvc/config/__init__.py

@@ -0,0 +1 @@
+from .config import config # NOQA

autumn-mvc/config/config.py

@@ -0,0 +1,47 @@
+import os
+
+config = {
+    # Web应用端口
+    "port": 3055,
+    "middleware": {
+        # 框架内置中间件
+        "list": [
+            "http_middleware",
+            "static_middleware",
+            "cookie_middleware",
+            "session_middleware",
+            "router_middleware",
+            "mvc_middleware",
+            "template_middleware",
+            "response_middleware"],
+        # 中间件目录
+        "path": "{path}/../middleware".format(path=os.path.dirname(os.path.realpath(__file__))), # NOQA
+    },
+    "controller": {
+        # 控制器目录
+        "path": "{path}/controller".format(path=os.getcwd())
+    },
+    "router": {
+        # 路由模式
+        "model": 1,
+        # 默认控制器
+        "controller": "home",
+        # 默认action
+        "action": "index"
+    },
+    "view": {
+        # 视图目录
+        "path": "{path}/view".format(path=os.getcwd()),
+        # 视图后缀名
+        "suffix": "html"
+    },
+    "static": {
+        # 静态文件后缀名
+        "suffix": ["html", "jpg", "ico", "png", "css", "json", "js", "gif", "txt"], # NOQA
+        # 静态文件路径
+        "path": "{path}/static".format(path=os.getcwd()),
+    },
+    "session": {
+        "id": "autumn_session_id"
+    }
+}

autumn-mvc/middleware/cookie_middleware.py

@@ -0,0 +1,33 @@
+def cookie_middleware(app, request, response, config):
+    request.cookie = cookies()
+    if "HTTP_COOKIE" in request.environ:
+        for cookie in request.environ["HTTP_COOKIE"].split(";"):
+            key = cookie.split("=")[0]
+            value = cookie.split("=")[1]
+            setattr(request.cookie, key, value)
+
+    def set_cookie(key, value):
+        if "Set-Cookie" not in response.heads:
+            response.heads["Set-Cookie"] = u"{key}={value};".format(**locals())
+        else:
+            response.heads["Set-Cookie"] += u";{key}={value}".format(**locals())
+
+    response.cookie = cookies(set_cookie) # NOQA)
+    return True
+
+
+class cookies:
+    def __init__(self, set_cooie=None):
+        if set_cooie:
+            self.__dict__["set_cooie"] = set_cooie
+
+    def __setattr__(self, key, value):
+        print(key)
+        self.__dict__[key] = value
+        if "set_cooie" in self.__dict__ and key != "set_cookie":
+            self.__dict__["set_cooie"](key, value)
+
+    def __getattr__(self, key):
+        if key not in self.__dict__:
+            return None
+        return self.__dict__[key]

autumn-mvc/middleware/http_middleware.py

@@ -0,0 +1,23 @@
+def http_middleware(app, request, response, config):
+    # 设置 web url
+    if 'PATH_INFO' in request.environ:
+        request.url = response.url = request.environ["PATH_INFO"]
+    else:
+        request.url = response.url = ""
+
+    # 设置响应函数
+    def send(message):
+        html = message.encode("utf-8") if type(message) == str else message
+        if not response.messages:
+            response.messages = [html]
+        else:
+            response.messages.append(html)
+    response.send = send
+
+    # 状态码
+    response.status = 200
+
+    # 设置响应头
+    response.heads = {}
+
+    return True

autumn-mvc/middleware/mvc_middleware.py

@@ -0,0 +1,23 @@
+import sys
+
+content_types = {
+    1: "text/html",
+    2: "application/json"
+}
+
+
+def mvc_middleware(app, request, response, config):
+    # 获取controller
+    if request.router.controller:
+        sys.path.insert(0, config["controller"]["path"])
+        controller = getattr(__import__(request.router.controller), request.router.controller)() # NOQA
+        controller.request = request
+        controller.response = response
+        controller.config = config
+        # 执行action
+        body = getattr(controller, request.router.action)()
+        response.template = body["template"]
+        response.heads["Content-Type"] = content_types[body["type"]]
+    else:
+        response.template = ""
+    return True

autumn-mvc/middleware/response_middleware.py

@@ -0,0 +1,18 @@
+def response_middleware(app, request, response, config):
+    # 获取响应状态信息
+    status = statusCodes[response.status]
+    # 获取响应头信息
+    heads = []
+    for (key, value) in response.heads.items():
+        heads.append((key, value))
+    # 写入响应头
+    from pprint import pprint
+    pprint(heads)
+    response.write(status, heads)
+    # 写入响应体
+    response.send(response.template)
+
+
+statusCodes = {
+    200: "200 OK"
+}

autumn-mvc/middleware/router_middleware.py

@@ -0,0 +1,42 @@
+def router_middleware(app, request, response, config):
+    router_map = {
+        1: mvcRouter
+    }
+    request.router = router_map[config["router"]["model"]](request.url, config)
+    return True
+
+
+class router:
+    def __init__(self, url, config):
+        self.url = url
+        self._controller = config["router"]["controller"]
+        self._action = config["router"]["action"]
+        self._parameters = None
+        self._parse()
+
+    @property
+    def controller(self):
+        return self._controller
+
+    @property
+    def action(self):
+        return self._action
+
+    @property
+    def parameters(self):
+        return self._parameters
+
+    def _parse(self):
+        pass
+
+
+class mvcRouter(router):
+    def __init__(self, url, config):
+        super().__init__(url, config)
+
+    def _parse(self):
+        if self.url:
+            str_arr = self.url.split("/")
+            if str_arr and len(str_arr) > 2:
+                self._controller = str_arr[1]
+                self._action = str_arr[2]

autumn-mvc/middleware/session_middleware.py

@@ -0,0 +1,21 @@
+def session_middleware(app, request, response, config):
+    sessionId = getattr(request.cookie, config["session"]["id"])
+    if not sessionId:
+        sessionId = app.guid()
+        setattr(response.cookie, config["session"]["id"], sessionId)
+    request.session = response.session = sessions(app, sessionId)
+    return True
+
+
+class sessions:
+    def __init__(self, app, sessionId):
+        self.__dict__["app"] = app
+        self.__dict__["sessionId"] = sessionId
+
+    def __setattr__(self, key, value):
+        if not hasattr(self.__dict__["app"], "store"):
+            self.__dict__["app"].store = {}
+        self.__dict__["app"].store[key] = value
+
+    def __getattr__(self, key):
+        return self.__dict__["app"].store[self.__dict__["sessionId"]][key]

autumn-mvc/middleware/static_middleware.py

@@ -0,0 +1,9 @@
+def static_middleware(app, request, response, config):
+    suffix = request.url.split(".").pop()
+    if suffix in config["static"]["suffix"]:
+        file = "{path}/{filename}".format(path=config["static"]["path"], filename=request.url) # NOQA
+        with open(file, 'rb') as f:
+            response.send(f.read())
+        response.write("200 OK", [("Content-Type", "application/octet-stream")]) # NOQA
+        return False
+    return True

autumn-mvc/middleware/template_middleware.py

@@ -0,0 +1,19 @@
+import re
+
+
+def template_middleware(app, request, response, config):
+    html = response.template.replace('\n', ' ').replace('\r', '')
+    html = re.sub("<%(.*?)%>", replace_function, html)
+    html = re.sub("<<(.*?)>>", replate_object, html)
+    print(html)
+    html = "'{html}'".format(**locals())
+    response.template = eval(html)
+    return True
+
+
+def replace_function(match):
+    pass
+
+
+def replate_object(match):
+    return "'+response.views[\"{obj}\"]+'".format(obj=match.group(1))

setup.py

@@ -0,0 +1,8 @@
+from setuptools import find_packages, setup
+
+setup(name='autumn-mvc',
+      version='1.0',
+      description='一个依赖大于配置的MVC框架',
+      author='Guifa Li',
+      author_email='[email protected]',
+      url='https://www.github.com/liguifa/autumnMVC')