defmodule RList.ActiveSupport do
@moduledoc """
Summarized all of List functions in Rails.ActiveSupport.
If a function with the same name already exists in Elixir, that is not implemented.
Defines all of here functions when `use RList.ActiveSupport`.
"""
@spec __using__(any) :: list
defmacro __using__(_opts) do
RUtils.define_all_functions!(__MODULE__)
end
alias RList.Support
# https://www.rubydoc.info/gems/activesupport/Array
# [:as_json, :compact_blank!, :deep_dup, :excluding, :extract!, :extract_options!, :fifth, :forty_two, :fourth, :from, :in_groups, :in_groups_of, :including, :inquiry, :second, :second_to_last, :split, :sum, :third, :third_to_last, :to, :to_default_s, :to_formatted_s, :to_param, :to_query, :to_s, :to_sentence, :to_xml]
# |> RUtils.required_functions([List, RList.Ruby, REnum])
# × as_json
# × deep_dup
# ✔ fifth
# ✔ forty_two
# ✔ fourth
# ✔ from
# ✔ in_groups
# ✔ in_groups_of
# inquiry
# ✔ second
# ✔ second_to_last
# ✔ third
# ✔ third_to_last
# ✔ to
# ✔ to_default_s
# × to_formatted_s
# to_param
# to_query
# ✔ to_sentence
# to_xml
@doc """
Returns the tail of the list from position.
## Examples
iex> ~w[a b c d]
iex> |> RList.from(0)
["a", "b", "c", "d"]
iex> ~w[a b c d]
iex> |> RList.from(2)
["c", "d"]
iex> ~w[a b c d]
iex> |> RList.from(10)
[]
iex> ~w[]
iex> |> RList.from(0)
[]
iex> ~w[a b c d]
iex> |> RList.from(-2)
["c", "d"]
iex> ~w[a b c d]
iex> |> RList.from(-10)
[]
"""
@spec from(list(), integer()) :: list()
def from(list, position) do
list
|> Enum.slice(position..Enum.count(list))
end
@doc """
Returns the beginning of the list up to position.
## Examples
iex> ~w[a b c d]
iex> |> RList.to(0)
["a"]
iex> ~w[a b c d]
iex> |> RList.to(2)
["a", "b", "c"]
iex> ~w[a b c d]
iex> |> RList.to(10)
["a", "b", "c", "d"]
iex> ~w[]
iex> |> RList.to(0)
[]
iex> ~w[a b c d]
iex> |> RList.to(-2)
["a", "b", "c"]
iex> ~w[a b c d]
iex> |> RList.to(-10)
[]
"""
@spec to(list(), integer()) :: list()
def to(list, position) do
list
|> Enum.slice(0..position)
end
@doc """
Equal to `Enum.at(list, 1)`.
## Examples
iex> ~w[a b c d]
iex> |> RList.second()
"b"
"""
@spec second(list()) :: any()
def second(list) do
Enum.at(list, 1)
end
@doc """
Equal to `Enum.at(list, 2)`.
## Examples
iex> ~w[a b c d]
iex> |> RList.third()
"c"
"""
@spec third(list()) :: any()
def third(list) do
Enum.at(list, 2)
end
@doc """
Equal to `Enum.at(list, 3)`.
## Examples
iex> ~w[a b c d]
iex> |> RList.fourth()
"d"
"""
@spec fourth(list()) :: any()
def fourth(list) do
Enum.at(list, 3)
end
@doc """
Equal to `Enum.at(list, 4)`.
## Examples
iex> ~w[a b c d e]
iex> |> RList.fifth()
"e"
"""
@spec fifth(list()) :: any()
def fifth(list) do
Enum.at(list, 4)
end
@doc """
Equal to `Enum.at(list, 41)`. Also known as accessing "the reddit".
## Examples
iex> 1..42
iex> |> RList.forty_two()
42
"""
@spec forty_two(list()) :: any()
def forty_two(list) do
Enum.at(list, 41)
end
@doc """
Equal to `Enum.at(list, -2)`.
## Examples
iex> ~w[a b c d e]
iex> |> RList.second_to_last()
"d"
"""
@spec second_to_last(list()) :: any()
def second_to_last(list) do
Enum.at(list, -2)
end
@doc """
Equal to `Enum.at(list, -3)`.
## Examples
iex> ~w[a b c d e]
iex> |> RList.third_to_last()
"c"
"""
@spec third_to_last(list()) :: any()
def third_to_last(list) do
Enum.at(list, -3)
end
@doc """
Converts the list to a comma-separated sentence where the last element is joined by the connector word.
You can pass the following options to change the default behavior. If you pass an option key that doesn't exist in the list below, it will raise an
** Options **
* `:words_connector` - The sign or word used to join all but the last
element in lists with three or more elements (default: ", ").
* `:last_word_connector` - The sign or word used to join the last element
in lists with three or more elements (default: ", and ").
* `:two_words_connector` - The sign or word used to join the elements
in lists with two elements (default: " and ").
## Examples
iex> ["one", "two"]
iex> |> RList.to_sentence()
"one and two"
iex> ["one", "two", "three"]
iex> |> RList.to_sentence()
"one, two, and three"
iex> ["one", "two"]
iex> |> RList.to_sentence(two_words_connector: "-")
"one-two"
iex> ["one", "two", "three"]
iex> |> RList.to_sentence(words_connector: " or ", last_word_connector: " or at least ")
"one or two or at least three"
iex> ["one", "two", "three"]
iex> |> RList.to_sentence()
"one, two, and three"
"""
@spec to_sentence(list(), list(keyword()) | nil) :: String.t()
def to_sentence(list, opts \\ []) do
words_connector = Keyword.get(opts, :words_connector) || ", "
two_words_connector = Keyword.get(opts, :two_words_connector) || " and "
last_word_connector = Keyword.get(opts, :last_word_connector) || ", and "
case Enum.count(list) do
0 -> ""
1 -> "#{Enum.at(list, 0)}"
2 -> "#{Enum.at(list, 0)}#{two_words_connector}#{Enum.at(list, 1)}"
_ -> "#{to(list, -2) |> Enum.join(words_connector)}#{last_word_connector}#{List.last(list)}"
end
end
@doc """
Splits or iterates over the list in number of groups, padding any remaining slots with fill_with unless it is false.
## Examples
iex> ~w[1 2 3 4 5 6 7 8 9 10]
iex> |> RList.in_groups(3)
[
["1", "2", "3", "4"],
["5", "6", "7", nil],
["8", "9", "10", nil]
]
iex> ~w[1 2 3 4 5 6 7 8 9 10]
iex> |> RList.in_groups(3, " ")
[
["1", "2", "3", "4"],
["5", "6", "7", " "],
["8", "9", "10", " "]
]
iex> ~w[1 2 3 4 5 6 7]
iex> |> RList.in_groups(3, false)
[
["1", "2", "3"],
["4", "5"],
["6", "7"]
]
"""
@spec in_groups(list(), non_neg_integer(), any() | nil) :: list()
def in_groups(list, number, fill_with \\ nil) do
division = div(Enum.count(list), number)
modulo = rem(Enum.count(list), number)
range = 0..(number - 1)
length_list =
range
|> Enum.map(&(division + if(modulo > 0 && modulo > &1, do: 1, else: 0)))
|> IO.inspect()
range
|> Enum.reduce([], fn index, acc ->
length = length_list |> Enum.at(index)
group =
Enum.slice(
list,
length_list
|> Enum.take(index)
|> Enum.sum(),
length
)
if fill_with != false && modulo > 0 && length == division do
acc ++ [group ++ [fill_with]]
else
acc ++ [group]
end
end)
end
@doc """
Splits or iterates over the list in groups of size number, padding any remaining slots with fill_with unless it is +false+.
## Examples
iex> ~w[1 2 3 4 5 6 7 8 9 10]
iex> |> RList.in_groups_of(3)
[
["1", "2", "3"],
["4", "5", "6"],
["7", "8", "9"],
["10", nil, nil]
]
iex> ~w[1 2 3 4 5]
iex> |> RList.in_groups_of(2, " ")
[
["1", "2"],
["3", "4"],
["5", " "]
]
iex> ~w[1 2 3 4 5]
iex> |> RList.in_groups_of(2, false)
[
["1", "2"],
["3", "4"],
["5"]
]
"""
@spec in_groups_of(list(), non_neg_integer(), any() | nil) :: list()
def in_groups_of(list, number, fill_with \\ nil) do
if(fill_with == false) do
list
else
padding = rem(number - rem(Enum.count(list), number), number)
list ++ Support.new(fill_with, padding)
end
|> REnum.each_slice(number)
|> Enum.to_list()
end
defdelegate to_default_s(list), to: Kernel, as: :inspect
end
