tagging bs

Gemfile

···
 
 gem "pry"
 
+gem 'friendly_id', '~> 5.5.0'
+
 group :development, :test do
   # See https://guides.rubyonrails.org/debugging_rails_applications.html#debugging-with-the-debug-gem
   gem "debug", platforms: %i[ mri mswin mswin64 mingw x64_mingw ]

Gemfile.lock

···
       warden (~> 1.2.3)
     drb (2.2.1)
     erubi (1.12.0)
+    friendly_id (5.5.1)
+      activerecord (>= 4.0.0)
     globalid (1.2.1)
       activesupport (>= 6.1)
     i18n (1.14.4)
···
   capybara
   debug
   devise
+  friendly_id (~> 5.5.0)
   importmap-rails
   jbuilder
   paperclip (~> 5.1.0)

app/controllers/articles_controller.rb

···
 
   def index
     @article = Article.all
+    @tags = Tag.all
     @profiles = Profile.all
     respond_to do |format|
       format.html
···
 
   private
     def article_params
-      params.require(:article).permit(:title, :body, :status, :icon, :all_tags)
+      params.require(:article).permit(:title, :body, :status, :icon, :tag_id)
     end
 end

app/controllers/tags_controller.rb

···
 class TagsController < ApplicationController
+#  before_action :set_tag, only: %i[ show edit update destroy ]
+  before_action :authenticate_user!, :except => [:show]
+
+  # GET /tags or /tags.json
   def index
-    @tags = Tag.all
+    @tag = Tag.all
+  end
+
+  # GET /tags/1 or /tags/1.json
+  def show
+    @tag = Tag.friendly.find(params[:id])
+#    @article = Article.friendly.find_by(params[:id])
+  end
+
+  # GET /tags/new
+  def new
+    @tag = Tag.new
+  end
+
+  # GET /tags/1/edit
+  def edit
+    @tag = Tag.friendly.find(params[:id])
   end
 
+  # POST /tags or /tags.json
   def create
-    @tags = Tag.new(tag_params)
+    @tag = Tag.new(tag_params)
 
-    if @tags.save
-      redirect_to @tags
-    else
-      render :new, status: :unprocessable_entity
+    respond_to do |format|
+      if @tag.save
+        format.html { redirect_to tag_url(@tag), notice: "Tag was successfully created." }
+        format.json { render :show, status: :created, location: @tag }
+      else
+        format.html { render :new, status: :unprocessable_entity }
+        format.json { render json: @tag.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+  # PATCH/PUT /tags/1 or /tags/1.json
+  def update
+    respond_to do |format|
+      if @tag.update(tag_params)
+        format.html { redirect_to tag_url(@tag), notice: "Tag was successfully updated." }
+        format.json { render :show, status: :ok, location: @tag }
+      else
+        format.html { render :edit, status: :unprocessable_entity }
+        format.json { render json: @tag.errors, status: :unprocessable_entity }
+      end
     end
   end
 
-  def show
-    @tags = Tag.find(params[:id])
+  # DELETE /tags/1 or /tags/1.json
+  def destroy
+    @tag = Tag.friendly.find(params[:id])
+    if @tag.present?
+      @tag.destroy!
+    end
+    respond_to do |format|
+      format.html { redirect_to tags_url, notice: "Tag was successfully destroyed." }
+      format.json { head :no_content }
+    end
   end
 
   private
-  def tag_params
-      params.require(:tags).permit(:name)
-  end
+    # Use callbacks to share common setup or constraints between actions.
+#    def set_tag
+ #     @tag = Tag.friendly.find(params[:id])
+  #  end
 
+    # Only allow a list of trusted parameters through.
+    def tag_params
+      params.require(:tag).permit(:id, :name, :slug)
+    end
 end

app/models/article.rb

···
   has_one_attached :icon, dependent: :detach
 
   has_many :taggings
-  has_many :tags, through: :taggings
+  belongs_to :tag, dependent: :destroy
 
   validates :title, presence: true
   validates :body, presence: true, length: { minimum: 10 }

app/models/tag.rb

···
 class Tag < ApplicationRecord
-
-  has_many :taggings
-  has_many :articles, through: :taggings
+  extend FriendlyId
+  friendly_id :name, use: :slugged
 
+  has_many :articles
 end

app/views/articles/_form.html.erb

···
   </div>
 
   <div>
-    <%= form.label :all_tags %><br>
-    <%= form.text_field :all_tags %>
+    <%= form.label :tags %><br>
+    <%= form.collection_select :slug, Tag.all, :id, :name %>
   </div>
 
   <div>

app/views/articles/show.html.erb

···
 
 <p class="article_date"><%= @article.created_at.strftime('%Y %b %d') %></p>
 
-<p class="article_date"><%= raw tag_links(@article.all_tags) %></p>
-
 <div class="pbody"><%== @article.body %></div>
 
 <% if user_signed_in? %>

app/views/tags/_form.html.erb

···
+<%= form_with(model: tag) do |form| %>
+  <div>
+    <%= form.label :name %>
+    <%= form.text_field :name %>
+  </div>
+
+  <div>
+    <%= form.label :slug %>
+    <%= form.text_field :slug %>
+  </div>
+
+  <div>
+    <%= form.submit %>
+  </div>
+<% end %>

app/views/tags/_tag.html.erb

···
+<%= link_to tag.name, tag %>

app/views/tags/_tag.json.jbuilder

···
+json.extract! tag, :id, :name, :slug, :created_at, :updated_at
+json.url tag_url(tag, format: :json)

app/views/tags/edit.html.erb

···
+<h1>Editing tag</h1>
+
+<%= render "form", tag: @tag %>
+
+<br>
+
+<div>
+  <%= link_to "Show this tag", @tag %> |
+  <%= link_to "Back to tags", tags_path %>
+</div>

app/views/tags/index.html.erb

···
 <div class="main">
 
+<h1>🐬 tags</h1>
+
 <ul>
-  <% Tag.all.each do |tag| %>
-      <li>
-        <%= link_to tag.name, tag_path(tag.name) %>
-      </li>
+  <% @tag.each do |tag| %>
+    <li>
+      <%= render tag %>
+    </li>
   <% end %>
 </ul>
 

app/views/tags/index.json.jbuilder

···
+json.array! @tags, partial: "tags/tag", as: :tag

app/views/tags/new.html.erb

···
+<h1>New tag</h1>
+
+<%= render "form", tag: @tag %>
+
+<br>
+
+<div>
+  <%= link_to "Back to tags", tags_path %>
+</div>

app/views/tags/show.html.erb

···
 <div class="main">
 
-  <ul>
-    <% Tag.articles.each do |articles| %>
-      <li>
-        <%= link_to article.title, article %>
-      </li>
-    <% end %>
-  </ul>
+<h1><%= render @tag %></h1>
+
+<p>
+<%= link_to "edit", edit_tag_path(@tag) %> |
+  <% if user_signed_in? %>
+    <%= link_to "delete", @tag, method: :delete %>
+  <% else %>
+    <%= link_to "back", tags_path %>
+  <% end %>
+</p>
 
 </div>

app/views/tags/show.json.jbuilder

···
+json.partial! "tags/tag", tag: @tag

config/initializers/friendly_id.rb

···
+# FriendlyId Global Configuration
+#
+# Use this to set up shared configuration options for your entire application.
+# Any of the configuration options shown here can also be applied to single
+# models by passing arguments to the `friendly_id` class method or defining
+# methods in your model.
+#
+# To learn more, check out the guide:
+#
+# http://norman.github.io/friendly_id/file.Guide.html
+
+FriendlyId.defaults do |config|
+  # ## Reserved Words
+  #
+  # Some words could conflict with Rails's routes when used as slugs, or are
+  # undesirable to allow as slugs. Edit this list as needed for your app.
+  config.use :reserved
+
+  config.reserved_words = %w[new edit index session login logout users admin
+    stylesheets assets javascripts images]
+
+  # This adds an option to treat reserved words as conflicts rather than exceptions.
+  # When there is no good candidate, a UUID will be appended, matching the existing
+  # conflict behavior.
+
+  # config.treat_reserved_as_conflict = true
+
+  #  ## Friendly Finders
+  #
+  # Uncomment this to use friendly finders in all models. By default, if
+  # you wish to find a record by its friendly id, you must do:
+  #
+  #    MyModel.friendly.find('foo')
+  #
+  # If you uncomment this, you can do:
+  #
+  #    MyModel.find('foo')
+  #
+  # This is significantly more convenient but may not be appropriate for
+  # all applications, so you must explicitly opt-in to this behavior. You can
+  # always also configure it on a per-model basis if you prefer.
+  #
+  # Something else to consider is that using the :finders addon boosts
+  # performance because it will avoid Rails-internal code that makes runtime
+  # calls to `Module.extend`.
+  #
+  # config.use :finders
+  #
+  # ## Slugs
+  #
+  # Most applications will use the :slugged module everywhere. If you wish
+  # to do so, uncomment the following line.
+  #
+  # config.use :slugged
+  #
+  # By default, FriendlyId's :slugged addon expects the slug column to be named
+  # 'slug', but you can change it if you wish.
+  #
+  # config.slug_column = 'slug'
+  #
+  # By default, slug has no size limit, but you can change it if you wish.
+  #
+  # config.slug_limit = 255
+  #
+  # When FriendlyId can not generate a unique ID from your base method, it appends
+  # a UUID, separated by a single dash. You can configure the character used as the
+  # separator. If you're upgrading from FriendlyId 4, you may wish to replace this
+  # with two dashes.
+  #
+  # config.sequence_separator = '-'
+  #
+  # Note that you must use the :slugged addon **prior** to the line which
+  # configures the sequence separator, or else FriendlyId will raise an undefined
+  # method error.
+  #
+  #  ## Tips and Tricks
+  #
+  #  ### Controlling when slugs are generated
+  #
+  # As of FriendlyId 5.0, new slugs are generated only when the slug field is
+  # nil, but if you're using a column as your base method can change this
+  # behavior by overriding the `should_generate_new_friendly_id?` method that
+  # FriendlyId adds to your model. The change below makes FriendlyId 5.0 behave
+  # more like 4.0.
+  # Note: Use(include) Slugged module in the config if using the anonymous module.
+  # If you have `friendly_id :name, use: slugged` in the model, Slugged module
+  # is included after the anonymous module defined in the initializer, so it
+  # overrides the `should_generate_new_friendly_id?` method from the anonymous module.
+  #
+  # config.use :slugged
+  # config.use Module.new {
+  #   def should_generate_new_friendly_id?
+  #     slug.blank? || <your_column_name_here>_changed?
+  #   end
+  # }
+  #
+  # FriendlyId uses Rails's `parameterize` method to generate slugs, but for
+  # languages that don't use the Roman alphabet, that's not usually sufficient.
+  # Here we use the Babosa library to transliterate Russian Cyrillic slugs to
+  # ASCII. If you use this, don't forget to add "babosa" to your Gemfile.
+  #
+  # config.use Module.new {
+  #   def normalize_friendly_id(text)
+  #     text.to_slug.normalize! :transliterations => [:russian, :latin]
+  #   end
+  # }
+end

config/routes.rb

···
 Rails.application.routes.draw do
-  get 'tags/index'
-  get 'tags/create'
-  resources :galleries
   # Define your application routes per the DSL in https://guides.rubyonrails.org/routing.html
 
   # Reveal health status on /up that returns 200 if the app boots with no exceptions, otherwise 500.
···
 end
 
 Rails.application.routes.draw do
-  get 'tags/index'
-  get 'tags/create'
   get "/tags", to: "tags#index"
+#  get "tags/:edit" => "tags#edit", as: :edit_tag_path
   get "tags/:id" => "tags#show", as: :tag
+  get "tags/:new" => "tags#new"
+#  resources :tag, path: '', only: [:show] 
+  resources :tags
+end
 
-  resources :galleries
+Rails.application.routes.draw do
   get "/articles", to: "articles#index"
-#  get 'tags/:tag', to: 'articles#index', as: "tag"
   # For details on the DSL available within this file, see https://guides.rubyonrails.org/routing.html
 end
 
 Rails.application.routes.draw do
-  resources :galleries
         get "/users", to: "users#index", via: "get"
 end
 
 Rails.application.routes.draw do
-  resources :galleries
   root "articles#index"
   
   resources :profiles

test/controllers/tags_controller_test.rb

···
 require "test_helper"
 
 class TagsControllerTest < ActionDispatch::IntegrationTest
+  setup do
+    @tag = tags(:one)
+  end
+
   test "should get index" do
-    get tags_index_url
+    get tags_url
+    assert_response :success
+  end
+
+  test "should get new" do
+    get new_tag_url
+    assert_response :success
+  end
+
+  test "should create tag" do
+    assert_difference("Tag.count") do
+      post tags_url, params: { tag: { name: @tag.name, slug: @tag.slug } }
+    end
+
+    assert_redirected_to tag_url(Tag.last)
+  end
+
+  test "should show tag" do
+    get tag_url(@tag)
     assert_response :success
   end
 
-  test "should get create" do
-    get tags_create_url
+  test "should get edit" do
+    get edit_tag_url(@tag)
     assert_response :success
+  end
+
+  test "should update tag" do
+    patch tag_url(@tag), params: { tag: { name: @tag.name, slug: @tag.slug } }
+    assert_redirected_to tag_url(@tag)
+  end
+
+  test "should destroy tag" do
+    assert_difference("Tag.count", -1) do
+      delete tag_url(@tag)
+    end
+
+    assert_redirected_to tags_url
   end
 end

test/fixtures/tags.yml

···
 
 one:
   name: MyString
+  slug: MyString
 
 two:
   name: MyString
+  slug: MyString

test/system/tags_test.rb

···
+require "application_system_test_case"
+
+class TagsTest < ApplicationSystemTestCase
+  setup do
+    @tag = tags(:one)
+  end
+
+  test "visiting the index" do
+    visit tags_url
+    assert_selector "h1", text: "Tags"
+  end
+
+  test "should create tag" do
+    visit tags_url
+    click_on "New tag"
+
+    fill_in "Name", with: @tag.name
+    fill_in "Slug", with: @tag.slug
+    click_on "Create Tag"
+
+    assert_text "Tag was successfully created"
+    click_on "Back"
+  end
+
+  test "should update Tag" do
+    visit tag_url(@tag)
+    click_on "Edit this tag", match: :first
+
+    fill_in "Name", with: @tag.name
+    fill_in "Slug", with: @tag.slug
+    click_on "Update Tag"
+
+    assert_text "Tag was successfully updated"
+    click_on "Back"
+  end
+
+  test "should destroy Tag" do
+    visit tag_url(@tag)
+    click_on "Destroy this tag", match: :first
+
+    assert_text "Tag was successfully destroyed"
+  end
+end