Common method in model and helper

I have a common method that exists in my model because it is called by my model. Retrospectively, my view also requires this model method. In order to accomplish this, I have:

1. moved the model method to the application_helper.rb file
2. my model calls the application_helper method by adding include ApplicationHelper at the top of my ActiveRecord model

Functionality wise, it works. But is t开发者_开发知识库his good practice?

My Model looks like this:

class Client < ActiveRecord::Base
  include ApplicationHelper
end

Writing include ApplicationHelper in to your model is bad practice because ApplicationHelper is a nice place to put tons of helper functions you need in your views. These functions will end up being imported as instance methods of your model. These functions are mostly unrelated to your model and will not work if they depend on things like params or request. Here are two other options:

Option 1:

You can just define the method inside the Client class, and then call it from the view, like this:

class Client < ActiveRecord::Base
    def self.my_class_method
    end
    def my_instance_method
    end
end

And then in your view:

<%= Client.my_class_method %>
<%= @client.my_instance_method %>

Option 2:

Make a separate module in lib and include it in the places you need it. The file name should match the module name for auto-loading to work.

In lib/my_module.rb:

module MyModule
    def my_method
    end
end

In your model:

class Client < ActiveRecord::Base
    include MyModule
    def other_method
      my_method
    end
end

Include the module in ApplicationHelper so it is available to all your views:

module ApplicationHelper
    include MyModule
end

Then in your view you can call it easily:

<%= my_method %>

If you do want to move it to a helper, you should move it in to the client_helper, as it is something just for your Client model and not for the whole application.

The method you speak of though, is it a static class method or an instance method? If it's an instance method, then your models (even if they're in views) can call that method. If it's a static class method, then your views can use it too by calling it like any other static class method (i.e, Client.do_method or something).

I don't see any reason why it needs to be in a helper, unless your method has absoloutely nothing to do with your model, in which case that would be a different question.

5 Common method in model and helper:

Option 1:

                    You can just define the method inside the Client class, and then call it from the view, 
                    like this:

                    class Client < ActiveRecord::Base
                        def self.my_class_method
                        end
                        def my_instance_method
                        end
                    end

                    And then in your view:

                        <%= Client.my_class_method %>
                        <%= @client.my_instance_method %>

Option 2:

                    module MyModule
                        def my_method
                        end
                    end

                  Include the module in ApplicationHelper so it is available to all your views:

                    module ApplicationHelper
                        include MyModule
                    end

                    Then in your view you can call it easily:

                    <%= my_method %>

option 3:

                    module MyModule
                        def my_method(amount)
                        end
                    end

                    In your model:

                    class Client < ActiveRecord::Base
                        include MyModule
                        def self.other_method(amount)
                          my_method(amount)
                        end
                    end     

                    Then in your view you can call it easily:

                    <%= Client.other_method(amount) %>  

Option 4: Or you can declare the helper method as a class function, and use it like so:

                    module Myhelper
                        def self.my_village
                          "bikharniyan kallan,Rajasthan,India"
                        end
                    end 

                  Then in your view you can call it easily:

                    <%= Myhelper.my_village %>  

option 5: use many helper in controller helper=>

                        module Myhelper
                            def my_info
                              "my information is"
                            end
                        end

                        module Myhelper1
                            def my_village
                              "bikharniyan kallan,Rajasthan,India"
                            end
                        end

                    ApplicationHelper=> 

                        module ApplicationHelper
                            include Myhelper
                            include Myhelper1
                        end

                    ApplicationController

                        class ApplicationController < ActionController::Base
                            include ApplicationHelper
                        end 

                    YourController  

                        class YourController < ActionController::Base
                            def action
                              my_info
                              my_village
                            end
                        end

At this moment, with rails 5 you can simply push your common method into application_record.rb

class ApplicationRecord < ActiveRecord::Base
  self.abstract_class = true

  def self.common_class_method
    # some awesome implement
  end

  def common_method
    # implement this
  end
end

Then in each model class you can call common_class_method by : YourClassName.common_class_method

or call common_method by: YourClassInstance.common_method