Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with
or
.
Download ZIP
Tree: 9b591f16b3
Fetching contributors…

Cannot retrieve contributors at this time

386 lines (354 sloc) 18.693 kB
pt-BR:
remarkable:
core:
not: "não"
should: "deve"
should_not: "não deve"
example_disabled: "Exemplo desativado"
failure_message_for_should: "Esperava que {{expectation}}"
failure_message_for_should_not: "Não esperava que {{expectation}}"
helpers:
words_connector: ", "
two_words_connector: " e "
last_word_connector: " e "
action_controller:
responding: "respondendo para #{{verb}} {{action}}"
mime_type: "com {{format}}"
assign_to:
description: "assinalar {{names}}"
expectations:
assigned_value: "ação assinalasse {{name}}, nenhum assinalamento ocorreu"
is_kind_of: "valor assinalado a {{name}} fosse um tipo de {{with_kind_of}}, obtive {{assign_class}}"
is_equal_value: "valor assinalado a {{name}} fosse igual a {{with}}, obtive {{assign_inspect}}"
optionals:
with_kind_of:
positive: "com um tipo de {{value}}"
filter_params:
description: "filtre {{params}} parâmetros do log"
expectations:
respond_to_filter_params: "controller respondesse para :filter_parameters (controller não está filtrando nenhum parâmetro)"
is_filtered: "{{param}} fosse filtrado, nenhum filtro ocorreu"
redirect_to:
description: "redirecione para {{expected}}"
expectations:
redirected: "redirecionasse para {{expected}}, nenhum redirecionamento ocorreu"
status_matches: "redirecionasse para {{expected}} com status {{with}}, obtive status {{status}}"
url_matches: "redirecionasse para {{expected}}, obtive redirecionamento para {{actual}}"
optionals:
with:
positive: "com status {{inspect}}"
render_template:
description: "renderize"
expectations:
rendered: "template {{template}} fosse renderizado, nenhuma renderização ocorreu"
template_matches: "template {{template}} fosse renderizado, obtive {{actual_template}}"
layout_matches: "renderizasse com layout {{layout}}, obtive {{actual_layout}}"
status_matches: "renderizasse com status {{with}}, obtive {{actual_status}}"
body_matches: "renderizasse com conteúdo {{body}}, obtive {{actual_body}}"
content_type_matches: "renderizasse com content type {{content_type}}, obtive {{actual_content_type}}"
optionals:
template:
positive: "template {{inspect}}"
layout:
positive: "com layout {{inspect}}"
negative: "sem layout"
with:
positive: "com statys {{value}}"
body:
positive: "com conteúdo {{inspect}}"
content_type:
positive: "com content type {{inspect}}"
respond_with:
description: "responder"
expectations:
status_matches: "respondesse com status {{with}}, obtive {{actual_status}}"
body_matches: "respondesse com corpo {{body}}, obtive {{actual_body}}"
content_type_matches: "respondesse com content type {{content_type}}, obtive {{actual_content_type}}"
optionals:
with:
positive: "com {{value}}"
body:
positive: "com conteúdo {{inspect}}"
content_type:
positive: "com content type {{inspect}}"
route:
description: "tenha rotas {{method}} {{path}} de/para {{options}}"
expectations:
map_to_path: "tivesse rotas de {{options}} para {{method}} {{path}}, obtive {{actual}}"
generate_params: "criasse {{options}} de {{method}} {{path}}, obtive {{actual}}"
set_cookies:
description: "definir cookies {{keys}}"
expectations:
is_not_empty: "algum cookie ser definido, obtive {{cookies_inspect}}"
contains_value: "algum cookie ser definido para {{to}}, obtive {{cookies_inspect}}"
assigned_value: "cookie {{key}} ser definido, obtive {{cookies_inspect}}"
is_equal_value: "cookie {{key}} ser definido para {{to}}, obtive {{cookies_inspect}}"
optionals:
to:
positive: "para {{inspect}}"
negative: "para {{inspect}}"
set_session:
description: "set variável de sessão {{keys}}"
expectations:
is_not_empty: "qualquer variável de sessão fosse setada, obtive {{session_inspect}}"
contains_value: "qualquer variável de sessão fosse setada para {{to}}, obtive {{session_inspect}}"
assigned_value: "variável de sessão {{key}} fosse setada, obtive {{session_inspect}}"
is_equal_value: "variável de sessão {{key}} fosse setada para {{to}}, obtive {{session_inspect}}"
optionals:
to:
positive: "para {{inspect}}"
negative: "para {{inspect}}"
set_the_flash:
description: "setar mensagem flash {{keys}}"
expectations:
is_not_empty: "qualquer mensagem flash fosse setada, obtive {{flash_inspect}}"
contains_value: "qualquer mensagem flash fosse setada para {{to}}, obtive {{flash_inspect}}"
assigned_value: "mensagem flash {{key}} fosse setada, obtive {{flash_inspect}}"
is_equal_value: "mensagem flash {{key}} fosse setada para {{to}}, obtive {{flash_inspect}}"
optionals:
to:
positive: "para {{inspect}}"
negative: "para {{inspect}}"
active_record:
describe:
each: "{{key}} for {{value}}"
prepend: "quando "
connector: " e "
expectations:
allow_nil: "{{subject_name}} {{not}} permitisse valores nulos para {{attribute}}"
allow_blank: "{{subject_name}} {{not}} permitisse valores vazios para {{attribute}}"
optionals:
allow_nil:
positive: "permitindo valores nulos"
negative: "não permitindo valores nulos"
allow_blank:
positive: "permitindo valores vazios"
negative: "não permitindo valores vazios"
accept_nested_attributes_for:
description: "aceite attributos aninhandos para {{associations}}"
expectations:
association_exists: "{{subject_name}} tivesse associação {{association}}, mas não tem"
is_autosave: "{{subject_name}} tivesse associação {{association}} com autosave habilitado, obtive desabilitado"
responds_to_attributes: "{{subject_name}} respondesse para :{{association}}_attributes=, mas não responde"
allows_destroy: "{{subject_name}} com permissão para destruir igual a {{allow_destroy}}, obtive {{actual}}"
accepts: "{{subject_name}} to aceitasse atributos {{attributes}} para {{association}}, mas não aceita"
rejects: "{{subject_name}} to rejeitasse atributos {{attributes}} para {{association}}, mas não rejeita"
optionals:
allow_destroy:
positive: "permitindo destruição"
negative: "não permitindo destruição"
accept:
positive: "aceitando {{sentence}}"
reject:
positive: "rejeitando {{sentence}}"
allow_values_for:
description: "permitir {{in}} como valores para {{attributes}}"
expectations:
is_valid: "{{subject_name}} fosse válido quando {{attribute}} é igual a {{value}}"
allow_mass_assignment_of:
description: "permitir assinalamento em massa de {{attributes}}"
expectations:
allows: "{{subject_name}} permitisse assinalamento em massa ({{subject_name}} está protegendo {{protected_attributes}})"
is_protected: "{{subject_name}} permitisse o assinalamento em massa de {{attribute}} ({{subject_name}} está protegendo {{attribute}})"
is_accessible: "{{subject_name}} permitisse o assinalamento em massa de {{attribute}} ({{subject_name}} não tornou {{attribute}} accessível)"
negative_expectations:
allows: "{{subject_name}} permitisse assinalamento em massa ({{subject_name}} tornou {{accessible_attributes}} accessível)"
is_protected: "{{subject_name}} permitisse o assinalamento em massa de {{attribute}} ({{subject_name}} não está protegendo {{attribute}})"
is_accessible: "{{subject_name}} permitisse o assinalamento em massa de {{attribute}} ({{subject_name}} tornou {{attribute}} accessível)"
association:
belongs_to: pertencer a
has_many: possuir vários(as)
has_and_belongs_to_many: possuir e pertencer a vários(as)
has_one: possuir um(a)
description: "{{macro}} {{associations}}"
expectations:
association_exists: "{{subject_name}} pudesse {{macro}} {{association}}, mas associação não existe"
macro_matches: "{{subject_name}} pudesse {{macro}} {{association}}, obtive que {{subject_name}} deve {{actual_macro}} {{association}}"
through_exists: "{{subject_name}} pudesse {{macro}} {{association}} através de {{through}}, obtive que \"through_association\" não existe"
source_exists: "{{subject_name}} pudesse {{macro}} {{association}} através de {{through}}, obtive que \"source association\" não existe"
klass_exists: "{{subject_name}} records {{macro}} {{association}}, mas a classe da associação não existe"
join_table_exists: "tabela de junção {{join_table}} existisse, mas não existe"
foreign_key_exists: "chave estrangeira {{foreign_key}} existisse em {{foreign_key_table}}, mas não existe"
polymorphic_exists: "{{subject_table}} tivesse {{polymorphic_column}} como coluna, mas não tem"
counter_cache_exists: "{{reflection_table}} tivesse {{counter_cache_column}} como coluna, mas não tem"
options_match: "{{subject_name}} tivesse {{macro}} {{association}} com as opções {{options}}, obtive {{actual}}"
optionals:
through:
positive: "através de {{value}}"
source:
positive: "com origem {{inspect}}"
source_type:
positive: "com tipo de origem {{inspect}}"
class_name:
positive: "com nome de classe {{inspect}}"
foreign_key:
positive: "com chave estrangeira {{inspect}}"
dependent:
positive: "com dependência {{inspect}}"
join_table:
positive: "com tabela de junção {{inspect}}"
uniq:
positive: "com registros únicos"
negative: "sem registros únicos"
readonly:
positive: "com registros apenas leitura"
negative: "sem registros apenas leitura"
validate:
positive: "validando registros associados"
negative: "não validando registros associados"
autosave:
positive: "salvando automaticamente registros associados"
negative: "não salvando automaticamente registros associados"
as:
positive: "através de uma interface polimórfica {{inspect}}"
counter_cache:
positive: "com coluna de cache {{inspect}}"
negative: "sem coluna de cache"
select:
positive: "selecionando {{inspect}}"
conditions:
positive: "com condições {{inspect}}"
include:
positive: "incluindo {{inspect}}"
group:
positive: "agrupando por {{inspect}}"
having:
positive: "contendo {{inspect}}"
order:
positive: "com ordem {{inspect}}"
limit:
positive: "com limite {{inspect}}"
offset:
positive: "com offset {{inspect}}"
have_column:
description: "haver coluna(s) {{columns}}"
expectations:
column_exists: "{{subject_name}} houvesse coluna chamada {{column}}"
options_match: "{{subject_name}} houvesse coluna {{column}} com configurações {{options}}, obtive {{actual}}"
optionals:
type:
positive: "com tipo {{inspect}}"
null:
positive: "permitindo valores nulos"
negative: "não permitindo valores nulos"
default:
positive: "com valor default {{inspect}}"
negative: "com valor default {{inspect}}"
limit:
positive: "com limite {{inspect}}"
have_default_scope:
description: "haver escopo padrão com {{options}}"
expectations:
options_match: "tivesse escopo padrão {{options}}, obtive {{actual}}"
have_index:
description: "haver índice para coluna(s) {{columns}}"
expectations:
index_exists: "índice {{column}} existisse na tabela {{table_name}}"
is_unique: "índice em {{column}} com valores unicos igual a {{unique}}, obtive {{actual}}"
optionals:
unique:
positive: "com valores únicos"
negative: "sem valores únicos"
table_name:
positive: "na tabela {{value}}"
have_readonly_attributes:
description: "tornar {{attributes}} apenas leitura"
expectations:
is_readonly: "{{subject_name}} tornasse {{attribute}} apenas leitura, obtive {{actual}}"
have_scope:
description: "haver escopo {{options}} quando {{scope_name}} é chamado"
expectations:
is_scope: "{{scope_name}} quando chamado em {{subject_name}} retornasse um instância de ActiveRecord::NamedScope::Scope"
options_match: "{{scope_name}} quando chamado em {{subject_name}} houvesse escopo {{options}}, obtive {{actual}}"
optionals:
with:
positive: "com {{inspect}} como argumento"
validate_acceptance_of:
description: "exigir que {{attributes}} sejam aceitos"
expectations:
requires_acceptance: "{{subject_name}} fosse inválido se {{attribute}} não foi aceito"
accept_is_valid: "{{subject_name}} fosse válido quando {{attribute}} é aceito com valor {{accept}}"
optionals:
accept:
positive: "com valor {{inspect}}"
validate_associated:
description: "exigir que associação {{associations}} seja válida"
expectations:
is_valid: "{{subject_name}} fosse válida quando {{association}} é inválido"
validate_confirmation_of:
description: "exigir que {{attributes}} seja confirmado"
expectations:
responds_to_confirmation: "{{subject_name}} respondesse a {{attribute}}_confirmation"
confirms: "{{subject_name}} fosse válido somente quando {{attribute}} é confirmado"
validate_exclusion_of:
description: "exigir exclusão de {{attributes}} de {{in}}"
expectations:
is_valid: "{{subject_name}} fosse válido quando {{attribute}} é igual a {{value}}"
is_invalid: "{{subject_name}} fosse inválido quando {{attribute}} é igual a {{value}}"
validate_inclusion_of:
description: "exigir inclusão de {{attributes}} em {{in}}"
expectations:
is_valid: "{{subject_name}} fosse válido quando {{attribute}} é igual a {{value}}"
is_invalid: "{{subject_name}} fosse inválido quando {{attribute}} é igual a {{value}}"
validate_length_of:
description: "garantir que o tamanho de {{attributes}}"
expectations:
less_than_min_length: "{{subject_name}} fosse inválido quando tamanho de {{attribute}} é menor que {{minimum}} caracteres"
exactly_min_length: "{{subject_name}} fosse válido quando tamanho de {{attribute}} é {{minimum}} caracteres"
more_than_max_length: "{{subject_name}} fosse inválido quando tamanho de {{attribute}} é mais que {{maximum}} caracteres"
exactly_max_length: "{{subject_name}} fosse válido quando tamannho de {{attribute}} é {{maximum}} caracteres"
optionals:
within:
positive: "seja entre {{inspect}} caracteres"
maximum:
positive: "seja no máximo {{inspect}} caracteres"
minimum:
positive: "seja no mínimo {{inspect}} caracteres"
is:
positive: "seja igual a {{inspect}} caracteres"
with_kind_of:
positive: "com um tipo de {{value}}"
validate_numericality_of:
description: "permitir apenas números para {{attributes}}"
expectations:
only_numeric_values: "{{subject_name}} permitisse apenas números para {{attribute}}"
only_integer: "{{subject_name}} {{not}} permitisse somente valores inteiros para {{attribute}}"
only_even: "{{subject_name}} permitisse apenas valores pares em {{attribute}}"
only_odd: "{{subject_name}} permitisse apenas valores ímpares em {{attribute}}"
equals_to: "{{subject_name}} fosse válido quando {{attribute}} é igual a {{count}}"
more_than_maximum: "{{subject_name}} fosse inválido quando {{attribute}} é maior que {{count}}"
less_than_minimum: "{{subject_name}} fosse inválido quando {{attribute}} é menor que {{count}}"
optionals:
only_integer:
positive: "permitindo apenas valores inteiros"
odd:
positive: "permitindo apenas valores ímpares"
even:
positive: "permitindo apenas valores pares"
equal_to:
positive: "iguais a {{inspect}}"
less_than:
positive: "menores que {{inspect}}"
greater_than:
positive: "maiores que {{inspect}}"
less_than_or_equal_to:
positive: "menores ou iguais a {{inspect}}"
greater_than_or_equal_to:
positive: "maiores ou iguais a {{inspect}}"
validate_presence_of:
description: "exigir que {{attributes}} seja(m) setado(s)"
expectations:
allow_nil: "{{subject_name}} exigisse que {{attribute}} fosse setado"
validate_uniqueness_of:
description: "exigir valores únicos para {{attributes}}"
expectations:
responds_to_scope: "isntância de {{subject_name}} respondesse para {{method}}"
is_unique: "{{subject_name}} exigisse valores únicos para {{attribute}}"
case_sensitive: "{{subject_name}} {{not}} fosse case sensitive quando validando {{attribute}}"
valid_with_new_scope: "{{subject_name}} fosse válido quando {{attribute}} escopo ({{method}}) alterasse"
optionals:
scope:
positive: "com escopo {{sentence}}"
case_sensitive:
positive: "case sensitive"
negative: "case insensitive"
Jump to Line
Something went wrong with that request. Please try again.