6 nov. 2018

Programa - Nuevo pograma

# Este programa es un analizador de lo que se mete por teclado
# Arroja dos ficheros sentidos.txt y decisiones.txt
# En realidad es un interface entre la entrada y el paso analizador
=begin
Esta parte del programa es lo que capta por el teclado
Sería el sentido teclado
=end

puts 'Hola, ¿Cómo te llamas?'
STDOUT.flush
@p=gets.strip.to_s

$otro_origen = nil
#puts "esto es $otro_origen=#{$otro_origen}"
@ma=[]
@captado = []
@evaluados = []
@sentidos  = "sentidos.txt"
@evaluado = "evaluado.txt"
@nueva = []
@ahora = Time.now
@hora = @ahora.strftime("%H")
@minuto = @ahora.strftime("%M")
@segundo = @ahora.strftime("%S")
@dia = @ahora.strftime("%d")
@mes = @ahora.strftime("%m")
@year = @ahora.strftime("%Y")

def xf
if File.exist?(@sentidos)
puts
#puts "El fichero necesario #{@sentidos} existe"
else
puts "No existia el archivo y ha sido creado sin contenido"
f=File.new @sentidos,"a+"
#puts "El fichero necesario #{@sentidos} ya existe"
f.close
end

if File.exist?(@evaluado)
#puts "El fichero necesario #{@decisiones} existe"
else
puts "No existia el archivo y ha sido creado sin contenido"
f=File.new @evaluado,"a+"
puts "El fichero necesario #{@evaluado} ya existe"
f.close
end
end
xf

=begin
Esta parte del programa busca lo que capta por el teclado
en un fichero sentidos.txt
y si lo tiene nos informa y continúa
si no lo tiene procederá a guardarlo en el siguiente paso
=end
def primero
fab=File.open("sentidos.txt", "a+")
@l=0
fab.each do |a|
#puts "Esto es a = #{a} de la clase #{a.class} con longitud de #{a.size}"
@ma=a.split(" ")
#puts "Esto es @ma = #{@ma} de la clase #{@ma.class} con longitud de #{@ma.size}"
#puts "Esto es @ma[0] = "+@ma[0]+" de la clase #{@ma[0].class} con longitud de #{@ma[0].size}"
s=@ma[0].to_s
#puts "Esto es s = #{s} con longitud de #{s.size}"
#limpiamos el array @ma porque tiene comillas, coma y [
menos = s.size-2
@quiero = s[2...menos] #ahora sólo se queda con lo que interesa
#puts "esto es @quiero = #{@quiero} y ésto es @p = #{@p} de la clase #{@quiero.class}"
#puts "@l = #{@l}"
if @p === @quiero
#puts "HAY COINCIDENCIA y no grabaré el nombre"
@l=1
end
end
fab.close
#puts "                         @l = #{@l}"


case @l
when 0
puts "Esto es bueno o malo (escribe bueno o malo)"
STDOUT.flush
@primeraimpresion = gets.chomp.upcase.to_s
puts "has esxrito #{@primeraimpresion}"
if @primeraimpresion != "BUENO" || @primeraimpresion != "MALO"
puts 'lo tomaré como bueno'
@primeraimpresion = "BUENO"
end
@evaluados<<@primeraimpresion
@evaluados<<@p
@evaluados<<@hora
@evaluados<<@minuto
@evaluados<<@dia
@evaluados<<@mes
@evaluados<<@year



@captado<<@p
@captado<<@hora
@captado<<@minuto
@captado<<@segundo
@captado<<@dia
@captado<<@mes
@captado<<@year

puts 'Como no ha habido ninguna coincidencias lo grabo en sentidos.txt'
faa=File.open("sentidos.txt", "a+")
faa.print @captado
faa.puts
faa.close

puts 'Como no ha habido ninguna coincidencias lo grabo en sentidos.txt'
faaa =File.open("evaluado.txt", "a+")
faaa.print @evaluados
faaa.puts
faaa.close
when 1
puts "HAY alguna COINCIDENCIA y no grabaré nada en sentidos.txt"
@ll=1
end
end

puts "Hola #{@p}, son las #{@ahora.strftime("%H:%M:%S")} de la fecha #{@ahora.strftime("%d-%m-%Y")}"

primero

Teoría - Los bloques

Los bloques

Un bloque es una porción de código encerrada entre paréntesis {} o entre do…end. Es una forma de agrupar instrucciones, y solo puede aparecer después de usar un método: el bloque empieza en la misma línea que usa el método. El código dentro del bloque no es ejectuado en el instante que el intérprete de Ruby lo encuentra: Ruby recordará del bloque (variables locales, …) y después entra en el método, ejecutando el bloque cuando es preciso.
Supongamos que existen dos métodos llamados greet1 y greet2:
#greet1, no necesita argumentos
greet1 {puts 'Hola'}
 
#greet2, necesita un argumento
greet2 ("argumento_cualquiera") {puts 'Hola'}
Lo usual es usar las llaves para bloques de una línea y el do…end para más de una línea.

yield

Un método puede usar el bloque mediante la palabra yield:
def metodo
  puts 'Comienzo del metodo'
  yield
  yield
  puts 'Final del metodo'
end
 
metodo{puts 'Dentro del bloque'}
La salida es:
'Comienzo del metodo'
'Dentro del bloque'     # primer yield
'Dentro del bloque'     # segundo yield
'Final del metodo'
Lo que sucede es que en el momento que el intérprete llega al yield, se ejecuta el código dentro del bloque, y luego se retorna al método.

Argumentos en los bloques

En los bloques se pueden usar argumentos especificándolos dentro de dos barras verticales | |. Y si se usan, en el yield no podemos olvidar darles valor:
def metodo
  yield('hola', 99)
end
 
metodo{|str,num| puts str + ' ' + num.to_s}  #hola 99
Un bloque de código devuelve un valor: el valor de la última expresión evaluada. Y este valor devuelto por yield, 

Teoría - Los proc en Ruby

Los proc en Ruby

Los bloques no son objetos, pero pueden convertirse en ellos gracias a la clase Proc. Los objetos tipo proc son bloques que se han unido a un conjuto de variables locales. Esto se hace gracias al método lambda del módulo Kernel.
prc = lambda{ "hola" }
Un bloque creado con lambda actúa como un método: si no especificas el número correcto de argumentos, no puedes llamar al bloque. La clase Proc tiene un método para llamar al bloque: el método call
prc = lambda {puts 'Hola'}
prc.call #llamamos al bloque
 
#otro ejemplo
toast = lambda do
  puts 'Gracias'
end
toast.call
La salida es:
Hola
Gracias
Para usar argumentos con lambda:
aBlock = lambda { |x| puts x }  
aBlock.call 'Hola Mundo!'
La salida es:
Hola Mundo!
Los procs son muy útiles por que:
  • No puedes pasar métodos dentro de otros métodos (usarlos como argumentos); pero si puedes usar procs como argumentos.
  • Los métodos no pueden devolver otros métodos; pero sí pueden devolver un procs.
#uso de procs como argumentos
 
def metod1 proc1
  puts 'Principio del metodo'
  proc1.call
  puts 'Final del metodo'
end
 
hola = lambda do
  puts 'Hola'
end
 
metod1 hola
la salida es:
Principio del metodo
Hola
Final del metodo

Teoría - Operadores en Ruby


http://www.marcossarmiento.com/2015/09/15/operadores-en-ruby/

Operadores en Ruby



Los operadores en Ruby son elementos que relacionan de forma diferente, los valores de una o mas variables y/o constantes para manipular valores. Los operadores son de tres tipos: Aritméticos, Relacionales y Lógicos.

Operadores Aritméticos

Los operadores aritméticos permiten realizar operaciones matemáticas, entre dos variables y/o constantes. Todas las expresiones entre paréntesis se evalúan primero. Las expresiones con paréntesis anidados se evalúan de adentro hacia afuera, el paréntesis más interno se evalúa primero. Dentro de una misma expresión los operadores se evalúan en el siguiente orden:
OperadorDescripción
**Exponencial
*, /, %Multiplicación, división, modulo
+, –Suma y resta
Ejemplo:
Exponencial
5 ** 2 (el resultado sera 25)
5 ** 3 (el resultado sera 125)
División
5 / 3 = 1 (la operación nos da como resultado 1, que seria el cociente de una división)
Modulo
5 % 3 = 2 ( la operación nos da como resultado 2, que es el resto o residuo de una división)

Los operadores en una misma expresión con igual nivel de prioridad se evalúan de izquierda a derecha.
Ejemplo:
5 * 5 / 6 = 4 (Primero se opera 5 * 5 que seria 25 y después se divide por 6 y nos daría 4)
6 / 5 * 5 = 5 (Primero se opera 6 / 5 que seria 1 y después se multiplica por 5 y nos daría 5)
En los dos ejemplos mostrados como los dos operadores tienen el mismo nivel de prioridad se evalúan de izquierda a derecha dándonos diferente resultado en dos operaciones aparentemente iguales.

Operadores Relacionales

Los operadores relacionales comparan valores entre sí, el resultado es verdadero o false (uno o cero).
OperadorDescripción
==igual que
!=diferente de
<menor que
>mayor que
<=menor o igual que
>=mayor o igual que
El operador == (igual que) es solo para realizar comparaciones, si deseamos asignar un valor a una variable debemos utilizar el operador = (igual)
Ejemplo:
a = 16
b = 61
a == b (el resultado sera falso, porque, 16 no es igual que 61)
a = b (el resultado de la variable a, ahora es 61, porque, se le ha asignado el valor de b)

Operadores Lógicos

Los operadores lógicos se utilizan para comparar dos expresiones y devolver un resultado booleano (verdadero o falso). Estos operadores unen estas expresiones devolviendo también verdadero o falso.
OperadorDescripción
&&, andY
||, orO
!No
Las expresiones conectadas con operadores && y || se evalúan de izquierda a derecha y la evaluación se detiene tan pronto como el resultado verdadero o falso es conocido.
Ejemplo:
Utilizamos el operador “and” para evaluar dos condiciones, solo si las dos son verdaderas obtendremos el mensaje “Mujer mayor de edad”.
operador1
En este ejemplo utilizamos el operador “or” para evaluar dos condiciones, si una de ellas es verdadera(se evalúan de izquierda a derecha) obtendremos el mensaje “Mujer mayor de edad”.
operador2
Como la primera condición es verdadera devuelve el mensaje “Mujer mayor de edad” a pesar que la segunda condición es falsa, porque se evalúa de izquierda a derecha y la evaluación se detiene tan pronto como el resultado es verdadero o falso.
Estos tres tipos de operadores se utilizan para el desarrollo de todo tipo de aplicaciones, elaboración de trabajos excel avanzado, operaciones matemáticas y la solución de todo tipo de problemas, es importante conocer a fondo este tema.

Teoría - Saber ruta en Ruby


@ruta=Dir.pwd

Teoría - GTK2

GTK2

require gtk2                                                                              0.- Requerir la gema gtk2
variable Gtk::Window.new                                             1.- Crear la ventana
Contorno y/o interior                                                          2.- Definir ventana (como mínimo ésto)
variable.signal_connect("delete_event") do
    Gtk.main_quit
    false
end
window.border_width = 20                                                       
window.show  ó winsow.show_all                                  3.- llamar a la ventana.
Gtk.mail                                                                                     4.- Activar la ventana para que se muestre con Gtk.main

Teoría - / ó \ en las rutas????

/ ó \ en las rutas????

En windows es \ En Linux es /

Teoría - Operaciones con gemas

Operaciones con gemas

gem install nombre_de_la_gema
gem update
gem update nombre_de_la_gema
gem clean
gem uninstall nombre_de_la_gema
gem list
gem list --local

Teoría - Ventanas... como mínimo (GTK2)

Ventanas... como mínimo

# encoding: UTF-8
require 'gtk2'
v=Gtk::Window.new
v.title = "Ventana de prueba 1"
v.border_width = 5
v.signal_connect('delete_event') do
Gtk.main_quit
false
end



v.show_all
Gtk.main

Teoría - gets

gets

hay diferencias si se utiliza con gets ó gets.strip ó gets.chomp
  • En la primera opción (gets), añade un retorno de carro al final de la entrada.
  • En la segunda opción (gets.strip) elimina los espacios antes y después de la entrada.
  • En la tercera opción (gets.chomp) elimina los espacios después de la entrada.

Teoría - TK-CANVAS

TK-CANVAS-Teoría

Extraído de: https://www.tutorialspoint.com/ruby/ruby_tk_canvas.htm

Descripción

Traducción pendiente

Un recurso o artilugio o clase Canvas implementa la habilidad de manejar gráficos estructurados como línea, círculos, rectángulos, arcos, textos. 

Syntaxis

Esta es esencialmente la sintaxis −
TkCanvas.new{
   .....Opciones standard....
   .....Opciones específicas (del widget) según la opción gráfica elegida....
}

Opciones Standard

  • background
  • borderwidth
  • cursor
  • highlightbackground
  • highlightcolor
  • highlightthickness
  • relief
  • selectbackground
  • selectborderwidth
  • selectforeground
  • state
  • takefocus
  • tile
  • xscrollcommand
  • yscrollcommand
Opciones específicas del Widget
1
closeenough =>Integer
Especifica un valor de coma flotante que indica la proximidad del cursor del ratón a un elemento antes de que se considere que está dentro del elemento. El valor predeterminado es 1.0
2
confine =>Boolean
Especifica un valor booleano que indica si se debe permitir o no establecer la vista del widget fuera de la región definida por el argumento scrollregion. El valor predeterminado es true, lo que significa que la vista será restringida dentro de la región de desplazamiento.
3
height =>Integer
Especifica la altura de ventana deseada que el widget de Canvas debe solicitar al administrador de geometría.
4
scrollregion =>Coordinates
Especifica una lista con cuatro coordenadas que describen las coordenadas izquierda, superior, derecha e inferior de una región rectangular. Esta región se utiliza para fines de desplazamiento y se considera que es el límite de la información en el lienzo.
5
state =>String
Modifica el estado por defecto de Canvas que puede ser uno de estos: normal, disabled, or hidden. Individualmente cada objeto Canvas tiene sus propias opciones que predominan sobre el estado por defecto.
6
width =>Integer
Especifica la anchura de ventana deseada que el widget de Canvas debe solicitar al administrador de geometría.
7
xscrollincrement =>Integer
Especifica un incremento para desplazamiento horizontal, en cualquiera de las formas habituales permitidas para distancias de pantalla. Si el valor de esta opción es mayor que cero, la vista horizontal en la ventana será restringida de modo que la coordenada canvas x en el borde izquierdo de la ventana sea siempre un múltiplo par de xscrollincrement; además, las unidades para desplazamiento también serán xscrollincrement.
8
yscrollincrement =>Integer
Especifica un incremento para el desplazamiento vertical, en cualquiera de los formatos habituales permitidos para distancias de pantalla. Si el valor de esta opción es mayor que cero, la vista vertical en la ventana será restringida de manera que la coordenada y del lienzo en el borde superior de la ventana sea siempre un múltiplo par de yscrollincrement; además, las unidades para desplazamiento también serán yscrollincrement.

Indices

Los índices se utilizan para métodos tales como insertar texto, eliminar un rango de caracteres y establecer la posición del cursor de inserción. Un índice puede especificarse de varias formas, y diferentes tipos de elementos pueden soportar diferentes formularios para especificar índices.
los items de Texto soportan las siguientes maneras para un índice −
  • number − Un número decimal que da la posición del carácter deseado dentro del elemento de texto. 0 hace referencia al primer carácter, 1 al siguiente carácter, y así sucesivamente.
  • end − Refiere al carácter o coordenada justo después de la última en el elemento (igual que el número de caracteres o coordenadas en el elemento).
  • insert − Se refiere al carácter justo antes de que el cursor de inserción se dibuja en este elemento. No válido para líneas y polígonos.

Creando Items

Cuando creas un nuevo widget con Canvas, éste puede ser esencialmente un rectángulo con nada dentro; verdaderamente es como un lienzo en blanco pero para hacer cualquier cosa que necesites con él necesitarás añadirle items.
Hay una extensa variedad de diferentes tipos de items que puedes añadir. los siguientes métodos puedes ser usados para crear diferentes items dentro de cada Canvas. −

Item Arc - ARCO -

Aparecerá arcos en el display. Un arco es una sección de un ovalo delimitado por dos ángulos. Los arcos son creados con la siguiente manera  −
TkcArc.new(canvas, x1, y1, x2, y2, ?option, value, option, value, ...?) 
Los argumentos x1, y1, x2, y y2 representan las coordenadas de dos esquinas opuestas por su diagonal correspondiente a una rectangular región que abarcaría al ovalo que define la arco. Esta es la descripción de otras opciones −
  • extent => degrees − Especifica los grados abarcados por el arco. Si fuera mayor de 360 o menor de -360, entonces 360 es el módulo de media como extensión.
  • fill => color − Rellena la región del arco con un color.
  • outline => color − Especifica el color de la línea exterior del arco.
  • start => degrees − Especifica el comienzo del rango angular ocupado por el arco.
  • style => type − Especifica cómo se dibujará el arco. Si type es pieslice(por defecto es así) entonces la región del arco se define por una sección del perímetro del óvalo más dos segmentos de línea, uno entre el centro del óvalo y cada extremo de la sección del perímetro. Si type es chord entonces la región del arco se define por una sección del perímetro del óvalo más un solo segmento de línea que conecta los dos puntos finales de la sección perimetral. Si type es arc entonces la región del arco consiste en una sección del perímetro solo.
  • tags => tagList − Especifies un conjunto de etiquetas (tags) para aplicar al item. TagList consiste en una lista de nombres de tag (etiquetas), lo cual reemplaza a cualquiera existente para ellos. TagList podría ser una lista vacía.
  • width => outlineWidth − Especifica la anchura de la línea exterior del arco.

Bitmap Items

Items of type bitmap appear on the display as images with two colors, foreground and background. Bitmaps are created with methods of the following form −
The TkcBitmap.new(canvas, x, y, ?option, value, option, value, ...?)method will be used to create a bitmap.
The arguments x and y specify the coordinates of a point used to position the bitmap on the display. Here is the description of other options −
  • anchor => anchorPos − AnchorPos tells how to position the bitmap relative to the positioning point for the item. For example, if anchorPos is center then the bitmap is centered on the point; if anchorPos is n then the bitmap will be drawn so that its top center point is at the positioning point. This option defaults to center.
  • background => color − Specifies a color to use for each of the bitmap pixels whose value is 0.
  • bitmap => bitmap − Specifies the bitmap to display in the item.
  • foreground => color − Specifies a color to use for each of the bitmap pixels whose value is 1.
  • tags => tagList − Specifies a set of tags to apply to the item. TagList consists of a list of tag names, which replace any existing tags for the item. TagList may be an empty list.

Image Items

Items of type image are used to display images on a canvas. Images are created with methods of the following form: :
The TkcImage.new(canvas,x, y, ?option, value, option, value, ...?)method will be used to create an image.
The arguments x and y specify the coordinates of a point used to position the image on the display. Here is the description of other options −
  • anchor => anchorPos − AnchorPos tells how to position the bitmap relative to the positioning point for the item. For example, if anchorPos is center then the bitmap is centered on the point; if anchorPos is n then the bitmap will be drawn so that its top center point is at the positioning point. This option defaults to center.
  • image => name − Specifies the name of the image to display in the item. This image must have been created previously with the image create command.
  • tags => tagList − Specifies a set of tags to apply to the item. TagList consists of a list of tag names, which replace any existing tags for the item. TagList may be an empty list.

Line Items

Items of type line appear on the display as one or more connected line segments or curves. Lines are created with methods of the following form −
The TkcLine.new(canvas, x1, y1..., xn, yn, ?option, value, ...?) method will be used to create a line.
The arguments x1 through yn give the coordinates for a series of two or more points that describe a series of connected line segments. Here is the description of other options −
  • arrow => where − Indicates whether or not arrowheads are to be drawn at one or both ends of the line. Where must have one of the values none (for no arrowheads), first (for an arrowhead at the first point of the line), last (for an arrowhead at the last point of the line), or both (for arrowheads at both ends). This option defaults to none.
  • arrowshape => shape − This option indicates how to draw arrowheads. If this option isn't specified then Tk picks a reasonable shape.
  • dash => pattern − Specifies a pattern to draw the line.
  • capstyle => style − Specifies the ways in which caps are to be drawn at the endpoints of the line. Possible values are butt, projecting, or round.
  • fill => color − Color specifies a color to use for drawing the line.
  • joinstyle => style − Specifies the ways in which joints are to be drawn at the vertices of the line. Possible values are bevel, miter, or round.
  • smooth => boolean − It indicates whether or not the line should be drawn as a curve.
  • splinesteps => number − Specifies the degree of smoothness desired for curves: each spline will be approximated with number line segments. This option is ignored unless the smooth option is true.
  • stipple => bitmap − Indicates that the line should be filled in a stipple pattern; bitmap specifies the stipple pattern to use.
  • tags => tagList − Specifies a set of tags to apply to the item. TagList consists of a list of tag names, which replace any existing tags for the item. TagList may be an empty list.
  • width => lineWidth − Specifies the width of the line.

Rectangle Items

Items of type rectangle appear as rectangular regions on the display. Each rectangle may have an outline, a fill, or both. Rectangles are created with methods of the following form −
The TkcRectangle.new(canvas, x1, y1, x2, y2, ?option, value,...?)method will be used to create a Rectangle.
The arguments x1, y1, x2, and y2 give the coordinates of two diagonally opposite corners of the rectangle. Here is the description of other options −
  • fill => color − Fills the area of the rectangle with color.
  • outline => color − Draws an outline around the edge of the rectangle in color.
  • stipple => bitmap − Indicates that the rectangle should be filled in a stipple pattern; bitmap specifies the stipple pattern to use.
  • tags => tagList − Specifies a set of tags to apply to the item. TagList consists of a list of tag names, which replace any existing tags for the item. TagList may be an empty list.
  • width => outlineWidth − Specifies the width of the outline to be drawn around the rectangle.

Event Bindings

Canvas has the default bindings to allow scrolling if necessary: <Up>, <Down>, <Left> and <Right> (and their <Control-*> counter parts). Further <Prior>, <Next>, <Home> and <End>. These bindings allow you to navigate the same way as in other widgets that can scroll.

Example 1

require "tk"

canvas = TkCanvas.new

TkcRectangle.new(canvas, '1c', '2c', '3c', '3c', 'outline' => 'black', 'fill' => 'blue')

TkcLine.new(canvas, 0, 0, 100, 100, 'width' => '2', 'fill' => 'red')
canvas.pack

Tk.mainloop
This will produce the following result −
Ruby/Tk canvas

Example 2

require 'tk'

root = TkRoot.new
root.title = "Window"

canvas = TkCanvas.new(root) do
   place('height' => 170, 'width' => 100, 'x' => 10, 'y' => 10)
end

TkcLine.new(canvas, 0, 5, 100, 5)
TkcLine.new(canvas, 0, 15, 100, 15, 'width' => 2)
TkcLine.new(canvas, 0, 25, 100, 25, 'width' => 3)
TkcLine.new(canvas, 0, 35, 100, 35, 'width' => 4)
TkcLine.new(canvas, 0, 55, 100, 55, 'width' => 3, 'dash' => ".")
TkcLine.new(canvas, 0, 65, 100, 65, 'width' => 3, 'dash' => "-")
TkcLine.new(canvas, 0, 75, 100, 75, 'width' => 3, 'dash' => "-.")
TkcLine.new(canvas, 0, 85, 100, 85, 'width' => 3, 'dash' => "-..")
TkcLine.new(canvas, 0, 105, 100, 105, 'width' => 2, 'arrow' => "first")
TkcLine.new(canvas, 0, 115, 100, 115, 'width' => 2, 'arrow' => "last")
TkcLine.new(canvas, 0, 125, 100, 125, 'width' => 2, 'arrow' => "both")
TkcLine.new(canvas, 10, 145, 90, 145, 'width' => 15, 'capstyle' => "round")
Tk.mainloop
This will produce the following result −
Ruby/Tk canvas

Example 3

require 'tk'

root = TkRoot.new
root.title = "Window"

canvas = TkCanvas.new(root) do
   place('height' => 170, 'width' => 100, 'x' => 10, 'y' => 10)
end

TkcRectangle.new(canvas, 10,  5,    55,  50, 'width' => 1)
TkcRectangle.new(canvas, 10,  65,  55, 110, 'width' => 5) 
TkcRectangle.new(canvas, 10,  125, 55, 170, 'width' => 1, 'fill'  => "red") 

Tk.mainloop
This will produce the following result −
Ruby/Tk canvas

Example 4

require 'tk'

root = TkRoot.new
root.title = "Window"

canvas = TkCanvas.new(root) do
   place('height' => 170, 'width' => 100, 'x' => 10, 'y' => 10)
end

TkcLine.new(canvas, 0,  10, 100,  10, 'width' => 10, 'fill' => "blue")
TkcLine.new(canvas, 0,  30, 100,  30, 'width' => 10, 'fill' => "red")
TkcLine.new(canvas, 0,  50, 100,  50, 'width' => 10, 'fill' => "green")
TkcLine.new(canvas, 0,  70, 100,  70, 'width' => 10, 'fill' => "violet")
TkcLine.new(canvas, 0,  90, 100,  90, 'width' => 10, 'fill' => "yellow")
TkcLine.new(canvas, 0, 110, 100, 110, 'width' => 10, 'fill' => "pink")
TkcLine.new(canvas, 0, 130, 100, 130, 'width' => 10, 'fill' => "orange")
TkcLine.new(canvas, 0, 150, 100, 150, 'width' => 10, 'fill' => "grey")
Tk.mainloop
This will produce the following result −
Ruby/Tk canvas