panel/app/models/post.rb

# frozen_string_literal: true

require 'jekyll/utils'

# Esta clase representa un post en un sitio jekyll e incluye métodos
# para modificarlos y crear nuevos.
#
# rubocop:disable Metrics/ClassLength
# rubocop:disable Style/MethodMissingSuper
# rubocop:disable Style/MissingRespondToMissing
class Post < OpenStruct
  # Atributos por defecto
  # XXX: Volver document opcional cuando estemos creando
  DEFAULT_ATTRIBUTES = %i[site document layout].freeze
  # Otros atributos que no vienen en los metadatos
  ATTRIBUTES = %i[content lang date slug attributes errors].freeze

  # Redefinir el inicializador de OpenStruct
  #
  # @param site: [Site] el sitio en Sutty
  # @param document: [Jekyll::Document] el documento leído por Jekyll
  # @param layout: [Layout] la plantilla
  #
  # rubocop:disable Metrics/AbcSize
  # rubocop:disable Metrics/MethodLength
  def initialize(**args)
    default_attributes_missing(args)
    super(args)

    # Genera un método con todos los atributos disponibles
    self.attributes = DEFAULT_ATTRIBUTES +
                      ATTRIBUTES +
                      layout.metadata.keys.map(&:to_sym)

    # El contenido
    # TODO: Mover a su propia clase para poder hacer limpiezas
    # independientemente
    self.content = document.content
    self.date    = document.date
    # TODO: idem content
    self.slug    = document.data['slug']

    # Genera un atributo por cada uno de los campos de la plantilla,
    # MetadataFactory devuelve un tipo de campo por cada campo.  A
    # partir de ahí se pueden obtener los valores actuales y una lista
    # de valores por defecto.
    layout.metadata.each_pair do |name, template|
      send "#{name}=".to_sym,
           MetadataFactory.build(document: document,
                                 site: site,
                                 name: name,
                                 type: template['type'],
                                 label: template['label'],
                                 help: template['help'],
                                 required: template['required'])
    end
  end
  # rubocop:enable Metrics/AbcSize
  # rubocop:enable Metrics/MethodLength

  # Levanta un error si al construir el artículo no pasamos un atributo.
  def default_attributes_missing(**args)
    DEFAULT_ATTRIBUTES.each do |attr|
      i18n = I18n.t("exceptions.post.#{attr}_missing")

      raise ArgumentError, i18n unless args[attr].present?
    end
  end

  # Solo ejecuta la magia de OpenStruct si el campo existe en la
  # plantilla
  #
  # XXX: Reemplazarlo por nuestro propio método, mantener todo lo demás
  # compatible con OpenStruct
  #
  # XXX: rubocop dice que tenemos que usar super cuando ya lo estamos
  # usando...
  def method_missing(mid, *args)
    unless attribute? mid
      raise NoMethodError, I18n.t('exceptions.post.no_method',
                                  method: mid)
    end

    super(mid, *args)
  end

  # Detecta si es un atributo válido o no, a partir de la tabla de la
  # plantilla
  def attribute?(mid)
    if singleton_class.method_defined? :attributes
      attributes.include? attribute_name(mid)
    else
      (DEFAULT_ATTRIBUTES + ATTRIBUTES).include? attribute_name(mid)
    end
  end

  # Genera el post con metadatos en YAML
  # rubocop:disable Metrics/AbcSize
  def full_content
    yaml = layout.metadata.keys.map(&:to_sym).map do |metadata|
      template = send(metadata)

      { metadata.to_s => template.value } unless template.empty?
    end.compact.inject(:merge)

    # Asegurarse que haya un layout
    yaml['layout'] = layout.name.to_s

    "#{yaml.to_yaml}---\n\n#{content}"
  end

  # Eliminar el artículo del repositorio y de la lista de artículos del
  # sitio
  #
  # XXX Commit
  def destroy
    FileUtils.rm_f path

    site.posts(lang: lang).delete_if do |post|
      post.path == path
    end

    !File.exist?(path) && !site.posts(lang: lang).include?(self)
  end
  alias destroy! destroy
  # rubocop:enable Metrics/AbcSize

  # Guarda los cambios
  def save
    return false unless valid?
    return false unless write

    # Vuelve a leer el post para tomar los cambios
    document.read

    true
  end
  alias save! save

  # Devuelve la ruta del post, si se cambió alguno de los datos,
  # generamos una ruta nueva para tener siempre la ruta actualizada.
  def path
    document.path
  end

  # Detecta si el artículo es válido para guardar
  def valid?
    validate
    errors.blank?
  end

  # Requisitos para que el post sea válido
  def validate
    self.errors = {}

    layout.metadata.keys.map(&:to_sym).each do |metadata|
      template = send(metadata)

      errors[metadata] = template.errors unless template.valid?
    end
  end
  alias validate! validate

  def basename_changed?
    @post.try(:basename) != basename_from_front_matter
  end

  def slug_changed?
    new? || @post.data.dig('slug') != slug
  end

  # devuelve las plantillas como strong params, primero los valores
  # simples, luego los arrays y al final los hashes
  def template_params
    @template_params ||= template_fields.map(&:to_param).sort_by do |s|
      s.is_a?(Symbol) ? 0 : 1
    end
  end

  # Solo agregar el post al sitio una vez que lo guardamos
  #
  # TODO no sería la forma correcta de hacerlo en Rails
  # def add_post_to_site!
  #   @site.jekyll.collections[@collection].docs << @post
  #   @site.jekyll.collections[@collection].docs.sort!

  #   unless @site.collections[@collection].include? self
  #     @site.collections[@collection] << self
  #     @site.collections[@collection].sort!
  #   end
  # end

  # Cambiar el nombre del archivo si cambió el título o la fecha.
  # Como Jekyll no tiene métodos para modificar un Document, lo
  # engañamos eliminando la instancia de @post y recargando otra.
  def detect_file_rename!
    return true unless basename_changed?
    # No eliminamos el archivo a menos que ya exista el reemplazo!
    return false unless File.exist? path

    Rails.logger.info I18n.t('posts.logger.rm', path: path)
    FileUtils.rm @post.path
    #    replace_post!
  end

  # Reemplaza el post en el sitio por uno nuevo
  # TODO: refactorizar
  # def replace_post!
  #   @old_post = @site.jekyll.collections[@lang].docs.delete @post

  #   new_post
  # end

  def cleanup!
    default_date_is_today!
    clean_content!
    slugify_title!
  end

  # Aplica limpiezas básicas del contenido
  def clean_content!
    content.try(:delete!, "\r")
  end

  # Guarda los cambios en el archivo destino
  def write
    return true if persisted?

    Site::Writer.new(site: site, file: path,
                     content: full_content, usuarie: usuarie,
                     message: title.value).save
  end

  # Devuelve le autore de un artículo
  # XXX: Si se cambia le autore en el editor también cambia quién hace
  # un cambio y se le puede asignar a cualquier otre.
  # TODO: Mover la escritura a un servicio que combine escritura, commit
  # y current_usuarie
  def usuarie
    OpenStruct.new(email: author.value.first,
                   name: author.value.first.split('@', 2).first)
  end

  # Verifica si hace falta escribir cambios
  def persisted?
    File.exist?(path) && full_content == File.read(path)
  end

  private

  def default_date_is_today!
    self.date ||= Time.now
  end

  def slugify_title!
    self.slug = Jekyll::Utils.slugify(title) if slug.blank?
  end

  # Obtiene el nombre del atributo sin
  def attribute_name(attr)
    attr.to_s.split('=').first.to_sym
  end
end
# rubocop:enable Metrics/ClassLength
# rubocop:enable Style/MethodMissingSuper
# rubocop:enable Style/MissingRespondToMissing