mulang 5.3.0 → 6.0.4

data/lib/locales/pt.yml

@@ -5,17 +5,17 @@ pt:
       must_not: 'não deve'
       must: 'deve'
       solution: 'a solução'
-      with_char: ' com o caractere <i>%{value}</i>'
-      with_false: ' com o valor <i>%{keyword_False}</i>'
+      with_char: ' com o caractere <code>%{value}</code>'
+      with_false: ' com o valor <code>%{keyword_False}</code>'
       with_literal: ' com um valor literal'
       with_logic: ' com uma expressão booleana'
       with_math: ' com uma expressão matemática'
-      with_nil: ' com <i>%{keyword_nil}</i>'
+      with_nil: ' com <code>%{keyword_Nil}</code>'
       with_nonliteral: ' com uma expressão não literal'
-      with_number: ' com o número <i>%{value}</i>'
-      with_string: ' com a string <i>%{value}</i>'
-      with_symbol: ' com o símbolo <i>%{value}</i>'
-      with_true: ' com o valor <i>%{keyword_True}</i>'
+      with_number: ' com o número <code>%{value}</code>'
+      with_string: ' com a string <code>%{value}</code>'
+      with_symbol: ' com o símbolo <code>%{value}</code>'
+      with_true: ' com o valor <code>%{keyword_True}</code>'
     inspection:
       Assigns_except: '%{binding} %{must} atribuir algo diferente a %{target}%{matching}'
       Assigns_like: '%{binding} %{must} atribuir algo semelhante ao %{target}%{matching}'
@@ -47,7 +47,7 @@ pt:
       DeclaresComputationWithArity3_named: '%{target} %{must} tem três parâmetros'
       DeclaresComputationWithArity4_named: '%{target} %{must} tem quatro parâmetros'
       DeclaresComputationWithArity5_named: '%{target} %{must} tem cinco parâmetros'
-      DeclaresEntryPoint: '%{binding} %{must} declarar um <i>%{keyword_EntryPoint}</i>%{matching}'
+      DeclaresEntryPoint: '%{binding} %{must} declarar um <code>%{keyword_EntryPoint}</code>%{matching}'
       DeclaresEnumeration_except: '%{binding} %{must} declarar enumerações que não são chamadas %{target}'
       DeclaresEnumeration_like: '%{binding} %{must} declarar uma enumeração de nome semelhante a %{target}'
       DeclaresEnumeration_named: '%{binding} %{must} declarar uma enumeração %{target}'
@@ -104,26 +104,27 @@ pt:
       Delegates: '%{binding} %{must} delegar'
       DiscardsExceptions: '%{binding}  está silenciosamente ignorando exceções'
       DoesConsolePrint: '%{binding}  está fazendo impressões na tela'
-      DoesNilTest: '%{binding}  faz comparações contra <i>%{keyword_Null}</i>'
-      DoesNullTest: '%{binding}  faz comparações contra <i>%{keyword_Null}</i>'
+      DoesNilTest: '%{binding}  faz comparações contra <code>%{keyword_Nil}</code>'
+      DoesNullTest: '%{binding}  faz comparações contra <code>%{keyword_Nil}</code>'
       DoesTypeTest: '%{binding}  faz comparações contra strings'
-      HasAssignmentCondition: '%{binding} avalia o resultado de uma atribuição no qual uma expressão booleana era esperada. Talvez você queira usar o operador <i>%{operator_Equal}</i>?'
-      HasAssignmentReturn: '%{binding}  retorna o resultado de uma atribuição. Talvez você queira usar o operador <i>%{operator_Equal}</i>?'
+      HasAssignmentCondition: '%{binding} avalia o resultado de uma atribuição no qual uma expressão booleana era esperada. Talvez você queira usar o operador <code>%{operator_Equal}</code>?'
+      HasAssignmentReturn: '%{binding}  retorna o resultado de uma atribuição. Talvez você queira usar o operador <code>%{operator_Equal}</code>?'
       HasCodeDuplication: '%{binding}  tem código repetido'
       HasDeclarationTypos_named: 'A solução deve declarar %{target}, mas declara %{binding}. Você poderia ter cometido um erro de digitação?'
       HasEmptyIfBranches: '%{binding} tem uma ramificaçao %{keyword_If} vazia'
-      HasEmptyRepeat: '%{binding} tem um <i>%{keyword_Repeat}</i> vazio'
+      HasEmptyRepeat: '%{binding} tem um <code>%{keyword_Repeat}</code> vazio'
+      HasEqualIfBranches: '%{binding} possui <code>%{keyword_If}</code>s desnecessários porque seus dois ramos são iguais'
       HasLongParameterList: '%{binding} tem muitos parâmetros. Você pode estar perdendo uma abstração.'
       HasMisspelledBindings: '%{binding}  está incorreto. Verifique a ortografia e tente não usar abreviaturas'
       HasMisspelledIdentifiers: '%{binding}  está incorreto. Verifique a ortografia e tente não usar abreviaturas'
       HasRedundantBooleanComparison: '%{binding}  faz comparações booleanas desnecessárias'
       HasRedundantGuards: '%{binding}  possui protetores desnecessários'
-      HasRedundantIf: '%{binding} <i>%{keyword_If}</i> desnecessário'
+      HasRedundantIf: '%{binding} possui <code>%{keyword_If}</code>s desnecessários que podem ser substituídos por expressões booleanas'
       HasRedundantLambda: '%{binding}  possui lambdas desnecessários'
       HasRedundantLocalVariableReturn: '%{binding}  usa variáveis ​​locais desnecessárias; você pode retornar a expressão diretamente'
       HasRedundantParameter: '%{binding}  possui parâmetros desnecessários (pode ser removido por ponto-livre)'
-      HasRedundantReduction: '%{binding}  usa <i>%{keyword_Is}</i>, mas não executa cálculos'
-      HasRedundantRepeat: '%{binding} tem <i>%{keyword_Repeat}</i> desnecessário'
+      HasRedundantReduction: '%{binding}  usa <code>%{keyword_Is}</code>, mas não executa cálculos'
+      HasRedundantRepeat: '%{binding} tem <code>%{keyword_Repeat}</code> desnecessário'
       HasTooManyMethods: '%{binding} tem muitos métodos'
       HasTooShortBindings: '%{binding}  é um identificador muito curto'
       HasTooShortIdentifiers: '%{binding} é um identificador muito curto'
@@ -144,7 +145,8 @@ pt:
       Instantiates_named: '%{binding} %{must} instantiate %{target}'
       Instantiates: '%{binding} %{must} instanciar objetos'
       IsLongCode: '%{binding}  é muito longo. Tente delegar mais'
-      OverridesEqualOrHashButNotBoth: '%{binding} redefine os métodos <i>equals</i> ou <i>hash </i>, mas não ambos'
+      JavaScript#UsesVarInsteadOfLet: '% {binding} deve usar <code>let</code> em vez de <code>var</code>'
+      OverridesEqualOrHashButNotBoth: '%{binding} redefine os métodos <code>equals</code> ou <code>hash </code>, mas não ambos'
       Raises_except: '%{binding} %{must} lançar exceções diferentes de %{target}'
       Raises_like: '%{binding} %{must} lançar exceções semelhantes a %{target}'
       Raises_named: '%{binding} %{must} launch %{target}'
@@ -156,9 +158,10 @@ pt:
       Returns: '%{binding} %{must} retornar%{matching}'
       ReturnsNil: '%{binding}  retorna nulo, o que é uma prática ruim'
       ReturnsNull: '%{binding}  retorna nulo, o que é uma prática ruim'
-      ShouldInvertIfCondition: '%{binding} deve inverter a condição da <i>%{keyword_If}</i> e trocar as ramos'
+      ShouldInvertIfCondition: '%{binding} deve inverter a condição da <code>%{keyword_If}</code> e trocar as ramos'
+      ShouldUseStrictComparators: '%{binding} deve usar os operadores de equivalência <code>%{operator_Equal}</code> e <code>%{operator_NotEqual}</code> em vez dos operadores de similaridade <code>%{operator_Similar}</code> e <code>%{operator_NotSimilar}</code> '
       SubordinatesDeclarationsTo: 'Todas as declarações em %{binding} %{must} ser usadas a partir de %{target}'
-      SubordinatesDeclarationsToEntryPoint: 'Todas as declarações em %{binding} %{must} devem ser usadas a partir de <i>%{keyword_EntryPoint}</i>'
+      SubordinatesDeclarationsToEntryPoint: 'Todas as declarações em %{binding} %{must} devem ser usadas a partir de <code>%{keyword_EntryPoint}</code>'
       TypesAs_named: '%{binding} %{must} é do tipo %{target}'
       TypesAs: '%{binding} %{must} tem tipo'
       TypesReturnAs_named: '%{binding} %{must} tem tipo de valor de retorno %{target}'
@@ -167,59 +170,36 @@ pt:
       Uses_like: '%{binding} %{must} delegar algo semelhante ao %{target}'
       Uses_named: '%{binding} %{must} usar %{target}'
       Uses: '%{binding} %{must} delegar'
-      UsesAnd: '%{binding} %{must} utilizar <i>%{operator_And}</i>'
       UsesAnonymousVariable: '%{binding} %{must} usar uma variável anônima'
-      UsesBackwardComposition: '%{binding} %{must} utilizar <i>%{operator_BackwardComposition}</i>'
-      UsesBitwiseAnd: '%{binding} %{must} utilizar <i>%{operator_BitwiseAnd}</i>'
-      UsesBitwiseLeftShift: '%{binding} %{must} utilizar <i>%{operator_BitwiseLeftShift}</i>'
-      UsesBitwiseOr: '%{binding} %{must} utilizar <i>%{operator_BitwiseOr}</i>'
-      UsesBitwiseRightShift: '%{binding} %{must} utilizar <i>%{operator_BitwiseRightShift}</i>'
-      UsesBitwiseXor: '%{binding} %{must} utilizar <i>%{operator_BitwiseXor}</i>'
       UsesComposition: '%{binding} %{must} usar a composição'
       UsesComprehension: '%{binding} %{must} usar listas pelo entendimento'
       UsesConditional: '%{binding} %{must} usar conditional'
       UsesCut: '%{binding}  usa o operador !, que é uma má prática'
-      UsesDivide: '%{binding} %{must} utilizar <i>%{operator_Divide}</i>'
-      UsesDyamicPolymorphism: '%{binding} %{must} usar polimorfismo'
+      UsesDynamicPolymorphism: '%{binding} %{must} usar polimorfismo'
       UsesDynamicMethodOverload: '%{binding} %{must} usar sobrecarga'
-      UsesEqual: '%{binding} %{must} utilizar <i>%{operator_Equal}</i>'
       UsesExceptionHandling: '%{binding} %{must} executar o tratamento de exceção'
       UsesExceptions: '%{binding} %{must} usar exceções'
-      UsesFail: '%{binding}  usa <i>%{keyword_Fail}</li>, o que é uma prática ruim'
-      UsesFindall: '%{binding} %{must} usar <i>%{keyword_findall}</i>'
-      UsesFor: '%{binding} %{must} usar <i>%{keyword_For}</i>%{matching}'
-      UsesForall: '%{binding} %{must} usar <i>%{keyword_Forall}</i>'
-      UsesForeach: '%{binding} %{must} usar <i>%{keyword_Foreach}</i>%{matching}'
-      UsesForwardComposition: '%{binding} %{must} utilizar <i>%{operator_ForwardComposition}</i>'
-      UsesGreatherOrEqualThan: '%{binding} %{must} utilizar <i>%{operator_GreatherOrEqualThan}</i>'
-      UsesGreatherThan: '%{binding} %{must} utilizar <i>%{operator_GreatherThan}</i>'
+      UsesFail: '%{binding}  usa <code>%{keyword_Fail}</li>, o que é uma prática ruim'
+      UsesFindall: '%{binding} %{must} usar <code>%{keyword_Findall}</code>'
+      UsesFor: '%{binding} %{must} usar <code>%{keyword_For}</code>%{matching}'
+      UsesForall: '%{binding} %{must} usar <code>%{keyword_Forall}</code>'
+      UsesForeach: '%{binding} %{must} usar <code>%{keyword_ForEach}</code>%{matching}'
       UsesGuards: '%{binding} %{must} usar guardas%{matching}'
-      UsesHash: '%{binding} %{must} utilizar <i>%{operator_Hash}</i>'
-      UsesIf: '%{binding} %{must} usar <i>%{keyword_If}</i>%{matching}'
+      UsesIf: '%{binding} %{must} usar <code>%{keyword_If}</code>%{matching}'
       UsesInheritance: '%{binding} %{must} usar herança'
       UsesLambda: '%{binding} %{must} usar expressões lambda%{matching}'
-      UsesLessOrEqualThan: '%{binding} %{must} utilizar <i>%{operator_LessOrEqualThan}</i>'
-      UsesLessThan: '%{binding} %{must} utilizar <i>%{operator_LessThan}</i>'
       UsesLogic: '%{binding} %{must} usar operadores booleanos'
       UsesLoop: '%{binding} %{must} usar um loop%{matching}'
       UsesMath: '%{binding} %{must} usar expressões matemáticas'
-      UsesMinus: '%{binding} %{must} utilizar <i>%{operator_Minus}</i>'
       UsesMixins: '%{binding} %{must} usar mixins'
-      UsesModulo: '%{binding} %{must} utilizar <i>%{operator_Modulo}</i>'
-      UsesMultiply: '%{binding} %{must} utilizar <i>%{operator_Multiply}</i>'
-      UsesNegation: '%{binding} %{must} utilizar <i>%{operator_Negation}</i>'
-      UsesNot: '%{binding} %{must} usar <i>%{keyword_Not}</i>'
-      UsesNotEqual: '%{binding} %{must} utilizar <i>%{operator_NotEqual}</i>'
+      UsesNot: '%{binding} %{must} usar <code>%{keyword_Not}</code>'
       UsesObjectComposition: '%{binding} %{must} usar composição'
-      UsesOr: '%{binding} %{must} utilizar <i>%{operator_Or}</i>'
-      UsesOtherwise: '%{binding} %{must} utilizar <i>%{operator_Otherwise}</i>'
       UsesPatternMatching: '%{binding} %{must} usar o padrão de correspondência'
-      UsesPlus: '%{binding} %{must} utilizar <i>%{operator_Plus}</i>'
-      UsesRepeat: '%{binding} %{must} usar <i>%{keyword_Repeat}</i>%{matching}'
-      UsesRepeatOf: '%{binding} %{must} usar uma <i>%{keyword_Repeat}</i> de %{target}'
+      UsesRepeat: '%{binding} %{must} usar <code>%{keyword_Repeat}</code>%{matching}'
+      UsesRepeatOf: '%{binding} %{must} usar uma <code>%{keyword_Repeat}</code> de %{target}'
       UsesStaticMethodOverload: '%{binding} %{must} usar sobrecarga'
       UsesStaticPolymorphism: '%{binding} %{must} usar polimorfismo'
-      UsesSwitch: '%{binding} %{must} usar um <i>%{keyword_Switch}</i>'
+      UsesSwitch: '%{binding} %{must} usar um <code>%{keyword_Switch}</code>'
       UsesTemplateMethod: '%{binding} %{must} usar um _template method_'
       UsesUnificationOperator: '%{binding}  usa o operador de unificação (=)'
-      UsesWhile: '%{binding} %{must} usar um <i>%{keyword_While}</i>%{matching}'
+      UsesWhile: '%{binding} %{must} usar um <code>%{keyword_While}</code>%{matching}'

data/lib/mulang.rb

@@ -9,16 +9,65 @@ module Mulang
   def self.bin_path
     File.join(__dir__, '..', 'bin', 'mulang')
   end
-  def self.analyse(analysis)
-    Open3.popen2(bin_path, '-s') do |input, output, _thread|
-      input.puts analysis.to_json
+  def self.analyse(analysis, **options)
+    arg, mode = Mulang::RunMode.for analysis, options
+    Open3.popen2(bin_path, arg) do |input, output, _thread|
+      input.puts mode.input(analysis).to_json
       input.close
-      JSON.parse output.read
+      result = JSON.parse output.read
+      mode.output result
+    end
+  end
+
+  private
+
+  module RunMode
+    def self.for(analysis, options)
+      serialization = options[:serialization]
+      many = analysis.is_a?(Array)
+      if many
+        [encode_serialization(serialization), Mulang::RunMode::Natural]
+      elsif serialization
+        [encode_serialization(serialization), Mulang::RunMode::ForcedMany]
+      else
+        ["-s", Mulang::RunMode::Natural]
+      end
+    end
+
+    def self.encode_serialization(option)
+      case option
+      when nil then '-S'
+      when :bracket then '-B'
+      when :brace then '-C'
+      else raise "Unsupported serialization #{option}"
+      end
+    end
+
+    module Natural
+      def self.input(analysis)
+        analysis
+      end
+
+      def self.output(result)
+        result
+      end
+    end
+
+    module ForcedMany
+      def self.input(analysis)
+        [analysis]
+      end
+
+      def self.output(result)
+        result[0]
+      end
     end
   end
 end
 
+require_relative './mulang/tokens'
 require_relative './mulang/inspection'
 require_relative './mulang/expectation'
 require_relative './mulang/code'
 require_relative './mulang/language'
+require_relative './mulang/sexp'

data/lib/mulang/code.rb

@@ -1,24 +1,41 @@
 module Mulang
   class Code
+    attr_accessor :language, :content
     def initialize(language, content)
       @language = language
       @content  = content
     end
 
-    def ast
-      @language.ast @content
+    def identifiers(**options)
+      @language.identifiers @content, **options
+    end
+
+    def ast(**options)
+      @language.ast @content, **options
+    end
+
+    def ast_analysis(**options)
+      @language.ast_analysis @content, **options
+    end
+
+    def transformed_asts(operations, **options)
+      @language.transformed_asts @content, operations, **options
+    end
+
+    def transformed_asts_analysis(operations, **options)
+      @language.transformed_asts_analysis @content, operations, **options
     end
 
     def sample
       @language.sample @content
     end
 
-    def analysis(spec)
-      { sample: sample, spec: spec }
+    def analysis(spec, **options)
+      @language.build_analysis @content, spec, **options
     end
 
-    def analyse(spec)
-      Mulang.analyse analysis(spec)
+    def analyse(spec, **options)
+      Mulang.analyse analysis(spec), **options
     end
 
     def expect(binding='*', inspection)
@@ -43,12 +60,25 @@ module Mulang
       native(*args).tap { |it| it.expect('Parses') }
     end
 
-    def self.external(content, &tool)
-      new Mulang::Language::External.new(&tool), content
+    def self.external(language_name = nil, content, &tool)
+      new Mulang::Language::External.new(language_name, &tool), content
+    end
+
+    def self.analyse_many(codes, spec, **options)
+      run_many(codes, **options) { |it| it.analysis(spec)  }
+    end
+
+    def self.ast_many(codes, **options)
+      run_many(codes, key: 'outputAst', **options) { |it| it.ast_analysis(**options) }
+    end
+
+    def self.transformed_asts_many(codes, operations, **options)
+      run_many(codes, key: 'transformedAsts', **options) { |it| it.transformed_asts_analysis(operations, **options) }
     end
 
-    def self.ast(ast)
-      new Mulang::Language::External.new, ast
+    def self.run_many(codes, key: nil, **options)
+      result = Mulang.analyse(codes.map { |it| yield it }, **options)
+      key ? result.map { |it| it[key] } : result
     end
 
     private

data/lib/mulang/expectation.rb

@@ -1,48 +1,78 @@
 module Mulang::Expectation
-  SMELLS = %w(
-    DiscardsExceptions
-    DoesConsolePrint
+  LOGIC_SMELLS = %w(
+    HasRedundantReduction
+    UsesCut
+    UsesFail
+    UsesUnificationOperator
+  )
+
+  FUNCTIONAL_SMELLS = %w(
+    HasRedundantGuards
+    HasRedundantParameter
+    ShouldUseOtherwise
+  )
+
+  OBJECT_ORIENTED_SMELLS = %w(
     DoesNilTest
     DoesNullTest
+    HasTooManyMethods
+    OverridesEqualOrHashButNotBoth
+    ReturnsNil
+    ReturnsNull
     DoesTypeTest
-    HasAssignmentReturn
+  )
+
+  IMPERATIVE_SMELLS = %w(
     HasAssignmentCondition
+    HasAssignmentReturn
+    HasEmptyRepeat
+    HasRedundantRepeat
+  )
+
+  EXPRESSIVENESS_SMELLS = %w(
+    HasMisspelledBindings
+    HasMisspelledIdentifiers
+    HasTooShortIdentifiers
+    HasWrongCaseBinding
+    HasWrongCaseIdentifiers
+  )
+
+  GENERIC_SMELLS = %w(
+    DiscardsExceptions
+    DoesConsolePrint
     HasCodeDuplication
     HasDeclarationTypos
     HasEmptyIfBranches
-    HasEmptyRepeat
+    HasEqualIfBranches
     HasLongParameterList
-    HasMisspelledBindings
-    HasMisspelledIdentifiers
     HasRedundantBooleanComparison
-    HasRedundantGuards
+    HasRedundantLocalVariableReturn
     HasRedundantIf
     HasRedundantLambda
-    HasRedundantLocalVariableReturn
-    HasRedundantParameter
-    HasRedundantReduction
-    HasRedundantRepeat
-    HasTooManyMethods
     HasTooShortBindings
-    HasTooShortIdentifiers
     HasUnreachableCode
     HasUsageTypos
-    HasWrongCaseBinding
-    HasWrongCaseIdentifiers
     IsLongCode
-    OverridesEqualOrHashButNotBoth
-    ReturnsNil
-    ReturnsNull
     ShouldInvertIfCondition
-    ShouldUseOtherwise
-    UsesCut
-    UsesFail
-    UsesUnificationOperator)
+    ShouldUseStrictComparators
+  )
+
+  JAVA_SCRIPT_SMELLS = %w(
+    JavaScript#UsesVarInsteadOfLet
+  )
+
+  SMELLS = GENERIC_SMELLS +
+           EXPRESSIVENESS_SMELLS +
+           IMPERATIVE_SMELLS +
+           OBJECT_ORIENTED_SMELLS +
+           FUNCTIONAL_SMELLS +
+           LOGIC_SMELLS +
+           JAVA_SCRIPT_SMELLS
 
   def self.guess_type(expectation)
     if expectation[:binding] == '<<custom>>'
       Custom
-    elsif expectation[:inspection] =~ /(Not\:)?Has.*/ && !has_smell?(expectation[:inspection])
+    elsif expectation[:inspection] =~ /^(Not\:)?Has.*/ && !has_smell?(expectation[:inspection])
       V0
     else
       V2

data/lib/mulang/expectation/i18n.rb

@@ -1,47 +1,5 @@
 module Mulang::Expectation::I18n
   class << self
-    DEFAULT_TOKENS = {
-      keyword_EntryPoint: 'program',
-      keyword_Fail: 'fail',
-      keyword_False: 'false',
-      keyword_findall: 'findall',
-      keyword_For: 'for',
-      keyword_Forall: 'forall',
-      keyword_Foreach: 'foreach',
-      keyword_If: 'if',
-      keyword_Is: 'is',
-      keyword_Not: 'not',
-      keyword_Null: 'null',
-      keyword_Repeat: 'repeat',
-      keyword_Switch: 'switch',
-      keyword_True: 'true',
-      keyword_While: 'while',
-      keyword_Yield: 'yield',
-      operator_And: '&&',
-      operator_BackwardComposition: '.',
-      operator_Divide: '/',
-      operator_Equal: '==',
-      operator_ForwardComposition: '>>',
-      operator_GreatherOrEqualThan: '>=',
-      operator_GreatherThan: '>',
-      operator_Hash: 'hash',
-      operator_LessOrEqualThan: '<=',
-      operator_LessThan: '<',
-      operator_Minus: '-',
-      operator_Multiply: '*',
-      operator_Negation: '!',
-      operator_NotEqual: '!=',
-      operator_Or: '||',
-      operator_Otherwise: 'otherwise',
-      operator_Plus: '+',
-      operator_Modulo: '%',
-      operator_BitwiseOr: '|',
-      operator_BitwiseAnd: '&',
-      operator_BitwiseXor: '^',
-      operator_BitwiseLeftShift: '<<',
-      operator_BitwiseRightShift: '>>'
-    }.transform_values { |v| CGI::escapeHTML(v) }.freeze
-
     def translate(e, tokens = nil)
       translate!(e, tokens)
     rescue
@@ -71,7 +29,7 @@ module Mulang::Expectation::I18n
     end
 
     def t_binding(binding)
-      binding == '*' ? ::I18n.t("mulang.expectation.solution") : "<strong>#{Mulang::Inspection.parse_binding_name binding}</strong>"
+      binding == '*' ? ::I18n.t("mulang.expectation.solution") : "<code>#{Mulang::Inspection.parse_binding_name binding}</code>"
     end
 
     def t_must(parsed)
@@ -79,7 +37,7 @@ module Mulang::Expectation::I18n
     end
 
     def t_target(parsed)
-      "<strong>#{parsed.target.value}</strong>" if parsed.target
+      "<code>#{parsed.target.value}</code>" if parsed.target
     end
 
     def t_matching(tokens, parsed)
@@ -87,7 +45,15 @@ module Mulang::Expectation::I18n
     end
 
     def with_tokens(tokens, params)
-      params.merge(DEFAULT_TOKENS).merge(tokens || {})
+      hash = if tokens.nil?
+        {}
+      elsif tokens.is_a?(Hash)
+        tokens
+      else
+        params.merge(Mulang::Tokens::TOKENS.indifferent_get(tokens))
+      end
+
+      params.merge(Mulang::Tokens::DEFAULT_TOKENS.merge(hash))
     end
   end
 end