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
  DEFAULT_ATTRIBUTES = %i[site document layout].freeze
  # Otros atributos que no vienen en los metadatos
  PRIVATE_ATTRIBUTES = %i[path slug attributes errors].freeze
  PUBLIC_ATTRIBUTES = %i[lang date].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
  #
  def initialize(**args)
    default_attributes_missing(args)
    super(args)

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

    # 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,
                                 post: self,
                                 site: site,
                                 name: name,
                                 value: args[name.to_sym],
                                 layout: layout,
                                 type: template['type'],
                                 label: template['label'],
                                 help: template['help'],
                                 required: template['required'])
    end

    load_lang!
    load_slug!
    load_date!
    load_path!

    # Leer el documento
    read
  end

  def id
    path.basename
  end

  # 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

    # Definir los attribute_*
    new_attribute_was(mid)
    new_attribute_changed(mid)

    # OpenStruct
    super(mid, *args)

    # Devolver lo mismo que devuelve el método después de definirlo
    send(mid, *args)
  end

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

  # Devuelve los strong params para el layout
  def params
    attributes.map do |attr|
      send(attr).to_param
    end
  end

  # Genera el post con metadatos en YAML
  def full_content
    body = ''
    yaml = layout.metadata.keys.map(&:to_sym).map do |metadata|
      template = send(metadata)

      unless template.front_matter?
        body += "\n\n"
        body += template.value
        next
      end

      next if template.empty?

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

    # Asegurarse que haya un layout
    yaml['layout'] = layout.name.to_s
    # Y que no se procese liquid
    yaml['liquid'] = false

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

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

    # TODO: Devolver self en lugar de todo el array
    site.posts(lang: lang.value).reject! do |post|
      post.path.absolute == path.absolute
    end
  end
  alias destroy! destroy

  # Guarda los cambios
  # rubocop:disable Metrics/CyclomaticComplexity
  def save
    return false unless valid?
    # Salir si tenemos que cambiar el nombre del archivo y no pudimos
    return false if !new? && path_changed? && !update_path!
    return false unless save_attributes!
    return false unless write

    # Vuelve a leer el post para tomar los cambios
    read

    written?
  end
  # rubocop:enable Metrics/CyclomaticComplexity
  alias save! save

  # Actualiza la ruta del documento y lo lee
  def read
    return unless written?

    document.path = path.absolute
    document.read
  end

  def new?
    document.path.blank?
  end

  def written?
    File.exist? path.absolute
  end

  # Actualizar la ubicación del archivo si cambió de lugar y si no
  # existe el destino
  def update_path!
    !File.exist?(path.absolute) &&
      FileUtils.mv(path_was, path.absolute) &&
      document.path = path.absolute
  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

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

    Site::Writer.new(site: site, file: path.absolute,
                     content: full_content).save
  end

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

  def destroyed?
    !File.exist?(path.absolute)
  end

  def update_attributes(hashable)
    hashable.to_hash.each do |name, value|
      self[name].value = value
    end

    save
  end
  alias update update_attributes

  private

  def new_attribute_was(method)
    attr_was = (attribute_name(method).to_s + '_was').to_sym
    return attr_was if singleton_class.method_defined? attr_was

    define_singleton_method(attr_was) do
      name = attribute_name(attr_was)
      if document.respond_to?(name)
        document.send(name)
      else
        document.data[name.to_s]
      end
    end
  end

  # Pregunta si el atributo cambió
  def new_attribute_changed(method)
    attr_changed = (attribute_name(method).to_s + '_changed?').to_sym

    return attr_changed if singleton_class.method_defined? attr_changed

    define_singleton_method(attr_changed) do
      name = attribute_name(attr_changed)
      name_was = (name.to_s + '_was').to_sym

      (send(name).try(:value) || send(name)) != send(name_was)
    end
  end

  # Obtiene el nombre del atributo a partir del nombre del método
  def attribute_name(attr)
    # XXX: Los simbolos van al final
    %w[_was _changed? ? =].reduce(attr.to_s) do |a, suffix|
      a.chomp suffix
    end.to_sym
  end

  def load_slug!
    self.slug = MetadataSlug.new(document: document, site: site,
                                 layout: layout, name: :slug, type: :slug,
                                 post: self,
                                 required: true)
  end

  def load_date!
    self.date = MetadataDocumentDate.new(document: document, site: site,
                                         layout: layout, name: :date,
                                         type: :document_date,
                                         post: self,
                                         required: true)
  end

  def load_path!
    self.path = MetadataPath.new(document: document, site: site,
                                 layout: layout, name: :path,
                                 type: :path, post: self,
                                 required: true)
  end

  def load_lang!
    self.lang = MetadataLang.new(document: document, site: site,
                                 layout: layout, name: :lang,
                                 type: :lang, post: self,
                                 required: true)
  end

  # Ejecuta la acción de guardado en cada atributo
  def save_attributes!
    attributes.map do |attr|
      send(attr).save
    end.all?
  end
end
# rubocop:enable Metrics/ClassLength
# rubocop:enable Style/MethodMissingSuper
# rubocop:enable Style/MissingRespondToMissing