elixir-git / xgit / 305

Committed 29 Aug 2019 - 3:56 coverage remained the same at 100.0%

Build # 305

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

Prepare 0.2.0 release. (#138)

Run Details

604 of 604 relevant lines covered (100.0%)

325.16 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

100.0

/lib/xgit/core/object.ex

# Copyright (C) 2008-2010, Google Inc.
# Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org>
# and other copyright owners as documented in the project's IP log.
#
# Elixir adaptation from jgit file:
# org.eclipse.jgit/src/org/eclipse/jgit/lib/ObjectChecker.java
#
# Copyright (C) 2019, Eric Scouten <eric+xgit@scouten.com>
#
# This program and the accompanying materials are made available
# under the terms of the Eclipse Distribution License v1.0 which
# accompanies this distribution, is reproduced below, and is
# available at http://www.eclipse.org/org/documents/edl-v10.php
#
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or
# without modification, are permitted provided that the following
# conditions are met:
#
# - Redistributions of source code must retain the above copyright
#   notice, this list of conditions and the following disclaimer.
#
# - Redistributions in binary form must reproduce the above
#   copyright notice, this list of conditions and the following
#   disclaimer in the documentation and/or other materials provided
#   with the distribution.
#
# - Neither the name of the Eclipse Foundation, Inc. nor the
#   names of its contributors may be used to endorse or promote
#   products derived from this software without specific prior
#   written permission.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

defmodule Xgit.Core.Object do
  @moduledoc ~S"""
  Describes a single object stored (or about to be stored) in a git repository.

  This struct is constructed, modified, and shared as a working description of
  how to find and describe an object before it gets written to a repository.
  """
  use Xgit.Core.ObjectType

  alias Xgit.Core.ContentSource
  alias Xgit.Core.FileMode
  alias Xgit.Core.FilePath
  alias Xgit.Core.ObjectId
  alias Xgit.Core.ObjectId
  alias Xgit.Util.RawParseUtils

  import Xgit.Util.RawParseUtils, only: [after_prefix: 2]

  @typedoc ~S"""
  This struct describes a single object stored or about to be stored in a git
  repository.

  ## Struct Members

  * `:type`: the object's type (`:blob`, `:tree`, `:commit`, or `:tag`)
  * `:content`: how to obtain the content (see `Xgit.Core.ContentSource`)
  * `:size`: size (in bytes) of the object or `:unknown`
  * `:id`: object ID (40 chars hex) of the object or `:unknown`
  """
  @type t :: %__MODULE__{
          type: ObjectType.t(),
          content: ContentSource.t(),
          size: non_neg_integer() | :unknown,
          id: ObjectId.t() | :unknown
        }

  @enforce_keys [:type, :content]
  defstruct [:type, :content, size: :unknown, id: :unknown]

  @doc ~S"""
  Return `true` if the struct describes a valid object.

  _IMPORTANT:_ This validation _only_ verifies that the struct itself is valid.
  It does not inspect the content of the object. That check can be performed by
  `check/2`.
  """
  @spec valid?(object :: any) :: boolean
  def valid?(object)

  def valid?(%__MODULE__{type: type, content: content, size: size, id: id})
      when is_object_type(type) and is_integer(size) and size >= 0,
      do: ObjectId.valid?(id) && content != nil

  def valid?(_), do: false

  @typedoc ~S"""
  Error codes which can be returned by `check/2`.
  """
  @type check_reason ::
          :invalid_type
          | :no_tree_header
          | :invalid_tree
          | :invalid_parent
          | :no_author
          | :no_committer
          | :no_object_header
          | :invalid_object
          | :no_type_header
          | :invalid_tagger
          | :bad_date
          | :bad_email
          | :missing_email
          | :missing_space_before_date
          | :bad_time_zone
          | :invalid_file_mode
          | :truncated_in_name
          | :duplicate_entry_names
          | :incorrectly_sorted
          | :truncated_in_object_id
          | :null_sha1
          | :invalid_mode

  @doc ~S"""
  Verify that a proposed object is valid.

  This function performs a detailed check on the _content_ of the object.
  For a simpler verification that the `Object` struct is _itself_
  valid, see `valid?/1`.

  Verifications made by this function only check that the fields of an object are
  formatted correctly. The object ID checksum of the object is not verified, and
  connectivity links between objects are also not verified. It's assumed that
  the caller can provide both of these validations on its own.

  ## Options

  By default, this function will only enforce Posix file name restrictions.

  * `:macosx?`: `true` to also enforce Mac OS X path name restrictions
  * `:windows?`: `true` to also enforce Windows path name restrictions

  ## Return Value

  `:ok` if the object is successfully validated.

  `{:error, :invalid_type}` if the object's type is unknown.

  `{:error, :no_tree_header}` if the object is a commit but does not contain
  a valid tree header.

  `{:error, :invalid_tree}` if the object is a commit but the tree object ID
  is invalid.

  `{:error, :invalid_parent}` if the object is a commit but one of the `parent`
  headers is invalid.

  `{:error, :no_author}` if the object is a commit but there is no `author` header.

  `{:error, :no_committer}` if the object is a commit but there is no `committer` header.

  `{:error, :no_object_header}` if the object is a tag but there is no `object` header.

  `{:error, :invalid_object}` if the object is a tag but the object ID is invalid.

  `{:error, :no_type_header}` if the object is a tag but there is no `type` header.

  `{:error, :invalid_tagger}` if the object is a tag but one of the `tagger` headers
  is invalid.

  `{:error, :bad_date}` if the object is a tag or a commit but has a malformed date entry.

  `{:error, :bad_email}` if the object is a tag or a commit but has a malformed e-mail address.

  `{:error, :missing_email}` if the object is a tag or a commit but has a missing e-mail address
  where one is expected.

  `{:error, :missing_space_before_date}` if the object is a tag or a commit but
  has no space preceding the place where a date is expected.

  `{:error, :bad_time_zone}` if the object is a tag or a commit but has a malformed
  time zone entry.

  `{:error, :invalid_file_mode}` if the object is a tree but one of the file modes is invalid.

  `{:error, :truncated_in_name}` if the object is a tree but one of the file names is incomplete.

  `{:error, :duplicate_entry_names}` if the object is a tree and contains duplicate
  entry names.

  `{:error, :incorrectly_sorted}` if the object is a tree and the entries are not
  in alphabetical order.

  `{:error, :truncated_in_object_id}` if the object is a tree and one of the object IDs
  is invalid.

  `{:error, :null_sha1}` if the object is a tree and one of the object IDs is all zeros.

  `{:error, :invalid_mode}` if the object is a tree and one of the file modes is incomplete.

  See also error responses from `Xgit.Core.FilePath.check_path/2` and
  `Xgit.Core.FilePath.check_path_segment/2`.
  """
  @spec check(object :: t(), windows?: boolean, macosx?: boolean) ::
          :ok
          | {:error, reason :: check_reason}
          | {:error, reason :: FilePath.check_path_reason()}
          | {:error, reason :: FilePath.check_path_segment_reason()}
  def check(object, opts \\ [])

  def check(%__MODULE__{type: :blob}, _opts), do: :ok
  def check(%__MODULE__{type: :commit} = object, _opts), do: check_commit(object)
  def check(%__MODULE__{type: :tag} = object, _opts), do: check_tag(object)
  def check(%__MODULE__{type: :tree} = object, opts), do: check_tree(object, opts)
  def check(%__MODULE__{type: _type}, _opts), do: {:error, :invalid_type}

  # -- commit specifics --

  defp check_commit(%__MODULE__{content: data}) when is_list(data) do
    with {:tree, data} when is_list(data) <- {:tree, after_prefix(data, 'tree ')},
         {:tree_id, data} when is_list(data) <- {:tree_id, check_id(data)},
         {:parents, data} when is_list(data) <- {:parents, check_commit_parents(data)},
         {:author, data} when is_list(data) <- {:author, after_prefix(data, 'author ')},
         {:author_id, data} when is_list(data) <- {:author_id, check_person_ident(data)},
         {:committer, data} when is_list(data) <- {:committer, after_prefix(data, 'committer ')},
         {:committer_id, data} when is_list(data) <- {:committer_id, check_person_ident(data)} do
      :ok
    else
      {:tree, _} -> {:error, :no_tree_header}
      {:tree_id, _} -> {:error, :invalid_tree}
      {:parents, _} -> {:error, :invalid_parent}
      {:author, _} -> {:error, :no_author}
      {:author_id, why} when is_atom(why) -> {:error, why}
      {:committer, _} -> {:error, :no_committer}
      {:committer_id, why} when is_atom(why) -> {:error, why}
    end
  end

  defp check_commit_parents(data) do
    case after_prefix(data, 'parent ') do
      after_match when is_list(after_match) ->
        if next_line = check_id(after_match),
          do: check_commit_parents(next_line),
          else: nil

      nil ->
        data
    end
  end

  # -- tag specifics --

  defp check_tag(%__MODULE__{content: data}) when is_list(data) do
    with {:object, data} when is_list(data) <- {:object, after_prefix(data, 'object ')},
         {:object_id, data} when is_list(data) <- {:object_id, check_id(data)},
         {:type, data} when is_list(data) <- {:type, after_prefix(data, 'type ')},
         data <- RawParseUtils.next_lf(data),
         {:tag, data} when is_list(data) <- {:tag, after_prefix(data, 'tag ')},
         data <- RawParseUtils.next_lf(data),
         {:tagger, data} when is_list(data) <- {:tagger, maybe_match_tagger(data)} do
      :ok
    else
      {:object, _} -> {:error, :no_object_header}
      {:object_id, _} -> {:error, :invalid_object}
      {:type, _} -> {:error, :no_type_header}
      {:tag, _} -> {:error, :no_tag_header}
      {:tagger, _} -> {:error, :invalid_tagger}
    end
  end

  defp maybe_match_tagger(data) do
    after_match = after_prefix(data, 'tagger ')

    if is_list(after_match),
      do: check_person_ident(after_match),
      else: data
  end

  # -- tree specifics --

  defp check_tree(%__MODULE__{content: data}, opts) when is_list(data) and is_list(opts) do
    maybe_normalized_paths =
      if Keyword.get(opts, :windows?) || Keyword.get(opts, :macosx?),
        do: MapSet.new(),
        else: nil

    check_next_tree_entry(data, maybe_normalized_paths, [], FileMode.regular_file(), opts)
  end

  defp check_next_tree_entry([], _maybe_normalized_paths, _previous_name, _previous_mode, _opts),
    do: :ok

  defp check_next_tree_entry(data, maybe_normalized_paths, previous_name, previous_mode, opts) do
    # Scan one entry then recurse to scan remaining entries.

    with {:file_mode, {:ok, file_mode, data}} <- {:file_mode, check_file_mode(data, 0)},
         {:file_mode, true} <- {:file_mode, FileMode.valid?(file_mode)},
         {:path_split, {path_segment, [0 | data]}} <- {:path_split, path_and_object_id(data)},
         {:path_valid, :ok} <- {:path_valid, FilePath.check_path_segment(path_segment, opts)},
         {:duplicate, false} <-
           {:duplicate, maybe_mapset_member?(maybe_normalized_paths, path_segment, opts)},
         {:duplicate, false} <- {:duplicate, duplicate_name?(path_segment, data)},
         {:sorted, true} <-
           {:sorted, correctly_sorted?(previous_name, previous_mode, path_segment, file_mode)},
         {raw_object_id, data} <- Enum.split(data, 20),
         {:object_id_length, 20} <- {:object_id_length, Enum.count(raw_object_id)},
         {:object_id_null, false} <- {:object_id_null, Enum.all?(raw_object_id, &(&1 == 0))} do
      check_next_tree_entry(
        data,
        maybe_put_path(maybe_normalized_paths, path_segment, opts),
        path_segment,
        file_mode,
        opts
      )
    else
      {:file_mode, {:error, reason}} -> {:error, reason}
      {:file_mode, _} -> {:error, :invalid_file_mode}
      {:path_split, _} -> {:error, :truncated_in_name}
      {:path_valid, {:error, reason}} -> {:error, reason}
      {:duplicate, _} -> {:error, :duplicate_entry_names}
      {:sorted, _} -> {:error, :incorrectly_sorted}
      {:object_id_length, _} -> {:error, :truncated_in_object_id}
      {:object_id_null, _} -> {:error, :null_sha1}
    end
  end

  defp check_file_mode([], _mode), do: {:error, :invalid_mode}

  defp check_file_mode([?\s | data], mode), do: {:ok, mode, data}

  defp check_file_mode([?0 | _data], 0), do: {:error, :invalid_mode}

  defp check_file_mode([c | data], mode) when c >= ?0 and c <= ?7,
    do: check_file_mode(data, mode * 8 + (c - ?0))

  defp check_file_mode([_c | _data], _mode), do: {:error, :invalid_mode}

  defp path_and_object_id(data), do: Enum.split_while(data, &(&1 != 0))

  defp maybe_mapset_member?(nil, _path_segment, _opts), do: false

  defp maybe_mapset_member?(mapset, path_segment, opts),
    do: MapSet.member?(mapset, normalize(path_segment, Keyword.get(opts, :macosx?, false)))

  defp duplicate_name?(this_name, data) do
    data = Enum.drop(data, 20)

    {mode_str, data} = Enum.split_while(data, &(&1 != ?\s))
    mode = parse_octal(mode_str)

    data = Enum.drop(data, 1)

    {next_name, data} = Enum.split_while(data, &(&1 != 0))

    data = Enum.drop(data, 1)

    compare = FilePath.compare_same_name(this_name, next_name, mode)

    cond do
      Enum.empty?(mode_str) or Enum.empty?(next_name) -> false
      compare == :lt -> false
      compare == :eq -> true
      compare == :gt -> duplicate_name?(this_name, data)
    end
  end

  defp parse_octal(data) do
    case Integer.parse(to_string(data), 8) do
      {n, _} when is_integer(n) -> n
      :error -> 0
    end
  end

  defp correctly_sorted?([], _previous_mode, _this_name, _this_mode), do: true

  defp correctly_sorted?(previous_name, previous_mode, this_name, this_mode),
    do: FilePath.compare(previous_name, previous_mode, this_name, this_mode) != :gt

  defp maybe_put_path(nil, _path_segment, _opts), do: nil

  defp maybe_put_path(mapset, path_segment, opts),
    do: MapSet.put(mapset, normalize(path_segment, Keyword.get(opts, :macosx?, false)))

  # -- generic matching utilities --

  defp check_id(data) do
    case ObjectId.from_hex_charlist(data) do
      {_id, [?\n | remainder]} -> remainder
      _ -> nil
    end
  end

  defp check_person_ident(data) do
    with {:missing_email, [?< | email_start]} <-
           {:missing_email, RawParseUtils.next_lf(data, ?<)},
         {:bad_email, [?> | after_email]} <- {:bad_email, RawParseUtils.next_lf(email_start, ?>)},
         {:missing_space_before_date, [?\s | date]} <- {:missing_space_before_date, after_email},
         {:bad_date, {_date, [?\s | tz]}} <- {:bad_date, RawParseUtils.parse_base_10(date)},
         {:bad_timezone, {_tz, [?\n | next]}} <- {:bad_timezone, RawParseUtils.parse_base_10(tz)} do
      next
    else
      {:missing_email, _} -> :missing_email
      {:bad_email, _} -> :bad_email
      {:missing_space_before_date, _} -> :missing_space_before_date
      {:bad_date, _} -> :bad_date
      {:bad_timezone, _} -> :bad_time_zone
    end
  end

  defp normalize(name, true = _mac?) when is_list(name) do
    name
    |> RawParseUtils.decode()
    |> String.downcase()
    |> :unicode.characters_to_nfc_binary()
  end

  defp normalize(name, _) when is_list(name), do: Enum.map(name, &to_lower/1)

  defp to_lower(b) when b >= ?A and b <= ?Z, do: b + 32
  defp to_lower(b), do: b
end

1	# Copyright (C) 2008-2010, Google Inc.
2	# Copyright (C) 2008, Shawn O. Pearce <spearce@spearce.org>
3	# and other copyright owners as documented in the project's IP log.
4	#
5	# Elixir adaptation from jgit file:
6	# org.eclipse.jgit/src/org/eclipse/jgit/lib/ObjectChecker.java
7	#
8	# Copyright (C) 2019, Eric Scouten <eric+xgit@scouten.com>
9	#
10	# This program and the accompanying materials are made available
11	# under the terms of the Eclipse Distribution License v1.0 which
12	# accompanies this distribution, is reproduced below, and is
13	# available at http://www.eclipse.org/org/documents/edl-v10.php
14	#
15	# All rights reserved.
16	#
17	# Redistribution and use in source and binary forms, with or
18	# without modification, are permitted provided that the following
19	# conditions are met:
20	#
21	# - Redistributions of source code must retain the above copyright
22	# notice, this list of conditions and the following disclaimer.
23	#
24	# - Redistributions in binary form must reproduce the above
25	# copyright notice, this list of conditions and the following
26	# disclaimer in the documentation and/or other materials provided
27	# with the distribution.
28	#
29	# - Neither the name of the Eclipse Foundation, Inc. nor the
30	# names of its contributors may be used to endorse or promote
31	# products derived from this software without specific prior
32	# written permission.
33	#
34	# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
35	# CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
36	# INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
37	# OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
38	# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
39	# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
40	# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
41	# NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
42	# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
43	# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
44	# STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
45	# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
46	# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
47
48	defmodule Xgit.Core.Object do
49	@moduledoc ~S"""
50	Describes a single object stored (or about to be stored) in a git repository.
51
52	This struct is constructed, modified, and shared as a working description of
53	how to find and describe an object before it gets written to a repository.
54	"""
55	use Xgit.Core.ObjectType
56
57	alias Xgit.Core.ContentSource
58	alias Xgit.Core.FileMode
59	alias Xgit.Core.FilePath
60	alias Xgit.Core.ObjectId
61	alias Xgit.Core.ObjectId
62	alias Xgit.Util.RawParseUtils
63
64	import Xgit.Util.RawParseUtils, only: [after_prefix: 2]
65
66	@typedoc ~S"""
67	This struct describes a single object stored or about to be stored in a git
68	repository.
69
70	## Struct Members
71
72	* `:type`: the object's type (`:blob`, `:tree`, `:commit`, or `:tag`)
73	* `:content`: how to obtain the content (see `Xgit.Core.ContentSource`)
74	* `:size`: size (in bytes) of the object or `:unknown`
75	* `:id`: object ID (40 chars hex) of the object or `:unknown`
76	"""
77	@type t :: %__MODULE__{
78	type: ObjectType.t(),
79	content: ContentSource.t(),
80	size: non_neg_integer() \| :unknown,
81	id: ObjectId.t() \| :unknown
82	}
83
84	@enforce_keys [:type, :content]
85	defstruct [:type, :content, size: :unknown, id: :unknown]
86
87	@doc ~S"""
88	Return `true` if the struct describes a valid object.
89
90	_IMPORTANT:_ This validation _only_ verifies that the struct itself is valid.
91	It does not inspect the content of the object. That check can be performed by
92	`check/2`.
93	"""
94	@spec valid?(object :: any) :: boolean
95	def valid?(object)
96
97	def valid?(%__MODULE__{type: type, content: content, size: size, id: id})
98	when is_object_type(type) and is_integer(size) and size >= 0,
99	do: ObjectId.valid?(id) && content != nil	44×
100
101	def valid?(_), do: false
102
103	@typedoc ~S"""
104	Error codes which can be returned by `check/2`.
105	"""
106	@type check_reason ::
107	:invalid_type
108	\| :no_tree_header
109	\| :invalid_tree
110	\| :invalid_parent
111	\| :no_author
112	\| :no_committer
113	\| :no_object_header
114	\| :invalid_object
115	\| :no_type_header
116	\| :invalid_tagger
117	\| :bad_date
118	\| :bad_email
119	\| :missing_email
120	\| :missing_space_before_date
121	\| :bad_time_zone
122	\| :invalid_file_mode
123	\| :truncated_in_name
124	\| :duplicate_entry_names
125	\| :incorrectly_sorted
126	\| :truncated_in_object_id
127	\| :null_sha1
128	\| :invalid_mode
129
130	@doc ~S"""
131	Verify that a proposed object is valid.
132
133	This function performs a detailed check on the _content_ of the object.
134	For a simpler verification that the `Object` struct is _itself_
135	valid, see `valid?/1`.
136
137	Verifications made by this function only check that the fields of an object are
138	formatted correctly. The object ID checksum of the object is not verified, and
139	connectivity links between objects are also not verified. It's assumed that
140	the caller can provide both of these validations on its own.
141
142	## Options
143
144	By default, this function will only enforce Posix file name restrictions.
145
146	* `:macosx?`: `true` to also enforce Mac OS X path name restrictions
147	* `:windows?`: `true` to also enforce Windows path name restrictions
148
149	## Return Value
150
151	`:ok` if the object is successfully validated.
152
153	`{:error, :invalid_type}` if the object's type is unknown.
154
155	`{:error, :no_tree_header}` if the object is a commit but does not contain
156	a valid tree header.
157
158	`{:error, :invalid_tree}` if the object is a commit but the tree object ID
159	is invalid.
160
161	`{:error, :invalid_parent}` if the object is a commit but one of the `parent`
162	headers is invalid.
163
164	`{:error, :no_author}` if the object is a commit but there is no `author` header.
165
166	`{:error, :no_committer}` if the object is a commit but there is no `committer` header.
167
168	`{:error, :no_object_header}` if the object is a tag but there is no `object` header.
169
170	`{:error, :invalid_object}` if the object is a tag but the object ID is invalid.
171
172	`{:error, :no_type_header}` if the object is a tag but there is no `type` header.
173
174	`{:error, :invalid_tagger}` if the object is a tag but one of the `tagger` headers
175	is invalid.
176
177	`{:error, :bad_date}` if the object is a tag or a commit but has a malformed date entry.
178
179	`{:error, :bad_email}` if the object is a tag or a commit but has a malformed e-mail address.
180
181	`{:error, :missing_email}` if the object is a tag or a commit but has a missing e-mail address
182	where one is expected.
183
184	`{:error, :missing_space_before_date}` if the object is a tag or a commit but
185	has no space preceding the place where a date is expected.
186
187	`{:error, :bad_time_zone}` if the object is a tag or a commit but has a malformed
188	time zone entry.
189
190	`{:error, :invalid_file_mode}` if the object is a tree but one of the file modes is invalid.
191
192	`{:error, :truncated_in_name}` if the object is a tree but one of the file names is incomplete.
193
194	`{:error, :duplicate_entry_names}` if the object is a tree and contains duplicate
195	entry names.
196
197	`{:error, :incorrectly_sorted}` if the object is a tree and the entries are not
198	in alphabetical order.
199
200	`{:error, :truncated_in_object_id}` if the object is a tree and one of the object IDs
201	is invalid.
202
203	`{:error, :null_sha1}` if the object is a tree and one of the object IDs is all zeros.
204
205	`{:error, :invalid_mode}` if the object is a tree and one of the file modes is incomplete.
206
207	See also error responses from `Xgit.Core.FilePath.check_path/2` and
208	`Xgit.Core.FilePath.check_path_segment/2`.
209	"""
210	@spec check(object :: t(), windows?: boolean, macosx?: boolean) ::
211	:ok
212	\| {:error, reason :: check_reason}
213	\| {:error, reason :: FilePath.check_path_reason()}
214	\| {:error, reason :: FilePath.check_path_segment_reason()}
215	def check(object, opts \\ [])	508×
216
217	def check(%__MODULE__{type: :blob}, _opts), do: :ok
218	def check(%__MODULE__{type: :commit} = object, _opts), do: check_commit(object)	136×
219	def check(%__MODULE__{type: :tag} = object, _opts), do: check_tag(object)	68×
220	def check(%__MODULE__{type: :tree} = object, opts), do: check_tree(object, opts)	652×
221	def check(%__MODULE__{type: _type}, _opts), do: {:error, :invalid_type}
222
223	# -- commit specifics --
224
225	defp check_commit(%__MODULE__{content: data}) when is_list(data) do
226	with {:tree, data} when is_list(data) <- {:tree, after_prefix(data, 'tree ')},	136×
227	{:tree_id, data} when is_list(data) <- {:tree_id, check_id(data)},	116×
228	{:parents, data} when is_list(data) <- {:parents, check_commit_parents(data)},	100×
229	{:author, data} when is_list(data) <- {:author, after_prefix(data, 'author ')},	84×
230	{:author_id, data} when is_list(data) <- {:author_id, check_person_ident(data)},	76×
231	{:committer, data} when is_list(data) <- {:committer, after_prefix(data, 'committer ')},	44×
232	{:committer_id, data} when is_list(data) <- {:committer_id, check_person_ident(data)} do	36×
233	:ok
234	else
235	{:tree, _} -> {:error, :no_tree_header}
236	{:tree_id, _} -> {:error, :invalid_tree}
237	{:parents, _} -> {:error, :invalid_parent}
238	{:author, _} -> {:error, :no_author}
239	{:author_id, why} when is_atom(why) -> {:error, why}
240	{:committer, _} -> {:error, :no_committer}
241	{:committer_id, why} when is_atom(why) -> {:error, why}
242	end
243	end
244
245	defp check_commit_parents(data) do
246	case after_prefix(data, 'parent ') do	624×
247	after_match when is_list(after_match) ->
248	if next_line = check_id(after_match),	540×
249	do: check_commit_parents(next_line),	524×
250	else: nil
251
252	nil ->
253	data	84×
254	end
255	end
256
257	# -- tag specifics --
258
259	defp check_tag(%__MODULE__{content: data}) when is_list(data) do
260	with {:object, data} when is_list(data) <- {:object, after_prefix(data, 'object ')},	68×
261	{:object_id, data} when is_list(data) <- {:object_id, check_id(data)},	56×
262	{:type, data} when is_list(data) <- {:type, after_prefix(data, 'type ')},	44×
263	data <- RawParseUtils.next_lf(data),	32×
264	{:tag, data} when is_list(data) <- {:tag, after_prefix(data, 'tag ')},	32×
265	data <- RawParseUtils.next_lf(data),	16×
266	{:tagger, data} when is_list(data) <- {:tagger, maybe_match_tagger(data)} do	16×
267	:ok
268	else
269	{:object, _} -> {:error, :no_object_header}
270	{:object_id, _} -> {:error, :invalid_object}
271	{:type, _} -> {:error, :no_type_header}
272	{:tag, _} -> {:error, :no_tag_header}
273	{:tagger, _} -> {:error, :invalid_tagger}
274	end
275	end
276
277	defp maybe_match_tagger(data) do
278	after_match = after_prefix(data, 'tagger ')	16×
279
280	if is_list(after_match),	16×
281	do: check_person_ident(after_match),	12×
282	else: data	4×
283	end
284
285	# -- tree specifics --
286
287	defp check_tree(%__MODULE__{content: data}, opts) when is_list(data) and is_list(opts) do
288	maybe_normalized_paths =	652×
289	if Keyword.get(opts, :windows?) \|\| Keyword.get(opts, :macosx?),	652×
290	do: MapSet.new(),	348×
291	else: nil
292
293	check_next_tree_entry(data, maybe_normalized_paths, [], FileMode.regular_file(), opts)	652×
294	end
295
296	defp check_next_tree_entry([], _maybe_normalized_paths, _previous_name, _previous_mode, _opts),
297	do: :ok
298
299	defp check_next_tree_entry(data, maybe_normalized_paths, previous_name, previous_mode, opts) do
300	# Scan one entry then recurse to scan remaining entries.
301
302	with {:file_mode, {:ok, file_mode, data}} <- {:file_mode, check_file_mode(data, 0)},	712×
303	{:file_mode, true} <- {:file_mode, FileMode.valid?(file_mode)},	688×
304	{:path_split, {path_segment, [0 \| data]}} <- {:path_split, path_and_object_id(data)},	680×
305	{:path_valid, :ok} <- {:path_valid, FilePath.check_path_segment(path_segment, opts)},	676×
306	{:duplicate, false} <-	304×
307	{:duplicate, maybe_mapset_member?(maybe_normalized_paths, path_segment, opts)},
308	{:duplicate, false} <- {:duplicate, duplicate_name?(path_segment, data)},	292×
309	{:sorted, true} <-	272×
310	{:sorted, correctly_sorted?(previous_name, previous_mode, path_segment, file_mode)},
311	{raw_object_id, data} <- Enum.split(data, 20),	260×
312	{:object_id_length, 20} <- {:object_id_length, Enum.count(raw_object_id)},	260×
313	{:object_id_null, false} <- {:object_id_null, Enum.all?(raw_object_id, &(&1 == 0))} do	256×
314	check_next_tree_entry(	252×
315	data,
316	maybe_put_path(maybe_normalized_paths, path_segment, opts),
317	path_segment,
318	file_mode,
319	opts
320	)
321	else
322	{:file_mode, {:error, reason}} -> {:error, reason}
323	{:file_mode, _} -> {:error, :invalid_file_mode}
324	{:path_split, _} -> {:error, :truncated_in_name}
325	{:path_valid, {:error, reason}} -> {:error, reason}
326	{:duplicate, _} -> {:error, :duplicate_entry_names}
327	{:sorted, _} -> {:error, :incorrectly_sorted}
328	{:object_id_length, _} -> {:error, :truncated_in_object_id}
329	{:object_id_null, _} -> {:error, :null_sha1}
330	end
331	end
332
333	defp check_file_mode([], _mode), do: {:error, :invalid_mode}
334
335	defp check_file_mode([?\s \| data], mode), do: {:ok, mode, data}
336
337	defp check_file_mode([?0 \| _data], 0), do: {:error, :invalid_mode}
338
339	defp check_file_mode([c \| data], mode) when c >= ?0 and c <= ?7,
340	do: check_file_mode(data, mode * 8 + (c - ?0))	4,084×
341
342	defp check_file_mode([_c \| _data], _mode), do: {:error, :invalid_mode}
343
344	defp path_and_object_id(data), do: Enum.split_while(data, &(&1 != 0))	680×
345
346	defp maybe_mapset_member?(nil, _path_segment, _opts), do: false
347
348	defp maybe_mapset_member?(mapset, path_segment, opts),
349	do: MapSet.member?(mapset, normalize(path_segment, Keyword.get(opts, :macosx?, false)))	36×
350
351	defp duplicate_name?(this_name, data) do
352	data = Enum.drop(data, 20)	316×
353
354	{mode_str, data} = Enum.split_while(data, &(&1 != ?\s))	316×
355	mode = parse_octal(mode_str)	316×
356
357	data = Enum.drop(data, 1)	316×
358
359	{next_name, data} = Enum.split_while(data, &(&1 != 0))	316×
360
361	data = Enum.drop(data, 1)	316×
362
363	compare = FilePath.compare_same_name(this_name, next_name, mode)	316×
364
365	cond do	316×
366	Enum.empty?(mode_str) or Enum.empty?(next_name) -> false	96×
367	compare == :lt -> false	96×
368	compare == :eq -> true	44×
369	compare == :gt -> duplicate_name?(this_name, data)	24×
370	end
371	end
372
373	defp parse_octal(data) do
374	case Integer.parse(to_string(data), 8) do	316×
375	{n, _} when is_integer(n) -> n	96×
376	:error -> 0
377	end
378	end
379
380	defp correctly_sorted?([], _previous_mode, _this_name, _this_mode), do: true
381
382	defp correctly_sorted?(previous_name, previous_mode, this_name, this_mode),
383	do: FilePath.compare(previous_name, previous_mode, this_name, this_mode) != :gt	52×
384
385	defp maybe_put_path(nil, _path_segment, _opts), do: nil
386
387	defp maybe_put_path(mapset, path_segment, opts),
388	do: MapSet.put(mapset, normalize(path_segment, Keyword.get(opts, :macosx?, false)))	24×
389
390	# -- generic matching utilities --
391
392	defp check_id(data) do
393	case ObjectId.from_hex_charlist(data) do	712×
394	{_id, [?\n \| remainder]} -> remainder	668×
395	_ -> nil
396	end
397	end
398
399	defp check_person_ident(data) do
400	with {:missing_email, [?< \| email_start]} <-	124×
401	{:missing_email, RawParseUtils.next_lf(data, ?<)},
402	{:bad_email, [?> \| after_email]} <- {:bad_email, RawParseUtils.next_lf(email_start, ?>)},	112×
403	{:missing_space_before_date, [?\s \| date]} <- {:missing_space_before_date, after_email},	100×
404	{:bad_date, {_date, [?\s \| tz]}} <- {:bad_date, RawParseUtils.parse_base_10(date)},	96×
405	{:bad_timezone, {_tz, [?\n \| next]}} <- {:bad_timezone, RawParseUtils.parse_base_10(tz)} do	80×
406	next	76×
407	else
408	{:missing_email, _} -> :missing_email
409	{:bad_email, _} -> :bad_email
410	{:missing_space_before_date, _} -> :missing_space_before_date
411	{:bad_date, _} -> :bad_date
412	{:bad_timezone, _} -> :bad_time_zone
413	end
414	end
415
416	defp normalize(name, true = _mac?) when is_list(name) do
417	name
418	\|> RawParseUtils.decode()
419	\|> String.downcase()
420	\|> :unicode.characters_to_nfc_binary()	48×
421	end
422
423	defp normalize(name, _) when is_list(name), do: Enum.map(name, &to_lower/1)	12×
424
425	defp to_lower(b) when b >= ?A and b <= ?Z, do: b + 32	8×
426	defp to_lower(b), do: b	4×
427	end

elixir-git / xgit / 305

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous