modulorails 0.2.2 → 1.0.1

data/lib/generators/modulorails/rubocop/rubocop_generator.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+
+class Modulorails::RubocopGenerator < Rails::Generators::Base
+  source_root File.expand_path('templates', __dir__)
+  desc 'This generator creates a configuration for Rubocop'
+
+  def create_config_files
+    rubocop_config_path = Rails.root.join('.rubocop.yml')
+    gitlab_config_path  = Rails.root.join('.gitlab-ci.yml')
+
+    template "rubocop.yml", rubocop_config_path, force: true
+
+    unless File.read(gitlab_config_path).match?(/\s+extends:\s+.lint\s*$/)
+      append_file gitlab_config_path do
+        <<~YAML
+        rubocop:
+          extends: .lint
+        YAML
+      end
+    end
+  end
+end

data/lib/generators/modulorails/rubocop/templates/rubocop.yml.tt

@@ -0,0 +1,18 @@
+# The behavior of RuboCop can be controlled via the .rubocop.yml
+# configuration file. It makes it possible to enable/disable
+# certain cops (checks) and to alter their behavior if they accept
+# any parameters. The file can be placed either in your home
+# directory or in some project directory.
+#
+# RuboCop will start looking for the configuration file in the directory
+# where the inspected file is and continue its way up to the root directory.
+#
+# See https://docs.rubocop.org/rubocop/configuration
+
+inherit_gem:
+  modulorails: .rubocop.yml
+
+# Take into account the exclude list from the gem
+inherit_mode:
+  merge:
+    - Exclude

data/lib/generators/modulorails/self_update/self_update_generator.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+
+# Author: Matthieu 'ciappa_m' Ciappara
+# This updates modulorails by editing the gemfile and running a bundle update
+class Modulorails::SelfUpdateGenerator < Rails::Generators::Base
+  source_root File.expand_path('templates', __dir__)
+  desc 'This generator updates Modulorails if required'
+
+  LATEST_VERSION_URL = 'https://rubygems.org/api/v1/versions/modulorails/latest.json'.freeze
+
+  def create_config_file
+    modulorails_version = Gem::Version.new(Modulorails::VERSION)
+
+    # Get the last published version
+    last_published_version_s = HTTParty.get(LATEST_VERSION_URL).parsed_response['version']
+    last_published_version   = Gem::Version.new(last_published_version_s)
+
+    # Do nothing if we could not fetch the last published version (whatever the reason)
+    # Or if the current version is the same as the last published version
+    return if last_published_version <= modulorails_version
+
+    # Add gem to Gemfile
+    gsub_file 'Gemfile', /^\s*gem\s['"]modulorails['"].*$/, "gem 'modulorails', '= #{last_published_version}'"
+
+    # Update the gem and the Gemfile.lock
+    system('bundle install')
+  rescue StandardError => e
+    $stderr.puts("[Modulorails] Error: cannot generate health_check configuration: #{e.message}")
+  end
+end

data/lib/generators/modulorails/service/service_generator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'rails/generators'
+
+class Modulorails::ServiceGenerator < Rails::Generators::NamedBase
+  source_root File.expand_path('templates', __dir__)
+  desc 'This generator creates a service inheriting Modulorails::BaseService'
+  argument :arguments, type: :array, default: [], banner: 'argument argument'
+
+  def create_service_files
+    template "service.rb", File.join("app/services", class_path, "#{file_name}_service.rb")
+  end
+end

data/lib/generators/modulorails/service/templates/service.rb.tt

@@ -0,0 +1,28 @@
+<% module_namespacing do -%>
+# @author <INSERT YOUR NAME HERE>
+# <DESCRIBE YOUR CLASS HERE>
+<%- if arguments.size >= 1 -%>
+#
+<%- arguments.each do |argument| -%>
+# @!attribute <%= argument %>
+#   @return <DESCRIBE YOUR ARGUMENT HERE>
+<%- end -%>
+<%- end -%>
+class <%= class_name %>Service < ::ApplicationService
+  <%- if arguments.size >= 1 -%>
+
+  def initialize(<%= arguments.join(', ') %>)
+    super()
+
+    <%- arguments.each do |argument| -%>
+    <%= "@#{argument} = #{argument}" %>
+    <%- end -%>
+  end
+  <%- end -%>
+
+  def call
+    # TODO
+  end
+
+end
+<% end -%>

data/lib/modulorails/configuration.rb

@@ -4,7 +4,7 @@ module Modulorails
   class Configuration
     # All the keys to configure the gem
     attr_accessor :_name, :_main_developer, :_project_manager, :_endpoint, :_api_key,
-                  :_no_auto_update
+                  :_no_auto_update, :_production_url, :_staging_url, :_review_base_url
 
     # This allows to define a DSL to configure the gem
     # Example:
@@ -14,8 +14,14 @@ module Modulorails
     #   config.project_manager 'pm@modulotech.fr'
     #   config.endpoint "intranet's endpoint"
     #   config.api_key "intranet's api key"
+    #   config.production_url "production.app.com"
+    #   config.staging_url "staging.app.com"
+    #   config.review_base_url "review.app.com"
     # end
-    %i[name main_developer project_manager endpoint api_key no_auto_update].each do |field|
+    %i[
+      name main_developer project_manager endpoint api_key no_auto_update production_url staging_url
+      review_base_url
+    ].each do |field|
       define_method(field) do |value=nil|
         # No value means we want to get the field
         return send("_#{field}") unless value

data/lib/modulorails/data.rb

@@ -10,7 +10,8 @@ module Modulorails
     # All the data handled by this class
     ATTRIBUTE_KEYS = %i[
       name main_developer project_manager repository type rails_name ruby_version rails_version
-      bundler_version modulorails_version adapter db_version adapter_version
+      bundler_version modulorails_version adapter db_version adapter_version production_url
+      staging_url review_base_url
     ].freeze
 
     # Useful if the gem's user need to read one of the data
@@ -30,7 +31,7 @@ module Modulorails
       # Get the gem's specifications to fetch the versions of critical gems
       loaded_specs = Gem.loaded_specs
 
-      # The three data written by the user in the configuration
+      # The data written by the user in the configuration
       # The name is the usual name of the project, the one used in conversations at Modulotech
       @name = configuration.name
       # The main developer, the lead developer, in short the developer to call when something's
@@ -39,6 +40,19 @@ module Modulorails
       # The project manager of the application; the other person to call when something's wrong with
       # the application ;)
       @project_manager = configuration.project_manager
+      # The URL of the production environment for the application
+      @production_url = configuration.production_url
+      # The URL of the staging environment for the application
+      @staging_url = configuration.staging_url
+      # The base URL of the review environment for the application.
+      # A real review URL is built like this at Modulotech:
+      # https://review-#{shortened_branch_name}-#{ci_slug}.#{review_base_url}
+      # Example:
+      # review_base_url: dev.app.com
+      # branch_name: 786-a_super_branch => shortened_branch_name: 786-a_sup
+      # ci_slug: jzzham
+      # |-> https://review-786-a_sup-jzzham.dev.app.com/
+      @review_base_url = configuration.review_base_url
 
       # Theorically, origin is the main repository of the project and git is the sole VCS we use
       # at Modulotech
@@ -101,6 +115,11 @@ module Modulorails
             'adapter'     => @adapter,
             'db_version'  => @db_version,
             'gem_version' => @adapter_version
+          },
+          'urls'                => {
+            'production'  => @production_url,
+            'staging'     => @staging_url,
+            'review_base' => @review_base_url
           }
         }
       }

data/lib/modulorails/error_data.rb

@@ -0,0 +1,21 @@
+# @author Matthieu Ciappara <ciappa_m@modulotech>
+# An error encountered during an operation with additional data.
+class Modulorails::ErrorData
+  # @!attribute r errors
+  #   An error message or an array of error messages (those will be joined by a coma and a space).
+  # @!attribute r exception
+  #   The exception that caused the error. Defaults to nil.
+  attr_reader :errors, :exception
+
+  # @param errors [String,Array<String>] An error message or an array of error messages
+  # @param exception [Exception,nil] The exception that caused the error.
+  def initialize(errors, exception: nil)
+    @errors    = errors.respond_to?(:join) ? errors.join(', ') : errors.to_s
+    @exception = exception
+  end
+
+  # @return [false] An error always means the operation was not a success.
+  def success?
+    false
+  end
+end

data/lib/modulorails/errors/base_error.rb

@@ -0,0 +1,4 @@
+# @author Matthieu CIAPPARA <ciappa_m@modulotech.fr>
+# The base class for modulorails exceptions.
+class Modulorails::BaseError < RuntimeError
+end

data/lib/modulorails/errors/errors.rb

@@ -0,0 +1,3 @@
+require_relative 'base_error'
+require_relative 'invalid_format_error'
+require_relative 'invalid_value_error'

data/lib/modulorails/errors/invalid_format_error.rb

@@ -0,0 +1,14 @@
+# @author Matthieu CIAPPARA <ciappa_m@modulotech.fr>
+# An exception representing an invalid format for a given field.
+class Modulorails::InvalidFormatError < Modulorails::BaseError
+  # @!attribute r field
+  #   The name of the field that had a wrong format.
+  attr_reader :field
+
+  # @param field [String]
+  def initialize(field)
+    super(I18n.t('modulorails.errors.invalid_format', field: field))
+
+    @field = field
+  end
+end

data/lib/modulorails/errors/invalid_value_error.rb

@@ -0,0 +1,14 @@
+# @author Matthieu CIAPPARA <ciappa_m@modulotech.fr>
+# An exception representing an invalid value for a given field.
+class Modulorails::InvalidValueError < Modulorails::BaseError
+  # @!attribute r field
+  #   The name of the field that had a wrong value.
+  attr_reader :field
+
+  # @param field [String]
+  def initialize(field)
+    super(I18n.t('modulorails.errors.invalid_value', field: field))
+
+    @field = field
+  end
+end

data/lib/modulorails/railtie.rb

@@ -1,9 +1,38 @@
+require_relative '../../app/helpers/modulorails/application_helper'
+
 module Modulorails
+  # Bind in the Rails lifecycle
   class Railtie < ::Rails::Railtie
-    # Binding in the Rails lifecycle. Sending data after the initialization ensures we can access
-    # all gems and symbols we might have to use.
+    # Update and add gems before we load the configuration
+    config.before_configuration do
+      # Currently, we limit everything to the development environment
+      if Rails.env.development?
+        # Check database configuration
+        Modulorails.generate_healthcheck_template
+      end
+    end
+
+    # Require the gem before we read the health_check initializer
+    config.before_initialize do
+      require 'health_check'
+    end
+
+    initializer 'modulorails.action_view' do
+      ActiveSupport.on_load :action_view do
+        include Modulorails::ApplicationHelper
+      end
+    end
+
+    initializer 'modulorails.assets' do |app|
+      %w[stylesheets javascripts].each do |subdirectory|
+        app.config.assets.paths << File.expand_path("../../../app/assets/#{subdirectory}", __FILE__)
+      end
+    end
+
+    # Sending data after the initialization ensures we can access
+    # all gems, constants and configurations we might need.
     config.after_initialize do
-      # For now, we limit everything to the development environment
+      # Currently, we limit everything to the development environment
       if Rails.env.development?
         # Load translations
         I18n.load_path += [File.expand_path('../../../config/locales/en.yml', __FILE__)]
@@ -17,6 +46,9 @@ module Modulorails
         # Check database configuration
         Modulorails.check_database_config
 
+        # Add/update Rubocop config
+        Modulorails.generate_rubocop_template
+
         # Gem's self-update if a new version was released
         Modulorails.self_update
       end

data/lib/modulorails/services/base_service.rb

@@ -0,0 +1,203 @@
+# @author Matthieu CIAPPARA <ciappa_m@modulotech.fr>
+# The base class for services. Should be implemented by ApplicationService following the model of
+# ActiveRecord::Base and ApplicationRecord.
+class Modulorails::BaseService
+  # Allow to instantiate the service and call the service in one go.
+  if Modulorails::COMPARABLE_RUBY_VERSION < Gem::Version.new('3.0')
+    def self.call(*args, &block)
+      new(*args, &block).call
+    end
+  else
+    def self.call(*args, **kwargs, &block)
+      new(*args, **kwargs, &block).call
+    end
+  end
+
+  # @abstract The main method to implement for your service to do something
+  def call
+    raise NotImplementedError.new('Implement method call on sub-class')
+  end
+
+  def to_s
+    self.class.to_s
+  end
+
+  # The method used by Modulorails::LogsForMethodService to log the service name
+  def to_tag
+    self.class.to_s
+  end
+
+  # Shamelessly copied from text_helper
+  def self.pluralize(count, singular, plural_arg = nil, plural: plural_arg, locale: I18n.locale)
+    word = if count == 1 || count =~ /^1(\.0+)?$/
+             singular
+           else
+             plural || singular.pluralize(locale)
+           end
+
+    "#{count || 0} #{word}"
+  end
+
+  protected
+
+  # Wrapper to Modulorails::LogsForMethodService
+  # @param method [#to_s] The method calling `#log`
+  # @param message [Hash,#to_s] The message to log; Hash will be logged after a #to_json call
+  def log(method, message)
+    Modulorails::LogsForMethodService.call(method: method, message: message, tags: [self])
+  end
+
+  # @yield Wrap the given block in an ActiveRecord transaction.
+  # @yieldreturn [Object] Will be available as data of the `SuccessData` returned by the method
+  # @return [SuccessData] If the transaction was not rollbacked; give access to the block's return.
+  # @return [ErrorData] If the transaction was rollbacked; give access to the rollbacking exception.
+  def with_transaction
+    data = nil
+
+    ActiveRecord::Base.transaction do
+      data = yield
+    end
+
+    SuccessData.new(data)
+  rescue ActiveRecord::RecordInvalid => e
+    # Known error, no need for a log, it just needs to be returned
+    ErrorData.new(e.message, exception: e)
+  rescue StandardError => e
+    # Unknown error, log the error
+    Rails.logger.error("#{self}: #{e.message}")
+    Rails.logger.error("Local variables: #{local_variables.map! { |v| { v => eval(v.to_s, binding) } }}")
+    Rails.logger.error(e.backtrace&.join("\n"))
+
+    # Return the error
+    ErrorData.new(e.message, exception: e)
+  end
+
+  # Cast the date/datetime parameters to time with zones.
+  # @param from [String,ActiveSupport::TimeWithZone] the minimum date
+  # @param to [String,ActiveSupport::TimeWithZone] the maximum date
+  # @return [[ActiveSupport::TimeWithZone, ActiveSupport::TimeWithZone]] The given dates casted.
+  def params_to_time(from, to = nil)
+    from = from.is_a?(String) && from.present? ? from.to_time_with_zone : from
+    to   = if to.is_a?(String) && to.present?
+             to = to.to_time_with_zone
+
+             # If the right bound is exactly the same as the left one, we add 1 day to the right
+             # one by default.
+             to.present? && to == from ? to + 1.day : to
+           else
+             to
+           end
+
+    [from, to]
+  end
+
+  # Shamelessly copied from text_helper
+  def pluralize(count, singular, plural_arg = nil, plural: plural_arg, locale: I18n.locale)
+    self.class.pluralize(count, singular, plural_arg, plural: plural, locale: locale)
+  end
+
+  # Take a series of keys, dig them into the given params and ensure the found value is a date.
+  # @param keys [Array<Symbol>] The keys to find in the parameters.
+  # @param params [#dig] The parameters to dig in.
+  # @return [ActiveSupport::TimeWithZone] If it is found, the value casted as a datetime.
+  # @return [nil] If the parameter was not found.
+  def parse_date_field(*keys, params:)
+    value = params.dig(*keys)
+
+    return nil unless value
+
+    begin
+      Time.zone.parse(value)
+    rescue ArgumentError
+      raise InvalidFormatError.new(keys.join('/'))
+    end
+  end
+
+  # Take a series of keys, dig them into the given params and ensure the found value is a date.
+  # @param keys [Array<Symbol>] The keys to find in the parameters.
+  # @param params [#dig] The parameters to dig in.
+  # @return [ActiveSupport::TimeWithZone] If it is found, the value casted as a datetime.
+  # @return [nil] If the parameter was not found.
+  def parse_iso8601_field(*keys, params: {})
+    value = params.dig(*keys)
+
+    return nil unless value
+
+    begin
+      Time.zone.iso8601(value)
+    rescue ArgumentError
+      raise InvalidFormatError.new(keys.join('/'))
+    end
+  end
+
+  # Take a series of keys, dig them into the given params and ensure the found value is valid.
+  # @param allowed_values [#include?] Allowed values
+  # @param keys [Array<Symbol>] The keys to find in the parameters.
+  # @param params [#dig] The parameters to dig in.
+  # @param allow_nil [Boolean] Do not raise if value is nil.
+  # @return [ActiveSupport::TimeWithZone] If it is found, the value casted as a datetime.
+  # @return [nil] If the parameter was not found.
+  def parse_enumerated_field(allowed_values, keys, params: {}, allow_nil: true)
+    value = params.dig(*keys)
+
+    if value.respond_to?(:each)
+      raise InvalidValueError.new(keys.join('/')) unless value.all? { |v| allowed_values.include?(v) }
+    else
+      return nil if !value && allow_nil
+
+      raise InvalidValueError.new(keys.join('/')) unless allowed_values.include?(value)
+    end
+
+    value
+  end
+
+  # @param model [#find_by] The model to search in
+  # @param field [Symbol] The field to filter on
+  # @param keys [Array<Symbol>] The keys to search in the params
+  # @param params [#dig] The params to search in
+  # @param allow_nil [Boolean] Raise if the keys are not found; default true
+  # @return [#id, nil] The record corresponding to given field and values (through keys)
+  # @raise [InvalidValueError] When there is no record for given field and values
+  def parse_referential_value(model, field, *keys, params: {}, allow_nil: true)
+    value = params.dig(*keys)
+
+    unless value
+      if allow_nil
+        return nil
+      else
+        raise InvalidValueError.new(keys.join('/'))
+      end
+    end
+
+    result = model.find_by(field => value)
+
+    raise InvalidValueError.new(keys.join('/')) if result.nil?
+
+    result
+  end
+
+  # @param model [#where] The model to search in
+  # @param field [Symbol] The field to filter on
+  # @param keys [Array<Symbol>] The keys to search in the params
+  # @param params [#dig] The parmas to search in
+  # @param allow_nil [Boolean] Raise if the keys are not found; default true
+  # @return [#ids, nil] The record corresponding to given field and values (through keys)
+  # @raise [InvalidValueError] When there is no record for given field and values
+  def parse_referential_values(model, field, *keys, params: {}, allow_nil: true)
+    values = params.dig(*keys)
+
+    if values.blank?
+      if allow_nil
+        return nil
+      else
+        raise InvalidValueError.new(keys.join('/'))
+      end
+    end
+
+    results = model.where(field => values)
+
+    raise InvalidValueError.new(keys.join('/')) if results.blank?
+
+    results
+  end
+end

data/lib/modulorails/services/logs_for_method_service.rb

@@ -0,0 +1,42 @@
+# @author Matthieu CIAPPARA <ciappa_m@modulotech.fr>
+# A service to write formatted debug logs from a method.
+class Modulorails::LogsForMethodService < Modulorails::BaseService
+
+  # @param method [String] The name of the calling method
+  # @param message [String,#to_json] The body of the log.
+  # @param tags [Array<String,#to_tag>] A list of tags to prefix the log.
+  def initialize(method:, message:, tags: [])
+    super()
+    @method  = method
+    @message = message
+    @tags    = tags
+  end
+
+  # Write a formatted debug log using given initialization parameters
+  def call
+    # Map the tags (either objects responding to #to_tag or strings) to prefix the log body
+    tag_strings = @tags.map do |tag|
+      tag.respond_to?(:to_tag) ? "[#{tag.to_tag}]" : "[#{tag}]"
+    end
+
+    # If the message respond_to #to_json (and is not a String), use it.
+    @message = jsonify if !@message.is_a?(String) && @message.respond_to?(:to_json)
+
+    # Join the tags
+    tag_string = tag_strings.join
+
+    # Split on newlines to avoid a log of a thousand columns and for each line, prefix the tags
+    # and log it as debug.
+    @message.split("\n").each do |line|
+      msg = "#{tag_string}[#{@method}] #{line}"
+
+      Rails.logger.debug(msg)
+    end
+  end
+
+  private
+
+  def jsonify
+    @message.to_json
+  end
+end

data/lib/modulorails/services/services.rb

@@ -0,0 +1,2 @@
+require_relative 'base_service'
+require_relative 'logs_for_method_service'

data/lib/modulorails/success_data.rb

@@ -0,0 +1,17 @@
+# @author Matthieu Ciappara <ciappa_m@modulotech>
+# A success resulting from an operation with optional additional data.
+class Modulorails::SuccessData
+  # @!attribute r data
+  #   An object to transport some data (for instance the result of the operation). Defaults to nil.
+  attr_reader :data
+
+  # @param data [Object] An object to transport some data (for instance the result of the operation)
+  def initialize(data=nil)
+    @data = data
+  end
+
+  # @return [true] A success always means the operation was a success. ;)
+  def success?
+    true
+  end
+end

data/lib/modulorails/validators/database_configuration.rb

@@ -31,7 +31,7 @@ module Modulorails
 
       def call
         database_configuration = check_standard_config_file_location
-        return false unless database_configuration
+        return [:standard_config_file_location] unless database_configuration
 
         check_test_database_not_equals_dev_database(database_configuration)
         check_rules_for_environment(database_configuration, :development)
@@ -52,13 +52,19 @@ module Modulorails
 
       def check_standard_config_file_location
         # Load the configuration
-        config = Psych.load_file(Rails.root.join('config/database.yml'))
+        config = if Modulorails::COMPARABLE_RUBY_VERSION >= Gem::Version.new('3.1')
+                   # Ruby 3.1 uses Psych4 which changes the default way of handling aliases in
+                   # `load_file`.
+                   Psych.load_file(Rails.root.join('config/database.yml'), aliases: true)
+                 else
+                   Psych.load_file(Rails.root.join('config/database.yml'))
+                 end
 
         # If no exception was raised, then the database configuration file is at standard location
         @rules[:standard_config_file_location] = true
 
         config
-      rescue StandardError =>e
+      rescue StandardError => e
         # An exception was raised, either the file is not a the standard location, either it just
         # cannot be read. Either way, we consider the config as invalid
         @rules[:standard_config_file_location] = false

data/lib/modulorails/version.rb

@@ -1,3 +1,6 @@
 module Modulorails
-  VERSION = '0.2.2'
+  VERSION = '1.0.1'
+
+  # Useful to compare the current Ruby version
+  COMPARABLE_RUBY_VERSION = Gem::Version.new(RUBY_VERSION)
 end