Datasets:

mvkvc

/

stack_elixir

like 0

f7dcdfd5b158850246f0cfffd18a874462beb4c7

ex

Elixir

lib/learn/api/lti.ex

mark-b-kauffman/bblearn_rest_client

63fb0da9b8027e385df927f43ec5e9ea4a517570

lib/learn/api/lti.ex

mark-b-kauffman/bblearn_rest_client

63fb0da9b8027e385df927f43ec5e9ea4a517570

lib/learn/api/lti.ex

mark-b-kauffman/bblearn_rest_client

63fb0da9b8027e385df927f43ec5e9ea4a517570

defmodule Learn.Api.Lti do require IEx @moduledoc """ Learn.Api.Lti """ @v1_lti_placements "/learn/api/public/v1/lti/placements" # Since: 3300.0.0 ## LTI ## Functions that call the @v1_lti endpoints def get_v1_lti_placements(rest_client, params \\ %{}) do params = %{offset: 0} |> Map.merge(params) paramlist = URI.encode_query(params) # Turn the map into a parameter list string in one fell swoop. url = "https://#{rest_client.fqdn}#{@v1_lti_placements}?#{paramlist}" headers = [{"Content-Type", "application/json"}, {"Authorization", "Bearer #{rest_client.token["access_token"]}"}] options = [] {status, response} = HTTPoison.get url, headers, options {status, response} end ## LTI convenience functions that call the current version def get_lti_placements(rest_client, params \\ %{}) do {code, response} = get_v1_lti_placements(rest_client, params) {code, response} end end

f7dcf02d01ecade607b584790004a884f58f04ec

exs

Elixir

test/ecto/multi_test.exs

ohta-rh/ecto

d5f8bfdfcc6fcfb520c62bbd1dbdd8ee6f09de59

test/ecto/multi_test.exs

ohta-rh/ecto

d5f8bfdfcc6fcfb520c62bbd1dbdd8ee6f09de59

test/ecto/multi_test.exs

ohta-rh/ecto

d5f8bfdfcc6fcfb520c62bbd1dbdd8ee6f09de59

defmodule Ecto.MultiTest do use ExUnit.Case, async: true doctest Ecto.Multi alias Ecto.Multi alias Ecto.Changeset alias Ecto.TestRepo defmodule Comment do use Ecto.Schema schema "comments" do field :x, :integer field :parent_x, :integer end end def ok(x), do: {:ok, x} def multi(x), do: Multi.new |> Multi.update(:update, Changeset.change(x.insert)) test "new" do assert Multi.new == %Multi{} end test "insert changeset" do changeset = Changeset.change(%Comment{}) multi = Multi.new |> Multi.insert(:comment, changeset) assert multi.names == MapSet.new([:comment]) assert multi.operations == [{:comment, {:changeset, %{changeset | action: :insert}, []}}] end test "insert struct" do struct = %Comment{} changeset = Changeset.change(struct) multi = Multi.new |> Multi.insert(:comment, struct) assert multi.names == MapSet.new([:comment]) assert multi.operations == [{:comment, {:changeset, %{changeset | action: :insert}, []}}] end test "update changeset" do changeset = Changeset.change(%Comment{}) multi = Multi.new |> Multi.update(:comment, changeset) assert multi.names == MapSet.new([:comment]) assert multi.operations == [{:comment, {:changeset, %{changeset | action: :update}, []}}] end test "delete changeset" do changeset = Changeset.change(%Comment{}) multi = Multi.new |> Multi.delete(:comment, changeset) assert multi.names == MapSet.new([:comment]) assert multi.operations == [{:comment, {:changeset, %{changeset | action: :delete}, []}}] end test "delete struct" do struct = %Comment{} changeset = Changeset.change(struct) multi = Multi.new |> Multi.delete(:comment, struct) assert multi.names == MapSet.new([:comment]) assert multi.operations == [{:comment, {:changeset, %{changeset | action: :delete}, []}}] end test "error" do multi = Multi.new |> Multi.error(:oops, :value) assert multi.names == MapSet.new([:oops]) assert multi.operations == [{:oops, {:error, :value}}] end test "run with fun" do fun = fn changes -> {:ok, changes} end multi = Multi.new |> Multi.run(:fun, fun) assert multi.names == MapSet.new([:fun]) assert multi.operations == [{:fun, {:run, fun}}] end test "run named with tuple" do fun = fn changes -> {:ok, changes} end multi = Multi.new |> Multi.run({:fun, 3}, fun) assert multi.names == MapSet.new([{:fun, 3}]) assert multi.operations == [{{:fun, 3}, {:run, fun}}] end test "run named with char_list" do fun = fn changes -> {:ok, changes} end multi = Multi.new |> Multi.run('myFunction', fun) assert multi.names == MapSet.new(['myFunction']) assert multi.operations == [{'myFunction', {:run, fun}}] end test "run with mfa" do multi = Multi.new |> Multi.run(:fun, __MODULE__, :ok, []) assert multi.names == MapSet.new([:fun]) assert multi.operations == [{:fun, {:run, {__MODULE__, :ok, []}}}] end test "insert_all" do multi = Multi.new |> Multi.insert_all(:comments, Comment, [[x: 2]]) assert multi.names == MapSet.new([:comments]) assert [{:comments, {:insert_all, Comment, [[x: 2]], []}}] = multi.operations end test "update_all" do multi = Multi.new |> Multi.update_all(:comments, Comment, set: [x: 2]) assert multi.names == MapSet.new([:comments]) assert [{:comments, {:update_all, query, updates, []}}] = multi.operations assert updates == [set: [x: 2]] assert query == Ecto.Queryable.to_query(Comment) end test "delete_all" do multi = Multi.new |> Multi.delete_all(:comments, Comment) assert multi.names == MapSet.new([:comments]) assert [{:comments, {:delete_all, query, []}}] = multi.operations assert query == Ecto.Queryable.to_query(Comment) end test "append/prepend without repetition" do fun = fn _ -> {:ok, :ok} end lhs = Multi.new |> Multi.run(:one, fun) |> Multi.run(:two, fun) rhs = Multi.new |> Multi.run(:three, fun) |> Multi.run(:four, fun) merged = Multi.append(lhs, rhs) operations = Keyword.keys(merged.operations) assert merged.names == MapSet.new([:one, :two, :three, :four]) assert operations == [:four, :three, :two, :one] merged = Multi.prepend(lhs, rhs) operations = Keyword.keys(merged.operations) assert merged.names == MapSet.new([:one, :two, :three, :four]) assert operations == [:two, :one, :four, :three] end test "append/prepend with repetition" do fun = fn _ -> {:ok, :ok} end multi = Multi.new |> Multi.run(:run, fun) assert_raise ArgumentError, ~r"both declared operations: \[:run\]", fn -> Multi.append(multi, multi) end assert_raise ArgumentError, ~r"both declared operations: \[:run\]", fn -> Multi.prepend(multi, multi) end end test "to_list" do changeset = Changeset.change(%Comment{id: 1}, x: 1) multi = Multi.new |> Multi.insert(:insert, changeset) |> Multi.run(:run, fn changes -> {:ok, changes} end) |> Multi.update(:update, changeset) |> Multi.delete(:delete, changeset) |> Multi.insert_all(:insert_all, Comment, [[x: 1]]) |> Multi.update_all(:update_all, Comment, set: [x: 1]) |> Multi.delete_all(:delete_all, Comment) assert [ {:insert, {:insert, _, []}}, {:run, {:run, _}}, {:update, {:update, _, []}}, {:delete, {:delete, _, []}}, {:insert_all, {:insert_all, _, _, []}}, {:update_all, {:update_all, _, _, []}}, {:delete_all, {:delete_all, _, []}}, ] = Ecto.Multi.to_list(multi) end test "add changeset with invalid action" do changeset = %{Changeset.change(%Comment{}) | action: :invalid} assert_raise ArgumentError, ~r"an action already set to :invalid", fn -> Multi.new |> Multi.insert(:changeset, changeset) end end test "add run with invalid arity" do assert_raise FunctionClauseError, fn -> Multi.new |> Multi.run(:run, fn -> nil end) end end test "repeating an operation" do fun = fn _ -> {:ok, :ok} end assert_raise RuntimeError, ~r":run is already a member", fn -> Multi.new |> Multi.run(:run, fun) |> Multi.run(:run, fun) end end describe "merge/2" do test "with fun" do changeset = Changeset.change(%Comment{}) multi = Multi.new |> Multi.insert(:insert, changeset) |> Multi.merge(fn data -> Multi.new |> Multi.update(:update, Changeset.change(data.insert)) end) assert {:ok, data} = TestRepo.transaction(multi) assert %Comment{} = data.insert assert %Comment{} = data.update end test "with mfa" do changeset = Changeset.change(%Comment{}) multi = Multi.new |> Multi.insert(:insert, changeset) |> Multi.merge(__MODULE__, :multi, []) assert {:ok, data} = TestRepo.transaction(multi) assert %Comment{} = data.insert assert %Comment{} = data.update end test "rollbacks on errors" do error = fn _ -> {:error, :error} end ok = fn _ -> {:ok, :ok} end multi = Multi.new |> Multi.run(:outside_ok, ok) |> Multi.merge(fn _ -> Multi.new |> Multi.run(:inside_ok, ok) |> Multi.run(:inside_error, error) end) |> Multi.run(:outside_error, error) assert {:error, :inside_error, :error, data} = TestRepo.transaction(multi) assert :ok == data.outside_ok assert :ok == data.inside_ok end test "does not allow repeated operations" do fun = fn _ -> {:ok, :ok} end multi = Multi.new |> Multi.merge(fn _ -> Multi.new |> Multi.run(:run, fun) end) |> Multi.run(:run, fun) assert_raise RuntimeError, ~r"found in both Ecto.Multi: \[:run\]", fn -> TestRepo.transaction(multi) end multi = Multi.new |> Multi.merge(fn _ -> Multi.new |> Multi.run(:run, fun) end) |> Multi.merge(fn _ -> Multi.new |> Multi.run(:run, fun) end) assert_raise RuntimeError, ~r"found in both Ecto.Multi: \[:run\]", fn -> TestRepo.transaction(multi) end end end describe "Repo.transaction" do test "on success" do changeset = Changeset.change(%Comment{id: 1}, x: 1) multi = Multi.new |> Multi.insert(:insert, changeset) |> Multi.run(:run, fn changes -> {:ok, changes} end) |> Multi.update(:update, changeset) |> Multi.delete(:delete, changeset) |> Multi.insert_all(:insert_all, Comment, [[x: 1]]) |> Multi.update_all(:update_all, Comment, set: [x: 1]) |> Multi.delete_all(:delete_all, Comment) assert {:ok, changes} = TestRepo.transaction(multi) assert_received {:transaction, _} assert {:messages, actions} = Process.info(self(), :messages) assert actions == [{:insert, {nil, "comments"}}, {:update, {nil, "comments"}}, {:delete, {nil, "comments"}}, {:insert_all, {nil, "comments"}, [[x: 1]]}, {:update_all, {nil, "comments"}}, {:delete_all, {nil, "comments"}}] assert %Comment{} = changes.insert assert %Comment{} = changes.update assert %Comment{} = changes.delete assert {1, nil} = changes.insert_all assert {1, nil} = changes.update_all assert {1, nil} = changes.delete_all assert Map.has_key?(changes.run, :insert) refute Map.has_key?(changes.run, :update) end test "with empty multi" do assert {:ok, changes} = TestRepo.transaction(Multi.new) refute_received {:transaction, _} assert changes == %{} end test "rolls back from run" do changeset = Changeset.change(%Comment{id: 1}, x: 1) multi = Multi.new |> Multi.insert(:insert, changeset) |> Multi.run(:run, fn _changes -> {:error, "error from run"} end) |> Multi.update(:update, changeset) |> Multi.delete(:delete, changeset) assert {:error, :run, "error from run", changes} = TestRepo.transaction(multi) assert_received {:transaction, _} assert_received {:rollback, _} assert {:messages, [{:insert, {nil, "comments"}}]} == Process.info(self(), :messages) assert %Comment{} = changes.insert refute Map.has_key?(changes, :run) refute Map.has_key?(changes, :update) end test "rolls back on error" do changeset = Changeset.change(%Comment{id: 1}, x: 1) multi = Multi.new |> Multi.insert(:insert, changeset) |> Multi.error(:oops, "explicit error") |> Multi.update(:update, changeset) |> Multi.delete(:delete, changeset) assert {:error, :oops, "explicit error", changes} = TestRepo.transaction(multi) assert_received {:transaction, _} assert_received {:rollback, _} assert {:messages, [{:insert, {nil, "comments"}}]} == Process.info(self(), :messages) assert %Comment{} = changes.insert refute Map.has_key?(changes, :run) refute Map.has_key?(changes, :update) end test "rolls back from repo" do changeset = Changeset.change(%Comment{id: 1}, x: 1) invalid = put_in(changeset.data.__meta__.context, {:invalid, [unique: "comments_x_index"]}) |> Changeset.unique_constraint(:x) multi = Multi.new |> Multi.insert(:insert, changeset) |> Multi.run(:run, fn _changes -> {:ok, "ok"} end) |> Multi.update(:update, invalid) |> Multi.delete(:delete, changeset) assert {:error, :update, error, changes} = TestRepo.transaction(multi) assert_received {:transaction, _} assert_received {:rollback, _} assert {:messages, [{:insert, {nil, "comments"}}]} == Process.info(self(), :messages) assert %Comment{} = changes.insert assert "ok" == changes.run assert error.errors == [x: {"has already been taken", []}] refute Map.has_key?(changes, :update) end test "checks invalid changesets before starting transaction" do changeset = %{Changeset.change(%Comment{}) | valid?: false} multi = Multi.new |> Multi.insert(:invalid, changeset) assert {:error, :invalid, invalid, %{}} = TestRepo.transaction(multi) assert invalid.data == changeset.data refute_received {:transaction, _} end end end

f7dd1fd2ca9c8ef9fa3aca8ba0452ab2751ac8c1

ex

Elixir

lib/elixir/lib/exception.ex

rcoppolo/elixir

c4092e071f8b42f5a9ad213dd8b3632918097213

lib/elixir/lib/exception.ex

rcoppolo/elixir

c4092e071f8b42f5a9ad213dd8b3632918097213

lib/elixir/lib/exception.ex

rcoppolo/elixir

c4092e071f8b42f5a9ad213dd8b3632918097213

defmodule Exception do @moduledoc """ Functions to format throw/catch/exit and exceptions. Note that stacktraces in Elixir are updated on throw, errors and exits. For example, at any given moment, `System.stacktrace/0` will return the stacktrace for the last throw/error/exit that occurred in the current process. Do not rely on the particular format returned by the `format*` functions in this module. They may be changed in future releases in order to better suit Elixir's tool chain. In other words, by using the functions in this module it is guaranteed you will format exceptions as in the current Elixir version being used. """ @typedoc "The exception type" @type t :: %{ required(:__struct__) => module, required(:__exception__) => true, atom => any } @typedoc "The kind handled by formatting functions" @type kind :: :error | :exit | :throw | {:EXIT, pid} @type stacktrace :: [stacktrace_entry] @type stacktrace_entry :: {module, atom, arity_or_args, location} | {(... -> any), arity_or_args, location} @typep arity_or_args :: non_neg_integer | list @typep location :: Keyword.t @callback exception(term) :: t @callback message(t) :: String.t @doc """ Returns `true` if the given `term` is an exception. """ def exception?(term) def exception?(%{__struct__: struct, __exception__: true}) when is_atom(struct), do: true def exception?(_), do: false @doc """ Gets the message for an `exception`. """ def message(%{__struct__: module, __exception__: true} = exception) when is_atom(module) do try do module.message(exception) rescue e -> "got #{inspect e.__struct__} with message #{inspect message(e)} " <> "while retrieving Exception.message/1 for #{inspect(exception)}" else x when is_binary(x) -> x x -> "got #{inspect(x)} " <> "while retrieving Exception.message/1 for #{inspect(exception)} " <> "(expected a string)" end end @doc """ Normalizes an exception, converting Erlang exceptions to Elixir exceptions. It takes the `kind` spilled by `catch` as an argument and normalizes only `:error`, returning the untouched payload for others. The third argument, a stacktrace, is optional. If it is not supplied `System.stacktrace/0` will sometimes be used to get additional information for the `kind` `:error`. If the stacktrace is unknown and `System.stacktrace/0` would not return the stacktrace corresponding to the exception an empty stacktrace, `[]`, must be used. """ @spec normalize(:error, any, stacktrace) :: t @spec normalize(kind, payload, stacktrace) :: payload when payload: var # Generating a stacktrace is expensive, default to nil # to only fetch it when needed. def normalize(kind, payload, stacktrace \\ nil) def normalize(:error, exception, stacktrace) do if exception?(exception) do exception else ErlangError.normalize(exception, stacktrace) end end def normalize(_kind, payload, _stacktrace) do payload end @doc """ Normalizes and formats any throw/error/exit. The message is formatted and displayed in the same format as used by Elixir's CLI. The third argument, a stacktrace, is optional. If it is not supplied `System.stacktrace/0` will sometimes be used to get additional information for the `kind` `:error`. If the stacktrace is unknown and `System.stacktrace/0` would not return the stacktrace corresponding to the exception an empty stacktrace, `[]`, must be used. """ @spec format_banner(kind, any, stacktrace | nil) :: String.t def format_banner(kind, exception, stacktrace \\ nil) def format_banner(:error, exception, stacktrace) do exception = normalize(:error, exception, stacktrace) "** (" <> inspect(exception.__struct__) <> ") " <> message(exception) end def format_banner(:throw, reason, _stacktrace) do "** (throw) " <> inspect(reason) end def format_banner(:exit, reason, _stacktrace) do "** (exit) " <> format_exit(reason, <<"\n ">>) end def format_banner({:EXIT, pid}, reason, _stacktrace) do "** (EXIT from #{inspect pid}) " <> format_exit(reason, <<"\n ">>) end @doc """ Normalizes and formats throw/errors/exits and stacktraces. It relies on `format_banner/3` and `format_stacktrace/1` to generate the final format. Note that `{:EXIT, pid}` do not generate a stacktrace though (as they are retrieved as messages without stacktraces). """ @spec format(kind, any, stacktrace | nil) :: String.t def format(kind, payload, stacktrace \\ nil) def format({:EXIT, _} = kind, any, _) do format_banner(kind, any) end def format(kind, payload, stacktrace) do stacktrace = stacktrace || System.stacktrace message = format_banner(kind, payload, stacktrace) case stacktrace do [] -> message _ -> message <> "\n" <> format_stacktrace(stacktrace) end end @doc """ Formats an exit. It returns a string. Often there are errors/exceptions inside exits. Exits are often wrapped by the caller and provide stacktraces too. This function formats exits in a way to nicely show the exit reason, caller and stacktrace. """ @spec format_exit(any) :: String.t def format_exit(reason) do format_exit(reason, <<"\n ">>) end # 2-Tuple could be caused by an error if the second element is a stacktrace. defp format_exit({exception, maybe_stacktrace} = reason, joiner) when is_list(maybe_stacktrace) and maybe_stacktrace !== [] do try do Enum.map(maybe_stacktrace, &format_stacktrace_entry/1) else formatted_stacktrace -> # Assume a non-empty list formattable as stacktrace is a # stacktrace, so exit was caused by an error. message = "an exception was raised:" <> joiner <> format_banner(:error, exception, maybe_stacktrace) Enum.join([message | formatted_stacktrace], joiner <> <<" ">>) catch :error, _ -> # Not a stacktrace, was an exit. format_exit_reason(reason) end end # :supervisor.start_link returns this error reason when it fails to init # because a child's start_link raises. defp format_exit({:shutdown, {:failed_to_start_child, child, {:EXIT, reason}}}, joiner) do format_start_child(child, reason, joiner) end # :supervisor.start_link returns this error reason when it fails to init # because a child's start_link returns {:error, reason}. defp format_exit({:shutdown, {:failed_to_start_child, child, reason}}, joiner) do format_start_child(child, reason, joiner) end # 2-Tuple could be an exit caused by mfa if second element is mfa, args # must be a list of arguments - max length 255 due to max arity. defp format_exit({reason2, {mod, fun, args}} = reason, joiner) when length(args) < 256 do try do format_mfa(mod, fun, args) else mfa -> # Assume tuple formattable as an mfa is an mfa, so exit was caused by # failed mfa. "exited in: " <> mfa <> joiner <> "** (EXIT) " <> format_exit(reason2, joiner <> <<" ">>) catch :error, _ -> # Not an mfa, was an exit. format_exit_reason(reason) end end defp format_exit(reason, _joiner) do format_exit_reason(reason) end defp format_exit_reason(:normal), do: "normal" defp format_exit_reason(:shutdown), do: "shutdown" defp format_exit_reason({:shutdown, reason}) do "shutdown: #{inspect(reason)}" end defp format_exit_reason(:calling_self), do: "process attempted to call itself" defp format_exit_reason(:timeout), do: "time out" defp format_exit_reason(:killed), do: "killed" defp format_exit_reason(:noconnection), do: "no connection" defp format_exit_reason(:noproc) do "no process: the process is not alive or there's no process currently associated with the given name, possibly because its application isn't started" end defp format_exit_reason({:nodedown, node_name}) when is_atom(node_name) do "no connection to #{node_name}" end # :gen_server exit reasons defp format_exit_reason({:already_started, pid}) do "already started: " <> inspect(pid) end defp format_exit_reason({:bad_return_value, value}) do "bad return value: " <> inspect(value) end defp format_exit_reason({:bad_call, request}) do "bad call: " <> inspect(request) end defp format_exit_reason({:bad_cast, request}) do "bad cast: " <> inspect(request) end # :supervisor.start_link error reasons # If value is a list will be formatted by mfa exit in format_exit/1 defp format_exit_reason({:bad_return, {mod, :init, value}}) when is_atom(mod) do format_mfa(mod, :init, 1) <> " returned a bad value: " <> inspect(value) end defp format_exit_reason({:bad_start_spec, start_spec}) do "bad start spec: invalid children: " <> inspect(start_spec) end defp format_exit_reason({:start_spec, start_spec}) do "bad start spec: " <> format_sup_spec(start_spec) end defp format_exit_reason({:supervisor_data, data}) do "bad supervisor data: " <> format_sup_data(data) end defp format_exit_reason(reason), do: inspect(reason) defp format_start_child(child, reason, joiner) do "shutdown: failed to start child: " <> inspect(child) <> joiner <> "** (EXIT) " <> format_exit(reason, joiner <> <<" ">>) end defp format_sup_data({:invalid_type, type}) do "invalid type: " <> inspect(type) end defp format_sup_data({:invalid_strategy, strategy}) do "invalid strategy: " <> inspect(strategy) end defp format_sup_data({:invalid_intensity, intensity}) do "invalid intensity: " <> inspect(intensity) end defp format_sup_data({:invalid_period, period}) do "invalid period: " <> inspect(period) end defp format_sup_data(other), do: inspect(other) defp format_sup_spec({:invalid_child_spec, child_spec}) do "invalid child spec: " <> inspect(child_spec) end defp format_sup_spec({:invalid_child_type, type}) do "invalid child type: " <> inspect(type) end defp format_sup_spec({:invalid_mfa, mfa}) do "invalid mfa: " <> inspect(mfa) end defp format_sup_spec({:invalid_restart_type, restart}) do "invalid restart type: " <> inspect(restart) end defp format_sup_spec({:invalid_shutdown, shutdown}) do "invalid shutdown: " <> inspect(shutdown) end defp format_sup_spec({:invalid_module, mod}) do "invalid module: " <> inspect(mod) end defp format_sup_spec({:invalid_modules, modules}) do "invalid modules: " <> inspect(modules) end defp format_sup_spec(other), do: inspect(other) @doc """ Receives a stacktrace entry and formats it into a string. """ @spec format_stacktrace_entry(stacktrace_entry) :: String.t def format_stacktrace_entry(entry) # From Macro.Env.stacktrace def format_stacktrace_entry({module, :__MODULE__, 0, location}) do format_location(location) <> inspect(module) <> " (module)" end # From :elixir_compiler_* def format_stacktrace_entry({_module, :__MODULE__, 1, location}) do format_location(location) <> "(module)" end # From :elixir_compiler_* def format_stacktrace_entry({_module, :__FILE__, 1, location}) do format_location(location) <> "(file)" end def format_stacktrace_entry({module, fun, arity, location}) do format_application(module) <> format_location(location) <> format_mfa(module, fun, arity) end def format_stacktrace_entry({fun, arity, location}) do format_location(location) <> format_fa(fun, arity) end defp format_application(module) do # We cannot use Application due to bootstrap issues case :application.get_application(module) do {:ok, app} -> "(" <> Atom.to_string(app) <> ") " :undefined -> "" end end @doc """ Formats the stacktrace. A stacktrace must be given as an argument. If not, the stacktrace is retrieved from `Process.info/2`. """ def format_stacktrace(trace \\ nil) do trace = trace || case Process.info(self(), :current_stacktrace) do {:current_stacktrace, t} -> Enum.drop(t, 3) end case trace do [] -> "\n" _ -> " " <> Enum.map_join(trace, "\n ", &format_stacktrace_entry(&1)) <> "\n" end end @doc """ Receives an anonymous function and arity and formats it as shown in stacktraces. The arity may also be a list of arguments. ## Examples Exception.format_fa(fn -> nil end, 1) #=> "#Function<...>/1" """ def format_fa(fun, arity) when is_function(fun) do "#{inspect fun}#{format_arity(arity)}" end @doc """ Receives a module, fun and arity and formats it as shown in stacktraces. The arity may also be a list of arguments. ## Examples iex> Exception.format_mfa Foo, :bar, 1 "Foo.bar/1" iex> Exception.format_mfa Foo, :bar, [] "Foo.bar()" iex> Exception.format_mfa nil, :bar, [] "nil.bar()" Anonymous functions are reported as -func/arity-anonfn-count-, where func is the name of the enclosing function. Convert to "anonymous fn in func/arity" """ def format_mfa(module, fun, arity) when is_atom(module) and is_atom(fun) do fun = case inspect(fun) do ":" <> fun -> fun fun -> fun end case match?("\"-" <> _, fun) and String.split(fun, "-") do [ "\"", outer_fun, "fun", _count, "\"" ] -> "anonymous fn#{format_arity(arity)} in #{inspect module}.#{outer_fun}" _ -> "#{inspect module}.#{fun}#{format_arity(arity)}" end end defp format_arity(arity) when is_list(arity) do inspected = for x <- arity, do: inspect(x) "(#{Enum.join(inspected, ", ")})" end defp format_arity(arity) when is_integer(arity) do "/" <> Integer.to_string(arity) end @doc """ Formats the given `file` and `line` as shown in stacktraces. If any of the values are `nil`, they are omitted. ## Examples iex> Exception.format_file_line("foo", 1) "foo:1:" iex> Exception.format_file_line("foo", nil) "foo:" iex> Exception.format_file_line(nil, nil) "" """ def format_file_line(file, line, suffix \\ "") do if file do if line && line != 0 do "#{file}:#{line}:#{suffix}" else "#{file}:#{suffix}" end else "" end end defp format_location(opts) when is_list(opts) do format_file_line Keyword.get(opts, :file), Keyword.get(opts, :line), " " end end # Some exceptions implement "message/1" instead of "exception/1" mostly # for bootstrap reasons. It is recommended for applications to implement # "exception/1" instead of "message/1" as described in "defexception/1" # docs. defmodule RuntimeError do defexception message: "runtime error" end defmodule ArgumentError do defexception message: "argument error" end defmodule ArithmeticError do defexception message: "bad argument in arithmetic expression" end defmodule SystemLimitError do defexception [] def message(_) do "a system limit has been reached" end end defmodule SyntaxError do defexception [:file, :line, description: "syntax error"] def message(exception) do Exception.format_file_line(Path.relative_to_cwd(exception.file), exception.line) <> " " <> exception.description end end defmodule TokenMissingError do defexception [:file, :line, description: "expression is incomplete"] def message(%{file: file, line: line, description: description}) do Exception.format_file_line(file && Path.relative_to_cwd(file), line) <> " " <> description end end defmodule CompileError do defexception [:file, :line, description: "compile error"] def message(%{file: file, line: line, description: description}) do Exception.format_file_line(file && Path.relative_to_cwd(file), line) <> " " <> description end end defmodule BadFunctionError do defexception [:term] def message(exception) do "expected a function, got: #{inspect(exception.term)}" end end defmodule BadStructError do defexception [:struct, :term] def message(exception) do "expected a struct named #{inspect(exception.struct)}, got: #{inspect(exception.term)}" end end defmodule BadMapError do defexception [:term] def message(exception) do "expected a map, got: #{inspect(exception.term)}" end end defmodule MatchError do defexception [:term] def message(exception) do "no match of right hand side value: #{inspect(exception.term)}" end end defmodule CaseClauseError do defexception [:term] def message(exception) do "no case clause matching: #{inspect(exception.term)}" end end defmodule WithClauseError do defexception [:term] def message(exception) do "no with clause matching: #{inspect(exception.term)}" end end defmodule CondClauseError do defexception [] def message(_exception) do "no cond clause evaluated to a true value" end end defmodule TryClauseError do defexception [:term] def message(exception) do "no try clause matching: #{inspect(exception.term)}" end end defmodule BadArityError do defexception [:function, :args] def message(exception) do fun = exception.function args = exception.args insp = Enum.map_join(args, ", ", &inspect/1) {:arity, arity} = :erlang.fun_info(fun, :arity) "#{inspect(fun)} with arity #{arity} called with #{count(length(args), insp)}" end defp count(0, _insp), do: "no arguments" defp count(1, insp), do: "1 argument (#{insp})" defp count(x, insp), do: "#{x} arguments (#{insp})" end defmodule UndefinedFunctionError do defexception [:module, :function, :arity, :reason, :exports] def message(%{reason: nil, module: module, function: function, arity: arity} = e) do cond do is_nil(function) or is_nil(arity) -> "undefined function" not is_nil(module) and :code.is_loaded(module) === false -> message(%{e | reason: :"module could not be loaded"}) true -> message(%{e | reason: :"function not exported"}) end end def message(%{reason: :"module could not be loaded", module: module, function: function, arity: arity}) do "function " <> Exception.format_mfa(module, function, arity) <> " is undefined (module #{inspect module} is not available)" end def message(%{reason: :"function not exported", module: module, function: function, arity: arity, exports: exports}) do suffix = if macro_exported?(module, function, arity) do " but #{inspect(module)} defines a macro with the same name and arity." <> " Be sure to require #{inspect(module)} if you intend to invoke this macro" else did_you_mean(module, function, arity, exports) end "function " <> Exception.format_mfa(module, function, arity) <> " is undefined or private" <> suffix end def message(%{reason: :"function not available", module: module, function: function, arity: arity}) do "nil." <> fa = Exception.format_mfa(nil, function, arity) "function " <> Exception.format_mfa(module, function, arity) <> " is undefined (function #{fa} is not available)" end def message(%{reason: reason, module: module, function: function, arity: arity}) do "function " <> Exception.format_mfa(module, function, arity) <> " is undefined (#{reason})" end @function_threshold 0.77 @max_suggestions 5 defp did_you_mean(module, function, _arity, exports) do exports = exports || exports_for(module) result = case Keyword.take(exports, [function]) do [] -> base = Atom.to_string(function) for {key, val} <- exports, dist = String.jaro_distance(base, Atom.to_string(key)), dist >= @function_threshold, do: {dist, key, val} arities -> for {key, val} <- arities, do: {1.0, key, val} end |> Enum.sort(&elem(&1, 0) >= elem(&2, 0)) |> Enum.take(@max_suggestions) |> Enum.sort(&elem(&1, 1) <= elem(&2, 1)) case result do [] -> "" suggestions -> ". Did you mean one of:\n\n#{Enum.map(suggestions, &format_fa/1)}" end end defp format_fa({_dist, fun, arity}) do fun = with ":" <> fun <- inspect(fun), do: fun " * " <> fun <> "/" <> Integer.to_string(arity) <> "\n" end defp exports_for(module) do if function_exported?(module, :__info__, 1) do module.__info__(:macros) ++ module.__info__(:functions) else module.module_info(:exports) end rescue # In case the module was removed while we are computing this UndefinedFunctionError -> [] end end defmodule FunctionClauseError do defexception [:module, :function, :arity] def message(exception) do if exception.function do formatted = Exception.format_mfa exception.module, exception.function, exception.arity "no function clause matching in #{formatted}" else "no function clause matches" end end end defmodule Code.LoadError do defexception [:file, :message] def exception(opts) do file = Keyword.fetch!(opts, :file) %Code.LoadError{message: "could not load #{file}", file: file} end end defmodule Protocol.UndefinedError do defexception [:protocol, :value, description: ""] def message(exception) do msg = "protocol #{inspect exception.protocol} not implemented for #{inspect exception.value}" case exception.description do "" -> msg descr -> msg <> ", " <> descr end end end defmodule KeyError do defexception [:key, :term] def message(exception) do msg = "key #{inspect exception.key} not found" if exception.term != nil do msg <> " in: #{inspect exception.term}" else msg end end end defmodule UnicodeConversionError do defexception [:encoded, :message] def exception(opts) do %UnicodeConversionError{ encoded: Keyword.fetch!(opts, :encoded), message: "#{Keyword.fetch!(opts, :kind)} #{detail Keyword.fetch!(opts, :rest)}" } end defp detail(rest) when is_binary(rest) do "encoding starting at #{inspect rest}" end defp detail([h | _]) when is_integer(h) do "code point #{h}" end defp detail([h | _]) do detail(h) end end defmodule Enum.OutOfBoundsError do defexception message: "out of bounds error" end defmodule Enum.EmptyError do defexception message: "empty error" end defmodule File.Error do defexception [:reason, :path, action: ""] def message(%{action: action, reason: reason, path: path}) do formatted = case {action, reason} do {"remove directory", :eexist} -> "directory is not empty" _ -> IO.iodata_to_binary(:file.format_error(reason)) end "could not #{action} #{inspect(path)}: #{formatted}" end end defmodule File.CopyError do defexception [:reason, :source, :destination, on: "", action: ""] def message(exception) do formatted = IO.iodata_to_binary(:file.format_error(exception.reason)) location = case exception.on do "" -> "" on -> ". #{on}" end "could not #{exception.action} from #{inspect(exception.source)} to " <> "#{inspect(exception.destination)}#{location}: #{formatted}" end end defmodule ErlangError do defexception [:original] def message(exception) do "erlang error: #{inspect(exception.original)}" end @doc false def normalize(:badarg, _stacktrace) do %ArgumentError{} end def normalize(:badarith, _stacktrace) do %ArithmeticError{} end def normalize(:system_limit, _stacktrace) do %SystemLimitError{} end def normalize(:cond_clause, _stacktrace) do %CondClauseError{} end def normalize({:badarity, {fun, args}}, _stacktrace) do %BadArityError{function: fun, args: args} end def normalize({:badfun, term}, _stacktrace) do %BadFunctionError{term: term} end def normalize({:badstruct, struct, term}, _stacktrace) do %BadStructError{struct: struct, term: term} end def normalize({:badmatch, term}, _stacktrace) do %MatchError{term: term} end def normalize({:badmap, term}, _stacktrace) do %BadMapError{term: term} end def normalize({:badkey, key}, stacktrace) do term = case stacktrace || :erlang.get_stacktrace do [{Map, :get_and_update!, [map, _, _], _} | _] -> map [{Map, :update!, [map, _, _], _} | _] -> map [{:maps, :update, [_, _, map], _} | _] -> map [{:maps, :get, [_, map], _} | _] -> map _ -> nil end %KeyError{key: key, term: term} end def normalize({:badkey, key, map}, _stacktrace) do %KeyError{key: key, term: map} end def normalize({:case_clause, term}, _stacktrace) do %CaseClauseError{term: term} end def normalize({:with_clause, term}, _stacktrace) do %WithClauseError{term: term} end def normalize({:try_clause, term}, _stacktrace) do %TryClauseError{term: term} end def normalize(:undef, stacktrace) do stacktrace = stacktrace || :erlang.get_stacktrace {mod, fun, arity} = from_stacktrace(stacktrace) %UndefinedFunctionError{module: mod, function: fun, arity: arity} end def normalize(:function_clause, stacktrace) do {mod, fun, arity} = from_stacktrace(stacktrace || :erlang.get_stacktrace) %FunctionClauseError{module: mod, function: fun, arity: arity} end def normalize({:badarg, payload}, _stacktrace) do %ArgumentError{message: "argument error: #{inspect(payload)}"} end def normalize(other, _stacktrace) do %ErlangError{original: other} end defp from_stacktrace([{module, function, args, _} | _]) when is_list(args) do {module, function, length(args)} end defp from_stacktrace([{module, function, arity, _} | _]) do {module, function, arity} end defp from_stacktrace(_) do {nil, nil, nil} end end

f7dd85a728a6883276392b5f6637b7f2603cc88f

exs

Elixir

test/phx_pow_web/controllers/page_controller_test.exs

brandedux/phoenix_authentication

a1a5758532a4ece73bfc7319f8c9235b070bd1fe

2019-09-25T22:02:59.000Z

2019-12-18T22:33:34.000Z

test/phx_pow_web/controllers/page_controller_test.exs

brandedux/phoenix_authentication

a1a5758532a4ece73bfc7319f8c9235b070bd1fe

test/phx_pow_web/controllers/page_controller_test.exs

brandedux/phoenix_authentication

a1a5758532a4ece73bfc7319f8c9235b070bd1fe

defmodule PhxPowWeb.PageControllerTest do use PhxPowWeb.ConnCase test "GET /", %{conn: conn} do conn = get(conn, "/") assert html_response(conn, 200) =~ "Welcome to Phoenix!" end end

f7dd89eec3dd071c4317e5ef4396e3982e3dfcd9

ex

Elixir

example/lib/example_web/endpoint.ex

revelrylabs/phoenix_harmonium

41aa64f53fda8af5db0882040e5508d4409996b1

2018-10-03T17:01:35.000Z

2021-12-29T21:13:35.000Z

example/lib/example_web/endpoint.ex

revelrylabs/phoenix_harmonium

41aa64f53fda8af5db0882040e5508d4409996b1

2018-06-13T18:42:35.000Z

2022-03-15T17:18:08.000Z

example/lib/example_web/endpoint.ex

revelrylabs/phoenix_harmonium

41aa64f53fda8af5db0882040e5508d4409996b1

2019-01-08T19:09:28.000Z

2020-05-11T21:01:57.000Z

defmodule ExampleWeb.Endpoint do use Phoenix.Endpoint, otp_app: :example socket "/socket", ExampleWeb.UserSocket, websocket: true, longpoll: false # Serve at "/" the static files from "priv/static" directory. # # You should set gzip to true if you are running phx.digest # when deploying your static files in production. plug Plug.Static, at: "/", from: :example, gzip: false, only: ~w(css fonts images js favicon.ico robots.txt) # Code reloading can be explicitly enabled under the # :code_reloader configuration of your endpoint. if code_reloading? do socket "/phoenix/live_reload/socket", Phoenix.LiveReloader.Socket plug Phoenix.LiveReloader plug Phoenix.CodeReloader end plug Plug.RequestId plug Plug.Logger plug Plug.Parsers, parsers: [:urlencoded, :multipart, :json], pass: ["*/*"], json_decoder: Phoenix.json_library() plug Plug.MethodOverride plug Plug.Head # The session will be stored in the cookie and signed, # this means its contents can be read but not tampered with. # Set :encryption_salt if you would also like to encrypt it. plug Plug.Session, store: :cookie, key: "_example_key", signing_salt: "1H/oIyPc" plug ExampleWeb.Router end

f7ddb9518aef4f5298d94c58182472e11867ed77

ex

Elixir

clients/dfa_reporting/lib/google_api/dfa_reporting/v33/model/report_floodlight_criteria.ex

medikent/elixir-google-api

98a83d4f7bfaeac15b67b04548711bb7e49f9490

clients/dfa_reporting/lib/google_api/dfa_reporting/v33/model/report_floodlight_criteria.ex

medikent/elixir-google-api

98a83d4f7bfaeac15b67b04548711bb7e49f9490

clients/dfa_reporting/lib/google_api/dfa_reporting/v33/model/report_floodlight_criteria.ex

medikent/elixir-google-api

98a83d4f7bfaeac15b67b04548711bb7e49f9490

# Copyright 2019 Google LLC # # 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. # NOTE: This file is auto generated by the elixir code generator program. # Do not edit this file manually. defmodule GoogleApi.DFAReporting.V33.Model.ReportFloodlightCriteria do @moduledoc """ The report criteria for a report of type "FLOODLIGHT". ## Attributes * `customRichMediaEvents` (*type:* `list(GoogleApi.DFAReporting.V33.Model.DimensionValue.t)`, *default:* `nil`) - The list of custom rich media events to include. * `dateRange` (*type:* `GoogleApi.DFAReporting.V33.Model.DateRange.t`, *default:* `nil`) - The date range this report should be run for. * `dimensionFilters` (*type:* `list(GoogleApi.DFAReporting.V33.Model.DimensionValue.t)`, *default:* `nil`) - The list of filters on which dimensions are filtered. Filters for different dimensions are ANDed, filters for the same dimension are grouped together and ORed. * `dimensions` (*type:* `list(GoogleApi.DFAReporting.V33.Model.SortedDimension.t)`, *default:* `nil`) - The list of dimensions the report should include. * `floodlightConfigId` (*type:* `GoogleApi.DFAReporting.V33.Model.DimensionValue.t`, *default:* `nil`) - The floodlight ID for which to show data in this report. All advertisers associated with that ID will automatically be added. The dimension of the value needs to be 'dfa:floodlightConfigId'. * `metricNames` (*type:* `list(String.t)`, *default:* `nil`) - The list of names of metrics the report should include. * `reportProperties` (*type:* `GoogleApi.DFAReporting.V33.Model.ReportFloodlightCriteriaReportProperties.t`, *default:* `nil`) - The properties of the report. """ use GoogleApi.Gax.ModelBase @type t :: %__MODULE__{ :customRichMediaEvents => list(GoogleApi.DFAReporting.V33.Model.DimensionValue.t()), :dateRange => GoogleApi.DFAReporting.V33.Model.DateRange.t(), :dimensionFilters => list(GoogleApi.DFAReporting.V33.Model.DimensionValue.t()), :dimensions => list(GoogleApi.DFAReporting.V33.Model.SortedDimension.t()), :floodlightConfigId => GoogleApi.DFAReporting.V33.Model.DimensionValue.t(), :metricNames => list(String.t()), :reportProperties => GoogleApi.DFAReporting.V33.Model.ReportFloodlightCriteriaReportProperties.t() } field(:customRichMediaEvents, as: GoogleApi.DFAReporting.V33.Model.DimensionValue, type: :list) field(:dateRange, as: GoogleApi.DFAReporting.V33.Model.DateRange) field(:dimensionFilters, as: GoogleApi.DFAReporting.V33.Model.DimensionValue, type: :list) field(:dimensions, as: GoogleApi.DFAReporting.V33.Model.SortedDimension, type: :list) field(:floodlightConfigId, as: GoogleApi.DFAReporting.V33.Model.DimensionValue) field(:metricNames, type: :list) field(:reportProperties, as: GoogleApi.DFAReporting.V33.Model.ReportFloodlightCriteriaReportProperties ) end defimpl Poison.Decoder, for: GoogleApi.DFAReporting.V33.Model.ReportFloodlightCriteria do def decode(value, options) do GoogleApi.DFAReporting.V33.Model.ReportFloodlightCriteria.decode(value, options) end end defimpl Poison.Encoder, for: GoogleApi.DFAReporting.V33.Model.ReportFloodlightCriteria do def encode(value, options) do GoogleApi.Gax.ModelBase.encode(value, options) end end

f7dde6f42ca773ead48c071af5f1f261b1586260

ex

Elixir

lib/mix/tasks/phoenix/pow.phoenix.gen.templates.ex

abartier/pow

58a3d082da093e2dc7f07825a950ee133204813f

lib/mix/tasks/phoenix/pow.phoenix.gen.templates.ex

abartier/pow

58a3d082da093e2dc7f07825a950ee133204813f

lib/mix/tasks/phoenix/pow.phoenix.gen.templates.ex

abartier/pow

58a3d082da093e2dc7f07825a950ee133204813f

defmodule Mix.Tasks.Pow.Phoenix.Gen.Templates do @shortdoc "Generates Pow views and templates" @moduledoc """ Generates pow templates for Phoenix. mix pow.phoenix.gen.templates ## Arguments * `--context-app MyApp` app to use for path and module names """ use Mix.Task alias Mix.{Pow, Pow.Phoenix} @switches [context_app: :string] @default_opts [] @mix_task "pow.phoenix.gen.templates" @doc false def run(args) do Pow.no_umbrella!(@mix_task) Pow.ensure_phoenix!(@mix_task, args) args |> Pow.parse_options(@switches, @default_opts) |> create_template_files() |> print_shell_instructions() end @templates [ {"registration", ~w(new edit)}, {"session", ~w(new)} ] defp create_template_files({config, _parsed, _invalid}) do structure = Phoenix.parse_structure(config) context_base = structure[:context_base] web_module = structure[:web_module] web_prefix = structure[:web_prefix] Enum.each(@templates, fn {name, actions} -> Phoenix.create_view_file(Elixir.Pow, name, web_module, web_prefix) Phoenix.create_templates(Elixir.Pow, name, web_prefix, actions) end) %{context_base: context_base, web_module: web_module} end defp print_shell_instructions(%{context_base: context_base, web_module: web_base}) do Mix.shell.info(""" Pow Phoenix templates and views has been generated. Please set `web_module: #{inspect(web_base)}` in your configuration. defmodule #{inspect(web_base)}.Endpoint do use #{inspect(web_base)}.Endpoint, otp_app: :#{Macro.underscore(context_base)} # ... plug #{inspect(web_base)}.Pow.Plug.Session, repo: #{inspect(context_base)}.Repo, user: #{inspect(context_base)}.Users.User, web_module: #{inspect(web_base)} # ... end """) end end

f7ddee57a2b30bc5fd0527e0dcd912c76fc62808

exs

Elixir

test/app_env_test.exs

nate/app_env

a556125a6e3c9661dea0a041e15910137fbf8276

test/app_env_test.exs

nate/app_env

a556125a6e3c9661dea0a041e15910137fbf8276

test/app_env_test.exs

nate/app_env

a556125a6e3c9661dea0a041e15910137fbf8276

defmodule AppEnvTest do use ExUnit.Case # doctest AppEnv setup do Application.put_env(:app_env, :config, %{"foo" => "bar"}) System.put_env("FOO", "1") end test "has a config value" do assert Application.get_env(:app_env, :config) == %{"foo" => "bar"} end test "copies a new value" do :ok = AppEnv.copy("FOO", :app_env, :config) assert Application.get_env(:app_env, :config) == "1" end test "copies a new value with a custom merge function" do :ok = AppEnv.copy("FOO", :app_env, :config, fn old_value, env_value -> {new_value, _} = Integer.parse(env_value) {:ok, Map.put(old_value, "foo", new_value)} end) assert Application.get_env(:app_env, :config) == %{"foo" => 1} end test "copies a new value to a path" do :ok = AppEnv.copy_to("FOO", :app_env, :config, ["foo"]) assert Application.get_env(:app_env, :config) == %{"foo" => "1"} end test "copies a new value to a path with a custom format function" do :ok = AppEnv.copy_to("FOO", :app_env, :config, ["foo"], fn env_value -> {new_value, _} = Integer.parse(env_value) {:ok, new_value} end) assert Application.get_env(:app_env, :config) == %{"foo" => 1} end test "handles errors in copying" do {:error, "error doing things"} = AppEnv.copy("FOO", :app_env, :config, fn _old_value, _env_value -> "error doing things" end) {:error, "another error doing things"} = AppEnv.copy("FOO", :app_env, :config, fn _old_value, _env_value -> {:error, "another error doing things"} end) {:error, "error doing things"} = AppEnv.copy_to("FOO", :app_env, :config, ["foo"], fn _env_value -> "error doing things" end) {:error, "another error doing things"} = AppEnv.copy_to("FOO", :app_env, :config, ["foo"], fn _env_value -> {:error, "another error doing things"} end) end end

f7ddff8ec5f7286b86391f37e909e1785fc6236d

ex

Elixir

lib/phlearn/application.ex

orneryhippo/phlearn

7ef72120c8d4719ef90809f16907b5e98d6c54b1

lib/phlearn/application.ex

orneryhippo/phlearn

7ef72120c8d4719ef90809f16907b5e98d6c54b1

lib/phlearn/application.ex

orneryhippo/phlearn

7ef72120c8d4719ef90809f16907b5e98d6c54b1

defmodule Phlearn.Application do use Application # See https://hexdocs.pm/elixir/Application.html # for more information on OTP Applications def start(_type, _args) do import Supervisor.Spec # Define workers and child supervisors to be supervised children = [ # Start the Ecto repository supervisor(Phlearn.Repo, []), # Start the endpoint when the application starts supervisor(PhlearnWeb.Endpoint, []), # Start your own worker by calling: Phlearn.Worker.start_link(arg1, arg2, arg3) # worker(Phlearn.Worker, [arg1, arg2, arg3]), ] # See https://hexdocs.pm/elixir/Supervisor.html # for other strategies and supported options opts = [strategy: :one_for_one, name: Phlearn.Supervisor] Supervisor.start_link(children, opts) end # Tell Phoenix to update the endpoint configuration # whenever the application is updated. def config_change(changed, _new, removed) do PhlearnWeb.Endpoint.config_change(changed, removed) :ok end end

f7de2ff36a5cff78c55fae98fd582cb107e2569e

ex

Elixir

apps/andi/lib/andi/input_schemas/input_converter.ex

SmartColumbusOS/smartcitiesdata

c8553d34631c822b034945eebf396994bf1001ff

2021-04-05T19:17:18.000Z

2021-04-05T19:17:18.000Z

apps/andi/lib/andi/input_schemas/input_converter.ex

SmartColumbusOS/smartcitiesdata

c8553d34631c822b034945eebf396994bf1001ff

2020-01-07T15:43:42.000Z

2020-12-22T15:23:25.000Z

apps/andi/lib/andi/input_schemas/input_converter.ex

SmartColumbusOS/smartcitiesdata

c8553d34631c822b034945eebf396994bf1001ff

defmodule Andi.InputSchemas.InputConverter do @moduledoc """ Used to convert between SmartCity.Datasets, form data (defined by Andi.InputSchemas.DatasetInput), and Ecto.Changesets. """ alias SmartCity.Dataset alias Andi.InputSchemas.DatasetInput @type dataset :: map() | Dataset.t() @spec changeset_from_dataset(dataset) :: Ecto.Changeset.t() def changeset_from_dataset(dataset) do %{id: id, business: business, technical: technical} = AtomicMap.convert(dataset, safe: false, underscore: false) from_business = get_business(business) |> fix_modified_date() from_technical = get_technical(technical) %{id: id} |> Map.merge(from_business) |> Map.merge(from_technical) |> DatasetInput.full_validation_changeset() end @spec changeset_from_dataset(Dataset.t(), map()) :: Ecto.Changeset.t() def changeset_from_dataset(%SmartCity.Dataset{} = original_dataset, changes) do form_data_with_atom_keys = AtomicMap.convert(changes, safe: false, underscore: false) original_dataset_flattened = original_dataset |> changeset_from_dataset() |> Ecto.Changeset.apply_changes() all_changes = Map.merge(original_dataset_flattened, form_data_with_atom_keys) all_changes |> adjust_form_input() |> DatasetInput.full_validation_changeset() end @spec form_changeset(map()) :: Ecto.Changeset.t() def form_changeset(params \\ %{}) do params |> adjust_form_input() |> DatasetInput.light_validation_changeset() end defp adjust_form_input(params) do params |> AtomicMap.convert(safe: false, underscore: false) |> Map.update(:keywords, nil, &keywords_to_list/1) |> fix_modified_date() end @spec restruct(map(), Dataset.t()) :: Dataset.t() def restruct(changes, dataset) do formatted_changes = changes |> Map.update(:issuedDate, nil, &date_to_iso8601_datetime/1) |> Map.update(:modifiedDate, nil, &date_to_iso8601_datetime/1) business = Map.merge(dataset.business, get_business(formatted_changes)) |> Map.from_struct() technical = Map.merge(dataset.technical, get_technical(formatted_changes)) |> Map.from_struct() %{} |> Map.put(:id, dataset.id) |> Map.put(:business, business) |> Map.put(:technical, technical) |> SmartCity.Dataset.new() |> (fn {:ok, dataset} -> dataset end).() end defp get_business(map) when is_map(map) do Map.take(map, DatasetInput.business_keys()) end defp get_technical(map) when is_map(map) do Map.take(map, DatasetInput.technical_keys()) end defp keywords_to_list(nil), do: [] defp keywords_to_list(""), do: [] defp keywords_to_list(keywords) when is_binary(keywords) do keywords |> String.split(", ") |> Enum.map(&String.trim/1) end defp keywords_to_list(keywords) when is_list(keywords), do: keywords defp date_to_iso8601_datetime(date) do time_const = "00:00:00Z" "#{Date.to_iso8601(date)} #{time_const}" end defp fix_modified_date(map) do map |> Map.get_and_update(:modifiedDate, fn "" -> {"", nil} current_value -> {current_value, current_value} end) |> elem(1) end end

f7de37494bf64859a32cf2157aabd136a60800ef

exs

Elixir

priv/repo/migrations/20180914060034_add_role_to_user.exs

TDogVoid/job_board

23793917bd1cc4e68bccce737b971093030a31eb

priv/repo/migrations/20180914060034_add_role_to_user.exs

TDogVoid/job_board

23793917bd1cc4e68bccce737b971093030a31eb

priv/repo/migrations/20180914060034_add_role_to_user.exs

TDogVoid/job_board

23793917bd1cc4e68bccce737b971093030a31eb

defmodule JobBoard.Repo.Migrations.AddRoleToUser do use Ecto.Migration def change do alter table(:users) do add :role_id, references(:roles) end create index(:users, [:role_id]) end end

f7de78ffa0e1ac881fa76515a2b9e11feb297dc2

ex

Elixir

lib/usir/server.ex

usir/usir_ex

059cc1679dcdc9defcad17a4aac3492a33e529e5

lib/usir/server.ex

usir/usir_ex

059cc1679dcdc9defcad17a4aac3492a33e529e5

lib/usir/server.ex

usir/usir_ex

059cc1679dcdc9defcad17a4aac3492a33e529e5

defmodule Usir.Server do alias Usir.Message.Client @spec handle_message(Client.message) :: {:ok, atom} | :error def handle_message(message) do case message do %Client.Mount{} -> {:ok, :mount} %Client.Unmount{} -> {:ok, :unmount} %Client.Authenticate{} -> {:ok, :authenticate} %Client.Action{} -> {:ok, :action} %Client.CallResponse{} -> {:ok, :response} %Client.CallError{} -> {:ok, :response} _ -> :error end end end

f7de9343595111b4cf6cc51cb3310a7ec149c8dc

exs

Elixir

test/plausible_web/controllers/auth_controller_test.exs

wvffle/analytics

2c0fd55bc67f74af1fe1e2641678d44e9fee61d5

2020-10-08T13:33:04.000Z

2020-10-08T13:33:04.000Z

test/plausible_web/controllers/auth_controller_test.exs

wvffle/analytics

2c0fd55bc67f74af1fe1e2641678d44e9fee61d5

test/plausible_web/controllers/auth_controller_test.exs

wvffle/analytics

2c0fd55bc67f74af1fe1e2641678d44e9fee61d5

defmodule PlausibleWeb.AuthControllerTest do use PlausibleWeb.ConnCase use Bamboo.Test import Plausible.TestUtils describe "GET /register" do test "shows the register form", %{conn: conn} do conn = get(conn, "/register") assert html_response(conn, 200) =~ "Enter your details" end test "registering sends an activation link", %{conn: conn} do post(conn, "/register", user: %{ name: "Jane Doe", email: "[email protected]" } ) assert_email_delivered_with(subject: "Activate your Plausible free trial") end test "user sees success page after registering", %{conn: conn} do conn = post(conn, "/register", user: %{ name: "Jane Doe", email: "[email protected]" } ) assert html_response(conn, 200) =~ "Success!" end end describe "GET /claim-activation" do test "creates the user", %{conn: conn} do token = Plausible.Auth.Token.sign_activation("Jane Doe", "[email protected]") get(conn, "/claim-activation?token=#{token}") assert Plausible.Auth.find_user_by(email: "[email protected]") end test "sends the welcome email", %{conn: conn} do token = Plausible.Auth.Token.sign_activation("Jane Doe", "[email protected]") get(conn, "/claim-activation?token=#{token}") assert_email_delivered_with(subject: "Welcome to Plausible") end test "redirects new user to create a password", %{conn: conn} do token = Plausible.Auth.Token.sign_activation("Jane Doe", "[email protected]") conn = get(conn, "/claim-activation?token=#{token}") assert redirected_to(conn) == "/password" end test "shows error when user with that email already exists", %{conn: conn} do token = Plausible.Auth.Token.sign_activation("Jane Doe", "[email protected]") conn = get(conn, "/claim-activation?token=#{token}") conn = get(conn, "/claim-activation?token=#{token}") assert conn.status == 400 end end describe "GET /login_form" do test "shows the login form", %{conn: conn} do conn = get(conn, "/login") assert html_response(conn, 200) =~ "Enter your email and password" end end describe "POST /login" do test "valid email and password - logs the user in", %{conn: conn} do user = insert(:user, password: "password") conn = post(conn, "/login", email: user.email, password: "password") assert get_session(conn, :current_user_id) == user.id assert redirected_to(conn) == "/sites" end test "email does not exist - renders login form again", %{conn: conn} do conn = post(conn, "/login", email: "[email protected]", password: "password") assert get_session(conn, :current_user_id) == nil assert html_response(conn, 200) =~ "Enter your email and password" end test "bad password - renders login form again", %{conn: conn} do user = insert(:user, password: "password") conn = post(conn, "/login", email: user.email, password: "wrong") assert get_session(conn, :current_user_id) == nil assert html_response(conn, 200) =~ "Enter your email and password" end end describe "GET /password/request-reset" do test "renders the form", %{conn: conn} do conn = get(conn, "/password/request-reset") assert html_response(conn, 200) =~ "Enter your email so we can send a password reset link" end end describe "POST /password/request-reset" do test "email is empty - renders form with error", %{conn: conn} do conn = post(conn, "/password/request-reset", %{email: ""}) assert html_response(conn, 200) =~ "Enter your email so we can send a password reset link" end test "email is present and exists - sends password reset email", %{conn: conn} do user = insert(:user) conn = post(conn, "/password/request-reset", %{email: user.email}) assert html_response(conn, 200) =~ "Success!" assert_email_delivered_with(subject: "Plausible password reset") end end describe "GET /password/reset" do test "with valid token - shows form", %{conn: conn} do token = Plausible.Auth.Token.sign_password_reset("[email protected]") conn = get(conn, "/password/reset", %{token: token}) assert html_response(conn, 200) =~ "Reset your password" end test "with invalid token - shows error page", %{conn: conn} do conn = get(conn, "/password/reset", %{token: "blabla"}) assert html_response(conn, 401) =~ "Your token is invalid" end end describe "POST /password/reset" do alias Plausible.Auth.{User, Token, Password} test "with valid token - resets the password", %{conn: conn} do user = insert(:user) token = Token.sign_password_reset(user.email) post(conn, "/password/reset", %{token: token, password: "new-password"}) user = Plausible.Repo.get(User, user.id) assert Password.match?("new-password", user.password_hash) end end describe "GET /settings" do setup [:create_user, :log_in] test "shows the form", %{conn: conn} do conn = get(conn, "/settings") assert html_response(conn, 200) =~ "Account settings" end test "shows subscription", %{conn: conn, user: user} do insert(:subscription, paddle_plan_id: "558018", user: user) conn = get(conn, "/settings") assert html_response(conn, 200) =~ "10k pageviews" assert html_response(conn, 200) =~ "monthly billing" end end describe "PUT /settings" do setup [:create_user, :log_in] test "updates user record", %{conn: conn, user: user} do put(conn, "/settings", %{"user" => %{"name" => "New name"}}) user = Plausible.Repo.get(Plausible.Auth.User, user.id) assert user.name == "New name" end end describe "DELETE /me" do setup [:create_user, :log_in, :create_site] use Plausible.Repo test "deletes the user", %{conn: conn, user: user, site: site} do Repo.insert_all("intro_emails", [ %{ user_id: user.id, timestamp: NaiveDateTime.utc_now() } ]) Repo.insert_all("feedback_emails", [ %{ user_id: user.id, timestamp: NaiveDateTime.utc_now() } ]) insert(:google_auth, site: site, user: user) insert(:subscription, user: user, status: "deleted") conn = delete(conn, "/me") assert redirected_to(conn) == "/" end end end

f7de93da603998904781ba9101fbe874ef71ece5

ex

Elixir

lib/tapebas_web/controllers/user_registration_controller.ex

cristineguadelupe/tapebas

5f8c70d5ac36b2a606fe4630cc659161b2f4d7bf

2022-03-24T16:48:38.000Z

2022-03-24T16:50:04.000Z

lib/tapebas_web/controllers/user_registration_controller.ex

cristineguadelupe/tapebas

5f8c70d5ac36b2a606fe4630cc659161b2f4d7bf

lib/tapebas_web/controllers/user_registration_controller.ex

cristineguadelupe/tapebas

5f8c70d5ac36b2a606fe4630cc659161b2f4d7bf

2022-03-20T01:11:12.000Z

2022-03-20T01:11:12.000Z

defmodule TapebasWeb.UserRegistrationController do use TapebasWeb, :controller alias Tapebas.Accounts alias Tapebas.Accounts.User alias TapebasWeb.UserAuth def new(conn, _params) do changeset = Accounts.change_user_registration(%User{}) render(conn, "new.html", changeset: changeset) end def create(conn, %{"user" => user_params}) do case Accounts.register_user(user_params) do {:ok, user} -> {:ok, _} = Accounts.deliver_user_confirmation_instructions( user, &Routes.user_confirmation_url(conn, :edit, &1) ) conn |> put_flash(:info, "User created successfully.") |> UserAuth.log_in_user(user) {:error, %Ecto.Changeset{} = changeset} -> render(conn, "new.html", changeset: changeset) end end end

f7deec2563d55e97f4de669e6e1414acc64026e3

ex

Elixir

lib/cforum/accounts/setting.ex

campingrider/cforum_ex

cf27684c47d6dc26c9c37a946f1c729a79d27c70

lib/cforum/accounts/setting.ex

campingrider/cforum_ex

cf27684c47d6dc26c9c37a946f1c729a79d27c70

lib/cforum/accounts/setting.ex

campingrider/cforum_ex

cf27684c47d6dc26c9c37a946f1c729a79d27c70

defmodule Cforum.Accounts.Setting do use CforumWeb, :model @primary_key {:setting_id, :id, autogenerate: true} @derive {Phoenix.Param, key: :setting_id} schema "settings" do field(:options, :map) belongs_to(:forum, Cforum.Forums.Forum, references: :forum_id) belongs_to(:user, Cforum.Accounts.User, references: :user_id) end @doc """ Builds a changeset based on the `struct` and `params`. """ def changeset(struct, params \\ %{}) do struct |> cast(params, [:options, :forum_id, :user_id]) |> remove_default_option_values() |> validate_required([:options]) |> unique_constraint(:forum_id) end defp remove_default_option_values(%Ecto.Changeset{valid?: true} = changeset) do case Ecto.Changeset.get_change(changeset, :options) do nil -> changeset options -> options = Enum.reduce(options, %{}, &defaults_reduce/2) Ecto.Changeset.put_change(changeset, :options, options) end end defp remove_default_option_values(changeset), do: changeset defp defaults_reduce({_key, "_DEFAULT_"}, acc), do: acc defp defaults_reduce({key, value}, acc), do: Map.put(acc, key, value) end

f7def801f046f85449b417d59716ec52d4dec8d8

ex

Elixir

clients/cloud_asset/lib/google_api/cloud_asset/v1/model/google_cloud_orgpolicy_v1_boolean_policy.ex

MasashiYokota/elixir-google-api

975dccbff395c16afcb62e7a8e411fbb58e9ab01

clients/cloud_asset/lib/google_api/cloud_asset/v1/model/google_cloud_orgpolicy_v1_boolean_policy.ex

MasashiYokota/elixir-google-api

975dccbff395c16afcb62e7a8e411fbb58e9ab01

2020-12-18T09:25:12.000Z

2020-12-18T09:25:12.000Z

clients/cloud_asset/lib/google_api/cloud_asset/v1/model/google_cloud_orgpolicy_v1_boolean_policy.ex

MasashiYokota/elixir-google-api

975dccbff395c16afcb62e7a8e411fbb58e9ab01

2020-10-04T10:12:44.000Z

2020-10-04T10:12:44.000Z

# Copyright 2019 Google LLC # # 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. # NOTE: This file is auto generated by the elixir code generator program. # Do not edit this file manually. defmodule GoogleApi.CloudAsset.V1.Model.GoogleCloudOrgpolicyV1BooleanPolicy do @moduledoc """ Used in `policy_type` to specify how `boolean_policy` will behave at this resource. ## Attributes * `enforced` (*type:* `boolean()`, *default:* `nil`) - If `true`, then the `Policy` is enforced. If `false`, then any configuration is acceptable. Suppose you have a `Constraint` `constraints/compute.disableSerialPortAccess` with `constraint_default` set to `ALLOW`. A `Policy` for that `Constraint` exhibits the following behavior: - If the `Policy` at this resource has enforced set to `false`, serial port connection attempts will be allowed. - If the `Policy` at this resource has enforced set to `true`, serial port connection attempts will be refused. - If the `Policy` at this resource is `RestoreDefault`, serial port connection attempts will be allowed. - If no `Policy` is set at this resource or anywhere higher in the resource hierarchy, serial port connection attempts will be allowed. - If no `Policy` is set at this resource, but one exists higher in the resource hierarchy, the behavior is as if the`Policy` were set at this resource. The following examples demonstrate the different possible layerings: Example 1 (nearest `Constraint` wins): `organizations/foo` has a `Policy` with: {enforced: false} `projects/bar` has no `Policy` set. The constraint at `projects/bar` and `organizations/foo` will not be enforced. Example 2 (enforcement gets replaced): `organizations/foo` has a `Policy` with: {enforced: false} `projects/bar` has a `Policy` with: {enforced: true} The constraint at `organizations/foo` is not enforced. The constraint at `projects/bar` is enforced. Example 3 (RestoreDefault): `organizations/foo` has a `Policy` with: {enforced: true} `projects/bar` has a `Policy` with: {RestoreDefault: {}} The constraint at `organizations/foo` is enforced. The constraint at `projects/bar` is not enforced, because `constraint_default` for the `Constraint` is `ALLOW`. """ use GoogleApi.Gax.ModelBase @type t :: %__MODULE__{ :enforced => boolean() } field(:enforced) end defimpl Poison.Decoder, for: GoogleApi.CloudAsset.V1.Model.GoogleCloudOrgpolicyV1BooleanPolicy do def decode(value, options) do GoogleApi.CloudAsset.V1.Model.GoogleCloudOrgpolicyV1BooleanPolicy.decode(value, options) end end defimpl Poison.Encoder, for: GoogleApi.CloudAsset.V1.Model.GoogleCloudOrgpolicyV1BooleanPolicy do def encode(value, options) do GoogleApi.Gax.ModelBase.encode(value, options) end end

f7df0cf309057df5dbffa13d60ec0bb6c3c1af68

ex

Elixir

lib/fun_land.ex

Qqwy/elixir_fun_land

337a322ea4102e2170557dbee0a77903dba79927

2016-07-10T15:40:21.000Z

2019-04-22T09:41:01.000Z

lib/fun_land.ex

Qqwy/elixir-fun_land

337a322ea4102e2170557dbee0a77903dba79927

2019-08-30T05:27:17.000Z

2022-03-23T18:22:32.000Z

lib/fun_land.ex

Qqwy/elixir_fun_land

337a322ea4102e2170557dbee0a77903dba79927

2016-07-23T16:23:31.000Z

2019-02-03T17:18:47.000Z

defmodule FunLand do @moduledoc """ FunLand defines many different Algebraic Data Types. An Algebraic Data Type is nothing more, than a 'container' for some other data type. Exactly how that 'container' behaves is what makes one ADT different from another. Lists are ADTs. And so are Maps. And Sets. And Tuples. And many other things. Algebraic Data Types contain no value of their own. They get a value, once you fill them with something, and then have useful operations you can perform on their contents. There are many similarities in the way the different ADTs work. This allows us to define behaviours which generalize to all ADTs. Any of your custom data types that you can implement one or multiple of these behaviours for, is an ADT, and will receive the benefits that the implemented ADTs give. Another nice thing about this generalization, is that there is no 'learning a new API' necessary when switching to one thing-that-is-an-ADT to the next. To easily use FunLand in your code, call `use FunLand`, which will alias for you: - `Mappable` -> A structure is Mappable if there is a way to map a function over it: transforming the contents but keeping the structure. - `Appliable` -> A structure is Applibable if it is Mappable and, given two of them where the first contains a partially-applied function, you can apply them together. - `Applicative` -> A structure is Applicative if it is Appliable and you can create a new one by wrapping any value. - `Chainable` -> A structure is Chainable if it is Appliable and you can chain multiple operations after each other, resulting in just a single structure. - `Monad` -> A structure is a Monad if it is both Applicative and Chainable. - `Semicombinable` -> A structure is Semicombinable if there is a way to combine two structures into one. - `Combinable` -> A structure is Combinable if it is Semicombinable and there is a clearly defined 'empty' element. - `CombinableMonad` -> A structure is a CombinableMonad if it is both Combinable and a Monad. - `Reducible` -> A structure is reducible if you can fold/reduce it to a single value, when giving a Combinable or function+default. - `Traversable` -> A structure is Traversable if it is Reducible and there is a way to flip the ??? When given the option `operators: true`, it will also import the following operators: - `~>` Shorthand for `Mappable.map/2` - `<~>` Shorthand for `Appliable.apply_with/2` - `~>>` Shorthand for `Chainable.chain/2` - `<>` Shorthand for `Combinable.combine/2`. This operator still works the same for binaries, but will now also work for any other Chainable. """ # Elixir doesn't let you _really_ define algebraic data types, so we're creating a 'one type fits all' type. @type adt :: [any] | {} | map | struct defmacro __using__(opts) do # Only import operators if wanted. import_code = if Keyword.get(opts, :operators, false) do quote do import Kernel, except: [<>: 2] import FunLand, only: [<>: 2, ~>: 2, <~>: 2, ~>>: 2] end else quote do import Kernel end end quote do unquote(import_code) alias FunLand.{ Mappable, Appliable, Applicative, Chainable, Monad, Semicombinable, Combinable, Reducible, Traversable, CombinableMonad } end end defdelegate map(mappable, fun), to: FunLand.Mappable defdelegate apply_with(appliable_with_fun, appliable), to: FunLand.Appliable defdelegate new(module, value), to: FunLand.Applicative defdelegate chain(chainable, fun_returning_chainable), to: FunLand.Chainable defdelegate empty(module), to: FunLand.Combinable defdelegate combine(semicombinable, semicombinable), to: FunLand.Semicombinable defdelegate reduce(reducible, accumulator, fun), to: FunLand.Reducible defdelegate reduce(reducible, combinable), to: FunLand.Reducible def any?(reducible, property_fun) do FunLand.Reducible.reduce(reducible, false, fn elem, acc -> acc || property_fun.(elem) end) end def all?(reducible, property_fun) do FunLand.Reducible.reduce(reducible, true, fn elem, acc -> acc && property_fun.(elem) end) end @doc """ Infix version of `FunLand.Mappable.map/2` """ def a ~> b do FunLand.Mappable.map(a, b) end @doc """ Infix version of `FunLand.Appliable.apply_with/2` """ def a <~> b do FunLand.Appliable.apply_with(a, b) end @doc """ Infix version of `FunLand.Chainable.chain/2` """ def a ~>> b do FunLand.Chainable.chain(a, b) end # This operator is made more general. It still works for binary combining, as binaries are indeed Combinable. @doc """ Infix version of `FunLand.Combinable.combine/2`. Note that binary strings are Combinable, so "foo" <> "bar" still works. `<>/2` can still be used in pattern-matches and guard clauses, but it will fall back to the behavior of `Kernel.<>/2`, which means that it will only work with binary strings. """ defmacro left <> right do in_module? = __CALLER__.context == nil if in_module? do quote do FunLand.Combinable.combine(unquote(left), unquote(right)) end else quote do Kernel.<>(unquote(left), unquote(right)) end end end end

f7df312c4b7e5bf798fea7088d1b418d12bb8a9b

ex

Elixir

lib/client.ex

menuan/fav

49ae04a5a7dbc70fcc8058303c70ca8332bec0e4

lib/client.ex

menuan/fav

49ae04a5a7dbc70fcc8058303c70ca8332bec0e4

lib/client.ex

menuan/fav

49ae04a5a7dbc70fcc8058303c70ca8332bec0e4

defmodule FirebaseAuthVerifier.Client do use Tesla @moduledoc """ A simple Tesla client to request the signing certificate that will be used to verify the signature. """ plug Tesla.Middleware.BaseUrl, Application.get_env(:firebase_auth_verifier, :cert_url) || raise "Base URL has not been set for FirebaseAuthVerifier" plug Tesla.Middleware.JSON def get_certificates do get("/") end end

f7df5563b7c8584a19a73b9b83623a062bbca26d

ex

Elixir

lib/grizzly/command_class/network_management_installation_maintenance/priority_route_get.ex

pragdave/grizzly

bcd7b46ab2cff1797dac04bc3cd12a36209dd579

lib/grizzly/command_class/network_management_installation_maintenance/priority_route_get.ex

pragdave/grizzly

bcd7b46ab2cff1797dac04bc3cd12a36209dd579

lib/grizzly/command_class/network_management_installation_maintenance/priority_route_get.ex

pragdave/grizzly

bcd7b46ab2cff1797dac04bc3cd12a36209dd579

defmodule Grizzly.CommandClass.NetworkManagementInstallationMaintenance.PriorityRouteGet do @behaviour Grizzly.Command alias Grizzly.Packet alias Grizzly.Command.{EncodeError, Encoding} alias Grizzly.CommandClass.NetworkManagementInstallationMaintenance @type t :: %__MODULE__{ seq_number: Grizzly.seq_number(), retries: non_neg_integer(), node_id: non_neg_integer() } @type opt :: {:seq_number, Grizzly.seq_number()} | {:retries, non_neg_integer() | {:node_id, non_neg_integer}} @enforce_keys [:node_id] defstruct seq_number: nil, retries: 2, node_id: nil @spec init([opt]) :: {:ok, t} def init(opts) do {:ok, struct(__MODULE__, opts)} end @spec encode(t) :: {:ok, binary} | {:error, EncodeError.t()} def encode(%__MODULE__{seq_number: seq_number, node_id: node_id} = command) do with {:ok, _encoded} <- Encoding.encode_and_validate_args(command, %{ node_id: :byte }) do binary = Packet.header(seq_number) <> <<0x67, 0x02, node_id>> {:ok, binary} end end @spec handle_response(t, Packet.t()) :: {:continue, t()} | {:done, {:error, :nack_response}} | {:done, NetworkManagementInstallationMaintenance.priority_route_report()} | {:retry, t()} | {:queued, t()} def handle_response(%__MODULE__{seq_number: seq_number} = command, %Packet{ seq_number: seq_number, types: [:ack_response] }) do {:continue, command} end def handle_response(%__MODULE__{seq_number: seq_number, retries: 0}, %Packet{ seq_number: seq_number, types: [:nack_response] }) do {:done, {:error, :nack_response}} end def handle_response(%__MODULE__{seq_number: seq_number, retries: n} = command, %Packet{ seq_number: seq_number, types: [:nack_response] }) do {:retry, %{command | retries: n - 1}} end def handle_response( %__MODULE__{seq_number: seq_number} = command, %Packet{ seq_number: seq_number, types: [:nack_response, :nack_waiting] } = packet ) do if Packet.sleeping_delay?(packet) do {:queued, command} else {:continue, command} end end def handle_response( _, %Packet{ body: %{ command_class: :network_management_installation_maintenance, command: :priority_route_report, value: value } } ) do {:done, {:ok, value}} end def handle_response(command, _), do: {:continue, command} end

f7df94f896b02498c05bd015d566264ffd7c091f

ex

Elixir

clients/health_care/lib/google_api/health_care/v1beta1/model/test_iam_permissions_request.ex

medikent/elixir-google-api

98a83d4f7bfaeac15b67b04548711bb7e49f9490

clients/health_care/lib/google_api/health_care/v1beta1/model/test_iam_permissions_request.ex

medikent/elixir-google-api

98a83d4f7bfaeac15b67b04548711bb7e49f9490

clients/health_care/lib/google_api/health_care/v1beta1/model/test_iam_permissions_request.ex

medikent/elixir-google-api

98a83d4f7bfaeac15b67b04548711bb7e49f9490

# Copyright 2019 Google LLC # # 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. # NOTE: This file is auto generated by the elixir code generator program. # Do not edit this file manually. defmodule GoogleApi.HealthCare.V1beta1.Model.TestIamPermissionsRequest do @moduledoc """ Request message for `TestIamPermissions` method. ## Attributes * `permissions` (*type:* `list(String.t)`, *default:* `nil`) - The set of permissions to check for the `resource`. Permissions with wildcards (such as '*' or 'storage.*') are not allowed. For more information see [IAM Overview](https://cloud.google.com/iam/docs/overview#permissions). """ use GoogleApi.Gax.ModelBase @type t :: %__MODULE__{ :permissions => list(String.t()) } field(:permissions, type: :list) end defimpl Poison.Decoder, for: GoogleApi.HealthCare.V1beta1.Model.TestIamPermissionsRequest do def decode(value, options) do GoogleApi.HealthCare.V1beta1.Model.TestIamPermissionsRequest.decode(value, options) end end defimpl Poison.Encoder, for: GoogleApi.HealthCare.V1beta1.Model.TestIamPermissionsRequest do def encode(value, options) do GoogleApi.Gax.ModelBase.encode(value, options) end end

f7dfb1cc724fbe92e736674a0ff6ca9a19c83c3a

exs

Elixir

test/duration_test.exs

slashdotdash/duration

c3afc94ea2a8b113280d1c71fa1c842a52a05197

2020-06-03T16:26:14.000Z

2020-06-04T12:28:06.000Z

test/duration_test.exs

slashdotdash/duration

c3afc94ea2a8b113280d1c71fa1c842a52a05197

test/duration_test.exs

slashdotdash/duration

c3afc94ea2a8b113280d1c71fa1c842a52a05197

defmodule DurationTest do use ExUnit.Case doctest Duration test "parse durations" do assert Duration.parse("PT3S") == {:ok, %Duration{seconds: 3}} assert Duration.parse("P3M") == {:ok, %Duration{months: 3}} assert Duration.parse("PT3M") == {:ok, %Duration{minutes: 3}} assert Duration.parse("P12341223T235759") == {:ok, %Duration{years: 1234, months: 12, days: 23, hours: 23, minutes: 57, seconds: 59}} assert Duration.parse("P1234-12-23T23:57:59") == {:ok, %Duration{years: 1234, months: 12, days: 23, hours: 23, minutes: 57, seconds: 59}} end test "string protocol" do assert to_string(%Duration{}) == "PT0S" assert to_string(%Duration{years: 1}) == "P1Y" assert to_string(%Duration{months: 1}) == "P1M" assert to_string(%Duration{years: 1, seconds: 12}) == "P1YT12S" assert to_string(%Duration{years: 1, months: 2, days: 3}) == "P1Y2M3D" assert to_string(%Duration{years: 1, months: 2, days: 3, hours: 4, minutes: 5, seconds: 6}) == "P1Y2M3DT4H5M6S" assert to_string(%Duration{minutes: 1}) == "PT1M" assert to_string(%Duration{hours: 1, minutes: 2, seconds: 3}) == "PT1H2M3S" assert to_string(%Duration{hours: 0, minutes: 2, seconds: 3}) == "PT2M3S" assert to_string(%Duration{hours: 0, minutes: 0, seconds: 3}) == "PT3S" end test "errors" do assert {:error, _} = Duration.parse("") assert {:error, _} = Duration.parse("P12341331T246060") assert {:error, _} = Duration.parse("P12341232T246060") assert {:error, _} = Duration.parse("P12341231T256060") assert {:error, _} = Duration.parse("P12341231T246160") assert {:error, _} = Duration.parse("P12341231T246061") end test "Timex.integration" do {:ok, duration} = Duration.new("PT1S") assert {:ok, [seconds: 1]} = Duration.to_timex_options(duration, :forward) assert {:ok, [seconds: -1]} = Duration.to_timex_options(duration, :backward) end end

f7dfc23a3a0bc4e57aa1c63a8bfdbc4242c3a03a

ex

Elixir

lib/livebook/runtime/mix_standalone.ex

mcrumm/livebook

b1ceedc2205e64348212fbf7edce568cdb084e97

2021-05-21T22:14:23.000Z

2021-05-21T22:14:23.000Z

lib/livebook/runtime/mix_standalone.ex

mcrumm/livebook

b1ceedc2205e64348212fbf7edce568cdb084e97

lib/livebook/runtime/mix_standalone.ex

mcrumm/livebook

b1ceedc2205e64348212fbf7edce568cdb084e97

defmodule Livebook.Runtime.MixStandalone do defstruct [:node, :primary_pid, :project_path] # A runtime backed by a standalone Elixir node managed by Livebook. # # This runtime is similar to `Livebook.Runtime.ElixirStandalone`, # but the node is started in the context of a Mix project. import Livebook.Runtime.StandaloneInit alias Livebook.Utils alias Livebook.Utils.Emitter @type t :: %__MODULE__{ node: node(), primary_pid: pid(), project_path: String.t() } @doc """ Starts a new Elixir node (i.e. a system process) and initializes it with Livebook-specific modules and processes. The node is started together with a Mix environment appropriate for the given `project_path`. The setup may involve long-running steps (like fetching dependencies, compiling the project), so the initialization is asynchronous. This function spawns and links a process responsible for initialization, which then uses `emitter` to emit the following notifications: * `{:output, string}` - arbitrary output/info sent as the initialization proceeds * `{:ok, runtime}` - a final message indicating successful initialization * `{:error, message}` - a final message indicating failure If no process calls `Runtime.connect/1` for a period of time, the node automatically terminates. Whoever connects, becomes the owner and as soon as it terminates, the node terminates as well. The node may also be terminated manually by using `Runtime.disconnect/1`. Note: to start the node it is required that both `elixir` and `mix` are recognised executables within the system. """ @spec init_async(String.t(), Emitter.t()) :: :ok def init_async(project_path, emitter) do output_emitter = Emitter.mapper(emitter, fn output -> {:output, output} end) spawn_link(fn -> parent_node = node() child_node = child_node_name(parent_node) Utils.temporarily_register(self(), child_node, fn -> argv = [parent_node] with {:ok, elixir_path} <- find_elixir_executable(), :ok <- run_mix_task("deps.get", project_path, output_emitter), :ok <- run_mix_task("compile", project_path, output_emitter), eval = child_node_eval_string(), port = start_elixir_mix_node(elixir_path, child_node, eval, argv, project_path), {:ok, primary_pid} <- parent_init_sequence(child_node, port, output_emitter) do runtime = %__MODULE__{ node: child_node, primary_pid: primary_pid, project_path: project_path } Emitter.emit(emitter, {:ok, runtime}) else {:error, error} -> Emitter.emit(emitter, {:error, error}) end end) end) :ok end defp run_mix_task(task, project_path, output_emitter) do Emitter.emit(output_emitter, "Running mix #{task}...\n") case System.cmd("mix", [task], cd: project_path, stderr_to_stdout: true, into: output_emitter ) do {_callback, 0} -> :ok {_callback, _status} -> {:error, "running mix #{task} failed, see output for more details"} end end defp start_elixir_mix_node(elixir_path, node_name, eval, argv, project_path) do # Here we create a port to start the system process in a non-blocking way. Port.open({:spawn_executable, elixir_path}, [ :binary, :stderr_to_stdout, :hide, cd: project_path, args: elixir_flags(node_name) ++ ["-S", "mix", "run", "--eval", eval, "--" | Enum.map(argv, &to_string/1)] ]) end end defimpl Livebook.Runtime, for: Livebook.Runtime.MixStandalone do alias Livebook.Runtime.ErlDist def connect(runtime) do ErlDist.Manager.set_owner(runtime.node, self()) Process.monitor({ErlDist.Manager, runtime.node}) end def disconnect(runtime) do ErlDist.Manager.stop(runtime.node) end def evaluate_code( runtime, code, container_ref, evaluation_ref, prev_evaluation_ref \\ :initial, opts \\ [] ) do ErlDist.Manager.evaluate_code( runtime.node, code, container_ref, evaluation_ref, prev_evaluation_ref, opts ) end def forget_evaluation(runtime, container_ref, evaluation_ref) do ErlDist.Manager.forget_evaluation(runtime.node, container_ref, evaluation_ref) end def drop_container(runtime, container_ref) do ErlDist.Manager.drop_container(runtime.node, container_ref) end end

f7dfe8042bcb40d6e91dfec40ab64f362c5bc01a

ex

Elixir

web/web.ex

mntns/artus

958380f42612ec0bc9d059037cf7b59dfbe1cfa9

web/web.ex

mntns/artus

958380f42612ec0bc9d059037cf7b59dfbe1cfa9

web/web.ex

mntns/artus

958380f42612ec0bc9d059037cf7b59dfbe1cfa9

defmodule Artus.Web do @moduledoc """ A module that keeps using definitions for controllers, views and so on. This can be used in your application as: use Artus.Web, :controller use Artus.Web, :view The definitions below will be executed for every view, controller, etc, so keep them short and clean, focused on imports, uses and aliases. Do NOT define functions inside the quoted expressions below. """ def model do quote do use Ecto.Schema import Ecto import Ecto.Changeset import Ecto.Query, only: [from: 1, from: 2] end end def controller do quote do use Phoenix.Controller alias Artus.Repo import Ecto import Ecto.Query, only: [from: 1, from: 2] import Artus.Router.Helpers import Artus.Gettext end end def view do quote do use Phoenix.View, root: "web/templates" # Import convenience functions from controllers import Phoenix.Controller, only: [get_csrf_token: 0, get_flash: 2, view_module: 1] # Use all HTML functionality (forms, tags, etc) use Phoenix.HTML import Artus.Router.Helpers import Artus.ErrorHelpers import Artus.Gettext end end def router do quote do use Phoenix.Router end end def channel do quote do use Phoenix.Channel alias Artus.Repo import Ecto import Ecto.Query, only: [from: 1, from: 2] import Artus.Gettext end end @doc """ When used, dispatch to the appropriate controller/view/etc. """ defmacro __using__(which) when is_atom(which) do apply(__MODULE__, which, []) end end

f7e00ca3d1cdefa5b8d2a21aae3fefe452346521

ex

Elixir

apps/admin_app/lib/admin_app/application.ex

VeryBigThings/avia

7ce5d5b244ae0dfddc30c09c17efe27f1718a4c9

2021-04-08T22:29:19.000Z

2021-04-08T22:29:19.000Z

apps/admin_app/lib/admin_app/application.ex

VeryBigThings/avia

7ce5d5b244ae0dfddc30c09c17efe27f1718a4c9

apps/admin_app/lib/admin_app/application.ex

VeryBigThings/avia

7ce5d5b244ae0dfddc30c09c17efe27f1718a4c9

defmodule AdminApp.Application do @moduledoc false use Application alias AdminAppWeb.Endpoint # See https://hexdocs.pm/elixir/Application.html # for more information on OTP Applications def start(_type, _args) do import Supervisor.Spec # Define workers and child supervisors to be supervised children = [ # Start the endpoint when the application starts supervisor(AdminAppWeb.Endpoint, []), # Start your own worker by calling: AdminApp.Worker.start_link(arg1, arg2, arg3) # worker(AdminApp.Worker, [arg1, arg2, arg3]), {Phoenix.PubSub, [name: AdminApp.PubSub, adapter: Phoenix.PubSub.PG2]} ] # Look for a better way to start HoneyDew workers. :ok = Honeydew.start_queue(:etsy_import_queue) :ok = Honeydew.start_workers(:etsy_import_queue, Avia.Etsy.ImportWorker) :ok = Honeydew.start_queue(:export_data_queue) :ok = Honeydew.start_workers(:export_data_queue, Avia.ExportDataWorker) :ok = Honeydew.start_queue(:category_delete_queue) :ok = Honeydew.start_workers(:category_delete_queue, Avia.CategoryWorker, num: 3) # See https://hexdocs.pm/elixir/Supervisor.html # for other strategies and supported options opts = [strategy: :one_for_one, name: AdminApp.Supervisor] Supervisor.start_link(children, opts) end # Tell Phoenix to update the endpoint configuration # whenever the application is updated. def config_change(changed, _new, removed) do Endpoint.config_change(changed, removed) :ok end end

f7e02267881fcf10e11e7101b79e2f0187d7b415

ex

Elixir

apps/engine/lib/engine/ethereum/authority/submitter/core.ex

omgnetwork/omg-childchain-v2

31cc9cf9e42718fc3b9bd6668f24a627cac80b4f

2020-11-30T17:38:57.000Z

2021-01-23T21:29:41.000Z

apps/engine/lib/engine/ethereum/authority/submitter/core.ex

omgnetwork/omg-childchain-v2

31cc9cf9e42718fc3b9bd6668f24a627cac80b4f

2020-11-30T17:32:48.000Z

2021-02-22T06:25:22.000Z

apps/engine/lib/engine/ethereum/authority/submitter/core.ex

omgnetwork/omg-childchain-v2

31cc9cf9e42718fc3b9bd6668f24a627cac80b4f

defmodule Engine.Ethereum.Authority.Submitter.Core do @moduledoc """ Submission + Ethereum logic """ @doc """ Plasma contracts give us the next mined plasma block number, but we're insterested in the current block number. The last mined block is the difference between the next childblock minus the interval. """ @spec mined(non_neg_integer(), pos_integer()) :: non_neg_integer() def mined(next_child_block, child_block_interval) do next_child_block - child_block_interval end end

f7e02455a28c4da7b85c19a6afbf7b848f8658ab

ex

Elixir

testData/org/elixir_lang/parser_definition/matched_dot_operator_call_operation/unqualified_no_parentheses_many_arguments_call_parsing_test_case/StringHeredoc.ex

keyno63/intellij-elixir

4033e319992c53ddd42a683ee7123a97b5e34f02

2015-01-03T05:54:27.000Z

2022-03-25T08:01:20.000Z

testData/org/elixir_lang/parser_definition/matched_dot_operator_call_operation/unqualified_no_parentheses_many_arguments_call_parsing_test_case/StringHeredoc.ex

keyno63/intellij-elixir

4033e319992c53ddd42a683ee7123a97b5e34f02

2015-01-01T22:43:39.000Z

2022-03-31T20:13:08.000Z

testData/org/elixir_lang/parser_definition/matched_dot_operator_call_operation/unqualified_no_parentheses_many_arguments_call_parsing_test_case/StringHeredoc.ex

keyno63/intellij-elixir

4033e319992c53ddd42a683ee7123a97b5e34f02

2015-01-15T11:37:16.000Z

2021-12-22T05:51:02.000Z

""" String Heredoc """.and unqualified positional, key: value """ String Heredoc """.&& unqualified positional, key: value """ String Heredoc """.|> unqualified positional, key: value """ String Heredoc """.@ unqualified positional, key: value """ String Heredoc """.& unqualified positional, key: value """ String Heredoc """.== unqualified positional, key: value """ String Heredoc """.+ unqualified positional, key: value """ String Heredoc """.^^^ unqualified positional, key: value """ String Heredoc """.<- unqualified positional, key: value """ String Heredoc """.in unqualified positional, key: value """ String Heredoc """.= unqualified positional, key: value """ String Heredoc """./ unqualified positional, key: value """ String Heredoc """.* unqualified positional, key: value """ String Heredoc """.or unqualified positional, key: value """ String Heredoc """.|| unqualified positional, key: value """ String Heredoc """.| unqualified positional, key: value """ String Heredoc """.<= unqualified positional, key: value """ String Heredoc """.-> unqualified positional, key: value """ String Heredoc """.<> unqualified positional, key: value """ String Heredoc """.^ unqualified positional, key: value """ String Heredoc """.not unqualified positional, key: value """ String Heredoc """.after unqualified positional, key: value """ String Heredoc """.do unqualified positional, key: value """ String Heredoc """.when unqualified positional, key: value

f7e05d329a6b59e0ed8ddc25151cc2135bef2585

ex

Elixir

lib/twirp.ex

daskycodes/twirp-elixir

51b701111a3b33601980703417388cd099dc7e44

2019-11-03T16:30:13.000Z

2020-06-23T19:38:53.000Z

lib/twirp.ex

daskycodes/twirp-elixir

51b701111a3b33601980703417388cd099dc7e44

2020-03-13T17:56:16.000Z

2020-06-11T10:40:02.000Z

lib/twirp.ex

daskycodes/twirp-elixir

51b701111a3b33601980703417388cd099dc7e44

2019-12-05T16:43:15.000Z

2020-05-11T21:34:44.000Z

defmodule Twirp do @moduledoc """ Twirp provides an elixir implementation of the [twirp rpc framework](https://github.com/twitchtv/twirp) developed by Twitch. The protocol defines semantics for routing and serialization of RPCs based on protobufs. ## Example The canonical Twirp example is a Haberdasher service. Here's the protobuf description for the service. ```protobuf syntax = "proto3"; package example; // Haberdasher service makes hats for clients. service Haberdasher { // MakeHat produces a hat of mysterious, randomly-selected color! rpc MakeHat(Size) returns (Hat); } // Size of a Hat, in inches. message Size { int32 inches = 1; // must be > 0 } // A Hat is a piece of headwear made by a Haberdasher. message Hat { int32 inches = 1; string color = 2; // anything but "invisible" string name = 3; // i.e. "bowler" } ``` We'll assume for now that this proto file lives in `priv/protos/service.proto` ### Code generation We can now use `protoc` to generate the files we need. You can run this command from the root directory of your project. $ protoc --proto_path=./priv/protos --elixir_out=./lib/example --twirp_elixir_out=./lib/example ./priv/protos/service.proto After running this command there should be 2 files located in `lib/example`. The message definitions: ```elixir defmodule Example.Size do @moduledoc false use Protobuf, syntax: :proto3 @type t :: %__MODULE__{ inches: integer } defstruct [:inches] field :inches, 1, type: :int32 end defmodule Example.Hat do @moduledoc false use Protobuf, syntax: :proto3 @type t :: %__MODULE__{ inches: integer, color: String.t(), name: String.t() } defstruct [:inches, :color, :name] field :inches, 1, type: :int32 field :color, 2, type: :string field :name, 3, type: :string end ``` The service and client definition: ```elixir defmodule Example.HaberdasherService do @moduledoc false use Twirp.Service package "example" service "Haberdasher" rpc :MakeHat, Example.Size, Example.Hat, :make_hat end defmodule Example.HaberdasherClient do @moduledoc false use Twirp.Client, service: Example.HaberdasherService end ``` ### Implementing the server Now that we've generated the service definition we can implement a "handler" module that will implement each "method". ```elixir defmodule Example.HaberdasherHandler do @colors ~w|white black brown red blue| @names ["bowler", "baseball cap", "top hat", "derby"] def make_hat(_ctx, size) do if size <= 0 do Twirp.Error.invalid_argument("I can't make a hat that small!") else %Haberdasher.Hat{ inches: size.inches, color: Enum.random(@colors), name: Enum.random(@names) } end end end ``` Separating the service and handler like this may seem a little odd but there are good reasons to do this. The most important is that it allows the service to be autogenerated again in the future. The second reason is that it allows us to easily mock service implementations for testing. ### Running the server To serve traffic Twirp provides a Plug. We use this plug to attach our service definition with our handler. ```elixir defmodule Example.Router do use Plug.Router plug Twirp.Plug, service: Haberdasher.HatMakerService, handler: Haberdasher.HatMakerHandler end ``` ```elixir defmodule Example.Application do use Application def start(_type, _args) do children = [ Plug.Cowboy.child_spec(scheme: :http, plug: Example.Router, options: [port: 4040]), ] opts = [strategy: :one_for_one, name: Example.Supervisor] Supervisor.start_link(children, opts) end end ``` If you start your application your plug will now be available on port 4040. ### Using the client Client definitions are generated alongside the service definition. This allows you to generate clients for your services in other applications. You can make RPC calls like so: ```elixir defmodule AnotherService.GetHats do alias Example.HaberdasherClient, as: Client alias Example.{Size, Hat} def make_a_hat(inches) do case Client.make_hat(Size.new(inches: inches)) do {:ok, %Hat{}=hat} -> hat {:error, %Twirp.Error{msg: msg}} -> Logger.error(msg) end end end ``` """ end

f7e06679888ee7553ecfae22fb531b70cf3fae88

ex

Elixir

lib/shex/shape_expressions/node_constraint/numeric_facets.ex

rdf-elixir/shex-ex

84100ab3dfcf3988b2b90289a8e4fbeb9f4d1516

2020-06-06T15:09:16.000Z

2021-03-22T19:46:30.000Z

lib/shex/shape_expressions/node_constraint/numeric_facets.ex

rdf-elixir/shex-ex

84100ab3dfcf3988b2b90289a8e4fbeb9f4d1516

lib/shex/shape_expressions/node_constraint/numeric_facets.ex

rdf-elixir/shex-ex

84100ab3dfcf3988b2b90289a8e4fbeb9f4d1516

defmodule ShEx.NodeConstraint.NumericFacets do @moduledoc false defstruct ~w[mininclusive minexclusive maxinclusive maxexclusive totaldigits fractiondigits]a alias RDF.{Literal, XSD} def new(xs_facets) do xs_facets_with_literals = Map.new(xs_facets, fn {key, value} when key in ~w[mininclusive minexclusive maxinclusive maxexclusive]a -> {key, value |> XSD.Decimal.new() |> Literal.canonical()} {key, value} -> {key, value} end) numeric_facets = struct(__MODULE__, xs_facets_with_literals) if %__MODULE__{} != numeric_facets do numeric_facets end end # TODO: instead of checking on every application to a node which constraints are there and must be applied, this could be compiled into minimal constraint checker def satisfies(nil, _), do: :ok def satisfies(numeric_facets, %Literal{} = node) do with true <- XSD.Numeric.datatype?(node) and Literal.valid?(node), true <- satisfies_numeric_mininclusive(numeric_facets.mininclusive, node), true <- satisfies_numeric_minexclusive(numeric_facets.minexclusive, node), true <- satisfies_numeric_maxinclusive(numeric_facets.maxinclusive, node), true <- satisfies_numeric_maxexclusive(numeric_facets.maxexclusive, node), true <- satisfies_numeric_totaldigits(numeric_facets.totaldigits, node), true <- satisfies_numeric_fractiondigits(numeric_facets.fractiondigits, node) do :ok else false -> %ShEx.Violation.NumericFacetConstraint{ facet_type: :invalid_numeric, node: node } {:violates, type, value} -> %ShEx.Violation.NumericFacetConstraint{ facet_type: type, facet_value: value, node: node } end end def satisfies(_, node) do %ShEx.Violation.NumericFacetConstraint{ facet_type: :invalid_numeric, node: node } end defp satisfies_numeric_mininclusive(nil, _), do: true defp satisfies_numeric_mininclusive(mininclusive, literal) do RDF.Literal.compare(literal, mininclusive) in [:gt, :eq] || {:violates, :mininclusive, mininclusive} end defp satisfies_numeric_minexclusive(nil, _), do: true defp satisfies_numeric_minexclusive(minexclusive, literal) do RDF.Literal.compare(literal, minexclusive) == :gt || {:violates, :minexclusive, minexclusive} end defp satisfies_numeric_maxinclusive(nil, _), do: true defp satisfies_numeric_maxinclusive(maxinclusive, literal) do RDF.Literal.compare(literal, maxinclusive) in [:lt, :eq] || {:violates, :maxinclusive, maxinclusive} end defp satisfies_numeric_maxexclusive(nil, _), do: true defp satisfies_numeric_maxexclusive(maxexclusive, literal) do RDF.Literal.compare(literal, maxexclusive) == :lt || {:violates, :maxexclusive, maxexclusive} end defp satisfies_numeric_totaldigits(nil, _), do: true defp satisfies_numeric_totaldigits(totaldigits, literal) do (decimal?(literal) && XSD.Decimal.digit_count(literal) <= totaldigits) || {:violates, :totaldigits, totaldigits} end defp satisfies_numeric_fractiondigits(nil, _), do: true defp satisfies_numeric_fractiondigits(fractiondigits, literal) do (decimal?(literal) && XSD.Decimal.fraction_digit_count(literal) <= fractiondigits) || {:violates, :fractiondigits, fractiondigits} end defp decimal?(%Literal{} = literal) do # We also have to check for XSD.Integer since RDF.ex implements it as a primitive XSD.Integer.datatype?(literal) or XSD.Decimal.datatype?(literal) end end

f7e085c660993b30e47f7cdee7d58cd987d5aec7

ex

Elixir

lib/codewar/application.ex

hanam1ni/codewar-web

0d7c46ac32d85b1d76c604226e0f3d6f2b76b0ad

lib/codewar/application.ex

hanam1ni/codewar-web

0d7c46ac32d85b1d76c604226e0f3d6f2b76b0ad

lib/codewar/application.ex

hanam1ni/codewar-web

0d7c46ac32d85b1d76c604226e0f3d6f2b76b0ad

defmodule Codewar.Application do # See https://hexdocs.pm/elixir/Application.html # for more information on OTP Applications @moduledoc false use Application def start(_type, _args) do topologies = [ codewar: [ strategy: Cluster.Strategy.DNSPoll, config: [ polling_interval: 1000, query: "codewar-web-staging.codewar-web-staging.local", node_basename: "codewar-web-staging" ] ] ] children = [ # Start the Ecto repository Codewar.Repo, # Start the Telemetry supervisor CodewarWeb.Telemetry, # Start the PubSub system {Phoenix.PubSub, name: Codewar.PubSub}, # Start the Endpoint (http/https) CodewarWeb.Endpoint, {Cluster.Supervisor, [topologies, [name: Codewar.ClusterSupervisor]]} # Start a worker by calling: Codewar.Worker.start_link(arg) # {Codewar.Worker, arg} ] # See https://hexdocs.pm/elixir/Supervisor.html # for other strategies and supported options opts = [strategy: :one_for_one, name: Codewar.Supervisor] Supervisor.start_link(children, opts) end # Tell Phoenix to update the endpoint configuration # whenever the application is updated. def config_change(changed, _new, removed) do CodewarWeb.Endpoint.config_change(changed, removed) :ok end end

f7e0a8be68d7d325d159b8e4f7af3e9632798bb4

ex

Elixir

lib/afk/keycode.ex

doughsay/afk

9b7f55c98aa8c52dee3f134cef112c1361fe75f4

2019-12-10T21:27:06.000Z

2020-01-26T03:07:43.000Z

lib/afk/keycode.ex

doughsay/afk

9b7f55c98aa8c52dee3f134cef112c1361fe75f4

2019-12-13T05:46:08.000Z

2020-10-29T13:07:40.000Z

lib/afk/keycode.ex

nerves-keyboard/afk

9b7f55c98aa8c52dee3f134cef112c1361fe75f4

2020-01-02T13:35:03.000Z

2020-01-02T13:35:03.000Z

defmodule AFK.Keycode do @moduledoc """ A keycode represents a key that when pressed affects the keyboard state in some way. The currently supported keycode types are: * `AFK.Keycode.Key` - A basic keyboard key * `AFK.Keycode.KeyLock` - A key that allows locking other keys * `AFK.Keycode.Layer` - A key that can activate other layers * `AFK.Keycode.Modifier` - A basic keyboard modifier * `AFK.Keycode.None` - A keycode that does nothing * `AFK.Keycode.Transparent` - A key that is transparent to its layer """ alias __MODULE__.{Key, KeyLock, Layer, MFA, Modifier, None, Transparent} @type t :: Key.t() | KeyLock.t() | Layer.t() | MFA.t() | Modifier.t() | None.t() | Transparent.t() @type with_scancode :: Key.t() | Modifier.t() end

f7e0dbf98075df18d15c37fe10e93507f4bc3ae6

ex

Elixir

lib/macchinista/accounts.ex

themaxhero/Machinista

2e0114dbbc69fc8187b3ed080de694ac4f558ae8

2019-12-16T10:22:07.000Z

2019-12-16T10:22:07.000Z

lib/macchinista/accounts.ex

themaxhero/Machinista

2e0114dbbc69fc8187b3ed080de694ac4f558ae8

2021-03-10T06:56:47.000Z

2021-05-11T02:41:32.000Z

lib/macchinista/accounts.ex

themaxhero/Macchinista

2e0114dbbc69fc8187b3ed080de694ac4f558ae8

defmodule Macchinista.Accounts do @moduledoc """ The Accounts context. """ import Ecto.Query, warn: false alias Macchinista.Repo alias Macchinista.Accounts.{User, Session} alias Session.Query, as: SessionQuery @token_secret Application.get_env(:macchinista, :token_secret) @doc """ Returns the list of users. ## Examples iex> list_users() [%User{}, ...] """ def list_users do Repo.all(User) end @doc """ Gets a single user. Raises `Ecto.NoResultsError` if the User does not exist. ## Examples iex> get_user!(123) %User{} iex> get_user!(456) ** (Ecto.NoResultsError) """ def get_user(id), do: Repo.get(User, id) def get_user!(id), do: Repo.get!(User, id) def get_user_by_email(email), do: Repo.get_by(User, email: email) @doc """ Creates a user. ## Examples iex> create_user(%{field: value}) {:ok, %User{}} iex> create_user(%{field: bad_value}) {:error, %Ecto.Changeset{}} """ def create_user(attrs \\ %{}) do Repo.transaction(fn -> result = attrs |> User.create_changeset() |> Repo.insert() case result do {:ok, %User{} = user} -> # create_log(user, :user, :insert, :success, user) user {:error, _} -> Repo.rollback(:internal) end end) end @doc """ Updates a user. ## Examples iex> update_user(user, %{field: new_value}) {:ok, %User{}} iex> update_user(user, %{field: bad_value}) {:error, %Ecto.Changeset{}} """ def update_user(%User{} = user, attrs) do user |> User.update_changeset(attrs) |> Repo.update() end @doc """ Deletes a User. ## Examples iex> delete_user(user) {:ok, %User{}} iex> delete_user(user) {:error, %Ecto.Changeset{}} """ def delete_user(%User{} = user) do Repo.delete(user) end def login(%{email: email, password: password}) do with user <- get_user_by_email(email), true <- Bcrypt.verify_pass(password, user.password_hash) do IO.puts(@token_secret) {:ok, Phoenix.Token.sign(@token_secret, "user", user.id)} else {:error, _} = response -> response false -> {:error, :invalid_credentials} _ -> {:error, :unknown_error} end end @spec validate_user(User.t() | nil) :: {:ok, User.t()} | {:error, :invalid_authorization_token} defp validate_user(%User{} = user), do: {:ok, user} defp validate_user(_), do: {:error, :invalid_authorization_token} @spec authorize_user(Session.token()) :: {:ok, User.t()} | {:error, :invalid_authorization_token} def authorize_user(token) do token |> SessionQuery.by_token() |> Repo.one() |> Session.get_user_id() |> get_user() |> validate_user() end end

f7e0e259a18811070fdcbc5773d1653e2f6a67f9

exs

Elixir

test/order_test.exs

aforward/acme_ex

f199943be6a75e0e4672a64dc4820dfc15abf330

2020-02-01T19:30:44.000Z

2020-02-01T19:30:44.000Z

test/order_test.exs

aforward/acme_ex

f199943be6a75e0e4672a64dc4820dfc15abf330

test/order_test.exs

aforward/acme_ex

f199943be6a75e0e4672a64dc4820dfc15abf330

defmodule AcmeEx.OrderTest do use ExUnit.Case, async: false alias AcmeEx.{Account, Order, Nonce} @config %{site: "http://localhost:9999"} test "new" do account = Account.new("abc124") order_id = Nonce.next() expected = %{ id: order_id, status: :pending, cert: nil, domains: ["d1", "d2"], token: "xxx123" } assert expected == Order.new(["d1", "d2"], account, "xxx123") assert {:ok, expected} == Order.fetch("abc124", order_id) assert {:ok, expected} == Order.fetch(account.id, order_id) assert {expected, %{id: account.id}} == Order.decode_path("#{account.id}/#{order_id}") end test "new generate token" do account = Account.new("abc126") id = Nonce.next() actual = Order.new(["d1", "d2"], account) expected = %{id: id, status: :pending, cert: nil, domains: ["d1", "d2"], token: actual.token} assert expected == actual assert {:ok, expected} == Order.fetch("abc126", id) end test "update" do account = Account.new("abc125") id = Nonce.next() _ = Order.new(["d1", "d2"], account, "xxx123") new_order = %{id: id, status: :pending, cert: nil, domains: ["d1", "d3"], token: "xxx124"} assert Order.update("abc125", new_order) == {:ok, new_order} assert {:ok, new_order} == Order.fetch("abc125", id) end test "domains" do assert ["foo.bar", "www.foo.bar", "blog.foo.bar"] == AcmeEx.Order.domains(%{ payload: %{ "identifiers" => [ %{"type" => "dns", "value" => "foo.bar"}, %{"type" => "dns", "value" => "www.foo.bar"}, %{"type" => "dns", "value" => "blog.foo.bar"} ], "resource" => "new-order", "status" => "pending" } }) end test "identifiers" do assert [%{type: "dns", value: "d1"}, %{type: "dns", value: "d2"}] == Order.identifiers(%{domains: ["d1", "d2"]}) end test "order_path" do assert "10/11" == Order.encode_path(%{id: 11}, %{id: 10}) end test "authorization" do assert "http://localhost:9999/authorizations/10/11" == Order.authorization(@config, %{id: 11}, %{id: 10}) end test "location" do assert "http://localhost:9999/order/10/11" == Order.location(@config, %{id: 11}, %{id: 10}) end test "finalize" do assert "http://localhost:9999/finalize/10/11" == Order.finalize(@config, %{id: 11}, %{id: 10}) end test "expires" do assert "2018-09-20T11:11:13Z" == Order.expires(3601, ~N[2018-09-20 10:11:12]) assert "2018-09-20T11:11:12Z" == Order.expires(nil, ~N[2018-09-20 10:11:12]) assert !is_nil(Order.expires()) end test "to_challenge" do assert %{ type: "http-01", status: "pending", url: "http://localhost:9999/challenge/http/10/11", token: "def456" } == Order.to_challenge(@config, %{id: 11, status: "pending", token: "def456"}, %{id: 10}) end test "to_summary" do assert %{ status: "pending", certificate: "http://localhost:9999/cert/10/11", identifier: %{type: "dns", value: "localhost"} } == Order.to_summary(@config, %{id: 11, status: "pending", token: "def456"}, %{id: 10}) end end

f7e0e4330f157cba8b04eda867332f641a1f9c05

ex

Elixir

clients/dlp/lib/google_api/dlp/v2/model/google_privacy_dlp_v2_list_job_triggers_response.ex

matehat/elixir-google-api

c1b2523c2c4cdc9e6ca4653ac078c94796b393c3

2018-12-03T23:43:10.000Z

2018-12-03T23:43:10.000Z

clients/dlp/lib/google_api/dlp/v2/model/google_privacy_dlp_v2_list_job_triggers_response.ex

matehat/elixir-google-api

c1b2523c2c4cdc9e6ca4653ac078c94796b393c3

clients/dlp/lib/google_api/dlp/v2/model/google_privacy_dlp_v2_list_job_triggers_response.ex

matehat/elixir-google-api

c1b2523c2c4cdc9e6ca4653ac078c94796b393c3

# Copyright 2019 Google LLC # # Licensed under the Apache License, Version 2.0 (the &quot;License&quot;); # 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 &quot;AS IS&quot; 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. # NOTE: This class is auto generated by the elixir code generator program. # Do not edit the class manually. defmodule GoogleApi.DLP.V2.Model.GooglePrivacyDlpV2ListJobTriggersResponse do @moduledoc """ Response message for ListJobTriggers. ## Attributes * `jobTriggers` (*type:* `list(GoogleApi.DLP.V2.Model.GooglePrivacyDlpV2JobTrigger.t)`, *default:* `nil`) - List of triggeredJobs, up to page_size in ListJobTriggersRequest. * `nextPageToken` (*type:* `String.t`, *default:* `nil`) - If the next page is available then the next page token to be used in following ListJobTriggers request. """ use GoogleApi.Gax.ModelBase @type t :: %__MODULE__{ :jobTriggers => list(GoogleApi.DLP.V2.Model.GooglePrivacyDlpV2JobTrigger.t()), :nextPageToken => String.t() } field(:jobTriggers, as: GoogleApi.DLP.V2.Model.GooglePrivacyDlpV2JobTrigger, type: :list) field(:nextPageToken) end defimpl Poison.Decoder, for: GoogleApi.DLP.V2.Model.GooglePrivacyDlpV2ListJobTriggersResponse do def decode(value, options) do GoogleApi.DLP.V2.Model.GooglePrivacyDlpV2ListJobTriggersResponse.decode(value, options) end end defimpl Poison.Encoder, for: GoogleApi.DLP.V2.Model.GooglePrivacyDlpV2ListJobTriggersResponse do def encode(value, options) do GoogleApi.Gax.ModelBase.encode(value, options) end end

f7e1057265b3deb25857b64f0605fdae2cf280cc

ex

Elixir

farmbot_firmware/lib/farmbot_firmware/request.ex

adamswsk/farmbot_os

d177d3b74888c1e7bcbf8f8595818708ee97f73b

farmbot_firmware/lib/farmbot_firmware/request.ex

adamswsk/farmbot_os

d177d3b74888c1e7bcbf8f8595818708ee97f73b

farmbot_firmware/lib/farmbot_firmware/request.ex

adamswsk/farmbot_os

d177d3b74888c1e7bcbf8f8595818708ee97f73b

defmodule FarmbotFirmware.Request do @moduledoc false # sister module to FarmbotFirmware.Command # see docs for FarmbotFirmware.request/1 alias FarmbotFirmware alias FarmbotFirmware.GCODE @spec request(GenServer.server(), GCODE.t()) :: {:ok, GCODE.t()} | {:error, :invalid_command | :firmware_error | FarmbotFirmware.status()} @ok [ :parameter_read, :status_read, :pin_read, :end_stops_read, :position_read, :software_version_read ] def request(firmware_server \\ FarmbotFirmware, code) def request(firmware_server, {_tag, {kind, _}} = code) do if kind not in @ok do raise ArgumentError, "#{kind} is not a valid request." end case GenServer.call(firmware_server, code, :infinity) do {:ok, tag} -> wait_for_request_result(tag, code) {:error, status} -> {:error, status} end end def request(firmware_server, {_, _} = code) do request(firmware_server, {to_string(:rand.uniform(100)), code}) end def request_timeout(tag, code, result \\ nil) do if result do {:ok, {tag, result}} else {:error, "timeout waiting for request to complete: #{inspect(code)}"} end end # This is a bit weird but let me explain: # if this function `receive`s # * report_error # * report_invalid # * report_emergency_lock # it needs to return an error. # # If this function `receive`s # * report_success # when no valid data has been collected from `wait_for_request_result_process` # it needs to return an error. # # If this function `receive`s # * report_success # when valid data has been collected from `wait_for_request_result_process` # it will return that data. # If this function returns no data for 5 seconds, it needs to error. def wait_for_request_result(tag, code, result \\ nil) do receive do {tag, {:report_begin, []}} -> wait_for_request_result(tag, code, result) {tag, {:report_busy, []}} -> wait_for_request_result(tag, code, result) {tag, {:report_success, []}} -> if result, do: {:ok, {tag, result}}, else: wait_for_request_result(tag, code, result) {_, {:report_error, error_code}} -> if error_code, do: {:error, error_code}, else: {:error, :firmware_error} {_, {:report_invalid, []}} -> {:error, :invalid_command} {_, {:report_emergency_lock, []}} -> {:error, :emergency_lock} {:error, reason} -> {:error, reason} {tag, report} -> wait_for_request_result_process(report, tag, code, result) after 10_000 -> request_timeout(tag, code, result) end end # {:parameter_read, [param]} => {:report_parameter_value, [{param, val}]} defp wait_for_request_result_process( {:report_parameter_value, _} = report, tag, {_, {:parameter_read, _}} = code, _ ) do wait_for_request_result(tag, code, report) end # {:status_read, [status]} => {:report_status_value, [{status, value}]} defp wait_for_request_result_process( {:report_status_value, _} = report, tag, {_, {:status_read, _}} = code, _ ) do wait_for_request_result(tag, code, report) end # {:pin_read, [pin]} => {:report_pin_value, [{pin, value}]} defp wait_for_request_result_process( {:report_pin_value, _} = report, tag, {_, {:pin_read, _}} = code, _ ) do wait_for_request_result(tag, code, report) end # {:end_stops_read, []} => {:position_end_stops, end_stops} defp wait_for_request_result_process( {:report_end_stops, _} = report, tag, {_, {:end_stops_read, []}} = code, _ ) do wait_for_request_result(tag, code, report) end # {:position_read, []} => {:position_report, [x: x, y: y, z: z]} defp wait_for_request_result_process( {:report_position, _} = report, tag, {_, {:position_read, []}} = code, _ ) do wait_for_request_result(tag, code, report) end # {:software_version_read, []} => {:report_software_version, [version]} defp wait_for_request_result_process( {:report_software_version, _} = report, tag, {_, {:software_version_read, _}} = code, _ ) do wait_for_request_result(tag, code, report) end defp wait_for_request_result_process(_report, tag, code, result) do wait_for_request_result(tag, code, result) end end

f7e130d4ca576e5138e2afa2cf005c978932efb3

exs

Elixir

config/prod.exs

thomasvolk/lighthouse

566f4029a1ef1e5863e45b7f9b1b7afa914980ec

config/prod.exs

thomasvolk/lighthouse

566f4029a1ef1e5863e45b7f9b1b7afa914980ec

config/prod.exs

thomasvolk/lighthouse

566f4029a1ef1e5863e45b7f9b1b7afa914980ec

use Mix.Config # For production, we often load configuration from external # sources, such as your system environment. For this reason, # you won't find the :http configuration below, but set inside # LighthouseWeb.Endpoint.init/2 when load_from_system_env is # true. Any dynamic configuration should be done there. # # Don't forget to configure the url host to something meaningful, # Phoenix uses this information when generating URLs. # # Finally, we also include the path to a cache manifest # containing the digested version of static files. This # manifest is generated by the mix phx.digest task # which you typically run after static files are built. config :lighthouse, LighthouseWeb.Endpoint, http: [port: 9996], load_from_system_env: false, root: "." #cache_static_manifest: "priv/static/cache_manifest.json" # Do not print debug messages in production config :logger, level: :info # ## SSL Support # # To get SSL working, you will need to add the `https` key # to the previous section and set your `:url` port to 443: # # config :lighthouse, LighthouseWeb.Endpoint, # ... # url: [host: "example.com", port: 443], # https: [:inet6, # port: 443, # keyfile: System.get_env("SOME_APP_SSL_KEY_PATH"), # certfile: System.get_env("SOME_APP_SSL_CERT_PATH")] # # Where those two env variables return an absolute path to # the key and cert in disk or a relative path inside priv, # for example "priv/ssl/server.key". # # We also recommend setting `force_ssl`, ensuring no data is # ever sent via http, always redirecting to https: # # config :lighthouse, LighthouseWeb.Endpoint, # force_ssl: [hsts: true] # # Check `Plug.SSL` for all available options in `force_ssl`. # ## Using releases # # If you are doing OTP releases, you need to instruct Phoenix # to start the server for all endpoints: # # config :phoenix, :serve_endpoints, true # # Alternatively, you can configure exactly which server to # start per endpoint: # # config :lighthouse, LighthouseWeb.Endpoint, server: true # # Finally import the config/prod.secret.exs # which should be versioned separately. #import_config "prod.secret.exs"

f7e13a41126a3f643c707748b3f0c5b2de41c1fa

exs

Elixir

test/validation/point_point_a_test.exs

codabrink/topo

f1ca4b7fe337a67285ee4c65a34fb521b119342c

2016-05-05T21:09:19.000Z

2022-03-08T05:22:16.000Z

test/validation/point_point_a_test.exs

codabrink/topo

f1ca4b7fe337a67285ee4c65a34fb521b119342c

2016-12-01T00:32:11.000Z

2022-01-18T13:56:37.000Z

test/validation/point_point_a_test.exs

codabrink/topo

f1ca4b7fe337a67285ee4c65a34fb521b119342c

2016-09-19T20:06:50.000Z

2021-06-16T06:41:10.000Z

defmodule Intersect.Validation.PointPointATest do use ExUnit.Case @tag :validation test "01-001 - P/P: same point" do a = "POINT (20 20)" |> Geo.WKT.decode!() b = "POINT (20 20)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == true assert Topo.intersects?(b, a) == true assert Topo.disjoint?(a, b) == false assert Topo.disjoint?(b, a) == false assert Topo.contains?(a, b) == true assert Topo.within?(a, b) == true assert Topo.equals?(a, b) == true assert Topo.equals?(b, a) == true end @tag :validation test "01-001 - P/P: same point (float)" do a = "POINT(20.0 20.0)" |> Geo.WKT.decode!() b = "POINT(20.0 20.0)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == true assert Topo.intersects?(b, a) == true assert Topo.disjoint?(a, b) == false assert Topo.disjoint?(b, a) == false assert Topo.contains?(a, b) == true assert Topo.within?(a, b) == true assert Topo.equals?(a, b) == true assert Topo.equals?(b, a) == true end @tag :validation test "01-002 - P/P: different point" do a = "POINT (20 20)" |> Geo.WKT.decode!() b = "POINT (40 60)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == false assert Topo.intersects?(b, a) == false assert Topo.disjoint?(a, b) == true assert Topo.disjoint?(b, a) == true assert Topo.contains?(a, b) == false assert Topo.within?(a, b) == false assert Topo.equals?(a, b) == false assert Topo.equals?(b, a) == false end @tag :validation test "01-002 - P/P: different point (float)" do a = "POINT(20.0 20.0)" |> Geo.WKT.decode!() b = "POINT(40.0 60.0)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == false assert Topo.intersects?(b, a) == false assert Topo.disjoint?(a, b) == true assert Topo.disjoint?(b, a) == true assert Topo.contains?(a, b) == false assert Topo.within?(a, b) == false assert Topo.equals?(a, b) == false assert Topo.equals?(b, a) == false end @tag :validation test "01-003 - P/mP: different points" do a = "POINT (40 40)" |> Geo.WKT.decode!() b = "MULTIPOINT (20 20, 80 80, 20 120)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == false assert Topo.intersects?(b, a) == false assert Topo.disjoint?(a, b) == true assert Topo.disjoint?(b, a) == true assert Topo.contains?(a, b) == false assert Topo.within?(a, b) == false assert Topo.equals?(a, b) == false assert Topo.equals?(b, a) == false end @tag :validation test "01-003 - P/mP: different points (float)" do a = "POINT(40.0 40.0)" |> Geo.WKT.decode!() b = "MULTIPOINT(20.0 20.0,80.0 80.0,20.0 120.0)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == false assert Topo.intersects?(b, a) == false assert Topo.disjoint?(a, b) == true assert Topo.disjoint?(b, a) == true assert Topo.contains?(a, b) == false assert Topo.within?(a, b) == false assert Topo.equals?(a, b) == false assert Topo.equals?(b, a) == false end @tag :validation test "01-004 - P/mP: point A within one of B points" do a = "POINT (20 20)" |> Geo.WKT.decode!() b = "MULTIPOINT (20 20, 80 80, 20 120)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == true assert Topo.intersects?(b, a) == true assert Topo.disjoint?(a, b) == false assert Topo.disjoint?(b, a) == false assert Topo.contains?(a, b) == false assert Topo.within?(a, b) == true assert Topo.equals?(a, b) == false assert Topo.equals?(b, a) == false end @tag :validation test "01-004 - P/mP: point A within one of B points (float)" do a = "POINT(20.0 20.0)" |> Geo.WKT.decode!() b = "MULTIPOINT(20.0 20.0,80.0 80.0,20.0 120.0)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == true assert Topo.intersects?(b, a) == true assert Topo.disjoint?(a, b) == false assert Topo.disjoint?(b, a) == false assert Topo.contains?(a, b) == false assert Topo.within?(a, b) == true assert Topo.equals?(a, b) == false assert Topo.equals?(b, a) == false end @tag :validation test "01-005 - mP/mP-1-1: same points" do a = "MULTIPOINT (40 40, 80 60, 120 100)" |> Geo.WKT.decode!() b = "MULTIPOINT (40 40, 80 60, 120 100)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == true assert Topo.intersects?(b, a) == true assert Topo.disjoint?(a, b) == false assert Topo.disjoint?(b, a) == false assert Topo.contains?(a, b) == true assert Topo.within?(a, b) == true assert Topo.equals?(a, b) == true assert Topo.equals?(b, a) == true end @tag :validation test "01-005 - mP/mP-1-1: same points (float)" do a = "MULTIPOINT(40.0 40.0,80.0 60.0,120.0 100.0)" |> Geo.WKT.decode!() b = "MULTIPOINT(40.0 40.0,80.0 60.0,120.0 100.0)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == true assert Topo.intersects?(b, a) == true assert Topo.disjoint?(a, b) == false assert Topo.disjoint?(b, a) == false assert Topo.contains?(a, b) == true assert Topo.within?(a, b) == true assert Topo.equals?(a, b) == true assert Topo.equals?(b, a) == true end @tag :validation test "01-006 - mP/mP-1-2: same but different sequence of points" do a = "MULTIPOINT (40 40, 80 60, 120 100)" |> Geo.WKT.decode!() b = "MULTIPOINT (40 40, 120 100, 80 60)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == true assert Topo.intersects?(b, a) == true assert Topo.disjoint?(a, b) == false assert Topo.disjoint?(b, a) == false assert Topo.contains?(a, b) == true assert Topo.within?(a, b) == true assert Topo.equals?(a, b) == true assert Topo.equals?(b, a) == true end @tag :validation test "01-006 - mP/mP-1-2: same but different sequence of points (float)" do a = "MULTIPOINT(40.0 40.0,80.0 60.0,120.0 100.0)" |> Geo.WKT.decode!() b = "MULTIPOINT(40.0 40.0,120.0 100.0,80.0 60.0)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == true assert Topo.intersects?(b, a) == true assert Topo.disjoint?(a, b) == false assert Topo.disjoint?(b, a) == false assert Topo.contains?(a, b) == true assert Topo.within?(a, b) == true assert Topo.equals?(a, b) == true assert Topo.equals?(b, a) == true end @tag :validation test "01-007 - mP/mP-2: different points" do a = "MULTIPOINT (40 40, 60 100, 100 60, 120 120)" |> Geo.WKT.decode!() b = "MULTIPOINT (20 120, 60 60, 100 100, 140 40)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == false assert Topo.intersects?(b, a) == false assert Topo.disjoint?(a, b) == true assert Topo.disjoint?(b, a) == true assert Topo.contains?(a, b) == false assert Topo.within?(a, b) == false assert Topo.equals?(a, b) == false assert Topo.equals?(b, a) == false end @tag :validation test "01-007 - mP/mP-2: different points (float)" do a = "MULTIPOINT(40.0 40.0,60.0 100.0,100.0 60.0,120.0 120.0)" |> Geo.WKT.decode!() b = "MULTIPOINT(20.0 120.0,60.0 60.0,100.0 100.0,140.0 40.0)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == false assert Topo.intersects?(b, a) == false assert Topo.disjoint?(a, b) == true assert Topo.disjoint?(b, a) == true assert Topo.contains?(a, b) == false assert Topo.within?(a, b) == false assert Topo.equals?(a, b) == false assert Topo.equals?(b, a) == false end @tag :validation test "01-008 - mP/mP-5-1: same points" do a = "MULTIPOINT (20 20, 80 70, 140 120, 200 170)" |> Geo.WKT.decode!() b = "MULTIPOINT (20 20, 80 70, 140 120, 200 170)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == true assert Topo.intersects?(b, a) == true assert Topo.disjoint?(a, b) == false assert Topo.disjoint?(b, a) == false assert Topo.contains?(a, b) == true assert Topo.within?(a, b) == true assert Topo.equals?(a, b) == true assert Topo.equals?(b, a) == true end @tag :validation test "01-008 - mP/mP-5-1: same points (float)" do a = "MULTIPOINT(20.0 20.0,80.0 70.0,140.0 120.0,200.0 170.0)" |> Geo.WKT.decode!() b = "MULTIPOINT(20.0 20.0,80.0 70.0,140.0 120.0,200.0 170.0)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == true assert Topo.intersects?(b, a) == true assert Topo.disjoint?(a, b) == false assert Topo.disjoint?(b, a) == false assert Topo.contains?(a, b) == true assert Topo.within?(a, b) == true assert Topo.equals?(a, b) == true assert Topo.equals?(b, a) == true end @tag :validation test "01-009 - mP/mP-5-2: same points but different sequence" do a = "MULTIPOINT (20 20, 140 120, 80 70, 200 170)" |> Geo.WKT.decode!() b = "MULTIPOINT (80 70, 20 20, 200 170, 140 120)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == true assert Topo.intersects?(b, a) == true assert Topo.disjoint?(a, b) == false assert Topo.disjoint?(b, a) == false assert Topo.contains?(a, b) == true assert Topo.within?(a, b) == true assert Topo.equals?(a, b) == true assert Topo.equals?(b, a) == true end @tag :validation test "01-009 - mP/mP-5-2: same points but different sequence (float)" do a = "MULTIPOINT(20.0 20.0,140.0 120.0,80.0 70.0,200.0 170.0)" |> Geo.WKT.decode!() b = "MULTIPOINT(80.0 70.0,20.0 20.0,200.0 170.0,140.0 120.0)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == true assert Topo.intersects?(b, a) == true assert Topo.disjoint?(a, b) == false assert Topo.disjoint?(b, a) == false assert Topo.contains?(a, b) == true assert Topo.within?(a, b) == true assert Topo.equals?(a, b) == true assert Topo.equals?(b, a) == true end @tag :validation test "01-010 - mP/mP-5-3: some points same" do a = "MULTIPOINT (20 20, 80 70, 140 120, 200 170)" |> Geo.WKT.decode!() b = "MULTIPOINT (80 70, 140 120)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == true assert Topo.intersects?(b, a) == true assert Topo.disjoint?(a, b) == false assert Topo.disjoint?(b, a) == false assert Topo.contains?(a, b) == true assert Topo.within?(a, b) == false assert Topo.equals?(a, b) == false assert Topo.equals?(b, a) == false end @tag :validation test "01-010 - mP/mP-5-3: some points same (float)" do a = "MULTIPOINT(20.0 20.0,80.0 70.0,140.0 120.0,200.0 170.0)" |> Geo.WKT.decode!() b = "MULTIPOINT(80.0 70.0,140.0 120.0)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == true assert Topo.intersects?(b, a) == true assert Topo.disjoint?(a, b) == false assert Topo.disjoint?(b, a) == false assert Topo.contains?(a, b) == true assert Topo.within?(a, b) == false assert Topo.equals?(a, b) == false assert Topo.equals?(b, a) == false end @tag :validation test "01-011 - mP/mP-5-4: some points same, in a different sequence" do a = "MULTIPOINT (80 70, 20 20, 200 170, 140 120)" |> Geo.WKT.decode!() b = "MULTIPOINT (140 120, 80 70)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == true assert Topo.intersects?(b, a) == true assert Topo.disjoint?(a, b) == false assert Topo.disjoint?(b, a) == false assert Topo.contains?(a, b) == true assert Topo.within?(a, b) == false assert Topo.equals?(a, b) == false assert Topo.equals?(b, a) == false end @tag :validation test "01-011 - mP/mP-5-4: some points same, in a different sequence (float)" do a = "MULTIPOINT(80.0 70.0,20.0 20.0,200.0 170.0,140.0 120.0)" |> Geo.WKT.decode!() b = "MULTIPOINT(140.0 120.0,80.0 70.0)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == true assert Topo.intersects?(b, a) == true assert Topo.disjoint?(a, b) == false assert Topo.disjoint?(b, a) == false assert Topo.contains?(a, b) == true assert Topo.within?(a, b) == false assert Topo.equals?(a, b) == false assert Topo.equals?(b, a) == false end @tag :validation test "01-012 - mP/mP-6-1: some points same, some different" do a = "MULTIPOINT (80 70, 20 20, 200 170, 140 120)" |> Geo.WKT.decode!() b = "MULTIPOINT (80 170, 140 120, 200 80)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == true assert Topo.intersects?(b, a) == true assert Topo.disjoint?(a, b) == false assert Topo.disjoint?(b, a) == false assert Topo.contains?(a, b) == false assert Topo.within?(a, b) == false assert Topo.equals?(a, b) == false assert Topo.equals?(b, a) == false end @tag :validation test "01-012 - mP/mP-6-1: some points same, some different (float)" do a = "MULTIPOINT(80.0 70.0,20.0 20.0,200.0 170.0,140.0 120.0)" |> Geo.WKT.decode!() b = "MULTIPOINT(80.0 170.0,140.0 120.0,200.0 80.0)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == true assert Topo.intersects?(b, a) == true assert Topo.disjoint?(a, b) == false assert Topo.disjoint?(b, a) == false assert Topo.contains?(a, b) == false assert Topo.within?(a, b) == false assert Topo.equals?(a, b) == false assert Topo.equals?(b, a) == false end @tag :validation test "01-013 - mP/mP-6-2: dim(0){A.4P1.Int = B.4P4.Int}, dim(0){A.4P4.Int = B.4P2.Int}" do a = "MULTIPOINT (80 70, 20 20, 200 170, 140 120)" |> Geo.WKT.decode!() b = "MULTIPOINT (80 170, 140 120, 200 80, 80 70)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == true assert Topo.intersects?(b, a) == true assert Topo.disjoint?(a, b) == false assert Topo.disjoint?(b, a) == false assert Topo.contains?(a, b) == false assert Topo.within?(a, b) == false assert Topo.equals?(a, b) == false assert Topo.equals?(b, a) == false end @tag :validation test "01-013 - mP/mP-6-2: dim(0){A.4P1.Int = B.4P4.Int}, dim(0){A.4P4.Int = B.4P2.Int} (float)" do a = "MULTIPOINT(80.0 70.0,20.0 20.0,200.0 170.0,140.0 120.0)" |> Geo.WKT.decode!() b = "MULTIPOINT(80.0 170.0,140.0 120.0,200.0 80.0,80.0 70.0)" |> Geo.WKT.decode!() assert Topo.intersects?(a, b) == true assert Topo.intersects?(b, a) == true assert Topo.disjoint?(a, b) == false assert Topo.disjoint?(b, a) == false assert Topo.contains?(a, b) == false assert Topo.within?(a, b) == false assert Topo.equals?(a, b) == false assert Topo.equals?(b, a) == false end end

f7e14c18b69026f8a1acfbc60099de59fe362a08

ex

Elixir

lib/mix/tasks/pandoc/update_infos.ex

dmitriid/panpipe

c93a189dd8aa40a3cef4d9fac5830268682df9eb

2019-08-19T02:53:06.000Z

2022-03-13T14:41:08.000Z

lib/mix/tasks/pandoc/update_infos.ex

dmitriid/panpipe

c93a189dd8aa40a3cef4d9fac5830268682df9eb

2020-04-02T02:05:52.000Z

2022-03-18T00:56:23.000Z

lib/mix/tasks/pandoc/update_infos.ex

dmitriid/panpipe

c93a189dd8aa40a3cef4d9fac5830268682df9eb

2019-10-28T15:38:47.000Z

2021-03-24T17:43:27.000Z

defmodule Mix.Tasks.Pandoc.UpdateInfos do @moduledoc false use Mix.Task alias Panpipe.Pandoc @shortdoc "Updates the information about the supported features of Pandoc." def run(_) do Mix.Shell.IO.cmd "pandoc --list-extensions > #{Pandoc.extensions_file()}" Mix.Shell.IO.cmd "pandoc --list-highlight-languages > #{Pandoc.highlight_languages_file()}" Mix.Shell.IO.cmd "pandoc --list-highlight-styles > #{Pandoc.highlight_styles_file()}" Mix.Shell.IO.cmd "pandoc --list-input-formats > #{Pandoc.input_formats_file()}" Mix.Shell.IO.cmd "pandoc --list-output-formats > #{Pandoc.output_formats_file()}" end end

f7e170eed2c0fd48e492a7a82fca339e78da9a7d

exs

Elixir

farmbot_firmware/mix.exs

va2ron1/farmbot_os

c80a38058713adc2ad91a4802664bcfe8da9d96c

farmbot_firmware/mix.exs

va2ron1/farmbot_os

c80a38058713adc2ad91a4802664bcfe8da9d96c

farmbot_firmware/mix.exs

va2ron1/farmbot_os

c80a38058713adc2ad91a4802664bcfe8da9d96c

defmodule FarmbotFirmware.MixProject do use Mix.Project @version Path.join([__DIR__, "..", "VERSION"]) |> File.read!() |> String.trim() @elixir_version Path.join([__DIR__, "..", "ELIXIR_VERSION"]) |> File.read!() |> String.trim() defp arduino_commit do opts = [cd: Path.join("c_src", "farmbot-arduino-firmware")] System.cmd("git", ~w"rev-parse --verify HEAD", opts) |> elem(0) |> String.trim() end def project do [ app: :farmbot_firmware, version: @version, elixir: @elixir_version, elixirc_options: [warnings_as_errors: true, ignore_module_conflict: true], arduino_commit: arduino_commit(), start_permanent: Mix.env() == :prod, deps: deps(), test_coverage: [tool: ExCoveralls], preferred_cli_env: [ test: :test, coveralls: :test, "coveralls.circle": :test, "coveralls.detail": :test, "coveralls.post": :test, "coveralls.html": :test ], source_url: "https://github.com/Farmbot/farmbot_os", homepage_url: "http://farmbot.io", docs: [ logo: "../farmbot_os/priv/static/farmbot_logo.png", extras: Path.wildcard("../docs/**/*.md") ] ] end # Run "mix help compile.app" to learn about applications. def application do [ extra_applications: [:logger] ] end # Run "mix help deps" to learn about dependencies. defp deps do [ {:farmbot_telemetry, path: "../farmbot_telemetry", env: Mix.env()}, {:circuits_uart, "~> 1.4.2"}, {:excoveralls, "~> 0.13.3", only: [:test], targets: [:host]}, {:mimic, "~> 1.3.1", only: :test}, {:ex_doc, "~> 0.23.0", only: [:dev], targets: [:host], runtime: false} ] end end

f7e1b829b987cff39298451077f6ef72daedf385

exs

Elixir

test/fixtures/umbrella/apps/api/mix.exs

snyk/mix-parser

1816912559529b41919f1ccee09dcf79aad3548d

2021-05-14T04:31:05.000Z

2022-02-07T19:03:54.000Z

test/fixtures/umbrella/apps/api/mix.exs

snyk/snyk-hex-plugin

1f4db02fe247c984b694957663e50d43362947b0

2021-04-29T08:07:22.000Z

2022-02-28T22:48:46.000Z

test/fixtures/umbrella/apps/api/mix.exs

snyk/mix-parser

1816912559529b41919f1ccee09dcf79aad3548d

2021-06-30T23:41:25.000Z

2021-10-07T22:06:25.000Z

defmodule Api.Mixfile do use Mix.Project def project do [ app: :api, version: "0.1.0", build_path: "../../_build", config_path: "../../config/config.exs", deps_path: "../../deps", lockfile: "../../mix.lock", elixir: "~> 1.7", elixirc_paths: elixirc_paths(Mix.env), compilers: [:phoenix] ++ Mix.compilers, start_permanent: Mix.env == :prod, deps: deps() ] end def application do [ mod: {Api.Application, []}, extra_applications: [:logger, :runtime_tools] ] end defp elixirc_paths(:test), do: ["lib", "test/support"] defp elixirc_paths(_), do: ["lib"] defp deps do [ {:core, in_umbrella: true}, {:cowboy, "~> 1.0"}, {:phoenix, "~> 1.3.4"} ] end end

f7e20286612f591e6d8447c4d9e10558879f0ea7

ex

Elixir

apps/extended_api/lib/extended_api_web/views/command_view.ex

iotaledger/chronicle

73566e5613268e4b0c5951265ae4760cedb4051f

2019-09-17T18:14:36.000Z

2021-12-06T07:29:27.000Z

apps/extended_api/lib/extended_api_web/views/command_view.ex

iotaledger/chronicle

73566e5613268e4b0c5951265ae4760cedb4051f

2019-09-30T04:57:14.000Z

2020-11-10T15:41:03.000Z

apps/extended_api/lib/extended_api_web/views/command_view.ex

iotaledger/chronicle

73566e5613268e4b0c5951265ae4760cedb4051f

2019-09-17T19:03:16.000Z

2021-03-01T01:04:31.000Z

defmodule ExtendedApiWeb.CommandView do use ExtendedApiWeb, :view @derive Jason.Encoder def render("getTrytes.json", %{trytes: trytes}) do %{trytes: trytes} end def render("bundles.json", %{hashes: hashes}) do %{hashes: hashes} end def render("addresses.json", %{hashes: hashes, hints: hints}) do %{hashes: hashes, hints: hints} end def render("approvees.json", %{hashes: hashes}) do %{hashes: hashes} end def render("tags.json", %{hints: hints}) do %{hints: hints} end end

f7e22f2ac404eb1c68c8aea5fcf72058ec8abe13

ex

Elixir

lib/packages_bot/melpa/client.ex

thiamsantos/melpa_telegram_bot

f71b4c4d6dec3dbfa1f137a0acb39cb02e72162f

2019-04-12T23:24:20.000Z

2019-04-17T12:18:12.000Z

lib/packages_bot/melpa/client.ex

thiamsantos/melpa_telegram_bot

f71b4c4d6dec3dbfa1f137a0acb39cb02e72162f

2019-04-17T12:16:41.000Z

2019-04-24T23:34:01.000Z

lib/packages_bot/melpa/client.ex

thiamsantos/melpa_telegram_bot

f71b4c4d6dec3dbfa1f137a0acb39cb02e72162f

2019-04-13T13:37:18.000Z

2019-04-13T13:37:18.000Z

defmodule PackagesBot.Melpa.Client do use Tesla plug Tesla.Middleware.BaseUrl, "https://melpa.org" plug Tesla.Middleware.Headers, [{"user-agent", "Melpa telegram bot"}] plug PackagesBot.TeslaLogger, marker: inspect(__MODULE__) plug Tesla.Middleware.JSON def archive do case get("archive.json") do {:ok, %{body: body, status: 200}} when is_map(body) -> {:ok, body} _ -> {:error, "Failed to fetch archive!"} end end def download_counts do case get("download_counts.json") do {:ok, %{body: body, status: 200}} when is_map(body) -> {:ok, body} _ -> {:error, "Failed to fetch download counts!"} end end end

f7e2454a500292a972ed0384550dc0acf8f74ffb

ex

Elixir

lib/toy.ex

bconnes/arcgis

cfe9dd53cb58dac30f0d64ee2c4ad3661e866c50

lib/toy.ex

bconnes/arcgis

cfe9dd53cb58dac30f0d64ee2c4ad3661e866c50

lib/toy.ex

bconnes/arcgis

cfe9dd53cb58dac30f0d64ee2c4ad3661e866c50

defmodule Toy do use GenServer def store(key, value) do GenServer.cast(__MODULE__, {:store, key, value}) end def get(key) do GenServer.call(__MODULE__, {:get, key}) end def start_link, do: GenServer.start_link(__MODULE__, :ok, [name: Toy]) def init(_args) do starting_state = %{ key_value: %{} } {:ok, starting_state} end def handle_cast({:store, key, value}, state) do key_value = state.key_value new_key_value = Map.put(key_value, key, value) new_state = Map.put(state, :key_value, new_key_value) {:noreply, new_state} end def handle_call({:get, key}, _from, state) do key_value = state.key_value value = Map.get(key_value, key) {:reply, value, state} end end

f7e283b201ff743641d7f828c77010da88320b47

exs

Elixir

test/tenancy_model_test.exs

wise-home/wise_homex

851f13191ed67acb1003888c12f4e6b71800d31b

2019-03-14T09:09:14.000Z

2020-11-25T06:44:46.000Z

test/tenancy_model_test.exs

wise-home/wise_homex

851f13191ed67acb1003888c12f4e6b71800d31b

2019-03-14T06:58:55.000Z

2022-03-29T12:28:09.000Z

test/tenancy_model_test.exs

wise-home/wise_homex

851f13191ed67acb1003888c12f4e6b71800d31b

2021-04-09T13:55:45.000Z

2021-04-16T15:49:36.000Z

defmodule WiseHomex.TenancyModelTest do @moduledoc false use WiseHomex.Test.Case, async: true import WiseHomex.Tenancy, only: [sort_date: 1] doctest WiseHomex.Tenancy end

f7e2ce163af9b57cf4a57280362cdb1fbd1784e3

ex

Elixir

lib/blockquote_web/controllers/daily_quote_controller.ex

allen-garvey/block-quote-phoenix

5c0f5d16daf6bb515a8f1846c3e4311b368a7bdb

lib/blockquote_web/controllers/daily_quote_controller.ex

allen-garvey/block-quote-phoenix

5c0f5d16daf6bb515a8f1846c3e4311b368a7bdb

2020-09-05T17:07:13.000Z

2020-09-05T17:07:13.000Z

lib/blockquote_web/controllers/daily_quote_controller.ex

allen-garvey/block-quote-phoenix

5c0f5d16daf6bb515a8f1846c3e4311b368a7bdb

defmodule BlockquoteWeb.DailyQuoteController do use BlockquoteWeb, :controller alias Blockquote.Admin alias Blockquote.Admin.DailyQuote def custom_render(conn, template, assigns) do custom_render(conn, view_module(conn), template, assigns) end def custom_render(conn, view_module, template, assigns) do assigns = [{:item_name_singular, "daily quote"}] ++ assigns render(conn, view_module, template, assigns) end def related_fields do quotes = Admin.list_quotes() |> BlockquoteWeb.QuoteView.map_for_form [quotes: quotes] end def index(conn, _params) do daily_quotes = Admin.list_daily_quotes_for_index() custom_render(conn, BlockquoteWeb.SharedView, "index.html", items: daily_quotes, item_view: view_module(conn), item_display_func: :to_s) end def new_page(conn, changeset, _params) do custom_render(conn, "new.html", changeset: changeset, related_fields: related_fields()) end def edit_page(conn, changeset, daily_quote) do custom_render(conn, "edit.html", changeset: changeset, related_fields: related_fields(), item: daily_quote) end def new(conn, params) do changeset = Admin.change_daily_quote(%DailyQuote{}) new_page(conn, changeset, params) end def create(conn, %{"daily_quote" => daily_quote_params}) do case Admin.create_daily_quote(daily_quote_params) do {:ok, daily_quote} -> conn |> put_flash(:info, "Daily quote created successfully.") |> redirect(to: daily_quote_path(conn, :show, daily_quote)) {:error, %Ecto.Changeset{} = changeset} -> new_page(conn, changeset, nil) end end def show(conn, %{"id" => id}) do daily_quote = Admin.get_daily_quote_for_show!(id) custom_render(conn, "show.html", daily_quote: daily_quote) end def edit(conn, %{"id" => id}) do daily_quote = Admin.get_daily_quote!(id) changeset = Admin.change_daily_quote(daily_quote) edit_page(conn, changeset, daily_quote) end def update(conn, %{"id" => id, "daily_quote" => daily_quote_params}) do daily_quote = Admin.get_daily_quote!(id) case Admin.update_daily_quote(daily_quote, daily_quote_params) do {:ok, daily_quote} -> conn |> put_flash(:info, "Daily quote updated successfully.") |> redirect(to: daily_quote_path(conn, :show, daily_quote)) {:error, %Ecto.Changeset{} = changeset} -> edit_page(conn, changeset, daily_quote) end end def delete(conn, %{"id" => id}) do daily_quote = Admin.get_daily_quote!(id) {:ok, _daily_quote} = Admin.delete_daily_quote(daily_quote) conn |> put_flash(:info, "Daily quote deleted successfully.") |> redirect(to: daily_quote_path(conn, :index)) end end

f7e333de8c3d49ed3458d36949f86763ba9eb5c4

ex

Elixir

lib/smppex/mc.ex

desoulter/smppex

1c8dbd9673291431b2d329a2cb20134c91857af2

lib/smppex/mc.ex

desoulter/smppex

1c8dbd9673291431b2d329a2cb20134c91857af2

lib/smppex/mc.ex

desoulter/smppex

1c8dbd9673291431b2d329a2cb20134c91857af2

defmodule SMPPEX.MC do @moduledoc """ This is a module for launching a TCP listener (or any other listener supported by `ranch`, for example, `ssl`) which handles incoming connections with the passed `SMPPEX.Session` implementations. To start an MC one generally should do the following. 1. Implement an `SMPPEX.Session` behaviour. ```elixir defmodule MyMCSession do use SMPPEX.Session # ...Callback implementation end ``` 2. Start a listener passing implemented behaviour as a callback module. ```elixir {:ok, listener} = SMPPEX.MC.start({MyESMESession, some_args}, transport_opts: [port: 2775]) ``` The important things to note are: * There is no `start_link` method, since started listener is not a standalone `GenServer` but a pool of socket acceptors running under `Ranch` supervisor. * Each received connection is served with its own process which uses passed callback module (`MyESMESession`) for handling connection events. Each process has his own state initialized by `init` callback receiving `socket`, `transport` and a copy of arguments (`some_args`). """ alias :ranch, as: Ranch alias SMPPEX.Session.Defaults @default_transport :ranch_tcp @default_acceptor_count 50 @spec start({module, args :: term}, opts :: Keyword.t()) :: {:ok, listener_ref :: Ranch.ref()} | {:error, reason :: term} @doc """ Starts listener for MC entitiy. `module` is the callback module which should implement `SMPPEX.Session` behaviour. `args` is the argument passed to the `init` callback each time a new connection is received. `opts` is a keyword list of different options: * `:transport` is Ranch transport used for TCP connections: either `ranch_tcp` (the default) or `ranch_ssl`; * `:transport_opts` is a list of Ranch transport options. The major option is `{:port, port}`. The port is set to `0` by default, which means that the listener will accept connections on a random free port. * `:acceptor_count` is the number of Ranch listener acceptors, #{@default_acceptor_count} by default. * `:mc_opts` is a keyword list of MC options: - `:timer_resolution` is interval of internal `ticks` on which time related events happen, like checking timeouts for pdus, checking SMPP timers, etc. The default is #{ inspect(Defaults.timer_resolution()) } ms; - `:session_init_limit` is the maximum time for which a session waits an incoming bind request. If no bind request is received within this interval of time, the session stops. The default value is #{ inspect(Defaults.session_init_limit()) } ms; - `:enquire_link_limit` is value for enquire_link SMPP timer, i.e. the interval of SMPP session inactivity after which enquire_link PDU is send to "ping" the connetion. The default value is #{ inspect(Defaults.enquire_link_limit()) } ms; - `:enquire_link_resp_limit` is the maximum time for which a session waits for enquire_link PDU response. If the response is not received within this interval of time and no activity from the peer occurs, the session is then considered dead and the session stops. The default value is #{ inspect(Defaults.enquire_link_resp_limit()) } ms; - `:inactivity_limit` is the maximum time for which a peer is allowed not to send PDUs (which are not response PDUs). If no such PDUs are received within this interval of time, the session stops. The default is #{ inspect(Defaults.inactivity_limit()) } ms; - `:response_limit` is the maximum time to wait for a response for a previously sent PDU. If the response is not received within this interval, `handle_resp_timeout` callback is triggered for the original pdu. If the response is received later, it is discarded. The default value is #{ inspect(Defaults.response_limit()) } ms. If `:mc_opts` list of options is ommited, all options take their default values. The returned value is either `{:ok, ref}` or `{:error, reason}`. The `ref` can be later used to stop the whole MC listener and all sessions received by it. """ def start({_module, _args} = mod_with_args, opts \\ []) do acceptor_count = Keyword.get(opts, :acceptor_count, @default_acceptor_count) transport = Keyword.get(opts, :transport, @default_transport) transport_opts = Keyword.get(opts, :transport_opts, [{:port, 0}]) mc_opts = Keyword.get(opts, :mc_opts, []) ref = make_ref() start_result = Ranch.start_listener( ref, acceptor_count, transport, transport_opts, SMPPEX.TransportSession, {SMPPEX.Session, [mod_with_args, mc_opts], :mc} ) case start_result do {:error, _} = error -> error {:ok, _, _} -> {:ok, ref} {:ok, _} -> {:ok, ref} end end @spec stop(Ranch.ref()) :: :ok @doc """ Stops MC listener and all its sessions. """ def stop(listener) do Ranch.stop_listener(listener) end end

f7e36b9bc74f5f66189afe95e4d1bd11f77c1c34

ex

Elixir

clients/vision/lib/google_api/vision/v1/model/google_cloud_vision_v1p5beta1_input_config.ex

matehat/elixir-google-api

c1b2523c2c4cdc9e6ca4653ac078c94796b393c3

2018-12-03T23:43:10.000Z

2018-12-03T23:43:10.000Z

clients/vision/lib/google_api/vision/v1/model/google_cloud_vision_v1p5beta1_input_config.ex

matehat/elixir-google-api

c1b2523c2c4cdc9e6ca4653ac078c94796b393c3

clients/vision/lib/google_api/vision/v1/model/google_cloud_vision_v1p5beta1_input_config.ex

matehat/elixir-google-api

c1b2523c2c4cdc9e6ca4653ac078c94796b393c3

# Copyright 2019 Google LLC # # Licensed under the Apache License, Version 2.0 (the &quot;License&quot;); # 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 &quot;AS IS&quot; 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. # NOTE: This class is auto generated by the elixir code generator program. # Do not edit the class manually. defmodule GoogleApi.Vision.V1.Model.GoogleCloudVisionV1p5beta1InputConfig do @moduledoc """ The desired input location and metadata. ## Attributes * `content` (*type:* `String.t`, *default:* `nil`) - File content, represented as a stream of bytes. Note: As with all `bytes` fields, protobuffers use a pure binary representation, whereas JSON representations use base64. Currently, this field only works for BatchAnnotateFiles requests. It does not work for AsyncBatchAnnotateFiles requests. * `gcsSource` (*type:* `GoogleApi.Vision.V1.Model.GoogleCloudVisionV1p5beta1GcsSource.t`, *default:* `nil`) - The Google Cloud Storage location to read the input from. * `mimeType` (*type:* `String.t`, *default:* `nil`) - The type of the file. Currently only "application/pdf", "image/tiff" and "image/gif" are supported. Wildcards are not supported. """ use GoogleApi.Gax.ModelBase @type t :: %__MODULE__{ :content => String.t(), :gcsSource => GoogleApi.Vision.V1.Model.GoogleCloudVisionV1p5beta1GcsSource.t(), :mimeType => String.t() } field(:content) field(:gcsSource, as: GoogleApi.Vision.V1.Model.GoogleCloudVisionV1p5beta1GcsSource) field(:mimeType) end defimpl Poison.Decoder, for: GoogleApi.Vision.V1.Model.GoogleCloudVisionV1p5beta1InputConfig do def decode(value, options) do GoogleApi.Vision.V1.Model.GoogleCloudVisionV1p5beta1InputConfig.decode(value, options) end end defimpl Poison.Encoder, for: GoogleApi.Vision.V1.Model.GoogleCloudVisionV1p5beta1InputConfig do def encode(value, options) do GoogleApi.Gax.ModelBase.encode(value, options) end end

f7e372e0896063659585da2725c97a821829943f

exs

Elixir

mix.exs

wesleimp/humanizex

ba459d3b9f8f92b3900fd618ca3ce5920259d559

mix.exs

wesleimp/humanizex

ba459d3b9f8f92b3900fd618ca3ce5920259d559

mix.exs

wesleimp/humanizex

ba459d3b9f8f92b3900fd618ca3ce5920259d559

defmodule Humanizex.MixProject do use Mix.Project @version "0.1.0" @source_url "https://github.com/wesleimp/humanizex" def project do [ app: :humanizex, version: "0.1.0", elixir: "~> 1.11", start_permanent: Mix.env() == :prod, description: "A simple library for making the web more humane.", deps: deps(), package: package(), docs: docs() ] end # Run "mix help compile.app" to learn about applications. def application do [ extra_applications: [:logger] ] end # Run "mix help deps" to learn about dependencies. defp deps do [ {:ex_doc, "~> 0.23", only: :dev, runtime: false} ] end defp package do [ files: ["lib", "mix.exs", "README.md", "LICENSE"], maintainers: ["Weslei Juan Moser Pereira"], licenses: ["MIT"], links: %{GitHub: @source_url} ] end defp docs do [ main: "readme", source_url: @source_url, source_ref: "v#{@version}", formatter_opts: [gfm: true], extras: [ "README.md" ] ] end end

f7e3824c1c89caf57bb588aa1f606ba6023653fe

exs

Elixir

mix.exs

wundercar/paytm

378ce47ae68588b80a60098f84ea50eb380cf7de

2017-11-10T14:57:02.000Z

2018-01-30T04:53:11.000Z

mix.exs

wundercar/paytm

378ce47ae68588b80a60098f84ea50eb380cf7de

2019-04-16T12:55:01.000Z

2020-08-25T15:17:52.000Z

mix.exs

wundercar/paytm

378ce47ae68588b80a60098f84ea50eb380cf7de

defmodule Paytm.Mixfile do use Mix.Project def project do [ app: :paytm, version: "0.8.2", elixir: "~> 1.5", start_permanent: Mix.env() == :prod, deps: deps(), elixirc_paths: elixirc_paths(Mix.env()), package: package(), aliases: aliases(), description: "Paytm API client for Elixir with Wallet, Gratification and OAuth API support" ] end def application do [ extra_applications: [:logger] ] end defp package do [ maintainers: [ "Nihal Gonsalves <[email protected]>" ], licenses: ["MIT"], links: %{"GitHub" => "https://github.com/wundercar/paytm"} ] end defp deps do [ {:httpoison, "~> 1.2"}, {:poison, "~> 3.1"}, {:money, "~> 1.4"}, {:exvcr, "~> 0.8", only: :test}, {:ex_doc, "~> 0.20.2", only: :dev}, {:timex, "~> 3.1"}, {:uuid, "~> 1.1", only: [:dev, :test]} ] end defp elixirc_paths(:test), do: ["lib", "test/support"] defp elixirc_paths(_), do: ["lib"] defp aliases do [ compile: ["compile --warnings-as-errors"] ] end end

f7e391fbfd12a356b47adc6f6df089acf04a962b

ex

Elixir

exrack_firmware/lib/exrack_firmware/dht.ex

jirimakarius/exrack

e499ea62f61000463360adb6b2b7a9ce9695467f

exrack_firmware/lib/exrack_firmware/dht.ex

jirimakarius/exrack

e499ea62f61000463360adb6b2b7a9ce9695467f

exrack_firmware/lib/exrack_firmware/dht.ex

jirimakarius/exrack

e499ea62f61000463360adb6b2b7a9ce9695467f

defmodule ExRack.DHT do @moduledoc false use GenServer @period 10_000 # Client def start_link(state) do GenServer.start_link(__MODULE__, state, name: __MODULE__) end def config do Application.fetch_env!(:exrack_firmware, ExRack.DHT) |> Map.new() end def temperature do GenServer.call(__MODULE__, :temperature) end def humidity do GenServer.call(__MODULE__, :humidity) end def data do GenServer.call(__MODULE__, :data) end def subscribe() do GenServer.call(__MODULE__, :subscribe) end # Server @impl true def init(state) do state = state |> Map.merge(%{temperature: nil, humidity: nil, subscribed: []}) schedule_work() {:ok, state} end @impl true def handle_info(:work, %{:gpio => gpio, :sensor => sensor, :subscribed => subscribed} = state) do state = case DHT.read(gpio, sensor) do {:ok, %{:humidity => humidity, :temperature => temperature}} -> :telemetry.execute([:dht, :humididty], %{percent: humidity}, %{sensor: sensor}) :telemetry.execute([:dht, :temperature], %{celsius: temperature}, %{sensor: sensor}) Enum.each(subscribed, fn pid -> if Process.alive?(pid) do Process.send(pid, {:dht, %{:temperature => temperature, :humidity => humidity}}, []) end end) Map.merge(state, %{:temperature => temperature, :humidity => humidity}) _ -> state end schedule_work() {:noreply, state} end @impl true def handle_call(:temperature, _from, %{:temperature => temperature} = state) do {:reply, temperature, state} end @impl true def handle_call(:humidity, _from, %{:humidity => humidity} = state) do {:reply, humidity, state} end @impl true def handle_call(:data, _from, %{:humidity => humidity, :temperature => temperature} = state) do {:reply, %{:temperature => temperature, :humidity => humidity}, state} end @impl true def handle_call(:subscribe, {pid, _}, state) do subscribed_state = [pid | state.subscribed] {:reply, :ok, Map.put(state, :subscribed, subscribed_state)} end defp schedule_work do Process.send_after(self(), :work, @period) end end

f7e3cae62aab95169ebe13176e4749bbdd72e03d

ex

Elixir

lib/sir_alex_web/views/group_view.ex

dnsbty/sir_alex

ab569dc7692826411877728444eaa00ec05767c2

2019-05-19T05:27:37.000Z

2020-04-21T06:23:08.000Z

lib/sir_alex_web/views/group_view.ex

dnsbty/sir_alex

ab569dc7692826411877728444eaa00ec05767c2

2017-10-28T20:52:07.000Z

2017-11-24T08:15:27.000Z

lib/sir_alex_web/views/group_view.ex

dnsbty/sir_alex

ab569dc7692826411877728444eaa00ec05767c2

2020-04-15T16:31:28.000Z

2020-04-15T16:31:28.000Z

defmodule SirAlexWeb.GroupView do use SirAlexWeb, :view alias SirAlex.Groups.Group def action_button(conn, %Group{is_private?: false} = group, false) do join_button("Join Group", conn, group) end def action_button(conn, %Group{is_private?: true} = group, false) do join_button("Request to Join Group", conn, group) end def action_button(conn, group, true) do options = [ to: member_path(conn, :leave, group), method: :delete, class: "btn btn-secondary" ] link("Leave Group", options) end defp join_button(link_text, conn, group) do options = [ to: member_path(conn, :create, group), method: :post, class: "btn btn-primary" ] link(link_text, options) end end

f7e3e20c9ccc645eec3180675d8fd995be6d55ba

ex

Elixir

lib/chat_api/repo.ex

vbrazo/chat_elixir_api

f2595d123934014b3a7c1b3b63b987fa3df5b3ad

2021-04-30T08:30:26.000Z

2021-04-30T16:20:39.000Z

lib/chat_api/repo.ex

vbrazo/chat_elixir_api

f2595d123934014b3a7c1b3b63b987fa3df5b3ad

lib/chat_api/repo.ex

vbrazo/chat_elixir_api

f2595d123934014b3a7c1b3b63b987fa3df5b3ad

defmodule ChatApi.Repo do use Ecto.Repo, otp_app: :chat_api @doc """ Dynamically loads the repository url from the DATABASE_URL environment variable. """ def init(_, opts) do {:ok, Keyword.put(opts, :url, System.get_env("DATABASE_URL"))} end end

f7e3e48b3e37c3926c625f5899d61c1b822416fe

ex

Elixir

larc_website/test/support/channel_case.ex

Cate-Lukner/cate-lukner-internship

43e8b467287ea3a7955e23f18180cb4f849e6620

larc_website/test/support/channel_case.ex

Cate-Lukner/cate-lukner-internship

43e8b467287ea3a7955e23f18180cb4f849e6620

larc_website/test/support/channel_case.ex

Cate-Lukner/cate-lukner-internship

43e8b467287ea3a7955e23f18180cb4f849e6620

2020-05-22T19:21:24.000Z

2020-05-22T19:21:24.000Z

defmodule LarcWebsiteWeb.ChannelCase do @moduledoc """ This module defines the test case to be used by channel tests. Such tests rely on `Phoenix.ChannelTest` and also import other functionality to make it easier to build common data structures and query the data layer. Finally, if the test case interacts with the database, we enable the SQL sandbox, so changes done to the database are reverted at the end of every test. If you are using PostgreSQL, you can even run database tests asynchronously by setting `use LarcWebsiteWeb.ChannelCase, async: true`, although this option is not recommended for other databases. """ use ExUnit.CaseTemplate using do quote do # Import conveniences for testing with channels import Phoenix.ChannelTest import LarcWebsiteWeb.ChannelCase # The default endpoint for testing @endpoint LarcWebsiteWeb.Endpoint end end setup tags do :ok = Ecto.Adapters.SQL.Sandbox.checkout(LarcWebsite.Repo) unless tags[:async] do Ecto.Adapters.SQL.Sandbox.mode(LarcWebsite.Repo, {:shared, self()}) end :ok end end

f7e3f3c4dfa4545a5bc062bf2ccb779db91594e3

ex

Elixir

lib/ref_web/router.ex

tk04/ref

6547a58344141e09300284943264dfe02f1e84f3

lib/ref_web/router.ex

tk04/ref

6547a58344141e09300284943264dfe02f1e84f3

lib/ref_web/router.ex

tk04/ref

6547a58344141e09300284943264dfe02f1e84f3

defmodule RefWeb.Router do use RefWeb, :router use PowAssent.Phoenix.Router use Pow.Phoenix.Router use Pow.Extension.Phoenix.Router, extensions: [PowExtensionOne, PowExtensionTwo] pipeline :browser do plug :accepts, ["html"] plug :fetch_session plug :fetch_live_flash plug :put_root_layout, {RefWeb.LayoutView, :root} plug :protect_from_forgery plug :put_secure_browser_headers end pipeline :api do plug :accepts, ["json"] # get "/users", UserController, :get_users end pipeline :skip_csrf_protection do plug :accepts, ["html"] plug :fetch_session plug :fetch_flash end # use this pipline for routes that require user_auth to visit pipeline :protected do plug Pow.Plug.RequireAuthenticated, error_handler: Pow.Phoenix.PlugErrorHandler end scope "/" do pipe_through [:browser] scope "/", RefWeb, as: "pow" do delete "/session", SessionController, :delete post "/session", SessionController, :create post "/registration", RegistrationController, :create get "/auth/paypal/callback", PaypalController, :token end pow_session_routes() pow_extension_routes() end scope "/" do pipe_through :browser pow_assent_routes() pow_routes() end scope "/", RefWeb do pipe_through :browser get "/", IndexController, :index live "/page", PageLive, :index live "/posts", PostLive.Index, :index live "/posts/new", PostLive.Index, :new live "/posts/:id/edit", PostLive.Index, :edit live "/posts/:id", PostLive.Show, :show live "/posts/:id/show/edit", PostLive.Show, :edit live "/comments/new", PostLive.Index, :new_comment resources "/:username/admin", ServiceController post "/:username/admin/status", UserController, :commission_status live "/messages/:username", MessageLive.Index, :index live "/messages/new", MessageLive.Index, :new live "/messages/:id/edit", MessageLive.Index, :edit live "/messages/:id", MessageLive.Show, :show live "/messages/:id/show/edit", MessageLive.Show, :edit get "/:username", UserController, :show post "/:username", UserController, :create_follow delete "/:username", UserController, :delete_follow live "/:username/requests/:rid", MessageLive.Index, :index resources "/:username/:id/requests/", RequestController get "/:username/:id/requests", RequestController, :index get "/:username/:id/requests/:id/edit", RequestController, :edit get "/:username/:id/requests/new", RequestController, :new post "/:username/:id/requests", RequestController, :create patch "/:username/:id/requests/:id", RequestController, :update put "/:username/:id/requests/:id", RequestController, :update delete "/:username/:id/requests/:id", RequestController, :delete end # Other scopes may use custom stacks. # scope "/api", RefWeb do # pipe_through :api # end # Enables LiveDashboard only for development # # If you want to use the LiveDashboard in production, you should put # it behind authentication and allow only admins to access it. # If your application does not have an admins-only section yet, # you can use Plug.BasicAuth to set up some basic authentication # as long as you are also using SSL (which you should anyway). if Mix.env() in [:dev, :test] do import Phoenix.LiveDashboard.Router scope "/" do pipe_through :browser live_dashboard "/dashboard", metrics: RefWeb.Telemetry end end end

f7e3fda42bd937bddf8d40a917c89ffff165f666

ex

Elixir

clients/cloud_tasks/lib/google_api/cloud_tasks/v2beta2/model/list_locations_response.ex

pojiro/elixir-google-api

928496a017d3875a1929c6809d9221d79404b910

2021-12-20T03:40:53.000Z

2021-12-20T03:40:53.000Z

clients/cloud_tasks/lib/google_api/cloud_tasks/v2beta2/model/list_locations_response.ex

pojiro/elixir-google-api

928496a017d3875a1929c6809d9221d79404b910

2020-08-18T00:11:23.000Z

2020-08-18T00:44:16.000Z

clients/cloud_tasks/lib/google_api/cloud_tasks/v2beta2/model/list_locations_response.ex

pojiro/elixir-google-api

928496a017d3875a1929c6809d9221d79404b910

# Copyright 2019 Google LLC # # 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. # NOTE: This file is auto generated by the elixir code generator program. # Do not edit this file manually. defmodule GoogleApi.CloudTasks.V2beta2.Model.ListLocationsResponse do @moduledoc """ The response message for Locations.ListLocations. ## Attributes * `locations` (*type:* `list(GoogleApi.CloudTasks.V2beta2.Model.Location.t)`, *default:* `nil`) - A list of locations that matches the specified filter in the request. * `nextPageToken` (*type:* `String.t`, *default:* `nil`) - The standard List next-page token. """ use GoogleApi.Gax.ModelBase @type t :: %__MODULE__{ :locations => list(GoogleApi.CloudTasks.V2beta2.Model.Location.t()) | nil, :nextPageToken => String.t() | nil } field(:locations, as: GoogleApi.CloudTasks.V2beta2.Model.Location, type: :list) field(:nextPageToken) end defimpl Poison.Decoder, for: GoogleApi.CloudTasks.V2beta2.Model.ListLocationsResponse do def decode(value, options) do GoogleApi.CloudTasks.V2beta2.Model.ListLocationsResponse.decode(value, options) end end defimpl Poison.Encoder, for: GoogleApi.CloudTasks.V2beta2.Model.ListLocationsResponse do def encode(value, options) do GoogleApi.Gax.ModelBase.encode(value, options) end end

f7e41164b29c92469d3b334beb04a4487923369b

ex

Elixir

lib/web/router/router.ex

IvanPereyra-23/PaaS

0179c7b57645473308b0a295a70b6284ed220fbf

2020-08-27T18:43:11.000Z

2020-08-27T18:43:11.000Z

lib/web/router/router.ex

IvanPereyra-23/PaaS

0179c7b57645473308b0a295a70b6284ed220fbf

lib/web/router/router.ex

IvanPereyra-23/PaaS

0179c7b57645473308b0a295a70b6284ed220fbf

2020-08-27T18:43:21.000Z

2020-08-27T18:43:21.000Z

# Copyright(c) 2015-2020 ACCESS CO., LTD. All rights reserved. defmodule Antikythera.Router do @moduledoc """ Defines the antikythera routing DSL. ## Routing macros This module defines macros to be used in each gear's Router module. The names of the macros are the same as the HTTP verbs: `get`, `post`, etc. The macros take the following 4 arguments (although you can omit the last and just pass 3 of them): - URL path pattern which consists of '/'-separated segments. The 1st character must be '/'. To match against incoming request path to a pattern you can use placeholders. See examples below for the usage. - Controller module. Antikythera expects that the module name given here does not contain `GearName.Controller.` as a prefix; it's automatically prepended by antikythera. - Name of the controller action as an atom. - Keyword list of options. Currently available options are `:from` and `:as`. See below for further explanations. ## Example If you define the following router module, defmodule MyGear.Router do use Antikythera.Router static_prefix "/static" websocket "/ws" get "/foo" , Hello, :exact_match post "/foo/:a/:b" , Hello, :placeholders put "/foo/bar/*w", Hello, :wildcard end Then the following requests are routed as: - `GET "/foo"` => `MyGear.Controller.Hello.exact_match/1` is invoked with `path_matches`: `%{}` - `POST "/foo/bar/baz"` => `MyGear.Controller.Hello.placeholders/1` is invoked with `path_matches`: `%{a: "bar", b: "baz"}` - `PUT "/foo/bar/abc/def/ghi"` => `MyGear.Controller.Hello.wildcard/1` is invoked with `path_matches`: `%{w: "abc/def/ghi"}` Note that - Each controller action is expected to receive a `Antikythera.Conn` struct and returns a `Antikythera.Conn` struct. - `Antikythera.Conn` struct has a field `request` which is a `Antikythera.Request` struct. - Matched segments are URL-decoded and stored in `path_matches` field in `Antikythera.Request`. If the result of URL-decoding is nonprintable binary, the request is rejected. ## Websocket endpoint To enable websocket interaction with clients, you must first define `MyGear.Websocket` module. See `Antikythera.Websocket` for more details about websocket handler module. Then invoke `websocket/1` macro in your router. websocket "/ws_path_pattern" The path pattern may have placeholders in the same way as normal routes. GET request with appropriate headers to this path will initialize a websocket connection using the HTTP 1.1 upgrade mechanism. If your gear does not interact with clients via websocket, simply don't invoke `websocket/1` macro in your router. ## Static file serving You can serve your static assets by placing them under `/priv/static` directory in your gear project. The endpoint to be used can be specified by `static_prefix/1` macro. For example, if you add static_prefix "/assets" to your router, you can download `/priv/static/html/index.html` file by sending GET request to the path `/assets/html/index.html`. If you don't need to serve static assets, just don't call `static_prefix/1` macro in your router. Currently, static assets served in this way are NOT automatically gzip compressed, even if `acceept-encoding: gzip` request header is set. It is recommended to use CDN to deliver large static assets in production. See also `Antikythera.Asset` for usage of CDN in delivery of static assets. ## Web requests and gear-to-gear (g2g) requests Antikythera treats both web requests and g2g requests in basically the same way. This means that if you define a route in your gear one can send request to the route using both HTTP and g2g communication. If you want to define a route that can be accessible only via g2g communication, specify `from: :gear` option. get "/foo", Hello, :action1, from: :gear post "/bar", Hello, :action2, from: :gear Similarly passing `from: :web` makes the route accessible only from web request. When dealing with multiple routes, `only_from_web/1` and `only_from_gear/1` macros can be used. For example, the following routes definition is the same as above one. only_from_gear do get "/foo", Hello, :action1 post "/bar", Hello, :action2 end ## Reverse routing To generate URL path of a route (e.g. a link in HTML), you will want to refer to the route's path. For this purpose you can specify `:as` option. For example, you have the following router module defmodule MyGear.Router do use Antikythera.Router get "/foo/:a/:b/*c", Hello, :placeholders, as: :myroute end By writing this the router automatically defines a function `myroute_path/4`, which receives segments that fill placeholders and an optional map for query parameters. MyGear.Router.myroute_path("segment_a", "segment_b", ["wildcard", "part"]) => "/foo/segment_a/segment_b/wildcard/part MyGear.Router.myroute_path("segment_a", "segment_b", ["wildcard", "part"], %{"query" => "param"}) => "/foo/segment_a/segment_b/wildcard/part?query=param Reverse routing helper functions automatically URI-encode all given arguments. If websocket endpoint is enabled, you can get its path with `MyGear.Router.websocket_path/0`. Also if static file serving is enabled, path prefix for static files can be obtained by `MyGear.Router.static_prefix/0`. """ alias Antikythera.Router.Impl defmacro __using__(_) do quote do import Antikythera.Router Module.register_attribute(__MODULE__, :antikythera_web_routes , accumulate: true) Module.register_attribute(__MODULE__, :antikythera_gear_routes, accumulate: true) Module.put_attribute(__MODULE__, :from_option, nil) @before_compile Antikythera.Router end end defmacro __before_compile__(%Macro.Env{module: module}) do web_routing_source = Module.get_attribute(module, :antikythera_web_routes ) |> Enum.reverse() gear_routing_source = Module.get_attribute(module, :antikythera_gear_routes) |> Enum.reverse() routing_quotes(module, web_routing_source, gear_routing_source) ++ reverse_routing_quotes(web_routing_source, gear_routing_source) end defp routing_quotes(module, web_source, gear_source) do Impl.generate_route_function_clauses(module, :web, web_source) ++ Impl.generate_route_function_clauses(module, :gear, gear_source) end defp reverse_routing_quotes(web_source, gear_source) do alias Antikythera.Router.Reverse Enum.uniq(web_source ++ gear_source) |> Enum.reject(fn {_verb, _path, _controller, _action, opts} -> is_nil(opts[:as]) end) |> Enum.map(fn {_verb, path, _controller, _action, opts} -> Reverse.define_path_helper(opts[:as], path) end) end for from <- [:web, :gear] do defmacro unquote(:"only_from_#{from}")(do: block) do current_from = unquote(from) quote do if @from_option, do: raise "nested invocation of `only_from_*` is not allowed" @from_option unquote(current_from) unquote(block) @from_option nil end end end for verb <- Antikythera.Http.Method.all() do defmacro unquote(verb)(path, controller, action, opts \\ []) do %Macro.Env{module: router_module} = __CALLER__ add_route(router_module, unquote(verb), path, controller, action, opts) end end defp add_route(router_module, verb, path, controller_given, action, opts) do quote bind_quoted: [r_m: router_module, verb: verb, path: path, c_g: controller_given, action: action, opts: opts] do controller = Antikythera.Router.fully_qualified_controller_module(r_m, c_g, opts) from_grouped = Module.get_attribute(__MODULE__, :from_option) from_per_route = opts[:from] if from_grouped && from_per_route, do: raise "using :from option within `only_from_*` block is not allowed" opts_without_from_option = Keyword.delete(opts, :from) routing_info = {verb, path, controller, action, opts_without_from_option} case from_grouped || from_per_route do :web -> @antikythera_web_routes routing_info :gear -> @antikythera_gear_routes routing_info nil -> @antikythera_web_routes routing_info @antikythera_gear_routes routing_info end end end def fully_qualified_controller_module(router_module, controller, opts) do if opts[:websocket?] do controller else [ Module.split(router_module) |> hd(), "Controller", Macro.expand(controller, __ENV__), # `{:__aliases__, meta, atoms}` must be expanded ] |> Module.concat() # Executed during compilation; `Module.concat/1` causes no problem end end defmacro websocket(path, opts \\ []) do %Macro.Env{module: router_module} = __CALLER__ ws_module = Module.split(router_module) |> hd() |> Module.concat("Websocket") # during compilation, it's safe to call `Module.concat/2` quote do get unquote(path), unquote(ws_module), :connect, [only_from: :web, websocket?: true] ++ unquote(opts) end end defmacro static_prefix(prefix) do quote bind_quoted: [prefix: prefix] do if prefix =~ ~R|\A(/[0-9A-Za-z.~_-]+)+\z| do def static_prefix(), do: unquote(prefix) else raise "invalid path prefix given to `static_prefix/1`: #{prefix}" end end end end

f7e454ea5f4b916a670325f06fdeccd2f458d73e

ex

Elixir

clients/analytics/lib/google_api/analytics/v3/model/segment.ex

medikent/elixir-google-api

98a83d4f7bfaeac15b67b04548711bb7e49f9490

clients/analytics/lib/google_api/analytics/v3/model/segment.ex

medikent/elixir-google-api

98a83d4f7bfaeac15b67b04548711bb7e49f9490

2020-12-18T09:25:12.000Z

2020-12-18T09:25:12.000Z

clients/analytics/lib/google_api/analytics/v3/model/segment.ex

medikent/elixir-google-api

98a83d4f7bfaeac15b67b04548711bb7e49f9490

2020-10-04T10:12:44.000Z

2020-10-04T10:12:44.000Z

# Copyright 2019 Google LLC # # 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. # NOTE: This file is auto generated by the elixir code generator program. # Do not edit this file manually. defmodule GoogleApi.Analytics.V3.Model.Segment do @moduledoc """ JSON template for an Analytics segment. ## Attributes * `created` (*type:* `DateTime.t`, *default:* `nil`) - Time the segment was created. * `definition` (*type:* `String.t`, *default:* `nil`) - Segment definition. * `id` (*type:* `String.t`, *default:* `nil`) - Segment ID. * `kind` (*type:* `String.t`, *default:* `analytics#segment`) - Resource type for Analytics segment. * `name` (*type:* `String.t`, *default:* `nil`) - Segment name. * `segmentId` (*type:* `String.t`, *default:* `nil`) - Segment ID. Can be used with the 'segment' parameter in Core Reporting API. * `selfLink` (*type:* `String.t`, *default:* `nil`) - Link for this segment. * `type` (*type:* `String.t`, *default:* `nil`) - Type for a segment. Possible values are "BUILT_IN" or "CUSTOM". * `updated` (*type:* `DateTime.t`, *default:* `nil`) - Time the segment was last modified. """ use GoogleApi.Gax.ModelBase @type t :: %__MODULE__{ :created => DateTime.t(), :definition => String.t(), :id => String.t(), :kind => String.t(), :name => String.t(), :segmentId => String.t(), :selfLink => String.t(), :type => String.t(), :updated => DateTime.t() } field(:created, as: DateTime) field(:definition) field(:id) field(:kind) field(:name) field(:segmentId) field(:selfLink) field(:type) field(:updated, as: DateTime) end defimpl Poison.Decoder, for: GoogleApi.Analytics.V3.Model.Segment do def decode(value, options) do GoogleApi.Analytics.V3.Model.Segment.decode(value, options) end end defimpl Poison.Encoder, for: GoogleApi.Analytics.V3.Model.Segment do def encode(value, options) do GoogleApi.Gax.ModelBase.encode(value, options) end end

f7e498499ee512c115a6a388217f4712b37de09e

exs

Elixir

test/phoenix_live_view/integrations/params_test.exs

feliperenan/phoenix_live_view

af65bb51fe12ea88e7c66808d2b1118e1c491ddd

test/phoenix_live_view/integrations/params_test.exs

feliperenan/phoenix_live_view

af65bb51fe12ea88e7c66808d2b1118e1c491ddd

test/phoenix_live_view/integrations/params_test.exs

feliperenan/phoenix_live_view

af65bb51fe12ea88e7c66808d2b1118e1c491ddd

defmodule Phoenix.LiveView.ParamsTest do # Telemetry events need to run asynchronously use ExUnit.Case, async: false import Plug.Conn import Phoenix.ConnTest import Phoenix.LiveViewTest import Phoenix.LiveView.TelemetryTestHelpers alias Phoenix.LiveView alias Phoenix.LiveViewTest.{Endpoint, DOM} @endpoint Endpoint setup_all do ExUnit.CaptureLog.capture_log(fn -> Endpoint.start_link() end) :ok end setup do conn = Phoenix.ConnTest.build_conn(:get, "http://www.example.com/", nil) |> Plug.Test.init_test_session(%{}) |> put_session(:test_pid, self()) {:ok, conn: conn} end defp put_serialized_session(conn, key, value) do put_session(conn, key, :erlang.term_to_binary(value)) end describe "handle_params on disconnected mount" do test "is called with named and query string params", %{conn: conn} do conn = get(conn, "/counter/123", query1: "query1", query2: "query2") response = html_response(conn, 200) assert response =~ rendered_to_string(~s|params: %{"id" => "123", "query1" => "query1", "query2" => "query2"}|) assert response =~ rendered_to_string(~s|mount: %{"id" => "123", "query1" => "query1", "query2" => "query2"}|) end test "telemetry events are emitted on success", %{conn: conn} do attach_telemetry([:phoenix, :live_view, :handle_params]) get(conn, "/counter/123", query1: "query1", query2: "query2") assert_receive {:event, [:phoenix, :live_view, :handle_params, :start], %{system_time: _}, metadata} refute metadata.socket.transport_pid assert metadata.params == %{"query1" => "query1", "query2" => "query2", "id" => "123"} assert metadata.uri == "http://www.example.com/counter/123?query1=query1&query2=query2" assert_receive {:event, [:phoenix, :live_view, :handle_params, :stop], %{duration: _}, metadata} refute metadata.socket.transport_pid assert metadata.params == %{"query1" => "query1", "query2" => "query2", "id" => "123"} assert metadata.uri == "http://www.example.com/counter/123?query1=query1&query2=query2" end test "telemetry events are emitted on exception", %{conn: conn} do attach_telemetry([:phoenix, :live_view, :handle_params]) assert_raise Plug.Conn.WrapperError, ~r/boom/, fn -> get(conn, "/errors", crash_on: "disconnected_handle_params") end assert_receive {:event, [:phoenix, :live_view, :handle_params, :start], %{system_time: _}, metadata} refute metadata.socket.transport_pid assert metadata.params == %{"crash_on" => "disconnected_handle_params"} assert metadata.uri == "http://www.example.com/errors?crash_on=disconnected_handle_params" assert_receive {:event, [:phoenix, :live_view, :handle_params, :exception], %{duration: _}, metadata} refute metadata.socket.transport_pid assert metadata.params == %{"crash_on" => "disconnected_handle_params"} assert metadata.uri == "http://www.example.com/errors?crash_on=disconnected_handle_params" end test "hard redirects", %{conn: conn} do assert conn |> put_serialized_session( :on_handle_params, &{:noreply, LiveView.redirect(&1, to: "/")} ) |> get("/counter/123?from=handle_params") |> redirected_to() == "/" end test "hard redirect with flash message", %{conn: conn} do conn = put_serialized_session(conn, :on_handle_params, fn socket -> {:noreply, socket |> LiveView.put_flash(:info, "msg") |> LiveView.redirect(to: "/")} end) |> fetch_flash() |> get("/counter/123?from=handle_params") assert redirected_to(conn) == "/" assert get_flash(conn, :info) == "msg" end test "push_patch", %{conn: conn} do assert conn |> put_serialized_session(:on_handle_params, fn socket -> {:noreply, LiveView.push_patch(socket, to: "/counter/123?from=rehandled_params")} end) |> get("/counter/123?from=handle_params") |> redirected_to() == "/counter/123?from=rehandled_params" end test "push_redirect", %{conn: conn} do assert conn |> put_serialized_session(:on_handle_params, fn socket -> {:noreply, LiveView.push_redirect(socket, to: "/thermo/456")} end) |> get("/counter/123?from=handle_params") |> redirected_to() == "/thermo/456" end test "with encoded URL", %{conn: conn} do assert get(conn, "/counter/Wm9uZ%2FozNzYxOA%3D%3D?foo=bar+15%26") assert_receive {:handle_params, _uri, _assigns, %{"id" => "Wm9uZ/ozNzYxOA==", "foo" => "bar 15&"}} end end describe "handle_params on connected mount" do test "is called on connected mount with query string params from get", %{conn: conn} do {:ok, _, html} = conn |> get("/counter/123?q1=1", q2: "2") |> live() assert html =~ rendered_to_string(~s|params: %{"id" => "123", "q1" => "1", "q2" => "2"}|) assert html =~ rendered_to_string(~s|mount: %{"id" => "123", "q1" => "1", "q2" => "2"}|) end test "is called on connected mount with query string params from live", %{conn: conn} do {:ok, _, html} = conn |> live("/counter/123?q1=1") assert html =~ rendered_to_string(~s|%{"id" => "123", "q1" => "1"}|) end test "telemetry events are emitted on success", %{conn: conn} do attach_telemetry([:phoenix, :live_view, :handle_params]) live(conn, "/counter/123?foo=bar") assert_receive {:event, [:phoenix, :live_view, :handle_params, :start], %{system_time: _}, %{socket: %{transport_pid: pid}} = metadata} when is_pid(pid) assert metadata.params == %{"id" => "123", "foo" => "bar"} assert metadata.uri == "http://www.example.com/counter/123?foo=bar" assert_receive {:event, [:phoenix, :live_view, :handle_params, :stop], %{duration: _}, %{socket: %{transport_pid: pid}} = metadata} when is_pid(pid) assert metadata.params == %{"id" => "123", "foo" => "bar"} assert metadata.uri == "http://www.example.com/counter/123?foo=bar" end test "telemetry events are emitted on exception", %{conn: conn} do attach_telemetry([:phoenix, :live_view, :handle_params]) assert catch_exit(live(conn, "/errors?crash_on=connected_handle_params")) assert_receive {:event, [:phoenix, :live_view, :handle_params, :start], %{system_time: _}, %{socket: %Phoenix.LiveView.Socket{transport_pid: pid}}} when is_pid(pid) assert_receive {:event, [:phoenix, :live_view, :handle_params, :exception], %{duration: _}, %{socket: %Phoenix.LiveView.Socket{transport_pid: pid}}} when is_pid(pid) end test "hard redirects", %{conn: conn} do {:error, {:redirect, %{to: "/thermo/456"}}} = conn |> put_serialized_session(:on_handle_params, fn socket -> if LiveView.connected?(socket) do {:noreply, LiveView.redirect(socket, to: "/thermo/456")} else {:noreply, socket} end end) |> get("/counter/123?from=handle_params") |> live() end test "push_patch", %{conn: conn} do {:ok, counter_live, _html} = conn |> put_serialized_session(:on_handle_params, fn socket -> if LiveView.connected?(socket) do {:noreply, LiveView.push_patch(socket, to: "/counter/123?from=rehandled_params")} else {:noreply, socket} end end) |> get("/counter/123?from=handle_params") |> live() response = render(counter_live) assert response =~ rendered_to_string(~s|params: %{"from" => "rehandled_params", "id" => "123"}|) assert response =~ rendered_to_string(~s|mount: %{"from" => "handle_params", "id" => "123"}|) end test "push_redirect", %{conn: conn} do {:error, {:live_redirect, %{to: "/thermo/456"}}} = conn |> put_serialized_session(:on_handle_params, fn socket -> if LiveView.connected?(socket) do {:noreply, LiveView.push_redirect(socket, to: "/thermo/456")} else {:noreply, socket} end end) |> get("/counter/123?from=handle_params") |> live() end test "with encoded URL", %{conn: conn} do {:ok, _counter_live, _html} = live(conn, "/counter/Wm9uZTozNzYxOA%3D%3D?foo=bar+15%26") assert_receive {:handle_params, _uri, %{connected?: true}, %{"id" => "Wm9uZTozNzYxOA==", "foo" => "bar 15&"}} end end describe "live_link" do test "renders static container", %{conn: conn} do container = conn |> get("/counter/123", query1: "query1", query2: "query2") |> html_response(200) |> DOM.parse() |> hd() assert { "div", [ {"data-phx-main", "true"}, {"data-phx-session", _}, {"data-phx-static", _}, {"id", "phx-" <> _} ], ["The value is: 1" <> _] } = container end test "invokes handle_params", %{conn: conn} do {:ok, counter_live, _html} = live(conn, "/counter/123") assert render_patch(counter_live, "/counter/123?filter=true") =~ rendered_to_string(~s|%{"filter" => "true", "id" => "123"}|) end test "with encoded URL", %{conn: conn} do {:ok, counter_live, _html} = live(conn, "/counter/123") assert render_patch(counter_live, "/counter/Wm9uZTozNzYxOa%3d%3d?foo=bar+15%26") =~ rendered_to_string(~s|%{"foo" => "bar 15&", "id" => "Wm9uZTozNzYxOa=="}|) end end describe "push_patch" do test "from event callback ack", %{conn: conn} do {:ok, counter_live, _html} = live(conn, "/counter/123") assert render_click(counter_live, :push_patch, %{to: "/counter/123?from=event_ack"}) =~ rendered_to_string(~s|%{"from" => "event_ack", "id" => "123"}|) assert_patch(counter_live, "/counter/123?from=event_ack") end test "from handle_info", %{conn: conn} do {:ok, counter_live, _html} = live(conn, "/counter/123") send(counter_live.pid, {:push_patch, "/counter/123?from=handle_info"}) assert render(counter_live) =~ rendered_to_string(~s|%{"from" => "handle_info", "id" => "123"}|) end test "from handle_cast", %{conn: conn} do {:ok, counter_live, _html} = live(conn, "/counter/123") :ok = GenServer.cast(counter_live.pid, {:push_patch, "/counter/123?from=handle_cast"}) assert render(counter_live) =~ rendered_to_string(~s|%{"from" => "handle_cast", "id" => "123"}|) end test "from handle_call", %{conn: conn} do {:ok, counter_live, _html} = live(conn, "/counter/123") next = fn socket -> {:reply, :ok, LiveView.push_patch(socket, to: "/counter/123?from=handle_call")} end :ok = GenServer.call(counter_live.pid, {:push_patch, next}) assert render(counter_live) =~ rendered_to_string(~s|%{"from" => "handle_call", "id" => "123"}|) end test "from handle_params", %{conn: conn} do {:ok, counter_live, _html} = live(conn, "/counter/123") next = fn socket -> send(self(), {:set, :val, 1000}) new_socket = LiveView.assign(socket, :on_handle_params, fn socket -> {:noreply, LiveView.push_patch(socket, to: "/counter/123?from=rehandled_params")} end) {:reply, :ok, LiveView.push_patch(new_socket, to: "/counter/123?from=handle_params")} end :ok = GenServer.call(counter_live.pid, {:push_patch, next}) html = render(counter_live) assert html =~ rendered_to_string(~s|%{"from" => "rehandled_params", "id" => "123"}|) assert html =~ "The value is: 1000" assert_receive {:handle_params, "http://www.example.com/counter/123?from=rehandled_params", %{val: 1}, %{"from" => "rehandled_params", "id" => "123"}} end end describe "push_redirect" do test "from event callback", %{conn: conn} do {:ok, counter_live, _html} = live(conn, "/counter/123") assert {:error, {:live_redirect, %{to: "/thermo/123"}}} = render_click(counter_live, :push_redirect, %{to: "/thermo/123"}) assert_redirect(counter_live, "/thermo/123") end test "from handle_params", %{conn: conn} do {:ok, counter_live, _html} = live(conn, "/counter/123") next = fn socket -> new_socket = LiveView.assign(socket, :on_handle_params, fn socket -> {:noreply, LiveView.push_redirect(socket, to: "/thermo/123")} end) {:reply, :ok, LiveView.push_patch(new_socket, to: "/counter/123?from=handle_params")} end :ok = GenServer.call(counter_live.pid, {:push_patch, next}) assert_receive {:handle_params, "http://www.example.com/counter/123?from=handle_params", %{val: 1}, %{"from" => "handle_params", "id" => "123"}} end test "shuts down with push_redirect", %{conn: conn} do {:ok, counter_live, _html} = live(conn, "/counter/123") next = fn socket -> {:noreply, LiveView.push_redirect(socket, to: "/thermo/123")} end assert {{:shutdown, {:live_redirect, %{to: "/thermo/123"}}}, _} = catch_exit(GenServer.call(counter_live.pid, {:push_redirect, next})) end end describe "@live_action" do test "when initially set to nil", %{conn: conn} do {:ok, live, html} = live(conn, "/action") assert html =~ "Live action: nil" assert html =~ "Mount action: nil" assert html =~ "Params: %{}" html = render_patch(live, "/action/index") assert html =~ "Live action: :index" assert html =~ "Mount action: nil" assert html =~ "Params: %{}" html = render_patch(live, "/action/1/edit") assert html =~ "Live action: :edit" assert html =~ "Mount action: nil" assert html =~ "Params: %{&quot;id&quot; =&gt; &quot;1&quot;}" end test "when initially set to action", %{conn: conn} do {:ok, live, html} = live(conn, "/action/index") assert html =~ "Live action: :index" assert html =~ "Mount action: :index" assert html =~ "Params: %{}" html = render_patch(live, "/action") assert html =~ "Live action: nil" assert html =~ "Mount action: :index" assert html =~ "Params: %{}" html = render_patch(live, "/action/1/edit") assert html =~ "Live action: :edit" assert html =~ "Mount action: :index" assert html =~ "Params: %{&quot;id&quot; =&gt; &quot;1&quot;}" end end end

f7e4c857770cec3ccd3629b022f112181d8365bc

ex

Elixir

lib/rasa_sdk/model/tracker.ex

henry-hz/rasa-sdk-elixir

575a57a32b322eb5647bac67bd88e0e03f36685e

2020-06-18T11:26:33.000Z

2021-04-19T18:05:42.000Z

lib/rasa_sdk/model/tracker.ex

henry-hz/rasa-sdk-elixir

575a57a32b322eb5647bac67bd88e0e03f36685e

lib/rasa_sdk/model/tracker.ex

henry-hz/rasa-sdk-elixir

575a57a32b322eb5647bac67bd88e0e03f36685e

2020-06-15T22:16:56.000Z

2021-02-04T01:10:35.000Z

# NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech). # https://openapi-generator.tech # Do not edit the class manually. defmodule RasaSdk.Model.Tracker do @moduledoc """ Conversation tracker which stores the conversation state. """ alias RasaSdk.Model.ParseResult alias RasaSdk.Model.Event alias RasaSdk.Model.TrackerActiveForm @derive [Poison.Encoder] defstruct [ :conversation_id, :slots, :latest_message, :latest_event_time, :followup_action, :paused, :events, :latest_input_channel, :latest_action_name, :active_form ] @type t :: %__MODULE__{ conversation_id: String.t | nil, slots: [Map] | nil, latest_message: ParseResult | nil, latest_event_time: float() | nil, followup_action: String.t | nil, paused: boolean() | nil, events: [Event] | nil, latest_input_channel: String.t | nil, latest_action_name: String.t | nil, active_form: TrackerActiveForm | nil } end defimpl Poison.Decoder, for: RasaSdk.Model.Tracker do import RasaSdk.Deserializer def decode(value, options) do value |> deserialize(:latest_message, :struct, RasaSdk.Model.ParseResult, options) |> deserialize(:events, :list, RasaSdk.Model.Event, options) |> deserialize(:active_form, :struct, RasaSdk.Model.TrackerActiveForm, options) end end

f7e4dd7e1638d590efb27e9a5969d40b0b6d3d1f

ex

Elixir

lib/amqp/basic/async.ex

neggertz/subscribex

5f40b06a514108dbdc42b4d7a166b7f4aa19e693

2016-08-11T11:51:13.000Z

2020-01-12T17:22:11.000Z

lib/amqp/basic/async.ex

neggertz/subscribex

5f40b06a514108dbdc42b4d7a166b7f4aa19e693

2016-10-04T19:26:14.000Z

2018-12-15T19:18:43.000Z

lib/amqp/basic/async.ex

neggertz/subscribex

5f40b06a514108dbdc42b4d7a166b7f4aa19e693

2016-08-09T14:27:57.000Z

2021-04-01T20:18:43.000Z

defmodule AMQP.Basic.Async do @moduledoc false import AMQP.Core alias AMQP.Utils alias AMQP.Channel @doc """ Publishes a message to an Exchange. This method publishes a message to a specific exchange. The message will be routed to queues as defined by the exchange configuration and distributed to any subscribers. The parameter `exchange` specifies the name of the exchange to publish to. If set to empty string, it publishes to the default exchange. The `routing_key` parameter specifies the routing key for the message. The `payload` parameter specifies the message content as a binary. In addition to the previous parameters, the following options can be used: # Options * `:mandatory` - If set, returns an error if the broker can't route the message to a queue (default `false`); * `:immediate` - If set, returns an error if the broker can't deliver te message to a consumer immediately (default `false`); * `:content_type` - MIME Content type; * `:content_encoding` - MIME Content encoding; * `:headers` - Message headers. Can be used with headers Exchanges; * `:persistent` - If set, uses persistent delivery mode. Messages marked as `persistent` that are delivered to `durable` \ queues will be logged to disk; * `:correlation_id` - application correlation identifier; * `:priority` - message priority, ranging from 0 to 9; * `:reply_to` - name of the reply queue; * `:expiration` - how long the message is valid (in milliseconds); * `:message_id` - message identifier; * `:timestamp` - timestamp associated with this message (epoch time); * `:type` - message type as a string; * `:user_id` - creating user ID. RabbitMQ will validate this against the active connection user; * `:app_id` - publishing application ID. ## Examples iex> AMQP.Basic.publish chan, \"my_exchange\", \"my_routing_key\", \"Hello World!\", persistent: true :ok """ @spec publish(Channel.t(), String.t(), String.t(), String.t(), keyword) :: :ok | :blocked | :closing def publish(%Channel{pid: pid}, exchange, routing_key, payload, options \\ []) do basic_publish = basic_publish( exchange: exchange, routing_key: routing_key, mandatory: Keyword.get(options, :mandatory, false), immediate: Keyword.get(options, :immediate, false) ) p_basic = p_basic( content_type: Keyword.get(options, :content_type, :undefined), content_encoding: Keyword.get(options, :content_encoding, :undefined), headers: Keyword.get(options, :headers, :undefined) |> Utils.to_type_tuple(), delivery_mode: if(options[:persistent], do: 2, else: 1), priority: Keyword.get(options, :priority, :undefined), correlation_id: Keyword.get(options, :correlation_id, :undefined), reply_to: Keyword.get(options, :reply_to, :undefined), expiration: Keyword.get(options, :expiration, :undefined), message_id: Keyword.get(options, :message_id, :undefined), timestamp: Keyword.get(options, :timestamp, :undefined), type: Keyword.get(options, :type, :undefined), user_id: Keyword.get(options, :user_id, :undefined), app_id: Keyword.get(options, :app_id, :undefined), cluster_id: Keyword.get(options, :cluster_id, :undefined) ) :amqp_channel.cast(pid, basic_publish, amqp_msg(props: p_basic, payload: payload)) end @doc """ Sets the message prefetch count or prefetech size (in bytes). If `global` is set to `true` this applies to the entire Connection, otherwise it applies only to the specified Channel. """ @spec qos(Channel.t(), keyword) :: :ok def qos(%Channel{pid: pid}, options \\ []) do basic_qos_ok() = :amqp_channel.cast( pid, basic_qos( prefetch_size: Keyword.get(options, :prefetch_size, 0), prefetch_count: Keyword.get(options, :prefetch_count, 0), global: Keyword.get(options, :global, false) ) ) :ok end @doc """ Acknowledges one or more messages. If `multiple` is set to `true`, all messages up to the one specified by `delivery_tag` are considered acknowledged by the server. """ @spec ack(Channel.t(), String.t(), keyword) :: :ok | :blocked | :closing def ack(%Channel{pid: pid}, delivery_tag, options \\ []) do :amqp_channel.cast( pid, basic_ack( delivery_tag: delivery_tag, multiple: Keyword.get(options, :multiple, false) ) ) end @doc """ Rejects (and, optionally, requeues) a message. """ @spec reject(Channel.t(), String.t(), keyword) :: :ok | :blocked | :closing def reject(%Channel{pid: pid}, delivery_tag, options \\ []) do :amqp_channel.cast( pid, basic_reject( delivery_tag: delivery_tag, requeue: Keyword.get(options, :requeue, true) ) ) end @doc """ Negative acknowledge of one or more messages. If `multiple` is set to `true`, all messages up to the one specified by `delivery_tag` are considered as not acknowledged by the server. If `requeue` is set to `true`, the message will be returned to the queue and redelivered to the next available consumer. This is a RabbitMQ specific extension to AMQP 0.9.1. It is equivalent to reject, but allows rejecting multiple messages using the `multiple` option. """ @spec nack(Channel.t(), String.t(), keyword) :: :ok | :blocked | :closing def nack(%Channel{pid: pid}, delivery_tag, options \\ []) do :amqp_channel.cast( pid, basic_nack( delivery_tag: delivery_tag, multiple: Keyword.get(options, :multiple, false), requeue: Keyword.get(options, :requeue, true) ) ) end @doc """ Polls a queue for an existing message. Returns the tuple `{:empty, meta}` if the queue is empty or the tuple {:ok, payload, meta} if at least one message exists in the queue. The returned meta map includes the entry `message_count` with the current number of messages in the queue. Receiving messages by polling a queue is not as as efficient as subscribing a consumer to a queue, so consideration should be taken when receiving large volumes of messages. Setting the `no_ack` option to true will tell the broker that the receiver will not send an acknowledgement of the message. Once it believes it has delivered a message, then it is free to assume that the consuming application has taken responsibility for it. In general, a lot of applications will not want these semantics, rather, they will want to explicitly acknowledge the receipt of a message and have `no_ack` with the default value of false. """ @spec get(Channel.t(), String.t(), keyword) :: {:ok, String.t(), map} | {:empty, map} def get(%Channel{pid: pid}, queue, options \\ []) do case :amqp_channel.cast( pid, basic_get(queue: queue, no_ack: Keyword.get(options, :no_ack, false)) ) do {basic_get_ok( delivery_tag: delivery_tag, redelivered: redelivered, exchange: exchange, routing_key: routing_key, message_count: message_count ), amqp_msg( props: p_basic( content_type: content_type, content_encoding: content_encoding, headers: headers, delivery_mode: delivery_mode, priority: priority, correlation_id: correlation_id, reply_to: reply_to, expiration: expiration, message_id: message_id, timestamp: timestamp, type: type, user_id: user_id, app_id: app_id, cluster_id: cluster_id ), payload: payload )} -> {:ok, payload, %{ delivery_tag: delivery_tag, redelivered: redelivered, exchange: exchange, routing_key: routing_key, message_count: message_count, content_type: content_type, content_encoding: content_encoding, headers: headers, persistent: delivery_mode == 2, priority: priority, correlation_id: correlation_id, reply_to: reply_to, expiration: expiration, message_id: message_id, timestamp: timestamp, type: type, user_id: user_id, app_id: app_id, cluster_id: cluster_id }} basic_get_empty(cluster_id: cluster_id) -> {:empty, %{cluster_id: cluster_id}} end end @doc """ Registers a queue consumer process. The `pid` of the process can be set using the `consumer_pid` argument and defaults to the calling process. The consumer process will receive the following data structures: * `{:basic_deliver, payload, meta}` - This is sent for each message consumed, where \ `payload` contains the message content and `meta` contains all the metadata set when \ sending with Basic.publish or additional info set by the broker; * `{:basic_consume_ok, %{consumer_tag: consumer_tag}}` - Sent when the consumer \ process is registered with Basic.consume. The caller receives the same information \ as the return of Basic.consume; * `{:basic_cancel, %{consumer_tag: consumer_tag, no_wait: no_wait}}` - Sent by the \ broker when the consumer is unexpectedly cancelled (such as after a queue deletion) * `{:basic_cancel_ok, %{consumer_tag: consumer_tag}}` - Sent to the consumer process after a call to Basic.cancel """ @spec consume(Channel.t(), String.t(), pid | nil, keyword) :: {:ok, String.t()} def consume(%Channel{} = chan, queue, consumer_pid \\ nil, options \\ []) do basic_consume = basic_consume( queue: queue, consumer_tag: Keyword.get(options, :consumer_tag, ""), no_local: Keyword.get(options, :no_local, false), no_ack: Keyword.get(options, :no_ack, false), exclusive: Keyword.get(options, :exclusive, false), nowait: Keyword.get(options, :no_wait, false), arguments: Keyword.get(options, :arguments, []) ) consumer_pid = consumer_pid || self() adapter_pid = spawn(fn -> Process.flag(:trap_exit, true) Process.monitor(consumer_pid) Process.monitor(chan.pid) do_start_consumer(chan, consumer_pid) end) basic_consume_ok(consumer_tag: consumer_tag) = :amqp_channel.subscribe(chan.pid, basic_consume, adapter_pid) {:ok, consumer_tag} end defp do_start_consumer(chan, consumer_pid) do receive do basic_consume_ok(consumer_tag: consumer_tag) -> send(consumer_pid, {:basic_consume_ok, %{consumer_tag: consumer_tag}}) do_consume(chan, consumer_pid, consumer_tag) end end defp do_consume(chan, consumer_pid, consumer_tag) do receive do {basic_deliver( consumer_tag: consumer_tag, delivery_tag: delivery_tag, redelivered: redelivered, exchange: exchange, routing_key: routing_key ), amqp_msg( props: p_basic( content_type: content_type, content_encoding: content_encoding, headers: headers, delivery_mode: delivery_mode, priority: priority, correlation_id: correlation_id, reply_to: reply_to, expiration: expiration, message_id: message_id, timestamp: timestamp, type: type, user_id: user_id, app_id: app_id, cluster_id: cluster_id ), payload: payload )} -> send( consumer_pid, {:basic_deliver, payload, %{ consumer_tag: consumer_tag, delivery_tag: delivery_tag, redelivered: redelivered, exchange: exchange, routing_key: routing_key, content_type: content_type, content_encoding: content_encoding, headers: headers, persistent: delivery_mode == 2, priority: priority, correlation_id: correlation_id, reply_to: reply_to, expiration: expiration, message_id: message_id, timestamp: timestamp, type: type, user_id: user_id, app_id: app_id, cluster_id: cluster_id }} ) do_consume(chan, consumer_pid, consumer_tag) basic_consume_ok(consumer_tag: consumer_tag) -> send(consumer_pid, {:basic_consume_ok, %{consumer_tag: consumer_tag}}) do_consume(chan, consumer_pid, consumer_tag) basic_cancel_ok(consumer_tag: consumer_tag) -> send(consumer_pid, {:basic_cancel_ok, %{consumer_tag: consumer_tag}}) basic_cancel(consumer_tag: consumer_tag, nowait: no_wait) -> send(consumer_pid, {:basic_cancel, %{consumer_tag: consumer_tag, no_wait: no_wait}}) {:DOWN, _ref, :process, ^consumer_pid, reason} -> AMQP.Basic.cancel(chan, consumer_tag) exit(reason) {:DOWN, _ref, :process, _pid, reason} -> exit(reason) end end @doc """ Registers a handler to deal with returned messages. The registered process will receive `{:basic_return, payload, meta}` data structures. """ @spec return(Channel.t(), pid) :: :ok def return(%Channel{pid: pid}, return_handler_pid) do adapter_pid = spawn(fn -> Process.flag(:trap_exit, true) Process.monitor(return_handler_pid) Process.monitor(pid) handle_return_messages(pid, return_handler_pid) end) :amqp_channel.register_return_handler(pid, adapter_pid) end @doc """ Removes the return handler, if it exists. Does nothing if there is no such handler. """ @spec cancel_return(Channel.t()) :: :ok def cancel_return(%Channel{pid: pid}) do :amqp_channel.unregister_return_handler(pid) end defp handle_return_messages(chan_pid, return_handler_pid) do receive do {basic_return( reply_code: reply_code, reply_text: reply_text, exchange: exchange, routing_key: routing_key ), amqp_msg( props: p_basic( content_type: content_type, content_encoding: content_encoding, headers: headers, delivery_mode: delivery_mode, priority: priority, correlation_id: correlation_id, reply_to: reply_to, expiration: expiration, message_id: message_id, timestamp: timestamp, type: type, user_id: user_id, app_id: app_id, cluster_id: cluster_id ), payload: payload )} -> send( return_handler_pid, {:basic_return, payload, %{ reply_code: reply_code, reply_text: reply_text, exchange: exchange, routing_key: routing_key, content_type: content_type, content_encoding: content_encoding, headers: headers, persistent: delivery_mode == 2, priority: priority, correlation_id: correlation_id, reply_to: reply_to, expiration: expiration, message_id: message_id, timestamp: timestamp, type: type, user_id: user_id, app_id: app_id, cluster_id: cluster_id }} ) handle_return_messages(chan_pid, return_handler_pid) {:DOWN, _ref, :process, _pid, reason} -> exit(reason) end end end

f7e4fc70c20f5ce2c5a791061282b45fe0fd894c

ex

Elixir

lib/mix/lib/mix/utils.ex

enokd/elixir

e39b32f235082b8a29fcb22d250c822cca98609f

2015-11-12T19:23:45.000Z

2015-11-12T19:23:45.000Z

lib/mix/lib/mix/utils.ex

enokd/elixir

e39b32f235082b8a29fcb22d250c822cca98609f

lib/mix/lib/mix/utils.ex

enokd/elixir

e39b32f235082b8a29fcb22d250c822cca98609f

defmodule Mix.Utils do @moduledoc """ Utilities used throughout Mix and tasks. """ @doc """ Get the mix home. It defaults to `~/.mix` unless the `MIX_HOME` environment variable is set. """ def mix_home do System.get_env("MIX_HOME") || Path.expand("~/.mix") end @doc """ Get all paths defined in the MIX_PATH env variable. `MIX_PATH` may contain multiple paths. If on Windows, those paths should be separated by `;`, if on unix systems, use `:`. """ def mix_paths do if path = System.get_env("MIX_PATH") do String.split(path, path_separator) else [] end end defp path_separator do case :os.type do { :win32, _ } -> ";" { :unix, _ } -> ":" end end @doc """ Take a `command` name and attempts to load a module with the command name converted to a module name in the given `at` scope. Returns `{ :module, module }` in case a module exists and is loaded, `{ :error, reason }` otherwise. ## Examples iex> Mix.Utils.command_to_module("compile", Mix.Tasks) { :module, Mix.Tasks.Compile } """ def command_to_module(command, at \\ Elixir) do module = Module.concat(at, command_to_module_name(command)) Code.ensure_loaded(module) end @doc """ Returns `true` if any of the `sources` are stale compared to the given `targets`. """ def stale?(sources, targets) do Enum.any? stale_stream(sources, targets) end @doc """ Extract all stale `sources` compared to the given `targets`. """ def extract_stale(_sources, []), do: [] def extract_stale(sources, targets) do stale_stream(sources, targets) |> Enum.to_list end defp stale_stream(sources, targets) do modified_target = targets |> Enum.map(&last_modified(&1)) |> Enum.min Stream.filter(sources, fn(source) -> source_mtime(source) > modified_target end) end defp source_mtime({ _, { { _, _, _ }, { _, _, _ } } = source }) do source end defp source_mtime(source) do last_modified(source) end defp last_modified(path) do case File.stat(path) do { :ok, File.Stat[mtime: mtime] } -> mtime { :error, _ } -> { { 1970, 1, 1 }, { 0, 0, 0 } } end end @doc ~S""" Reads the given file as a manifest and returns each entry as a list. A manifest is a tabular file where each line is a row and each entry in a row is separated by "\t". The first entry must always be a path to a compiled artifact. In case there is no manifest file, returns an empty list. """ def read_manifest(file) do case File.read(file) do { :ok, contents } -> String.split(contents, "\n") { :error, _ } -> [] end end @doc """ Writes a manifest file with the given `entries` list. """ def write_manifest(file, entries) do Path.dirname(file) |> File.mkdir_p! File.write!(file, Enum.join(entries, "\n")) end @doc """ Extract files from a list of paths. `exts_or_pattern` may be a list of extensions or a `Path.wildcard/1` pattern. If the path in `paths` is a file, it is included in the return result. If it is a directory, it is searched recursively for files with the given extensions or matching the given patterns. Any file starting with `"."` is ignored. """ def extract_files(paths, exts_or_pattern) def extract_files(paths, exts) when is_list(exts) do extract_files(paths, "*.{#{Enum.join(exts, ",")}}") end def extract_files(paths, pattern) do files = Enum.flat_map(paths, fn path -> if File.regular?(path), do: [path], else: Path.wildcard("#{path}/**/#{pattern}") end) files |> exclude_files |> Enum.uniq end defp exclude_files(files) do filter = fn(x) -> not match?("." <> _, Path.basename(x)) end Enum.filter files, filter end @doc """ Merges two configs recursively, merging keyword lists and concatenating normal lists. """ def config_merge(old, new) do Keyword.merge(old, new, fn(_, x, y) -> if is_list(x) and is_list(y) do if Keyword.keyword?(x) and Keyword.keyword?(y) do config_merge(x, y) else x ++ y end else y end end) end @doc """ Converts the given atom or binary to underscore format. If an atom is given, it is assumed to be an Elixir module, so it is converted to a binary and then processed. ## Examples iex> Mix.Utils.underscore "FooBar" "foo_bar" iex> Mix.Utils.underscore "Foo.Bar" "foo/bar" iex> Mix.Utils.underscore Foo.Bar "foo/bar" In general, `underscore` can be thought of as the reverse of `camelize`, however, in some cases formatting may be lost: Mix.Utils.underscore "SAPExample" #=> "sap_example" Mix.Utils.camelize "sap_example" #=> "SapExample" """ def underscore(atom) when is_atom(atom) do "Elixir." <> rest = atom_to_binary(atom) underscore(rest) end def underscore(""), do: "" def underscore(<<h, t :: binary>>) do <<to_lower_char(h)>> <> do_underscore(t, h) end defp do_underscore(<<h, t, rest :: binary>>, _) when h in ?A..?Z and not t in ?A..?Z do <<?_, to_lower_char(h), t>> <> do_underscore(rest, t) end defp do_underscore(<<h, t :: binary>>, prev) when h in ?A..?Z and not prev in ?A..?Z do <<?_, to_lower_char(h)>> <> do_underscore(t, h) end defp do_underscore(<<?-, t :: binary>>, _) do <<?_>> <> do_underscore(t, ?-) end defp do_underscore(<< "..", t :: binary>>, _) do <<"..">> <> underscore(t) end defp do_underscore(<<?.>>, _), do: <<?.>> defp do_underscore(<<?., t :: binary>>, _) do <<?/>> <> underscore(t) end defp do_underscore(<<h, t :: binary>>, _) do <<to_lower_char(h)>> <> do_underscore(t, h) end defp do_underscore(<<>>, _) do <<>> end @doc """ Converts the given string to CamelCase format. ## Examples iex> Mix.Utils.camelize "foo_bar" "FooBar" """ def camelize(""), do: "" def camelize(<<?_, t :: binary>>) do camelize(t) end def camelize(<<h, t :: binary>>) do <<to_upper_char(h)>> <> do_camelize(t) end defp do_camelize(<<?_, ?_, t :: binary>>) do do_camelize(<< ?_, t :: binary >>) end defp do_camelize(<<?_, h, t :: binary>>) when h in ?a..?z do <<to_upper_char(h)>> <> do_camelize(t) end defp do_camelize(<<?_>>) do <<>> end defp do_camelize(<<?/, t :: binary>>) do <<?.>> <> camelize(t) end defp do_camelize(<<h, t :: binary>>) do <<h>> <> do_camelize(t) end defp do_camelize(<<>>) do <<>> end @doc """ Takes a module and converts it to a command. The nesting argument can be given in order to remove the nesting of a module. ## Examples iex> Mix.Utils.module_name_to_command(Mix.Tasks.Compile, 2) "compile" iex> Mix.Utils.module_name_to_command("Mix.Tasks.Compile.Elixir", 2) "compile.elixir" """ def module_name_to_command(module, nesting \\ 0) def module_name_to_command(module, nesting) when is_atom(module) do module_name_to_command(inspect(module), nesting) end def module_name_to_command(module, nesting) do t = Regex.split(~r/\./, to_string(module)) t |> Enum.drop(nesting) |> Enum.map(&first_to_lower(&1)) |> Enum.join(".") end @doc """ Takes a command and converts it to the module name format. ## Examples iex> Mix.Utils.command_to_module_name("compile.elixir") "Compile.Elixir" """ def command_to_module_name(s) do Regex.split(~r/\./, to_string(s)) |> Enum.map(&first_to_upper(&1)) |> Enum.join(".") end defp first_to_upper(<<s, t :: binary>>), do: <<to_upper_char(s)>> <> t defp first_to_upper(<<>>), do: <<>> defp first_to_lower(<<s, t :: binary>>), do: <<to_lower_char(s)>> <> t defp first_to_lower(<<>>), do: <<>> defp to_upper_char(char) when char in ?a..?z, do: char - 32 defp to_upper_char(char), do: char defp to_lower_char(char) when char in ?A..?Z, do: char + 32 defp to_lower_char(char), do: char @doc """ Symlink directory `source` to `target` or copy it recursively in case symlink fails. Expect source and target to be absolute paths as it generates a relative symlink. """ def symlink_or_copy(source, target) do if File.exists?(source) do source_list = String.to_char_list!(source) case :file.read_link(target) do { :ok, ^source_list } -> :ok { :ok, _ } -> File.rm!(target) do_symlink_or_copy(source, target) { :error, :enoent } -> do_symlink_or_copy(source, target) { :error, _ } -> File.rm_rf!(target) do_symlink_or_copy(source, target) end else { :error, :enoent } end end defp do_symlink_or_copy(source, target) do symlink_source = make_relative_path(source, target) case :file.make_symlink(symlink_source, target) do :ok -> :ok { :error, _ } -> File.cp_r!(source, target) end end # Make a relative path in between two paths. # Expects both paths to be fully expanded. defp make_relative_path(source, target) do do_make_relative_path(Path.split(source), Path.split(target)) end defp do_make_relative_path([h|t1], [h|t2]) do do_make_relative_path(t1, t2) end defp do_make_relative_path(source, target) do base = List.duplicate("..", max(length(target) - 1, 0)) Path.join(base ++ source) end @doc """ Opens and reads content from either a URL or a local filesystem path. Used by tasks like `local.install` and `local.rebar` that support installation either from a URL or a local file. Raises if the given path is not a url, nor a file or if the file or url are invalid. """ def read_path!(path) do cond do url?(path) -> read_url(path) file?(path) -> read_file(path) :else -> raise Mix.Error, message: "Expected #{path} to be a url or a local file path" end end defp read_file(path) do File.read!(path) end defp read_url(path) do :ssl.start :inets.start headers = [ { 'user-agent', 'Mix/#{System.version}' } ] request = { :binary.bin_to_list(path), headers } case :httpc.request(:get, request, [], body_format: :binary) do { :ok, { { _, status, _ }, _, body } } when status in 200..299 -> body { :ok, { { _, status, _ }, _, _ } } -> raise Mix.Error, message: "Could not access url #{path}, got status: #{status}" { :error, reason } -> raise Mix.Error, message: "Could not access url #{path}, error: #{inspect reason}" end end defp file?(path) do File.regular?(path) end defp url?(path) do URI.parse(path).scheme in ["http", "https"] end end

f7e511ab31571f23d9076bbc438d7b5e7b85e4e2

ex

Elixir

lib/intcode.ex

eldemonstro/AdventOfCode2019Elixir

a047a5085a906b7d78ce4f3c8a26904415616f2c

lib/intcode.ex

eldemonstro/AdventOfCode2019Elixir

a047a5085a906b7d78ce4f3c8a26904415616f2c

lib/intcode.ex

eldemonstro/AdventOfCode2019Elixir

a047a5085a906b7d78ce4f3c8a26904415616f2c

defmodule IntCode do @moduledoc """ Executes the intcode """ def sum(x, y) do {x + y, 4} end def mul(x, y) do {x * y, 4} end def less_than(x, y) do {(if x < y, do: 1, else: 0), 4} end def equals(x, y) do {(if x == y, do: 1, else: 0), 4} end def parse_program(program) do program |>String.split(~r/[,\n]/) |>Enum.reject(& &1 == "") |>Enum.map(& String.to_integer(&1)) |>Enum.with_index(0) |>Enum.map(fn {k, v} -> {v, k} end) |>Map.new() end def execute(program, opcode, needle, inputs \\ []) def execute(program, opcode, needle, inputs) when rem(opcode, 100) == 99 do {program, :halt, needle, inputs} end def execute(program, opcode, needle, inputs) when rem(opcode, 100) == 6 do reversed_opcode = opcode |> Integer.digits() |> Enum.reverse() mode_b = Enum.at(reversed_opcode, 3) || 0 mode_c = Enum.at(reversed_opcode, 2) || 0 index_x = program[needle + 1] index_y = program[needle + 2] value_x = program[(if mode_c == 1, do: needle + 1, else: index_x)] value_y = program[(if mode_b == 1, do: needle + 2, else: index_y)] needle_jump = (if value_x == 0, do: value_y, else: needle + 3) execute(program, program[needle_jump], needle_jump, inputs) end def execute(program, opcode, needle, inputs) when rem(opcode, 100) == 5 do reversed_opcode = opcode |> Integer.digits() |> Enum.reverse() mode_b = Enum.at(reversed_opcode, 3) || 0 mode_c = Enum.at(reversed_opcode, 2) || 0 index_x = program[needle + 1] index_y = program[needle + 2] value_x = program[(if mode_c == 1, do: needle + 1, else: index_x)] value_y = program[(if mode_b == 1, do: needle + 2, else: index_y)] needle_jump = (if value_x != 0, do: value_y, else: needle + 3) execute(program, program[needle_jump], needle_jump, inputs) end def execute(program, opcode, needle, inputs) when rem(opcode, 100) == 4 do reversed_opcode = opcode |> Integer.digits() |> Enum.reverse() mode_c = Enum.at(reversed_opcode, 2) || 0 index_x = program[needle + 1] value_x = program[(if mode_c == 1, do: needle + 1, else: index_x)] IO.puts value_x execute(program, program[needle + 2], needle + 2, inputs) end def execute(program, opcode, needle, inputs) when rem(opcode, 100) == 3 do [input | new_inputs] = inputs index_x = program[needle + 1] execute(Map.put(program, index_x, input), program[needle + 2], needle + 2, new_inputs) end def execute(program, opcode, needle, inputs) do reversed_opcode = opcode |> Integer.digits() |> Enum.reverse() {mode_a, mode_b, mode_c} = {Enum.at(reversed_opcode, 4, 0), Enum.at(reversed_opcode, 3, 0), Enum.at(reversed_opcode, 2, 0)} index_z = program[needle + 3] value_x = program[(if mode_c == 1, do: needle + 1, else: program[needle + 1])] value_y = program[(if mode_b == 1, do: needle + 2, else: program[needle + 1])] {result, needle_jump} = case rem(opcode, 100) do 1 -> sum(value_x, value_y) 2 -> mul(value_x, value_y) 7 -> less_than(value_x, value_y) 8 -> equals(value_x, value_y) end new_program = Map.put(program, index_z, result) execute(new_program, new_program[needle + needle_jump], needle + needle_jump, inputs) end end

f7e511fdbe76d4277fb9bb4f412f390a2c879275

ex

Elixir

lib/bot_ex/helpers/user_actions.ex

bot-ex/bot_ex

7f28464723187ef415b5e6926e4c48e2ace50fad

2020-04-10T11:25:47.000Z

2021-11-08T08:03:22.000Z

lib/bot_ex/helpers/user_actions.ex

bot-ex/botex

7f28464723187ef415b5e6926e4c48e2ace50fad

2020-07-21T08:01:50.000Z

2020-07-22T17:53:00.000Z

lib/bot_ex/helpers/user_actions.ex

bot-ex/botex

7f28464723187ef415b5e6926e4c48e2ace50fad

2020-04-11T11:12:03.000Z

2020-07-21T07:37:55.000Z

defmodule BotEx.Helpers.UserActions do @moduledoc """ User actions interacting functions """ alias BotEx.Models.Message @doc """ Find the last user action ## Parameters: - u_id: user id """ @spec get_last_call(integer | binary) :: Message.t() def get_last_call(u_id) when is_binary(u_id), do: String.to_integer(u_id) |> get_last_call() def get_last_call(u_id) when is_integer(u_id) do case :ets.lookup(:last_call, u_id) do [] -> %Message{} [{_, msg}] -> msg end end @doc """ Update last user message ## Parameters: - user_id: user id - call: `BotEx.Models.Message` for saving """ @spec update_last_call(user_id :: integer() | binary(), call :: Message.t()) :: :true def update_last_call(user_id, call) when is_binary(user_id), do: String.to_integer(user_id) |> update_last_call(call) def update_last_call(user_id, %Message{} = call), do: :ets.insert(:last_call, {user_id, call}) end

f7e52568f5a4ff41add48baf084f99c6cb7d61cd

exs

Elixir

mix.exs

topfreegames/vernemq_redis_auth_plugin

2e447fb17827820fec271081e0e748571c2ce378

2017-07-25T13:59:13.000Z

2017-11-26T04:34:42.000Z

mix.exs

topfreegames/vernemq_redis_auth_plugin

2e447fb17827820fec271081e0e748571c2ce378

mix.exs

topfreegames/vernemq_redis_auth_plugin

2e447fb17827820fec271081e0e748571c2ce378

defmodule RedisAuthPlugin.Mixfile do use Mix.Project def project do [app: :redis_auth_plugin, version: "0.1.1", elixir: "~> 1.4", build_embedded: Mix.env == :prod, start_permanent: Mix.env == :prod, deps: deps()] end defp vmq_plugin_hooks do hooks = [ {RedisAuthPlugin, :auth_on_register, 5, []}, {RedisAuthPlugin, :auth_on_subscribe, 3, []}, {RedisAuthPlugin, :auth_on_publish, 6, []}, ] {:vmq_plugin_hooks, hooks} end def application do [ mod: {RedisAuthPlugin, []}, extra_applications: [:logger, :redix, :pbkdf2], env: [vmq_plugin_hooks()] ] end defp deps do [ {:pbkdf2, "~> 2.0"}, {:redix, ">= 0.0.0"}, {:distillery, "~> 1.4", runtime: false}, ] end end

f7e543ac9bf9a2c72ec4f659e08e0471146dbe86

exs

Elixir

config/config.exs

lukeledet/ex_selfie

c097b039f29e77f69e89cb564662bf280b2e772f

2020-01-26T06:02:33.000Z

2020-01-26T06:02:33.000Z

config/config.exs

lukeledet/ex_selfie

c097b039f29e77f69e89cb564662bf280b2e772f

2018-03-02T21:18:12.000Z

2018-03-02T21:18:12.000Z

config/config.exs

lukeledet/ex_selfie

c097b039f29e77f69e89cb564662bf280b2e772f

2018-03-02T17:52:18.000Z

2018-03-02T17:52:18.000Z

# This file is responsible for configuring your application # and its dependencies with the aid of the Mix.Config module. use Mix.Config # This configuration is loaded before any dependency and is restricted # to this project. If another project depends on this project, this # file won't be loaded nor affect the parent project. For this reason, # if you want to provide default values for your application for # 3rd-party users, it should be done in your "mix.exs" file. # You can configure your application as: # # config :selfie, key: :value # # and access this configuration in your application as: # # Application.get_env(:selfie, :key) # # You can also configure a 3rd-party app: # # config :logger, level: :info # # It is also possible to import configuration files, relative to this # directory. For example, you can emulate configuration per environment # by uncommenting the line below and defining dev.exs, test.exs and such. # Configuration from the imported file will override the ones defined # here (which is why it is important to import them last). # # import_config "#{Mix.env}.exs"

f7e546a114e7ba8e8e3458b257fe745979ec9c2e

ex

Elixir

test/support/shop.ex

stevegrossi/ex_venture

e02d5a63fdb882d92cfb4af3e15f7b48ad7054aa

2019-02-10T10:22:39.000Z

2019-02-10T10:22:39.000Z

test/support/shop.ex

stevegrossi/ex_venture

e02d5a63fdb882d92cfb4af3e15f7b48ad7054aa

test/support/shop.ex

stevegrossi/ex_venture

e02d5a63fdb882d92cfb4af3e15f7b48ad7054aa

defmodule Test.Game.Shop do alias Data.Item alias Data.Shop def start_link() do Agent.start_link(fn () -> %{shop: _shop()} end, name: __MODULE__) end def _shop() do %Shop{ name: "Tree Stand Shop", } end def set_shop(shop) do start_link() Agent.update(__MODULE__, fn (state) -> Map.put(state, :shop, shop) end) end def list(_id) do start_link() Agent.get(__MODULE__, fn (state) -> Map.get(state, :shop) end) end def set_buy(buy_response) do start_link() Agent.update(__MODULE__, fn (state) -> Map.put(state, :buy_response, buy_response) end) end def buy(id, item_id, save) do start_link() Agent.get_and_update(__MODULE__, fn (state) -> buys = Map.get(state, :buy, []) state = Map.put(state, :buy, buys ++ [{id, item_id, save}]) response = Map.get(state, :buy_response, {:ok, %{save | currency: save.currency - 1}, %Item{}}) {response, state} end) end def get_buys() do start_link() Agent.get(__MODULE__, fn (state) -> Map.get(state, :buy, []) end) end def clear_buys() do start_link() Agent.update(__MODULE__, fn (state) -> Map.put(state, :buy, []) end) end def set_sell(sell_response) do start_link() Agent.update(__MODULE__, fn (state) -> Map.put(state, :sell_response, sell_response) end) end def sell(id, item_id, save) do start_link() Agent.get_and_update(__MODULE__, fn (state) -> sells = Map.get(state, :sell, []) state = Map.put(state, :sell, sells ++ [{id, item_id, save}]) response = Map.get(state, :sell_response, {:ok, %{save | currency: save.currency - 1}, %Item{}}) {response, state} end) end def get_sells() do start_link() Agent.get(__MODULE__, fn (state) -> Map.get(state, :sell, []) end) end def clear_sells() do start_link() Agent.update(__MODULE__, fn (state) -> Map.put(state, :sell, []) end) end end

f7e55f3bd0442889fbbebe447f69905cb7e6278e

ex

Elixir

lib/prima_auth0_ex/telemetry.ex

primait/auth0_ex

15ef5d6d91d8fe00ff703a4f58e1cb32bb169a82

2021-12-01T10:50:40.000Z

2022-02-15T13:07:02.000Z

lib/prima_auth0_ex/telemetry.ex

primait/auth0_ex

15ef5d6d91d8fe00ff703a4f58e1cb32bb169a82

2021-12-22T09:19:28.000Z

2022-03-24T06:15:04.000Z

lib/prima_auth0_ex/telemetry.ex

primait/auth0_ex

15ef5d6d91d8fe00ff703a4f58e1cb32bb169a82

defmodule PrimaAuth0Ex.Telemetry do @moduledoc """ A pre-defined module which sets up telemetry with a given reporter """ alias PrimaAuth0Ex.Telemetry.Handler @auth0_handler_id "auth0-handler" def setup do reporter = telemetry_reporter() if reporter != nil do :ok = :telemetry.attach_many( @auth0_handler_id, [ [:prima_auth0_ex, :retrieve_token, :failure], [:prima_auth0_ex, :retrieve_token, :success] ], &Handler.handle_event/4, %{reporter: reporter} ) end end defp telemetry_reporter, do: Application.get_env(:prima_auth0_ex, :telemetry_reporter) end defmodule PrimaAuth0Ex.Telemetry.Handler do @moduledoc """ A pre-defined telemetry handler """ def handle_event([:prima_auth0_ex, :retrieve_token, :failure], %{count: count}, %{audience: audience}, %{ reporter: reporter }) do reporter.increment("retrieve_token:failure", count, tags: ["audience:#{audience}"]) end def handle_event([:prima_auth0_ex, :retrieve_token, :success], %{count: count}, %{audience: audience}, %{ reporter: reporter }) do reporter.increment("retrieve_token:success", count, tags: ["audience:#{audience}"]) end end

f7e564ca71193238797a0b16e57eae0b3376641c

exs

Elixir

test/radiator_web/graphql/public/schema/query/episodes_test.exs

djschilling/radiator

382e22904d7e400a8ffba54e9ddfd2845bc2b623

test/radiator_web/graphql/public/schema/query/episodes_test.exs

djschilling/radiator

382e22904d7e400a8ffba54e9ddfd2845bc2b623

test/radiator_web/graphql/public/schema/query/episodes_test.exs

djschilling/radiator

382e22904d7e400a8ffba54e9ddfd2845bc2b623

defmodule RadiatorWeb.GraphQL.Public.Schema.Query.EpisodesTest do use RadiatorWeb.ConnCase, async: true import Radiator.Factory alias Radiator.Directory.Episode alias Radiator.Media @single_query """ query ($id: ID!) { publishedEpisode(id: $id) { id title enclosure { length type url } audio { chapters { image link start title } } } } """ test "episode returns an episode", %{conn: conn} do podcast = build(:podcast) upload = %Plug.Upload{ path: "test/fixtures/image.jpg", filename: "image.jpg" } audio = insert(:audio) {:ok, chapter} = Radiator.AudioMeta.create_chapter(audio, %{ image: upload, link: "http://example.com", title: "An Example", start: 12345 }) image_url = Media.ChapterImage.url({chapter.image, chapter}) episode = insert(:published_episode, podcast: podcast, audio: audio ) enclosure = Episode.enclosure(episode) conn = get conn, "/api/graphql", query: @single_query, variables: %{"id" => episode.id} assert image_url =~ "http" assert json_response(conn, 200) == %{ "data" => %{ "publishedEpisode" => %{ "id" => Integer.to_string(episode.id), "title" => episode.title, "enclosure" => %{ "length" => enclosure.length, "type" => enclosure.type, "url" => enclosure.url }, "audio" => %{ "chapters" => [ %{ "image" => image_url, "link" => "http://example.com", "title" => "An Example", "start" => 12345 } ] } } } } end test "episode returns an error when queried with a non-existent ID", %{conn: conn} do conn = get conn, "/api/graphql", query: @single_query, variables: %{"id" => -1} assert %{"errors" => [%{"message" => message}]} = json_response(conn, 200) assert message == "Episode ID -1 not found" end test "episode returns an error if not published", %{conn: conn} do episode = insert(:unpublished_episode) conn = get conn, "/api/graphql", query: @single_query, variables: %{"id" => episode.id} assert %{"errors" => [%{"message" => message}]} = json_response(conn, 200) assert message == "Episode ID #{episode.id} not found" end @episodes_in_podcast_query """ query ($podcast_id: ID!) { publishedPodcast(id: $podcast_id) { episodes { title } } } """ test "episodes in podcast are ordered, latest first", %{conn: conn} do podcast = insert(:podcast) timestamp = 1_500_000_000 _ep1 = insert(:published_episode, title: "E001", published_at: DateTime.from_unix!(timestamp), podcast: podcast ) _ep3 = insert(:published_episode, title: "E003", published_at: DateTime.from_unix!(timestamp + 20), podcast: podcast ) _ep2 = insert(:published_episode, title: "E002", published_at: DateTime.from_unix!(timestamp + 10), podcast: podcast ) conn = get conn, "/api/graphql", query: @episodes_in_podcast_query, variables: %{"podcast_id" => podcast.id} assert %{ "data" => %{ "publishedPodcast" => %{ "episodes" => [ %{"title" => "E003"}, %{"title" => "E002"}, %{"title" => "E001"} ] } } } = json_response(conn, 200) end end

f7e5715f81f559a88eab4f3fbd0ec43a14d561a0

ex

Elixir

clients/dfa_reporting/lib/google_api/dfa_reporting/v34/model/city.ex

medikent/elixir-google-api

98a83d4f7bfaeac15b67b04548711bb7e49f9490

clients/dfa_reporting/lib/google_api/dfa_reporting/v34/model/city.ex

medikent/elixir-google-api

98a83d4f7bfaeac15b67b04548711bb7e49f9490

clients/dfa_reporting/lib/google_api/dfa_reporting/v34/model/city.ex

medikent/elixir-google-api

98a83d4f7bfaeac15b67b04548711bb7e49f9490

# Copyright 2019 Google LLC # # 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. # NOTE: This file is auto generated by the elixir code generator program. # Do not edit this file manually. defmodule GoogleApi.DFAReporting.V34.Model.City do @moduledoc """ Contains information about a city that can be targeted by ads. ## Attributes * `countryCode` (*type:* `String.t`, *default:* `nil`) - Country code of the country to which this city belongs. * `countryDartId` (*type:* `String.t`, *default:* `nil`) - DART ID of the country to which this city belongs. * `dartId` (*type:* `String.t`, *default:* `nil`) - DART ID of this city. This is the ID used for targeting and generating reports. * `kind` (*type:* `String.t`, *default:* `dfareporting#city`) - Identifies what kind of resource this is. Value: the fixed string "dfareporting#city". * `metroCode` (*type:* `String.t`, *default:* `nil`) - Metro region code of the metro region (DMA) to which this city belongs. * `metroDmaId` (*type:* `String.t`, *default:* `nil`) - ID of the metro region (DMA) to which this city belongs. * `name` (*type:* `String.t`, *default:* `nil`) - Name of this city. * `regionCode` (*type:* `String.t`, *default:* `nil`) - Region code of the region to which this city belongs. * `regionDartId` (*type:* `String.t`, *default:* `nil`) - DART ID of the region to which this city belongs. """ use GoogleApi.Gax.ModelBase @type t :: %__MODULE__{ :countryCode => String.t(), :countryDartId => String.t(), :dartId => String.t(), :kind => String.t(), :metroCode => String.t(), :metroDmaId => String.t(), :name => String.t(), :regionCode => String.t(), :regionDartId => String.t() } field(:countryCode) field(:countryDartId) field(:dartId) field(:kind) field(:metroCode) field(:metroDmaId) field(:name) field(:regionCode) field(:regionDartId) end defimpl Poison.Decoder, for: GoogleApi.DFAReporting.V34.Model.City do def decode(value, options) do GoogleApi.DFAReporting.V34.Model.City.decode(value, options) end end defimpl Poison.Encoder, for: GoogleApi.DFAReporting.V34.Model.City do def encode(value, options) do GoogleApi.Gax.ModelBase.encode(value, options) end end

f7e572f2f964da8b3af01848322ce2290f1886f9

ex

Elixir

test/support/data_case.ex

sb8244/ecto_tenancy_enforcer

7dac523d0560ec4a57bcf3800b788d312d70d6e6

2019-12-30T23:02:59.000Z

2022-03-26T14:38:41.000Z

test/support/data_case.ex

sb8244/ecto_tenancy_enforcer

7dac523d0560ec4a57bcf3800b788d312d70d6e6

2021-01-13T05:01:04.000Z

2021-01-13T05:01:04.000Z

test/support/data_case.ex

sb8244/ecto_tenancy_enforcer

7dac523d0560ec4a57bcf3800b788d312d70d6e6

2021-04-25T16:50:16.000Z

2021-04-25T16:50:16.000Z

defmodule Tenancy.DataCase do @moduledoc """ This module defines the setup for tests requiring access to the application's data layer. You may define functions here to be used as helpers in your tests. Finally, if the test case interacts with the database, it cannot be async. For this reason, every test runs inside a transaction which is reset at the beginning of the test unless the test case is marked as async. """ use ExUnit.CaseTemplate using do quote do alias Tenancy.Repo import Ecto import Ecto.Changeset import Ecto.Query import Tenancy.DataCase end end setup tags do :ok = Ecto.Adapters.SQL.Sandbox.checkout(Tenancy.Repo) unless tags[:async] do Ecto.Adapters.SQL.Sandbox.mode(Tenancy.Repo, {:shared, self()}) end :ok end @doc """ A helper that transforms changeset errors into a map of messages. assert {:error, changeset} = Accounts.create_user(%{password: "short"}) assert "password is too short" in errors_on(changeset).password assert %{password: ["password is too short"]} = errors_on(changeset) """ def errors_on(changeset) do Ecto.Changeset.traverse_errors(changeset, fn {message, opts} -> Regex.replace(~r"%{(\w+)}", message, fn _, key -> opts |> Keyword.get(String.to_existing_atom(key), key) |> to_string() end) end) end end

f7e57c4cc786c01b9606fd3144c661d0feb6c9ca

exs

Elixir

harbor/test/ports/rumble/message/landing_test.exs

miapolis/port7

7df1223f83d055eeb6ce8f61f4af8b4f2cf33e74

harbor/test/ports/rumble/message/landing_test.exs

miapolis/port7

7df1223f83d055eeb6ce8f61f4af8b4f2cf33e74

harbor/test/ports/rumble/message/landing_test.exs

miapolis/port7

7df1223f83d055eeb6ce8f61f4af8b4f2cf33e74

defmodule PortsTests.Rumble.Message.Landing.LandingTest do use ExUnit.Case, async: true alias PierTest.WsClient alias PierTest.WsClientFactory alias PierTest.Helpers.Room alias HarborTest.Support.Factory require WsClient setup do user_id = Factory.user_token() client_ws = WsClientFactory.create_client_for(user_id) {:ok, user_id: user_id, client_ws: client_ws} end describe "validate landing" do test "single peer", t do Room.create_and_join(t.client_ws, :rumble) WsClient.assert_frame( "landing", %{ "milestone" => %{"state" => "lobby", "serverNow" => _some_val}, "peers" => [%{"id" => 0, "nickname" => "TEST USER", "isJoined" => false}] } ) end test "second peer", t do {room_id, _} = Room.create_and_join(t.client_ws, :rumble) second_ws = WsClientFactory.create_client_for(Factory.user_token()) Room.join_existing(second_ws, room_id) WsClient.assert_frame( "landing", %{ "milestone" => %{"state" => "lobby", "serverNow" => _some_val}, "peers" => [ %{"id" => 0, "nickname" => "TEST USER", "isJoined" => false}, %{"id" => 1, "nickname" => "TEST USER", "isJoined" => false} ] }, second_ws ) end test "first peer leaves and receives same landing", t do {room_id, _} = Room.create_and_join(t.client_ws, :rumble) second_ws = WsClientFactory.create_client_for(Factory.user_token()) Room.join_existing(second_ws, room_id) Process.exit(t.client_ws, :kill) restarted_ws = WsClientFactory.create_client_for(t.user_id) Room.join_existing(restarted_ws, room_id) WsClient.assert_frame( "landing", %{ "milestone" => %{"state" => "lobby", "serverNow" => _some_val}, "peers" => [ %{"id" => 0, "nickname" => "TEST USER", "isJoined" => false}, %{"id" => 1, "nickname" => "TEST USER", "isJoined" => false} ] }, restarted_ws ) end end end

f7e5ad2eafecda30cd5ec801ccf8953faedaa35f

ex

Elixir

web/controllers/page_controller.ex

zampino/livex

74bcc6557ca8e5185b7e4dac85323b1c5174e52d

2016-03-31T21:23:21.000Z

2020-09-15T01:36:17.000Z

web/controllers/page_controller.ex

zampino/livex

74bcc6557ca8e5185b7e4dac85323b1c5174e52d

web/controllers/page_controller.ex

zampino/livex

74bcc6557ca8e5185b7e4dac85323b1c5174e52d

defmodule Livex.PageController do use Livex.Web, :controller alias Livex.Page def index(conn, _params) do render(conn, "index.html", pages: []) end end

f7e5e459a1f69630933cc407b91d36517125f9ef

ex

Elixir

test/support/gen/plug/test_post.ex

feng19/oasis

36e81db1413f24f153f960b1ee3706858ec1f952

2021-02-24T09:21:11.000Z

2021-12-26T03:51:25.000Z

test/support/gen/plug/test_post.ex

feng19/oasis

36e81db1413f24f153f960b1ee3706858ec1f952

2021-03-18T14:15:37.000Z

2022-03-02T09:53:42.000Z

test/support/gen/plug/test_post.ex

feng19/oasis

36e81db1413f24f153f960b1ee3706858ec1f952

2021-02-24T09:21:01.000Z

2021-11-16T08:45:03.000Z

defmodule Oasis.Gen.Plug.TestPost do use Oasis.Controller alias Oasis.BadRequestError def init(opts), do: opts def call(conn, _opts) do json( conn, %{ "body_params" => conn.body_params, "params" => conn.params } ) end def handle_errors(conn, %{kind: _kind, reason: %BadRequestError{error: %BadRequestError.JsonSchemaValidationFailed{} = json_schema} = reason, stack: _stack}) do message = "Find #{reason.use_in} parameter `#{reason.param_name}` with error: #{to_string(json_schema.error)}" send_resp(conn, conn.status, message) end def handle_errors(conn, %{kind: _kind, reason: reason, stack: _stack}) do message = Map.get(reason, :message) || "Something went wrong" send_resp(conn, conn.status, message) end end

f7e5e957010c78464bd4bda6553e10750bdd9da4

exs

Elixir

test/type_check/type_error/formatter_test.exs

ktec/elixir-type_check

42bde40b4a67e999653c5336294dc651c98a747a

test/type_check/type_error/formatter_test.exs

ktec/elixir-type_check

42bde40b4a67e999653c5336294dc651c98a747a

test/type_check/type_error/formatter_test.exs

ktec/elixir-type_check

42bde40b4a67e999653c5336294dc651c98a747a

defmodule TypeCheck.TypeError.FormatterTest do use ExUnit.Case use ExUnitProperties import StreamData, only: [] import TypeCheck.Type.StreamData property "the default formatter is able to handle all problem tuples (returning a binary string message)" do check all problem <- StreamData.scale( to_gen(TypeCheck.TypeError.Formatter.problem_tuple()), &div(&1, 3) ) do result = TypeCheck.TypeError.DefaultFormatter.format_wrap(problem) assert is_binary(result) end end end

f7e5ec8e68726782350e5e203640f5d7e15e19a1

ex

Elixir

lib/validation/rules/credit_card/jcb.ex

adolfont/validation

6288f5a5745f645c90b6f6241e14f0088c218f5b

lib/validation/rules/credit_card/jcb.ex

adolfont/validation

6288f5a5745f645c90b6f6241e14f0088c218f5b

lib/validation/rules/credit_card/jcb.ex

adolfont/validation

6288f5a5745f645c90b6f6241e14f0088c218f5b