# Contributor: Carlo Landmeter <clandmeter@gmail.com>
# Contributor: Jakub Jirutka <jakub@jirutka.cz>
# Maintainer: Natanael Copa <ncopa@alpinelinux.org>
#
# secfixes:
#   2.4.2-r0:
#     - CVE-2017-0898
#     - CVE-2017-10784
#     - CVE-2017-14033
#     - CVE-2017-14064
#     - CVE-2017-0899
#     - CVE-2017-0900
#     - CVE-2017-0901
#     - CVE-2017-0902
#
global pkgname := 'ruby'
global pkgver := '2.4.2'
global _abiver := ""$(pkgver%.*).0""
global pkgrel := '0'
global pkgdesc := '"An object-oriented language for quick and easy programming'"
global url := '"http://www.ruby-lang.org/en/'"
global arch := '"all'"
global license := '"Ruby'"
global depends := '"ca-certificates'"
global depends_dev := '"gmp-dev'"
global makedepends := ""$depends_dev zlib-dev libressl-dev gdbm-dev db-dev readline-dev
	libffi-dev coreutils yaml-dev linux-headers autoconf""
global subpackages := ""$pkgname-doc $pkgname-dev
	$pkgname-bigdecimal::noarch
	$pkgname-did_you_mean::noarch
	$pkgname-io-console:io_console
	$pkgname-irb::noarch
	$pkgname-json
	$pkgname-minitest::noarch
	$pkgname-net-telnet:net_telnet:noarch
	$pkgname-power_assert::noarch
	$pkgname-rake::noarch
	$pkgname-rdoc::noarch
	$pkgname-test-unit:test_unit:noarch
	$pkgname-xmlrpc::noarch
	$pkgname-libs
	""
global source := ""ftp://ftp.ruby-lang.org/pub/ruby/$(pkgver%.*)/$pkgname-$pkgver.tar.bz2
	rubygems-avoid-platform-specific-gems.patch""
global options := '"!fhs'"
global replaces := '"ruby-gems'"
global builddir := ""$srcdir/$pkgname-$pkgver""

global _gemdir := ""/usr/lib/ruby/gems/$_abiver""
global _rubydir := ""/usr/lib/ruby/$_abiver""
global _chost := $(CHOST/-alpine-/-)

matchstr $CARCH {
	x86 { global _arch := '"i386'"}
	* { global _arch := $CARCH}
}

proc prepare {
	default_prepare

	cd $builddir
	autoconf
}

proc build {
	cd $builddir

	# -fomit-frame-pointer makes ruby segfault, see gentoo bug #150413
	# In many places aliasing rules are broken; play it safe
	# as it's risky with newer compilers to leave it as it is.
	export CFLAGS="$CFLAGS -fno-omit-frame-pointer -fno-strict-aliasing"
	export CPPFLAGS="$CPPFLAGS -fno-omit-frame-pointer -fno-strict-aliasing"

	# ruby saves path to install. we want use $PATH
	export INSTALL=install

	# the configure script does not detect isnan/isinf as macros
	export ac_cv_func_isnan=yes
	export ac_cv_func_isinf=yes

	./configure \
		--build=$CBUILD \
		--host=$CHOST \
		--prefix=/usr \
		--sysconfdir=/etc \
		--mandir=/usr/share/man \
		--infodir=/usr/share/info \
		--with-sitedir='/usr/local/lib/site_ruby' \
		--with-search-path="/usr/lib/site_ruby/\$(ruby_ver)/$_arch-linux" \
		--enable-pthread \
		--disable-rpath \
		--enable-shared \
		--with-mantype=man
	make
}

proc check {
	cd $builddir
	make test
}

proc package {
	cd $builddir

	make DESTDIR="$pkgdir" install

	install -m 644 -D COPYING \
		"$pkgdir"/usr/share/licenses/$pkgname/COPYING

	rm -R "$pkgdir"$_gemdir/cache/*

	# Remove bundled CA certificates.
	rm -R "$pkgdir"$_rubydir/rubygems/ssl_certs/*.pem || true

	if test -d "$pkgdir"/usr/local {
		var f = $[cd $pkgdir ; find usr/local -type f]
		if test -n $f {
			error "Found files in /usr/local:"
			echo $f
			return 1
		}
	}
}

proc bigdecimal {
	global pkgdesc := '"Ruby arbitrary-precision floating point decimal arithmetic'"
	global depends := $pkgname

	_mvgem bigdecimal
}

proc did_you_mean {
	global pkgdesc := '"Did you mean? experience in Ruby'"
	global depends := $pkgname

	_mvgem did_you_mean
}

proc io_console {
	global pkgdesc := '"Ruby simple console IO library'"
	global depends := $pkgname

	_mvgem io-console
	_mv $_rubydir/io \
		$_rubydir/$_chost/io/console.so
}

proc irb {
	global pkgdesc := '"The Interactive Ruby'"
	global replaces := $pkgname
	global depends := $pkgname

	cd $pkgdir
	_mv usr/bin/irb \
		usr/lib/ruby/$_abiver/irb*
}

proc json {
	global pkgdesc := '"JSON implementation as a Ruby extension in C'"
	global depends := $pkgname

	_mvgem json
}

proc minitest {
	global pkgdesc := '"Ruby suite of testing facilities'"
	global depends := $pkgname

	_mvgem minitest
}

proc net_telnet {
	global pkgdesc := '"Telnet client functionality for Ruby'"
	global depends := $pkgname

	_mvgem net-telnet
}

proc power_assert {
	global pkgdesc := '"Power Assert for Ruby'"
	global depends := $pkgname

	_mvgem power_assert
}

proc rake {
	global pkgdesc := '"Ruby based make-like utility'"
	global depends := $pkgname

	_mvgem rake || return 1
	_mv usr/bin/rake
}

proc rdoc {
	global pkgdesc := '"Ruby documentation tool'"
	global depends := ""$pkgname $pkgname-json $pkgname-io-console""

	_mvgem rdoc || return 1
	_mv usr/bin/ri \
		usr/bin/rdoc
}

proc test_unit {
	global pkgdesc := '"An xUnit family unit testing framework for Ruby'"
	global depends := ""$pkgname $pkgname-power_assert""

	_mvgem test-unit
}

proc xmlrpc {
	global pkgdesc := '"XMLRPC library for Ruby'"
	global depends := $pkgname

	_mvgem xmlrpc
}

proc libs {
	global pkgdesc := '"Libraries necessary to run Ruby'"
	global depends := ''""

	mkdir -p "$subpkgdir"/usr
	mv "$pkgdir"/usr/lib "$subpkgdir"/usr/
}

proc _mv {
	var i = ''; for i in [@Argv] {
		mkdir -p "$subpkgdir"/$(i%/*)
		mv "$pkgdir"/$(i) "$subpkgdir"/$(i%/*)/ || return 1
	}
}

proc _mvgem {
	cd $pkgdir
	var path = ''; for path in [./$_rubydir/$(1).rb \
			./$_rubydir/$(1) \
			./$_rubydir/$_chost/$(1) \
			./$_gemdir/gems/$(1)-* \
			./$_gemdir/specifications/$(1)-* \
			./$_gemdir/specifications/default/$(1)-*]  {
		test ! -e "$pkgdir/$path" || _mv $path
	}
}

global sha512sums := '"1a5302d2558089a6b91b815fff9b75a29e690f10861de5fdd48211f3f45025a70dad7495f216e6af9c62d72e69ed316f1a52fada704bdc7e6d8c094d141ea77c  ruby-2.4.2.tar.bz2
cfdc5ea3b2e2ea69c51f38e8e2180cb1dc27008ca55cc6301f142ebafdbab31c3379b3b6bba9ff543153876dd98ed2ad194df3255b7ea77a62e931c935f80538  rubygems-avoid-platform-specific-gems.patch'"
(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:pkgname) op:Equal rhs:{(ruby)} spids:[45])]
      spids: [45]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:pkgver) op:Equal rhs:{(2.4.2)} spids:[48])]
      spids: [48]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_abiver)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name pkgver>
                  suffix_op: (StringUnary op_id:VOp1_Percent arg_word:{(".*")})
                  spids: [53 57]
                ) (.0)
              )
            }
          spids: [51]
        )
      ]
      spids: [51]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:pkgrel) op:Equal rhs:{(0)} spids:[61])]
      spids: [61]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:pkgdesc)
          op: Equal
          rhs: {(DQ ("An object-oriented language for quick and easy programming"))}
          spids: [64]
        )
      ]
      spids: [64]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:url)
          op: Equal
          rhs: {(DQ ("http://www.ruby-lang.org/en/"))}
          spids: [69]
        )
      ]
      spids: [69]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:arch) op:Equal rhs:{(DQ (all))} spids:[74])]
      spids: [74]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:license) op:Equal rhs:{(DQ (Ruby))} spids:[79])]
      spids: [79]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:depends)
          op: Equal
          rhs: {(DQ (ca-certificates))}
          spids: [84]
        )
      ]
      spids: [84]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:depends_dev) op:Equal rhs:{(DQ (gmp-dev))} spids:[89])]
      spids: [89]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:makedepends)
          op: Equal
          rhs: 
            {
              (DQ ($ VSub_Name "$depends_dev") 
                (" zlib-dev libressl-dev gdbm-dev db-dev readline-dev\n") ("\tlibffi-dev coreutils yaml-dev linux-headers autoconf")
              )
            }
          spids: [94]
        )
      ]
      spids: [94]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:subpackages)
          op: Equal
          rhs: 
            {
              (DQ ($ VSub_Name "$pkgname") ("-doc ") ($ VSub_Name "$pkgname") ("-dev\n") ("\t") 
                ($ VSub_Name "$pkgname") ("-bigdecimal::noarch\n") ("\t") ($ VSub_Name "$pkgname") ("-did_you_mean::noarch\n") ("\t") 
                ($ VSub_Name "$pkgname") ("-io-console:io_console\n") ("\t") ($ VSub_Name "$pkgname") ("-irb::noarch\n") ("\t") 
                ($ VSub_Name "$pkgname") ("-json\n") ("\t") ($ VSub_Name "$pkgname") ("-minitest::noarch\n") ("\t") ($ VSub_Name "$pkgname") 
                ("-net-telnet:net_telnet:noarch\n") ("\t") ($ VSub_Name "$pkgname") ("-power_assert::noarch\n") ("\t") ($ VSub_Name "$pkgname") 
                ("-rake::noarch\n") ("\t") ($ VSub_Name "$pkgname") ("-rdoc::noarch\n") ("\t") ($ VSub_Name "$pkgname") 
                ("-test-unit:test_unit:noarch\n") ("\t") ($ VSub_Name "$pkgname") ("-xmlrpc::noarch\n") ("\t") ($ VSub_Name "$pkgname") ("-libs\n") ("\t")
              )
            }
          spids: [101]
        )
      ]
      spids: [101]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:source)
          op: Equal
          rhs: 
            {
              (DQ ("ftp://ftp.ruby-lang.org/pub/ruby/") 
                (BracedVarSub
                  token: <VSub_Name pkgver>
                  suffix_op: (StringUnary op_id:VOp1_Percent arg_word:{(".*")})
                  spids: [152 156]
                ) (/) ($ VSub_Name "$pkgname") (-) ($ VSub_Name "$pkgver") (".tar.bz2\n") 
                ("\trubygems-avoid-platform-specific-gems.patch")
              )
            }
          spids: [149]
        )
      ]
      spids: [149]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:options) op:Equal rhs:{(DQ ("!fhs"))} spids:[165])]
      spids: [165]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:replaces) op:Equal rhs:{(DQ (ruby-gems))} spids:[170])]
      spids: [170]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:builddir)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$srcdir") (/) ($ VSub_Name "$pkgname") (-) ($ VSub_Name "$pkgver"))}
          spids: [175]
        )
      ]
      spids: [175]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_gemdir)
          op: Equal
          rhs: {(DQ (/usr/lib/ruby/gems/) ($ VSub_Name "$_abiver"))}
          spids: [185]
        )
      ]
      spids: [185]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_rubydir)
          op: Equal
          rhs: {(DQ (/usr/lib/ruby/) ($ VSub_Name "$_abiver"))}
          spids: [191]
        )
      ]
      spids: [191]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_chost)
          op: Equal
          rhs: 
            {
              (DQ 
                (BracedVarSub
                  token: <VSub_Name CHOST>
                  suffix_op: 
                    (PatSub
                      pat: {(-alpine-)}
                      replace: {(-)}
                      do_all: False
                      do_prefix: False
                      do_suffix: False
                    )
                  spids: [199 205]
                )
              )
            }
          spids: [197]
        )
      ]
      spids: [197]
    )
    (Case
      to_match: {(DQ ($ VSub_Name "$CARCH"))}
      arms: [
        (case_arm
          pat_list: [{(x86)}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:_arch) op:Equal rhs:{(DQ (i386))} spids:[221])]
              spids: [221]
            )
          ]
          spids: [218 219 225 -1]
        )
        (case_arm
          pat_list: [{(Lit_Other "*")}]
          action: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:_arch)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$CARCH"))}
                  spids: [231]
                )
              ]
              spids: [231]
            )
          ]
          spids: [228 229 235 -1]
        )
      ]
      spids: [209 215 237]
    )
    (FuncDef
      name: prepare
      body: 
        (BraceGroup
          children: [(C {(default_prepare)}) (C {(cd)} {(DQ ($ VSub_Name "$builddir"))}) (C {(autoconf)})]
          spids: [244]
        )
      spids: [240 243]
    )
    (FuncDef
      name: build
      body: 
        (BraceGroup
          children: [
            (C {(cd)} {(DQ ($ VSub_Name "$builddir"))})
            (C {(export)} 
              {(Lit_VarLike "CFLAGS=") 
                (DQ ($ VSub_Name "$CFLAGS") (" -fno-omit-frame-pointer -fno-strict-aliasing"))
              }
            )
            (C {(export)} 
              {(Lit_VarLike "CPPFLAGS=") 
                (DQ ($ VSub_Name "$CPPFLAGS") (" -fno-omit-frame-pointer -fno-strict-aliasing"))
              }
            )
            (C {(export)} {(Lit_VarLike "INSTALL=") (install)})
            (C {(export)} {(Lit_VarLike "ac_cv_func_isnan=") (yes)})
            (C {(export)} {(Lit_VarLike "ac_cv_func_isinf=") (yes)})
            (C {(./configure)} {(--build) (Lit_Other "=") ($ VSub_Name "$CBUILD")} 
              {(--host) (Lit_Other "=") ($ VSub_Name "$CHOST")} {(--prefix) (Lit_Other "=") (/usr)} {(--sysconfdir) (Lit_Other "=") (/etc)} 
              {(--mandir) (Lit_Other "=") (/usr/share/man)} {(--infodir) (Lit_Other "=") (/usr/share/info)} 
              {(--with-sitedir) (Lit_Other "=") (SQ </usr/local/lib/site_ruby>)} 
              {(--with-search-path) (Lit_Other "=") 
                (DQ (/usr/lib/site_ruby/) (EscapedLiteralPart token:<Lit_EscapedChar "\\$">) 
                  ("(ruby_ver)/") ($ VSub_Name "$_arch") (-linux)
                )
              } {(--enable-pthread)} {(--disable-rpath)} {(--enable-shared)} {(--with-mantype) (Lit_Other "=") (man)}
            )
            (C {(make)})
          ]
          spids: [267]
        )
      spids: [263 266]
    )
    (FuncDef
      name: check
      body: 
        (BraceGroup
          children: [(C {(cd)} {(DQ ($ VSub_Name "$builddir"))}) (C {(make)} {(test)})]
          spids: [423]
        )
      spids: [419 422]
    )
    (FuncDef
      name: package
      body: 
        (BraceGroup
          children: [
            (C {(cd)} {(DQ ($ VSub_Name "$builddir"))})
            (C {(make)} {(Lit_VarLike "DESTDIR=") (DQ ($ VSub_Name "$pkgdir"))} {(install)})
            (C {(install)} {(-m)} {(644)} {(-D)} {(COPYING)} 
              {(DQ ($ VSub_Name "$pkgdir")) (/usr/share/licenses/) ($ VSub_Name "$pkgname") (/COPYING)}
            )
            (C {(rm)} {(-R)} 
              {(DQ ($ VSub_Name "$pkgdir")) ($ VSub_Name "$_gemdir") (/cache/) (Lit_Other "*")}
            )
            (AndOr
              children: [
                (C {(rm)} {(-R)} 
                  {(DQ ($ VSub_Name "$pkgdir")) ($ VSub_Name "$_rubydir") (/rubygems/ssl_certs/) 
                    (Lit_Other "*") (.pem)
                  }
                )
                (C {(true)})
              ]
              op_id: Op_DPipe
            )
            (If
              arms: [
                (if_arm
                  cond: [
                    (Sentence
                      child: 
                        (C {(Lit_Other "[")} {(-d)} {(DQ ($ VSub_Name "$pkgdir")) (/usr/local)} 
                          {(Lit_Other "]")}
                        )
                      terminator: <Op_Semi ";">
                    )
                  ]
                  action: [
                    (Assignment
                      keyword: Assign_Local
                      pairs: [
                        (assign_pair
                          lhs: (LhsName name:f)
                          op: Equal
                          rhs: 
                            {
                              (CommandSubPart
                                command_list: 
                                  (CommandList
                                    children: [
                                      (Sentence
                                        child: (C {(cd)} {(DQ ($ VSub_Name "$pkgdir"))})
                                        terminator: <Op_Semi ";">
                                      )
                                      (C {(find)} {(usr/local)} {(-type)} {(f)})
                                    ]
                                  )
                                left_token: <Left_CommandSub "$(">
                                spids: [542 558]
                              )
                            }
                          spids: [541]
                        )
                      ]
                      spids: [539]
                    )
                    (If
                      arms: [
                        (if_arm
                          cond: [
                            (Sentence
                              child: 
                                (C {(Lit_Other "[")} {(-n)} {(DQ ($ VSub_Name "$f"))} {(Lit_Other "]")})
                              terminator: <Op_Semi ";">
                            )
                          ]
                          action: [
                            (C {(error)} {(DQ ("Found files in /usr/local:"))})
                            (C {(echo)} {(DQ ($ VSub_Name "$f"))})
                            (ControlFlow
                              token: <ControlFlow_Return return>
                              arg_word: {(1)}
                            )
                          ]
                          spids: [-1 574]
                        )
                      ]
                      spids: [-1 596]
                    )
                  ]
                  spids: [-1 536]
                )
              ]
              spids: [-1 599]
            )
          ]
          spids: [444]
        )
      spids: [440 443]
    )
    (FuncDef
      name: bigdecimal
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pkgdesc)
                  op: Equal
                  rhs: {(DQ ("Ruby arbitrary-precision floating point decimal arithmetic"))}
                  spids: [611]
                )
              ]
              spids: [611]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:depends)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$pkgname"))}
                  spids: [617]
                )
              ]
              spids: [617]
            )
            (C {(_mvgem)} {(bigdecimal)})
          ]
          spids: [608]
        )
      spids: [604 607]
    )
    (FuncDef
      name: did_you_mean
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pkgdesc)
                  op: Equal
                  rhs: {(DQ ("Did you mean? experience in Ruby"))}
                  spids: [638]
                )
              ]
              spids: [638]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:depends)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$pkgname"))}
                  spids: [644]
                )
              ]
              spids: [644]
            )
            (C {(_mvgem)} {(did_you_mean)})
          ]
          spids: [635]
        )
      spids: [631 634]
    )
    (FuncDef
      name: io_console
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pkgdesc)
                  op: Equal
                  rhs: {(DQ ("Ruby simple console IO library"))}
                  spids: [665]
                )
              ]
              spids: [665]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:depends)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$pkgname"))}
                  spids: [671]
                )
              ]
              spids: [671]
            )
            (C {(_mvgem)} {(io-console)})
            (C {(_mv)} {($ VSub_Name "$_rubydir") (/io)} 
              {($ VSub_Name "$_rubydir") (/) ($ VSub_Name "$_chost") (/io/console.so)}
            )
          ]
          spids: [662]
        )
      spids: [658 661]
    )
    (FuncDef
      name: irb
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pkgdesc)
                  op: Equal
                  rhs: {(DQ ("The Interactive Ruby"))}
                  spids: [705]
                )
              ]
              spids: [705]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:replaces)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$pkgname"))}
                  spids: [711]
                )
              ]
              spids: [711]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:depends)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$pkgname"))}
                  spids: [717]
                )
              ]
              spids: [717]
            )
            (C {(cd)} {(DQ ($ VSub_Name "$pkgdir"))})
            (C {(_mv)} {(usr/bin/irb)} {(usr/lib/ruby/) ($ VSub_Name "$_abiver") (/irb) (Lit_Other "*")})
          ]
          spids: [702]
        )
      spids: [698 701]
    )
    (FuncDef
      name: json
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pkgdesc)
                  op: Equal
                  rhs: {(DQ ("JSON implementation as a Ruby extension in C"))}
                  spids: [752]
                )
              ]
              spids: [752]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:depends)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$pkgname"))}
                  spids: [758]
                )
              ]
              spids: [758]
            )
            (C {(_mvgem)} {(json)})
          ]
          spids: [749]
        )
      spids: [745 748]
    )
    (FuncDef
      name: minitest
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pkgdesc)
                  op: Equal
                  rhs: {(DQ ("Ruby suite of testing facilities"))}
                  spids: [779]
                )
              ]
              spids: [779]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:depends)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$pkgname"))}
                  spids: [785]
                )
              ]
              spids: [785]
            )
            (C {(_mvgem)} {(minitest)})
          ]
          spids: [776]
        )
      spids: [772 775]
    )
    (FuncDef
      name: net_telnet
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pkgdesc)
                  op: Equal
                  rhs: {(DQ ("Telnet client functionality for Ruby"))}
                  spids: [806]
                )
              ]
              spids: [806]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:depends)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$pkgname"))}
                  spids: [812]
                )
              ]
              spids: [812]
            )
            (C {(_mvgem)} {(net-telnet)})
          ]
          spids: [803]
        )
      spids: [799 802]
    )
    (FuncDef
      name: power_assert
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pkgdesc)
                  op: Equal
                  rhs: {(DQ ("Power Assert for Ruby"))}
                  spids: [833]
                )
              ]
              spids: [833]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:depends)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$pkgname"))}
                  spids: [839]
                )
              ]
              spids: [839]
            )
            (C {(_mvgem)} {(power_assert)})
          ]
          spids: [830]
        )
      spids: [826 829]
    )
    (FuncDef
      name: rake
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pkgdesc)
                  op: Equal
                  rhs: {(DQ ("Ruby based make-like utility"))}
                  spids: [860]
                )
              ]
              spids: [860]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:depends)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$pkgname"))}
                  spids: [866]
                )
              ]
              spids: [866]
            )
            (AndOr
              children: [
                (C {(_mvgem)} {(rake)})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (C {(_mv)} {(usr/bin/rake)})
          ]
          spids: [857]
        )
      spids: [853 856]
    )
    (FuncDef
      name: rdoc
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pkgdesc)
                  op: Equal
                  rhs: {(DQ ("Ruby documentation tool"))}
                  spids: [898]
                )
              ]
              spids: [898]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:depends)
                  op: Equal
                  rhs: 
                    {
                      (DQ ($ VSub_Name "$pkgname") (" ") ($ VSub_Name "$pkgname") ("-json ") 
                        ($ VSub_Name "$pkgname") (-io-console)
                      )
                    }
                  spids: [904]
                )
              ]
              spids: [904]
            )
            (AndOr
              children: [
                (C {(_mvgem)} {(rdoc)})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (C {(_mv)} {(usr/bin/ri)} {(usr/bin/rdoc)})
          ]
          spids: [895]
        )
      spids: [891 894]
    )
    (FuncDef
      name: test_unit
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pkgdesc)
                  op: Equal
                  rhs: {(DQ ("An xUnit family unit testing framework for Ruby"))}
                  spids: [945]
                )
              ]
              spids: [945]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:depends)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$pkgname") (" ") ($ VSub_Name "$pkgname") (-power_assert))}
                  spids: [951]
                )
              ]
              spids: [951]
            )
            (C {(_mvgem)} {(test-unit)})
          ]
          spids: [942]
        )
      spids: [938 941]
    )
    (FuncDef
      name: xmlrpc
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pkgdesc)
                  op: Equal
                  rhs: {(DQ ("XMLRPC library for Ruby"))}
                  spids: [975]
                )
              ]
              spids: [975]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:depends)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$pkgname"))}
                  spids: [981]
                )
              ]
              spids: [981]
            )
            (C {(_mvgem)} {(xmlrpc)})
          ]
          spids: [972]
        )
      spids: [968 971]
    )
    (FuncDef
      name: libs
      body: 
        (BraceGroup
          children: [
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:pkgdesc)
                  op: Equal
                  rhs: {(DQ ("Libraries necessary to run Ruby"))}
                  spids: [1002]
                )
              ]
              spids: [1002]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:depends) op:Equal rhs:{(DQ )} spids:[1008])]
              spids: [1008]
            )
            (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$subpkgdir")) (/usr)})
            (C {(mv)} {(DQ ($ VSub_Name "$pkgdir")) (/usr/lib)} 
              {(DQ ($ VSub_Name "$subpkgdir")) (/usr/)}
            )
          ]
          spids: [999]
        )
      spids: [995 998]
    )
    (FuncDef
      name: _mv
      body: 
        (BraceGroup
          children: [
            (Sentence
              child: 
                (Assignment
                  keyword: Assign_Local
                  pairs: [(assign_pair lhs:(LhsName name:i) op:Equal spids:[1048])]
                  spids: [1046]
                )
              terminator: <Op_Semi ";">
            )
            (ForEach
              iter_name: i
              iter_words: [{(DQ ($ VSub_At "$@"))}]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (C {(mkdir)} {(-p)} 
                      {(DQ ($ VSub_Name "$subpkgdir")) (/) 
                        (BracedVarSub
                          token: <VSub_Name i>
                          suffix_op: (StringUnary op_id:VOp1_Percent arg_word:{(Lit_Slash /) ("*")})
                          spids: [1073 1078]
                        )
                      }
                    )
                    (AndOr
                      children: [
                        (C {(mv)} {(DQ ($ VSub_Name "$pkgdir")) (/) (${ VSub_Name i)} 
                          {(DQ ($ VSub_Name "$subpkgdir")) (/) 
                            (BracedVarSub
                              token: <VSub_Name i>
                              suffix_op: 
                                (StringUnary
                                  op_id: VOp1_Percent
                                  arg_word: {(Lit_Slash /) ("*")}
                                )
                              spids: [1095 1100]
                            ) (/)
                          }
                        )
                        (ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(1)}
                        )
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [1062 1110]
                )
              spids: [1056 1060]
            )
          ]
          spids: [1043]
        )
      spids: [1039 1042]
    )
    (FuncDef
      name: _mvgem
      body: 
        (BraceGroup
          children: [
            (C {(cd)} {(DQ ($ VSub_Name "$pkgdir"))})
            (Sentence
              child: 
                (Assignment
                  keyword: Assign_Local
                  pairs: [(assign_pair lhs:(LhsName name:path) op:Equal spids:[1131])]
                  spids: [1129]
                )
              terminator: <Op_Semi ";">
            )
            (ForEach
              iter_name: path
              iter_words: [
                {(./) ($ VSub_Name "$_rubydir") (/) (${ VSub_Number 1) (.rb)}
                {(./) ($ VSub_Name "$_rubydir") (/) (${ VSub_Number 1)}
                {(./) ($ VSub_Name "$_rubydir") (/) ($ VSub_Name "$_chost") (/) (${ VSub_Number 1)}
                {(./) ($ VSub_Name "$_gemdir") (/gems/) (${ VSub_Number 1) (-) (Lit_Other "*")}
                {(./) ($ VSub_Name "$_gemdir") (/specifications/) (${ VSub_Number 1) (-) (Lit_Other "*")}
                {(./) ($ VSub_Name "$_gemdir") (/specifications/default/) (${ VSub_Number 1) (-) 
                  (Lit_Other "*")
                }
              ]
              do_arg_iter: False
              body: 
                (DoGroup
                  children: [
                    (AndOr
                      children: [
                        (C {(Lit_Other "[")} {(KW_Bang "!")} {(-e)} 
                          {(DQ ($ VSub_Name "$pkgdir") (/) ($ VSub_Name "$path"))} {(Lit_Other "]")}
                        )
                        (C {(_mv)} {(DQ ($ VSub_Name "$path"))})
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [1203 1229]
                )
              spids: [1139 1201]
            )
          ]
          spids: [1119]
        )
      spids: [1115 1118]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:sha512sums)
          op: Equal
          rhs: 
            {
              (DQ 
                (
"1a5302d2558089a6b91b815fff9b75a29e690f10861de5fdd48211f3f45025a70dad7495f216e6af9c62d72e69ed316f1a52fada704bdc7e6d8c094d141ea77c  ruby-2.4.2.tar.bz2\n"
                ) 
                (
"cfdc5ea3b2e2ea69c51f38e8e2180cb1dc27008ca55cc6301f142ebafdbab31c3379b3b6bba9ff543153876dd98ed2ad194df3255b7ea77a62e931c935f80538  rubygems-avoid-platform-specific-gems.patch"
                )
              )
            }
          spids: [1234]
        )
      ]
      spids: [1234]
    )
  ]
)