[RUBY] Machen wir Rails-like 2 (Controller Edition)

Einführung

Dieser Artikel ist eine Fortsetzung des vorherigen. ↓ ↓ ↓ https://qiita.com/alex0033/items/73f62ac7e5700ab2b4d6

Dieses Mal möchte ich das Routing in Rails implementieren, da es sich um eine Controller-Edition handelt.

Die anzustrebende Verzeichnisstruktur ist wie folgt.

directory
  |- app
      |- controllers
           |- basic_pages_controller
      |- views
           |- basic_pages
               |- home.html.erb #Startseite
               |- next.html.erb #Nächste Seite
  |- config
       |- routes.rb
  |- srv.rb

Punkt

Bis zum letzten Mal befindet es sich im folgenden Zustand.

-Sie können einen Server einrichten, indem Sie im Terminal `` `ruby srv.rb``` eingeben. ・ Wenn Sie auf http: // localhost: 3000 zugreifen, wird die Startseite angezeigt.

Die Ziele dieses Mal sind wie folgt.

・ Wenn Sie auf http: // localhost: 3000 (im Folgenden als Root-Pfad) zugreifen, wird die Homepage angezeigt. -Wenn Sie auf http: // localhost: 3000 / next zugreifen (im Folgenden als nächster Pfad bezeichnet), wird die nächste Seite angezeigt. ・ Gehen Sie durch den Controller, bevor Sie auf die Seite zugreifen

Daher lautet die Erläuterung dieses Artikels wie folgt.

    1. Anzeige der nächsten Seite ① Erstellen Sie eine Ansichtsdatei (app / views / basic_pages / next.html.erb) ② Versuchen Sie, von der Startseite aus mit dem Tag \ </ em> darauf zuzugreifen ③ Ändern Sie die Einstellung (srv.rb)
  2. Controller-like erstellen ① Reflexion der Logik durch Servlet ② Organisieren Sie Dateien so, dass sie wie ein Controller aussehen
    1. Routing ① Erstellen Sie eine Routing-Einstellungsdatei (config / route.rb) (2) Automatische Erzeugung von Routing durch Metaprogrammierung

1. 1. Anzeige der nächsten Seite

Lassen Sie uns zunächst eine nächste Seite erstellen, damit sie angezeigt werden kann. Beschreiben Sie in der folgenden Reihenfolge.

① Erstellen Sie eine Ansichtsdatei (app / views / basic_pages / next.html.erb) ② Versuchen Sie, von der Startseite aus mit dem Tag \ </ em> darauf zuzugreifen ③ Ändern Sie die Einstellung (srv.rb)

① Erstellen Sie eine Ansichtsdatei (app / views / basic_pages / next.html.erb)

Lassen Sie uns eine Ansichtsdatei erstellen.

erb:app/views/basic_pages/next.html.erb


<html>
  <head>
    <meta charset="utf-8">
  </head>
  <body>
    <h1>Nächste Seite</h1>
    <p>This is a next page.</p>
  </body>
</html>

② Versuchen Sie, von der Startseite aus mit dem Tag \ </ em> darauf zuzugreifen

Sie können nicht nur auf das Vorhandensein der Ansichtsdatei zugreifen. Versuchen wir daher, von der Startseite aus mit dem \ -Tag </ em> darauf zuzugreifen.

erb:app/views/basic_pages/home.html.erb


<html>
  <head>
    <meta charset="utf-8">
  </head>
  <body>
    <h1>Startseite</h1>
    <p>Hello, World</p>
    <%= 1 + 4 %>

    <!--Link zur nächsten Seite-->
    <a href="../next.html.erb">to next</a>
  </body>
</html>

Wenn Sie auf den Stammpfad zugreifen, sollte Folgendes angezeigt werden: Screenshot from 2020-11-06 11-56-54.png Tippen Sie auf "Weiter", um dem Link zu folgen.

Möglicherweise lautet die URL nur http: // localhost: 3000 / next.html.erb.

③ Ändern Sie die Einstellung (srv.rb)

Bisher haben wir den Pfad zur Homepage als "DocumentRoot" festgelegt.

Von hier aus setzen Sie auf `` `app / views``` und legen die URL und Anzeigedatei einzeln fest.

srv.rb


require 'webrick'

op = {
    BindAdress: "127.0.1",
    Port: 3000,
    DocumentRoot: "."
}

WEBrick::HTTPServlet::FileHandler.add_handler("erb", WEBrick::HTTPServlet::ERBHandler)
s = WEBrick::HTTPServer.new(op)

#Unten individuelle Einstellungen für URL und Anzeigedatei
s.mount('/', WEBrick::HTTPServlet::FileHandler, 'app/views/basic_pages/home.html.erb')
s.mount('/next', WEBrick::HTTPServlet::FileHandler, 'app/views/basic_pages/next.html.erb')

s.start

Sie haben jetzt den Stammpfad und den nächsten Pfad festgelegt.

Der Link zur Homepage wurde jedoch nicht festgelegt. Lassen Sie uns ihn also festlegen.

erb:app/views/basic_pages/home.html.erb


<html>
  <head>
    <meta charset="utf-8">
  </head>
  <body>
    <h1>Startseite</h1>
    <p>Hello, World</p>
    <%= 1 + 4 %>
    <!--Linkeinstellung zur nächsten Seite-->
    <a href="/next">to next</a>
  </body>
</html>

erb:app/views/basic_pages/next.html.erb


<html>
  <head>
    <meta charset="utf-8">
  </head>
  <body>
    <h1>Nächste Seite</h1>
    <p>This is a next page.</p>

    <!--Linkeinstellung zur Homepage-->
    <a href="/">to home</a>
  </body>
</html>

Sie können jetzt zwischen der Startseite und der nächsten Seite hin und her wechseln, indem Sie auf "Weiter" oder "Nach Hause" klicken.

Referenz ↓ ↓ ↓ https://docs.ruby-lang.org/ja/latest/library/webrick.html https://docs.ruby-lang.org/ja/latest/method/WEBrick=3a=3aHTTPServer/i/mount.html

2. Controller erstellen

Bis zu diesem Punkt können Sie jetzt Bildschirme wechseln, indem Sie die URL festlegen.

Lassen Sie uns von hier aus den Controller durchgehen und die Ansicht anzeigen.

① Reflexion der Logik durch Servlet ② Organisieren Sie Dateien so, dass sie wie ein Controller aussehen

① Reflexion der Logik durch Servlet

Verwenden wir zunächst ein Servlet, damit die Logik vor dem Seitenübergang wiedergegeben wird.

srb.rb


require 'webrick'
require 'erb'

include WEBrick

op = {
    BindAdress: "127.0.1",
    Port: 3000,
    DocumentRoot: "."
}

s = HTTPServer.new(op)

#Servlet
class HomeServlet < HTTPServlet::AbstractServlet
    def do_GET(req, res)
        #Beginn der Logik
        @home_string = "pass homeServlet"
        #Logike Ende
        erb = ERB.new File.open('app/views/basic_pages/home.html.erb').read
        res.body = erb.result(binding)
    end
end

class NextServlet < HTTPServlet::AbstractServlet
    def do_GET(req, res)
        #Beginn der Logik
        @next_string = "pass nextServlet"
        #Logike Ende
        erb = ERB.new File.open('app/views/basic_pages/next.html.erb').read
        res.body = erb.result(binding)
    end
end

s.mount('/', HomeServlet)
s.mount('/next', NextServlet)
trap(:INT){ s.shutdown }
s.start

Dies sollte den Wert der Instanzvariablen widerspiegeln.

app/views/basic_pages_controller.rb


<html>
  <head>
    <meta charset="utf-8">
  </head>
  <body>
    <h1>Startseite</h1>
    <p>Hello, World</p>
    <p><%= 1 + 4 %></p>
    <a href="/next">to next</a>
    <p><%= @home_string %></p>
    <p><%= @next_string %></p>
  </body>
</html>

Wenn Sie einen Server einrichten und auf die Homepage zugreifen, wird die Anzeige der in der Instanzvariablen gespeicherten Zeichenfolge "pass home Servlet" angezeigt.

Referenz ↓ ↓ ↓ http://unageanu.hatenablog.com/entry/20080720/1216539411 https://magazine.rubyist.net/articles/0017/0017-BundledLibraries.html

② Organisieren Sie Dateien so, dass sie wie ein Controller aussehen

So wie es ist, ist die dem Controller entsprechende Logik in srv.rb geschrieben, und die Aussichten sind schlecht.

Lassen Sie uns daher organisieren, indem Sie ein neues Verzeichnis und eine neue Datei erstellen.

app/controllers/basic_apges_cotroller.rb


require 'erb'

def render_result(path)
    erb = ERB.new File.open("app/views/#{path}.html.erb").read
    erb.result(binding)
end

module BasicPagesController
    class HomeServlet < HTTPServlet::AbstractServlet
        def do_GET(req, res)
            @home_string = "pass homeServlet"
            res.body = render_result 'basic_pages/home'
        end
    end

    class NextServlet < HTTPServlet::AbstractServlet
        def do_GET(req, res)
            @next_string = "pass nextServlet"
            res.body = render_result 'basic_pages/next'
        end
    end
end

srv.rb


require 'webrick'
include WEBrick

op = {
    BindAdress: "127.0.1",
    Port: 3000,
    DocumentRoot: "."
}

s = HTTPServer.new(op)

#Logik zum Anzeigen der Homepage und der nächsten Seite
require './app/controllers/basic_pages_controller.rb'
include BasicPagesController
s.mount('/', HomeServlet)
s.mount('/next', NextServlet)

trap(:INT){ s.shutdown }
s.start

Damit war es ziemlich erfrischend.

3. 3. Routing

Zu diesem Zeitpunkt haben wir die Seitenanzeige über den Controller implementiert.

Wenn jedoch nichts unternommen wird, wird srv.rb jedes Mal manuell aktualisiert, wenn eine neue Seite erstellt wird.

Dann ist es schwierig zu verstehen, welche Art von Seite es gibt. Verwenden Sie daher die Routing-Datei (config / route.rb), um sie zu organisieren.

Führen Sie die folgenden Schritte aus, um es zu implementieren.

① Erstellen Sie eine Routing-Einstellungsdatei (config / route.rb) (2) Automatische Erzeugung von Routing durch Metaprogrammierung

① Erstellen Sie eine Routing-Einstellungsdatei (config / route.rb)

config/routes.rb


class Routes
    def initialize
        @routes = Array.new
    end

    def make_routes
        #Die Route wird unten beschrieben
        get "/", "basic_pages", "home"
        get "/next", "basic_pages", "next"

        #Der Rückgabewert ist unten aufgeführt(Gibt eine Liste mit Routeninformationen zurück)
        return @routes
    end

    def get(url, controller_name, action)
        @routes.push({ url: url, controller_name: controller_name, action: action }) 
    end
end

Erstellen Sie in srv.rb eine Instanz, damit Sie mit make_routes eine Liste von Routen generieren und abrufen können.

(2) Automatische Erzeugung von Routing durch Metaprogrammierung

Basierend auf config / route.rb müssen Sie den Code schreiben, um das tatsächliche Routing in srv.rb festzulegen.

srv.rb


require 'webrick'
include WEBrick

op = {
    BindAdress: "127.0.1",
    Port: 3000,
    DocumentRoot: "."
}

s = HTTPServer.new(op)

#String-Klassenerweiterung
class String
    def to_camel()
        self.split("_").map{ |w| w[0] = w[0].upcase; w }.join
    end
end

#Routing-Informationen abrufen
require './config/routes.rb'
r = Routes.new
routes = r.make_routes

#Routing automatisch mit Metaprogrammierung generieren
routes.each do |route|
    require "./app/controllers/#{route[:controller_name]}_controller.rb"
    include eval("#{route[:controller_name].to_camel}Controller")

    s.mount route[:url], eval("#{route[:action].to_camel}Servlet")
end

trap(:INT){ s.shutdown }
s.start

Damit ist das Routing abgeschlossen.

Zusammenfassung

Diesmal handelt es sich um eine Controller-Edition, daher habe ich den Seitenübergang durch den Controller implementiert.

Es scheint, dass es noch ein langer Weg ist, bis es wie Schienen aussieht, aber ich möchte es nach und nach implementieren.