working on it ...

Filters

Explore Public Snippets

Sort by

Found 35k snippets

    public by tcyrus modified Jan 7, 2016  27  0  1  0

    Homebrew formula for jart/hiptext (https://github.com/jart/hiptext)

    Homebrew formula for jart/hiptext (https://github.com/jart/hiptext): hiptext.rb
    require "formula"
    
    class Hiptext < Formula
      homepage "https://github.com/jart/hiptext"
      head "https://github.com/jart/hiptext.git", :branch => "master"
    
      depends_on "pkg-config" => :build
      depends_on "ragel" => :build
      depends_on :libpng
      depends_on "jpeg"
      depends_on "ffmpeg"
      depends_on "freetype"
      depends_on "glog"
    
      patch :DATA
    
      #ENV["PKG_CONFIG_PATH"] = "#{HOMEBREW_PREFIX}/lib/pkgconfig:#{MacOS::X11.lib}/pkgconfig"
    
      #pkg-config --libs libavcodec libavformat libavutil libswscale
      def install
        system "make"
        system "install -m 0755 hiptext #{HOMEBREW_PREFIX}/bin"
      end
    end
    
    __END__
    diff --git a/font.cc b/font.cc
    index e3b3218..b9cf579 100644
    --- a/font.cc
    +++ b/font.cc
    @@ -11,7 +11,7 @@
     #include "graphic.h"
     #include "pixel.h"
    
    -DEFINE_string(font, "DejaVuSansMono.ttf",
    +DEFINE_string(font, "/System/Library/Fonts/Monaco.dfont",
                   "The path to the font .ttf file to use.");
     DEFINE_int32(font_index, 0, "Index of face to use inside font .ttf file.");
     DEFINE_int32(font_size, 11, "The size of the font in points.");
    diff --git a/hiptext.cc b/hiptext.cc
    index a23fa02..da0c96f 100644
    --- a/hiptext.cc
    +++ b/hiptext.cc
    @@ -202,9 +202,9 @@ int main(int argc, char** argv) {
       google::ParseCommandLineFlags(&argc, &argv, true);
       google::InitGoogleLogging(argv[0]);
       google::InstallFailureSignalHandler();
    -  const char* lang = std::getenv("LANG");
    -  if (lang == nullptr) lang = "en_US.utf8";
    -  std::locale::global(std::locale(lang));
    +  //const char* lang = std::getenv("LANG");
    +  //if (lang == nullptr) lang = "en_US.utf8";
    +  //std::locale::global(std::locale(lang));
       InitFont();
       Movie::InitializeMain();
    
    

    public by Rafael G modified Dec 12, 2015  823  1  3  1

    WIP: script to auto-correct almost any program (the outputs should not contain "\n\n" though)

    WIP: script to auto-correct almost any program (the outputs should not contain "\n\n" though): examinator.rb
    ## Converting line endings to unix:
    inputs_file = File.open('./inputs.txt', 'a+')
    outputs_file = File.open('./outputs.txt', 'a+')
    
    input_file_contents = inputs_file.read.gsub(/\r\n?/,"\n")
    inputs_file.truncate(0)
    inputs_file.print input_file_contents
    
    outputs_file_contents = outputs_file.read.gsub(/\r\n?/,"\n")
    outputs_file.truncate(0)
    outputs_file.print outputs_file_contents
    
    inputs_file.close
    outputs_file.close
    
    #  Getting each input and each output into an array the idea is, basically, 
    # separate them each time we find an empty line ("\n").
    #  Should be noted though, that since the expected output should contain an
    # "\n" at its ending, so should each element on our array.
    
    inputs_file = File.open('./inputs.txt', 'r')
    outputs_file = File.open('./outputs.txt', 'r')
    
    inputs = []
    outputs = []
    
    loop do
      inputs_contents = inputs_file.gets('')
      outputs_contents = outputs_file.gets('')
      if inputs_contents.nil? || outputs_contents.nil?
        break
      else
        inputs_contents.gsub!("\n\n", "\n")
        outputs_contents.gsub!("\n\n", "\n")
        inputs << inputs_contents
        outputs << outputs_contents
      end
    end
    
    # To continue. Next step: get user's output.
    # Little snippet on how to get terminal's output below:
    
    test = __FILE__
    puts `ls #{test}`.class # It's a string.
    
    
    

    public by Drowze modified Dec 2, 2015  1125  0  3  0

    mim ajuda

    mim ajuda: mim_ajuda.rb
    require 'matrix'
    class Matrix
      def []=(i, j, x)
        @rows[i][j] = x
      end
    end
    
    class String # Only works for single letters; could be extended to uppercase letters too
      def step(c, delta=1)
        if c.ord + delta > 122 then
          return [c.ord + delta - 26].pack 'U'
        elsif c.ord + delta < 97 then
          return [c.ord + delta + 26].pack 'U'
        else
          return [c.ord + delta].pack 'U'
        end
      end
    
      def increment(c)
        return nil if self.size > 1
        c %= 26
        step self, c
      end
    
      def decrement(c)
        return nil if self.size > 1
        c %= 26
        step self, -c
      end
    end
    
    class Board
      attr_reader :cell_pairs
      MOVES = {
        'nw' => [-1, 0],
        'ne' => [-1, +1],
        'sw' => [+1, -1],
        'se' => [+1, 0]
      }
      CELL_CODES = Matrix[
        [0,0,0,0,0,1,3,3,3,2],
         [0,0,0,0,5,7,7,7,7,2],
          [0,0,0,5,7,7,7,7,7,2],
           [0,0,5,7,7,7,7,7,7,2],
            [0,5,7,7,7,7,7,7,7,2],
             [4,7,7,7,7,7,7,7,7,0],
              [4,7,7,7,7,7,7,7,0,0],
               [4,7,7,7,7,7,7,0,0,0],
                [4,7,7,7,7,7,0,0,0,0],
                 [4,7,7,7,7,0,0,0,0,0],
                  [0,0,0,0,0,0,0,0,0,0]
      ]
    
      CELL_PAIRS = module Cell_pairs # "Function" to prepare the cell_pairs
        cell_pairs = Hash.new
        start_letter = 'a'
        increment = 0
        checker = 0
        CELL_CODES.each_with_index do |element, row, col|
          if row <= 5
            if checker != row then # I get here everytime it goes to another row
              increment = -row + 5
              checker = row
            end
            if(element == 7) then
              cell_pairs["#{row} #{col}"] = "#{row.to_s}#{start_letter.increment(increment)}"
              increment += 2
            end
          else
            if checker != row then # I get here everytime it goes to another row
              increment = row - 5
              checker = row
            end
            if(element == 7) then
              cell_pairs["#{row} #{col}"] = "#{row.to_s}#{start_letter.increment(increment)}"
              increment += 2
            end
          end
        end
        cell_pairs
      end
    
    
    
      def self.prepare_board positions
        seq = [' ',1,2,3,4,5,6,7,8,9,' ']
        counter = 0
        indentation = 0
        ret = ''
    
        CELL_CODES.to_a.map.with_index do |m, i|
          if i != 10 then
            ret += seq[counter].to_s + ' ' * indentation 
            m.each_with_index do |n, j| 
              n == 7 ? ret += ("#{positions[i,j]} ") : ret += ('  ')  # piece occupying the cell
              [4,5,6,7].include?(n) ? ret += ('| ') : ret += ('  ') 
            end
            ret += "\n" + ' ' * indentation unless i == CELL_CODES.to_a.map.size-1
            m.each_with_index do |n|
              [2,3,6,7].include?(n) ? ret += ('\\ ') : ret += ('  ') 
              [1,3,5,7].include?(n) ? ret += ('/ ') : ret += ('  ') 
            end
            ret += "\n" 
            counter+=1 
            indentation+=2
          end
        end
        ret += ' ' * 15 + 'a b c d e f g h i j k l m n o' + "\n"
        ret
      end
    end
    
    print Board::CELL_PAIRS
    
    

    public by DavidEGrayson modified Oct 1, 2015  697  0  2  0

    Original: https://gist.github.com/pdg137/2cb48696ed7ba25370b6

    Original: https://gist.github.com/pdg137/2cb48696ed7ba25370b6: ruby_quiz1.rb
    a = 10
    
    def b(x = 1)
      10
    end
    
    puts a /2/
    5
    
    puts b /2/
    5
    
    puts a / 2/
    5
    
    puts b / 2/
    5
    
    
    
    

    public by addicttux modified Aug 27, 2015  1004  0  4  0

    PDF Template

    Template para la generación de reportes simples en PDF
    # Genera el reporte en PDF
    class NombreDeLaTablaEnSingularPdf < Prawn::Document
    
      include PdfHelper
    
      # Valores de inicialización del método.
      # @param nombre_de_la_tabla_en_singulars [Array] Contiene todos los registros a mostrar en el reporte
      # @param helpers [Obj] Utilizado para tener acceso a los helpers definidos en +app/helpers+
      # @note El encabezado y el título del reporte lo genera a través del código en +PdfHelper+ ubicado en +lib/pdf_helper.rb+
      def initialize( nombre_de_la_tabla_en_singulars, helpers )
        
        titulo =  'Listado de '
        encabezados    = %w( encabezado1 encabezado2 )
        ancho_columnas = [150,70]
        campos = Proc.new{|x| [x.campo_ordenado.titleize, x.campo_segundo.titleize] }
    
        super size: :letter,
              margin: 56,
              layout: :portrait
    
        pdf_encabezado_hoja_membretada
    
        pdf_titulo_del_reporte titulo
    
        #reporte
        elementos = [ encabezados ]
        elementos += nombre_de_la_tabla_en_singulars.map{|i| campos[i] }
        table elementos,
              column_widths: ancho_columnas,
              position: :center,
              cell_style: { size: 8 } do
          row(0).font_style = :bold
          row(0).align = :center
          row(0).size = 15
          self.row_colors = %w( EEEEEE FFE3BF )
          self.header = true
        end
    
      end
    
    end                                                                        

    public by addicttux modified Aug 27, 2015  1060  2  5  0

    TEST: xxx_test.rb

    Unit Testing
    require 'test_helper'
    
    class NombreDeTablaEnSingularTest < ActiveSupport::TestCase
    
      setup do
        @root = users :admin
        @usr  = users :user
        @caracteres_minimo = 
        @caracteres_maximo = 
        @palabra = ''
        @datos_1char          = { forma_de_pago: 'a',                      solo_root_ns: false, usuario_actual: @usr }
        @datos_blanco         = { forma_de_pago: '',                       solo_root_ns: false, usuario_actual: @usr }
        @datos_blanco_ambos   = { forma_de_pago: " #{@palabra} ",          solo_root_ns: false, usuario_actual: @usr }
        @datos_blanco_final   = { forma_de_pago: "#{@palabra} ",           solo_root_ns: false, usuario_actual: @usr }
        @datos_blanco_inicial = { forma_de_pago: " #{@palabra}",           solo_root_ns: false, usuario_actual: @usr }
        @datos_excedido       = { forma_de_pago: 'a'*@caracteres_maximo*2, solo_root_ns: false, usuario_actual: @usr }
        @datos_maximo         = { forma_de_pago: 'a'*@caracteres_maximo,   solo_root_ns: false, usuario_actual: @usr }
        @datos_minimo         = { forma_de_pago: 'a'*@caracteres_minimo,   solo_root_ns: false, usuario_actual: @usr }
        @datos_minusculas     = { forma_de_pago: @palabra.upcase,          solo_root_ns: false, usuario_actual: @usr }
        @datos_nulo           = { forma_de_pago: nil,                      solo_root_ns: false, usuario_actual: @usr }
        @datos_root           = { forma_de_pago: 'segundo',                solo_root_ns: true,  usuario_actual: @root }
        @datos_user           = { forma_de_pago: 'valor',                  solo_root_ns: false }
        @duplicado            = { forma_de_pago: '',                       solo_root_ns: false, usuario_actual: @usr }
      end
    
      # +-------------------------+
      # | Pruebas para New/Create |
      # +-------------------------+
    
      test 'Prueba #XXX-U-001: Probando la creación de ______ [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_user
        assert tut.valid?, tut.errors.messages.to_yaml
      end
    
      test 'Prueba #XXX-U-002: Probando que no guarde ______ en blanco [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_blanco
        refute tut.valid?, 'Se guardó en blanco'
      end
    
      test 'Prueba #XXX-U-003: Probando que no guarde ______ nil [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_nulo
        refute tut.valid?, 'Se guardó siendo nil'
      end
    
      test 'Prueba #XXX-U-004: Probando que no guarde ______ menores al mínimo de caracteres [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_1char
        refute tut.valid?, 'Se guardó siendo menor al mínimo de caracteres'
      end
    
      test 'Prueba #XXX-U-005: Probando que guarde ______ igual al mínimo de caracteres [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_minimo
        assert tut.valid?, 'No se guardo palabra igual al mínimo de caracteres'
      end
    
      test 'Prueba #XXX-U-006: Probando que guarde ______ igual al máximo de caracteres [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_maximo
        assert tut.valid?, 'No se guardo palabra igual al maximo de caracteres'
      end
    
      test 'Prueba #XXX-U-007: Prueba que no se guarde ______ mayor del máximo de caracteres permitidos [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_excedido
        refute tut.valid?, 'Se guardo palabra de mas caracteres que los permitidos'
      end
    
      test 'Prueba #XXX-U-008: Prueba que elimine el espacio inicial [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_blanco_inicial
        assert_equal tut.forma_de_pago, @palabra, 'No eliminó el espacio inicial'
      end
    
      test 'Prueba #XXX-U-009: Prueba que elimine espacios finales [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_blanco_final
        assert_equal tut.forma_de_pago, @palabra, 'No eliminó los espacios finales'
      end
    
      test 'Prueba #XXX-U-010: Prueba que elimine espacios iniciales y finales [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_blanco_ambos
        assert_equal tut.forma_de_pago, @palabra, 'No eliminó los espacios alrededor del texto'
      end
    
      test 'Prueba #XXX-U-011: Prueba que se guarde en minúsculas [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_minusculas
        assert_equal tut.forma_de_pago, @palabra, 'No guardó el texto en minúsculas'
      end
    
      test 'Prueba #XXX-U-012: Prueba que detecte contenido duplicado [hmjr]' do
        original = NombreDeTablaEnSingular.first.forma_de_pago
        @duplicado[:forma_de_pago] = original
        tut = NombreDeTablaEnSingular.create @duplicado
        refute tut.valid?, 'No detectó duplicidad'
      end
    
    
      # +----------------------+
      # | Pruebas para Destroy |
      # +----------------------+
    
      test 'Prueba #XXX-U-013: No debe de poder eliminar sin ser usuario registrado [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_user
        antes = NombreDeTablaEnSingular.count
        tut.destroy
        assert_equal antes, NombreDeTablaEnSingular.count, 'Borró pese a no estar registrado'
      end
    
      test 'Prueba #XXX-U-014: Elimina ______, el usuario no es root, solo_root_ns = false, no tiene dependientes [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_user
        tut.usuario_actual = @usr
        antes = NombreDeTablaEnSingular.count
        tut.destroy
        refute_equal antes, NombreDeTablaEnSingular.count, 'No se borró y no tiene teléfonos dependientes'
      end
    
      test 'Prueba #XXX-U-015: Elimina ______, el usuario no es root, solo_root_ns = false, TIENE dependientes [hmjr]' do
    #    tid = NombreDeTablaEnSingular.first
    #    dir = Directorio.create razon_fiscal: 'borrame s.a. de c.v.', razon_comercial: 'borrame', sobrenombre: 'borrame'
    #    TablaRelacionada.create tipo_forma_pago: tid, directorio: dir, solo_root_ns: false
    #    antes = NombreDeTablaEnSingular.count
    #    tid.usuario_actual = @usr
    #    tid.destroy
    #    assert_equal antes, NombreDeTablaEnSingular.count, 'Se eliminó pese a que tiene dependientes'
      end
    
    
      test 'Prueba #XXX-U-016: Elimina ______, el usuario no es root, solo_root_ns = true [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_root
        tut.usuario_actual = @usr
        antes = NombreDeTablaEnSingular.count
        tut.destroy
        assert_equal antes, NombreDeTablaEnSingular.count, 'Pudo borrar registro cuando solo root debería'
      end
    
      test 'Prueba #XXX-U-017: Elimina ______, el usuario es ROOT, solo_root_ns = false [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_user
        tut.usuario_actual = @root
        antes = NombreDeTablaEnSingular.count
        tut.destroy
        refute_equal antes, NombreDeTablaEnSingular.count, 'Root no pudo borrar un registro no exclusivo'
      end
    
      test 'Prueba #XXX-U-018: Elimina ______, el usuario es ROOT, solo_root_ns = true [hmjr]' do
        tut = NombreDeTablaEnSingular.create @datos_root
        antes = NombreDeTablaEnSingular.count
        tut.destroy
        refute_equal antes, NombreDeTablaEnSingular.count, 'Root no pudo borrar un registro exclusivo'
      end
    
      # +---------------------------------------+
      # | Pruebas para Edit para usuario normal |
      # +---------------------------------------+
    
      test 'Prueba #XXX-U-019: Probando la edición de ______ con usuario no logeado [hmjr]' do
        tut = NombreDeTablaEnSingular.last
        tut.update @datos_user
        refute tut.save, tut.errors.messages.to_yaml
      end
    
      test 'Prueba #XXX-U-020: Probando la edición de ______ con usuario logeado [hmjr]' do
        @datos_user[:usuario_actual] = @usr
        tut = NombreDeTablaEnSingular.first
        tut.update @datos_user
        assert tut.save, tut.errors.messages.to_yaml
      end
    
      test 'Prueba #XXX-U-021: Probando que no edite ______ en blanco [hmjr]' do
        tut = NombreDeTablaEnSingular.first
        tut.update @datos_blanco
        refute tut.valid?, 'Se guardó en blanco'
      end
    
      test 'Prueba #XXX-U-022: Probando que no edite ______ nil [hmjr]' do
        tut = NombreDeTablaEnSingular.first
        tut.update @datos_nulo
        refute tut.valid?, 'Se guardó siendo nil'
      end
    
      test 'Prueba #XXX-U-023: Probando que no edite ______ menores al mínimo de caracteres [hmjr]' do
        tut = NombreDeTablaEnSingular.first
        tut.update @datos_1char
        refute tut.valid?, 'Se guardó siendo menor al mínimo de caracteres'
      end
    
      test 'Prueba #XXX-U-024: Probando que guarde ______ siendo igual al mínimo de caracteres [hmjr]' do
        tut = NombreDeTablaEnSingular.first
        tut.update @datos_minimo
        assert tut.valid?, 'No se guardo palabra igual al mínimo de caracteres'
      end
    
      test 'Prueba #XXX-U-025: Probando que guarde ______ igual al máximo de caracteres [hmjr]' do
        tut = NombreDeTablaEnSingular.first
        tut.update @datos_maximo
        assert tut.valid?, 'No se guardo palabra igual al máximo de caracteres'
      end
    
      test 'Prueba #XXX-U-026: Prueba que no se guarde ______ mayor al máximo de caracteres [hmjr]' do
        tut = NombreDeTablaEnSingular.first
        tut.update @datos_excedido
        refute tut.valid?, 'Se guardo palabra mayor al máximo de caracteres'
      end
    
      test 'Prueba #XXX-U-027: Prueba que elimine el espacio inicial [hmjr]' do
        tut = NombreDeTablaEnSingular.first
        tut.update @datos_blanco_inicial
        assert_equal tut.forma_de_pago, @palabra, 'No eliminó el espacio inicial'
      end
    
      test 'Prueba #XXX-U-028: Prueba que elimine espacios finales [hmjr]' do
        tut = NombreDeTablaEnSingular.first
        tut.update @datos_blanco_final
        assert_equal tut.forma_de_pago, @palabra, 'No eliminó los espacios finales'
      end
    
      test 'Prueba #XXX-U-029: Prueba que elimine espacios iniciales y finales [hmjr]' do
        tut = NombreDeTablaEnSingular.first
        tut.update @datos_blanco_ambos
        assert_equal tut.forma_de_pago, @palabra, 'No eliminó los espacios alrededor del texto'
      end
    
      test 'Prueba #XXX-U-030: Prueba que se guarde en minúsculas [hmjr]' do
        tut = NombreDeTablaEnSingular.first
        tut.update @datos_minusculas
        assert_equal tut.forma_de_pago, @palabra, 'No guardó el texto en minúsculas'
      end
    
      test 'Prueba #XXX-U-031: Prueba que detecte contenido duplicado [hmjr]' do
        tut = NombreDeTablaEnSingular.first
        tut.update forma_de_pago: NombreDeTablaEnSingular.last.forma_de_pago, usuario_actual: @usr
        refute tut.valid?, 'No detectó duplicidad'
      end
    
      test 'Prueba #XXX-U-032: Prueba que NO pueda editar si solo_root_ns es true [hmjr]' do
        tut = NombreDeTablaEnSingular.create forma_de_pago: @palabra, solo_root_ns: true, usuario_actual: @usr
        cam = NombreDeTablaEnSingular.find tut.id
        cam.forma_de_pago = 'cambiado'
        cam.usuario_actual = @usr
        refute cam.save, 'No detectó que solo root lo puede modificar'
      end
    
      # +-------------------------------------+
      # | Pruebas para Edit para usuario root |
      # +-------------------------------------+
    
      test 'Prueba #XXX-U-033: Probando la edición de ______ con usuario logeado [hmjr]' do
        @usr = @root
        tut = NombreDeTablaEnSingular.last
        tut.update @datos_root
        assert tut.save, tut.errors.messages.to_yaml
      end
    
      test 'Prueba #XXX-U-034: Probando que no edite ______ en blanco [hmjr]' do
        tut = NombreDeTablaEnSingular.last
        tut.update @datos_blanco
        refute tut.valid?, 'Se guardó en blanco'
      end
    
      test 'Prueba #XXX-U-035: Probando que no edite ______ nil [hmjr]' do
        tut = NombreDeTablaEnSingular.last
        tut.update @datos_nulo
        refute tut.valid?, 'Se guardó siendo nil'
      end
    
      test 'Prueba #XXX-U-036: Probando que no edite ______ menores al mínimo de caracteres [hmjr]' do
        tut = NombreDeTablaEnSingular.last
        tut.update @datos_1char
        refute tut.valid?, 'Se guardó siendo menor al mínimo de caracteres'
      end
    
      test 'Prueba #XXX-U-037: Probando que guarde ______ igual al mínimo de caracteres [hmjr]' do
        tut = NombreDeTablaEnSingular.last
        tut.update @datos_minimo
        assert tut.valid?, 'No se guardo palabra igual al mínimo de caracteres'
      end
    
      test 'Prueba #XXX-U-038: Probando que guarde ______ igual al máximo de caracteres [hmjr]' do
        tut = NombreDeTablaEnSingular.last
        tut.update @datos_maximo
        assert tut.valid?, 'No se guardo palabra igual al máximo de caracteres'
      end
    
      test 'Prueba #XXX-U-039: Prueba que no se guarde ______ mayor al máximo de caracteres [hmjr]' do
        tut = NombreDeTablaEnSingular.last
        tut.update @datos_excedido
        refute tut.valid?, 'Se guardo palabra mayor al máximo de caracteres'
      end
    
      test 'Prueba #XXX-U-040: Prueba que elimine el espacio inicial [hmjr]' do
        tut = NombreDeTablaEnSingular.last
        tut.update @datos_blanco_inicial
        assert_equal tut.forma_de_pago, @palabra, 'No eliminó el espacio inicial'
      end
    
      test 'Prueba #XXX-U-041: Prueba que elimine espacios finales [hmjr]' do
        tut = NombreDeTablaEnSingular.last
        tut.update @datos_blanco_final
        assert_equal tut.forma_de_pago, @palabra, 'No eliminó los espacios finales'
      end
    
      test 'Prueba #XXX-U-042: Prueba que elimine espacios iniciales y finales [hmjr]' do
        tut = NombreDeTablaEnSingular.last
        tut.update @datos_blanco_ambos
        assert_equal tut.forma_de_pago, @palabra, 'No eliminó los espacios alrededor del texto'
      end
    
      test 'Prueba #XXX-U-043: Prueba que se guarde en minúsculas [hmjr]' do
        tut = NombreDeTablaEnSingular.last
        tut.update @datos_minusculas
        assert_equal tut.forma_de_pago, @palabra, 'No guardó el texto en minúsculas'
      end
    
      test 'Prueba #XXX-U-044: Prueba que detecte contenido duplicado [hmjr]' do
        tut = NombreDeTablaEnSingular.last
        tut.update forma_de_pago: NombreDeTablaEnSingular.first.forma_de_pago, usuario_actual: @root
        refute tut.valid?, 'No detectó duplicidad'
      end
    
      test 'Prueba #XXX-U-045: Prueba que pueda editar si solo_root_ns es true [hmjr]' do
        tut = NombreDeTablaEnSingular.create forma_de_pago: @palabra, solo_root_ns: true, usuario_actual: @root
        cam = NombreDeTablaEnSingular.find tut.id
        cam.forma_de_pago = 'cambiado'
        cam.usuario_actual = @root
        assert cam.save, 'No detectó que solo root lo puede modificar'
      end
    
    end
    
    #------------------------------------------------------------------------------
    # NombreDeTablaEnSingular
    #
    # Name          SQL Type             Null    Default Primary
    # ------------- -------------------- ------- ------- -------
    # id            int(11)              false           true
    # forma_de_pago varchar(10)          false           false
    # solo_root_ns  tinyint(1)           false   0       false
    # lock_version  int(11)              false   0       false
    # created_at    datetime             false           false
    # updated_at    datetime             false           false
    #
    #------------------------------------------------------------------------------
    

    public by addicttux modified Aug 27, 2015  964  1  4  0

    TEST: xxxs_test.rb

    integration testing
    require 'test_helper'
    
    class NombreTablaEnSingularsTest < ActionDispatch::IntegrationTest
    
      setup do
        @root = users :admin
        @user = users :user
        @txt = 'nombre_tabla_en_singular'
        @palabra = 'valor'
        @cambiar = 'modificado'
        @duplicado = NombreTablaEnSingular.find(3).campo_ordenado
        @datos_user = { campo_ordenado: 'texto', solo_root_ns: false, usuario_actual: @user }
        @datos_root = { campo_ordenado: 'texto', solo_root_ns: false, usuario_actual: @root }
        @datos_user_root = { campo_ordenado: 'texto', solo_root_ns: true, usuario_actual: @user }
      end
    
      test 'Prueba #XXX-I-001: usuario se logea, y luego' do
        # nos logeamos como usuario
        post_via_redirect '/users/login', 'user[username]' => 'user', 'user[password]' => 'password'
    
        # vamos a la pagina principal
        get '/'
        assert_response :success, 'no se logeo'
    
        ### index
        # vamos al index de nombre_tabla_en_singular
        get nombre_tabla_en_singulars_path
        assert_response :success
    
        ### print
        # generamos el listado de nombre_tabla_en_singulars
        get nombre_tabla_en_singulars_listado_path
        assert_response :not_acceptable
    
        ### new
        # creamos un nuevo nombre_tabla_en_singular
        xhr :get, "/#{@txt}s/new"
        assert_response :success
        # capturamos los nuevos datos
        xhr :post, "/#{@txt}s", {"#{@txt}[campo_ordenado]" => @palabra, "#{@txt}[solo_root_ns]" => false }
        assert_response :success
        tut = NombreTablaEnSingular.last
        assert_equal tut.campo_ordenado, @palabra
        assert_select 'form', 0
        assert_equal css_select( '.ui.pointing.below.label.red' ).size, 0
        # capturamos los mismos datos con la finalidad de evalur que aparezca el mensaje de error por duplicidad
        xhr :post, "/#{@txt}s", {"#{@txt}[campo_ordenado]" => @duplicado, "#{@txt}[solo_root_ns]" => false }
        assert_select 'form', 1
        assert_response :success
        # capturamos con datos en blanco
        xhr :post, "/#{@txt}s", {"#{@txt}[campo_ordenado]" => '', "#{@txt}[solo_root_ns]" => false }
        assert_select 'form', 1
        assert_response :success
        # capturamos datos de 1 caracteres
        xhr :post, "/#{@txt}s", {"#{@txt}[campo_ordenado]" => 'a', "#{@txt}[solo_root_ns]" => false }
        assert_select 'form', 1
        assert_response :success
    
        ### edit
        # obtenemos el registro en pantalla de captura
        tut = NombreTablaEnSingular.first
        xhr :get, "/#{@txt}s/#{tut.id}/edit"
        assert_response :success
        # editamos sin cambiar valores
        xhr :patch, "/#{@txt}s/#{tut.id}", {"#{@txt}[campo_ordenado]" => tut.campo_ordenado, "#{@txt}[solo_root_ns]" => false }
        assert_response :success
        assert_select 'form', 0
        # editamos cambiando valores
        antes = tut.campo_ordenado
        xhr :patch, "/#{@txt}s/#{tut.id}", {"#{@txt}[campo_ordenado]" => @cambiar, "#{@txt}[solo_root_ns]" => false }
        assert_response :success
        assert_select 'form', 0
        tut = NombreTablaEnSingular.find tut.id
        assert_not_equal antes, tut.campo_ordenado
        # editamos duplicando valores
        NombreTablaEnSingular.create @datos_user
        xhr :patch, "/#{@txt}s/#{tut.id}", {"#{@txt}[campo_ordenado]" => @duplicado }
        assert_response :success
        assert_select 'form', 1
        tut = NombreTablaEnSingular.find tut.id
        assert_not_equal @duplicado, tut.campo_ordenado
        # editamos dejando en blanco los valres
        xhr :patch, "/#{@txt}s/#{tut.id}", {"#{@txt}[campo_ordenado]" => '' }
        assert_response :success
        assert_select 'form', 1
        # editamos con valores de 1 caracteres
        xhr :patch, "/#{@txt}s/#{tut.id}", {"#{@txt}[campo_ordenado]" => 'u' }
        assert_response :success
        assert_select 'form', 1
        # no puede editar si solo_root_ns = true
        xhr :patch, "/#{@txt}s/#{tut.id}", {"#{@txt}[campo_ordenado]" => 'no debe', "#{@txt}[solo_root_ns]" => true }
        assert_response :success
        assert_not_equal 'no debe', NombreTablaEnSingular.find( tut.id ).campo_ordenado
    
        ### delete
        # verificamos que aparezca el diálogo de confirmar para borrar
        tut = NombreTablaEnSingular.last
        xhr :get, "/#{@txt}s/#{tut.id}/confirmar_borrar"
        assert_response :success
        # eliminamos con solo_root_ns=false
        assert_difference 'NombreTablaEnSingular.count', -1 do
          xhr :delete, "/#{@txt}s/#{tut.id}"
        end
        # no debe eliminar con solo_root_ns=true
        tut = NombreTablaEnSingular.create @datos_user_root
        assert_no_difference 'NombreTablaEnSingular.count', -1 do
          xhr :delete, "/#{@txt}s/#{tut.id}"
        end
      end
    
      test 'Prueba #XXX-I-002: root se logea, y luego' do
        # nos logeamos como usuario
        post_via_redirect '/users/login', 'user[username]' => 'root', 'user[password]' => '5170yPOR0771c3Ya'
    
        # vamos a la pagina principal
        get '/'
        assert_response :success
    
        ### index
        # vamos al index de nombre_tabla_en_singular
        get nombre_tabla_en_singulars_path
        assert_response :success
    
        ### print
        # generamos el listado de nombre_tabla_en_singulars
        get nombre_tabla_en_singulars_listado_path
        assert_response :not_acceptable
    
        ### new
        # creamos un nuevo nombre_tabla_en_singular
        xhr :get, "/#{@txt}s/new"
        assert_response :success
        # capturamos los nuevos datos
        xhr :post, "/#{@txt}s", {"#{@txt}[campo_ordenado]" => @palabra, "#{@txt}[solo_root_ns]" => false }
        assert_response :success
        tut = NombreTablaEnSingular.last
        assert_equal tut.campo_ordenado, @palabra
        assert_select 'form', 0
        assert_equal css_select( '.ui.pointing.below.label.red' ).size, 0
        # capturamos los mismos datos con la finalidad de evalur que aparezca el mensaje de error por duplicidad
        xhr :post, "/#{@txt}s", {"#{@txt}[campo_ordenado]" => @duplicado, "#{@txt}[solo_root_ns]" => true }
        assert_select 'form', 1
        assert_response :success
        # capturamos con datos en blanco
        xhr :post, "/#{@txt}s", {"#{@txt}[campo_ordenado]" => '', "#{@txt}[solo_root_ns]" => true }
        assert_select 'form', 1
        assert_response :success
        # capturamos datos de 1 caracteres
        xhr :post, "/#{@txt}s", {"#{@txt}[campo_ordenado]" => 'a', "#{@txt}[solo_root_ns]" => true }
        assert_select 'form', 1
        assert_response :success
    
        ### edit
        # obtenemos el registro en pantalla de captura
        tut = NombreTablaEnSingular.first
        xhr :get, "/#{@txt}s/#{tut.id}/edit"
        assert_response :success
        # editamos sin cambiar valores
        xhr :patch, "/#{@txt}s/#{tut.id}", {"#{@txt}[campo_ordenado]" => tut.campo_ordenado, "#{@txt}[solo_root_ns]" => tut.solo_root_ns }
        assert_response :success
        assert_select 'form', 0
        # editamos cambiando valores
        antes = tut.campo_ordenado
        xhr :patch, "/#{@txt}s/#{tut.id}", {"#{@txt}[campo_ordenado]" => @cambiar, "#{@txt}[solo_root_ns]" => tut.solo_root_ns }
        assert_response :success
        assert_select 'form', 0
        tut = NombreTablaEnSingular.find tut.id
        assert_not_equal antes, tut.campo_ordenado
        # editamos duplicando valores
        NombreTablaEnSingular.create @datos_root
        xhr :patch, "/#{@txt}s/#{tut.id}", {"#{@txt}[campo_ordenado]" => @duplicado }
        assert_response :success
        assert_select 'form', 1
        tut = NombreTablaEnSingular.find tut.id
        assert_not_equal @duplicado, tut.campo_ordenado
        # editamos dejando en blanco los valres
        xhr :patch, "/#{@txt}s/#{tut.id}", {"#{@txt}[campo_ordenado]" => '' }
        assert_response :success
        assert_select 'form', 1
        # editamos con valores de 2 caracteres
        xhr :patch, "/#{@txt}s/#{tut.id}", {"#{@txt}[campo_ordenado]" => 'u' }
        assert_response :success
        assert_select 'form', 1
        # no puede editar si solo_root_ns = true
        xhr :patch, "/#{@txt}s/#{tut.id}", {"#{@txt}[campo_ordenado]" => @cambiar, "#{@txt}[solo_root_ns]" => true }
        assert_response :success
        assert_equal @cambiar, NombreTablaEnSingular.find( tut.id ).campo_ordenado
    
        ### delete
        # verificamos que aparezca el diálogo de confirmar para borrar
        tut = NombreTablaEnSingular.last
        xhr :get, "/#{@txt}s/#{tut.id}/confirmar_borrar"
        assert_response :success
        # eliminamos con solo_root_ns=false
        assert_difference 'NombreTablaEnSingular.count', -1 do
          xhr :delete, "/#{@txt}s/#{tut.id}"
        end
        # no debe eliminar con solo_root_ns=true
        tut = NombreTablaEnSingular.create @datos_root
        assert_difference 'NombreTablaEnSingular.count', -1 do
          xhr :delete, "/#{@txt}s/#{tut.id}"
        end
      end
    
    end
                

    public by addicttux modified Aug 15, 2015  961  1  4  0

    TEST: xxx_controller_test.rb

    functional testing
    require 'test_helper'
    
    class NombreDeLaTablaEnSingularsControllerTest < ActionController::TestCase
    
      setup do
        @nombre_de_la_tabla_en_singular = nombre_de_la_tabla_en_singulars :valor_tomadp_de_fixtures
        @root = users :admin
        @user = users :user
        @datos_user = {
          solo_root_ns: false,
          campo_ordenado: 'tdc' }
        @datos_root = {
          campo_ordenado: 'tdd',
          solo_root_ns: true  }
      end
    
      test 'Prueba #XXX-F-001: No debe de obtener index si no está logeado [hmjr]' do
        get :index
        assert_response :redirect, 'Es redirigido a la pantalla de login'
        assert_redirected_to 'http://test.host/users/login'
        assert_response :redirect
      end
    
      test 'Prueba #XXX-F-002: una vez logeado como user va al index [hmjr]' do
        sign_in @user
        get :index
        assert_response :success, 'El usuario no llegó a index'
        assert_not_nil assigns( :nombre_de_la_tabla_en_singulars ), 'El usuario no obtuvo el listado de NombreDeLaTablaEnSingulars'
      end
    
      test 'Prueba #XXX-F-003: una vez logeado como root va al index [hmjr]' do
        sign_in @root
        get :index
        assert_response :success, 'Root no llegó a index'
        assert_not_nil assigns( :nombre_de_la_tabla_en_singulars ), 'Root no obtuvo el listado de NombreDeLaTablaEnSingulars'
      end
    
      test 'Prueba #XXX-F-004: No debe de existir la pantalla de new para usuario [hmjr]' do
        sign_in @user
        get :new
        assert_response 303 do
          assert false, 'Existe pantalla de new para el usuario, cuando debe ser por ajax'
        end
      end
    
      test 'Prueba #XXX-F-005: No debe de existir la pantalla de new para root [hmjr]' do
        sign_in @root
        get :new
        assert_response 303 do
          assert false, 'Existe pantalla de new para root, cuando debe ser por ajax'
        end
      end
    
      test 'Prueba #XXX-F-006: Usuario no logeado no puede crear un nuevo NombreDeLaTablaEnSingular [hmjr]' do
        assert_no_difference 'NombreDeLaTablaEnSingular.count' do
          post :create, nombre_de_la_tabla_en_singular: @datos_user, format: :js
        end
      end
    
      test 'Prueba #XXX-F-007: Usuario logeado puede crear un nuevo NombreDeLaTablaEnSingular [hmjr]' do
        sign_in @user
        assert_difference 'NombreDeLaTablaEnSingular.count' do
          post :create, nombre_de_la_tabla_en_singular: @datos_user, format: :js
        end
        css_select '#reemplazame ui basic modal'
      end
    
      test 'Prueba #XXX-F-008: root puede crear un nuevo NombreDeLaTablaEnSingular [hmjr]' do
        sign_in @root
        assert_difference 'NombreDeLaTablaEnSingular.count' do
          post :create, nombre_de_la_tabla_en_singular: @datos_user, format: :js
        end
        css_select '#reemplazame ui basic modal'
      end
    
      test 'Prueba #XXX-F-009: Usuario no logeado no puede existir pantalla HTML de edición [hmjr]' do
        get :edit, id: @nombre_de_la_tabla_en_singular
        assert_response :redirect, 'Es redirigido a la pantalla de login'
        assert_redirected_to 'http://test.host/users/login'
        assert_response :redirect
      end
    
      test 'Prueba #XXX-F-010: Usuario logeado no puede existir pantalla HTML de edición [hmjr]' do
        sign_in @user
        get :edit, id: @nombre_de_la_tabla_en_singular
        assert_response :redirect, 'Es redirigido a la pantalla de index'
        assert_redirected_to 'http://test.host/en/nombre_de_la_tabla_en_singulars'
      end
    
      test 'Prueba #XXX-F-011: root logeado no puede existir pantalla HTML de edición [hmjr]' do
        sign_in @root
        get :edit, id: @nombre_de_la_tabla_en_singular
        assert_response :redirect, 'Es redirigido a la pantalla de index'
        assert_redirected_to 'http://test.host/en/nombre_de_la_tabla_en_singulars'
      end
    
      test 'Prueba #XXX-F-012: Usuario no logeado no puede update un registro existente [hmjr]' do
        tut = NombreDeLaTablaEnSingular.first
        tut.campo_ordenado = 'inválido'
        patch :update, id: tut.id, nombre_de_la_tabla_en_singular: tut, format: :js
        assert_response :unauthorized
      end
    
      test 'Prueba #XXX-F-013: Usuario logeado puede update un registro existente con solo_root_ns=false [hmjr]' do
        sign_in @user
        tut = NombreDeLaTablaEnSingular.create @datos_user
        tut.campo_ordenado = 'inválido'
        patch :update, id: tut.id, nombre_de_la_tabla_en_singular: tut, format: :js
        refute_equal @datos_user[:campo_ordenado], NombreDeLaTablaEnSingular.find( tut.id ).campo_ordenado
      end
    
      test 'Prueba #XXX-F-014: Usuario logeado no puede update un registro existente con solo_root_ns=true [hmjr]' do
        sign_in @user
        tut =NombreDeLaTablaEnSingular.create @datos_root
        tut.campo_ordenado = 'inválido'
        patch :update, id: tut.id, nombre_de_la_tabla_en_singular: tut, format: :js
        assert_equal @datos_root[:campo_ordenado], NombreDeLaTablaEnSingular.find( tut.id ).campo_ordenado
      end
    
      test 'Prueba #XXX-F-015: root logeado puede update un registro existente con solo_root_ns=false [hmjr]' do
        sign_in @root
        tut =NombreDeLaTablaEnSingular.create @datos_user
        tut.campo_ordenado = 'inválido'
        patch :update, id: tut.id, nombre_de_la_tabla_en_singular: tut, format: :js
        refute_equal @datos_user[:campo_ordenado], NombreDeLaTablaEnSingular.find( tut.id ).campo_ordenado
      end
    
      test 'Prueba #XXX-F-016: root logeado puede update un registro existente con solo_root_ns=true [hmjr]' do
        sign_in @root
        tut =NombreDeLaTablaEnSingular.create @datos_root
        tut.campo_ordenado = 'inválido'
        patch :update, id: tut.id, nombre_de_la_tabla_en_singular: tut, format: :js
        refute_equal @datos_root[:campo_ordenado], NombreDeLaTablaEnSingular.find( tut.id ).campo_ordenado
      end
    
      test 'Prueba #XXX-F-017: Usuario no logeado no puede borrar un registro [hmjr]' do
        tut =NombreDeLaTablaEnSingular.first
        assert_no_difference 'NombreDeLaTablaEnSingular.count' do
          delete :destroy, id: tut.id, format: :js
        end
      end
    
      test 'Prueba #XXX-F-018: Usuario logeado puede borrar un registro cuando solo_root_ns=false [hmjr]' do
        sign_in @user
        tut =NombreDeLaTablaEnSingular.create @datos_user
        assert_difference 'NombreDeLaTablaEnSingular.count', -1 do
          delete :destroy, id: tut.id, format: :js
        end
      end
    
      test 'Prueba #XXX-F-019: Usuario logeado no puede borrar un registro cuando solo_root_ns=true [hmjr]' do
        sign_in @user
        tut =NombreDeLaTablaEnSingular.create @datos_root
        assert_no_difference 'NombreDeLaTablaEnSingular.count', -1 do
          delete :destroy, id: tut.id, format: :js
        end
      end
    
      test 'Prueba #XXX-F-020: root logeado puede borrar un registro cuando solo_root_ns=false [hmjr]' do
        sign_in @root
        tut =NombreDeLaTablaEnSingular.create @datos_user
        assert_difference 'NombreDeLaTablaEnSingular.count', -1 do
          delete :destroy, id: tut.id, format: :js
        end
      end
    
      test 'Prueba #XXX-F-021: root logeado puede borrar un registro cuando solo_root_ns=true [hmjr]' do
        sign_in @root
        tut =NombreDeLaTablaEnSingular.create @datos_root
        assert_difference 'NombreDeLaTablaEnSingular.count', -1 do
          delete :destroy, id: tut.id, format: :js
        end
      end
    
    end
    

    public by addicttux modified Aug 13, 2015  1056  1  4  0

    Controller Template

    Template para el controller con CRUD
    # Controla el CRUD
    #
    # Por convencionalismo se omiten los métodos +index+, +new+, +update+. Ver nota sobre convencionalismos en +application_controller.rb+
    #
    # El método +update+ es un alias de +create+ debido a *DRYtizar* el código
    #
    # Se aplican 7 métodos +before_action+ como consecuencia de *DRYtizar* el código, los cuales son *privados*
    class NombreDeLaTablaEnSingularsController < ApplicationController
    
      before_action :authenticate_user!
      before_action :set_nombre_de_la_tabla_en_singular, only: [:edit, :update, :destroy, :confirmar_borrar]
      before_action :new_nombre_de_la_tabla_en_singular, only: [:new, :create]
      before_action :crear_breadcrum, only: [:index,:new,:edit]
      before_action :asginar_captura, only: [:create,:update]
      before_action :asgina_current_user, only: [ :update, :destroy ]
      before_action :genera_listado, only: :index
    
      # Evitamos que en producción se vea un 404, redirigiendo culaquier petición a una página inexistente al index
      unless Rails.env.development?
        rescue_from ActionView::MissingTemplate do
          redirect_to nombre_de_la_tabla_en_singulars_path, status: 303
        end
      end
    
      # Lo guarda en la base de datos.
      #
      # @note Hacemos uso del método del mismo nombre definido en <tt>application_controller.rb</tt>
      def create
        super  @nombre_de_la_tabla_en_singular
      end
    
      alias_method :update, :create
    
      # Lo elimina de la base de datos
      #
      # @note Hacemos uso del método del mismo nombre definido en <tt>application_controller.rb</tt>
      def destroy
        super @nombre_de_la_tabla_en_singular
      end
    
      # Genera el reporte en PDF
      #
      # @note Hacemos uso del método del mismo nombre definido en <tt>application_controller.rb</tt>
      def listado_pdf
        super NombreDeLaTablaEnSingularPdf.new( NombreDeLaTablaEnSingular.all.order(:campo_ordenado), view_context )
      end
    
      private
    
      # Este método se utiliza para asignar cada valor capturado a su contraparte en la instancia de la base de datos.
      # <b>Hacemos esto para evitar un ataque de inyección de SQL</b>
      def asginar_captura
        @nombre_de_la_tabla_en_singular.campo_ordenado = params[:nombre_de_la_tabla_en_singular][:campo_ordenado]
        @nombre_de_la_tabla_en_singular.campo_segundo  = params[:nombre_de_la_tabla_en_singular][:campo_segundo]
        @nombre_de_la_tabla_en_singular.solo_root_ns   = params[:nombre_de_la_tabla_en_singular][:solo_root_ns]
      end
    
      # Genera el breadcrum, pasamos la ruta a +index+
      #
      # @note Hacemos uso del método del mismo nombre definido en <tt>application_controller.rb</tt>
      def crear_breadcrum
        super nombre_de_la_tabla_en_singulars_path
      end
    
      # Crea una nueva instancia del objeto
      def new_nombre_de_la_tabla_en_singular
        @nombre_de_la_tabla_en_singular = NombreDeLaTablaEnSingular.new
      end
    
      # Obtiene los datos desde la base de datos
      def set_nombre_de_la_tabla_en_singular
        @nombre_de_la_tabla_en_singular = NombreDeLaTablaEnSingular.find(params[:id])
      end
    
      # Genera el listado. Este método es llamado tanto de forma directa como en el filtro +before_action+
      def genera_listado
        @nombre_de_la_tabla_en_singulars = initialize_grid NombreDeLaTablaEnSingular,
                                              order: 'nombre_de_la_tabla_en_singulars.campo_ordenado',
                                              order_direction: 'desc',
                                              per_page: 10
      end
    
      # Asigna el usuario actual a una variable de instancia a fin de pasen los tests
      def asgina_current_user
        @nombre_de_la_tabla_en_singular.usuario_actual = current_user
      end
    
    end            

    public by addicttux modified Aug 12, 2015  953  3  4  0

    Model Template

    Template para el modelo de datos en rails
    # Responsable del registro de datos y su obtención de la base de datos
    # = Estructura de la Base de Datos
    # = Relaciones
    # = Validaciones
    class NombreDeLaTablaEnSingular < ActiveRecord::Base
    
      include ModeloGeneral
    
      has_many :TablaRelacionadaPlural, dependent: :restrict_with_error
    
      # Usado para contener al +current_user+
      attr_accessor :usuario_actual
    
      before_validation :adecuar
      before_update :autorizar_accion
      before_destroy :autorizar_accion
      before_destroy :no_tiene_objetos_relacionados
      validates :campo_ordenado,
                length: { within: 3..15 },
                presence: true,
                uniqueness: true
    
      private
    
      # Adecua los valores capturados para ser guardados en la base de datos.
      def adecuar
        self.campo_ordenado ||= ''
        self.campo_ordenado.lstrip!
        self.campo_ordenado.rstrip!
        self.campo_ordenado.downcase!
      end
    
      # Verifica que no tenga objetos relacionados
      def no_tiene_objetos_relacionados
        if tabla_relacionada_singulars.empty?
          true
        else
          errors.add :base, "<span style='color: red;'>#{I18n.t('nombre_de_la_tabla_en_singulars.destroy.error_tiene_hijos_html')}</span>"
          false
        end
      end
    
    end            
    • Public Snippets
    • Channels Snippets