print (struct RBasic *)($arg0)

else

if ($flags & RUBY_T_MASK) == RUBY_T_DATA

print (struct RTypedData *)($arg0)

else

printf "%sT_DATA%s: ", $color_type, $color_end

spec_opts=''

# Launchable

setup_launchable() {

pushd ${srcdir}

# To prevent a slowdown in CI, disable request retries when the Launchable server is unstable.

export LAUNCHABLE_SESSION_DIR=${builddir}

local github_ref="${GITHUB_REF//\//_}"

local build_name="${github_ref}"_"${GITHUB_PR_HEAD_SHA}"

launchable record build --name "${build_name}" || true

if [ "$INPUT_CHECK" = "true" ]; then

mkdir "${builddir}"/"${test_spec_report_path}"

fi

}

launchable_record_test() {

pushd "${builddir}"

if [ "$INPUT_CHECK" = "true" ]; then

fi

}

if [ "$LAUNCHABLE_ENABLED" = "true" ]; then

btest_report_path='launchable_bootstraptest.json'

test_report_path='launchable_test_all.json'

test_spec_report_path='launchable_test_spec_report'

launchable_failed=false

kill "$sleep_pid" 2> /dev/null

echo "::endgroup::"

$launchable_failed || trap launchable_record_test EXIT

fi

echo test_all_enabled="${test_all_enabled}" >> $GITHUB_OUTPUT

echo btest_enabled="${btest_enabled}" >> $GITHUB_OUTPUT

echo test_spec_enabled="${test_spec_enabled}" >> $GITHUB_OUTPUT

echo test_all_report_file='launchable_test_all_report.json' >> $GITHUB_OUTPUT

echo btest_report_file='launchable_btest_report.json' >> $GITHUB_OUTPUT

echo test_spec_report_dir='launchable_test_spec_report' >> $GITHUB_OUTPUT

btest_test_suite="yjit-${btest_test_suite}"

test_spec_test_suite="yjit-${test_spec_test_suite}"

fi

--build "${build_name}" \

--observation \

--flavor os="${{ inputs.os }}" \

--flavor test_task="${{ inputs.test-task }}" \

--flavor test_opts="${test_opts}" \

--flavor workflow="${{ github.workflow }}" \

launchable subset \

--get-tests-from-previous-sessions \

--non-blocking \

--target 90% \

raw > /dev/null

fi

fi

fi

if: steps.enable-launchable.outputs.enable-launchable

env:

test_all_enabled: ${{ steps.global.outputs.test_all_enabled }}

btest_enabled: ${{ steps.global.outputs.btest_enabled }}

test_spec_enabled: ${{ steps.global.outputs.test_spec_enabled }}

test_all_report_file: ${{ steps.global.outputs.test_all_report_file }}

btest_report_file: ${{ steps.global.outputs.btest_report_file }}

test_spec_report_dir: ${{ steps.global.outputs.test_spec_report_dir }}

- name: Clean up test results in Launchable

uses: gacts/run-and-post-run@674528335da98a7afc80915ff2b4b860a0b3553a # v1.4.0

with:

post: |

if [[ "${test_all_enabled}" = "true" ]]; then \

launchable record attachment \

"${stdout_report_path}" \

"${stderr_report_path}"; \

launchable record tests \

raw "${test_report_path}" || true; \

fi

if [[ "${btest_enabled}" = "true" ]]; then \

launchable record attachment \

"${stdout_report_path}" \

"${stderr_report_path}"; \

launchable record tests \

raw "${btest_report_path}" || true; \

fi

if [[ "${test_spec_enabled}" = "true" ]]; then \

launchable record attachment \

"${stdout_report_path}" \

"${stderr_report_path}"; \

launchable record tests \

raw ${test_spec_report_path}/* || true; \

fi

if: ${{ always() && steps.enable-launchable.outputs.enable-launchable }}

test_all_enabled: ${{ steps.global.outputs.test_all_enabled }}

btest_enabled: ${{ steps.global.outputs.btest_enabled }}

test_spec_enabled: ${{ steps.global.outputs.test_spec_enabled }}

stdout_report_path: ${{ steps.variables.outputs.stdout_report_path }}

stderr_report_path: ${{ steps.variables.outputs.stderr_report_path }}

${{ steps.clean.outputs.distclean }}

${{ steps.clean.outputs.remained-files }}

${{ steps.clean.outputs.final }}

uses: necojackarc/auto-request-review@e89da1a8cd7c8c16d9de9c6e763290b6b0e3d424 # v0.13.0

with:

# scope: public_repo

steps:

- uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2

with:

- uses: ./.github/actions/setup/directories

with:

checkout: '' # false (ref: https://github.com/actions/runner/issues/2238)

- name: Set ENV

steps:

- uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2

with:

- uses: ./.github/actions/setup/directories

with:

makeup: true

checkout: '' # false (ref: https://github.com/actions/runner/issues/2238)

# Run this step first to make sure auto-style commits are pushed

EMAIL: [email protected]

GIT_AUTHOR_NAME: git

GIT_COMMITTER_NAME: git

PUSH_REF: ${{ github.ref == 'refs/heads/master' && github.ref || '' }}

- name: Check if C-sources are US-ASCII

run: |

steps:

- uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2

with:

- id: gems

run: true

- uses: ./.github/actions/setup/directories

with:

makeup: true

checkout: '' # false (ref: https://github.com/actions/runner/issues/2238)

if: ${{ steps.gems.outcome == 'success' }}

- name: Wait for status checks

uses: lewagon/wait-on-check-action@ccfb013c15c8afb7bf2b7c028fb74dc5a068cccc # v1.3.4

with:

ref: ${{ github.event.pull_request.head.sha || github.sha }}

check-regexp: 'make \(check, .*\)'

wait-interval: 30

run: gh pr merge --auto --rebase "$PR_URL"

env:

PR_URL: ${{ github.event.pull_request.html_url }}

- run: make hello

- name: Set test options for skipped tests

run: |

set -x

echo $PREVIOUS_RELEASE_TAG

tool/gen-github-release.rb $PREVIOUS_RELEASE_TAG $RELEASE_TAG --no-dry-run

env:

- name: Update versions index

run: |

# by a third-party and are governed by separate terms of service, privacy

# policy, and support documentation.

on:

# For Branch-Protection check. Only the default branch is supported. See

# https://github.com/ossf/scorecard/blob/main/docs/checks.md#branch-protection

# To guarantee Maintained check is occasionally updated. See

# https://github.com/ossf/scorecard/blob/main/docs/checks.md#maintained

schedule:

# push:

# branches: [ "master" ]

jobs:

analysis:

runs-on: ubuntu-latest

permissions:

# Needed to upload the results to code-scanning dashboard.

security-events: write

# actions: read

steps:

uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2

with:

persist-credentials: false

with:

results_file: results.sarif

results_format: sarif

# - you want to enable the Branch-Protection check on a *public* repository, or

# Public repositories:

# - Publish results to OpenSSF REST API for easy access by consumers

# of the value entered here.

publish_results: true

# Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF

# format to the repository Actions tab.

with:

sarif_file: results.sarif

- run: $SETARCH make hello

- name: Set test options for skipped tests

run: |

set -x

- name: Restore vcpkg artifact

uses: actions/cache@5a3ec84eff668545956fd18022155c47e93e2684 # v4.2.3

with:

key: windows-${{ matrix.os }}-vcpkg-${{ hashFiles('src/vcpkg.json') }}

- name: Install libraries with vcpkg

jobs:

wsl:

if: >-

${{!(false

)}}

steps:

- name: Install or update WSL

uses: Ubuntu/WSL/.github/actions/wsl-install@main

with:

configure: '--enable-zjit=dev'

tests: '../src/test/ruby/test_zjit.rb'

env:

GITPULLOPTIONS: --no-tags origin ${{ github.ref }}

RUN_OPTS: ${{ matrix.zjit_opts }}

ruby -ne 'raise "Disassembly seems broken in dev build (output has too few lines)" unless $_.to_i > 10'

if: ${{ contains(matrix.configure, 'jit=dev') }}

- name: make ${{ matrix.test_task }}

run: >-

make -s ${{ matrix.test_task }} ${TESTS:+TESTS="$TESTS"}

PRECHECK_BUNDLED_GEMS: 'no'

TESTS: ${{ matrix.tests }}

continue-on-error: ${{ matrix.continue-on-test_task || false }}

result:

if: ${{ always() }}

configure: '--enable-zjit=dev'

tests: '../src/test/ruby/test_zjit.rb'

env:

GITPULLOPTIONS: --no-tags origin ${{ github.ref }}

RUN_OPTS: ${{ matrix.zjit_opts }}

run: ./miniruby --zjit -v | grep "+ZJIT"

if: ${{ matrix.configure != '--disable-zjit' }}

- name: make ${{ matrix.test_task }}

run: >-

make -s ${{ matrix.test_task }} ${TESTS:+TESTS="$TESTS"}

LIBCLANG_PATH: ${{ matrix.libclang_path }}

TESTS: ${{ matrix.tests }}

continue-on-error: ${{ matrix.continue-on-test_task || false }}

result:

if: ${{ always() }}

* Kernel

end

* Binding

The following bundled gems are promoted from default gems.

* pstore 0.2.0

* benchmark 0.4.1

* logger 1.7.0

* win32ole 1.9.2

* irb 1.15.2

* reline 0.6.1

* stringio 3.1.8.dev

* strscan 3.1.6.dev

* uri 1.0.3

The following bundled gems are added.

* rake 13.3.0

* test-unit 3.6.8

* rexml 3.4.1

* net-smtp 0.5.1

* rbs 3.9.4

* base64 0.3.0

* bigdecimal 3.2.2

* drb 2.2.3

## Compatibility issues

* `Ractor.yield`

* `Ractor#take`

[Bug #21049]: https://bugs.ruby-lang.org/issues/21049

[Feature #21166]: https://bugs.ruby-lang.org/issues/21166

[Feature #21216]: https://bugs.ruby-lang.org/issues/21216

[Feature #21258]: https://bugs.ruby-lang.org/issues/21258

[Feature #21262]: https://bugs.ruby-lang.org/issues/21262

[Feature #21287]: https://bugs.ruby-lang.org/issues/21287

location_new(&RNODE_CLASS(node)->class_keyword_loc),

location_new(&RNODE_CLASS(node)->inheritance_operator_loc),

location_new(&RNODE_CLASS(node)->end_keyword_loc));

case NODE_DOT2:

return rb_ary_new_from_args(2,

location_new(nd_code_loc(node)),

--filter REGEXP Filter out benchmarks with given regexp

--run-duration SECONDS Warmup estimates loop_count to run for this duration (default: 3)

--timeout SECONDS Timeout ruby command execution with timeout(1)

```

## make benchmark

prelude: |

def a = nil

benchmark:

to_i: |

nil.to_i

to_f: |

nil.to_f

splat: |

a(*nil)

loop_count: 100000

call(Sub.new('o')).class

}

assert_equal '["str", "ivar"]', %q{

def str_dup(str) = str.dup

str = "str"

RCLASSEXT_M_TBL(ext) = duplicate_classext_m_tbl(RCLASSEXT_M_TBL(orig), klass, dup_iclass);

}

if (RCLASSEXT_SHARED_CONST_TBL(orig)) {

runruby: $(PROGRAM) PHONY

RUBY_ON_BUG='gdb -x $(srcdir)/.gdbinit -p' $(RUNRUBY) $(RUNOPT0) $(TESTRUN_SCRIPT) $(RUNOPT)

parse: yes-fake miniruby$(EXEEXT) PHONY

$(BTESTRUBY) --dump=parsetree_with_comment,insns $(TESTRUN_SCRIPT)

yes-test-bundler: $(PREPARE_BUNDLER)

$(gnumake_recursive)$(XRUBY) \

-r./$(arch)-fake \

-r spec_helper $(RSPECOPTS) spec/bundler/$(BUNDLER_SPECS)

no-test-bundler:

imemo.$(OBJEXT): $(top_srcdir)/internal/sanitizers.h

imemo.$(OBJEXT): $(top_srcdir)/internal/serial.h

imemo.$(OBJEXT): $(top_srcdir)/internal/set_table.h

imemo.$(OBJEXT): $(top_srcdir)/internal/static_assert.h

imemo.$(OBJEXT): $(top_srcdir)/internal/variable.h

imemo.$(OBJEXT): $(top_srcdir)/internal/vm.h

re.$(OBJEXT): {$(VPATH)}node.h

re.$(OBJEXT): {$(VPATH)}onigmo.h

re.$(OBJEXT): {$(VPATH)}oniguruma.h

re.$(OBJEXT): {$(VPATH)}re.c

re.$(OBJEXT): {$(VPATH)}re.h

re.$(OBJEXT): {$(VPATH)}regenc.h

re.$(OBJEXT): {$(VPATH)}thread_native.h

re.$(OBJEXT): {$(VPATH)}util.h

re.$(OBJEXT): {$(VPATH)}vm_core.h

re.$(OBJEXT): {$(VPATH)}vm_opts.h

regcomp.$(OBJEXT): $(hdrdir)/ruby.h

regcomp.$(OBJEXT): $(hdrdir)/ruby/ruby.h

iobj->insn_id = BIN(opt_ary_freeze);

iobj->operand_size = 2;

iobj->operands = compile_data_calloc2(iseq, iobj->operand_size, sizeof(VALUE));

iobj->operands[1] = (VALUE)ci;

ELEM_REMOVE(next);

}

iobj->insn_id = BIN(opt_hash_freeze);

iobj->operand_size = 2;

iobj->operands = compile_data_calloc2(iseq, iobj->operand_size, sizeof(VALUE));

iobj->operands[1] = (VALUE)ci;

ELEM_REMOVE(next);

}

unsigned int flags = vm_ci_flag(ci);

if ((flags & set_flags) == set_flags && !(flags & unset_flags)) {

((INSN*)niobj)->insn_id = BIN(putobject);

const struct rb_callinfo *nci = vm_ci_new(vm_ci_mid(ci),

flags & ~VM_CALL_KW_SPLAT_MUT, vm_ci_argc(ci), vm_ci_kwarg(ci));

VALUE ast_value = rb_ruby_ast_new(RNODE(&scope_node));

rb_iseq_new_with_opt(ast_value, rb_iseq_base_label(iseq),

rb_iseq_path(iseq), rb_iseq_realpath(iseq),

nd_line(line_node), NULL, 0,

ISEQ_TYPE_METHOD, ISEQ_COMPILE_DATA(iseq)->option,

ISEQ_BODY(iseq)->variable.script_lines);

ALLOCV_END(idtmp);

return COMPILE_OK;

}

static struct iseq_catch_table *

{

if (size) {

struct iseq_catch_table *table = ruby_xmalloc(iseq_catch_table_bytes(size));

table->entries[i].cont = (unsigned int)ibf_load_small_value(load, &reading_pos);

table->entries[i].sp = (unsigned int)ibf_load_small_value(load, &reading_pos);

}

return table;

}

if (!ap->name) {

return -1;

return 1;

}

load_body->insns_info.body = ibf_load_insns_info_body(load, insns_info_body_offset, insns_info_size);

load_body->insns_info.positions = ibf_load_insns_info_positions(load, insns_info_positions_offset, insns_info_size);

load_body->local_table = ibf_load_local_table(load, local_table_offset, local_table_size);

// This must be done after the local table is loaded.

if (load_body->param.keyword != NULL) {

/*

* call-seq:

* to_c -> complex

*

* Returns +self+ as a Complex object.

rb_define_method(rb_cComplex, "to_r", nucomp_to_r, 0);

rb_define_method(rb_cComplex, "rationalize", nucomp_rationalize, -1);

rb_define_method(rb_cComplex, "to_c", nucomp_to_c, 0);

rb_define_method(rb_cNumeric, "to_c", numeric_to_c, 0);

rb_define_method(rb_cString, "to_c", string_to_c, 0);

RB_DEBUG_COUNTER(obj_imemo_callinfo)

RB_DEBUG_COUNTER(obj_imemo_callcache)

RB_DEBUG_COUNTER(obj_imemo_constcache)

RB_DEBUG_COUNTER(opt_new_hit)

RB_DEBUG_COUNTER(opt_new_miss)

The tarball for official releases is created by the release manager. The release manager uploads the tarball to the [Ruby website](https://www.ruby-lang.org/en/downloads/).

### Using the nightly tarball for testing

An output stream, initially <tt>$stdout</tt>.

=== <tt>$.</tt> (Input Position)

* https://github.com/rubygems/rubygems

* https://rubygems.org/gems/bundler

* *unmaintained*

#### lib/English.rb

#### ext/cgi

* Nobuyoshi Nakada ([nobu])

#### ext/date

## Libraries

- Bundler ([GitHub][bundler]): Manage your Ruby application's gem dependencies

- Delegator ([GitHub][delegate]): Provides three abilities to delegate method calls to an object

- DidYouMean ([GitHub][did_you_mean]): "Did you mean?" experience in Ruby

- English ([GitHub][English]): Provides references to special global variables with less cryptic names

[benchmark]: https://github.com/ruby/benchmark

[bigdecimal]: https://github.com/ruby/bigdecimal

[bundler]: https://github.com/rubygems/rubygems

[csv]: https://github.com/ruby/csv

[date]: https://github.com/ruby/date

[debug]: https://github.com/ruby/debug

RB_OBJ_WRITTEN(hash, Qundef, tally);

}

*value = (st_data_t)tally;

return ST_CONTINUE;

}

static VALUE

rb_enum_tally_up(VALUE hash, VALUE group)

{

return hash;

}

*/

VALUE rb_cEnumerator;

static VALUE rb_cLazy;

static ID id_next, id_result, id_receiver, id_arguments, id_memo, id_method, id_force;

static VALUE lazy_use_super_method;

return obj;

}

/*

* Document-class: Enumerator::ArithmeticSequence

*

rb_enumerator_size_func *size_fn,

VALUE beg, VALUE end, VALUE step, int excl)

{

obj, meth, argc, argv, size_fn, Qnil, rb_keyword_given_p());

return aseq;

}

static inline VALUE

arith_seq_begin(VALUE self)

{

}

/*

static inline VALUE

arith_seq_end(VALUE self)

{

}

/*

static inline VALUE

arith_seq_step(VALUE self)

{

}

/*

static inline VALUE

arith_seq_exclude_end(VALUE self)

{

}

static inline int

arith_seq_exclude_end_p(VALUE self)

{

}

int

Init_Enumerator(void)

{

id_rewind = rb_intern_const("rewind");

id_next = rb_intern_const("next");

id_result = rb_intern_const("result");

id_receiver = rb_intern_const("receiver");

id_force = rb_intern_const("force");

id_to_enum = rb_intern_const("to_enum");

id_each_entry = rb_intern_const("each_entry");

sym_each = ID2SYM(id_each);

sym_yield = ID2SYM(rb_intern_const("yield"));

InitVM(Enumerator);

if (simple_dat_p(x)) {

r = m_real_jd(x);

long ir = FIX2LONG(r);

ir = ir * 2 - 1;

return rb_rational_new2(LONG2FIX(ir), INT2FIX(2));

static VALUE

d_lite_hash(VALUE self)

{

get_d1(self);

v = rb_memhash(h, sizeof(h));

return ST2FIX(v);

}

m_of_in_day(dat),

DBL2NUM(m_sg(dat)));

return a;

}

INT2FIX(m_of(dat)),

DBL2NUM(m_sg(dat)));

return a;

}

HAVE_JD | HAVE_DF);

}

return self;

}

/* Command-line: gperf --ignore-case -L ANSI-C -C -c -P -p -j1 -i 1 -g -o -t -N zonetab zonetab.list */

/* Computed positions: -k'1-4,9' */

#ifndef GPERF_DOWNCASE

#define GPERF_DOWNCASE 1

{

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,

15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,

{

default:

hval += asso_values[(unsigned char)str[8]];

/*FALLTHROUGH*/

case 8:

case 7:

case 5:

case 4:

hval += asso_values[(unsigned char)str[3]];

/*FALLTHROUGH*/

case 3:

hval += asso_values[(unsigned char)str[2]];

/*FALLTHROUGH*/

case 2:

hval += asso_values[(unsigned char)str[1]+6];

/*FALLTHROUGH*/

case 1:

hval += asso_values[(unsigned char)str[0]+52];

const struct zone *

zonetab (register const char *str, register size_t len)

{

static const struct zone wordlist[] =

{

{-1}, {-1},

#line 141 "zonetab.list"

{(int)(size_t)&((struct stringpool_t *)0)->stringpool_str619, -10800}

};

if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)

{

}

}

}

}

#line 330 "zonetab.list"

# to string interpolation.

#

# Note: no validation is performed on the provided string. It is the

Fragment = Struct.new(:json) do

def initialize(json)

unless string = String.try_convert(json)

INIT_IMEMO_TYPE_ID(imemo_callinfo);

INIT_IMEMO_TYPE_ID(imemo_callcache);

INIT_IMEMO_TYPE_ID(imemo_constcache);

#undef INIT_IMEMO_TYPE_ID

}

dc->cur_obj = obj;

dc->cur_obj_references = 0;

dc->cur_obj_klass = 0;

dc->cur_obj_klass = RBASIC_CLASS(obj);

}

dump_append(dc, obj_type(obj));

dump_append(dc, "\"");

dump_append(dc, ", \"shape_id\":");

dump_append_sizet(dc, shape_id);

}

return;

}

dump_append(dc, "{\"address\":");

dump_append(dc, ", \"type\":\"SHAPE\", \"id\":");

dump_append_sizet(dc, shape_id);

dump_append(dc, ", \"parent_id\":");

}

dump_append(dc, ", \"depth\":");

dump_append_sizet(dc, rb_shape_depth(shape_id));

case SHAPE_ROOT:

dump_append(dc, ", \"shape_type\":\"ROOT\"");

break;

dump_append(dc, ", \"shape_type\":\"IVAR\"");

dump_append(dc, ",\"edge_name\":");

break;

case SHAPE_OBJ_ID:

#

# [:resolv_timeout] Specifies the timeout in seconds from when the hostname resolution starts.

# [:connect_timeout] This method sequentially attempts connecting to all candidate destination addresses.<br>The +connect_timeout+ specifies the timeout in seconds from the start of the connection attempt to the last candidate.<br>By default, all connection attempts continue until the timeout occurs.<br>When +fast_fallback:false+ is explicitly specified,<br>a timeout is set for each connection attempt and any connection attempt that exceeds its timeout will be canceled.

# [:fast_fallback] Enables the Happy Eyeballs Version 2 algorithm (enabled by default).

#

# If a block is given, the block is called with the socket.

# sock.close_write

# puts sock.read

# }

sock = if fast_fallback && !(host && ip_address?(host))

else

end

if block_given?

end

end

if local_host || local_port

local_addrinfos = Addrinfo.getaddrinfo(local_host, local_port, nil, :STREAM, timeout: resolv_timeout)

resolving_family_names = local_addrinfos.map { |lai| ADDRESS_FAMILIES.key(lai.afamily) }.uniq

resolution_delay_expires_at = nil

connection_attempt_delay_expires_at = nil

user_specified_connect_timeout_at = nil

last_error = nil

last_error_from_thread = false

ends_at =

if resolution_store.any_addrinfos?

else

[user_specified_resolv_timeout_at, user_specified_connect_timeout_at].compact.max

end

end

end

if resolution_store.empty_addrinfos?

if connecting_sockets.empty? && resolution_store.resolved_all_families?

if last_error_from_thread

end

end

last_error = nil

ret = nil

local_addr_list = Addrinfo.getaddrinfo(local_host, local_port, nil, :STREAM, nil)

end

if local_addr_list

local_addr = local_addr_list.find {|local_ai| local_ai.afamily == ai.afamily }

next unless local_addr

local_addr = nil

end

begin

sock = local_addr ?

rescue SystemCallError

last_error = $!

next

require 'mkmf'

if RUBY_ENGINE == 'ruby'

$INCFLAGS << " -I$(top_srcdir)" if $extmk

create_makefile 'strscan'

else

File.write('Makefile', dummy_makefile("").join)

# Replace %\w+% into the environment value of what is contained between the %'s

# This method is used for REG_EXPAND_SZ.

#

#

def self.expand_environ(str)

str.gsub(Regexp.compile("%([^%]+)%".encode(str.encoding))) {

ObjectSpace.define_finalizer self, @@final.call(@hkeyfinal)

end

attr_reader :parent

# Same as subkey value of Registry.open or

# Registry.create method.

# For each value it yields key, type and data.

#

# key is a String which contains name of key.

# data is the value of this key.

#

def each_value

#if RUBY_USE_STATX

unsigned int m = get_stat(self)->stx_dev_major;

unsigned int n = get_stat(self)->stx_dev_minor;

#elif SIZEOF_STRUCT_STAT_ST_DEV <= SIZEOF_DEV_T

return DEVT2NUM(get_stat(self)->st_dev);

#elif SIZEOF_STRUCT_STAT_ST_DEV <= SIZEOF_LONG

#if RUBY_USE_STATX

unsigned int m = get_stat(self)->stx_rdev_major;

unsigned int n = get_stat(self)->stx_rdev_minor;

#elif !defined(HAVE_STRUCT_STAT_ST_RDEV)

return Qnil;

#elif SIZEOF_STRUCT_STAT_ST_RDEV <= SIZEOF_DEV_T

struct classext_foreach_args {

VALUE klass;

rb_objspace_t *objspace; // used for update_*

};

rb_id_table_free(RCLASSEXT_M_TBL(ext));

rb_cc_tbl_free(RCLASSEXT_CC_TBL(ext), args->klass);

if (!RCLASSEXT_SHARED_CONST_TBL(ext) && (tbl = RCLASSEXT_CONST_TBL(ext)) != NULL) {

rb_free_const_table(tbl);

}

case T_MODULE:

case T_CLASS:

args.klass = obj;

rb_class_classext_foreach(obj, classext_free, (void *)&args);

if (RCLASS(obj)->ns_classext_tbl) {

st_free_table(RCLASS(obj)->ns_classext_tbl);

static inline void

obj_free_object_id(VALUE obj)

{

VALUE obj_id = 0;

if (RB_UNLIKELY(id2ref_tbl)) {

switch (BUILTIN_TYPE(obj)) {

case T_MODULE:

obj_id = RCLASS(obj)->object_id;

break;

shape_id_t shape_id = RBASIC_SHAPE_ID(obj);

if (rb_shape_has_object_id(shape_id)) {

obj_id = object_id_get(obj, shape_id);

}

break;

}

}

if (RB_UNLIKELY(obj_id)) {

RUBY_ASSERT(FIXNUM_P(obj_id) || RB_TYPE_P(obj_id, T_BIGNUM));

if (!st_delete(id2ref_tbl, (st_data_t *)&obj_id, NULL)) {

rb_bug("Object ID seen, but not in _id2ref table: object_id=%llu object=%s", NUM2ULL(obj_id), rb_obj_info(obj));

}

}

{

obj_free_object_id(obj);

}

switch (BUILTIN_TYPE(obj)) {

}

static void

classext_superclasses_memsize(rb_classext_t *ext, bool prime, VALUE namespace, void *arg)

{

size_t *size = (size_t *)arg;

return 0;

}

switch (BUILTIN_TYPE(obj)) {

case T_OBJECT:

if (rb_shape_obj_too_complex_p(obj)) {

case T_MODULE:

case T_CLASS:

rb_class_classext_foreach(obj, classext_memsize, (void *)&size);

rb_class_classext_foreach(obj, classext_superclasses_memsize, (void *)&size);

break;

case T_ICLASS:

MARK_CHECKPOINT("vm");

rb_vm_mark(vm);

MARK_CHECKPOINT("end_proc");

rb_mark_end_proc();

gc_mark_internal(RCLASSEXT_SUPER(ext));

}

mark_m_tbl(objspace, RCLASSEXT_M_TBL(ext));

if (!RCLASSEXT_SHARED_CONST_TBL(ext) && RCLASSEXT_CONST_TBL(ext)) {

mark_const_tbl(objspace, RCLASSEXT_CONST_TBL(ext));

}

{

struct gc_mark_classext_foreach_arg foreach_args;

rb_mark_generic_ivar(obj);

}

foreach_args.objspace = objspace;

foreach_args.obj = obj;

rb_class_classext_foreach(obj, gc_mark_classext_module, (void *)&foreach_args);

break;

case T_ICLASS:

update_classext(rb_classext_t *ext, bool is_prime, VALUE namespace, void *arg)

{

struct classext_foreach_args *args = (struct classext_foreach_args *)arg;

rb_objspace_t *objspace = args->objspace;

if (RCLASSEXT_SUPER(ext)) {

update_m_tbl(objspace, RCLASSEXT_M_TBL(ext));

if (!RCLASSEXT_SHARED_CONST_TBL(ext)) {

update_const_tbl(objspace, RCLASSEXT_CONST_TBL(ext));

}

return iter_data->update_callback((VALUE *)value, iter_data->data);

}

struct st_table *rb_generic_fields_tbl_get(void);

static int

int ret = iter_data->callback((VALUE)key, iter_data->data);

switch (ret) {

case ST_CONTINUE:

break;

case ST_DELETE:

return ST_DELETE;

case ST_REPLACE: {

ret = iter_data->update_callback(&new_key, iter_data->data);

}

break;

}

default:

}

if (!iter_data->weak_only) {

}

}

}

return ret;

break;

}

case RB_GC_VM_WEAK_TABLE_COUNT:

default:

rb_bug("rb_gc_vm_weak_table_foreach: unknown table %d", table);

}

// Continue to the shared T_CLASS/T_MODULE

case T_MODULE:

args.klass = obj;

args.objspace = objspace;

rb_class_classext_foreach(obj, update_classext, (void *)&args);

break;

const HIDDEN_SIZE_MASK: usize = 0x0000FFFFFFFFFFFF;

// An opaque type for the C counterpart.

#[allow(non_camel_case_types)]

pub struct st_table;

unsafe { self.flags_field().load::<usize>() }

}

pub fn prefix_size() -> usize {

// Currently, a hidden size field of word size is placed before each object.

OBJREF_OFFSET

rexml 3.4.1 https://github.com/ruby/rexml

rss 0.3.1 https://github.com/ruby/rss

net-ftp 0.3.8 https://github.com/ruby/net-ftp

net-pop 0.1.2 https://github.com/ruby/net-pop

net-smtp 0.5.1 https://github.com/ruby/net-smtp

rbs 3.9.4 https://github.com/ruby/rbs

typeprof 0.30.1 https://github.com/ruby/typeprof

racc 1.8.1 https://github.com/ruby/racc

mutex_m 0.3.0 https://github.com/ruby/mutex_m

getoptlong 0.2.1 https://github.com/ruby/getoptlong

syslog 0.3.0 https://github.com/ruby/syslog

csv 3.3.5 https://github.com/ruby/csv

repl_type_completor 0.1.11 https://github.com/ruby/repl_type_completor 25108aa8d69ddaba0b5da3feff1c0035371524b2

pstore 0.2.0 https://github.com/ruby/pstore

benchmark 0.4.1 https://github.com/ruby/benchmark

logger 1.7.0 https://github.com/ruby/logger

win32ole 1.9.2 https://github.com/ruby/win32ole

reline 0.6.1 https://github.com/ruby/reline

readline 0.0.4 https://github.com/ruby/readline

fiddle 1.1.8 https://github.com/ruby/fiddle

rb_hash_dup(VALUE hash)

{

const VALUE flags = RBASIC(hash)->flags;

rb_copy_generic_ivar(ret, hash);

return ret;

}

VALUE

rb_hash_key_str(VALUE key)

{

return rb_fstring(key);

}

else {

}

rb_ary_set_len(values, size);

}

else {

rb_hash_foreach(hash, values_i, values);

}

#include "id_table.h"

#include "internal.h"

#include "internal/imemo.h"

#include "vm_callinfo.h"

size_t rb_iseq_memsize(const rb_iseq_t *iseq);

IMEMO_NAME(svar);

IMEMO_NAME(throw_data);

IMEMO_NAME(tmpbuf);

#undef IMEMO_NAME

}

}

/* =========================================================================

return tmpbuf;

}

/* =========================================================================

* memsize

* ========================================================================= */

size += ((rb_imemo_tmpbuf_t *)obj)->cnt * sizeof(VALUE);

break;

default:

rb_bug("unreachable");

}

break;

}

default:

rb_bug("unreachable");

}

rb_id_table_free(cc_tbl);

}

void

rb_imemo_free(VALUE obj)

{

break;

case imemo_svar:

RB_DEBUG_COUNTER_INC(obj_imemo_svar);

break;

case imemo_throw_data:

RB_DEBUG_COUNTER_INC(obj_imemo_throw_data);

RB_DEBUG_COUNTER_INC(obj_imemo_tmpbuf);

break;

default:

rb_bug("unreachable");

}

= 0,

/**

* This flag has something to do with Ractor. Multiple Ractors run without

* protecting each other. Sharing an object among Ractors are basically

* dangerous, disabled by default. This flag is used to bypass that

*/

RUBY_FL_UNUSED9 = (1<<9),

/**

* This flag has something to do with data immutability. When this flag is

# pragma deprecated(RUBY_FL_DUPPED)

#endif

};

#undef RBIMPL_HAVE_ENUM_ATTRIBUTE

struct rb_classext_struct {

const rb_namespace_t *ns;

VALUE super;

struct rb_id_table *m_tbl;

struct rb_id_table *const_tbl;

struct rb_id_table *callable_m_tbl;

#define RCLASSEXT_NS(ext) (ext->ns)

#define RCLASSEXT_SUPER(ext) (ext->super)

#define RCLASSEXT_M_TBL(ext) (ext->m_tbl)

#define RCLASSEXT_CONST_TBL(ext) (ext->const_tbl)

#define RCLASSEXT_CALLABLE_M_TBL(ext) (ext->callable_m_tbl)

#define RCLASS_PRIME_NS(c) (RCLASS_EXT_PRIME(c)->ns)

// To invalidate CC by inserting&invalidating method entry into tables containing the target cme

// See clear_method_cache_by_id_in_class()

#define RCLASS_PRIME_M_TBL(c) (RCLASS_EXT_PRIME(c)->m_tbl)

#define RCLASS_PRIME_CONST_TBL(c) (RCLASS_EXT_PRIME(c)->const_tbl)

#define RCLASS_PRIME_CALLABLE_M_TBL(c) (RCLASS_EXT_PRIME(c)->callable_m_tbl)

static inline void RCLASS_SET_SUPER(VALUE klass, VALUE super);

static inline void RCLASS_WRITE_SUPER(VALUE klass, VALUE super);

// TODO: rename RCLASS_SET_M_TBL_WORKAROUND (and _WRITE_) to RCLASS_SET_M_TBL with write barrier

static inline void RCLASS_SET_M_TBL_WORKAROUND(VALUE klass, struct rb_id_table *table, bool check_promoted);

static inline void RCLASS_WRITE_M_TBL_WORKAROUND(VALUE klass, struct rb_id_table *table, bool check_promoted);

if (ext)

return ext;

RB_VM_LOCKING() {

// re-check the classext is not created to avoid the multi-thread race

ext = RCLASS_EXT_TABLE_LOOKUP_INTERNAL(obj, ns);

RCLASS_EXT_WRITABLE(VALUE obj)

{

const rb_namespace_t *ns;

return RCLASS_EXT_PRIME(obj);

}

// delay namespace loading to optimize for unmodified classes

RB_OBJ_WRITE(klass, &RCLASSEXT_SUPER(RCLASS_EXT_WRITABLE(klass)), super);

}

{

RUBY_ASSERT(RB_TYPE_P(obj, RUBY_T_CLASS) || RB_TYPE_P(obj, RUBY_T_MODULE));

}

{

RUBY_ASSERT(RB_TYPE_P(obj, RUBY_T_CLASS) || RB_TYPE_P(obj, RUBY_T_MODULE));

}

static inline void

{

RUBY_ASSERT(RB_TYPE_P(obj, RUBY_T_CLASS) || RB_TYPE_P(obj, RUBY_T_MODULE));

}

static inline void

{

RUBY_ASSERT(RB_TYPE_P(obj, RUBY_T_CLASS) || RB_TYPE_P(obj, RUBY_T_MODULE));

}

static inline uint32_t

RCLASS_FIELDS_COUNT(VALUE obj)

{

RUBY_ASSERT(RB_TYPE_P(obj, RUBY_T_CLASS) || RB_TYPE_P(obj, RUBY_T_MODULE));

}

}

}

#define RCLASS_SET_M_TBL_EVEN_WHEN_PROMOTED(klass, table) RCLASS_SET_M_TBL_WORKAROUND(klass, table, false)

imemo_callinfo = 11,

imemo_callcache = 12,

imemo_constcache = 13,

};

/* CREF (Class REFerence) is defined in method.h */

RB_OBJ_WRITE(m, &m->v2, v);

}

#endif /* INTERNAL_IMEMO_H */

#endif

/* string.c */

VALUE rb_fstring(VALUE);

VALUE rb_fstring_cstr(const char *str);

VALUE rb_fstring_enc_new(const char *ptr, long len, rb_encoding *enc);

int rb_threadptr_execute_interrupts(struct rb_thread_struct *th, int blocking_timing);

bool rb_thread_mn_schedulable(VALUE thread);

// interrupt exec

typedef VALUE (rb_interrupt_exec_func_t)(void *data);

enum rb_interrupt_exec_flag {

rb_interrupt_exec_flag_none = 0x00,

rb_interrupt_exec_flag_value_data = 0x01,

};

// interrupt the target_th and run func.

#include "constant.h" /* for rb_const_entry_t */

#include "ruby/internal/stdbool.h" /* for bool */

#include "ruby/ruby.h" /* for VALUE */

/* variable.c */

void rb_gc_mark_global_tbl(void);

void rb_gc_update_global_tbl(void);

VALUE rb_search_class_path(VALUE);

VALUE rb_attr_delete(VALUE, ID);

void rb_autoload_str(VALUE mod, ID id, VALUE file);

*/

VALUE rb_mod_set_temporary_name(VALUE, VALUE);

void rb_obj_copy_ivs_to_hash_table(VALUE obj, st_table *table);

void rb_obj_init_too_complex(VALUE obj, st_table *table);

void rb_evict_ivars_to_hash(VALUE obj);

}

static void

rb_io_buffer_type_free(void *_buffer)

{

struct rb_io_buffer *buffer = _buffer;

return total;

}

static const rb_data_type_t rb_io_buffer_type = {

.wrap_struct_name = "IO::Buffer",

.function = {

.dfree = rb_io_buffer_type_free,

.dsize = rb_io_buffer_type_size,

},

.data = NULL,

};

static inline enum rb_io_buffer_flags

arguments->instance = io_buffer_for_make_instance(arguments->klass, arguments->string, arguments->flags);

return rb_yield(arguments->instance);

}

rb_io_buffer_free(arguments->instance);

}

return Qnil;

}

body->local_iseq = iseq;

}

else if (piseq) {

}

if (piseq) {

}

if (type == ISEQ_TYPE_MAIN) {

if man_pages.include?(command)

man_page = man_pages[command]

Kernel.exec("man", man_page)

else

puts File.read("#{man_path}/#{File.basename(man_page)}.ronn")

end

end

desc "viz [OPTIONS]", "Generates a visual dependency graph", hide: true

long_desc <<-D

Viz generates a PNG file of the current Gemfile as a dependency graph.

end

message = "Using the `config` command without a subcommand [list, get, set, unset] is deprecated and will be removed in the future. Use `bundle #{new_args.join(" ")}` instead."

Base.new(options, name, value, self).run

end

Plugin.gemfile_install(Bundler.default_gemfile) if Bundler.feature_flag.plugins?

definition.validate_runtime!

installer = Installer.install(Bundler.root, definition, options)

if Bundler.feature_flag.update_requires_all_flag?

raise InvalidOption, "To update everything, pass the `--all` flag."

end

elsif !full_update && options[:all]

raise InvalidOption, "Cannot specify --all along with specific options."

end

if unlock == true

@unlocking_all = true

@unlocking_bundler = false

@unlocking = unlock

@sources_to_unlock = []

conservative = false

else

@unlocking_all = false

@unlocking_bundler = unlock.delete(:bundler)

@unlocking = unlock.any? {|_k, v| !Array(v).empty? }

@sources_to_unlock = unlock.delete(:sources) || []

if lockfile_exists?

@lockfile_contents = Bundler.read_file(lockfile)

@locked_platforms = @locked_gems.platforms

@most_specific_locked_platform = @locked_gems.most_specific_locked_platform

@platforms = @locked_platforms.dup

end

def multiple_global_source_warning

msg = "This Gemfile contains multiple global sources. " \

"Each source after the first must include a block to indicate which gems " \

"should come from that source"

BUNDLER_KEYS = %w[

BUNDLE_BIN_PATH

BUNDLE_GEMFILE

BUNDLER_VERSION

BUNDLER_SETUP

GEM_HOME

(1..10).each {|v| define_method("bundler_#{v}_mode?") { @major_version >= v } }

settings_flag(:plugins) { @bundler_version >= Gem::Version.new("1.14") }

def initialize(bundler_version)

@bundler_version = Gem::Version.create(bundler_version)

lazy_spec

end

@name = name

@version = version

@dependencies = []

@original_source = source

@source = source

@force_ruby_platform = default_force_ruby_platform

@most_specific_locked_platform = nil

# Validate dependencies of this locked spec are consistent with dependencies

# of the actual spec that was materialized.

#

# accept what's in the lockfile instead for performance, since loading

# dependencies of locally installed gems would mean evaluating all gemspecs,

# which would affect `bundler/setup` performance.

def validate_dependencies(spec)

spec.dependencies = dependencies

else

if !source.is_a?(Source::Path) && spec.runtime_dependencies.sort != dependencies.sort

lockfile_contents.split(BUNDLED).last.strip

end

@platforms = []

@sources = []

@dependencies = {}

"Gemfile.lock"

end

@pos = Position.new(1, 1)

if lockfile.match?(/<<<<<<<|=======|>>>>>>>|\|\|\|\|\|\|\|/)

raise LockfileError, "Your #{@lockfile_path} contains merge conflicts.\n" \

version = Gem::Version.new(version)

platform = platform ? Gem::Platform.new(platform) : Gem::Platform::RUBY

@current_source.add_dependency_names(name)

@specs[@current_spec.full_name] = @current_spec

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-add\fR \- Add gem to the Gemfile and run bundle install

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-binstubs\fR \- Install the binstubs of the listed gems

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-cache\fR \- Package your needed \fB\.gem\fR files into your application

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-check\fR \- Verifies if dependencies are satisfied by installed gems

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-clean\fR \- Cleans up unused gems in your bundler directory

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-config\fR \- Set bundler configuration options

.SH "SYNOPSIS"

Any periods in the configuration keys must be replaced with two underscores when setting it via environment variables\. The configuration key \fBlocal\.rack\fR becomes the environment variable \fBBUNDLE_LOCAL__RACK\fR\.

.SH "LIST OF AVAILABLE KEYS"

The following is a list of all configuration keys and their purpose\. You can learn more about their operation in bundle install(1) \fIbundle\-install\.1\.html\fR\.

.SH "REMEMBERING OPTIONS"

Flags passed to \fBbundle install\fR or the Bundler runtime, such as \fB\-\-path foo\fR or \fB\-\-without production\fR, are remembered between commands and saved to your local application's configuration (normally, \fB\./\.bundle/config\fR)\.

.P

will be installed by `bundle install`. Defaults to `Gem.dir`.

* `path.system` (`BUNDLE_PATH__SYSTEM`):

Whether Bundler will install gems into the default system path (`Gem.dir`).

Makes `--path` relative to the CWD instead of the `Gemfile`.

* `plugins` (`BUNDLE_PLUGINS`):

Enable Bundler's experimental plugin system.

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-console\fR \- Open an IRB session with the bundle pre\-loaded

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-doctor\fR \- Checks the bundle for common problems

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-env\fR \- Print information about the environment Bundler is running under

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-exec\fR \- Execute a command in the context of the bundle

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-fund\fR \- Lists information about gems seeking funding assistance

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-gem\fR \- Generate a project skeleton for creating a rubygem

.SH "SYNOPSIS"

\fBgem\.test\fR

.IP "" 0

.SH "OPTIONS"

.IP

When Bundler is configured to generate tests, this defaults to Bundler's global config setting \fBgem\.test\fR\.

.IP

When Bundler is configured to not generate tests, an interactive prompt will be displayed and the answer will be used for the current rubygem project\.

.IP

When Bundler is unconfigured, an interactive prompt will be displayed and the answer will be saved in Bundler's global config for future \fBbundle gem\fR use\.

.IP

When Bundler is configured to generate CI files, this defaults to Bundler's global config setting \fBgem\.ci\fR\.

.IP

When Bundler is configured to not generate CI files, an interactive prompt will be displayed and the answer will be used for the current rubygem project\.

.IP

When Bundler is unconfigured, an interactive prompt will be displayed and the answer will be saved in Bundler's global config for future \fBbundle gem\fR use\.

.IP

When Bundler is configured to add a linter, this defaults to Bundler's global config setting \fBgem\.linter\fR\.

.IP

When Bundler is configured not to add a linter, an interactive prompt will be displayed and the answer will be used for the current rubygem project\.

.IP

When Bundler is unconfigured, an interactive prompt will be displayed and the answer will be saved in Bundler's global config for future \fBbundle gem\fR use\.

.SH "SEE ALSO"

.IP "\(bu" 4

bundle config(1) \fIbundle\-config\.1\.html\fR

Do not create a `CODE_OF_CONDUCT.md` (overrides `--coc` specified in the

global config).

Add a `CHANGELOG.md` file to the root of the generated project. If

this option is unspecified, an interactive prompt will be displayed and the

answer will be saved in Bundler's global config for future `bundle gem` use.

* `--no-changelog`:

Do not create a `CHANGELOG.md` (overrides `--changelog` specified in the

Do not use a test framework (overrides `--test` specified in the global

config).

* `--ci`, `--ci=circle`, `--ci=github`, `--ci=gitlab`:

Specify the continuous integration service that Bundler should use when

generating the project. Acceptable values are `github`, `gitlab`

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-help\fR \- Displays detailed help for each subcommand

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-info\fR \- Show information for the given gem in your bundle

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-init\fR \- Generates a Gemfile into the current working directory

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-inject\fR \- Add named gem(s) with version requirements to Gemfile

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-install\fR \- Install the dependencies specified in your Gemfile

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-issue\fR \- Get help reporting Bundler issues

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-licenses\fR \- Print the license of all gems in the bundle

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-list\fR \- List all the gems in the bundle

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-lock\fR \- Creates / Updates a lockfile without installing

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-open\fR \- Opens the source directory for a gem in your bundle

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-outdated\fR \- List installed gems with newer versions available

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-platform\fR \- Displays platform compatibility information

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-plugin\fR \- Manage Bundler plugins

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-pristine\fR \- Restores installed gems to their pristine condition

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-remove\fR \- Removes gems from the Gemfile

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-show\fR \- Shows all the gems in your bundle, or the path to a gem

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-update\fR \- Update your gems to the latest available versions

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-version\fR \- Prints Bundler version information

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\-viz\fR \- Generates a visual dependency graph for your Gemfile

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBbundle\fR \- Ruby Dependency Management

.SH "SYNOPSIS"

.\" generated with Ronn-NG/v0.10.1

.\" http://github.com/apjanke/ronn-ng/tree/0.10.1

.SH "NAME"

\fBGemfile\fR \- A format for describing gem dependencies for Ruby programs

.SH "SYNOPSIS"

end

end

private

def dependencies_to_gemfile(dependencies, group = nil)

# Used to give better error messages when activating specs outside of the current bundle

def replace_bin_path(specs_by_name)

redefine_method(gem_class, :find_spec_for_exe) do |gem_name, *args|

exec_name = args.first

raise ArgumentError, "you must supply exec_name" unless exec_name

Gem::Specification.all = specs

end

[]

end

end

def plain_specs

def default_stubs

Gem::Specification.default_stubs("*.gemspec")

end

end

def self.rubygems

def autoswitching_applies?

ENV["BUNDLER_VERSION"].nil? &&

ruby_can_restart_with_same_arguments? &&

lockfile_version

end

def capture3_args_for(cmd, dir)

return ["git", *cmd] unless dir

["git", "-C", dir.to_s, *cmd]

else

["git", *cmd, { chdir: dir.to_s }]

next unless spec = load_gemspec(file)

spec.source = self

# Validation causes extension_dir to be calculated, which depends

# on #source, so we validate here instead of load_gemspec

validate_spec(spec)

if previous_source.nil?

requirements[indirect_dependency_name] = source

else

msg = ["The gem '#{indirect_dependency_name}' was found in multiple relevant sources."]

msg.concat [previous_source, source].map {|s| " * #{s}" }.sort

steps:

- uses: actions/checkout@v4

<%- if config[:ext] == 'rust' -%>

- name: Set up Ruby & Rust

uses: oxidize-rb/actions/setup-ruby-and-rust@v1

# frozen_string_literal: false

module Bundler

def self.bundler_major_version

@bundler_major_version ||= VERSION.split(".").first.to_i

"\#<#{self.class} #{@method}>"

end

##

# Don't automatically decode response content-encoding if the user indicates

# they want to handle it.

def send_request_with_body(sock, ver, path, body)

self.content_length = body.bytesize

delete 'Transfer-Encoding'

write_header sock, ver, path

wait_for_continue sock, ver if sock.continue_timeout

sock.write body

raise ArgumentError,

"Content-Length not given and Transfer-Encoding is not `chunked'"

end

write_header sock, ver, path

wait_for_continue sock, ver if sock.continue_timeout

if chunked?

buf.clear

end

##

# Waits up to the continue timeout for a response from the server provided

# we're speaking HTTP 1.1 and are expecting a 100-continue response.

end

end

"lib/prism/pattern.rb",

"lib/prism/polyfill/append_as_bytes.rb",

"lib/prism/polyfill/byteindex.rb",

"lib/prism/polyfill/unpack1.rb",

"lib/prism/polyfill/warn.rb",

"lib/prism/reflection.rb",

require "strscan"

require_relative "../../polyfill/append_as_bytes"

module Prism

module Translation

elsif (value = scanner.scan(/M-\\?(?=[[:print:]])/))

# \M-x where x is an ASCII printable character

escape_read(result, scanner, control, true)

# Something else after an escape.

result.append_as_bytes(escape_build(0x7f, false, meta))

else

end

end

end

ENV["BUNDLE_GEMFILE"] ||= File.expand_path(path)

require_relative "rubygems/user_interaction"

begin

Gem::DefaultUserInteraction.use_ui(ui) do

Bundler.ui.silence do

specs.group_by(&:full_name_with_location).values.each do |grouped_specs|

spec = grouped_specs.find {|s| !s.default_gem? } || grouped_specs.first

# Default gemspecs include changes provided by ruby-core installer that

# can't currently be pristined (inclusion of compiled extension targets in

# the file list). So stick to resetting executables if it's a default gem.

end

if options.key? :skip

end

end

say "Skipped #{spec.full_name_with_location}, it needs to compile an extension"

next

end

gem = spec.cache_file

require_relative "../remote_fetcher"

say "Cached gem for #{spec.full_name_with_location} not found, attempting to fetch..."

bin_dir: bin_dir,

}

installer = Gem::Installer.for_spec(spec, installer_options)

installer.generate_bin

installer = Gem::Installer.for_spec(spec, installer_options)

installer.generate_plugins

else

say "Restored #{spec.full_name_with_location}"

end

end

end

# mkmf work properly.

def linker_args

cc_flag = self.class.shellsplit(makefile_config("CC"))

linker = cc_flag.shift

link_args = cc_flag.flat_map {|a| ["-C", "link-arg=#{a}"] }

# Install requested gems after they have been downloaded

sorted_requests.each do |req|

req.spec.spec.build_extensions

end

spec =

sources.each do |source|

groups[source].

map {|spec| ActivationRequest.new spec, dependency }.

each {|activation_request| activation_requests << activation_request }

end