Repaso

1. Complete el siguiente programa Ruby que resuelve el reto Dropbox conocido como "El Problema de la Dieta" (partes en subrayado):

    1  def solve(goal, values)
    2    x = values.____
    3  
    4    subsets = lambda do |k|
    5      return { _______ } if k < 0
    6      old_sums = subsets[___]
    7  
    8      new_sums = ___
    9  
   10      old_sums.keys.each do |p|
   11        c = p + ____
   12        new_sums[c] = _________________ if c <= goal
   13      end
   14  
   15      return old_sums._____(new_sums) 
   16    end
   17  
   18    z = subsets[values.________][goal] || []
   19    x.values_at(*z)
   20  end
   21  
   22  rdropbox = {
   23    'free-lunch'    =>  802,
   ..    .......................,
   34    'playing-drums'    =>  -295
   35  }.invert
   36  
   37  s = solve(0, rdropbox.keys)
   38  puts s.inspect
   39  puts rdropbox.values_at(*s).inspect
   

2. Escriba los nombres de los métodos para listar los nombres (como cadenas) de
   • las variables globales que estén definidas (________________)
   • de las variables locales que estén actualmente definidas (_______________)
   • de las variables de instancia de un objeto (__________________)
   • de las variables de clase o módulo (_______________)
   • y de las constantes de una clase o módulo (_________)
   ¿Cuales son métodos de instancia? ¿Cuáles de clase?

3. El código que sigue implementa un motor para las expresiones regulares. Para simplificar las expresiones, se han definido algunos operadores. Siguen algunos ejemplos de uso:

     e = 'c'.re - +('d'.re | 'r'.re)   # /c(d|r)+/
     s = 'crddf'
     remaining = e[s]                  # s =~ /c(d|r)+/
     puts "/c(d|r)+/ '#{s}' Matched. Remaining = '#{remaining}'" if remaining
                                 # /c(d|r)+/ 'crddf' Matched. Remaining = 'f' 
     e = 'c'.re - ~('d'.re | 'r'.re)   # /c(d|r)*/
     s = 'cdrdrf'
     remaining = e[s]                  # s =~ /c(d|r)*/
     puts "/c(d|r)*/ '#{s}' Matched. Remaining = '#{remaining}'" if remaining
   

   Rellene el código que falta:

    1  class ____
    2  
    3    def -(right)  # concatenacion
    4      lambda { |x|  _ _ self[x] ___ right[_] }
    5    end
    6  
    7    def |(right)  # or
    8      lambda { |x|  self[x] __ _____[x] }
    9    end
   10  
   11    def epsilon   # palabra vacía
   12      lambda {|x| _ }
   13    end
   14  
   15    def ~         # cierre de Kleene *
   16      lambda { |x| (_____)[x] or self._______[x] }
   17    end
   18  
   19    def +@        # cierre positivo
   20      lambda { |x| (____________)[x] }
   21    end
   22  
   23  end # Proc
   24  
   25  class ______
   26    def re
   27      lambda { |x| x[0,self.______] == ____ and x[self.______..__] }
   28    end
   29  end
   

4. ¿Que predicado debo de usar para saber si la llamada al método actual es seguida de un bloque?
5. ¿Que hace el método send?¿Que argumentos lleva? ¿que retorna?
6. ¿Cómo puedo llamar a un método privado en Ruby desde fuera de la clase?
7. ¿Que visibilidad tiene define_method? ¿Cómo funciona? ¿Que argumentos recibe? ¿Que devuelve? ¿En que contexto espera ser evaluado?
8. ¿Es posible definir en Ruby un método cuyo nombre no case con la expresión regular /^[a-z_]+\w*$/i?
9. ¿Cuándo se ejecuta method_missing? ¿Que argumentos espera? ¿Que precauciones hay que tomar cuando se escribe uno?
10. ¿Que se entiende por delegación?

     1  require 'delegate'
     2  class Set < DelegateClass(Array)
    

    ¿Que ocurre en la línea 2? ¿Que debe hacerse en el initialize para que el proceso de delegación funcione?
11. ¿Cómo puedo recorrer los objetos (referencia) que estan vivos en un punto dado de la ejecución de un programa?
12. ¿Como puedo obtener los nombres de los métodos de un objeto?
13. ¿Como funciona el método de instancia index de un objeto de la clase Array?
14. ¿Cómo puedo llamar a un método cuyo nombre esta almacenado en la variable x?
15. ¿Cómo puedo saber cuantos argumentos espera un método cuyo nombre esta almacenado en la variable x?
16. ¿Cuales son los pasos para sobreescribir un método mm de una clase o módulo MM por nuestro propio mm?

17. Rellene las partes de código que faltan en esta clase que implementa una clase que da una funcionalidad parecida a la de la librería markby:

    class HTML
    
      attr_accessor :page
    
      def initialize(&block)
        @page = ____
        _____________ &block
      end
    
      def build_attr(attributes)
          return '' if attributes.nil? or  attributes._____?
          attributes.______(__) { |s,x| s += %{ ___________________ } } 
      end
    
      def method_missing(tag, *args)
        if block_given?
          @page.____ ______
          _____ 
          text = @page.________
        else
          text = args.__________ || "\n"
        end
        tagattr = build_attr(args.shift) 
        text = "______________________________________"
        @page[__].push ____
        text
      end
    
      def to_s
        @page.join("\n")
      end
    end
    

18. Explique brevemente que hacen los siguientes comandos:
    1. git init
    2. git add
    3. git commit
    4. git clone ssh://..
    5. git status
    6. git diff oldref newref
    7. git push
    8. git pull
19. 1. ¿Que paquete hay que cargar require '_________' para elaborar una prueba?
    2. ¿De que clase debe heredar nuestra clase para que pueda ser usada en la implementación de pruebas Test::Unit?
    3. ¿Que patrón debe seguir el nombre de los métodos de prueba dentro de la clase de prueba?
20. 1. ¿Cómo se declara una tarea en Rake?
    2. ¿Cómo se declara que una tarea tiene dependencias?
    3. ¿Cómo se definen las acciones asociadas que componen una tarea?
    4. Cada tarea se define en un lugar del fichero Rakefile ¿cierto o falso?
    5. ¿Cómo se declara una tarea fichero? ¿Como se definen sus dependencias? ¿Cómo se declara una tarea directorio?
    6. ¿Que hace el método sh?
    7. ¿Como se llama la clase que nos facilita la tarea de ejecutar un conjunto de pruebas? ¿Que hacen los métodos libs y pattern del objeto t en el siguiente código?

       Rake::TestTask.new do |t|
         t.libs << "test"
         t.test_files = FileList['test/test*.rb']
         t.verbose = true
       end