mumukit-inspection 1.0.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 37ba721a6cd491b18b1f0ec7924890f7f6936206
-  data.tar.gz: b4051e47c4cabbc716b1f6fb3af7114b43ff649e
+  metadata.gz: 862d0aaea9f5338ca16507bc3f564870f093ecf4
+  data.tar.gz: bb8724791a6303e935aaef57cfa6fe1ba79ee589
 SHA512:
-  metadata.gz: 69cd4dc30948d74cc61617a6e395982bbd4e86698b645a45e2552c29bbe3b7e25057095c0fa6b6f792842f23a44b3d6513f190111d226c50807a2cfa0ceee31b
-  data.tar.gz: 48cb12f074367c4647f01a3a63c29ac42aba9869165f8dd114f950f4de1bbc83838de751a2cb9265e9ef273e6dd94d1e1138c60b8bde1d01e104f6a5d713e490
+  metadata.gz: 2c47373f1be4e7b0b4324d0c5e0f9b50a861b9b3e825fcb0422276744fec26a8a40d8b9ef076ace3ad5654019a847fa75b85df289760e6365c875f2d8faa76bd
+  data.tar.gz: 5db7fe22cbf62ce8a682de124b213362456e67b79081927863d69396961ad4beb4ac105a0aeeec189cfc718350e06d790ca5c374c15f9f6fb7be33024658e9db

data/lib/locales/en.yml

@@ -1,27 +1,108 @@
 ---
 en:
-  expectation_DoesTypeTest: '%{binding} has redundant string comparisons'
-  expectation_HasArity: '%{binding} %{must} have %{target} parameters'
-  expectation_HasBinding: '%{binding} %{must} be defined'
-  expectation_HasComposition: '%{binding} %{must} use composition'
-  expectation_HasComprehension: '%{binding} %{must} use list comprehensions'
-  expectation_HasConditional: '%{binding} %{must} use conditionals'
-  expectation_HasDirectRecursion: '%{binding} %{must} use recursion'
-  expectation_HasForeach: '%{binding} %{must} use an indexed repetition (<i>foreach</i> statement)'
-  expectation_HasGuards: '%{binding} %{must} use guards'
-  expectation_HasIf: '%{binding} %{must} use if'
-  expectation_HasLambda: '%{binding} %{must} use lambda expressions'
-  expectation_HasRedundantBooleanComparison: '%{binding} has redundant boolean comparisons'
-  expectation_HasRedundantGuards: '%{binding} has redundant guards'
-  expectation_HasRedundantIf: '%{binding} has redundant ifs'
-  expectation_HasRedundantLambda: '%{binding} has redundant lambdas'
-  expectation_HasRedundantParameter: '%{binding} has redundant parameters - you may avoid them using point-free'
-  expectation_HasRepeat: '%{binding} %{must} use a simple repetition (<i>repeat</i> statement)'
-  expectation_HasRepeatOf: '%{binding} %{must} use a simple repetition (<i>repeat</i> sentence) of %{target}'
-  expectation_HasTypeDeclaration: type %{binding} %{must} be defined
-  expectation_HasTypeSignature: Signature for %{binding} %{must} be declared
-  expectation_HasUsage: '%{binding} %{must} use %{target}'
-  expectation_HasVariable: '%{binding} %{must} use variables'
-  expectation_HasWhile: '%{binding} %{must} use conditional repetition (<i>while</i> statement)'
+  expectation_Declares: '%{binding} %{must} contain declarations'
+  expectation_Declares_except: '%{binding} %{must} contain declarations distinct from %{target}'
+  expectation_Declares_like: '%{binding} %{must} declare an identifier similar to %{target}'
+  expectation_Declares_named: '%{binding} %{must} declare %{target}'
+  expectation_DeclaresAttribute: '%{binding} %{must} declare attributes'
+  expectation_DeclaresAttribute_except: '%{binding} %{must} declare attributes distinct from %{target}'
+  expectation_DeclaresAttribute_like: '%{binding} %{must} declare an attribute similar to %{target}'
+  expectation_DeclaresAttribute_named: '%{binding} %{must} declare an attribute %{target}'
+  expectation_DeclaresClass: '%{binding} %{must} declare classes'
+  expectation_DeclaresClass_except: '%{binding} %{must} declare classes distinct from %{target}'
+  expectation_DeclaresClass_like: '%{binding} %{must} declare a class similar to %{target}'
+  expectation_DeclaresClass_named: '%{binding} %{must} declare a class %{target}'
+  expectation_DeclaresComputation: '%{binding} %{must} declare computations'
+  expectation_DeclaresComputation_except: '%{binding} %{must} declare computations distinct from %{target}'
+  expectation_DeclaresComputation_like: '%{binding} %{must} declare a computation similar to %{target}'
+  expectation_DeclaresComputation_named: '%{binding} %{must} declare a computation %{target}'
+  expectation_DeclaresComputationWithArity0_named: '%{target} %{must} have zero parameters'
+  expectation_DeclaresComputationWithArity1_named: '%{target} %{must} have one parameter'
+  expectation_DeclaresComputationWithArity2_named: '%{target} %{must} have 2 parameters'
+  expectation_DeclaresComputationWithArity3_named: '%{target} %{must} have 3 parameters'
+  expectation_DeclaresComputationWithArity4_named: '%{target} %{must} have 4 parameters'
+  expectation_DeclaresComputationWithArity5_named: '%{target} %{must} have 5 parameters'
+  expectation_DeclaresEntryPoint: '%{binding} %{must} declare an entry point'
+  expectation_DeclaresFact: '%{binding} %{must} declare facts'
+  expectation_DeclaresFact_except: '%{binding} %{must} declare facts distinct from %{target}'
+  expectation_DeclaresFact_like: '%{binding} %{must} declare a fact similar to %{target}'
+  expectation_DeclaresFact_named: '%{binding} %{must} declare a fact %{target}'
+  expectation_DeclaresFunction: '%{binding} %{must} debe declare functions'
+  expectation_DeclaresFunction_except: '%{binding} %{must} declare functions distinct from %{target}'
+  expectation_DeclaresFunction_like: '%{binding} %{must} declare a function similar to %{target}'
+  expectation_DeclaresFunction_named: '%{binding} %{must} declare a function %{target}'
+  expectation_DeclaresMethod: '%{binding} %{must} declare methods'
+  expectation_DeclaresMethod_except: '%{binding} %{must} declare methods distinct from %{target}'
+  expectation_DeclaresMethod_like: '%{binding} %{must} declare a method similar to %{target}'
+  expectation_DeclaresMethod_named: '%{binding} %{must} declare a method %{target}'
+  expectation_DeclaresObject: '%{binding} %{must} declare objects'
+  expectation_DeclaresObject_except: '%{binding} %{must} declare objects distinct from %{target}'
+  expectation_DeclaresObject_like: '%{binding} %{must} declare an object similar to %{target}'
+  expectation_DeclaresObject_named: '%{binding} %{must} declare an object %{target}'
+  expectation_DeclaresPredicate: '%{binding} %{must} declare predicates'
+  expectation_DeclaresPredicate_except: '%{binding} %{must} declare a predicate distinct from %{target}'
+  expectation_DeclaresPredicate_like: '%{binding} %{must} declare a predicate similar to %{target}'
+  expectation_DeclaresPredicate_named: '%{binding} %{must} declare predicates %{target}'
+  expectation_DeclaresProcedure: '%{binding} %{must} declare procedures'
+  expectation_DeclaresProcedure_except: '%{binding} %{must} declare procedures distinct from %{target}'
+  expectation_DeclaresProcedure_like: '%{binding} %{must} declare a procedure similar to %{target}'
+  expectation_DeclaresProcedure_named: '%{binding} %{must} declare a procedure %{target}'
+  expectation_DeclaresRecursively_named: '%{target} %{must} declared recursively'
+  expectation_DeclaresRule: '%{binding} %{must} debe declare rules'
+  expectation_DeclaresRule_except: '%{binding} %{must} declare rules distinct from %{target}'
+  expectation_DeclaresRule_like: '%{binding} %{must} declare a rule similar to %{target}'
+  expectation_DeclaresRule_named: '%{binding} %{must} declare a rule %{target}'
+  expectation_DeclaresTypeAlias: '%{binding} %{must} declare type aliases'
+  expectation_DeclaresTypeAlias_except: '%{binding} %{must} declare type aliases distinct from %{target}'
+  expectation_DeclaresTypeAlias_like: '%{binding} %{must} declare a type alias similar to %{target}'
+  expectation_DeclaresTypeAlias_named: '%{binding} %{must} declare a type alias %{target}'
+  expectation_DeclaresTypeSignature: '%{binding} %{must} decarar type signatures'
+  expectation_DeclaresTypeSignature_except: '%{binding} %{must} declare a type signature distinct from %{target}'
+  expectation_DeclaresTypeSignature_like: '%{binding} %{must} declare a type signature for something like %{target}'
+  expectation_DeclaresTypeSignature_named: '%{binding} %{must} declare a type signature %{target}'
+  expectation_DeclaresVariable: '%{binding} %{must} debe declare variables'
+  expectation_DeclaresVariable_except: '%{binding} %{must} declare variables distinct from %{target}'
+  expectation_DeclaresVariable_like: '%{binding} %{must} declare a variable similar to %{target}'
+  expectation_DeclaresVariable_named: '%{binding} %{must} declare a variable %{target}'
+  expectation_DoesNullTest: '%{binding} does null tests'
+  expectation_DoesTypeTest: '%{binding} string type tests'
+  expectation_HasAssignmentReturn: '%{binding} returns the result of an assignment'
+  expectation_HasCodeDuplication: '%{binding} has code duplication'
+  expectation_HasMisspelledBindings: '%{binding} is misspelled'
+  expectation_HasRedundantBooleanComparison: '%{binding} makes unnecesary boolean comparisons'
+  expectation_HasRedundantGuards: '%{binding} has unnecessary guards'
+  expectation_HasRedundantIf: '%{binding} has unnecessary ifs'
+  expectation_HasRedundantLambda: '%{binding} has unnecessary lambdas'
+  expectation_HasRedundantLocalVariableReturn: '%{binding} has unnecesary local variables; please try returning the expression directly'
+  expectation_HasRedundantParameter: '%{binding} has unnecessary parameters, that can be removed using point-free'
+  expectation_HasRedundantReduction: '%{binding} uses <i>is</i>, but it does not artihmetic.'
+  expectation_HasTooShortBindings: '%{binding} is a too short identifier'
+  expectation_HasWrongCaseBindings: '%{binding} does not honor case conventions'
+  expectation_IsLongCode: '%{binding} is too long'
   expectation_must: must
   expectation_must_not: must not
+  expectation_ReturnsNull: '%{binding} retuns null, which is a bad practice'
+  expectation_solution: solution
+  expectation_Uses: '%{binding} %{must} delegate'
+  expectation_Uses_except: '%{binding} %{must} delegate to something distinct from %{target}'
+  expectation_Uses_like: '%{binding} %{must} delegate to something similar to %{target}'
+  expectation_Uses_named: '%{binding} %{must} use %{target}'
+  expectation_UsesAnonymousVariable: '%{binding} %{must} use an annonymous variable'
+  expectation_UsesComposition: '%{binding} %{must} use composition'
+  expectation_UsesComprehension: '%{binding} %{must} use comprehensions'
+  expectation_UsesConditional: '%{binding} %{must} use conditionals'
+  expectation_UsesCut: '%{binding} uses <i>!</li> operator, which is a bad practice'
+  expectation_UsesFail: '%{binding} uses <i>fail</li>, which is a bad practice'
+  expectation_UsesFindall: '%{binding} %{must} use findall'
+  expectation_UsesForall: '%{binding} %{must} use forall'
+  expectation_UsesForeach: '%{binding} %{must} use foreach'
+  expectation_UsesGuards: '%{binding} %{must} use guards'
+  expectation_UsesIf: '%{binding} %{must} use if'
+  expectation_UsesLambda: '%{binding} %{must} use lambda expressions'
+  expectation_UsesNot: '%{binding} %{must} use not'
+  expectation_UsesPatternMatching: '%{binding} %{must} use pattern matching'
+  expectation_UsesRepeat: '%{binding} %{must} use repeat'
+  expectation_UsesRepeatOf: '%{binding} %{must} use repeat'
+  expectation_UsesSwitch: '%{binding} %{must} use a switch'
+  expectation_UsesUnificationOperator: '%{binding} uses the unification operator (=)'
+  expectation_UsesWhile: '%{binding} %{must} use while'

data/lib/locales/es.yml

@@ -1,27 +1,108 @@
 ---
 es:
-  expectation_DoesTypeTest: '%{binding} hace comparaciones de strings innecesarias'
-  expectation_HasArity: '%{binding} %{must} tener %{target} parámetros'
-  expectation_HasBinding: '%{binding} %{must} estar definido'
-  expectation_HasComposition: '%{binding} %{must} usar composición'
-  expectation_HasComprehension: '%{binding} %{must} emplear listas por comprensión'
-  expectation_HasConditional: '%{binding} %{must} utilizar condicionales (guardas/if)'
-  expectation_HasDirectRecursion: '%{binding} %{must} emplear recursión'
-  expectation_HasForeach: '%{binding} %{must} usar una repetición indexada (sentencia <i>foreach</i>)'
-  expectation_HasGuards: '%{binding} %{must} usar guardas'
-  expectation_HasIf: '%{binding} %{must} usar if'
-  expectation_HasLambda: '%{binding} %{must} emplear expresiones lambda'
+  expectation_Declares: '%{binding} %{must} contener declaraciones'
+  expectation_Declares_except: '%{binding} %{must} contener declaraciones distintas a %{target}'
+  expectation_Declares_like: '%{binding} %{must} declarar un identificador parecido a %{target}'
+  expectation_Declares_named: '%{binding} %{must} declarar %{target}'
+  expectation_DeclaresAttribute: '%{binding} %{must} declarar atributos'
+  expectation_DeclaresAttribute_except: '%{binding} %{must} declarar atributos diferentes a %{target}'
+  expectation_DeclaresAttribute_like: '%{binding} %{must} declarar un atributo parecido a %{target}'
+  expectation_DeclaresAttribute_named: '%{binding} %{must} declarar un atributo %{target}'
+  expectation_DeclaresClass: '%{binding} %{must} declarar clases'
+  expectation_DeclaresClass_except: '%{binding} %{must} declarar clases diferentes a %{target}'
+  expectation_DeclaresClass_like: '%{binding} %{must} declarar una clase parecida a %{target}'
+  expectation_DeclaresClass_named: '%{binding} %{must} declarar una clase %{target}'
+  expectation_DeclaresComputation: '%{binding} %{must} declarar computaciones'
+  expectation_DeclaresComputation_except: '%{binding} %{must} declarar computaciones diferentes a %{target}'
+  expectation_DeclaresComputation_like: '%{binding} %{must} declarar una computación parecida a %{target}'
+  expectation_DeclaresComputation_named: '%{binding} %{must} declarar una computación %{target}'
+  expectation_DeclaresComputationWithArity0_named: '%{target} %{must} declarar cero parametros'
+  expectation_DeclaresComputationWithArity1_named: '%{target} %{must} tener un parámetro'
+  expectation_DeclaresComputationWithArity2_named: '%{target} %{must} tener dos parámetros'
+  expectation_DeclaresComputationWithArity3_named: '%{target} %{must} tener tres parámetros'
+  expectation_DeclaresComputationWithArity4_named: '%{target} %{must} tener cuatro parámetros'
+  expectation_DeclaresComputationWithArity5_named: '%{target} %{must} tener cinco parámetros'
+  expectation_DeclaresEntryPoint: '%{binding} %{must} declarar un punto de entrada'
+  expectation_DeclaresFact: '%{binding} %{must} declarar hechos'
+  expectation_DeclaresFact_except: '%{binding} %{must} declarar hechos diferentes a %{target}'
+  expectation_DeclaresFact_like: '%{binding} %{must} declarar un hecho parecido a %{target}'
+  expectation_DeclaresFact_named: '%{binding} %{must} declarar un hecho %{target}'
+  expectation_DeclaresFunction: '%{binding} %{must} debe declarar funciones'
+  expectation_DeclaresFunction_except: '%{binding} %{must} declarar funciones diferentes a %{target}'
+  expectation_DeclaresFunction_like: '%{binding} %{must} declarar una función parecida a %{target}'
+  expectation_DeclaresFunction_named: '%{binding} %{must} declarar una función %{target}'
+  expectation_DeclaresMethod: '%{binding} %{must} declarar métodos'
+  expectation_DeclaresMethod_except: '%{binding} %{must} declarar métodos diferentes a %{target}'
+  expectation_DeclaresMethod_like: '%{binding} %{must} declarar un método parecido a %{target}'
+  expectation_DeclaresMethod_named: '%{binding} %{must} declarar un método %{target}'
+  expectation_DeclaresObject: '%{binding} %{must} declarar objetos'
+  expectation_DeclaresObject_except: '%{binding} %{must} declarar objetos diferentes a %{target}'
+  expectation_DeclaresObject_like: '%{binding} %{must} declarar un objeto parecido a%{target}'
+  expectation_DeclaresObject_named: '%{binding} %{must} declarar un objeto %{target}'
+  expectation_DeclaresPredicate: '%{binding} %{must} declarar predicados'
+  expectation_DeclaresPredicate_except: '%{binding} %{must} declarar predicados diferentes a %{target}'
+  expectation_DeclaresPredicate_like: '%{binding} %{must} declarar un predicados parecido a %{target}'
+  expectation_DeclaresPredicate_named: '%{binding} %{must} declarar un predicados %{target}'
+  expectation_DeclaresProcedure: '%{binding} %{must} declarar procedimientos'
+  expectation_DeclaresProcedure_except: '%{binding} %{must} declarar procedimientos diferentes a %{target}'
+  expectation_DeclaresProcedure_like: '%{binding} %{must} declarar un procedimiento parecido a %{target}'
+  expectation_DeclaresProcedure_named: '%{binding} %{must} declarar un procedimiento %{target}'
+  expectation_DeclaresRecursively_named: '%{target} %{must} estar declarado recursivamente'
+  expectation_DeclaresRule: '%{binding} %{must} debe declarar reglas'
+  expectation_DeclaresRule_except: '%{binding} %{must} declarar reglas diferentes a %{target}'
+  expectation_DeclaresRule_like: '%{binding} %{must} declarar una regla parecida a %{target}'
+  expectation_DeclaresRule_named: '%{binding} %{must} declarar una regla %{target}'
+  expectation_DeclaresTypeAlias: '%{binding} %{must} declarar sinónimos de tipo'
+  expectation_DeclaresTypeAlias_except: '%{binding} %{must} declarar sinónimos de tipo diferentes a %{target}'
+  expectation_DeclaresTypeAlias_like: '%{binding} %{must} declarar un sinónimo de tipo parecido a %{target}'
+  expectation_DeclaresTypeAlias_named: '%{binding} %{must} declarar un sinónimo de tipo %{target}'
+  expectation_DeclaresTypeSignature: '%{binding} %{must} decarar firmas de tipos'
+  expectation_DeclaresTypeSignature_except: '%{binding} %{must} declarar firmas de tipos diferentes a %{target}'
+  expectation_DeclaresTypeSignature_like: '%{binding} %{must} declarar una firma para algo parecido %{target}'
+  expectation_DeclaresTypeSignature_named: '%{binding} %{must} declarar una firma %{target}'
+  expectation_DeclaresVariable: '%{binding} %{must} debe declarar variables'
+  expectation_DeclaresVariable_except: '%{binding} %{must} declarar variables diferentes a %{target}'
+  expectation_DeclaresVariable_like: '%{binding} %{must} declarar una variable parecida a %{target}'
+  expectation_DeclaresVariable_named: '%{binding} %{must} declarar una variable %{target}'
+  expectation_DoesNullTest: '%{binding} hace comparaciones contra null'
+  expectation_DoesTypeTest: '%{binding} hace comparaciones contra strings'
+  expectation_HasAssignmentReturn: '%{binding} devuelve el resultado de una asignación'
+  expectation_HasCodeDuplication: '%{binding} tiene código repetido'
+  expectation_HasMisspelledBindings: '%{binding} está mal escrito'
   expectation_HasRedundantBooleanComparison: '%{binding} hace comparaciones booleanas innecesarias'
   expectation_HasRedundantGuards: '%{binding} tiene guardas innecesarias'
   expectation_HasRedundantIf: '%{binding} tiene ifs innecesarios'
   expectation_HasRedundantLambda: '%{binding} tiene lambdas innecesarias'
+  expectation_HasRedundantLocalVariableReturn: '%{binding} usa variables locales innecesarias; podés retornar directamente la expresión'
   expectation_HasRedundantParameter: '%{binding} tiene parámetros innecesarios (se pueden eliminar mediante point-free)'
-  expectation_HasRepeat: '%{binding} %{must} usar una repetición simple (sentencia <i>repeat</i>)'
-  expectation_HasRepeatOf: '%{binding} %{must} usar una repetición simple (sentencia <i>repeat</i>) de %{target}'
-  expectation_HasTypeDeclaration: '%{must} existir una declaración para el sinónimo de tipo %{binding}'
-  expectation_HasTypeSignature: La firma para %{binding} %{must} ser declarada
-  expectation_HasUsage: '%{binding} %{must} utilizar %{target}'
-  expectation_HasVariable: '%{binding} %{must} utilizar variables'
-  expectation_HasWhile: '%{binding} %{must} utilizar repetición condicional (sentencia <i>while</i>)'
+  expectation_HasRedundantReduction: '%{binding} usa <i>is</i>, pero no realiza cálculos.'
+  expectation_HasTooShortBindings: '%{binding} es un identificador muy corto'
+  expectation_HasWrongCaseBindings: '%{binding} no respeta la convención de nombres'
+  expectation_IsLongCode: '%{binding} es muy largo. Tratá de delegar más'
   expectation_must: debe
   expectation_must_not: no debe
+  expectation_ReturnsNull: '%{binding} retorna null, lo cual es una mala práctica'
+  expectation_solution: la solución
+  expectation_Uses: '%{binding} %{must} delegar'
+  expectation_Uses_except: '%{binding} %{must} delegar en algo diferente a %{target}'
+  expectation_Uses_like: '%{binding} %{must} delegar en algo parecido a %{target}'
+  expectation_Uses_named: '%{binding} %{must} utilizar %{target}'
+  expectation_UsesAnonymousVariable: '%{binding} %{must} utilizar una variable anónima'
+  expectation_UsesComposition: '%{binding} %{must} usar composición'
+  expectation_UsesComprehension: '%{binding} %{must} emplear listas por comprensión'
+  expectation_UsesConditional: '%{binding} %{must} utilizar condicionales'
+  expectation_UsesCut: '%{binding} usa el operador !, lo cual es una mala práctica'
+  expectation_UsesFail: '%{binding} usa <i>fail</li>, lo cual es una mala práctica'
+  expectation_UsesFindall: '%{binding} %{must} utilizar findall'
+  expectation_UsesForall: '%{binding} %{must} utilizar forall'
+  expectation_UsesForeach: '%{binding} %{must} usar una repetición indexada (sentencia <i>foreach</i>)'
+  expectation_UsesGuards: '%{binding} %{must} usar guardas'
+  expectation_UsesIf: '%{binding} %{must} usar if'
+  expectation_UsesLambda: '%{binding} %{must} emplear expresiones lambda'
+  expectation_UsesNot: '%{binding} %{must} utilizar not'
+  expectation_UsesPatternMatching: '%{binding} %{must} utilizar pattern matching'
+  expectation_UsesRepeat: '%{binding} %{must} usar una repetición simple (sentencia <i>repeat</i>)'
+  expectation_UsesRepeatOf: '%{binding} %{must} usar una repetición simple (sentencia <i>repeat</i>) de %{target}'
+  expectation_UsesSwitch: '%{binding} %{must} utilizar un switch'
+  expectation_UsesUnificationOperator: '%{binding} usa el operador de unificación (=)'
+  expectation_UsesWhile: '%{binding} %{must} utilizar repetición condicional (sentencia <i>while</i>)'

data/lib/mumukit/inspection.rb

@@ -5,78 +5,43 @@ I18n.load_translations_path File.join(__dir__, '..', 'locales', '*.yml')
 require_relative '../mumukit/inspection/version'
 
 module Mumukit
-  module Inspection
-    def self.parse(s)
-      not_match = s.match /^Not:(.*)$/
-      if not_match
-        NegatedInspection.new(parse_base_inspection(not_match[1]))
-      else
-        parse_base_inspection(s)
-      end
+  class Inspection
+    attr_accessor :type, :target, :negated
+    alias negated? negated
+
+    def initialize(type, target, negated=false)
+      @type = type
+      @target = target
+      @negated = negated
     end
 
-    private
-
-    def self.parse_base_inspection(s)
-      target_match = s.match /^(.*):(.*)$/
-      if target_match
-        TargetedInspection.new(target_match[1], target_match[2])
-      else
-        PlainInspection.new(s)
-      end
+    def to_s
+      "#{negated_to_s}#{type}#{target_to_s}"
     end
 
-    class BaseInspection
-      def to_h
-        {negated: negated?, type: type, target: target}
-      end
+    def negated_to_s
+      negated ? 'Not:' : nil
     end
 
-    class PositiveInspection < BaseInspection
-      attr_accessor :type
-
-      def negated?
-        false
-      end
-    end
-
-    class PlainInspection < PositiveInspection
-      def initialize(type)
-        @type = type
-      end
-
-      def target
-        nil
-      end
+    def target_to_s
+      target ? ":#{target.to_s}" : nil
     end
 
-    class TargetedInspection < PositiveInspection
-      attr_accessor :target
-
-      def initialize(type, target)
-        @type = type
-        @target = target
+    def self.parse_binding_name(binding_s)
+      if binding_s.start_with? 'Intransitive:'
+        binding_s[13..-1]
+      else
+        binding_s
       end
     end
 
-    class NegatedInspection < BaseInspection
-      def initialize(inspection)
-        @inspection = inspection
-      end
-
-      def negated?
-        true
-      end
-
-      def target
-        @inspection.target
-      end
-
-      def type
-        @inspection.type
-      end
+    def self.parse(insepection_s)
+      raise "Invalid inspection #{insepection_s}" unless insepection_s =~ /^(Not\:)?([^\:]+)\:?(.+)?$/
+      Inspection.new($2, Mumukit::Inspection::Target.parse($3), $1.present?)
     end
   end
 end
 
+require_relative '../mumukit/inspection/target'
+require_relative '../mumukit/inspection/expectation'
 require_relative '../mumukit/inspection/i18n'

data/lib/mumukit/inspection/expectation.rb

@@ -0,0 +1,93 @@
+class Mumukit::Inspection::Expectation
+  attr_accessor :binding, :inspection
+
+  def initialize(binding, inspection)
+    @binding = binding
+    @inspection = inspection
+  end
+
+  def check!
+    raise "Wrong binding #{binding}" unless binding?
+    raise "Wrong inspection #{inspection}" unless inspection?
+  end
+
+  def translate
+    Mumukit::Inspection::I18n.translate self
+  end
+
+  def to_h
+    {binding: binding, inspection: inspection.to_s}
+  end
+
+  def self.guess_type(expectation)
+    if expectation[:inspection] =~ /(Not\:)?Has.*/
+      V0
+    else
+      V2
+    end
+  end
+
+  def self.parse(expectation)
+    guess_type(expectation).new(
+      expectation[:binding],
+      Mumukit::Inspection.parse(expectation[:inspection])).tap &:check!
+  end
+
+  class V0 < Mumukit::Inspection::Expectation
+    INSPECTIONS = %w(HasBinding HasTypeDeclaration HasTypeSignature HasVariable HasArity HasDirectRecursion
+                     HasComposition HasComprehension HasForeach HasIf HasGuards HasConditional HasLambda HasRepeat HasWhile
+                     HasUsage)
+
+
+    def binding?
+      binding.present?
+    end
+
+    def inspection?
+      inspection.present? && INSPECTIONS.include?(inspection.type)
+    end
+
+    def as_v2
+      if has? 'Binding' then as_v2_declare ''
+      elsif has? 'TypeDeclaration' then as_v2_declare 'TypeAlias'
+      elsif has? 'TypeSignature' then as_v2_declare 'TypeSignature'
+      elsif has? 'Variable' then as_v2_declare 'Variable'
+      elsif has? 'Arity' then as_v2_declare "ComputationWithArity#{inspection.target.value}"
+      elsif has? 'DirectRecursion' then as_v2_declare "Recursively"
+      elsif has? 'Usage'
+        V2.new binding, new_inspection('Uses', Mumukit::Inspection::Target.named(inspection.target.value))
+      else as_v2_use
+      end
+    end
+
+    def has?(simple_type)
+      inspection.type == "Has#{simple_type}"
+    end
+
+    def as_v2_use
+      V2.new binding, new_inspection(inspection.type.gsub('Has', 'Uses'), Mumukit::Inspection::Target.anyone)
+    end
+
+    def as_v2_declare(simple_type)
+      V2.new '', new_inspection("Declares#{simple_type}", Mumukit::Inspection::Target.named(binding))
+    end
+
+    def new_inspection(type, target)
+      Mumukit::Inspection.new(type, target, inspection.negated?)
+    end
+  end
+
+  class V2 < Mumukit::Inspection::Expectation
+    def binding?
+      true
+    end
+
+    def inspection?
+      true
+    end
+
+    def as_v2
+      self
+    end
+  end
+end

data/lib/mumukit/inspection/i18n.rb

@@ -1,38 +1,34 @@
-module Mumukit::Inspection
-
-  class Mumukit::Inspection::NegatedInspection
-    def must
-      'must_not'
+module Mumukit::Inspection::I18n
+  class << self
+    def translate(e)
+      e = e.as_v2
+      key = key_for e.binding, e.inspection
+      ::I18n.t key,
+      binding: t_binding(e.binding),
+      target: t_target(e.inspection),
+      must: t_must(e.inspection)
+    rescue
+      '<unknown expectation>'
     end
-  end
 
-  class Mumukit::Inspection::PositiveInspection
-    def must
-      'must'
-    end
-  end
+    alias t translate
 
-  module I18n
-    class << self
-      def translate(expectation)
-        binding = expectation[:binding]
-        inspection = Mumukit::Inspection.parse expectation[:inspection]
+    private
 
-        ::I18n.t "expectation_#{inspection.type}",
-                 binding: "<strong>#{binding}</strong>",
-                 target: "<strong>#{inspection.target}</strong>",
-                 must: t_must(inspection)
-      rescue
-        '<unknown expectation>'
-      end
+    def key_for(binding, inspection)
+      "expectation_#{inspection.type}#{inspection.target ? inspection.target.i18n_suffix : nil }"
+    end
 
-      alias t translate
+    def t_binding(binding)
+      binding.present? ? "<strong>#{Mumukit::Inspection.parse_binding_name binding}</strong>" : ::I18n.t("expectation_solution")
+    end
 
-      private
+    def t_must(parsed)
+      ::I18n.t("expectation_#{parsed.negated? ? 'must_not' : 'must' }")
+    end
 
-      def t_must(parsed)
-        ::I18n.t("expectation_#{parsed.must}")
-      end
+    def t_target(parsed)
+      "<strong>#{parsed.target.value}</strong>" if parsed.target
     end
   end
-end
+end

data/lib/mumukit/inspection/target.rb

@@ -0,0 +1,68 @@
+class Mumukit::Inspection::Target
+  attr_accessor :type, :value
+
+  def initialize(type, value=nil)
+    @type = type
+    @value = value
+  end
+
+  def self.parse(target_s)
+    if target_s.blank?
+      nil
+    elsif target_s == '*'
+      anyone
+    elsif target_s.start_with? '^'
+      new :except, target_tail(target_s)
+    elsif target_s.start_with? '~'
+      new :like, target_tail(target_s)
+    elsif target_s.start_with? '='
+      named target_tail(target_s)
+    else
+      unknown target_s
+    end
+  end
+
+  def to_s
+    case type
+    when  :anyone
+      '*'
+    when :except
+      "^#{value}"
+    when :like
+      "~#{value}"
+    when :named
+      "=#{value}"
+    else
+      value
+    end
+  end
+
+  def i18n_suffix
+    case type
+    when :anyone
+      nil
+    when :except
+      "_except"
+    when :like
+      "_like"
+    else
+      "_named"
+    end
+  end
+
+  def self.target_tail(target_s)
+    target_s[1..-1]
+  end
+
+  def self.unknown(value)
+    new(:unknown, value)
+  end
+
+  def self.named(value)
+    new(:named, value)
+  end
+
+  def self.anyone
+    new(:anyone)
+  end
+end

data/lib/mumukit/inspection/version.rb

@@ -1,5 +1,5 @@
 module Mumukit
-  module Inspection
-    VERSION = '1.0.0'
+  class Inspection
+    VERSION = '2.0.0'
   end
 end

metadata

@@ -1,29 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: mumukit-inspection
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Franco Leonardo Bulgarelli
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-28 00:00:00.000000000 Z
+date: 2017-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mumukit-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - "<"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -90,7 +96,9 @@ files:
 - lib/locales/en.yml
 - lib/locales/es.yml
 - lib/mumukit/inspection.rb
+- lib/mumukit/inspection/expectation.rb
 - lib/mumukit/inspection/i18n.rb
+- lib/mumukit/inspection/target.rb
 - lib/mumukit/inspection/version.rb
 homepage: ''
 licenses: