O Django é um framework Web para Python de alto nível que incentiva o desenvolvimento rápido e um design clean e pragmático. Criado por desenvolvedores experientes, ele cuida de grande parte do trabalho de desenvolvimento Web, para que você possa se concentrar em escrever seu aplicativo sem a necessidade de reinventar a roda. Django é um framework livre e open source.

Existem outros frameworks ótimos para Python direcionados ao desenvolvimento Web, como o Web2py, no entanto o Django é o mais famoso e o mais requisitado no mercado de trabalho atual, podemos dizer que o Django em termos de popularidade se assemelha ao framework Rails para Ruby mas conceitualmente possui diferenças significativas, Rails utiliza o Pattern MVC enquanto o Django utiliza o conceito MVT (Model View Template).

Django: https://www.djangoproject.com/

Instalando o Django e Criando Uma Aplicação Web

O Django é fácil de instalar e simples de utilizar, pode ser utilizado pela linha de comando de um modo parecido com o Rails, ou através de IDEs que permitem integração com o Django como, o Eclipse com PyDev (licença gratuita), Visual Studio com Python Tools (versão comunitária gratuita) ou PyCharm Pro (licença com custo).  Neste site você encontra um walkthrough sobre como instalar cada IDE citada. Não se preocupe em entender os conceitos MVT agora, veremos muito sobre o assunto durante o decorrer dos post sobre o Django.

1 – Para instalar o Django digite as instruções abaixo no terminal do Linux:

sudo apt-get install python-django

# Para testar
Python
import django
django.VERSION
Instalar Django - Versão

Instalar Django – Versão

2 – Entre em uma pasta de sua escolha para criar seu primeiro projeto e testa-lo,  digite:

django-admin startproject devaberto
python manage.py runserver
Projeto - Servidor

Django – Projeto – Servidor

3 – Com servidor rodando abra seu navegador e digite o endereço local e a porta 8000:

Testando Servidor

Django – Testando Servidor

4 – Agora que já temos um projeto criado, precisamos criar uma nova aplicação, digite:

django-admin startapp HelloWorldApp
Django - Cria Aplicação

Django – Cria Aplicação

5 – Com o projeto e a aplicação criados, basicamente precisamos alterar dois arquivos do projeto e um arquivo da aplicação. Vamos começar com o arquivo do projeto settings.py onde adicionaremos nossa aplicação:

Django - Settings.py

Django – Settings.py

6 – O arquivo do projeto url.py é onde importaremos nossa View e mapearemos a URL desejada para a nossa View:

Django - URL - View

Django – URL – View

7 – No arquivo da aplicação views.py é onde criaremos o código Python para executar a View. O código HTML deste programa foi retirado do site W3Schools, recomendamos que você o utilize para aprender mais sobre HTML e outras linguagens de script para web, você encontra o link para o site no menu Uteis:

Django - View

Django – View

8 – Com o servidor Django do seu projeto rodando, digite o nome da sua aplicação na url do navegador:

Django - Aplicação

Django – Aplicação – Hello World

Exemplo:

Neste exemplo instalamos o Django e criamos um projeto e uma aplicação básica, onde configuramos os arquivos necessários para que o projeto consiga enxergar nossa View e mapear sua URL, logo criamos uma View para ser executada no navegador.

Python

settings.py

"""
Django settings for devaberto project.

For more information on this file, see
https://docs.djangoproject.com/en/1.6/topics/settings/

For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.6/ref/settings/
"""

# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
import os
BASE_DIR = os.path.dirname(os.path.dirname(__file__))

# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.6/howto/deployment/checklist/

# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 's8eic)^+f@%gg0ffq9j3_kfsoo11k*a-&8x7jw@2p(ujy$=p4a'

# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = True

TEMPLATE_DEBUG = True

ALLOWED_HOSTS = []

# Application definition

INSTALLED_APPS = (
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'HelloWorldApp',

)

MIDDLEWARE_CLASSES = (
    'django.contrib.sessions.middleware.SessionMiddleware',
    'django.middleware.common.CommonMiddleware',
    'django.middleware.csrf.CsrfViewMiddleware',
    'django.contrib.auth.middleware.AuthenticationMiddleware',
    'django.contrib.messages.middleware.MessageMiddleware',
    'django.middleware.clickjacking.XFrameOptionsMiddleware',
)

ROOT_URLCONF = 'devaberto.urls'

WSGI_APPLICATION = 'devaberto.wsgi.application'

# Database
# https://docs.djangoproject.com/en/1.6/ref/settings/#databases

DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.sqlite3',
        'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
    }
}

# Internationalization
# https://docs.djangoproject.com/en/1.6/topics/i18n/

LANGUAGE_CODE = 'en-us'

TIME_ZONE = 'UTC'

USE_I18N = True

USE_L10N = True

USE_TZ = True

# Static files (CSS, JavaScript, Images)
# https://docs.djangoproject.com/en/1.6/howto/static-files/

STATIC_URL = '/static/'

url.py

from django.conf.urls import patterns, include, url

# Importa View
from HelloWorldApp.views import hello

# from django.contrib import admin
# admin.autodiscover()

urlpatterns = patterns('',
    # Examples:
    # url(r'^$', 'devaberto.views.home', name='home'),
    # url(r'^blog/', include('blog.urls')),

    # url(r'^admin/', include(admin.site.urls)),
    url(r'HelloWorldApp/$', hello),
)

views.py

from django.shortcuts import render
from django.http import HttpResponse

html = """
<!DOCTYPE html>
<html>
<body>
<h1> Hello World - Python - Django </h1>
<div style="position:relative;">  <div style="opacity:0.5;position:absolute;left:50px;top:-30px;width:300px;height:150px;background-color:#40B3DF"></div>  <div style="opacity:0.3;position:absolute;left:120px;top:20px;width:100px;height:170px;background-color:#8AC007"></div>
  <div style="margin-top:30px;width:360px;height:130px;padding:20px;border-radius:10px;border:10px solid #EE872A;font-size:120%;">
	<h1>CSS = Styles and Colors</h1>
	<div style="letter-spacing:12px;font-size:15px;position:relative;left:25px;top:25px;">Manipulate Text</div>
	<div style="color:#40B3DF;letter-spacing:12px;font-size:15px;position:relative;left:25px;top:30px;">Colors,
	<span style="background-color:#B4009E;color:#ffffff;"> Boxes</span></div>
	</div></div>
</body>
</html>
"""

def hello(request):
    return HttpResponse(html)

A interface gráfica das ferramentas do Web Dynpro nos proporciona um modo de criar aplicações web usando um ambiente RAD que em português significa, desenvolvimento rápido de aplicações. Além do ambiente RAD, o Web Dynpro nos proporciona o paradigma da programação declarativa, que significa que vamos desenvolver uma aplicação escrevendo o mínimo de código fonte possível. Vamos fazer isto utilizando o Pattern mais difundido para aplicações para web na atualidade, o MVC, que nos permite maior controle sobre os elementos e objetos da aplicação em relação aos modelos e visões.

Criando um Aplicação Web Dynpro

1 – Crie um novo componente Web Dynpro e arraste para a tela um elemento Header, um TransparentContainer, um Label, um Input_Field e um Button. Preencha os campos textos e para o elemento Header e ligue a propriedade Label For no elemento Input_Field. Para o elemento TransparentContainer mude a propriedade Height para 10 px:

View - Main - Layout

View – Main – Layout

2 – Clique em Views e com o botão direito crie uma nova View chamada Saudação:

Nova - View - Saudacao

Nova – View – Saudação

3 – Abra a nova View e insira em seu Layout os elementos Header, TransparentContainer e 2 TextView. Mude as propriedades Text dos elementos TextViews para “Bem-vindo:” e “usuário” e a propriedade Height do TransparentContainer para 10px:

View - Saudação - Layout

View – Saudação – Layout

4 – Agora vamos utilizar atributos para guardar o valor do campo de entrada de texto, vamos fazer isto no contexto do controlador. No seu componente Dynpro, clique em COMPONENTCONTROLLER e selecione Context e com o botão direito Create->Node:

Controller - Contexto

Controller – Contexto

5 – Crie um Node para o controlador chamado Usuario_Controller, este node será onde guardaremos nosso atributo, ele está localizado no contexto do controlador, isto significa que todas as visões podem vê-lo:

Node - Controle Usuário

Node – Controle Usuário

6 – No novo Node crie um atributo chamado usuario_login do tipo string, este atributo será usado para guardar o valor digitado no campo de texto:

Atributo - Usuário - String

Atributo – Usuário – String

7 – ATENÇÃO – Neste momento vamos ligar os componentes para que obtenhamos a funcionalidade desejada para a aplicação. Clique na View Main e na aba Context, arraste o Node criado no controlador para o contexto da View:

Main - Contexto - Atributos

Main – Contexto – Atributos

8 – Agora podemos enxergar o atributo do controlador em nossa View, clique em Layout e clique no elemento Input_Field, vamos ligar o atributo no valor da propriedade Value do elemento:

Ligação - Atributo - Valor

Ligação – Atributo – Valor

9 – Abra a View Saudacao e na aba Context faça a mesma coisa, arraste o Node do controlador para o contexto da View para que possamos enxergar o atributo:

View - Saudação - Contexto - Atributo

View – Saudação – Contexto – Atributo

10 – Abra a aba Layout e clique no segundo elemento TextView no qual está reservado para exibir o nome digitado pelo usuário e ligue a propriedade Text do elemento ao atributo da View:

View - Atributo - Text

View – Atributo – Text

11 – IMPORTANTE – Agora vamos criar a regra para uma ação, ou seja vamos criar plugs dizendo que queremos que a View Main abra a View Saudação. Para isto abra a aba OutBound Plugs e crie um Plug de saída chamado ir_saudação:

Plugs - OutBound - Saida

Plugs – OutBound – Saida

12 – Abra a View Saudação e na aba InBound Plugs vamos criar um plug de entrada chamado vir_main:

Plugs - InBound - Entrada

Plugs – InBound – Entrada

13 – No seu componente Dynpro abra o item Windows e arraste a View Saudação para a estrutura do objeto Window:

Window - Estrutura das Views

Window – Estrutura das Views

14 – Agora vamos plugar os plugs criados anteriormente arraste o plug Out (vermelho) IR_SAUDACAO para o plug In VIR_MAIN:

Ligação - Plugar Out -> In

Ligação – Plugar Out -> In

15 – Volte para a View Main e clique no elemento Button, em sua propriedade onAction vamos criar uma ação para o evento de clique do botão, preencha os dados para o evento e escolha o plug de saída IR_SAUDACAO:

Eventos - Botão - Ação

Eventos – Botão – Ação

16 -Salve, ative o componente e teste sua aplicação. Alimente o usuário e senha para login, com o navegador aberto entre seu nome no campo de texto e clique no botão enviar:

Aplicação - View - Main

Aplicação – View – Main

17 – O controlador processará a ação alimentando o valor ligado ao atributo ao dado inserido na propriedade de texto do campo de entrada e o enviará para a visão de saudação alimentando a propriedade de texto do elemento de texto, criando assim a funcionalidade da aplicação:

View - Saudação

View – Saudação

Como utilizamos o paradigma de programação declarativa não escrevemos uma única linha de código sequer, mas isto não significa que não haja código fonte.  Para ver o código da aplicação, clique na View Main e na aba Action e dê um duplo clique na ação criada, você será levado ao método criado para executar o evento de clique do botão.

Abap

method ONACTIONACAO_BOTAO_ENVIAR .
  wd_this->fire_ir_saudacao_plg(
  ).
endmethod.

SAP – Web Dynpro – Hello World – Abap

Publicado: 2 de janeiro de 2015 em Abap

O Web Dynpro é a tecnologia padrão SAP para o desenvolvimento de aplicações Web no ambiente ABAP. Ela consiste de um ambiente de tempo de execução e um ambiente gráfico de desenvolvimento com ferramentas Dynpro especiais para web que estão integradas no ABAP Workbench. O modelo de programação Web Dynpro é baseado no Design Pattern Model View Controller (MVC) entretanto sua UI utiliza o paradigma de programação declarativa.

O Web Dynpro possui ferramentas gráficas para o desenvolvimento que de certo modo são similares a outras soluções para web que utilizam programação declarativa como por exemplo, o Oracle Application Express que também utiliza o paradigma declarativo, no entanto diferente do Web Dynpro o APEX possui uma IDE RAD que é executada inteiramente no navegador web e é parte integrante do Oracle Database. A principal característica deste paradigma de programação é a pouca necessidade de escrever código fonte para criar aplicações robustas.

Criando Sua Primeira Aplicação Web Dynpro

Para criar um aplicação Web Dynpro você precisa criar um componente Dynpro que é nada mais que um tipo de projeto MVC.

1- Abra ABAP Development Workbench com a transação SE80, escolha “Web Dynpro Comp./ Inf.” e preencha o campo de busca como ZMeuDynpro.

SE80 - Web Dynpro - Componente

SE80 – Web Dynpro – Componente

2- Clique em pesquisar, quando indagado escolha criar um componente Web Dynpro:

Dynpro - Criar Componente

Dynpro – Criar Componente

3 – Expanda Views e clique em Main. Na aba Layout clique com o botão direito em ROOTUIELEMENT e escolha Insert Element:

Dynpro - View

Dynpro – View

4 – Escolha um ID para o elemento e escolha o tipo Page Header:

Tipo de Elemento

Tipo de Elemento

5 – Com o elemento criado, o selecione e em sua propriedade title, escolha um titulo:

Modifica Elemento

Modifica Elemento

6 – ATENÇÃO – Clique no botão Show/Hide Layout Preview. O Preview irá lhe mostrar o design da pagina, entretanto todos os serviços necessários para que o Web Dynpro funcione precisam estar ativados, caso lhe mostre algum erro nesta tela, saia, ative os serviços requisitados e volte.

O Preview lhe permite utilizar uma caixa de ferramentas para que você arraste os elementos na pagina e monte seu design mais rapidamente. Adicione na tela um elemento TransparentContainer e um Label, mude a propriedade text do Label e associe sua propriedade Label For no TransparentContainer. A propriedade Label For é obrigatória e geralmente é associada a uma caixa de texto:

Layout Preview

Layout Preview

7 – Clique no seu componente com o botão direito e o ative:

Ativar - Dynpro

Ativar – Dynpro

8 – Agora precisamos criar uma aplicação Web Dynpro, com o botão direito escolha Create e Web Dynpro Application:

Criar Aplicação

Criar Aplicação

9 – Defina uma descrição para sua aplicação:

Descrição da Aplicação

Descrição da Aplicação

10 – Em sua aplicação, clique com o botão direito e escolha Test:

Testar Aplicação

Testar Aplicação

11 – O seu navegador padrão será aberto, no entanto ainda não definimos um protocolo seguro para aplicação e uma pagina lhe questionará sobre a autenticação, clique em Log On:

Web Dynpro - Log On

Web Dynpro – Log On

12 – Digite o seu usuário e senha:

Log On

Log On

13 – Pronto sua aplicação foi executada com sucesso:

Web Dynpro App

Web Dynpro App

Não se esqueça que todos os serviços básicos ICM e ICF precisam estar ativados para que você possa desenvolver e rodar aplicações Web Dynpro. A Aplicação é criada como um serviço ICF no seguinte local, Virtual Host: sap/bc/webdynpro/sap/SuaApp.

Para saber como configurar um ambiente básico para criar e rodar aplicações Web Dynpro clique aqui.

 

 

O Web Dynpro é uma tecnologia de aplicação web proprietária desenvolvida pela SAP AG que se concentra no desenvolvimento de aplicações de negócio  para web, do lado do servidor. Uma de suas principais características de seu projeto é que a interface do usuário é definida de uma forma totalmente declarativa. Aplicações Web Dynpro podem ser desenvolvidas usando um Java (Web Dynpro para Java) ou ABAP (Web Dynpro ABAP).

Por motivos de segurança os serviços necessários para que uma aplicação Web Dynpro seja executada ou escrita utilizando o Netweaver, por padrão estão desabilitados, deste modo é necessário uma serie de configurações adicionais para que possamos rodar um aplicação Web Dynpro. Podemos dizer então que basicamente o Web Dynpro utiliza os componentes ICM (Internet Communication Manager) e ICF (Internet Communication Framework).

SAP Oficial: Web Dynpro

Configuração Inicial Web Dynpro

1 – Abra a transação SMICM para acessar o ICM Monitor:

ICM Monitor

ICM Monitor

2- No menu GOTO escolha Parameters->Display. Procure pelo item icm/host_name_full, você verá que ele esta com o nome do seu computador que é o nome do servidor de aplicação do Netweaver.

ICM Parâmetros

ICM Parâmetros

3 – O ICM requer que tenhamos um DNS valido chamado de Fully Qualified Domain Names (FQDN) e não o nome do servidor de aplicação do Netweaver.

FQDN: Fully Qualified Domain Names 

Para realizar esta tarefa podemos efetuar uma configuração no perfil do Default do Netweaver, entre na transação RZ10 e selecione o perfil Default, clique em Extended Maintance e clique em Change:

Netweaver - Profile

Netweaver – Profile

4 – Adicione um novo parâmetro para o icm/host_name_full de valor devabertosap.com, este será o nosso FQDN, salve o parâmetro, volte a tela e ative o perfil:

Netweaver - ICM - FDQN Parâmetro

Netweaver – ICM – FQDN Parâmetro

Sabemos que estas configurações no mundo real precisam ser efetuadas por um consultor BASIS, por este motivo caso você tenha algum problema par importar, modificar, salvar e ativar seu perfil no qual depende de outras configurações, você pode utilizar diretamente o arquivo de configuração de perfil do Netweaver, com isso você corta os dois passos acima. Seu arquivo Default.PFL é encontrado no diretório: C:\usr\sap\NSP\SYS\profile.

Default.PFL (Utilizamos o cliente de desenvolvimento 200 nesta configuração)

SAPDBHOST = Estacao01
j2ee/dbtype = sap
j2ee/dbname = NSP
j2ee/dbhost = Estacao01
SAPSYSTEMNAME = NSP
SAPGLOBALHOST = Estacao01
system/type = ABAP
#-----------------------------------------------------------------------
# SAP Message Server for ABAP
#-----------------------------------------------------------------------
rdisp/mshost = Estacao01
rdisp/msserv = 0
rdisp/msserv_internal = 3900
login/system_client = 200
login/no_automatic_user_sapstar = 0
icm/host_name_full = devabertosap.com

5 – ATENÇÃO – Entre na transação SICF e clique no botão Execute. Neste passo você precisa ativar os serviços básicos para que possamos criar e rodar aplicações Web Dynpro:

ICF - Services

ICF – Services

Procure com cuidado e ative clicando com o botão direito em cima do serviço selecionado e escolhendo a opção Activate Service:

/default_host/sap/public/bc/ur
/default_host/sap/public/bc/icons
/default_host/sap/public/bc/icons_rtl
/default_host/sap/public/bc/webicons
/default_host/sap/public/bc/pictograms
/default_host/sap/public/bc/webdynpro/* (ssr, mimes, etc.)
/default_host/sap/public/myssocntl

/default host/sap/bc/webdynpro
/default host/sap/bc/wdvd

ICF: ICF services

6 – Após as configurações no Netweaver precisamos configurar o arquivo de host do Windows para utilizar o FQDN configurado no sistema SAP. Entre no prompt de comando e digite ipconfig, verifique o IP da sua placa de rede virtual (MS Loopback) ou qualquer outra que você utilize.

Nesta instalação não utilizamos o MS Loopback (recomendado pela SAP) e o substituímos pelo Oracle VirtualBox Host:

Servidor de Aplicação SAP - Placa Virtual

Servidor de Aplicação SAP – Placa Virtual

7 – Abra seu arquivo de hosts com direitos de administrador e insira o IP e o seu FQDN, vide imagem para referencia:

O arquivo hosts é encontrado no diretório: C:\Windows\System32\Drivers\etc

Hosts - IP - FQDN

Hosts – IP – FQDN

8 – Após todas estas configurações reinicie o servidor SAP e você estará apto a criar sua primeira aplicação Web Dynpro. Veja nosso post Hello World – Web Dynpro para saber como utilizar o Web Dynpro pela primeira vez:

Servidor SAP

Servidor SAP

Para criar sua primeira aplicação Web Dynpro clique aqui.

 

Quando você utiliza Netweaver Application Server ABAP Developer Edition com o banco de dados SAP MaxDB em um computador Desktop, você o instala e configura por conta própria, este trabalho no mundo real em um ambiente profissional é feito por um consultor especializado chamado BASIS. Este consultor é responsável por deixar os sistemas SAP em perfeita harmonia segundo as melhores praticas para cada tipo de instalação e configuração dos componente do sistema e seus ambientes.

O banco de dados SAP MaxDB precisa ser configurado corretamente para que seu log não ocupe todo o espaço definido por padrão e o sistema não consiga mais gravar novas entradas de logs, acusando assim que existe algum item que não esta em perfeita afinidade com o restante do sistema, neste caso o console de manutenção dos sistemas SAP mudará a cor do ícone que representa o servidor para amarelo avisando a inconformidade do sistema e lhe informando com a seguinte mensagem: Funcionando mas há uma paralisação na fila de diálogos (Running But Dialog Queue StandStill).

SAP - Running But Dialog Queue StandStill

SAP – Running But Dialog Queue StandStill

Para resolver a situação você pode executar um backup completo do banco de dados NSP ou definir o log como automático. Vamos fazer as duas coisas, o backup e a configuração automática do log, mas antes você precisa instalar o SAP MaxDB Database Manager, o instalador se encontra no diretório MaxDbTools da imagem do DVD de instalação que você baixou da SAP Store e procuramos o arquivo com o nome de DBM76.exe. Clique no instalador e siga os passos do assistente de instalação:

SAP - MaxDB - Database Manager

SAP – MaxDB – Database Manager

Configurando o SAP MaxDB

1 – Abra o Database Manager e com o botão direito no item Server escolha Sync Server e escolha NSP, quando interrogado pelo usuário e senha utilize: control e a senha master que você definiu no momento da instalação do NetWeaver. Você verá que o log está cheio 100% e o próprio gerenciador sugere que você faça o backup e defina o auto log para ON:

MaxDB - Log Full

MaxDB – Log Full

2 – Ao clicar no link sugerido o assistente de backup o ajudara a executar a tarefa, clique em next:

Backup - Wizard

Backup – Wizard

3 – Clique no botão Backup Medium e insira um nome para seu backup:

Backup Medium

Backup Medium

4 – Na tela de resumo clique em Start para iniciar o backup:

Start Backup

Start Backup

5 – Após o termino do backup (pode demorar), clique em Close:

Backup - Completo

Backup – Completo

6 – Vamos definir o log como automático, clique no banco NSP e com o botão direito escolha Set Auto Log On:

Log Automático

Log Automático

7 – Clique no botão do assistente para adicionar um nome para o backup automático de log e clique OK e depois em ON:

Nome do Backup de Log

Nome do Backup de Log

8 – Com o botão direito no banco de dados NSP clique em Refresh ou aguarde alguns segundos, e o novo status será mostrado:

MaxDB - Novo Status

MaxDB – Novo Status

10 – Pronto seu sistema SAP já esta funcionando perfeitamente e pronto para processar novas mensagens, você já pode logar novamente com sucesso.

SAP System - Console

SAP System – Console

Ruby – Date and Time – Linux

Publicado: 30 de dezembro de 2014 em Ruby on Rails

A classe Time é uma abstração de datas e horários. O tempo é armazenado internamente como o número de segundos com fração desde a época de 01 de janeiro de 1970 00:00 UTC. A classe Time trata os padrões GMT (Greenwich Mean Time) e UTC (Tempo Universal Coordenado) como equivalente. GMT é a maneira mais antiga de se referir a estes tempos de base.

Time: http://ruby-doc.org/core-2.2.0/Time.html

Ruby - Time

Ruby – Time

Exemplo:

Neste exemplo imprimimos datas e horários através da classe Time.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# time.rb

# Utiliza classe de tempo
tempo = Time.new

# Imprime data e hora
puts "Dia: " + String(tempo.day) + "/" + 
               String(tempo.month) + "/" + 
               String(tempo.year)
               
puts "hora: " + String(tempo.hour) + ":" +
                String(tempo.min) + ":" +
                String(tempo.sec)
               
# Imprime data com formato               
puts "Data Formatada: " + tempo.strftime("%d-%m-%Y %H:%M:%S")

Um erro de aplicativo é um erro de tempo de execução que não pode necessariamente ser evitado escrevendo um código livre de erros. Erros de tempo de execução podem ocorrer por uma variedade de razões. No entanto, nem todos os erros devem ser tratados como exceções em seu código. Em alguns casos, um erro de programa pode refletir uma condição de erro esperada ou de rotina. Neste caso, você pode querer evitar o uso de tratamento de exceção para lidar com o erro do programa. Em outros casos, um erro de programa reflete uma condição de erro inesperado que pode ser manipulado em seu código. Por exemplo, mesmo que você tenha verificado para garantir que existe um arquivo, ele pode ser excluído antes que você possa abri-lo, ou ele pode estar corrompido.

A falha do sistema é um erro de tempo de execução que não pode ser tratado por meio de programação de uma maneira significativa. Por exemplo, qualquer método pode lançar uma exceção OutOfMemory se o Runtime for incapaz de alocar memória adicional

O Ruby utiliza blocos para manipular exceções, todo o código contido no bloco pode ser manipulado com a instrução Rescue que previne a interrupção do programa e trata o erro, Ensure que assegura o termino da execução do bloco, Retry que executa novamente o inicio do bloco e o próprio Raise que força uma exceção. A classe Exception o ajuda a manipular os erros como por exemplo, exibindo suas mensagens.

Exception: http://www.ruby-doc.org/core-2.2.0/Exception.html

Ruby - Exception

Ruby – Exception

Exemplo:

Neste exemplo utilizamos os conceitos básicos de tratamento de exceção para manipular erros.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# Erros.rb

# Para validar instruções crie um bloco
puts "Erro numero 1: \n\n"
begin

  # Define valores
  numero1 = 10
  numero2 = 0

  # Tenta dividir por zero
  resultado = numero1 / numero2

# Previne o erro e imprime mensagem de erro
rescue Exception => ex
  puts "Houve um erro: " + ex.message

#Garante final da execução do bloco
ensure
  puts "coloque algo aqui caso queira ter certeza da execução." 

end

# Gera seu próprio erro
puts "\nErro numero 2: \n\n"
begin

  # Define valores
  valor1 = 5
  valor2 = 6

  # Raise gera um erro especifico
  if (valor2 > valor1)
    raise "Valor 2 não pode ser maior que o valor 1"
  end

# Rescue impede a interrupção do programa e exibe mensagem
rescue Exception => ex
  puts "Houve um erro: " + ex.message

end

Ruby – Container e Iterator – Linux

Publicado: 29 de dezembro de 2014 em Ruby on Rails

Em português iterador, é um objeto que permite a um programador examinar uma coleção ou container. Vários tipos de iteradores são frequentemente fornecidos através de uma interface de container. Apesar da interface e semântica de um determinado iterador serem fixas, iteradores são frequentemente implementados em termos de estruturas subjacentes a uma implementação de container e são muitas vezes ligados intimamente ao container para permitir a semântica operacional do iterador.

Observe que um iterador percorre e também dá acesso aos elementos de dados em um container, mas não realiza iteração (isto é, não sem alguma liberdade significativa tomada com este conceito ou com uso trivial da terminologia). Um iterador tem um comportamento semelhante a um cursor de banco de dados. Iteradores datam da linguagem de programação CLU de 1974.

Collection

É uma coleção, às vezes chamada de um recipiente (container), é simplesmente um objeto que agrupa vários elementos em uma única unidade. Coleções são usadas ​​para armazenar, recuperar, manipular e comunicar dados agregados, ou seja uma coleção é um objeto que contém outros objetos, existem outras coleções com diferentes capacidades.

Historicamente, o quadro de coleções têm sido bastante complexo, o que lhes deu uma reputação de ter uma grande curva de aprendizagem. Os exemplos mais conhecidos de frameworks de coleções são o C ++ Standard Template Library (STL). A nomenclatura das APIs e suas sintaxes podem mudar de uma linguagem de programação para outra.

Ruby - Container e Iterator

Ruby – Container e Iterator

Array e Hash

O Ruby possui dois tipos de containers, eles pertencem as classes Array e Hash. Os Arrays são ordenados, coleções indexadas por números inteiros de qualquer objeto, um Hash é uma coleção como um dicionário de chaves únicas e seus respectivos valores.

Array: http://www.ruby-doc.org/core-2.2.0/Array.html

Hash: http://www.ruby-doc.org/core-2.0/Hash.html

Exemplo:

Neste exemplo criamos uma classe para representar um item musical que contem determinadas informações de uma musica. Utilizamos um container para armazenar as musicas representando um álbum e utilizamos o iterador para navegar e imprimir o conteúdo do container.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# Containers.rb

# Define classe
class Album
  
  # Métodos
  attr_accessor :id, :musica, :duracao
  
  # Construtor
  def initialize(id, musica, duracao)
    @id = id
    @musica = musica
    @duracao = duracao
  end

end

# Cria Array (Lista)
afd = [
  Album.new(1, "Welcome to the Jungle ", "4:34"),
  Album.new(2,"It's So Easy","3:23"),
  Album.new(3,"Nightrain","4:28"),
  Album.new(4,"Out Ta Get Me","4:24"),
  Album.new(5,"Mr. Brownstone","3:49"),
  Album.new(6,"Paradise City","6:46"),
  Album.new(7,"My Michelle","3:40"),
  Album.new(8,"Think About You","3:52"),
  Album.new(9,"Sweet Child O' Mine","3:21"),
  Album.new(10,"You're Crazy","3:17"),
  Album.new(12,"Anything Goes","3:26"),
  Album.new(12,"Rocket Queen","6:13")]

# itera lista
puts "Album - Appetite for Destruction  - GNR\n\n"

# Itera lista
afd.each do |musicas|
  # Recupera objetos
  objeto =  musicas
  # Imprime objeto
  puts String(objeto.id).ljust(5) +
              objeto.musica.ljust(40) + objeto.duracao.rjust(5)
  
end

Um módulo é um conjunto de métodos e constantes. Os métodos em um módulo podem ser métodos de instância ou métodos do próprio módulo. Módulos também proporcionam um espaço de nomes (namespace) onde pode-se organizar o código e evitar possíveis colisões de nomenclaturas. Os métodos de instância se comportam como métodos em uma classe quando o módulo está incluído na classe, os métodos do módulo não se comportam da mesma forma. Por outro lado, os métodos de módulos podem ser chamados sem criar um objeto de encapsulamento, enquanto os métodos de instância não podem.

Module: http://www.ruby-doc.org/core-2.2.0/Module.html

Linguagens como C++ permitem que uma classe possa herdar mais de uma classe, Ruby não, entretanto existe o conceito chamado Mixing que nos permite utilizar está mesma funcionalidade através dos módulos.

Ruby - Modules - Mixing

Ruby – Modules – Mixing

Exemplo:

Neste exemplo criamos um modulo chamado Portas e um modulo chamado Janelas. A especificação de objetos Ruby não permite múltiplas heranças ou seja, não permite que minha classe chamada Casa possa herdar as classes Portas e Janelas ao mesmo tempo, no entanto existe um modo de criar esta mesma funcionalidade incluindo os módulos em minha classe.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# Mixing.rb

# Define modulo
module Portas
  
  def porta(tipo)
    puts "Portas: " + tipo       
  end
      
end

# Define modulo
module Janelas
  
  def janela(tipo)
    puts "Janelas: " + tipo
  end
  
end

# Define classe 
class Casa
  
 # Inclui modulos
 include Portas
 include Janelas
 
 def modelo(tipo, cor)
   puts "Casa ----------------->>>> 1\n\n"
   puts "Modelo:" + tipo
   puts "Cor: " + cor
 end
 
end

# Cria instancia do objeto
minhaCasa = Casa.new

# utiliza objeto
minhaCasa.modelo("Sobrado", "Branco")
minhaCasa.porta("Azul")
minhaCasa.janela("Amarelas")

A programação orientada a objetos permite que classes possam herdar estados e comportamentos comuns usados de outras classes. Neste exemplo, bicicleta torna-se agora a superclasse da classe BicicletaMontanha. Na linguagem de programação Ruby, cada classe é permitido ter uma superclasse direta, e cada superclasse tem o potencial para um número ilimitado de subclasses.

Ruby - Herança - Sobreposição - Super

Ruby – Herança – Sobreposição – Super

Override

Métodos Override (substituição), em programação orientada a objeto, é um recurso de linguagem que permite que uma subclasse ou classe filha possa fornecer uma implementação específica de um método que já é fornecido por uma de suas superclasses ou classes pai.

A implementação Override das subclasses substitui a implementação na superclasse, fornecendo um método que tem o mesmo nome, mesmos parâmetros ou assinatura, e mesmo tipo de retorno como o método na classe pai.

@ (Arroba – Ruby)

Uma variável associada ao sinal de arroba em Ruby significa uma variável da instancia ex: @variavavel.

Super

Usando super você irá chamar o mesmo método, mas, tal como definido na superclasse e consequentemente lhe fornecendo o resultado.

Exemplo:

Neste exemplo damos a classe BicicletaMontanha todos os mesmos campos e métodos da classe bicicleta, e ainda permite que seu código se concentre exclusivamente sobre as características que a tornam única. Isso faz do código de suas subclasses fáceis de ler. Usamos métodos Override neste exemplo de duas maneiras, para substituir um método da subclasse e adicionar mais um construtor com parâmetros.

No entanto, você deve tomar cuidado para documentar corretamente o estado e o comportamento que cada superclasse define, uma vez que o código não irá aparecer no arquivo de origem de cada subclasse.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# Herança.rb

# Define classe
class Bicicleta

 # Define métodos assesores
 attr_accessor :modelo, :quadro, :rodas, :freios

 # Construtor
 def initialize(modelo, quadro, rodas, freios)
   @modelo = modelo
   @quadro = quadro
   @rodas  = rodas
   @freios = freios
 end  

 # Imprime modelo
 def imprimeModelo()
   puts "Modelo : " + @modelo
   puts "Quadro: "  + @quadro
   puts "Rodas: "   + @rodas
   puts "Freios: "  + @freios
 end

end

# Classe com Herança
class BicicletaMontanha < Bicicleta

 # Novos métodos assessores
 attr_accessor :marchas, :amortecedores, :garrafa, :gps

 # Construtor da classe
 def initialize(modelo, quadro, rodas, freios, marchas, amortecedores, garrafa, gps)

   # Super inicializa construtor da herança
   super(modelo, quadro, rodas, freios)

   # Inicializa variáveis
   @marchas = marchas
   @amortecedores = amortecedores
   @garrafa = garrafa
   @gps = gps

 end

 # Método Override - sobrepõe o metodo da classe super
 def imprimeModelo()

    puts "Modelo : " + modelo
    puts "Quadro: "  + quadro
    puts "Rodas: "   + rodas
    puts "Freios: "  + freios
    puts "Marchas: " + @marchas
    puts "Amortecedores: " + @amortecedores
    puts "Garrafa: " + @garrafa
    puts "Gps: " + @gps

 end

end

# cria instancia da classe Bicicleta
bike1 = Bicicleta.new("Street", "Aço", "Ferro", "Pastilhas")
puts "Bicicleta Numero ---> 1:"
bike1.imprimeModelo()

# Cria instancia da classe BicicletaMontanha
bike2 = BicicletaMontanha.new("Montain Bike", "Carbono", "Aluminio", "Disco", "10 M",
                              "RX 3000 oil", "Aliminio 500ml", "Discovery 300xs")
puts "\nBicicleta Numero ---> 2:"
bike2.imprimeModelo()