Implement i18n

docs/js/edlhighligh.js

@@ -2,7 +2,7 @@ hljs.registerLanguage('edl', () => {
   return {
     k: {
       keyword: "count except in like unlike something somewhere expectation that through with within",
-      literal: "anything false logic math nil self true literal nonliteral",
+      literal: "anything false logic math nil self true literal nonliteral anystring anynumber",
       built_in: "and or not"
     },
     c: [

gem/lib/locales/en.yml

@@ -9,6 +9,8 @@ en:
       with_char: ' with character <code>%{value}</code>'
       with_false: ' with value <code>%{keyword_False}</code>'
       with_literal: ' with a literal value'
+      with_any_string: ' with a string literal'
+      with_any_number: ' with a number literal'
       with_logic: ' with a boolean expression'
       with_math:  ' with a math expression'
       with_nil: ' with <code>%{keyword_Nil}</code>'

gem/lib/locales/es.yml

@@ -9,6 +9,8 @@ es:
       with_char: ' con el carácter <code>%{value}</code>'
       with_false: ' con el valor <code>%{keyword_False}</code>'
       with_literal: ' con un valor literal'
+      with_any_string: ' con un string literal'
+      with_any_number: ' con un número literal'
       with_logic: ' con una expresión booleana'
       with_math:  'con una expresión matemática'
       with_nil: ' con <code>%{keyword_Nil}</code>'

gem/lib/locales/pt.yml

@@ -9,6 +9,8 @@ pt:
       with_char: ' com o caractere <code>%{value}</code>'
       with_false: ' com o valor <code>%{keyword_False}</code>'
       with_literal: ' com um valor literal'
+      with_any_string: ' com uma string literal'
+      with_any_number: ' com um número literal'
       with_logic: ' com uma expressão booleana'
       with_math: ' com uma expressão matemática'
       with_nil: ' com <code>%{keyword_Nil}</code>'

gem/lib/mulang/inspection.rb

@@ -12,7 +12,7 @@ def as_json(*args)
       ^(?<negation>Not:)?
       (?<type>[^:]+)
       (
-        :(?<matcher>WithAnything|WithLiteral|WithNonliteral|WithLogic|WithMath|WithFalse|WithNil|WithTrue) |
+        :(?<matcher>WithAnything|WithLiteral|WithNonliteral|WithAnyString|WithAnyNumber|WithLogic|WithMath|WithFalse|WithNil|WithTrue) |
         :(?<matcher>WithReference|WithChar|WithNumber|WithString|WithSymbol):(?<value>[^:]+) |
         :(?<target>[^:]+)(:(?<matcher>[^:]+)(:(?<value>[^:]+))?)?
       )?$}.gsub(/\s/, '')

gem/lib/mulang/inspection/matcher.rb

@@ -5,7 +5,8 @@ class Mulang::Inspection::Matcher
     WithAnything WithChar WithFalse WithLiteral
     WithLogic WithMath WithNil WithNonliteral
     WithNumber WithReference WithString
-    WithSymbol WithTrue)
+    WithSymbol WithTrue
+    WithAnyString WithAnyNumber)
 
   attr_accessor :type, :value
 

gem/spec/i18n_spec.rb

@@ -73,6 +73,9 @@ def expectation(binding, inspection)
       it { expect(expectation('*', 'CallsSetAt:WithAnything').translate).to eq('solution must use <code>[]=</code> with some expression') }
       it { expect(expectation('*', 'CallsSetAt:WithLiteral').translate).to eq('solution must use <code>[]=</code> with a literal value') }
       it { expect(expectation('*', 'CallsSetAt:WithReference:x').translate).to eq('solution must use <code>[]=</code> with <code>x</code>') }
+
+      it { expect(expectation('*', 'CallsPlus:WithAnyString').translate).to eq('solution must use <code>+</code> with a string literal') }
+      it { expect(expectation('*', 'CallsPlus:WithAnyNumber').translate).to eq('solution must use <code>+</code> with a number literal') }
     end
   end
 
@@ -94,6 +97,8 @@ def expectation(binding, inspection)
 
     it { expect(expectation('*', 'CallsSlice:WithReference:nomes').translate :Python).to eq('a solução deve utilizar <code>[:]</code> com <code>nomes</code>') }
 
+    it { expect(expectation('*', 'CallsPlus:WithAnyString').translate).to eq('a solução deve utilizar <code>+</code> com uma string literal') }
+    it { expect(expectation('*', 'CallsPlus:WithAnyNumber').translate).to eq('a solução deve utilizar <code>+</code> com um número literal') }
   end
 
   context 'es locale' do
@@ -121,6 +126,9 @@ def expectation(binding, inspection)
 
       it { expect(expectation('*', 'CallsSize:WithNonliteral').translate :Python).to eq('la solución debe usar <code>len</code> con una expresión no literal') }
       it { expect(expectation('*', 'CallsSize:WithReference:y').translate :JavaScript).to eq('la solución debe usar <code>length</code> con <code>y</code>') }
+
+      it { expect(expectation('*', 'CallsPlus:WithAnyString').translate).to eq('la solución debe usar <code>+</code> con un string literal') }
+      it { expect(expectation('*', 'CallsPlus:WithAnyNumber').translate).to eq('la solución debe usar <code>+</code> con un número literal') }
     end
 
     describe 'custom expectations' do

gem/spec/inspection_spec.rb

@@ -53,6 +53,8 @@
   it { expect(Mulang::Inspection.parse("Assigns:x")).to json_like(type: 'Assigns', negated: false, target: {type: :unknown, value: 'x'}) }
   it { expect(Mulang::Inspection.parse("Assigns:WithFalse")).to json_like(type: 'Assigns', negated: false, matcher: {type: :with_false }) }
   it { expect(Mulang::Inspection.parse("Assigns:WithNumber:2")).to json_like(type: 'Assigns', negated: false, matcher: {type: :with_number, value: "2" }) }
+  it { expect(Mulang::Inspection.parse("Assigns:WithAnyNumber")).to json_like(type: 'Assigns', negated: false, matcher: {type: :with_any_number }) }
+  it { expect(Mulang::Inspection.parse("Assigns:WithAnyString")).to json_like(type: 'Assigns', negated: false, matcher: {type: :with_any_string }) }
 
   it { expect(Mulang::Inspection.parse("Returns:WithFalse")).to json_like(type: 'Returns', negated: false, matcher: {type: :with_false }) }
   it { expect(Mulang::Inspection.parse("Returns:WithNil")).to json_like(type: 'Returns', negated: false, matcher: {type: :with_nil }) }

spec/LiteralSpec.hs

@@ -47,12 +47,12 @@ spec = do
       isNonliteral (MuNumber 4) `shouldBe` False
 
     it "works with anynumber and anystring" $ do
-      isAnyNumber MuNil `shouldBe` False
-      isAnyNumber (MuString "Nil") `shouldBe` False
-      isAnyNumber MuTrue `shouldBe` False
-      isAnyNumber (MuNumber 4) `shouldBe` True
-
       isAnyString MuNil `shouldBe` False
       isAnyString (MuString "Nil") `shouldBe` True
       isAnyString MuTrue `shouldBe` False
-      isAnyString (MuNumber 4) `shouldBe` False
+      isAnyString (MuNumber 4) `shouldBe` False
+
+      isAnyNumber MuNil `shouldBe` False
+      isAnyNumber (MuString "Nil") `shouldBe` False
+      isAnyNumber MuTrue `shouldBe` False
+      isAnyNumber (MuNumber 4) `shouldBe` True

src/Language/Mulang/Edl/Lexer.x

@@ -88,8 +88,8 @@ tokens :-
   "math" { symbolToken TMath }
   "nil" { symbolToken TNil }
   "nonliteral" { symbolToken TNonliteral }
-  "anynumber" { symbolToken TAnyNumber }
   "anystring" { symbolToken TAnyString }
+  "anynumber" { symbolToken TAnyNumber }
   "not" { symbolToken TNot }
   "or" { symbolToken TOr }
   "self" { symbolToken TSelf }

src/Language/Mulang/Edl/Parser.y

@@ -176,8 +176,8 @@ Clause : number { IsNumber . numberValue $ $1 }
   | math { IsMath }
   | nil { IsNil }
   | nonliteral { IsNonliteral }
-  | anynumber { IsAnyNumber }
   | anystring { IsAnyString }
+  | anynumber { IsAnyNumber }
   | self { IsSelf }
   | true { IsTrue }
   | something that openParen TopQuery closeParen { That $4 }
@@ -226,8 +226,8 @@ m TLogic = "logic is not expected here"
 m TMath = "math is not expected here"
 m TNil = "nil is not expected here"
 m TNonliteral = "nonliteral is not expected here"
-m TAnyNumber = "anynumber is not expected here"
 m TAnyString = "anystring is not expected here"
+m TAnyNumber = "anynumber is not expected here"
 m TNot = "not is not expected here"
 m TOpenParen = "Unexpected )"
 m TOr = "or is not expected here"