git-replay - EXPERIMENTAL: Replay commits on a new base, works with bare repos too


SYNOPSIS
--------
(EXPERIMENTAL!) 'git replay' ([--contained] --onto <newbase> | --advance <branch>) <revision-range>...

DESCRIPTION
-----------

Takes ranges of commits and replays them onto a new location. Leaves
the working tree and the index untouched, and updates no references.
The output of this command is meant to be used as input to
`git update-ref --stdin`, which would update the relevant branches
(see the OUTPUT section below).

THIS COMMAND IS EXPERIMENTAL. THE BEHAVIOR MAY CHANGE.

OPTIONS
-------

--onto <newbase>
    Starting point at which to create the new commits.  May be any
    valid commit, and not just an existing branch name.

When `--onto` is specified, the update-ref command(s) in the output will
update the branch(es) in the revision range to point at the new
commits, similar to the way how `git rebase --update-refs` updates
multiple branches in the affected range.

--advance <branch>
    Starting point at which to create the new commits; must be a
    branch name.

When `--advance` is specified, the update-ref command(s) in the output
will update the branch passed as an argument to `--advance` to point at
the new commits (in other words, this mimics a cherry-pick operation).

<revision-range>
    Range of commits to replay. More than one <revision-range> can
    be passed, but in `--advance <branch>` mode, they should have
    a single tip, so that it's clear where <branch> should point
    to. See "Specifying Ranges" in git-rev-parse and the
    "Commit Limiting" options below.

OUTPUT
------

When there are no conflicts, the output of this command is usable as
input to `git update-ref --stdin`.  It is of the form:

    update refs/heads/branch1 ${NEW_branch1_HASH} ${OLD_branch1_HASH}
    update refs/heads/branch2 ${NEW_branch2_HASH} ${OLD_branch2_HASH}
    update refs/heads/branch3 ${NEW_branch3_HASH} ${OLD_branch3_HASH}

where the number of refs updated depends on the arguments passed and
the shape of the history being replayed.  When using `--advance`, the
number of refs updated is always one, but for `--onto`, it can be one
or more (rebasing multiple branches simultaneously is supported).

Rawhide (rh) lets you search for files on the command line using expressions and user-defined functions in a mini-language inspired by C. It’s like find(1), but more fun to use. Search criteria can be very readable and self-explanatory and/or very concise and typeable, and you can create your own lexicon of search terms. The output can include lots of detail, like ls(1).

Rawhide (rh) searches the filesystem, starting at each given path, for files that make the given search criteria expression true. If no search paths are given, the current working directory is searched.
The search criteria expression can come from the command line (with the -e option), from a file (with the -f option), or from standard input (stdin) (with -f-). If there is no explicit -e option expression, rh looks for an implicit expression among any remaining command line arguments. If no expression is specified, the default search criteria is the expression 1, which matches all filesystem entries.
An rh expression is a C-like expression that can call user-defined functions.
These expressions can contain all of C’s conditional, logical, relational, equality, arithmetic, and bit operators.

constexpr auto result = flux::ints()                        // 0,1,2,3,...
                         .filter(flux::pred::even)          // 0,2,4,6,...
                         .map([](int i) { return i * 2; })  // 0,4,8,12,...
                         .take(3)                           // 0,4,8
                         .sum();                            // 12

static_assert(result == 12);

using namespace lug::language;
		rule JSON;
		rule ExponentPart   = lexeme[ "[Ee]"_rx > ~"[+-]"_rx > +"[0-9]"_rx ];
		rule FractionalPart = lexeme[ "."_sx > +"[0-9]"_rx ];
		rule IntegralPart   = lexeme[ "0"_sx | "[1-9]"_rx > *"[0-9]"_rx ];
		rule Number         = lexeme[ ~"-"_sx > IntegralPart > ~FractionalPart > ~ExponentPart ];
		rule Boolean        = lexeme[ "true"_sx | "false" ];
		rule Null           = lexeme[ "null" ];
		rule UnicodeEscape  = lexeme[ 'u' > "[0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f][0-9A-Fa-f]"_rx ];
		rule Escape         = lexeme[ "\\" > ("[/\\bfnrt]"_rx | UnicodeEscape) ];
		rule String         = lexeme[ "\"" > *("[^\"\\\u0000-\u001F]"_rx | Escape) > "\"" ];
		rule Array          = "[" > JSON > *("," > JSON) > "]";
		rule Object         = "{" > String > ":" > JSON > *("," > String > ":" > JSON) > "}";
		JSON                = Object | Array | String | Number | Boolean | Null;
		grammar_ = start(JSON);

#include <boost/ut.hpp> // import boost.ut;

constexpr auto sum(auto... values) { return (values + ...); }

int main() {
  using namespace boost::ut;

  "sum"_test = [] {
    expect(sum(0) == 0_i);
    expect(sum(1, 2) == 3_i);
    expect(sum(1, 2) > 0_i and 41_i == sum(40, 2));
  };
}

#include <boost/ut.hpp>
#include <chrono>
#include <iostream>
#include <string>
#include <string_view>

namespace benchmark {
struct benchmark : boost::ut::detail::test {
  explicit benchmark(std::string_view _name)
      : boost::ut::detail::test{"benchmark", _name} {}

  template <class Test>
  auto operator=(Test _test) {
    static_cast<boost::ut::detail::test&>(*this) = [&_test, this] {
      const auto start = std::chrono::high_resolution_clock::now();
      _test();
      const auto stop = std::chrono::high_resolution_clock::now();
      const auto ns =
          std::chrono::duration_cast<std::chrono::nanoseconds>(stop - start);
      std::clog << "[" << name << "] " << ns.count() << " ns\n";
    };
  }
};

[[nodiscard]] auto operator""_benchmark(const char* _name,
                                        decltype(sizeof("")) size) {
  return ::benchmark::benchmark{{_name, size}};
}

#if defined(__GNUC__) or defined(__clang__)
template <class T>
void do_not_optimize(T&& t) {
  asm volatile("" ::"m"(t) : "memory");
}
#else
#pragma optimize("", off)
template <class T>
void do_not_optimize(T&& t) {
  reinterpret_cast<char volatile&>(t) =
      reinterpret_cast<char const volatile&>(t);
}
#pragma optimize("", on)
#endif
}  // namespace benchmark

int main() {
  using namespace boost::ut;
  using namespace benchmark;

  "string creation"_benchmark = [] {
    std::string created_string{"hello"};
    do_not_optimize(created_string);
  };
}

#include <boost/ut.hpp>

int main() {
  using namespace boost::ut::literals;
  using namespace boost::ut::operators::terse;
  using namespace boost::ut::bdd;

  "Scenario"_test = [] {
    given("I have...") = [] {
      when("I run...") = [] {
        then("I should have...") = [] { 1_u == 1u; };
        then("I should have...") = [] { 1u == 1_u; };
      };
    };
  };

  feature("Calculator") = [] {
    scenario("Addition") = [] {
      given("I have number 40") = [] {
        auto number = 40;
        when("I add 2 to number") = [&number] { number += 2; };
        then("I expect number to be 42") = [&number] { 42_i == number; };
      };
    };
  };

  // clang-format off
  scenario("Addition");
    given("I have number 40");
      auto number = 40;

    when("I add 2 to number");
      number += 2;

    then("I expect number to be 42");
      42_i == number;
}

#include <boost/ut.hpp>
#include <fstream>
#include <numeric>
#include <streambuf>
#include <string>

template <class T>
class calculator {
 public:
  auto enter(const T& value) -> void { values_.push_back(value); }
  auto add() -> void {
    result_ = std::accumulate(std::cbegin(values_), std::cend(values_), T{});
  }
  auto sub() -> void {
    result_ = std::accumulate(std::cbegin(values_) + 1, std::cend(values_),
                              values_.front(), std::minus{});
  }
  auto get() const -> T { return result_; }

 private:
  std::vector<T> values_{};
  T result_{};
};

int main(int argc, const char** argv) {
  using namespace boost::ut;

  bdd::gherkin::steps steps = [](auto& steps) {
    steps.feature("Calculator") = [&] {
      steps.scenario("*") = [&] {
        steps.given("I have calculator") = [&] {
          calculator<int> calc{};
          steps.when("I enter {value}") = [&](int value) { calc.enter(value); };
          steps.when("I press add") = [&] { calc.add(); };
          steps.when("I press sub") = [&] { calc.sub(); };
          steps.then("I expect {value}") = [&](int result) {
            expect(that % calc.get() == result);
          };
        };
      };
    };
  };

  // clang-format off
  "Calculator"_test = steps |
    R"(
      Feature: Calculator

        Scenario: Addition
          Given I have calculator
           When I enter 40
           When I enter 2
           When I press add
           Then I expect 42

        Scenario: Subtraction
          Given I have calculator
           When I enter 4
           When I enter 2
           When I press sub
           Then I expect 2
    )";
  // clang-format on

  if (argc == 2) {
    const auto file = [](const auto path) {
      std::ifstream file{path};
      return std::string{(std::istreambuf_iterator<char>(file)),
                         std::istreambuf_iterator<char>()};
    };

    "Calculator"_test = steps | file(argv[1]);
  }
}

ARMASM
AVRASM
AWK
Basic
Brainfuck
C
JSON
Julia
Lisp
LLVM
Makefile
MIPSASM
Nim
Nix
Ocaml
Scheme
TCL
TypeScript
Vim
WASM
X86ASM
YAML

>>> sed → sd
свёрнутый, по умолчанию, текст
<<<

diff --git a/src/main/scala/ru/org/linux/reaction/ReactionService.scala b/src/main/scala/ru/org/linux/reaction/ReactionService.scala
index aa6dde91e..dd31c5a99 100644
--- a/src/main/scala/ru/org/linux/reaction/ReactionService.scala
+++ b/src/main/scala/ru/org/linux/reaction/ReactionService.scala
@@ -97,7 +97,7 @@ object ReactionService {
   val DefinedReactions: Map[String, String] = Map(
     "\uD83D\uDC4D" -> "большой палец вверх",
     "\uD83D\uDC4E" -> "большой палец вниз",
-    "\uD83D\uDE0A" -> "улыбающееся лицо",
+    "\uD83D\uDE42" -> "смешно!",                  // 🙂
     "\uD83D\uDE31" -> "лицо, кричащее от страха",
     "\uD83E\uDD26" -> "facepalm",
     "\uD83D\uDD25" -> "огонь",

В новом исследовании международная группа учёных во главе с профессором Мариек Шмидт из Университета Брока представила открытия о критическом периоде эволюционной истории Марса. Работа раскрывает новые подробности о геологическом прошлом Красной планеты.

Профессор Шмидт, возглавляющая кафедру наук о Земле в Университете Брока, участвовала в миссии марсохода Perseverance NASA в качестве научного сотрудника. Она и её коллеги анализировали древние породы, найденные в кратере Езеро на Марсе. Одной из основных целей миссии был поиск признаков древней микробной жизни, но изучение магматических пород и реголита в этом районе также дало представление о малоизученном периоде истории планеты.

«Мы делаем на Марсе то, чего никогда раньше не делали», – говорит Шмидт. Она также является со-исследователем в команде, работающей с прибором PIXL (Planetary Instrument for X-Ray Lithochemistry). Этот рентгенофлуоресцентный спектрометр использовался для определения элементного состава марсианских поверхностных материалов с высоким разрешением, позволяя учёным дистанционно «заглянуть» вглубь пород, чтобы исследовать, как они формировались и из чего состоят.

«Масштаб научных исследований был невероятным. Это самое всестороннее на сегодняшний день изучение образцов, которые были сохранены для возвращения на Землю», – отмечает Шмидт. «Теперь мы знаем минеральный и химический состав пород, понимаем их текстуры, но следующим шагом было рассказать о том, как, по нашему мнению, формировались эти породы с точки зрения подъёма магмы через марсианскую кору, её кристаллизации, эволюции и изменения состава».

Работа также выдвигает ряд гипотез, которые могут направлять дальнейшие исследования, когда образцы будут доставлены на Землю.

Таня Кизовски, соавтор статьи и заместитель куратора по минералогии в Королевском музее Онтарио, отмечает, что все марсианские образцы, изученные на Земле до сих пор, были метеоритами. Большинство марсианских метеоритов имеют возраст менее 500 миллионов лет, что относительно молодо по сравнению с 4,5-миллиардной историей Марса. В то же время образцы из кратера Езеро, как полагают, имеют возраст не менее 3,5 миллиардов лет.

«Марс очень хорошо сохранился с точки зрения ранней истории нашей Солнечной системы, поэтому возможность изучать такие древние породы, особенно когда они будут доставлены на Землю, поможет нам узнать об истории внутренней части Солнечной системы и о том, когда возникла жизнь», – говорит Кизовски.

Образцы также происходят из уникального периода в истории Марса, когда внутренняя динамика планеты претерпевала серьёзные изменения. Шмидт объясняет: «Вулканизм на Марсе в основном связан с так называемыми горячими точками, подобными Гавайям или Исландии на Земле, где есть сфокусированный источник магмы, уходящий глубоко, пробивающийся через всё и затем извергающийся на поверхность. Но в ранней истории Марса есть модели, подтверждающие идею о том, что марсианская кора формировалась в результате широко распространённого вулканизма, не обязательно сосредоточенного в этих горячих точках, и этот переход, как считается, произошёл примерно в то время, когда формировались эти породы».

Шмидт и её команде ещё предстоит подождать – возможно, десятилетие или больше – прежде чем образцы буду доставлены на Землю. «Доставка этих образцов с Марса будет невероятно сложной задачей и потребует удивительного инженерного подвига, особенно если учесть, что вы доставляете с орбиты нечто размером с баскетбольный мяч», – говорит Шмидт.

Тем временем марсоход Perseverance продолжает исследовать новые районы Марса и собирать образцы, а Шмидт и её коллеги терпеливо ожидают возможности однажды проанализировать марсианские породы уже на Земле.

Это исследование открывает новую главу в изучении Марса, предоставляя учёным беспрецедентную возможность заглянуть в далёкое прошлое планеты. Анализ древних пород из кратера Езеро не только проливает свет на геологическую историю Марса, но и может помочь в поиске следов древней жизни на планете. Кроме того, эти данные могут быть ключом к пониманию ранних этапов формирования планет в Солнечной системе.