Initial commit

Author: kipcole9

.formatter.exs

@@ -0,0 +1,4 @@
+# Used by "mix format"
+[
+  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
+]

.gitignore

@@ -0,0 +1,24 @@
+# The directory Mix will write compiled artifacts to.
+/_build/
+
+# If you run "mix test --cover", coverage assets end up here.
+/cover/
+
+# The directory Mix downloads your dependencies sources to.
+/deps/
+
+# Where third-party dependencies like ExDoc output generated docs.
+/doc/
+
+# Ignore .fetch files in case you like to edit your project deps locally.
+/.fetch
+
+# If the VM crashes, it generates a dump, let's ignore it too.
+erl_crash.dump
+
+# Also ignore archive artifacts (built via "mix archive.build").
+*.ez
+
+# Ignore package tarball (built via "mix hex.build").
+unicode_guards-*.tar
+

CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog for Unicode Guards v0.1.0
+
+This is the changelog for Unicode Guards v0.1.0 released on November 23rd, 2019.  For older changelogs please consult the release tag on [GitHub](https://github.com/elixir-unicode/unicode_guards/tags)
+
+Initial release.

LICENSE.md

@@ -0,0 +1,13 @@
+# License
+
+Copyright 2019 Kip Cole
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
+compliance with the License. You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License
+is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied. See the License for the specific language governing permissions and limitations under the
+License.

README.md

@@ -0,0 +1,38 @@
+# Unicode Guards
+
+Provides a set of function guards that can be used to match Unicode codepoints.  Based upon [ex_unicode](https://hex.pm/packages/ex_unicode) and [unicode_set](https://hex.pm/packages/unicode_set).
+
+## Usage
+
+Each guard operates on a UTF8 codepoint since the permitted operators in a guard clause are restricted to simple comparisons that do not include strings.
+
+The data that underpins these guards is generated from the Unicode character database and therefore
+includes a broad range of scripts well beyond the basic ASCII definitions.
+
+Some examples follow defining functions using the pre-defined guards. Note that since guards operate on codepoints (not strings) we use binary pattern matching to extract the first codepoint for these example.
+
+```elixir
+defmodule Guards do
+  import Unicode.Guards
+
+  def upper(<< x :: utf8, _rest :: binary >>) when is_upper(x), do: :upper
+  def lower(<< x :: utf8, _rest :: binary >>) when is_lower(x), do: :lower
+  def digit(<< x :: utf8, _rest :: binary >>) when is_digit(x), do: :digit
+  def whitespace(<< x :: utf8, _rest :: binary >>) when is_whitespace(x), do: :whitespace
+  def currency(<< x :: utf8, _rest :: binary >>) when is_currency_symbol(x), do: :currency
+end
+```
+## Installation
+
+The package can be installed by adding `unicode_guards` to your list of dependencies in `mix.exs`:
+
+```elixir
+def deps do
+  [
+    {:unicode_guards, "~> 0.1.0"}
+  ]
+end
+```
+
+The docs can be found at [https://hexdocs.pm/unicode_guards](https://hexdocs.pm/unicode_guards).
+

lib/unicode_guards.ex

@@ -0,0 +1,70 @@
+defmodule Unicode.Guards do
+  @moduledoc """
+  Defines a set of guards that can be used with
+  Elixir functions.
+
+  Each guard operates on a UTF8 codepoint since
+  the permitted operators in a guard clause
+  are restricted to simple comparisons that do
+  not include string comparators.
+
+  The data that underpins these guards is generated
+  from the Unicode character database and therefore
+  includes a broad range of scripts well beyond
+  the basic ASCII definitions.
+
+  """
+
+  require Unicode.Set
+  import Unicode.Set, only: [match?: 2]
+  import Kernel, except: [match?: 2]
+
+  @doc """
+  Guards whether a UTF8 codepoint is an upper case
+  character.
+
+  The match is for any UTF8 character that is defined
+  in Unicode to be an upper case character in any
+  script.
+
+  """
+  defguard is_upper(codepoint) when is_integer(codepoint) and match?(codepoint, "[[:Lu:]]")
+
+  @doc """
+  Guards whether a UTF8 codepoint is a lower case
+  character.
+
+  The match is for any UTF8 character that is defined
+  in Unicode to be an lower case character in any
+  script.
+
+  """
+  defguard is_lower(codepoint) when is_integer(codepoint) and match?(codepoint, "[[:Ll:]]")
+
+  @doc """
+  Guards whether a UTF8 codepoint is a digit
+  character.
+
+  This guard will match any digit character from any
+  Unicode script, not only the ASCII decimal digits.
+
+  """
+  defguard is_digit(codepoint) when is_integer(codepoint) and match?(codepoint, "[[:Nd:]]")
+
+  @doc """
+  Guards whether a UTF8 codepoint is a currency symbol
+  character.
+
+  """
+  defguard is_currency_symbol(codepoint)
+           when is_integer(codepoint) and match?(codepoint, "[[:Sc:]]")
+
+
+  @doc """
+  Guards whether a UTF8 codepoint is a whitespace symbol
+  character.
+
+  """
+  defguard is_whitespace(codepoint) when is_integer(codepoint) and match?(codepoint, "[[:Zs:]]")
+
+end

logo.png

@@ -0,0 +1,88 @@
+defmodule Unicode.Guards.MixProject do
+  use Mix.Project
+
+  @version "0.1.0"
+
+  def project do
+    [
+      app: :unicode_guards,
+      version: @version,
+      elixir: "~> 1.8",
+      start_permanent: Mix.env() == :prod,
+      build_embedded: Mix.env() == :prod,
+      deps: deps(),
+      docs: docs(),
+      name: "Unicode function guards for Elixir",
+      source_url: "https://github.com/elixir-unicode/unicode_guards",
+      description: description(),
+      package: package(),
+      elixirc_paths: elixirc_paths(Mix.env())
+    ]
+  end
+
+  defp description do
+    """
+    Implementation of Unicode Set-based guards for Elixir. Supports matching
+    unicode sets to codepoints that can be used in function guards.
+    """
+  end
+
+  defp package do
+    [
+      maintainers: ["Kip Cole"],
+      licenses: ["Apache 2.0"],
+      logo: "logo.png",
+      links: links(),
+      files: [
+        "lib",
+        "logo.png",
+        "mix.exs",
+        "README*",
+        "CHANGELOG*",
+        "LICENSE*"
+      ]
+    ]
+  end
+
+  def application do
+    [
+      extra_applications: [:logger]
+    ]
+  end
+
+  defp deps do
+    [
+      {:ex_unicode, "~> 1.1"},
+      {:unicode_set, "~> 0.1"},
+      {:nimble_parsec, "~> 0.5", runtime: false},
+      {:benchee, "~> 1.0", only: :dev},
+      {:ex_doc, "~> 0.19", only: [:dev, :test, :release], runtime: false}
+    ]
+  end
+
+  def links do
+    %{
+      "GitHub" => "https://github.com/elixir-unicode/unicode_guards",
+      "Readme" => "https://github.com/elixir-unicode/unicode_guards/blob/v#{@version}/README.md",
+      "Changelog" => "https://github.com/elixir-unicode/unicode_guards/blob/v#{@version}/CHANGELOG.md"
+    }
+  end
+
+  def docs do
+    [
+      source_ref: "v#{@version}",
+      main: "readme",
+      logo: "logo.png",
+      extras: [
+        "README.md",
+        "LICENSE.md",
+        "CHANGELOG.md"
+      ],
+      skip_undefined_reference_warnings_on: ["changelog"]
+    ]
+  end
+
+  defp elixirc_paths(:test), do: ["lib", "test"]
+  defp elixirc_paths(:dev), do: ["lib", "bench"]
+  defp elixirc_paths(_), do: ["lib"]
+end

mix.exs

@@ -0,0 +1,11 @@
+%{
+  "benchee": {:hex, :benchee, "1.0.1", "66b211f9bfd84bd97e6d1beaddf8fc2312aaabe192f776e8931cb0c16f53a521", [:mix], [{:deep_merge, "~> 1.0", [hex: :deep_merge, repo: "hexpm", optional: false]}], "hexpm"},
+  "deep_merge": {:hex, :deep_merge, "1.0.0", "b4aa1a0d1acac393bdf38b2291af38cb1d4a52806cf7a4906f718e1feb5ee961", [:mix], [], "hexpm"},
+  "earmark": {:hex, :earmark, "1.4.2", "3aa0bd23bc4c61cf2f1e5d752d1bb470560a6f8539974f767a38923bb20e1d7f", [:mix], [], "hexpm"},
+  "ex_doc": {:hex, :ex_doc, "0.21.2", "caca5bc28ed7b3bdc0b662f8afe2bee1eedb5c3cf7b322feeeb7c6ebbde089d6", [:mix], [{:earmark, "~> 1.3.3 or ~> 1.4", [hex: :earmark, repo: "hexpm", optional: false]}, {:makeup_elixir, "~> 0.14", [hex: :makeup_elixir, repo: "hexpm", optional: false]}], "hexpm"},
+  "ex_unicode": {:hex, :ex_unicode, "1.1.0", "95e8ed3fb3a3688a365c85a60e2aa79a20426ed3d2ca1516389324f71efca842", [:mix], [], "hexpm"},
+  "makeup": {:hex, :makeup, "1.0.0", "671df94cf5a594b739ce03b0d0316aa64312cee2574b6a44becb83cd90fb05dc", [:mix], [{:nimble_parsec, "~> 0.5.0", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm"},
+  "makeup_elixir": {:hex, :makeup_elixir, "0.14.0", "cf8b7c66ad1cff4c14679698d532f0b5d45a3968ffbcbfd590339cb57742f1ae", [:mix], [{:makeup, "~> 1.0", [hex: :makeup, repo: "hexpm", optional: false]}], "hexpm"},
+  "nimble_parsec": {:hex, :nimble_parsec, "0.5.2", "1d71150d5293d703a9c38d4329da57d3935faed2031d64bc19e77b654ef2d177", [:mix], [], "hexpm"},
+  "unicode_set": {:hex, :unicode_set, "0.1.0", "d32d23953702baeb89da0486cad22eeb8817bb8050571250248da443ba73983a", [:mix], [{:ex_unicode, "~> 1.1", [hex: :ex_unicode, repo: "hexpm", optional: false]}, {:nimble_parsec, "~> 0.5", [hex: :nimble_parsec, repo: "hexpm", optional: false]}], "hexpm"},
+}

mix.lock

@@ -0,0 +1 @@
+ExUnit.start()