[RUBY] Faisons en sorte que Rails-like 2 (édition contrôleur)

introduction

Cet article est une continuation du précédent. ↓ ↓ ↓ https://qiita.com/alex0033/items/73f62ac7e5700ab2b4d6

Cette fois, j'aimerais implémenter le routage dans Rails car il s'agit d'une édition de contrôleur.

La structure de répertoires à viser est la suivante.

directory
  |- app
      |- controllers
           |- basic_pages_controller
      |- views
           |- basic_pages
               |- home.html.erb #page d'accueil
               |- next.html.erb #Page suivante
  |- config
       |- routes.rb
  |- srv.rb

point

Jusqu'à la dernière fois, il est dans l'état suivant.

-Vous pouvez configurer un serveur en tapant `` ruby srv.rb '' dans le terminal. ・ Lorsque vous accédez à http: // localhost: 3000, la page d'accueil s'affiche.

Les objectifs cette fois sont les suivants.

・ Lorsque vous accédez à http: // localhost: 3000 (ci-après, chemin racine), la page d'accueil s'affiche. -Lorsque vous accédez à http: // localhost: 3000 / next (ci-après, chemin suivant), la page suivante s'affiche. ・ Passez par le contrôleur avant d'accéder à la page

Par conséquent, l'explication de cet article est la suivante.

    1. Affichage de la page suivante ① Créez un fichier de vue (app / views / basic_pages / next.html.erb) ② Essayez d'accéder à partir de la page d'accueil avec \ tag </ em> ③ Changez le réglage (srv.rb)
  2. Créer un type de contrôleur ① Réflexion de la logique par servlet ② Organisez les fichiers pour qu'ils ressemblent à un contrôleur
    1. routage ① Créez un fichier de paramètres de routage (config / routes.rb) (2) Génération automatique de routage par métaprogrammation

1. 1. Affichage de la page suivante

Commençons par créer une page suivante afin qu'elle puisse être affichée. Décrivez dans l'ordre suivant.

① Créez un fichier de vue (app / views / basic_pages / next.html.erb) ② Essayez d'accéder à partir de la page d'accueil avec \ tag </ em> ③ Changez le réglage (srv.rb)

① Créez un fichier de vue (app / views / basic_pages / next.html.erb)

Créons un fichier de vue.

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


<html>
  <head>
    <meta charset="utf-8">
  </head>
  <body>
    <h1>Page suivante</h1>
    <p>This is a next page.</p>
  </body>
</html>

② Essayez d'accéder à partir de la page d'accueil avec \ tag </ em>

Vous ne pouvez pas y accéder simplement par l'existence du fichier de vue. Par conséquent, essayons d'y accéder depuis la page d'accueil en utilisant la balise \ </ em>.

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


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

    <!--Lien vers la page suivante-->
    <a href="../next.html.erb">to next</a>
  </body>
</html>

Lorsque vous accédez au chemin racine, vous devriez voir quelque chose comme ceci: Screenshot from 2020-11-06 11-56-54.png Essayez de toucher "au suivant" pour suivre le lien.

Peut-être que l'URL est simplement http: // localhost: 3000 / next.html.erb.

③ Changez le réglage (srv.rb)

Jusqu'à présent, nous avons défini le chemin d'accès à la page d'accueil comme `` DocumentRoot```.

À partir de là, définissez sur `` application / vues '' et définissez l'URL et le fichier d'affichage individuellement.

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)

#Ci-dessous, les paramètres individuels pour l'URL et le fichier d'affichage
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

Vous avez maintenant défini le chemin racine et le chemin suivant.

Cependant, le lien vers la page d'accueil n'a pas été défini, alors définissons-le.

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


<html>
  <head>
    <meta charset="utf-8">
  </head>
  <body>
    <h1>page d'accueil</h1>
    <p>Hello, World</p>
    <%= 1 + 4 %>
    <!--Lier le paramètre à la page suivante-->
    <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>Page suivante</h1>
    <p>This is a next page.</p>

    <!--Lier le paramètre à la page d'accueil-->
    <a href="/">to home</a>
  </body>
</html>

Vous pouvez maintenant aller et venir entre la page d'accueil et la page suivante en cliquant sur «à la suivante» ou «à l'accueil».

Référence ↓ ↓ ↓ 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. Créer un contrôleur

Jusqu'à présent, vous pouvez désormais effectuer la transition des écrans en définissant l'URL.

De là, passons par le contrôleur et rendons possible l'affichage de la vue.

① Réflexion de la logique par servlet ② Organisez les fichiers pour qu'ils ressemblent à un contrôleur

① Réflexion de la logique par servlet

Tout d'abord, utilisons un servlet pour que la logique soit reflétée avant la transition de page.

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)
        #Début de la logique
        @home_string = "pass homeServlet"
        #Fin logique
        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)
        #Début de la logique
        @next_string = "pass nextServlet"
        #Fin logique
        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

Cela doit refléter la valeur de la variable d'instance.

app/views/basic_pages_controller.rb


<html>
  <head>
    <meta charset="utf-8">
  </head>
  <body>
    <h1>page d'accueil</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>

Si vous configurez un serveur et accédez à la page d'accueil, vous pouvez voir l'affichage de la chaîne de caractères "pass home Servlet" stockée dans la variable d'instance.

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

② Organisez les fichiers pour qu'ils ressemblent à un contrôleur

En l'état, la logique correspondant au contrôleur est écrite dans srv.rb et les perspectives sont mauvaises.

Par conséquent, organisons en créant un nouveau répertoire et un nouveau fichier.

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)

#Logique d'affichage de la page d'accueil et de la page suivante
require './app/controllers/basic_pages_controller.rb'
include BasicPagesController
s.mount('/', HomeServlet)
s.mount('/next', NextServlet)

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

Avec cela, c'était assez rafraîchissant.

3. 3. routage

À ce stade, nous avons implémenté l'affichage des pages via le contrôleur.

Cependant, si rien n'est fait, srv.rb sera mis à jour manuellement chaque fois qu'une nouvelle page est créée.

Ensuite, il est difficile de comprendre de quel type de page il existe, utilisez donc le fichier de routage (config / routes.rb) pour l'organiser.

Suivez les étapes ci-dessous pour l'implémenter.

① Créez un fichier de paramètres de routage (config / routes.rb) (2) Génération automatique de routage par métaprogrammation

① Créez un fichier de paramètres de routage (config / routes.rb)

config/routes.rb


class Routes
    def initialize
        @routes = Array.new
    end

    def make_routes
        #L'itinéraire est décrit ci-dessous
        get "/", "basic_pages", "home"
        get "/next", "basic_pages", "next"

        #La valeur de retour est répertoriée ci-dessous(Renvoie une liste d'informations sur l'itinéraire)
        return @routes
    end

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

Dans srv.rb, créez une instance afin de pouvoir générer et obtenir une liste de routes avec make_routes.

(2) Génération automatique de routage par métaprogrammation

Basé sur config / routes.rb, vous devez écrire le code pour définir le routage réel dans srv.rb.

srv.rb


require 'webrick'
include WEBrick

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

s = HTTPServer.new(op)

#Extension de classe de chaîne
class String
    def to_camel()
        self.split("_").map{ |w| w[0] = w[0].upcase; w }.join
    end
end

#Obtenir des informations de routage
require './config/routes.rb'
r = Routes.new
routes = r.make_routes

#Générer automatiquement le routage avec la métaprogrammation
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

Ceci termine le routage.

Sommaire

Cette fois, il s'agit d'une édition de contrôleur, j'ai donc implémenté la transition de page via le contrôleur.

Il semble qu'il y ait encore un long chemin à parcourir pour que cela ressemble à des rails, mais j'aimerais l'implémenter petit à petit.