Merge pull request #98 from fcevado/ebert_issues

Ebert issues

CONTRIBUTING.md

@@ -44,7 +44,7 @@ defmodule Phone.NANP.CA do
   def a3, do: "CAN"
 
   matcher :modules, [Phone.NANP.CA.AB, Phone.NANP.CA.BC, Phone.NANP.CA.MB,
-                     Phone.NANP.CA.NB, Phone.NANP.CA.NL, Phone.NANP.CA.NS_PE,
+                     Phone.NANP.CA.NB, Phone.NANP.CA.NL, Phone.NANP.CA.NSAndPE,
                      Phone.NANP.CA.ON, Phone.NANP.CA.QC, Phone.NANP.CA.SK,
                      Phone.NANP.CA.Territory]
 end

lib/helpers/area.ex

@@ -2,8 +2,6 @@ defmodule Helper.Area do
   @moduledoc false
   defmacro __using__(_) do
     quote do
-      @moduledoc false
-
       import Helper.Area
 
       def regex, do: ""
@@ -18,6 +16,7 @@ defmodule Helper.Area do
           __MODULE__
           |> Module.split
           |> Enum.reverse
+
         country =
           country
           |> Enum.reverse
@@ -40,56 +39,54 @@ defmodule Helper.Area do
     end
   end
 
-  defmacro matcher(codes) do
+  defp generate_codes(codes) do
     [quote do
       def codes, do: unquote(codes)
     end]
-    ++
-    Enum.map(codes,
-      fn code ->
-        quote do
-          def match?(unquote(code) <> _ = number) do
-            Regex.match?(regex(), number)
-          end
-        end
-      end)
-    ++
+  end
+
+  defp generate_errors do
     [quote do
+      def build(_number), do: {:error, "Not a valid phone number."}
+
+      def build!(_number), do: raise ArgumentError, message: "Not a valid phone number."
+
       def match?(_number), do: false
     end]
-    ++
-    Enum.map(codes,
-      fn code ->
-        quote do
-          def build(unquote(code) <> _ = number) do
-            if match?(number) do
-              {:ok, builder(number)}
-            else
-              {:error, "Not a valid phone number."}
-            end
-          end
+  end
+
+  defp generate_matcher(code) do
+    quote do
+      def match?(unquote(code) <> _ = number) do
+        Regex.match?(regex(), number)
+      end
+
+      def build(unquote(code) <> _ = number) do
+        if match?(number) do
+          {:ok, builder(number)}
+        else
+          {:error, "Not a valid phone number."}
         end
-      end)
-    ++
-    [quote do
-      def build(_number), do: {:error, "Not a valid phone number."}
-    end]
+      end
+
+      def build!(unquote(code) <> _ = number) do
+        if match?(number) do
+          builder(number)
+        else
+          raise ArgumentError, message: "Not a valid phone number."
+        end
+      end
+    end
+  end
+
+  defmacro matcher(codes) do
+    generate_codes(codes)
     ++
     Enum.map(codes,
       fn code ->
-        quote do
-          def build!(unquote(code) <> _ = number) do
-            if match?(number) do
-              builder(number)
-            else
-              raise ArgumentError, message: "Not a valid phone number."
-            end
-          end
-        end
+        generate_matcher(code)
       end)
     ++
-    [quote do
-      def build!(_number), do: raise ArgumentError, message: "Not a valid phone number."
-    end]
+    generate_errors()
   end
 end

lib/helpers/country.ex

@@ -2,8 +2,6 @@ defmodule Helper.Country do
   @moduledoc false
   defmacro __using__(_) do
     quote do
-      @moduledoc false
-
       import Helper.Country
 
       def regex, do: ""
@@ -12,12 +10,6 @@ defmodule Helper.Country do
       def a3, do: ""
 
       defoverridable [regex: 0, country: 0, a2: 0, a3: 0]
-    end
-  end
-
-  defmacro matcher(:regex, codes) do
-    [quote do
-      def codes, do: unquote(codes)
 
       def builder(number) do
         [[_, code, area, number]] = Regex.scan(regex(), number)
@@ -31,33 +23,16 @@ defmodule Helper.Country do
           number: number
         }
       end
+    end
+  end
+
+  defp generate_codes(codes) do
+    [quote do
+      def codes, do: unquote(codes)
     end]
-    ++
-    Enum.map(codes,
-      fn code ->
-        quote do
-          def match?(unquote(code) <> _ = number) do
-            Regex.match?(regex(), number)
-          end
-
-          def build(unquote(code) <> _ = number) do
-            if match?(number) do
-              {:ok, builder(number)}
-            else
-              {:error, "Not a valid phone number."}
-            end
-          end
-
-          def build!(unquote(code) <> _ = number) do
-            if match?(number) do
-              builder(number)
-            else
-              raise ArgumentError, "Not a valid phone number."
-            end
-          end
-        end
-      end)
-    ++
+  end
+
+  defp generate_errors do
     [quote do
       def match?(_number), do: false
 
@@ -67,42 +42,73 @@ defmodule Helper.Country do
     end]
   end
 
+  def generate_matcher(:regex, code) do
+    quote do
+      def match?(unquote(code) <> _ = number) do
+        Regex.match?(regex(), number)
+      end
+
+      def build(unquote(code) <> _ = number) do
+        if match?(number) do
+          {:ok, builder(number)}
+        else
+          {:error, "Not a valid phone number."}
+        end
+      end
+
+      def build!(unquote(code) <> _ = number) do
+        if match?(number) do
+          builder(number)
+        else
+          raise ArgumentError, "Not a valid phone number."
+        end
+      end
+    end
+  end
+
+  def generate_matcher(:modules, module, code) do
+    quote do
+      def match?(unquote(code) <> _ = number) do
+        unquote(module).match?(number)
+      end
+
+      def build(unquote(code) <> _ = number) do
+        unquote(module).build(number)
+      end
+
+      def build!(unquote(code) <> _ = number) do
+        unquote(module).build!(number)
+      end
+    end
+  end
+
+  defmacro matcher(:regex, codes) do
+    generate_codes(codes)
+    ++
+    Enum.map(codes,
+      fn code ->
+        generate_matcher(:regex, code)
+      end)
+    ++
+    generate_errors()
+  end
+
   defmacro matcher(:modules, modules) do
     modules = Enum.map(modules, &(Macro.expand(&1, __CALLER__)))
 
-    all_codes = Enum.reduce(modules, [], fn m, acc -> acc ++ m.codes end)
-
-    [quote do
-      def codes, do: unquote(all_codes)
-    end]
+    (modules
+    |> Enum.reduce([], fn m, acc -> acc ++ m.codes end)
+    |> generate_codes)
     ++
     Enum.map(modules,
       fn module ->
         Enum.map(module.codes,
           fn code ->
-            quote do
-              def match?(unquote(code) <> _ = number) do
-                unquote(module).match?(number)
-              end
-
-              def build(unquote(code) <> _ = number) do
-                unquote(module).build(number)
-              end
-
-              def build!(unquote(code) <> _ = number) do
-                unquote(module).build!(number)
-              end
-            end
+            generate_matcher(:modules, module, code)
           end)
       end)
     ++
-    [quote do
-      def match?(_number), do: false
-
-      def build(_number), do: {:error, "Not a valid phone number."}
-
-      def build!(_number), do: raise ArgumentError, message: "Not a valid phone number."
-    end]
+    generate_errors()
   end
 
   defmacro matcher(_, _),

lib/helpers/parser.ex

@@ -72,7 +72,6 @@ defmodule Helper.Parser do
     end
   end
 
-
   defmacro country_parser do
     quote do
         parser :ad, "376"

lib/phone.ex

@@ -2,7 +2,6 @@ defmodule Phone do
   @moduledoc ~S"""
   Phone is a real telephone number parser, that will help you get useful information from numbers.
 
-
   ## How to use
 
   Very simple to use:
@@ -119,7 +118,6 @@ defmodule Phone do
   @spec parse!(pos_integer, Atom.t) :: Map.t
   country_parser()
 
-
   @doc """
   Returns `true` if the number can be parsed, otherwhise returns `false`.
 

lib/phone/ad.ex

@@ -1,4 +1,6 @@
 defmodule Phone.AD do
+  @moduledoc false
+
   use Helper.Country
 
   def regex, do: ~r/^(376)()(.{6})/

lib/phone/ae.ex

@@ -1,4 +1,6 @@
 defmodule Phone.AE do
+  @moduledoc false
+
   use Helper.Country
 
   def regex, do: ~r/^(971)(.)(.{7})/

lib/phone/af.ex

@@ -1,4 +1,6 @@
 defmodule Phone.AF do
+  @moduledoc false
+
   use Helper.Country
 
   def regex, do: ~r/^(93)(..)(.{7})/

lib/phone/al.ex

@@ -1,4 +1,6 @@
 defmodule Phone.AL do
+  @moduledoc false
+
   use Helper.Country
 
   def regex, do: ~r/^(355)()(.{7})/

lib/phone/am.ex

@@ -1,4 +1,6 @@
 defmodule Phone.AM do
+  @moduledoc false
+
   use Helper.Country
 
   def regex, do: ~r/^(374)()(.{8})/

lib/phone/ao.ex

@@ -1,4 +1,6 @@
 defmodule Phone.AO do
+  @moduledoc false
+
   use Helper.Country
 
   def regex, do: ~r/^(244)()(9)/

lib/phone/ar.ex

@@ -1,4 +1,6 @@
 defmodule Phone.AR do
+  @moduledoc false
+
   use Helper.Country
 
   def regex, do: ~r/^(54)()(.{10})/

lib/phone/at.ex

@@ -1,4 +1,6 @@
 defmodule Phone.AT do
+  @moduledoc false
+
   use Helper.Country
 
   def regex, do: ~r/^(43)()(.+)/

lib/phone/au.ex

@@ -1,4 +1,6 @@
 defmodule Phone.AU do
+  @moduledoc false
+
   use Helper.Country
 
   def regex, do: ~r/^(61)([1-478])(.{8})/

lib/phone/aw.ex

@@ -1,4 +1,6 @@
 defmodule Phone.AW do
+  @moduledoc false
+
   use Helper.Country
 
   def regex, do: ~r/^(297)()(.{7})/

lib/phone/az.ex

@@ -1,4 +1,6 @@
 defmodule Phone.AZ do
+  @moduledoc false
+
   use Helper.Country
 
   def regex, do: ~r/^(994)()(.{9})/

lib/phone/ba.ex

@@ -1,4 +1,6 @@
 defmodule Phone.BA do
+  @moduledoc false
+
   use Helper.Country
 
   def regex, do: ~r/^(387)(..)(.{5,6})/

lib/phone/bd.ex

@@ -1,4 +1,6 @@
 defmodule Phone.BD do
+  @moduledoc false
+
   use Helper.Country
 
   def regex, do: ~r/^(880)()(.{10})/