7 Rust IDE Rust Et Éditeurs De Code

Selon l'enquête annuelle auprès des développeurs de Stack Overflow , Rust a été le langage le plus apprécié pendant sept années consécutives, bien qu'il ne soit pas l'un des plus populaires. Les Rustacés sont attirés par le langage en raison de ses hautes performances, de ses fonctions de sécurité du code et de son incroyable compilateur.

En relativement peu de temps, Rust a obtenu le soutien d'énormes entreprises comme Mozilla, Amazon, Huawei, Google et Microsoft. Pour toutes ces raisons, beaucoup de curiosité s'est développée autour de la langue et beaucoup de gens veulent l'essayer.

Dans cet article, je vais partager avec vous sept des meilleurs IDE et éditeurs de code Rust pour optimiser votre expérience de codage, vous aider à raccourcir le temps de développement et vous fournir des outils pour rendre le processus de lecture et d'écriture de code dans Rust facile et efficace. .

Que devrait offrir un bon IDE Rust ?

Un bon IDE ou éditeur de code est ergonomique et peut vous aider à augmenter votre productivité. Certains d'entre eux sont livrés avec des outils pour vous aider à compléter votre code au fur et à mesure que vous écrivez, ainsi que pour déboguer vos applications Rust avant la compilation.

Parmi les autres fonctionnalités que vous pouvez attendre d'un bon éditeur pour un langage populaire tel que Rust , citons la coloration syntaxique, les raccourcis clavier pour accélérer votre flux de travail et la génération de code. Sans plus tarder, plongeons dans cette liste de certains des meilleurs IDE Rust.

Code Visual Studio (code VS)

Page d'accueil de Visual Studio Code affichée au démarrage avec des invites pour démarrer, personnaliser, apprendre, obtenir de l'aide et accéder aux fichiers récents

Visual Studio Code est un projet open source et gratuit créé par Microsoft et disponible pour macOS, Windows et Linux. Il prend en charge de nombreuses langues majeures, y compris Rust.

Actuellement, VS Code est l'un des meilleurs éditeurs de code et l'éditeur le plus utilisé pour le développement Rust . Avec l'aide de plugins commerust-analyzer , VS Code fournit aux développeurs Rust des fonctionnalités telles que :

Mise en évidence des erreurs (et suggestions de correctifs possibles)
Prise en charge du débogage
Mise en évidence de la syntaxe
Complétion de code
Génération de code et refactorisation pour améliorer la qualité du code

L'un des principaux facteurs qui rendent VS Code populaire est qu'il est léger. Il est également livré avec des raccourcis clavier pour aider à augmenter la productivité et des fonctionnalités d'intelligence linguistique telles que la navigation dans le code pour vous aider à trouver facilement des fichiers, des définitions, des implémentations et des symboles.

VS Code est également livré avec le support Git prêt à l'emploi, ce qui est utile pour maintenir différentes versions de votre projet. D'autres plugins VCS peuvent également être trouvés sur le marché des extensions de VS Code .

Bien que similaire à des éditeurs comme Atom en termes de fonctionnalités, contrairement à Atom, VS Code est connu pour être rapide et causer rarement des retards lors d'activités telles que la recherche et le changement de fichiers. Un autre éditeur très performant est Sublime Text, dont nous parlerons ci-dessous.

Comparé à des éditeurs comme Vim et Emacs, VS Code est facile à configurer et à utiliser. Puisqu'il a été conçu comme un éditeur de code, il n'a pas autant de fonctionnalités qu'un IDE standard ; néanmoins, il est hautement extensible et sa collection de fonctionnalités est impressionnante.

Selon la rust-analyzerdocumentation, VS Code est actuellement l'éditeur le mieux pris en charge pour Rust. Vous pouvez télécharger VS Code pour voir par vous-même. Assurez-vous de l' installerrust-analyzer également !

CLion

Page d'accueil CLion avec invite pour obtenir un essai gratuit de 30 jours et des informations sur la dernière version

CLion est un IDE premium créé par JetBrains . Bien que créé pour C et C++, vous pouvez l'utiliser avec Rust via le plugin IntelliJ Rust . Il est disponible pour Linux, Mac et Windows.

Contrairement à Atom, VS Code et à d'autres éditeurs open source, les organisations et les particuliers doivent payer pour CLion. Il est gratuit pour les étudiants, les enseignants, les projets open source et les écoles de codage ; cependant, la plupart des développeurs ne seront probablement pas éligibles pour la licence gratuite.

Si cela ne vous dérange pas de payer un petit abonnement mensuel ou annuel, CLion peut être votre IDE Rust. Il est facile à utiliser et son interface utilisateur moderne et intuitive ne nécessite aucune courbe d'apprentissage. Vous pouvez commencer à construire votre projet Rust.

CLion est un IDE complet doté de nombreuses fonctionnalités et, par conséquent, il est lourd et gourmand en CPU et en RAM. Comparé à un éditeur comme VS Code, il a tendance à s'exécuter plus lentement. Avec des projets de taille moyenne à grande, vous pouvez rencontrer des décalages et des blocages.

Avec l'aide d'IntelliJ Rust, CLion est en mesure de fournir aux développeurs Rust les fonctionnalités suivantes :

CLion a une interface utilisateur propre et est livré avec un certain nombre de thèmes que vous pouvez personnaliser selon vos goûts. Téléchargez CLion pour l'essayer par vous-même .

IDÉE IntelliJ

Page d'accueil IntelliJ IDEA avec bouton de téléchargement et informations sur les raisons pour lesquelles les développeurs devraient utiliser cet IDE

IntelliJ IDEA, bien que conçu à l'origine pour Java par JetBrains , peut également être utilisé pour coder Rust. Comme CLion, cela est possible grâce au plugin IntelliJ Rust . Il est disponible pour Windows, macOS et Linux.

Vous pouvez choisir parmi des thèmes réguliers et personnalisés pour améliorer l'apparence de l'interface utilisateur très agréable et conviviale d'IntelliJ IDEA. Semblable à CLion, IDEA est disponible pour les organisations et les particuliers moyennant des frais, tandis que les étudiants, les enseignants, les écoles de codage et les contributeurs à des projets open source peuvent l'obtenir gratuitement.

IntelliJ IDEA utilise IntelliJ Rust pour fournir aux développeurs Rust les fonctionnalités suivantes :

Raccourcis clavier
Fonctionnalités d'accessibilité
Aide au codage intelligent
Détection d'erreur
Complétion de code
Refactorisation automatique
Inspections et actions contextuelles
Mise en évidence du code
Modèles en direct
Débogueur

IntelliJ IDEA fournit aux développeurs Rust des outils de contrôle de version prêts à l'emploi, ainsi que des outils pour collaborer avec d'autres en temps réel .

Dans l'IDE, vous pouvez cloner votre projet, gérer les branches, fusionner les conflits, valider et pousser les modifications. Il vous aide également à intégrer de manière transparente votre projet Rust avec des systèmes d'orchestration de conteneurs tels que Docker et Kubernetes.

Un "inconvénient" d'IntelliJ IDEA est que, puisqu'il s'agit d'un IDE, il n'est évidemment pas léger. Il utilise plus de RAM et de puissance CPU que VS Code, Atom, Spacemacs, Neovim et d'autres éditeurs de code. Cela peut ralentir considérablement l'ouverture de grands projets ou le travail sur plusieurs projets à la fois.

Vous pouvez télécharger IntelliJ IDEA pour voir toutes ses fonctionnalités en action.

Éditeur d'atome

Page d'accueil de l'éditeur Atom affichant les informations sur la version actuelle, les informations de compatibilité, le bouton de téléchargement

L'éditeur de code Atom prend en charge Windows, Linux et macOS. Bien qu'Atom soit plus ancien que des éditeurs comme VS Code, il est devenu moins populaire ces derniers temps. Il a la réputation d'être lent et il est plus maladroit que VS Code.

Cependant, Atom a une flexibilité de personnalisation qui ne peut être dépassée que par Spacemacs. Presque toutes les fonctionnalités sont disponibles sous forme de package qui peut être facilement ajouté ou supprimé. Vous pouvez également créer de nouvelles fonctionnalités et les adapter à vos goûts.

Comme VS Code, Atom a un excellent design et vous pouvez y créer des thèmes personnalisés. Atom a également derrière lui une communauté énorme et dynamique qui gère à la fois les plugins existants et travaille sur de nouveaux.

Contrairement aux éditeurs comme Emacs et Vim, Atom a une courbe d'apprentissage peu profonde. Vous pouvez simplement l'installer et commencer immédiatement à éditer votre code Rust grâce à son interface très intuitive.

Avec l'aide de packages commeide-rust , qui s'utilisent rust-analyzersous le capot, Atom est en mesure de fournir aux développeurs Rust des fonctionnalités telles que :

Saisie automatique
Mise en évidence de la syntaxe
Contrôle de version
Extraits de langage Rust
Aller à la définition

Téléchargez Atom pour l'essayer .

Texte sublime

Écran de démarrage Sublime Text affichant les dossiers de projet et les fichiers ouverts

Sublime Text est un éditeur de code minimaliste mais efficace. Il prend en charge des dizaines de langues, dont Rust. Il semble nu comparé à des éditeurs comme VS Code et Atom, mais cette simplicité le rend beaucoup plus rapide que ces autres éditeurs.

Sublime est facile à utiliser ; il arbore une interface conviviale qui ne nécessite aucune courbe d'apprentissage. Il peut fonctionner sous Linux, Windows et macOS. Bien que son interface utilisateur ne soit pas aussi personnalisable que celle d'Atom, il contient de nombreux thèmes installables qui peuvent modifier le schéma de couleurs de votre code Rust.

En termes de taille, Sublime Text est beaucoup plus léger que ses homologues d'éditeurs modernes et il est très facile à configurer. Il est également assez extensible et personnalisable à l'aide des plugins de son gestionnaire de packages.

Étant donné que Sublime Text n'est pas open source, il a une équipe plutôt petite derrière lui par rapport à ses homologues, ce qui rend les mises à jour et les corrections de bogues relativement peu fréquentes.

Il existe de nombreux plugins Sublime disponibles qui rendent le codage dans Rust plus rapide, plus facile et plus pratique. Avec l'aide de packages commerust-enhanced , il fournit aux développeurs Rust des fonctionnalités telles que :

Auto-complétion
Fonction aller à
Pliage de code
Tondeuse
Emmet
Pipette à couleurs
Aperçu Markdown
Gite
Mise en évidence de la syntaxe
Détection d'erreur

Vous pouvez télécharger Sublime gratuitement , mais il existe également des versions premium. Sublime vous invitera à passer à une licence payante, mais si la version gratuite et les plug-ins fournissent toutes les fonctionnalités dont vous avez besoin, vous pouvez simplement ignorer ces fenêtres contextuelles.

Spacemacs

Page d'accueil de Spacemacs avec des boutons pour télécharger et installer ainsi que des liens vers des documents et d'autres ressources

Si vous aimez que votre flux de travail soit centré sur le clavier, Spacemacs pourrait être l'éditeur qu'il vous faut . À l'aide de raccourcis clavier, vous pouvez utiliser les touches de votre clavier pour exécuter différentes commandes et rendre le processus de développement plus rapide et plus efficace.

Un inconvénient ici est que cela peut prendre un certain temps pour maîtriser des éditeurs comme Spacemacs ; il a une courbe d'apprentissage abrupte. À moins que vous ne soyez déjà familiarisé avec les principes et les codes d'Emacs, vous risquez de perdre beaucoup de temps à essayer de comprendre comment exécuter différentes fonctions.

Si vous n'avez aucune expérience de travail avec Emacs ou Vim pour le développement de Rust et que vous voulez démarrer avec votre projet Rust, Spacemacs n'est pas l'éditeur qu'il vous faut.

Spacemacs prend en charge de nombreuses langues, dont Rust. rlsEn exploitant et , Spacemacs rust-analyzerest en mesure de fournir aux développeurs Rust des fonctionnalités telles que :

Raccourcis clavier
Auto-complétion
Prise en charge de la navigation
Débogueur interactif
Les peluches avec Clippy
Conseils d'incrustation
Actions codées

En matière de personnalisation, Spacemacs est en avance sur des éditeurs comme VS Code et Sublime Text. Presque toutes les parties de l'éditeur peuvent être modifiées et ses fonctionnalités peuvent être grandement améliorées grâce à des packages. Bien que les fonctionnalités de VS Code puissent également être étendues via des plugins, elles sont quelque peu restreintes.

Si vous préférez personnaliser votre environnement de développement à votre goût plutôt que de travailler dans un environnement au design avisé, Spacemacs pourrait être fait pour vous.

Bien que cela puisse sembler trivial, certaines personnes trouvent en fait Spacemacs plus amusant et aventureux à utiliser que des éditeurs comme VS Code et Atom. D'autres l'essayent par curiosité. Donc, si vous aimez apprendre et que vous vous sentez aventureux, cela vaut peut-être la peine d'essayer Spacemacs .

Néovim

Page d'accueil de Neovim avec bouton d'installation et informations sur les fonctionnalités notables de Neovim

Neovim est une variante de Vim, l'éditeur de texte Unix. Il est très léger, rapide et flexible, mais sa flexibilité signifie également qu'il nécessite beaucoup de personnalisation. Si le temps et l'énergie que cela prend ne vous dérange pas, alors c'est peut-être l'éditeur qu'il vous faut.

Si vous aimez une approche minimaliste du montage, Neovim pourrait également être une excellente option pour vous car vous pouvez faire tout votre montage sans avoir à quitter votre terminal. Neovim est également très léger, ce qui le rend très rapide et réactif.

Cet éditeur gratuit et open source s'appuie sur une communauté dynamique et prend en charge de nombreuses langues, dont Rust.

Étant donné que Rust est un langage économe en mémoire, Neovim pourrait en fait être un bon match car il est également léger sur les ressources mémoire. Cela peut être important si vous utilisez une petite machine peu coûteuse et que la gestion de l'utilisation des ressources de votre processeur est une priorité élevée.

Avec l'aide de rust-analyzer, Neovim est en mesure de fournir des fonctionnalités telles que :

Mise en évidence de la syntaxe
Complétion de code
Intégration Git
Pliage de code
Aller à la définition
Détection d'erreur
Navigation des codes

Les raccourcis clavier de Neovim vous permettent d'effectuer toutes sortes de fonctions avec votre clavier sans avoir à utiliser votre souris. Cela peut constituer une expérience de codage efficace si vous pouvez bien les utiliser. Neovim est également très extensible, car il existe des plugins disponibles pour toutes sortes de fonctionnalités.

Alors que les éditeurs modernes comme VS Code et Atom ont tendance à collecter les informations personnelles des utilisateurs, les éditeurs classiques comme Neovim sont considérés comme plus sûrs.

Consultez ce guide Github pour installer Neovim pour commencer.

Conclusion

Tous les éditeurs ont leurs avantages, leurs inconvénients et leur place dans le monde du développement. En fin de compte, cela dépend probablement de ce avec quoi vous êtes à l'aise, de votre expérience antérieure avec les éditeurs, du type de projet sur lequel vous souhaitez travailler et d'autres facteurs.

Si vous êtes à l'aise avec l'exécution de la plupart des tâches avec votre clavier et l'édition de code à partir de votre terminal, des éditeurs comme Neovim et Spacemacs pourraient mieux vous convenir.

Si vous recherchez quelque chose de plus moderne avec une courbe d'apprentissage peu profonde, vous pouvez choisir entre VS Code, Atom et Sublime Text.

Cependant, si ceux-ci vous semblent incomplets et que vous avez besoin d'un environnement de développement plus sophistiqué et complet avec de nombreux outils prêts à l'emploi, parfaits pour coder et déboguer de grands projets, envisagez CLion ou IntelliJ IDEA.

Vous pouvez jouer avec chacun d'eux et voir celui qui vous convient le mieux.

Source : https://blog.logrocket.com/comparing-rust-ides-intellij-idea-vs-code-more/

#vscode #rust #intellij-idea

What is GEEK

Buddha Community

Monty Boehm

1675304280

How to Use Hotwire Rails

Introduction

We are back with another exciting and much-talked-about Rails tutorial on how to use Hotwire with the Rails application. This Hotwire Rails tutorial is an alternate method for building modern web applications that consume a pinch of JavaScript.

Rails 7 Hotwire is the default front-end framework shipped with Rails 7 after it was launched. It is used to represent HTML over the wire in the Rails application. Previously, we used to add a hotwire-rails gem in our gem file and then run rails hotwire: install. However, with the introduction of Rails 7, the gem got deprecated. Now, we use turbo-rails and stimulus rails directly, which work as Hotwire’s SPA-like page accelerator and Hotwire’s modest JavaScript framework.

What is Hotwire?

Hotwire is a package of different frameworks that help to build applications. It simplifies the developer’s work for writing web pages without the need to write JavaScript, and instead sending HTML code over the wire.

Introduction to The Hotwire Framework:

1. Turbo:

It uses simplified techniques to build web applications while decreasing the usage of JavaScript in the application. Turbo offers numerous handling methods for the HTML data sent over the wire and displaying the application’s data without actually loading the entire page. It helps to maintain the simplicity of web applications without destroying the single-page application experience by using the below techniques:

Turbo Frames: Turbo Frames help to load the different sections of our markup without any dependency as it divides the page into different contexts separately called frames and updates these frames individually.
Turbo Drive: Every link doesn’t have to make the entire page reload when clicked. Only the HTML contained within the tag will be displayed.
Turbo Streams: To add real-time features to the application, this technique is used. It helps to bring real-time data to the application using CRUD actions.

2. Stimulus

It represents the JavaScript framework, which is required when JS is a requirement in the application. The interaction with the HTML is possible with the help of a stimulus, as the controllers that help those interactions are written by a stimulus.

3. Strada

Not much information is available about Strada as it has not been officially released yet. However, it works with native applications, and by using HTML bridge attributes, interaction is made possible between web applications and native apps.

Simple diagrammatic representation of Hotwire Stack:

Hotwire Stack

Prerequisites For Hotwire Rails Tutorial

As we are implementing the Ruby on Rails Hotwire tutorial, make sure about the following installations before you can get started.

Ruby on Rails
Hotwire gem
PostgreSQL/SQLite (choose any one database)
Turbo Rails
Stimulus.js

Looking for an enthusiastic team of ROR developers to shape the vision of your web project?
Contact Bacancy today and hire Ruby developers to start building your dream project!

Create a new Rails Project

Find the following commands to create a rails application.

mkdir ~/projects/railshotwire
cd ~/projects/railshotwire
echo "source 'https://rubygems.org'" > Gemfile
echo "gem 'rails', '~> 7.0.0'" >> Gemfile
bundle install  
bundle exec rails new . --force -d=postgresql

Now create some files for the project, up till now no usage of Rails Hotwire can be seen.
Fire the following command in your terminal.

For creating a default controller for the application

echo "class HomeController < ApplicationController" > app/controllers/home_controller.rb
echo "end" >> app/controllers/home_controller.rb

For creating another controller for the application

echo "class OtherController < ApplicationController" > app/controllers/other_controller.rb
echo "end" >> app/controllers/home_controller.rb

For creating routes for the application

echo "Rails.application.routes.draw do" > config/routes.rb
echo '  get "home/index"' >> config/routes.rb
echo '  get "other/index"' >> config/routes.rb
echo '  root to: "home#index"' >> config/routes.rb
echo 'end' >> config/routes.rb

For creating a default view for the application

mkdir app/views/home
echo '<h1>This is Rails Hotwire homepage</h1>' > app/views/home/index.html.erb
echo '<div><%= link_to "Enter to other page", other_index_path %></div>' >> app/views/home/index.html.erb

For creating another view for the application

mkdir app/views/other
echo '<h1>This is Another page</h1>' > app/views/other/index.html.erb
echo '<div><%= link_to "Enter to home page", root_path %></div>' >> app/views/other/index.html.erb

For creating a database and schema.rb file for the application

bin/rails db:create
bin/rails db:migrate

For checking the application run bin/rails s and open your browser, your running application will have the below view.

Rails Hotwire Home Page

Additionally, you can clone the code and browse through the project. Here’s the source code of the repository: Rails 7 Hotwire application

Now, let’s see how Hotwire Rails can work its magic with various Turbo techniques.

Hotwire Rails: Turbo Drive

Go to your localhost:3000 on your web browser and right-click on the Inspect and open a Network tab of the DevTools of the browser.

Now click on go to another page link that appears on the home page to redirect from the home page to another page. In our Network tab, we can see that this action of navigation is achieved via XHR. It appears only the part inside HTML is reloaded, here neither the CSS is reloaded nor the JS is reloaded when the navigation action is performed.

Hotwire Rails Turbo Drive

By performing this action we can see that Turbo Drive helps to represent the HTML response without loading the full page and only follows redirect and reindeer HTML responses which helps to make the application faster to access.

Hotwire Rails: Turbo Frame

This technique helps to divide the current page into different sections called frames that can be updated separately independently when new data is added from the server.
Below we discuss the different use cases of Turbo frame like inline edition, sorting, searching, and filtering of data.

Let’s perform some practical actions to see the example of these use cases.

Make changes in the app/controllers/home_controller.rb file

#CODE

class HomeController < ApplicationController
   def turbo_frame_form
   end
   
   def turbo_frame submit
      extracted_anynumber = params[:any][:anynumber]
      render :turbo_frame_form, status: :ok, locals: {anynumber: extracted_anynumber,      comment: 'turbo_frame_submit ok' }
   end
end

Turbo Frame

Add app/views/home/turbo_frame_form.html.erb file to the application and add this content inside the file.

#CODE

<section>

    <%= turbo_frame_tag 'anyframe' do %>
            
      <div>
          <h2>Frame view</h2>
          <%= form_with scope: :any, url: turbo_frame_submit_path, local: true do |form| %>
              <%= form.label :anynumber, 'Type an integer (odd or even)', 'class' => 'my-0  d-inline'  %>
              <%= form.text_field :anynumber, type: 'number', 'required' => 'true', 'value' => "#{local_assigns[:anynumber] || 0}",  'aria-describedby' => 'anynumber' %>
              <%= form.submit 'Submit this number', 'id' => 'submit-number' %>
          <% end %>
      </div>
      <div>
        <h2>Data of the view</h2>
        <pre style="font-size: .7rem;"><%= JSON.pretty_generate(local_assigns) %></pre> 
      </div>
      
    <% end %>

</section>

Add the content inside file

Make some adjustments in routes.rb

#CODE

Rails.application.routes.draw do
  get 'home/index'
  get 'other/index'

  get '/home/turbo_frame_form' => 'home#turbo_frame_form', as: 'turbo_frame_form'
  post '/home/turbo_frame_submit' => 'home#turbo_frame_submit', as: 'turbo_frame_submit'


  root to: "home#index"
end

Next step is to change homepage view in app/views/home/index.html.erb

#CODE

<h1>This is Rails Hotwire home page</h1>
<div><%= link_to "Enter to other page", other_index_path %></div>

<%= turbo_frame_tag 'anyframe' do %>        
  <div>
      <h2>Home view</h2>
      <%= form_with scope: :any, url: turbo_frame_submit_path, local: true do |form| %>
          <%= form.label :anynumber, 'Type an integer (odd or even)', 'class' => 'my-0  d-inline'  %>
          <%= form.text_field :anynumber, type: 'number', 'required' => 'true', 'value' => "#{local_assigns[:anynumber] || 0}",  'aria-describedby' => 'anynumber' %>
          <%= form.submit 'Submit this number', 'id' => 'submit-number' %>
      <% end %>
  <div>
<% end %>

Change HomePage

After making all the changes, restart the rails server and refresh the browser, the default view will appear on the browser.

restart the rails server Now in the field enter any digit, after entering the digit click on submit button, and as the submit button is clicked we can see the Turbo Frame in action in the below screen, we can observe that the frame part changed, the first title and first link didn’t move.

Hotwire Rails: Turbo Streams

Turbo Streams deliver page updates over WebSocket, SSE or in response to form submissions by only using HTML and a series of CRUD-like operations, you are free to say that either

Update the piece of HTML while responding to all the other actions like the post, put, patch, and delete except the GET action.
Transmit a change to all users, without reloading the browser page.

This transmit can be represented by a simple example.

Make changes in app/controllers/other_controller.rb file of rails application

#CODE

class OtherController < ApplicationController

  def post_something
    respond_to do |format|
      format.turbo_stream {  }
    end
  end

   end

file of rails application

Add the below line in routes.rb file of the application

#CODE

post '/other/post_something' => 'other#post_something', as: 'post_something'

Superb! Rails will now attempt to locate the app/views/other/post_something.turbo_stream.erb template at any moment the ‘/other/post_something’ endpoint is reached.

For this, we need to add app/views/other/post_something.turbo_stream.erb template in the rails application.

#CODE

<turbo-stream action="append" target="messages">
  <template>
    <div id="message_1">This changes the existing message!</div>
  </template>
</turbo-stream>

This states that the response will try to append the template of the turbo frame with ID “messages”.

Now change the index.html.erb file in app/views/other paths with the below content.

#CODE

<h1>This is Another page</h1>
<div><%= link_to "Enter to home page", root_path %></div>

<div style="margin-top: 3rem;">
  <%= form_with scope: :any, url: post_something_path do |form| %>
      <%= form.submit 'Post any message %>
  <% end %>
  <turbo-frame id="messages">
    <div>An empty message</div>
  </turbo-frame>
</div>

After making all the changes, restart the rails server and refresh the browser, and go to the other page.

go to the other page

Once the above screen appears, click on the Post any message button

This action shows that after submitting the response, the Turbo Streams help the developer to append the message, without reloading the page.

Another use case we can test is that rather than appending the message, the developer replaces the message. For that, we need to change the content of app/views/other/post_something.turbo_stream.erb template file and change the value of the action attribute from append to replace and check the changes in the browser.

#CODE

<turbo-stream action="replace" target="messages">
  <template>
    <div id="message_1">This changes the existing message!</div>
  </template>
</turbo-stream>

change the value of the action attribute When we click on Post any message button, the message that appear below that button will get replaced with the message that is mentioned in the app/views/other/post_something.turbo_stream.erb template

Stimulus

There are some cases in an application where JS is needed, therefore to cover those scenarios we require Hotwire JS tool. Hotwire has a JS tool because in some scenarios Turbo-* tools are not sufficient. But as we know that Hotwire is used to reduce the usage of JS in an application, Stimulus considers HTML as the single source of truth. Consider the case where we have to give elements on a page some JavaScript attributes, such as data controller, data-action, and data target. For that, a stimulus controller that can access elements and receive events based on those characteristics will be created.

Make a change in app/views/other/index.html.erb template file in rails application

#CODE

<h1>This is Another page</h1>
<div><%= link_to "Enter to home page", root_path %></div>

<div style="margin-top: 2rem;">
  <%= form_with scope: :any, url: post_something_path do |form| %>
      <%= form.submit 'Post something' %>
  <% end %>
  <turbo-frame id="messages">
    <div>An empty message</div>
  </turbo-frame>
</div>

<div style="margin-top: 2rem;">
  <h2>Stimulus</h2>  
  <div data-controller="hello">
    <input data-hello-target="name" type="text">
    <button data-action="click->hello#greet">
      Greet
    </button>
    <span data-hello-target="output">
    </span>
  </div>
</div>

Make A change Make changes in the hello_controller.js in path app/JavaScript/controllers and add a stimulus controller in the file, which helps to bring the HTML into life.

#CODE

import { Controller } from "@hotwired/stimulus"

export default class extends Controller {
  static targets = [ "name", "output" ]

  greet() {
    this.outputTarget.textContent =
      `Hello, ${this.nameTarget.value}!`
  }
}

add a stimulus controller in the file Go to your browser after making the changes in the code and click on Enter to other page link which will navigate to the localhost:3000/other/index page there you can see the changes implemented by the stimulus controller that is designed to augment your HTML with just enough behavior to make it more responsive.

With just a little bit of work, Turbo and Stimulus together offer a complete answer for applications that are quick and compelling.

Using Rails 7 Hotwire helps to load the pages at a faster speed and allows you to render templates on the server, where you have access to your whole domain model. It is a productive development experience in ROR, without compromising any of the speed or responsiveness associated with SPA.

Conclusion

We hope you were satisfied with our Rails Hotwire tutorial. Write to us at service@bacancy.com for any query that you want to resolve, or if you want us to share a tutorial on your query.

For more such solutions on RoR, check out our Ruby on Rails Tutorials. We will always strive to amaze you and cater to your needs.

Original article source at: https://www.bacancytechnology.com/

#rails #ruby

Tyrique Littel

1604008800

Static Code Analysis: What It Is? How to Use It?

Static code analysis refers to the technique of approximating the runtime behavior of a program. In other words, it is the process of predicting the output of a program without actually executing it.

Lately, however, the term “Static Code Analysis” is more commonly used to refer to one of the applications of this technique rather than the technique itself — program comprehension — understanding the program and detecting issues in it (anything from syntax errors to type mismatches, performance hogs likely bugs, security loopholes, etc.). This is the usage we’d be referring to throughout this post.

“The refinement of techniques for the prompt discovery of error serves as well as any other as a hallmark of what we mean by science.”

J. Robert Oppenheimer

Outline

We cover a lot of ground in this post. The aim is to build an understanding of static code analysis and to equip you with the basic theory, and the right tools so that you can write analyzers on your own.

We start our journey with laying down the essential parts of the pipeline which a compiler follows to understand what a piece of code does. We learn where to tap points in this pipeline to plug in our analyzers and extract meaningful information. In the latter half, we get our feet wet, and write four such static analyzers, completely from scratch, in Python.

Note that although the ideas here are discussed in light of Python, static code analyzers across all programming languages are carved out along similar lines. We chose Python because of the availability of an easy to use ast module, and wide adoption of the language itself.

How does it all work?

Before a computer can finally “understand” and execute a piece of code, it goes through a series of complicated transformations:

static analysis workflow

As you can see in the diagram (go ahead, zoom it!), the static analyzers feed on the output of these stages. To be able to better understand the static analysis techniques, let’s look at each of these steps in some more detail:

Scanning

The first thing that a compiler does when trying to understand a piece of code is to break it down into smaller chunks, also known as tokens. Tokens are akin to what words are in a language.

A token might consist of either a single character, like (, or literals (like integers, strings, e.g., 7, Bob, etc.), or reserved keywords of that language (e.g, def in Python). Characters which do not contribute towards the semantics of a program, like trailing whitespace, comments, etc. are often discarded by the scanner.

Python provides the tokenize module in its standard library to let you play around with tokens:

Python

1

import io

2

import tokenize

3

4

code = b"color = input('Enter your favourite color: ')"

5

6

for token in tokenize.tokenize(io.BytesIO(code).readline):

7

    print(token)

Python

1

TokenInfo(type=62 (ENCODING),  string='utf-8')

2

TokenInfo(type=1  (NAME),      string='color')

3

TokenInfo(type=54 (OP),        string='=')

4

TokenInfo(type=1  (NAME),      string='input')

5

TokenInfo(type=54 (OP),        string='(')

6

TokenInfo(type=3  (STRING),    string="'Enter your favourite color: '")

7

TokenInfo(type=54 (OP),        string=')')

8

TokenInfo(type=4  (NEWLINE),   string='')

9

TokenInfo(type=0  (ENDMARKER), string='')

(Note that for the sake of readability, I’ve omitted a few columns from the result above — metadata like starting index, ending index, a copy of the line on which a token occurs, etc.)

#code quality #code review #static analysis #static code analysis #code analysis #static analysis tools #code review tips #static code analyzer #static code analysis tool #static analyzer

Rust Blockchain

1643176207

Serde Rust: Serialization Framework for Rust

Serde

*Serde is a framework for serializing and deserializing Rust data structures efficiently and generically.*

You may be looking for:

Serde in action

Click to show Cargo.toml. Run this code in the playground.

[dependencies]

# The core APIs, including the Serialize and Deserialize traits. Always
# required when using Serde. The "derive" feature is only required when
# using #[derive(Serialize, Deserialize)] to make Serde work with structs
# and enums defined in your crate.
serde = { version = "1.0", features = ["derive"] }

# Each data format lives in its own crate; the sample code below uses JSON
# but you may be using a different one.
serde_json = "1.0"

use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, Debug)]
struct Point {
    x: i32,
    y: i32,
}

fn main() {
    let point = Point { x: 1, y: 2 };

    // Convert the Point to a JSON string.
    let serialized = serde_json::to_string(&point).unwrap();

    // Prints serialized = {"x":1,"y":2}
    println!("serialized = {}", serialized);

    // Convert the JSON string back to a Point.
    let deserialized: Point = serde_json::from_str(&serialized).unwrap();

    // Prints deserialized = Point { x: 1, y: 2 }
    println!("deserialized = {:?}", deserialized);
}

Getting help

Serde is one of the most widely used Rust libraries so any place that Rustaceans congregate will be able to help you out. For chat, consider trying the #rust-questions or #rust-beginners channels of the unofficial community Discord (invite: https://discord.gg/rust-lang-community), the #rust-usage or #beginners channels of the official Rust Project Discord (invite: https://discord.gg/rust-lang), or the #general stream in Zulip. For asynchronous, consider the [rust] tag on StackOverflow, the /r/rust subreddit which has a pinned weekly easy questions post, or the Rust Discourse forum. It's acceptable to file a support issue in this repo but they tend not to get as many eyes as any of the above and may get closed without a response after some time.

Download Details:
Author: serde-rs
Source Code: https://github.com/serde-rs/serde
License: View license

#rust #rustlang

Thierry Perret

1657318200