package-installer-cli 2.2.0 → 2.3.0

data/bundle-standalone/templates/go/golang-boilerplate/util/helper.go

@@ -1,300 +0,0 @@
-package util
-
-import (
-	"fmt"
-	"math"
-	"reflect"
-	"runtime"
-	"strconv"
-	"strings"
-	"time"
-	"unicode"
-)
-
-func NewSliceForType(t reflect.Type) interface{} {
-	items := reflect.New(reflect.SliceOf(t)).Interface()
-	return items
-}
-
-func StringPtr(s string) *string {
-	return &s
-}
-
-func UintPtr(u uint) *uint {
-	return &u
-}
-
-func IntPtr(i int) *int {
-	return &i
-}
-
-func Float32Ptr(f float32) *float32 {
-	return &f
-}
-
-func Float64Ptr(f float64) *float64 {
-	return &f
-}
-
-func TimePtr(t time.Time) *time.Time {
-	return &t
-}
-
-func BoolPtr(b bool) *bool {
-	return &b
-}
-
-func AUintToAInt(au []uint) []int {
-	ai := make([]int, len(au))
-	for i := 0; i < len(au); i++ {
-		ai[i] = int(au[i])
-	}
-	return ai
-}
-
-func Atou(a string) (uint, error) {
-	i, err := strconv.Atoi(a)
-	if err != nil {
-		return 0, err
-	}
-	return uint(i), nil
-}
-
-func Utoa(u uint) string {
-	return fmt.Sprintf("%d", u)
-}
-
-func Capitalize(s string) string {
-	if s == "" {
-		return ""
-	}
-	if len(s) == 1 {
-		return strings.ToUpper(s)
-	}
-	return strings.ToUpper(s[0:1]) + s[1:]
-}
-
-func CamelToSnake(s string) string {
-	if s == "" {
-		return ""
-	}
-	var result string
-	var words []string
-	var lastPos int
-	rs := []rune(s)
-
-	for i := 0; i < len(rs); i++ {
-		if i > 0 && unicode.IsUpper(rs[i]) {
-			words = append(words, s[lastPos:i])
-			lastPos = i
-		}
-	}
-
-	// append the last word
-	if s[lastPos:] != "" {
-		words = append(words, s[lastPos:])
-	}
-
-	for k, word := range words {
-		if k > 0 {
-			result += "_"
-		}
-
-		result += strings.ToLower(word)
-	}
-
-	return result
-}
-
-// SnakeToCamel returns a string converted from snake case to uppercase
-func SnakeToCamel(s string) string {
-	if s == "" {
-		return ""
-	}
-	var result string
-
-	words := strings.Split(s, "_")
-
-	for _, word := range words {
-		w := []rune(word)
-		w[0] = unicode.ToUpper(w[0])
-		result += string(w)
-	}
-
-	return result
-}
-
-func NanoToMicro(n int64) int64 {
-	// Conversion to float64 was leading to imperfect results!
-	//return int64(Round(float64(n) / 1000.0))
-	return (n + 500) / 1000
-}
-
-func MicroToNano(ms int64) int64 {
-	return ms * 1000
-}
-
-func DurationInMs(start, end time.Time) int64 {
-	return (end.UnixNano() - start.UnixNano()) / 1000000
-}
-
-func IsZeroStruct(item interface{}) bool {
-	zero := false
-
-	if item != nil {
-		v := reflect.ValueOf(item)
-		t := v.Type()
-		k := t.Kind()
-
-		if k == reflect.Struct {
-			z := reflect.Zero(t)
-			if reflect.DeepEqual(v.Interface(), z.Interface()) {
-				zero = true
-			}
-		}
-	}
-
-	return zero
-}
-
-func Round(num float64) int {
-	return int(num + math.Copysign(0.5, num))
-}
-
-func RoundToDecimal(f float64, decimals int) float64 {
-	factor := math.Pow(10, float64(decimals))
-	res := f * factor
-	res = RoundFloat(res)
-	res = res / factor
-	return res
-}
-
-func RoundFloat(f float64) float64 {
-	return math.Floor(f + .5)
-}
-
-func RoundPlus(f float64, places int) float64 {
-	shift := math.Pow(10, float64(places))
-	return RoundFloat(f*shift) / shift
-}
-
-func ToFixed(num float64, precision int) float64 {
-	output := math.Pow(10, float64(precision))
-	return float64(Round(num*output)) / output
-}
-
-func IsEmptyValue(v reflect.Value) bool {
-	switch v.Kind() {
-	case reflect.String, reflect.Array:
-		return v.Len() == 0
-	case reflect.Map, reflect.Slice:
-		return v.Len() == 0 || v.IsNil()
-	case reflect.Bool:
-		return !v.Bool()
-	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
-		return v.Int() == 0
-	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr:
-		return v.Uint() == 0
-	case reflect.Float32, reflect.Float64:
-		return v.Float() == 0
-	case reflect.Interface, reflect.Ptr:
-		return v.IsNil()
-	}
-
-	return reflect.DeepEqual(v.Interface(), reflect.Zero(v.Type()).Interface())
-}
-
-func CallerInfo() string {
-	_, file, line, ok := runtime.Caller(2)
-	if !ok {
-		return ""
-	}
-	parts := strings.Split(file, "/")
-	file = parts[len(parts)-1]
-	return fmt.Sprintf("%s:%d", file, line)
-}
-
-func ParentCallerInfo() string {
-	_, file, line, ok := runtime.Caller(3)
-	if !ok {
-		return ""
-	}
-	parts := strings.Split(file, "/")
-	file = parts[len(parts)-1]
-	return fmt.Sprintf("%s:%d", file, line)
-}
-
-func ItemsOrEmptySlice(t reflect.Type, items interface{}) interface{} {
-	if reflect.ValueOf(items).IsNil() {
-		items = reflect.MakeSlice(reflect.SliceOf(t), 0, 0)
-	}
-	return items
-}
-
-func ConvertQueryTermToOrderTerm(term string) (fields []string, ascending []bool) {
-	if strings.HasPrefix(term, "[") && strings.HasSuffix(term, "]") {
-		term = term[1 : len(term)-1]
-	}
-
-	if term == "" {
-		return
-	}
-
-	fieldConfigs := strings.Split(term, ",")
-
-	for _, config := range fieldConfigs {
-		if strings.HasSuffix(config, "-asc") {
-			fields = append(fields, config[0:len(config)-4])
-			ascending = append(ascending, true)
-		} else if strings.HasSuffix(config, "-desc") {
-			fields = append(fields, config[0:len(config)-5])
-			ascending = append(ascending, false)
-		} else {
-			fields = append(fields, config)
-			ascending = append(ascending, true)
-		}
-	}
-
-	fmt.Println(ascending)
-
-	return
-}
-
-func PtrEquals(ptr1 interface{}, ptr2 interface{}) bool {
-	if reflect.TypeOf(ptr1).Kind() != reflect.Ptr {
-		return false
-	}
-	if reflect.TypeOf(ptr2).Kind() != reflect.Ptr {
-		return false
-	}
-	vptr1 := reflect.ValueOf(ptr1)
-	vptr2 := reflect.ValueOf(ptr2)
-
-	if vptr1.IsNil() {
-		if vptr2.IsNil() {
-			return true
-		}
-		return false
-	} else if vptr2.IsNil() {
-		return false
-	}
-
-	v1 := reflect.Indirect(vptr1)
-	v2 := reflect.Indirect(vptr2)
-
-	return v1.Interface() == v2.Interface()
-}
-
-func Unique(input []uint) []uint {
-	u := make([]uint, 0, len(input))
-	m := make(map[uint]bool)
-
-	for _, val := range input {
-		if _, ok := m[val]; !ok {
-			m[val] = true
-			u = append(u, val)
-		}
-	}
-
-	return u
-}

data/bundle-standalone/templates/go/golang-boilerplate/util/helper_test.go

@@ -1,230 +0,0 @@
-package util
-
-import (
-	"reflect"
-	"testing"
-)
-
-// Helper funcs
-
-type TestStruct struct {
-	ID          uint
-	Title       string
-	Description *string
-}
-
-func AssertEqual(t *testing.T, expected, actual interface{}) {
-	if !reflect.DeepEqual(expected, actual) {
-		t.Errorf("assertEqual: Expected:\n%v\nbut got:\n%v\n (caller: %s)", expected, actual, CallerInfo())
-	}
-}
-
-func AssertTrue(t *testing.T, actual bool) {
-	if !actual {
-		t.Errorf("assertTrue: Assertion is false (caller: %s)", CallerInfo())
-	}
-}
-
-func AssertFalse(t *testing.T, actual bool) {
-	if actual {
-		t.Errorf("assertFalse: Assertion is true (caller: %s)", CallerInfo())
-	}
-}
-
-// Tests
-
-func TestAtou(t *testing.T) {
-	var nilErr error
-
-	val, err := Atou("1")
-	AssertEqual(t, nilErr, err)
-	AssertEqual(t, uint(1), val)
-
-	val, err = Atou("0")
-	AssertEqual(t, nilErr, err)
-	AssertEqual(t, uint(0), val)
-
-	val, err = Atou("1384234")
-	AssertEqual(t, nilErr, err)
-	AssertEqual(t, uint(1384234), val)
-
-	val, err = Atou("-1")
-	AssertEqual(t, nilErr, err)
-	AssertEqual(t, uint(18446744073709551615), val)
-
-	val, err = Atou("not a number")
-	AssertEqual(t, "strconv.Atoi: parsing \"not a number\": invalid syntax", err.Error())
-	AssertEqual(t, uint(0), val)
-
-	val, err = Atou("#234")
-	AssertEqual(t, "strconv.Atoi: parsing \"#234\": invalid syntax", err.Error())
-	AssertEqual(t, uint(0), val)
-}
-
-func TestUtoa(t *testing.T) {
-	AssertEqual(t, "1", Utoa(1))
-	AssertEqual(t, "0", Utoa(0))
-	AssertEqual(t, "1384234", Utoa(1384234))
-}
-
-func TestCaptialize(t *testing.T) {
-	AssertEqual(t, "Testing", Capitalize("testing"))
-	AssertEqual(t, "This is a longer string", Capitalize("this is a longer string"))
-	AssertEqual(t, "Already Capitalized", Capitalize("Already Capitalized"))
-	AssertEqual(t, "", Capitalize(""))
-}
-
-func TestSnakeToCamel(t *testing.T) {
-	AssertEqual(t, "Testing", SnakeToCamel("testing"))
-	AssertEqual(t, "This is a longer string", SnakeToCamel("this is a longer string"))
-	AssertEqual(t, "Already Capitalized", SnakeToCamel("Already Capitalized"))
-	AssertEqual(t, "ActualSnake", SnakeToCamel("actual_snake"))
-	AssertEqual(t, "ThisIsAMultipleSnake", SnakeToCamel("this_is_a_multiple_snake"))
-	AssertEqual(t, "", SnakeToCamel(""))
-}
-
-func TestCamelToSnake(t *testing.T) {
-	AssertEqual(t, "testing", CamelToSnake("Testing"))
-	AssertEqual(t, "testing", CamelToSnake("testing"))
-	AssertEqual(t, "actual_camel", CamelToSnake("ActualCamel"))
-	AssertEqual(t, "this_is_a_multiple_camel", CamelToSnake("ThisIsAMultipleCamel"))
-	AssertEqual(t, "", CamelToSnake(""))
-}
-
-func TestRound(t *testing.T) {
-	AssertEqual(t, 5, Round(4.5))
-	AssertEqual(t, 4, Round(4.49))
-	AssertEqual(t, 5, Round(4.7))
-	AssertEqual(t, 5, Round(5.1))
-	AssertEqual(t, 5, Round(5.0))
-	AssertEqual(t, 0, Round(0.49))
-	AssertEqual(t, 0, Round(-0.49))
-	AssertEqual(t, -1, Round(-1.0))
-	AssertEqual(t, -2, Round(-1.5))
-	AssertEqual(t, -2, Round(-1.51))
-}
-
-func TestRoundFloat(t *testing.T) {
-	AssertEqual(t, 5.0, RoundFloat(4.5))
-	AssertEqual(t, 4.0, RoundFloat(4.49))
-	AssertEqual(t, 5.0, RoundFloat(4.7))
-	AssertEqual(t, 5.0, RoundFloat(5.1))
-	AssertEqual(t, 5.0, RoundFloat(5.0))
-	AssertEqual(t, 0.0, RoundFloat(0.49))
-	AssertEqual(t, 0.0, RoundFloat(-0.49))
-	AssertEqual(t, -1.0, RoundFloat(-1.0))
-	AssertEqual(t, -1.0, RoundFloat(-1.5))
-	AssertEqual(t, -2.0, RoundFloat(-1.51))
-}
-
-func TestRoundToDecimal(t *testing.T) {
-	AssertEqual(t, 5.0, RoundToDecimal(4.5, 0))
-	AssertEqual(t, 4.5, RoundToDecimal(4.5, 1))
-	AssertEqual(t, 4.5, RoundToDecimal(4.5, 2))
-	AssertEqual(t, 4.5, RoundToDecimal(4.49, 1))
-	AssertEqual(t, 4.49, RoundToDecimal(4.49, 2))
-	AssertEqual(t, 4.45, RoundToDecimal(4.449, 2))
-	AssertEqual(t, 12433.2342, RoundToDecimal(12433.2341698323239823, 4))
-}
-
-func TestNanoToMicro(t *testing.T) {
-	AssertEqual(t, int64(1452522568079810), NanoToMicro(1452522568079810000))
-	AssertEqual(t, int64(1452522568079810), NanoToMicro(1452522568079810260))
-	AssertEqual(t, int64(1452522568079811), NanoToMicro(1452522568079810500))
-	AssertEqual(t, int64(1452522568079810), NanoToMicro(1452522568079810499))
-	AssertEqual(t, int64(1452522568079811), NanoToMicro(1452522568079810599))
-}
-
-func TestMicroToNano(t *testing.T) {
-	AssertEqual(t, int64(1452522568079810000), MicroToNano(1452522568079810))
-	AssertEqual(t, int64(1452522568079811000), MicroToNano(1452522568079811))
-}
-
-func TestIsZeroStruct(t *testing.T) {
-	AssertEqual(t, false, IsZeroStruct(nil))
-	AssertEqual(t, true, IsZeroStruct(TestStruct{}))
-	AssertEqual(t, true, IsZeroStruct(TestStruct{ID: 0}))
-	AssertEqual(t, true, IsZeroStruct(TestStruct{ID: 0, Title: ""}))
-	AssertEqual(t, false, IsZeroStruct(TestStruct{ID: 10}))
-	AssertEqual(t, false, IsZeroStruct(TestStruct{Title: "Hello"}))
-	s := "Hello, Test"
-	AssertEqual(t, false, IsZeroStruct(TestStruct{Description: &s}))
-	AssertEqual(t, false, IsZeroStruct(&TestStruct{}))
-	var i interface{}
-	AssertEqual(t, false, IsZeroStruct(i))
-}
-
-func TestIsEmptyValue(t *testing.T) {
-	AssertEqual(t, true, IsEmptyValue(reflect.ValueOf(0)))
-	AssertEqual(t, false, IsEmptyValue(reflect.ValueOf(10)))
-	AssertEqual(t, true, IsEmptyValue(reflect.ValueOf("")))
-	AssertEqual(t, false, IsEmptyValue(reflect.ValueOf("Yo mama")))
-	AssertEqual(t, true, IsEmptyValue(reflect.ValueOf(uint(0))))
-	AssertEqual(t, false, IsEmptyValue(reflect.ValueOf(uint(10))))
-	AssertEqual(t, true, IsEmptyValue(reflect.ValueOf(float64(0))))
-	AssertEqual(t, false, IsEmptyValue(reflect.ValueOf(float64(10))))
-	AssertEqual(t, true, IsEmptyValue(reflect.ValueOf([]uint{})))
-	AssertEqual(t, false, IsEmptyValue(reflect.ValueOf([]uint{1, 5, 7})))
-	var a, b *int
-	bval := 10
-	b = &bval
-	AssertEqual(t, true, IsEmptyValue(reflect.ValueOf(a)))
-	AssertEqual(t, false, IsEmptyValue(reflect.ValueOf(b)))
-}
-
-func TestPtrEquals(t *testing.T) {
-	AssertFalse(t, PtrEquals(1, 1))
-	AssertFalse(t, PtrEquals(1, 2))
-
-	var s1, s2 string
-	AssertFalse(t, PtrEquals(s1, s2))
-	s1 = "Hello"
-	s2 = "World"
-	AssertFalse(t, PtrEquals(s1, s2))
-	s2 = s1
-	AssertFalse(t, PtrEquals(s1, s2))
-
-	var sPtr1, sPtr2 *string
-	AssertTrue(t, PtrEquals(sPtr1, sPtr2))
-	sPtr1 = &s1
-	AssertFalse(t, PtrEquals(sPtr1, sPtr2))
-	sPtr1 = nil
-	sPtr2 = &s2
-	AssertFalse(t, PtrEquals(sPtr1, sPtr2))
-	s2 = "World"
-	sPtr1 = &s1
-	sPtr2 = &s2
-	AssertFalse(t, PtrEquals(sPtr1, sPtr2))
-	sPtr2 = &s1
-	AssertTrue(t, PtrEquals(sPtr1, sPtr2))
-	s2 = "Hello"
-	sPtr1 = &s1
-	sPtr2 = &s2
-	AssertTrue(t, PtrEquals(sPtr1, sPtr2))
-
-	var uPtr1, uPtr2 *uint
-	u1 := uint(123)
-	u2 := uint(345)
-	AssertTrue(t, PtrEquals(uPtr1, uPtr2))
-	uPtr1 = &u1
-	AssertFalse(t, PtrEquals(uPtr1, uPtr2))
-	uPtr1 = nil
-	uPtr2 = &u2
-	AssertFalse(t, PtrEquals(uPtr1, uPtr2))
-	uPtr1 = &u1
-	uPtr2 = &u2
-	AssertFalse(t, PtrEquals(uPtr1, uPtr2))
-	uPtr2 = &u1
-	AssertTrue(t, PtrEquals(uPtr1, uPtr2))
-	u2 = uint(123)
-	uPtr1 = &u1
-	uPtr2 = &u2
-	AssertTrue(t, PtrEquals(uPtr1, uPtr2))
-}
-
-func TestUnique(t *testing.T) {
-	integers := []uint{1, 2, 3, 3, 4, 5}
-	unique := Unique(integers)
-	expected := []uint{1, 2, 3, 4, 5}
-	AssertEqual(t, unique, expected)
-}

data/bundle-standalone/templates/ruby/rails_7_esbuild_hotwire_tailwindcss_starter/Dockerfile

@@ -1,75 +0,0 @@
-# syntax = docker/dockerfile:1
-
-# Make sure RUBY_VERSION matches the Ruby version in .ruby-version and Gemfile
-ARG RUBY_VERSION=3.2.0
-FROM registry.docker.com/library/ruby:$RUBY_VERSION-slim as base
-
-# Rails app lives here
-WORKDIR /rails
-
-# Set production environment
-ENV RAILS_ENV="production" \
-    BUNDLE_DEPLOYMENT="1" \
-    BUNDLE_PATH="/usr/local/bundle" \
-    BUNDLE_WITHOUT="development"
-
-
-# Throw-away build stage to reduce size of final image
-FROM base as build
-
-# Install packages needed to build gems and node modules
-RUN apt-get update -qq && \
-    apt-get install --no-install-recommends -y build-essential curl git libpq-dev libvips node-gyp pkg-config python-is-python3
-
-# Install JavaScript dependencies
-ARG NODE_VERSION=20.11.1
-ARG YARN_VERSION=1.22.21
-ENV PATH=/usr/local/node/bin:$PATH
-RUN curl -sL https://github.com/nodenv/node-build/archive/master.tar.gz | tar xz -C /tmp/ && \
-    /tmp/node-build-master/bin/node-build "${NODE_VERSION}" /usr/local/node && \
-    npm install -g yarn@$YARN_VERSION && \
-    rm -rf /tmp/node-build-master
-
-# Install application gems
-COPY Gemfile Gemfile.lock ./
-RUN bundle install && \
-    rm -rf ~/.bundle/ "${BUNDLE_PATH}"/ruby/*/cache "${BUNDLE_PATH}"/ruby/*/bundler/gems/*/.git && \
-    bundle exec bootsnap precompile --gemfile
-
-# Install node modules
-COPY package.json yarn.lock ./
-RUN yarn install --frozen-lockfile
-
-# Copy application code
-COPY . .
-
-# Precompile bootsnap code for faster boot times
-RUN bundle exec bootsnap precompile app/ lib/
-
-# Precompiling assets for production without requiring secret RAILS_MASTER_KEY
-RUN SECRET_KEY_BASE_DUMMY=1 ./bin/rails assets:precompile
-
-
-# Final stage for app image
-FROM base
-
-# Install packages needed for deployment
-RUN apt-get update -qq && \
-    apt-get install --no-install-recommends -y curl libvips postgresql-client && \
-    rm -rf /var/lib/apt/lists /var/cache/apt/archives
-
-# Copy built artifacts: gems, application
-COPY --from=build /usr/local/bundle /usr/local/bundle
-COPY --from=build /rails /rails
-
-# Run and own only the runtime files as a non-root user for security
-RUN useradd rails --create-home --shell /bin/bash && \
-    chown -R rails:rails db log storage tmp
-USER rails:rails
-
-# Entrypoint prepares the database.
-ENTRYPOINT ["/rails/bin/docker-entrypoint"]
-
-# Start the server by default, this can be overwritten at runtime
-EXPOSE 3000
-CMD ["./bin/rails", "server"]

data/bundle-standalone/templates/ruby/rails_7_esbuild_hotwire_tailwindcss_starter/Gemfile

@@ -1,29 +0,0 @@
-source "https://rubygems.org"
-
-ruby "3.2.0"
-
-gem "rails", "~> 7.1.4"
-gem "sprockets-rails"
-gem "pg", "~> 1.1"
-gem "puma", ">= 5.0"
-gem "jsbundling-rails"
-gem "turbo-rails"
-gem "stimulus-rails"
-gem "cssbundling-rails"
-gem "jbuilder"
-gem "tzinfo-data", platforms: %i[ windows jruby ]
-gem "bootsnap", require: false
-gem "dotenv-rails"
-
-group :development, :test do
-  gem "debug", platforms: %i[ mri windows ]
-end
-
-group :development do
-  gem "web-console"
-end
-
-group :test do
-  gem "capybara"
-  gem "selenium-webdriver"
-end