361 lines
8.5 KiB
Ruby
361 lines
8.5 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
# Representa los distintos tipos de campos que pueden venir de una
|
|
# plantilla compleja
|
|
class Post
|
|
class TemplateField
|
|
attr_reader :post, :contents, :key
|
|
|
|
STRING_VALUES = %w[string text url number email password date year
|
|
image video audio document].freeze
|
|
|
|
# Tipo de valores que son archivos
|
|
FILE_TYPES = %w[image video audio document].freeze
|
|
|
|
def initialize(post, key, contents)
|
|
@post = post
|
|
@key = key
|
|
@contents = contents
|
|
end
|
|
|
|
def title
|
|
contents.dig('title') if complex?
|
|
end
|
|
|
|
def subtitle
|
|
contents.dig('subtitle') if complex?
|
|
end
|
|
|
|
# Obtiene el valor
|
|
def value
|
|
complex? ? contents.dig('value') : contents
|
|
end
|
|
|
|
def max
|
|
return 0 if simple?
|
|
|
|
contents.fetch('max', 0)
|
|
end
|
|
|
|
def min
|
|
return 0 if simple?
|
|
|
|
contents.fetch('min', 0)
|
|
end
|
|
|
|
# TODO: volver elegante!
|
|
def type
|
|
return @type if @type
|
|
|
|
if image?
|
|
@type = 'image'
|
|
elsif email?
|
|
@type = 'email'
|
|
elsif url?
|
|
@type = 'url'
|
|
elsif number?
|
|
@type = 'number'
|
|
elsif password?
|
|
@type = 'password'
|
|
elsif date?
|
|
@type = 'date'
|
|
elsif year?
|
|
@type = 'year'
|
|
elsif text_area?
|
|
@type = 'text_area'
|
|
elsif check_box_group?
|
|
@type = 'check_box_group'
|
|
elsif radio_group?
|
|
@type = 'radio_group'
|
|
elsif string?
|
|
@type = 'text'
|
|
# TODO: volver a hacer funcionar esto y ahorranos los multiple:
|
|
# false
|
|
elsif string? && contents.split('/', 2).count == 2
|
|
@type = 'select'
|
|
elsif nested?
|
|
@type = 'table'
|
|
elsif array?
|
|
@type = 'select'
|
|
elsif boolean?
|
|
@type = 'check_box'
|
|
end
|
|
|
|
@type
|
|
end
|
|
|
|
# Devuelve los valores vacíos según el tipo
|
|
def empty_value
|
|
if string?
|
|
''
|
|
elsif nested?
|
|
# TODO: devolver las keys también
|
|
{}
|
|
elsif array?
|
|
[]
|
|
elsif boolean?
|
|
false
|
|
end
|
|
end
|
|
|
|
def cols
|
|
complex? && contents.dig('cols')
|
|
end
|
|
|
|
def align
|
|
complex? && contents.dig('align')
|
|
end
|
|
|
|
# El campo es requerido si es complejo y se especifica que lo sea
|
|
def required?
|
|
complex? && contents.dig('required')
|
|
end
|
|
|
|
def boolean?
|
|
value.is_a?(FalseClass) || value.is_a?(TrueClass)
|
|
end
|
|
|
|
def string?
|
|
value.is_a? String
|
|
end
|
|
|
|
def text_area?
|
|
value == 'text'
|
|
end
|
|
|
|
def url?
|
|
value == 'url'
|
|
end
|
|
|
|
def email?
|
|
value == 'email' || value == 'mail'
|
|
end
|
|
alias mail? email?
|
|
|
|
def date?
|
|
value == 'date'
|
|
end
|
|
|
|
def password?
|
|
value == 'password'
|
|
end
|
|
|
|
def number?
|
|
value == 'number'
|
|
end
|
|
|
|
def year?
|
|
value == 'year'
|
|
end
|
|
|
|
def file?
|
|
string? && FILE_TYPES.include?(value)
|
|
end
|
|
|
|
def image?
|
|
array? ? value.first == 'image' : value == 'image'
|
|
end
|
|
|
|
# Si la plantilla es simple no está admitiendo Hashes como valores
|
|
def simple?
|
|
!complex?
|
|
end
|
|
|
|
def complex?
|
|
contents.is_a? Hash
|
|
end
|
|
|
|
# XXX Retrocompatibilidad
|
|
def to_s
|
|
key
|
|
end
|
|
|
|
# Convierte el campo en un parámetro
|
|
def to_param
|
|
if nested?
|
|
{ key.to_sym => {} }
|
|
elsif array? && multiple?
|
|
{ key.to_sym => [] }
|
|
else
|
|
key.to_sym
|
|
end
|
|
end
|
|
|
|
# Convierte la plantilla en el formato de front_matter
|
|
def to_front_matter
|
|
{ key => empty_value }
|
|
end
|
|
|
|
def check_box_group?
|
|
array? && (complex? && contents.fetch('checkbox', false))
|
|
end
|
|
|
|
def radio_group?
|
|
array? && (complex? && contents.fetch('radio', false))
|
|
end
|
|
|
|
def array?
|
|
value.is_a? Array
|
|
end
|
|
|
|
# TODO: detectar cuando es complejo y tomar el valor de :multiple
|
|
def multiple?
|
|
# si la plantilla es simple, es multiple cuando tenemos un array
|
|
return array? if simple?
|
|
|
|
array? && contents.fetch('multiple', true)
|
|
end
|
|
|
|
# Detecta si el valor es una tabla de campos
|
|
def nested?
|
|
value.is_a?(Hash) || (array? && value.first.is_a?(Hash))
|
|
end
|
|
|
|
# Un campo acepta valores abiertos si no es un array con múltiples
|
|
# elementos
|
|
def open?
|
|
# Todos los valores simples son abiertos
|
|
return true unless complex?
|
|
return false unless array?
|
|
|
|
# La cosa se complejiza cuando tenemos valores complejos
|
|
#
|
|
# Si tenemos una lista cerrada de valores, necesitamos saber si el
|
|
# campo es abierto o cerrado. Si la lista tiene varios elementos,
|
|
# es una lista cerrada, opcionalmente abierta. Si la lista tiene
|
|
# un elemento, quiere decir que estamos autocompletando desde otro
|
|
# lado.
|
|
contents.fetch('open', value.count < 2)
|
|
end
|
|
|
|
def closed?
|
|
!open?
|
|
end
|
|
|
|
# Determina si los valores del campo serán públicos después
|
|
#
|
|
# XXX Esto es solo una indicación, el theme Jekyll tiene que
|
|
# respetarlos por su lado luego
|
|
def public?
|
|
# Todos los campos son públicos a menos que se indique lo
|
|
# contrario
|
|
simple? || contents.fetch('public', true)
|
|
end
|
|
|
|
def private?
|
|
!public?
|
|
end
|
|
|
|
def human
|
|
h = key.humanize
|
|
|
|
h
|
|
end
|
|
|
|
def label
|
|
h = (complex? && contents.dig('label')) || human
|
|
h += ' *' if required?
|
|
|
|
h
|
|
end
|
|
|
|
def help
|
|
complex? && contents.dig('help')
|
|
end
|
|
|
|
def nested_fields
|
|
return unless nested?
|
|
|
|
v = value
|
|
v = value.first if array?
|
|
|
|
@nested_fields ||= v.map do |k, sv|
|
|
Post::TemplateField.new post, k, sv
|
|
end
|
|
end
|
|
|
|
# Obtiene los valores posibles para el campo de la plantilla
|
|
def values
|
|
return 'false' if value == false
|
|
return 'true' if value == true
|
|
# XXX por alguna razón `value` no refiere a value() :/
|
|
return '' if STRING_VALUES.include? value
|
|
# Las listas cerradas no necesitan mayor procesamiento
|
|
return value if array? && closed? && value.count > 1
|
|
# Y las vacías tampoco
|
|
return value if array? && value.empty?
|
|
# Ahorrarnos el trabajo
|
|
return @values if @values
|
|
|
|
# Duplicar el valor para no tener efectos secundarios luego (?)
|
|
value = self.value.dup
|
|
|
|
# Para obtener los valores posibles, hay que procesar la string y
|
|
# convertirla a parametros
|
|
|
|
# Si es una array de un solo elemento, es un indicador de que
|
|
# tenemos que rellenarla con los valores que indica.
|
|
#
|
|
# El primer valor es el que trae la string de autocompletado
|
|
values = array? ? value.shift : value
|
|
|
|
# Si el valor es un array con más de un elemento, queremos usar
|
|
# esas opciones. Pero si además es abierto, queremos traer los
|
|
# valores cargados anteriormente.
|
|
|
|
# Procesamos el valor, buscando : como separador de campos que
|
|
# queremos encontrar y luego los unimos
|
|
_value = (values&.split(':', 2) || []).map do |v|
|
|
# Tenemos hasta tres niveles de búsqueda
|
|
collection, attr, subattr = v.split('/', 3)
|
|
|
|
if collection == 'site'
|
|
# TODO: puede ser peligroso permitir acceder a cualquier
|
|
# atributo de site? No estamos trayendo nada fuera de
|
|
# lo normal
|
|
post.site.send(attr.to_sym)
|
|
# Si hay un subatributo, tenemos que averiguar todos los
|
|
# valores dentro de el
|
|
# TODO volver elegante!
|
|
# TODO volver recursivo!
|
|
elsif subattr
|
|
post.site.everything_of(attr, lang: collection)
|
|
.compact
|
|
.map { |sv| sv[subattr] }
|
|
.flatten
|
|
.compact
|
|
.uniq
|
|
else
|
|
post.site.everything_of(attr, lang: collection).compact
|
|
end
|
|
end
|
|
|
|
# Si el valor es abierto, sumar los valores auto-completados a
|
|
# lo pre-cargados.
|
|
#
|
|
# En este punto _value es un array de 1 o 2 arrays, si es de uno,
|
|
# value tambien tiene que serlo. Si es de 2, hay que unir cada
|
|
# una
|
|
if open?
|
|
if _value.count == 1
|
|
_value = [(_value.first + value).uniq]
|
|
elsif _value.count == 2
|
|
_value = _value.each_with_index.map do |v, i|
|
|
v + value.fetch(i, [])
|
|
end
|
|
end
|
|
end
|
|
|
|
# Crea un array de arrays, útil para los select
|
|
# [ [ 1, a ], [ 2, b ] ]
|
|
# aunque si no hay un : en el autocompletado, el array queda
|
|
# [ [ 1, 1 ], [ 2, 2 ] ]
|
|
values = _value.empty? ? [] : _value.last.zip(_value.first)
|
|
|
|
# En última instancia, traer el valor por defecto y ahorrarnos
|
|
# volver a procesar
|
|
@values = values
|
|
end
|
|
end
|
|
end
|