# Contributor: Carlo Landmeter <clandmeter@gmail.com>
# Maintainer: Jakub Jirutka <jakub@jirutka.cz>
#
# secfixes:
#   2.2.8-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 := 'ruby2.2'
global _pkgname := 'ruby'
global _majorver := $(pkgname#ruby)
global pkgver := ""$_majorver.8""
global _pkgver := $(pkgver/_/-)
global _abiver := ""$_majorver.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 := ''""
global depends_dev := '"gmp-dev'"
global makedepends := ""$depends_dev zlib-dev libressl-dev gdbm-dev db-dev readline-dev
	libffi-dev coreutils yaml-dev autoconf""
global subpackages := ""$pkgname-doc $pkgname-dev $pkgname-irb::noarch
	$pkgname-rdoc::noarch $pkgname-rake::noarch $pkgname-bigdecimal::noarch
	$pkgname-io-console:io_console $pkgname-minitest::noarch
	$pkgname-json $pkgname-libs
	""
global source := ""ftp://ftp.ruby-lang.org/pub/ruby/$(pkgver%.*)/$_pkgname-$_pkgver.tar.bz2""
global options := '"!fhs'"
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 || return 1

	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 \
		--program-suffix=$_majorver \
		--with-soname=$pkgname \
		|| return 1
	make || return 1
	make test
}

proc package {
	cd $builddir

	make DESTDIR="$pkgdir" install || return 1

	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
		}
	}
	install -Dm644 COPYING "$pkgdir"/usr/share/licenses/$pkgname/COPYING
}

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

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

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

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

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

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

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

	_mvgem bigdecimal
}

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 minitest {
	global pkgdesc := '"Ruby suite of testing facilities'"
	global depends := $pkgname

	_mvgem minitest
}

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

	_mvgem json
}

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 := '"aa1c65f76a51a57d9059a38a13a823112b53850a9e7d6f72c3f3e38d381412014521049f7065c1b00877501b3b554235135d0f308045c2a9da133c766f5b9e46  ruby-2.2.8.tar.bz2'"
(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:pkgname) op:Equal rhs:{(ruby2.2)} spids:[42])]
      spids: [42]
    )
    (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:_majorver)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Name pkgname>
                suffix_op: (StringUnary op_id:VOp1_Pound arg_word:{(ruby)})
                spids: [49 53]
              )
            }
          spids: [48]
        )
      ]
      spids: [48]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:pkgver)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$_majorver") (.8))}
          spids: [55]
        )
      ]
      spids: [55]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_pkgver)
          op: Equal
          rhs: 
            {
              (BracedVarSub
                token: <VSub_Name pkgver>
                suffix_op: 
                  (PatSub
                    pat: {(_)}
                    replace: {(-)}
                    do_all: False
                    do_prefix: False
                    do_suffix: False
                  )
                spids: [62 68]
              )
            }
          spids: [61]
        )
      ]
      spids: [61]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_abiver)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$_majorver") (.0))}
          spids: [70]
        )
      ]
      spids: [70]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:pkgrel) op:Equal rhs:{(0)} spids:[76])]
      spids: [76]
    )
    (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: [79]
        )
      ]
      spids: [79]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:url)
          op: Equal
          rhs: {(DQ ("http://www.ruby-lang.org/en/"))}
          spids: [84]
        )
      ]
      spids: [84]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:arch) op:Equal rhs:{(DQ (all))} spids:[89])]
      spids: [89]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:license) op:Equal rhs:{(DQ (Ruby))} spids:[94])]
      spids: [94]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:depends) op:Equal rhs:{(DQ )} spids:[99])]
      spids: [99]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:depends_dev) op:Equal rhs:{(DQ (gmp-dev))} spids:[103])]
      spids: [103]
    )
    (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 autoconf")
              )
            }
          spids: [108]
        )
      ]
      spids: [108]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:subpackages)
          op: Equal
          rhs: 
            {
              (DQ ($ VSub_Name "$pkgname") ("-doc ") ($ VSub_Name "$pkgname") ("-dev ") 
                ($ VSub_Name "$pkgname") ("-irb::noarch\n") ("\t") ($ VSub_Name "$pkgname") ("-rdoc::noarch ") ($ VSub_Name "$pkgname") 
                ("-rake::noarch ") ($ VSub_Name "$pkgname") ("-bigdecimal::noarch\n") ("\t") ($ VSub_Name "$pkgname") 
                ("-io-console:io_console ") ($ VSub_Name "$pkgname") ("-minitest::noarch\n") ("\t") ($ VSub_Name "$pkgname") ("-json ") 
                ($ VSub_Name "$pkgname") ("-libs\n") ("\t")
              )
            }
          spids: [115]
        )
      ]
      spids: [115]
    )
    (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: [146 150]
                ) (/) ($ VSub_Name "$_pkgname") (-) ($ VSub_Name "$_pkgver") (.tar.bz2)
              )
            }
          spids: [143]
        )
      ]
      spids: [143]
    )
    (Assignment
      keyword: Assign_None
      pairs: [(assign_pair lhs:(LhsName name:options) op:Equal rhs:{(DQ ("!fhs"))} spids:[158])]
      spids: [158]
    )
    (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: [163]
        )
      ]
      spids: [163]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_gemdir)
          op: Equal
          rhs: {(DQ (/usr/lib/ruby/gems/) ($ VSub_Name "$_abiver"))}
          spids: [173]
        )
      ]
      spids: [173]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:_rubydir)
          op: Equal
          rhs: {(DQ (/usr/lib/ruby/) ($ VSub_Name "$_abiver"))}
          spids: [179]
        )
      ]
      spids: [179]
    )
    (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: [187 193]
                )
              )
            }
          spids: [185]
        )
      ]
      spids: [185]
    )
    (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:[209])]
              spids: [209]
            )
          ]
          spids: [206 207 213 -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: [219]
                )
              ]
              spids: [219]
            )
          ]
          spids: [216 217 223 -1]
        )
      ]
      spids: [197 203 225]
    )
    (FuncDef
      name: prepare
      body: 
        (BraceGroup
          children: [
            (AndOr
              children: [
                (C {(default_prepare)})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (C {(cd)} {(DQ ($ VSub_Name "$builddir"))})
            (C {(autoconf)})
          ]
          spids: [232]
        )
      spids: [228 231]
    )
    (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)})
            (AndOr
              children: [
                (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)} 
                  {(--program-suffix) (Lit_Other "=") ($ VSub_Name "$_majorver")} {(--with-soname) (Lit_Other "=") ($ VSub_Name "$pkgname")}
                )
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (AndOr
              children: [(C {(make)}) (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})]
              op_id: Op_DPipe
            )
            (C {(make)} {(test)})
          ]
          spids: [261]
        )
      spids: [257 260]
    )
    (FuncDef
      name: package
      body: 
        (BraceGroup
          children: [
            (C {(cd)} {(DQ ($ VSub_Name "$builddir"))})
            (AndOr
              children: [
                (C {(make)} {(Lit_VarLike "DESTDIR=") (DQ ($ VSub_Name "$pkgdir"))} {(install)})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              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: [496 512]
                              )
                            }
                          spids: [495]
                        )
                      ]
                      spids: [493]
                    )
                    (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 528]
                        )
                      ]
                      spids: [-1 550]
                    )
                  ]
                  spids: [-1 490]
                )
              ]
              spids: [-1 553]
            )
            (C {(install)} {(-Dm644)} {(COPYING)} 
              {(DQ ($ VSub_Name "$pkgdir")) (/usr/share/licenses/) ($ VSub_Name "$pkgname") (/COPYING)}
            )
          ]
          spids: [448]
        )
      spids: [444 447]
    )
    (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: [579]
                )
              ]
              spids: [579]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:depends)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$pkgname"))}
                  spids: [585]
                )
              ]
              spids: [585]
            )
            (AndOr
              children: [
                (C {(_mvgem)} {(rake)})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (C {(_mv)} {(usr/bin/rake) ($ VSub_Name "$_majorver")})
          ]
          spids: [576]
        )
      spids: [572 575]
    )
    (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: [618]
                )
              ]
              spids: [618]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:replaces)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$pkgname"))}
                  spids: [624]
                )
              ]
              spids: [624]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:depends)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$pkgname"))}
                  spids: [630]
                )
              ]
              spids: [630]
            )
            (C {(cd)} {(DQ ($ VSub_Name "$pkgdir"))})
            (C {(_mv)} {(usr/bin/irb) ($ VSub_Name "$_majorver")} 
              {(usr/lib/ruby/) ($ VSub_Name "$_abiver") (/irb) (Lit_Other "*")}
            )
          ]
          spids: [615]
        )
      spids: [611 614]
    )
    (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: [666]
                )
              ]
              spids: [666]
            )
            (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: [672]
                )
              ]
              spids: [672]
            )
            (AndOr
              children: [
                (C {(_mvgem)} {(rdoc)})
                (ControlFlow token:<ControlFlow_Return return> arg_word:{(1)})
              ]
              op_id: Op_DPipe
            )
            (C {(_mv)} {(usr/bin/ri) ($ VSub_Name "$_majorver")} 
              {(usr/bin/rdoc) ($ VSub_Name "$_majorver")}
            )
          ]
          spids: [663]
        )
      spids: [659 662]
    )
    (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: [715]
                )
              ]
              spids: [715]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:depends)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$pkgname"))}
                  spids: [721]
                )
              ]
              spids: [721]
            )
            (C {(_mvgem)} {(bigdecimal)})
          ]
          spids: [712]
        )
      spids: [708 711]
    )
    (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: [742]
                )
              ]
              spids: [742]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:depends)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$pkgname"))}
                  spids: [748]
                )
              ]
              spids: [748]
            )
            (C {(_mvgem)} {(io-console)})
            (C {(_mv)} {($ VSub_Name "$_rubydir") (/io)} 
              {($ VSub_Name "$_rubydir") (/) ($ VSub_Name "$_chost") (/io/console.so)}
            )
          ]
          spids: [739]
        )
      spids: [735 738]
    )
    (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: [782]
                )
              ]
              spids: [782]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:depends)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$pkgname"))}
                  spids: [788]
                )
              ]
              spids: [788]
            )
            (C {(_mvgem)} {(minitest)})
          ]
          spids: [779]
        )
      spids: [775 778]
    )
    (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: [809]
                )
              ]
              spids: [809]
            )
            (Assignment
              keyword: Assign_None
              pairs: [
                (assign_pair
                  lhs: (LhsName name:depends)
                  op: Equal
                  rhs: {(DQ ($ VSub_Name "$pkgname"))}
                  spids: [815]
                )
              ]
              spids: [815]
            )
            (C {(_mvgem)} {(json)})
          ]
          spids: [806]
        )
      spids: [802 805]
    )
    (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: [836]
                )
              ]
              spids: [836]
            )
            (Assignment
              keyword: Assign_None
              pairs: [(assign_pair lhs:(LhsName name:depends) op:Equal rhs:{(DQ )} spids:[842])]
              spids: [842]
            )
            (C {(mkdir)} {(-p)} {(DQ ($ VSub_Name "$subpkgdir")) (/usr)})
            (C {(mv)} {(DQ ($ VSub_Name "$pkgdir")) (/usr/lib)} 
              {(DQ ($ VSub_Name "$subpkgdir")) (/usr/)}
            )
          ]
          spids: [833]
        )
      spids: [829 832]
    )
    (FuncDef
      name: _mv
      body: 
        (BraceGroup
          children: [
            (Sentence
              child: 
                (Assignment
                  keyword: Assign_Local
                  pairs: [(assign_pair lhs:(LhsName name:i) op:Equal spids:[882])]
                  spids: [880]
                )
              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: [907 912]
                        )
                      }
                    )
                    (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: [929 934]
                            ) (/)
                          }
                        )
                        (ControlFlow
                          token: <ControlFlow_Return return>
                          arg_word: {(1)}
                        )
                      ]
                      op_id: Op_DPipe
                    )
                  ]
                  spids: [896 944]
                )
              spids: [890 894]
            )
          ]
          spids: [877]
        )
      spids: [873 876]
    )
    (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:[965])]
                  spids: [963]
                )
              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: [1037 1063]
                )
              spids: [973 1035]
            )
          ]
          spids: [953]
        )
      spids: [949 952]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:sha512sums)
          op: Equal
          rhs: 
            {
              (DQ 
                (
"aa1c65f76a51a57d9059a38a13a823112b53850a9e7d6f72c3f3e38d381412014521049f7065c1b00877501b3b554235135d0f308045c2a9da133c766f5b9e46  ruby-2.2.8.tar.bz2"
                )
              )
            }
          spids: [1068]
        )
      ]
      spids: [1068]
    )
  ]
)