Merge pull request #92 from fcevado/change_to_behavior

v0.4.0

.gitignore

@@ -1,4 +1,5 @@
 /_build
+/bench/snapshots
 /cover
 /doc
 /docs

.travis.yml

@@ -2,8 +2,8 @@ language: elixir
 
 elixir:
   - 1.2.6
-  - 1.3.2
-  - 1.4.0
+  - 1.3.4
+  - 1.4.2
 
 otp_release:
   - 18.3

CHANGELOG.md

@@ -1,5 +1,11 @@
 #Changelog
 
+##v0.4.0:
+  * Updates `Helper.Countries` and `Helper.Area` behavior
+  * Several changes to improve performance.
+  * Include `valid?/1`.
+  * Remove warning from v0.3
+
 ##v0.3.10:
   * Correct number validation for Norway.
   * Correct Ireland area codes validation.

bench/phone_bench.exs

@@ -0,0 +1,19 @@
+defmodule PhoneBench do
+  use Benchfella
+
+  @nanp_phone_number "12536301234"
+  @andorra_phone_number "376123456"
+  @zimbabwe_phone_number "2634333224"
+
+  bench "Phone.parse/1 with an NANP phone number" do
+    {:ok, _result} = Phone.parse(@nanp_phone_number)
+  end
+
+  bench "Phone.parse/1 with an Andorra phone number" do
+    {:ok, _result} = Phone.parse(@andorra_phone_number)
+  end
+
+  bench "Phone.parse/1 with a Zimbabwe phone number" do
+    {:ok, _result} = Phone.parse(@zimbabwe_phone_number)
+  end
+end

lib/helpers/area.ex

@@ -2,22 +2,16 @@ defmodule Helper.Area do
   @moduledoc false
   defmacro __using__(_) do
     quote do
-      import Helper.Area
       @moduledoc false
-    end
-  end
 
-  defmacro field(name, value) do
-    quote do
-      defp unquote(name)(), do: unquote(value)
-    end
-  end
+      import Helper.Area
 
-  defmacro builder do
-    quote do
-      def match?(number) do
-        Regex.match?(regex(), number)
-      end
+      def regex, do: ""
+      def area_name, do: ""
+      def area_type, do: ""
+      def area_abbreviation, do: ""
+
+      defoverridable [regex: 0, area_name: 0, area_type: 0, area_abbreviation: 0]
 
       def builder(number) do
         [_ | country] =
@@ -43,22 +37,59 @@ defmodule Helper.Area do
           area_abbreviation: area_abbreviation()
         }
       end
+    end
+  end
 
-      def build(number) do
-        if match?(number) do
-          {:ok, builder(number)}
-        else
-          {:error, "Not a valid phone number."}
+  defmacro matcher(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
-
-      def build!(number) do
-        if match?(number) do
-          builder(number)
-        else
-          raise ArgumentError, message: "Not a valid phone number."
+      end)
+    ++
+    [quote do
+      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
-      end
-    end
+      end)
+    ++
+    [quote do
+      def build(_number), do: {:error, "Not a valid phone number."}
+    end]
+    ++
+    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
+      end)
+    ++
+    [quote do
+      def build!(_number), do: raise ArgumentError, message: "Not a valid phone number."
+    end]
   end
 end

lib/helpers/country.ex

@@ -2,22 +2,22 @@ defmodule Helper.Country do
   @moduledoc false
   defmacro __using__(_) do
     quote do
-      import Helper.Country
       @moduledoc false
-    end
-  end
 
-  defmacro field(name, value) do
-    quote do
-      def unquote(name)(), do: unquote(value)
+      import Helper.Country
+
+      def regex, do: ""
+      def country, do: ""
+      def a2, do: ""
+      def a3, do: ""
+
+      defoverridable [regex: 0, country: 0, a2: 0, a3: 0]
     end
   end
 
-  defp regex_matcher do
-    quote do
-      def match?(number) do
-        Regex.match?(regex(), number)
-      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,58 +31,80 @@ defmodule Helper.Country do
           number: number
         }
       end
+    end]
+    ++
+    Enum.map(codes,
+      fn code ->
+        quote do
+          def match?(unquote(code) <> _ = number) do
+            Regex.match?(regex(), number)
+          end
 
-      def build(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
+              {:ok, builder(number)}
+            else
+              {:error, "Not a valid phone number."}
+            end
+          end
 
-      def build!(number) do
-        if match?(number) do
-          builder(number)
-        else
-          raise ArgumentError, "Not a valid phone number."
+          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
+      end)
+    ++
+    [quote do
+      def match?(_number), do: false
+
+      def build!(_number), do: raise ArgumentError, "Not a valid phone number."
+
+      def build(_number), do: {:error, "Not a valid phone number."}
+    end]
   end
 
-  defp modules_matcher do
-    quote do
-      def match?(number) do
-        ms = Enum.filter(modules(), fn m -> m.match?(number) end)
-        length(ms) > 0
-      end
+  defmacro matcher(:modules, modules) do
+    modules = Enum.map(modules, &(Macro.expand(&1, __CALLER__)))
 
-      def build(number) do
-        if match?(number) do
-          [module] = Enum.filter(modules(), fn m -> m.match?(number) end)
-          module.build(number)
-        else
-          {:error, "Not a valid phone number."}
-        end
-      end
+    all_codes = Enum.reduce(modules, [], fn m, acc -> acc ++ m.codes end)
 
-      def build!(number) do
-        if match?(number) do
-          [module] = Enum.filter(modules(), fn m -> m.match?(number) end)
-          module.build!(number)
-        else
-          raise ArgumentError, message: "Not a valid phone number."
-        end
-      end
-    end
-  end
+    [quote do
+      def codes, do: unquote(all_codes)
+    end]
+    ++
+    Enum.map(modules,
+      fn module ->
+        Enum.map(module.codes,
+          fn code ->
+            quote do
+              def match?(unquote(code) <> _ = number) do
+                unquote(module).match?(number)
+              end
 
-  defmacro match(matcher) do
-    case matcher do
-      :regex -> regex_matcher()
-      :modules -> modules_matcher()
-      true ->
-        raise ArgumentError, "You can only match against :regex or :modules, passed #{inspect matcher}"
-    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)
+      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]
   end
+
+  defmacro matcher(_, _),
+    do: raise ArgumentError, "You can only match against :regex or :modules"
 end