基于年份变量选择模型：Rails多年度内部项目技术问询

Nice approach splitting your models by year to encapsulate annual changes—this keeps your codebase clean and avoids messy conditionals across models. Here are a few practical ways to dynamically select the right model based on a year variable in Rails:

1. Dynamic Constant Resolution (Simplest Approach) #

Rails models are just Ruby constants, so you can build the model name as a string and safely resolve it using const_get. This works well if your models follow a consistent naming pattern (like Sample2019Record, Sample2020Record).

Example Implementation: #

def model_for_year(year)
  # Convert year to a string and validate format first
  year_str = year.to_s
  unless year_str.match?(/^\d{4}$/)
    raise ArgumentError, "Invalid year format: #{year} (must be 4-digit number)"
  end

  # Build the model name string
  model_name = "Sample#{year_str}Record"

  # Safely check if the model exists before resolving it
  if Object.const_defined?(model_name)
    Object.const_get(model_name)
  else
    # Handle missing years: either raise an error or fall back to a base model
    raise ArgumentError, "No record model exists for year #{year}"
    # Or: SampleBaseRecord (if you have a shared base model)
  end
end

# Usage in controller or service
current_year = 2023
selected_model = model_for_year(current_year)
user_records = selected_model.where(owner_id: current_user.id)

Key Notes: #

• Always validate the year input to prevent malicious strings from being passed to const_get (the regex check ensures only 4-digit years are allowed).
• If you have a shared base model for all year-specific records, use that as a fallback instead of raising an error for edge cases.

2. Namespaced Models (Cleaner Organization) #

For better code organization, wrap your year-specific models in a module. This avoids cluttering the global namespace and makes it easier to group related logic.

Example Setup: #

# app/models/yearly_records/sample_2019_record.rb
module YearlyRecords
  class Sample2019Record < ApplicationRecord; end
end

# app/models/yearly_records/sample_2020_record.rb
module YearlyRecords
  class Sample2020Record < ApplicationRecord; end
end

Updated Model Selection Method: #

def model_for_year(year)
  year_str = year.to_s
  unless year_str.match?(/^\d{4}$/)
    raise ArgumentError, "Invalid year format: #{year}"
  end

  model_name = "Sample#{year_str}Record"
  if YearlyRecords.const_defined?(model_name)
    YearlyRecords.const_get(model_name)
  else
    raise ArgumentError, "No yearly record model found for #{year}"
  end
end

3. Shared Base Model (For Reusable Logic) #

If your year-specific models share common functionality (like report generation, field formatting, or scopes), abstract that logic into an abstract base model. All year-specific models inherit from this base, so you can treat them uniformly when rendering or processing data.

Example Base Model: #

# app/models/sample_base_record.rb
class SampleBaseRecord < ApplicationRecord
  self.abstract_class = true # Mark as abstract so Rails doesn't create a table for it

  # Shared scope example
  scope :active, -> { where(status: 'active') }

  # Shared method example
  def formatted_report_date
    created_at.strftime("%B %d, %Y")
  end
end

# Year-specific models inherit from base
class Sample2019Record < SampleBaseRecord; end
class Sample2020Record < SampleBaseRecord; end

Benefits: #

• When you dynamically select a model, you can call shared methods/scopes without worrying about which year it is.
• Views can render records from any year using the same template, since all models have the same shared interface.

Rendering Past Year Content #

In your controllers, grab the year parameter (from URL, session, or user input), resolve the model, and pass records to the view as you would with any other model:

Controller Example: #

# app/controllers/records_controller.rb
class RecordsController < ApplicationController
  def index
    @year = params[:year].to_i || Time.current.year
    @selected_model = model_for_year(@year)
    @records = @selected_model.active.order(created_at: :desc)
  end
end

View Example (ERB): #

<h1>Records for <%= @year %></h1>

<div class="records-list">
  <% @records.each do |record| %>
    <div class="record-item">
      <h3><%= record.title %></h3>
      <p>Created: <%= record.formatted_report_date %></p>
      <!-- Render year-specific fields conditionally if needed -->
      <% if @year >= 2021 %>
        <p>Custom Field: <%= record.custom_2021_field %></p>
      <% end %>
    </div>
  <% end %>
</div>

Routing Tip #

Add a route that accepts a year parameter to make it easy to navigate between years:

# config/routes.rb
get '/records/:year', to: 'records#index', as: :yearly_records

You can link to past years like this in views:

<% (2019..Time.current.year).each do |year| %>
  <%= link_to year, yearly_records_path(year: year) %>
<% end %>

内容的提问来源于stack exchange，提问作者Booshwa