Perguntas[ruby-on-rails](coding)

Tenho dois modelos:

class Product
  belongs_to :storage_box
end

class StorageBox
  validates :key
            presence: true,
            uniqueness: { scope: %i[kind] }

  validates :kind
            presence: true
  def code
    "#{key}#{kind.to_s.rjust(4, '0')}"
  end
end

Gostaria de poder definir a storage_boxrelação com base no codemétodo:

Product.new(storage_box: '150001')

Como devo proceder para conseguir isso? Não tenho certeza se o Productdeve lidar com isso (parece que não é "rails" fazer isso lá) ou instruir o StorageBoxcomo encontrar a base no code.

Qual é a diferença entre isso:

User.includes(:sites).where("sites.name = 'test'").references(:sites)

e isto:

User.joins(:sites).where(sites: { name: "test"} )

Existe um consenso geral sobre o uso de um método em vez do outro?

Tenho uma pasta Rails com dois arquivos:

app/hub_spot/client.rb:
module HubSpot
  class Client

app/hub_spot/create_contact_form.rb:
module HubSpot
  class CreateContactForm

quando executo a verificação zeitwerk recebo:

expected file app/hub_spot/client.rb to define constant Client, but didn't

se eu adicionar:

config.autoload_paths << Rails.root.join("app/hub_spot")
config.eager_load_paths << Rails.root.join("app/hub_spot")

então recebo um novo erro:

expected file app/hub_spot/create_contact_form.rb to define constant CreateContactForm, but didn't

parece reclamar sobre ambos os arquivos de forma diferente? Tem alguma maneira de dizer ao Zeitwerk para olhar a pasta para o nome do módulo?

# frozen_string_literal: true

class UserUploader < ApplicationUploader
  include CarrierWave::MiniMagick

  def generate_image(text)
    tmp_path = File.join(Dir.tmpdir, "#{SecureRandom.hex}.png")

    MiniMagick::Tool::Convert.new do |img|
      img.size "500x200"
      img.xc "white"            # Background color
      img.gravity "Center"      # Center the text
      img.pointsize "36"        # Font size
      img.fill "black"          # Text color
      img.draw "text 0,0 '#{text}'"
      img.font "#{Rails.root.join('public', 'font', 'Franklin_Gothic_Heavy_Regular.ttf')}"
      img << tmp_path           # Save image to this path
    end

    File.open(tmp_path)  # Return file handle
  end
end

Estou enviando parâmetros do frontend e a fonte que estou usando no frontend é Franklin_Gothic_Heavy_Regular.ttf definida em app/assets/fonts/Franklin_Gothic_Heavy_Regular.ttf

Para usá-lo no carregador, adicionei o mesmo arquivo de fonte em public/font/Franklin_Gothic_Heavy_Regular.ttf, mas quando a imagem é armazenada, ela não mostra a fonte correta.

Estou usando vuejs no front-end e rails no back-end. Por favor, me ajude a consertar isso.

Informações do ImageMagick

Version: ImageMagick 7.1.0-58 Q16-HDRI x86_64 20802 https://imagemagick.org
Copyright: (C) 1999 ImageMagick Studio LLC
License: https://imagemagick.org/script/license.php
Features: Cipher DPC HDRI Modules OpenMP(5.0) 
Delegates (built-in): bzlib fontconfig freetype gslib heic jng jp2 jpeg jxl lcms lqr ltdl lzma openexr png ps raw tiff webp xml zlib
Compiler: gcc (4.2)

coloca img.command.join(" ") retorna

magick convert -size 500x200 xc:white -gravity Center -pointsize 36 -fill black -draw text 0,0 'Testing Font' -font /Users/Documents/work/company/public/font/Franklin_Gothic_Heavy_Regular.ttf /var/folders/tc/3b0wh1xs7z7dms5rxj1l23_00000gn/T/74a90ba3c194bda014cb2706a3fcdd32.png

Preciso acessar uma constante ActiveRecord de um módulo incluído em um aplicativo Rails.

class User < ApplicationRecord
  include ModOne
  
  OPTIONS = {a: 1}.freeze

  ...
end

Module ModOne
  extend ActiveSupport::Concern

  included do
    do_semething(self::OPTIONS)
  end

  class_methods do
   def do_something(opts)
     ...
   end
  end
end

Mas eu entendo

NameError: constante não inicializada Usuário (chame 'User.connection' para estabelecer uma conexão)::OPTIONS Você quis dizer? Usuário::OPTIONS

O que estou perdendo aqui?

Também tentei substituir selfpor base_classe evento User, mas recebo o mesmo erro.

Estou trabalhando em um projeto Ruby on Rails e praticando Desenvolvimento Orientado a Testes (TDD) usando o Minitest.

Para autenticação de usuário (usando Devise), escrevi um teste para verificar se um usuário não pode se inscrever sem um e-mail. No entanto, também tenho outros atributos obrigatórios, como first_name, last_name, username e password.

Isso me fez pensar:

• Devo escrever um teste separado para cada atributo ausente?
• Ou testar um atributo ausente é suficiente, já que o Rails já aplica validates :presence, true no nível do modelo?

Outro desenvolvedor sugeriu que se eu tivesse validação de presença para múltiplos atributos, eu também deveria escrever um teste para cada um. O raciocínio deles era que toda funcionalidade implementada deveria ser testada. Eles também sugeriram usar uma abordagem de loop para evitar código redundante em vez de escrever múltiplos testes quase idênticos.

Entendo que, de uma perspectiva TDD, onde eu escrevo o teste primeiro e então escrevo o código para fazê-lo passar, um teste de loop para atributos ausentes me forçaria a implementar validação de presença para cada campo. Isso garante que eu não esqueça um acidentalmente. No entanto, de uma abordagem mais pragmática, ainda me pergunto se esse nível de teste é necessário quando o Rails já impõe validação de presença no nível do modelo.

Adoraria ouvir as melhores práticas aqui: como desenvolvedores Rails experientes abordam isso?

Aqui está o teste que tenho atualmente:

  test "user cannot sign up without email" do
    post user_registration_path, params: {
      user: {
        first_name: "Test",
        last_name: "User",
        username: "testuser",
        email: "",
        password: "password123",
        password_confirmation: "password123",
      }
    }

    assert_response :unprocessable_entity
  end

Estou tentando remover automaticamente o valor atribuído do nome da coluna "table_number" se o usuário alterar o valor do nome da coluna "status" para "no" no formulário RSVP.

Estou tentando fazer isso no modelo do meu rsvp.rb com o seguinte código:

class Rsvp < ApplicationRecord

after_commit :remove_table_assignment, :if => :status_changed?

    def remove_table_assignment
        if self.status = "no"
          self.table_number = nil
        end
    end

end

Isso não faz o que estou tentando fazer e nem gera erro.

Recentemente baixei e instalei as últimas versões do Ruby (3.4.1) e Rails (8.0.1). Criei um projeto Rails e gerei um controlador com

bin/rails​​ ​​generate​​ ​​controller​​ ​​Say​​ ​​hello​​ ​​goodbye

Então eu iniciei o servidor e digitei "localhost:3000/say/hello" no meu navegador. A página da web é exibida sem erros. Em seguida, substituo o código em hello.html.erb por:

    <p>
      It is now ​<%=​ Time.​now​ ​%>​
    </p>

Recebi o seguinte erro quando atualizei meu navegador:

Para sua informação, instalei Ruby e Rails no Ubuntu 24.04, Windows 11 WSL e Mac OSX Sequoia usando:

Windows - https://rubyinstaller.org/downloads/ (Ruby+Devkit 3.3.7-1 (x64))

Ubuntu (vm rodando em Mac Parallels) - https://gorails.com/setup/ubuntu/24.04

Mac OSX - https://gorails.com/setup/macos/15-sequoia'

Toda vez eu obtenho o mesmo resultado. Como eu conserto isso?

Eu vi o código mostrado neste vídeo Go Rails em 05:15: Vídeo-tutorial

<%= form_with model: Link.new do |form| %>
    # ...
<% end %>

Normalmente eu teria escrito uma new-action. Algo como:

def new
  @link = Link.new
end

Obviamente, é possível pular a ação e criar o objeto necessário imediatamente, ao invocar o form_with.

Qual é o benefício de ter uma nova ação?

É para ter uma rota separada, que cria o formulário, quando invocada?

Sou novo no Ruby on Rails e gostaria de saber se é possível criar um nome de caminho de camada única no Rails.

Até onde eu sei, você só pode criar rotas como home/about. Existe uma maneira de criar somente /aboutem vez disso?

Tentei fazer isso com get '/test'um objeto que testtem seu próprio controlador e uma única página HTML nas visualizações, mas o Rails gerou um erro chamado:ArgumentError: Missing :controller key on routes definition, please check your routes.

Isso significa que não posso criar um caminho como /about, mas tenho que criar um caminho como home/about? Acho que ninguém mais perguntou isso antes.