text:
# author: Nick Porcino
# license: MIT

# LABRENDER_FOUND
# LABRENDER_INCLUDE_DIR
# LABRENDER_LIBRARY_RELEASE
# LABRENDER_LIBRARY_DEBUG
# LABRENDER_LIBRARIES
# LABRENDER_DYLIBS
# LABRENDER_DYLIBS_RELEASE
# LABRENDER_DYLIBS_DEBUG

include_guard()

include(FindPackageHandleStandardArgs)

find_path(LABRENDER_INCLUDE_DIR LabRender/Renderer.h
    PATHS
    ${LABRENDER_LOCATION}
    $ENV{LABRENDER_DIR}
    $ENV{PROGRAMFILES}/LabRender
    /usr
    /usr/local
    /sw
    /opt/local

    PATH_SUFFIXES
    /include

    DOC "LabRender include directory")

set(LABRENDER_LIB_NAMES LabRender LabModelLoader LabRenderBinder)

foreach(LIB ${LABRENDER_LIB_NAMES})
    find_library(LABRENDER_${LIB}_LIB_RELEASE ${LIB}
        HINTS ${LABRENDER_INCLUDE_DIR}/..

        PATHS
        ${LABRENDER_LOCATION}
        $ENV{LABRENDER_DIR}
        /usr
        /usr/local
        /sw
        /opt/local

        PATH_SUFFIXES
        /lib
        DOC "LABRENDER library ${LIB}")

        if (LABRENDER_${LIB}_LIB_RELEASE)
            list(APPEND LABRENDER_LIBRARIES "${LABRENDER_${LIB}_LIB_RELEASE}")
            list(APPEND LABRENDER_LIBRARIES_RELEASE "${LABRENDER_${LIB}_LIB_RELEASE}")
            set(LABRENDER_${LIB}_FOUND TRUE)
            set(${LIB}_LIBRARY "${LABRENDER_${LIB}_LIB_RELEASE}")
            set(${LIB}_LIBRARY_RELEASE "${LABRENDER_${LIB}_LIB_RELEASE}")
        else()
            set(${LIB}_FOUND FALSE)
        endif()

    find_library(LABRENDER_${LIB}_LIB_DEBUG ${LIB}_d
        HINTS ${LABRENDER_INCLUDE_DIR}/..

        PATHS
        ${LABRENDER_LOCATION}
        $ENV{LABRENDER_DIR}
        /usr
        /usr/local
        /sw
        /opt/local

        PATH_SUFFIXES
        /lib
        DOC "LABRENDER library ${LIB}")

        if (LABRENDER_${LIB}_LIB_DEBUG)
            list(APPEND LABRENDER_LIBRARIES_DEBUG "${LABRENDER_${LIB}_LIB_DEBUG}")
            set(${LIB}_DEBUG_FOUND TRUE)
            set(${LIB}_LIBRARY_DEBUG "${LABRENDER_${LIB}_LIB_DEBUG}")
        else()
            set(${LIB}_FOUND FALSE)
        endif()
endforeach()

find_package_handle_standard_args(LABRENDER
    REQUIRED_VARS LABRENDER_LIBRARIES LABRENDER_LIBRARIES_DEBUG LABRENDER_INCLUDE_DIR)

iF (LABRENDER_FOUND)

    add_library(LabRender::Core SHARED IMPORTED)
    set_property(TARGET LabRender::Core APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
    set_property(TARGET LabRender::Core APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
    set_target_properties(LabRender::Core PROPERTIES IMPORTED_IMPLIB_RELEASE ${LabRender_LIBRARY})
    set_target_properties(LabRender::Core PROPERTIES IMPORTED_IMPLIB_DEBUG   ${LabRender_LIBRARY_DEBUG})
    set_property(TARGET LabRender::Core APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${LabRender_INCLUDE_DIR})

    add_library(LabRender::Binder SHARED IMPORTED)
    set_property(TARGET LabRender::Binder APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
    set_property(TARGET LabRender::Binder APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
    set_target_properties(LabRender::Binder PROPERTIES IMPORTED_IMPLIB_RELEASE ${LabRenderBinder_LIBRARY})
    set_target_properties(LabRender::Binder PROPERTIES IMPORTED_IMPLIB_DEBUG   ${LabRenderBinder_LIBRARY_DEBUG})
    set_property(TARGET LabRender::Binder APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${LabRender_INCLUDE_DIR})

    add_library(LabRender::ModelLoader SHARED IMPORTED)
    set_property(TARGET LabRender::ModelLoader APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG)
    set_property(TARGET LabRender::ModelLoader APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE)
    set_target_properties(LabRender::ModelLoader PROPERTIES IMPORTED_IMPLIB_RELEASE ${LabModelLoader_LIBRARY})
    set_target_properties(LabRender::ModelLoader PROPERTIES IMPORTED_IMPLIB_DEBUG   ${LabModelLoader_LIBRARY_DEBUG})
    set_property(TARGET LabRender::ModelLoader APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${LabRender_INCLUDE_DIR})

endif()

repository: meshula/LabCMake

repo_name: meshula/LabCMake


text:
@misc{energie_schlaglichter_2019,
	title = {Schlaglichter der {Wirtschaftspolitik}},
	url = {https://www.bmwi.de/Redaktion/DE/Publikationen/Schlaglichter-der-Wirtschaftspolitik/schlaglichter-der-wirtschaftspolitik-07-2019.html},
	language = {de},
	urldate = {2021-04-28},
	author = {{Bundesministerium für Wirtschaft und Energie}},
}

@webpage{t3n_2021,
	title = {Uber Eats greift Lieferando mit niedrigeren Gebühren an},
	url = {https://t3n.de/news/uber-eats-vs-lieferando-1373971/},
	language = {de},
	urldate = {2021-04-28},
	author = {{t3n}},
}
@webpage{dehoga_2019,
	title = {Anzahl der umsatzsteuerpflichtigen Unternehmen des Gastgewerbes},
	url = {https://www.dehoga-bundesverband.de/zahlen-fakten/anzahl-der-unternehmen/},
	language = {de},
	urldate = {2021-04-28},
	author = {{dehoga}},
}
@webpage{statista_umfrage_lieferienst_2021,
	title = {Haben Sie seit dem Ausbruch der Corona-Pandemie Essen nach Hause bestellt?},
	url = {https://de.statista.com/statistik/daten/studie/1135602/umfrage/bestellung-von-essen-nach-hause/},
	language = {de},
	urldate = {2021-04-28},
	author = {{Statista}},
}

@misc{tagesschau_2021,
	title = {Lieferandos Geschäft mit "Schattenwebseiten"},
	url = {https://www.tagesschau.de/investigativ/br-recherche/lieferando-websites-101.html},
	language = {de},
	urldate = {2021-04-28},
	author = {{tagesschau.de}},
}

@misc{jet_annual_2020,
	title = {Annual Report 2020},
	url = {https://www.justeattakeaway.com/investors/annual-reports},
	language = {de},
	urldate = {2021-04-28},
	author = {{Just Eat Takeway.com}},
}

@misc{jet_annual_2019,
	title = {Annual Report 2019},
	url = {https://www.justeattakeaway.com/investors/annual-reports},
	language = {de},
	urldate = {2021-04-28},
	author = {{Just Eat Takeway.com}},
}

@misc{jet_annual_2018,
	title = {Annual Report 2018},
	url = {https://www.justeattakeaway.com/investors/annual-reports},
	language = {de},
	urldate = {2021-04-28},
	author = {{Just Eat Takeway.com}},
}
@misc{dh_annual_2017,
	title = {Annual Report 2017},
	url = {https://ir.deliveryhero.com/download/companies/delivery/Hauptversammlung/AGM2018_AnnualReport2017.pdf},
	language = {de},
	urldate = {2021-04-28},
	author = {{Delivery Hero}},
}

license: MIT

repository: nfra-project/kickstart-flavor-pandoc

license_type: permissive

repo_name: nfra-project/kickstart-flavor-pandoc

branch_name: refs/heads/main

extension: bib


text:
package gui

import (
	"errors"
	"github.com/mattn/go-gtk/gdk"
	"github.com/mattn/go-gtk/glib"
	"github.com/mattn/go-gtk/gtk"
	"regexp"
	"unsafe"
)

type SettingsFunc func()

type GUI struct {
	width    int
	height   int
	window   *gtk.Window
	notebook *gtk.Notebook
	pages    map[string]*Page
	settingsBox *gtk.VBox
	settingspopup *gtk.Window
	sf SettingsFunc
}

type Page struct {
	textView *gtk.TextView
	nickTV   *gtk.TextView
	entry    *gtk.Entry
}

func NewGUI(title string, width, height int) *GUI {
	glib.ThreadInit(nil)
	gdk.ThreadsInit()
	gdk.ThreadsEnter()
	gtk.Init(nil)

	window := gtk.NewWindow(gtk.WINDOW_TOPLEVEL)
	window.SetPosition(gtk.WIN_POS_CENTER)
	window.SetTitle(title)
	window.SetIconFromFile("icon/64.png")
	window.Connect("destroy", func(ctx *glib.CallbackContext) {
		println("got destroy!", ctx.Data().(string))
		gtk.MainQuit()
	}, "foo")

	vbox := gtk.NewVBox(false, 0)

	notebook := gtk.NewNotebook()

	vbox.Add(notebook)
	window.Add(vbox)
	window.SetSizeRequest(width, height)

	gui := &GUI{window: window, notebook: notebook, pages: make(map[string]*Page),
		width: width, height: height}

	gui.createMenu(vbox)

	return gui
}

func (gui *GUI) StartMain() {
	gui.window.ShowAll()
	gtk.Main()
	gdk.ThreadsLeave()
}

func (gui *GUI) CreateChannelWindow(context string, sendFunc func()) {
	var page *gtk.Frame

	conversationRegex := "^\\w"
	regex := regexp.MustCompile(conversationRegex)
	if context == "" {
		page = gtk.NewFrame("Server")
		gui.notebook.AppendPage(page, gtk.NewLabel("Server"))
	} else {
		page = gtk.NewFrame(context)
		gui.notebook.AppendPage(page, gtk.NewLabel(context))
	}

	vbox := gtk.NewVBox(false, 1)
	hbox1 := gtk.NewHBox(false, 1)

	var nickTV *gtk.TextView
	var textView *gtk.TextView

	if context != "" && !regex.MatchString(context) {
		swin := gtk.NewScrolledWindow(nil, nil)
		swin.SetPolicy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
		swin.SetShadowType(gtk.SHADOW_IN)
		textView = gtk.NewTextView()
		textView.SetEditable(false)
		textView.SetCursorVisible(false)
		textView.SetWrapMode(gtk.WRAP_WORD)
		textView.SetSizeRequest(600, 500)
		swin.Add(textView)
		hbox1.Add(swin)

		swin2 := gtk.NewScrolledWindow(nil, nil)
		swin2.SetPolicy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
		swin2.SetShadowType(gtk.SHADOW_IN)
		nickTV = gtk.NewTextView()
		nickTV.SetEditable(false)
		nickTV.SetCursorVisible(false)
		nickTV.SetWrapMode(gtk.WRAP_WORD)
		nickTV.SetSizeRequest(200, 500)
		swin2.Add(nickTV)
		hbox1.Add(swin2)
	} else {
		swin := gtk.NewScrolledWindow(nil, nil)
		swin.SetPolicy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
		swin.SetShadowType(gtk.SHADOW_IN)
		textView = gtk.NewTextView()
		textView.SetEditable(false)
		textView.SetCursorVisible(false)
		textView.SetWrapMode(gtk.WRAP_WORD)
		textView.SetSizeRequest(800, 500)
		swin.Add(textView)
		hbox1.Add(swin)
	}

	vbox.Add(hbox1)
	hbox2 := gtk.NewHBox(false, 1)

	// entry
	entry := gtk.NewEntry()
	entry.SetSizeRequest(700, 40)
	entry.Connect("key-press-event", func(ctx *glib.CallbackContext) {
		arg := ctx.Args(0)
		kev := *(**gdk.EventKey)(unsafe.Pointer(&arg))
		if kev.Keyval == gdk.KEY_Return {
			sendFunc()
		}
	})
	hbox2.Add(entry)

	button := gtk.NewButtonWithLabel("Send")
	button.Clicked(sendFunc)
	hbox2.Add(button)

	vbox.Add(hbox2)

	page.Add(vbox)

	newPage := &Page{textView: textView, nickTV: nickTV, entry: entry}
	gui.pages[context] = newPage
	gui.window.ShowAll()
}

func (gui *GUI) DeleteCurrentWindow() {
	gui.notebook.RemovePage(nil, gui.notebook.GetCurrentPage())
	gui.window.ShowAll()
}

func (gui *GUI) DeleteChannelWindow(context string) error {
	len := gui.notebook.GetNPages()
	for i := 0; i < len; i++ {
		frame := gui.notebook.GetNthPage(i)
		if gui.notebook.GetTabLabelText(frame) == context {
			gui.notebook.RemovePage(nil, i)
			gui.window.ShowAll()
			return nil
		}
	}
	return errors.New("Context doesn't exist")
}

func (gui *GUI) WriteToChannel(s, context string) error {
	var endIter gtk.TextIter
	page, ok := gui.pages[context]
	if !ok {
		return errors.New("WriteToChannel: No Such Window!")
	}
	textBuffer := page.textView.GetBuffer()
	textBuffer.GetEndIter(&endIter)
	textBuffer.Insert(&endIter, s+"\n")

	gui.AutoScroll(page.textView, &endIter)
	return nil
}

func (gui *GUI) WriteToCurrentWindow(s string) error {
	var endIter gtk.TextIter
	i := gui.notebook.GetCurrentPage()
	frame := gui.notebook.GetNthPage(i)
	labelText := gui.notebook.GetTabLabelText(frame)

	var context string
	if labelText == "Server" {
		context = ""
	} else {
		context = labelText
	}

	page, ok := gui.pages[context]
	if !ok {
		return errors.New("WriteToChannel: No Such Window!")
	}
	textBuffer := page.textView.GetBuffer()
	textBuffer.GetEndIter(&endIter)
	textBuffer.Insert(&endIter, s+"\n")

	gui.AutoScroll(page.textView, &endIter)
	return nil
}

func (gui *GUI) WriteToNicks(s, context string) error {
	page, ok := gui.pages[context]
	if !ok {
		return errors.New("WriteToChannel: No Such Window!")
	}
	if page.nickTV != nil {
		var endIter gtk.TextIter
		textBuffer := page.nickTV.GetBuffer()
		textBuffer.GetEndIter(&endIter)
		textBuffer.Insert(&endIter, s+"\n")
	}
	return nil
}

func (gui *GUI) EmptyNicks(context string) error {
	page, ok := gui.pages[context]
	if !ok {
		return errors.New("WriteToChannel: No Such Window!")
	}
	if page.nickTV != nil {
		textBuffer := page.nickTV.GetBuffer()
		textBuffer.SetText("")
	}
	return nil
}

func (gui *GUI) AutoScroll(textview *gtk.TextView, endIter *gtk.TextIter) {
	textview.ScrollToIter(endIter, 0.0, true, 0.0, 0.0)
}

func (gui *GUI) GetEntryText(context string) (string, error) {
	page, ok := gui.pages[context]
	if !ok {
		return "", errors.New("GetEntryBuffer: No such window!")
	}
	return page.entry.GetText(), nil
}

func (gui *GUI) EmptyEntryText(context string) error {
	page, ok := gui.pages[context]
	if !ok {
		return errors.New("EmptyEntryBuffer: No such window!")
	}
	page.entry.SetText("")
	return nil
}

func (gui *GUI) Notebook() *gtk.Notebook {
	return gui.notebook
}

func (gui *GUI) createMenu(vbox *gtk.VBox) {
	menubar := gtk.NewMenuBar()
	vbox.PackStart(menubar, false, false, 0)

	menuitem := gtk.NewMenuItem()
	vbox.PackStart(menuitem, false, false, 0)

	cascademenu := gtk.NewMenuItemWithMnemonic("_File")
	menubar.Append(cascademenu)
	submenu := gtk.NewMenu()
	cascademenu.SetSubmenu(submenu)

	menuitem = gtk.NewMenuItemWithMnemonic("E_xit")
	menuitem.Connect("activate", func() {
		gtk.MainQuit()
	})
	submenu.Append(menuitem)

	cascademenu = gtk.NewMenuItemWithMnemonic("_Tools")
	menubar.Append(cascademenu)
	submenu = gtk.NewMenu()
	cascademenu.SetSubmenu(submenu)

	settings := gtk.NewMenuItemWithMnemonic("_Settings")
	settings.Connect("activate", func() {

		gui.settingspopup = gtk.NewWindow(gtk.WINDOW_TOPLEVEL)
		gui.settingspopup.SetPosition(gtk.WIN_POS_CENTER)
		gui.settingspopup.SetTitle("Settings")
		gui.settingspopup.SetKeepAbove(true)
		gui.settingspopup.Connect("destroy", func(ctx *glib.CallbackContext) {
			println("settings window got destroy!", ctx.Data().(string))
			gui.CloseSettingsWindow()
		}, "foo")
		gui.settingsBox = gtk.NewVBox(false, 0)

		gui.sf() // settings function

		gui.settingspopup.Add(gui.settingsBox)
		gui.settingspopup.ShowAll()
	})

	submenu.Append(settings)

	cascademenu = gtk.NewMenuItemWithMnemonic("_Help")
	menubar.Append(cascademenu)
	submenu = gtk.NewMenu()
	cascademenu.SetSubmenu(submenu)

	menuitem = gtk.NewMenuItemWithMnemonic("_Info")
	menuitem.Connect("activate", func() {
		dialog := gtk.NewMessageDialog(gui.window, gtk.DIALOG_DESTROY_WITH_PARENT,
			gtk.MESSAGE_INFO, gtk.BUTTONS_OK, "%s",
			"Irken works like most IRC-clients. All commands start with forward-slash(/).\n\nFor a list of commands type /help")
		dialog.Run()
		dialog.Destroy()
	})

	submenu.Append(menuitem)

	menuitem = gtk.NewMenuItemWithMnemonic("_About")
	menuitem.Connect("activate", func() {
		dialog := gtk.NewAboutDialog()
		dialog.SetName("About")
		dialog.SetProgramName("Irken")
		dialog.SetAuthors([]string{"André Nyström - github.com/andren32", "Axel Riese - github.com/axelri"})
		dialog.Run()
		dialog.Destroy()
	})

	submenu.Append(menuitem)
}

// AddSetting adds a setting to the setting menu in the form of an entry.
// Takes the setting name and the initialtext in the entry and returns
// a pointer to the entry.
func (gui *GUI) AddSetting(settingsName, initialText string) *gtk.Entry {
	vbox := gtk.NewVBox(false, 0)

	hbox1 := gtk.NewHBox(false, 0)
	label := gtk.NewLabel(settingsName)
	hbox1.Add(label)
	vbox.Add(hbox1)

	hbox2 := gtk.NewHBox(false, 0)
	entry := gtk.NewEntry()
	entry.SetEditable(true)
	entry.SetText(initialText)
	hbox2.Add(entry)
	vbox.Add(hbox2)

	gui.settingsBox.Add(vbox)
	return entry
}

// AddSettingButton adds a button to the settings menu with the label
// of the first argument. Calls on buttonFunc on click
func (gui *GUI) AddSettingButton (text string, buttonFunc func()) {
	vbox := gtk.NewVBox(false, 0)
	button := gtk.NewButtonWithLabel(text)
	button.Clicked(buttonFunc)
	vbox.Add(button)
	gui.settingsBox.Add(vbox)
}

func (gui *GUI) SetSettingsFunc (settingsfunc func()) {
	gui.sf = settingsfunc
}

func (gui *GUI) CloseSettingsWindow() {
	gui.settingspopup.Hide()
}

repository: axelri/irken

repo_name: axelri/irken

branch_name: refs/heads/master

extension: go


text:
SECTION = "x11/libs"
PRIORITY = "optional"
LICENSE = "BSD-X"

DEPENDS = "util-macros-native"

SRC_URI = "${XORG_MIRROR}/X11R7.0/src/lib/xtrans-${PV}.tar.bz2"
S = "${WORKDIR}/xtrans-${PV}"

inherit native autotools pkgconfig

extension: bb


text:
PR = "r9"
DESCRIPTION = "Alternative system logger daemon"
DEPENDS = "libol flex"

SRC_URI = "http://www.balabit.com/downloads/files/syslog-ng/sources/1.6/src/${PN}-${PV}.tar.gz \
          file://syslog-ng.conf \
	  file://initscript"

S = "${WORKDIR}/${PN}-${PV}"
inherit autotools update-rc.d

EXTRA_OECONF = "--with-libol=${STAGING_BINDIR_CROSS}/"
CONFFILES_${PN} = "${sysconfdir}/${PN}/syslog-ng.conf"
INITSCRIPT_NAME = "syslog-ng"
INITSCRIPT_PARAMS = "defaults 05"

do_install_append() {
	install -d ${D}/${sysconfdir}/${PN}
	install ${WORKDIR}/syslog-ng.conf ${D}${sysconfdir}/${PN}/syslog-ng.conf
	install -d ${D}/${sysconfdir}/init.d
	install -m 755 ${WORKDIR}/initscript ${D}/${sysconfdir}/init.d/syslog-ng
}

pkg_postinst() {
	update-rc.d -f syslog remove
}

pkg_postrm() {
	update-rc.d syslog add 5
}


text:
package config

import (
	"encoding/json"
	"net/http"

	"github.com/covidtrace/utils/env"
)

// Config is the structure describing a configuration file
type Config struct {
	ArchiveBucket               string `json:"archiveBucket"`
	HoldingBucket               string `json:"holdingBucket"`
	PublishedBucket             string `json:"publishedBucket"`
	TokenBucket                 string `json:"tokenBucket"`
	ExposureKeysHoldingBucket   string `json:"exposureKeysHoldingBucket"`
	ExposureKeysPublishedBucket string `json:"exposureKeysPublishedBucket"`
	AggLevels                   []int  `json:"aggS2Levels"`
	CompareLevel                int    `json:"compareS2Level"`
	ExposureLevel               int    `json:"exposureS2Level"`
}

// Get fetches and unmarshals
func Get() (*Config, error) {
	resp, err := http.Get(
		env.GetDefault("CONFIG_FILE", "https://storage.googleapis.com/covidtrace-config/config.json"),
	)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	var config Config
	if err := json.NewDecoder(resp.Body).Decode(&config); err != nil {
		return nil, err
	}

	return &config, nil
}

repository: covidtrace/aggregator

repo_name: covidtrace/aggregator

gha_license_id: MIT

gha_language: Go


text:
@article{art_taes97,
 author = {A. Ferrari and C. Bérenguer and G. Alengrin},
 journal = {IEEE Transactions on Aerospace and Electronic Systems},
 number = {3},
 pages = {738--751},
 title = {Doppler Ambiguity Resolution Using Multiple PRF},
 volume = {33},
 year = {1997}
}

repository: andferrari/academic-kickstart

repo_name: andferrari/academic-kickstart


text:
require bug-app.inc

DESCRIPTION = "A camera app that stores images on an X Drive account.  See xdrive.com for more information."
HOMEPAGE = "http://buglabs.net/applications/XDriveCamera"

DEPENDS += "com.buglabs.app.org.eclipse.spaces.xdrive service-tracker com.buglabs.bug.menu com.buglabs.bug.module.camera com.buglabs.common com.buglabs.bug.base com.buglabs.osgi "

PV = "5"

SRC_LINK = "http://buglabs.net/program_version/download/161"

APIVERSION = ""

repository: overo/overo-oe-natty

repo_name: overo/overo-oe-natty

branch_name: HEAD


text:
DESCRIPTION = "Terminal multiplexer"
HOMEPAGE = "http://tmux.sourceforge.net"
SECTION = "console/utils"

LICENSE = "ISC"
LIC_FILES_CHKSUM = "file://tmux.c;startline=3;endline=17;md5=75758f698fa88e729278d7f662bec19e"

DEPENDS = "ncurses libevent sed"

SRC_URI = "${SOURCEFORGE_MIRROR}/tmux/${P}.tar.gz \
	   file://tmux.sh \
	   file://tmux.conf \
"

SRC_URI[md5sum] = "9fb6b443392c3978da5d599f1e814eaa"
SRC_URI[sha256sum] = "795f4b4446b0ea968b9201c25e8c1ef8a6ade710ebca4657dd879c35916ad362"

inherit autotools-brokensep pkgconfig

do_configure_prepend () {
    sed -i -e 's:-I/usr/local/include::' ${S}/Makefile.am || bb_fatal "sed failed"
}

do_install_append () {
	install -d ${D}/${bindir} ${D}${sysconfdir}/
	install -m 755 ${WORKDIR}/tmux.sh ${D}/${bindir}/
	install -m 644 ${WORKDIR}/tmux.conf ${D}${sysconfdir}/
}


text:
require recipes-kernel/linux/linux-riscv-common.inc

LINUX_VERSION ?= "4.15"

BRANCH = "riscv-linux-4.15"
SRCREV = "2b0aa1de45f63535f6d26757aa22b48515289302"

repository: mfischer/meta-riscv

repo_name: mfischer/meta-riscv


text:
SUMMARY = "bpftrace"
HOMEPAGE = "https://github.com/iovisor/bpftrace"
LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://LICENSE;md5=3b83ef96387f14655fc854ddc3c6bd57"

DEPENDS += "bison-native \
            ninja-native \
            elfutils-native \
            flex-native \
            gtest-native \
            git-native \
            ${MLPREFIX}elfutils \
            ${MLPREFIX}binutils \
            ${MLPREFIX}flex \
            clang \
            bcc \
            "

RDEPENDS_${PN} += "bash python3"

SRC_URI = "git://github.com/iovisor/bpftrace \
           file://0001-Allow-to-build-with-OE-llvm-clang-cross-compiled-pac.patch \
           "
SRCREV = "85f9eea624c83443816e37654d0c1c93366a2e66"

S = "${WORKDIR}/git"

inherit cmake

OECMAKE_FIND_ROOT_PATH_MODE_PROGRAM = "BOTH"

EXTRA_OECMAKE = " \
    -DCMAKE_BUILD_TYPE=Release \
"

FILES_${PN} += "${prefix}/man/*"

repository: davidlt/meta-clang

repo_name: davidlt/meta-clang


text:
require xorg-app-common.inc
DESCRIPTION = "system load average display for X"
DEPENDS += " libxaw libxt"
PE = "1"
PR = "${INC_PR}.0"

SRC_URI[archive.md5sum] = "b41ed6b4bcfc9897366c27a94d2bf150"
SRC_URI[archive.sha256sum] = "86b176b6efc52557b1c7631bfdd5c17e7060a438e1e85ce15ec9657be356c50b"


text:
DESCRIPTION = "TI ICSS-EMAC low level driver tests"

DEPENDS="common-csl-ip pruss-lld icss-emac-lld osal ti-pdk-build-rtos icss-emac-lld-rtos"

DEPENDS_append_ti33x = " starterware"
DEPENDS_append_ti43x = " starterware"

include icss-emac-lld.inc

PR = "${INC_PR}.0"

EXTRA_OEMAKE += "-f makefile_armv7 PDK_INSTALL_PATH=${STAGING_INCDIR} PDK_PKG_PATH=${STAGING_DATADIR}/ti/ti-pdk-tree/packages ICSS_EMAC_SRC_DIR=${S}"

DEVICE_LIST ?= "${TI_PDK_LIMIT_SOCS}"

do_compile () {
    # Build the tests
    for device in ${DEVICE_LIST}
    do
        oe_runmake tests DEVICE="$device"
    done
}

do_install() {
    # Install the binary
    for device in ${DEVICE_LIST}
    do
        oe_runmake installbin INSTALL_BIN_BASE_DIR=${D}${bindir} DEVICE="$device"
    done
}

repository: bjornwilliam/meta-ti

repo_name: bjornwilliam/meta-ti


text:
SUMMARY = "Install a InitRamFS enabled FitImage"
LICENSE = "MIT"
FILESEXTRAPATHS:prepend := "${THISDIR}/${PN}:"
SRC_URI = " \
    file://checkfitimage.sh \
"
LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"

inherit kernel-artifact-names module-base

pkg_preinst:${PN} () {
    bootpart=`lsblk -o NAME,LABEL -r | grep "mmcblk[0-9]p[0-9] boot" | awk -F' ' '{print $1}'`
    if [ ! -z "$bootpart" ];
    then
        mount /dev/$bootpart /boot || true
        dpkg-divert --package ${PN} --divert /usr/share/kernel/${KERNEL_IMAGETYPE}-initramfs-${KERNEL_VERSION} /boot/${KERNEL_IMAGETYPE}-initramfs-${KERNEL_VERSION}
    fi
}

pkg_postinst_ontarget:${PN} () {
    ${libexecdir}/checkfitimage.sh || true
}

pkg_prerm:${PN} () {
    dpkg-divert --remove /boot/${KERNEL_IMAGETYPE}-initramfs-${KERNEL_VERSION}
    ${libexecdir}/checkfitimage.sh || true
}

do_install() {
    install -d -m 0755 ${D}/boot/
    ls ${DEPLOY_DIR_IMAGE}/fitImage-*${KERNEL_FIT_BIN_EXT}
    install -m 0644 ${DEPLOY_DIR_IMAGE}/fitImage-${INITRAMFS_IMAGE}-${MACHINE}--${KERNEL_VERSION}*${KERNEL_FIT_BIN_EXT} ${D}/boot/${KERNEL_IMAGETYPE}-initramfs-${KERNEL_VERSION}
    install -d -m 0755 ${D}/${libexecdir}
    install -m 0755 ${WORKDIR}/checkfitimage.sh ${D}/${libexecdir}/
}

FILES:${PN} += " \
    /boot/${KERNEL_IMAGETYPE}-initramfs-${KERNEL_VERSION} \
    ${libexecdir}/checkfitimage.sh \
"

do_install[depends] = "virtual/kernel:do_deploy"

RDEPENDS:${PN} += " \
    u-boot-tools \
    kernel-modules (>= ${PV}) \
"

RREPLACES:${PN} = " \
    kernel-image-fitimage \
"

gha_language: BitBake


text:
@techreport{Zisimatos2015TR,
  title={How to Create Affordable, Modular, Light-Weight, Underactuated, Compliant Robot Hands},
  author={Zisimatos, Agisilaos G and Liarokapis, Minas V and Mavrogiannis, Christoforos I and Kontoudis, George P and Kyriakopoulos, Kostas J},
  year={2015},
  institution={National Technical University of Athens}
}


text:
// Copyright 2018 Fortio Authors
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Package bincommon is the common code and flag handling between the fortio
// (fortio_main.go) and fcurl (fcurl.go) executables.
package bincommon

// Do not add any external dependencies we want to keep fortio minimal.

import (
	"context"
	"flag"
	"net/http"
	"os"
	"reflect"
	"strings"

	"fortio.org/dflag"
	"fortio.org/fortio/fhttp"
	"fortio.org/fortio/fnet"
	"fortio.org/fortio/periodic"
	"fortio.org/log"
)

// -- Support for multiple instances of -H flag on cmd line.
type headersFlagList struct{}

func (f *headersFlagList) String() string {
	return ""
}

func (f *headersFlagList) Set(value string) error {
	return httpOpts.AddAndValidateExtraHeader(value)
}

// -- end of functions for -H support

// FortioHook is used in cli and rapi to customize the run and introduce for instance clienttrace
// and otel access logger.
type FortioHook func(*fhttp.HTTPOptions, *periodic.RunnerOptions)

var (
	compressionFlag = flag.Bool("compression", false, "Enable http compression")
	keepAliveFlag   = flag.Bool("keepalive", true, "Keep connection alive (only for fast http 1.1)")
	halfCloseFlag   = flag.Bool("halfclose", false,
		"When not keepalive, whether to half close the connection (only for fast http)")
	httpReqTimeoutFlag  = flag.Duration("timeout", fhttp.HTTPReqTimeOutDefaultValue, "Connection and read timeout value (for http)")
	stdClientFlag       = flag.Bool("stdclient", false, "Use the slower net/http standard client (slower but supports h2/h2c)")
	http10Flag          = flag.Bool("http1.0", false, "Use http1.0 (instead of http 1.1)")
	h2Flag              = flag.Bool("h2", false, "Attempt to use http2.0 / h2 (instead of http 1.1) for both TLS and h2c")
	httpsInsecureFlag   = flag.Bool("k", false, "Do not verify certs in https/tls/grpc connections")
	httpsInsecureFlagL  = flag.Bool("https-insecure", false, "Long form of the -k flag")
	resolve             = flag.String("resolve", "", "Resolve host name to this `IP`")
	headersFlags        headersFlagList
	httpOpts            fhttp.HTTPOptions
	followRedirectsFlag = flag.Bool("L", false, "Follow redirects (implies -std-client) - do not use for load test")
	userCredentialsFlag = flag.String("user", "", "User credentials for basic authentication (for http). Input data format"+
		" should be `user:password`")
	contentTypeFlag = flag.String("content-type", "",
		"Sets http content type. Setting this value switches the request method from GET to POST.")
	// PayloadSizeFlag is the value of -payload-size.
	PayloadSizeFlag = flag.Int("payload-size", 0, "Additional random payload size, replaces -payload when set > 0,"+
		" must be smaller than -maxpayloadsizekb. Setting this switches http to POST.")
	// PayloadFlag is the value of -payload.
	PayloadFlag = flag.String("payload", "", "Payload string to send along")
	// PayloadFileFlag is the value of -paylaod-file.
	PayloadFileFlag = flag.String("payload-file", "", "File `path` to be use as payload (POST for http), replaces -payload when set.")
	// PayloadStreamFlag for streaming payload from stdin (curl only).
	PayloadStreamFlag = flag.Bool("stream", false, "Stream payload from stdin (only for fortio curl mode)")
	// UnixDomainSocket to use instead of regular host:port.
	unixDomainSocketFlag = flag.String("unix-socket", "", "Unix domain socket `path` to use for physical connection")
	// CertFlag is the flag for the path for the client custom certificate.
	CertFlag = flag.String("cert", "", "`Path` to the certificate file to be used for client or server TLS")
	// KeyFlag is the flag for the path for the key for the `cert`.
	KeyFlag = flag.String("key", "", "`Path` to the key file matching the -cert")
	// CACertFlag is the flag for the path of the custom CA to verify server certificates in client calls.
	CACertFlag = flag.String("cacert", "",
		"`Path` to a custom CA certificate file to be used for the TLS client connections, "+
			"if empty, use https:// prefix for standard internet/system CAs")
	mTLS = flag.Bool("mtls", false, "Require client certificate signed by -cacert for client connections")
	// LogErrorsFlag determines if the non ok http error codes get logged as they occur or not.
	LogErrorsFlag = flag.Bool("log-errors", true, "Log http non 2xx/418 error codes as they occur")
	// RunIDFlag is optional RunID to be present in json results (and default json result filename if not 0).
	RunIDFlag = flag.Int64("runid", 0, "Optional RunID to add to json result and auto save filename, to match server mode")
	// HelpFlag is true if help/usage is being requested by the user.
	warmupFlag = flag.Bool("sequential-warmup", false,
		"http(s) runner warmup done in parallel instead of sequentially. When set, restores pre 1.21 behavior")
	curlHeadersStdout = flag.Bool("curl-stdout-headers", false,
		"Restore pre 1.22 behavior where http headers of the fast client are output to stdout in curl mode. now stderr by default.")
	// ConnectionReuseRange Dynamic string flag to set the max connection reuse range.
	ConnectionReuseRange = dflag.Flag("connection-reuse", dflag.New("",
		"Range `min:max` for the max number of connections to reuse for each thread, default to unlimited. "+
			"e.g. 10:30 means randomly choose a max connection reuse threshold between 10 and 30 requests.").
		WithValidator(ConnectionReuseRangeValidator(&httpOpts)))
	// NoReResolveFlag is false if we want to resolve the DNS name for each new connection.
	NoReResolveFlag = flag.Bool("no-reresolve", false, "Keep the initial DNS resolution and "+
		"don't re-resolve when making new connections (because of error or reuse limit reached)")
	MethodFlag = flag.String("X", "", "HTTP method to use instead of GET/POST depending on payload/content-type")
)

// SharedMain is the common part of main from fortio_main and fcurl.
// It sets up the common flags, the rest of usage/argument/flag handling
// is now moved to the [fortio.org/cli] and [fortio.org/scli] packages.
func SharedMain() {
	flag.Var(&headersFlags, "H",
		"Additional http header(s) or grpc metadata. Multiple `key:value` pairs can be passed using multiple -H.")
	flag.IntVar(&fhttp.BufferSizeKb, "httpbufferkb", fhttp.BufferSizeKb,
		"Size of the buffer (max data size) for the optimized http client in `kbytes`")
	flag.BoolVar(&fhttp.CheckConnectionClosedHeader, "httpccch", fhttp.CheckConnectionClosedHeader,
		"Check for Connection: Close Header")
	// FlagResolveIPType indicates which IP types to resolve.
	// With round robin resolution now the default, you are likely to get ipv6 which may not work if
	// use both type (`ip`). In particular some test environments like the CI do have ipv6
	// for localhost but fail to connect. So we made the default ip4 only.
	dflag.Flag("resolve-ip-type", fnet.FlagResolveIPType)
	// FlagResolveMethod decides which method to use when multiple ips are returned for a given name
	// default assumes one gets all the ips in the first call and does round robin across these.
	// first just picks the first answer, rr rounds robin on each answer.
	dflag.Flag("dns-method", fnet.FlagResolveMethod)
	dflag.Flag("echo-server-default-params", fhttp.DefaultEchoServerParams)
	dflag.FlagBool("proxy-all-headers", fhttp.Fetch2CopiesAllHeader)
	dflag.Flag("server-idle-timeout", fhttp.ServerIdleTimeout)
	// MaxDelay is the maximum delay allowed for the echoserver responses.
	// It is a dynamic flag with default value of 1.5s so we can test the default 1s timeout in envoy.
	dflag.Flag("max-echo-delay", fhttp.MaxDelay)
	// call [scli.ServerMain()] to complete the setup.
}

// FetchURL is fetching url content and exiting with 1 upon error.
// common part between fortio_main and fcurl.
func FetchURL(o *fhttp.HTTPOptions) {
	// keepAlive could be just false when making 1 fetch but it helps debugging
	// the http client when making a single request if using the flags
	o.DataWriter = os.Stdout
	client, _ := fhttp.NewClient(o)
	// big gotcha that nil client isn't nil interface value (!)
	if client == nil || reflect.ValueOf(client).IsNil() {
		os.Exit(1) // error logged already
	}
	var code int
	var dataLen int64
	var header uint
	if client.HasBuffer() {
		// Fast client
		var data []byte
		var headerI int
		code, data, headerI = client.Fetch(context.Background())
		dataLen = int64(len(data))
		header = uint(headerI)
		if *curlHeadersStdout {
			os.Stdout.Write(data)
		} else {
			os.Stderr.Write(data[:header])
			os.Stdout.Write(data[header:])
		}
	} else {
		code, dataLen, header = client.StreamFetch(context.Background())
	}
	log.LogVf("Fetch result code %d, data len %d, headerlen %d", code, dataLen, header)
	if code != http.StatusOK {
		log.Errf("Error status %d", code)
		os.Exit(1)
	}
}

// TLSInsecure returns true if -k or -https-insecure was passed.
func TLSInsecure() bool {
	TLSInsecure := *httpsInsecureFlag || *httpsInsecureFlagL
	if TLSInsecure {
		log.Infof("TLS certificates will not be verified, per flag request")
	} else {
		log.LogVf("Will verify TLS certificates, use -k / -https-insecure to disable")
	}
	return TLSInsecure
}

// ConnectionReuseRangeValidator returns a validator function that checks if the connection reuse range is valid
// and set in httpOpts.
func ConnectionReuseRangeValidator(httpOpts *fhttp.HTTPOptions) func(string) error {
	return func(value string) error {
		return httpOpts.ValidateAndSetConnectionReuseRange(value)
	}
}

// SharedHTTPOptions is the flag->httpoptions transfer code shared between
// fortio_main and fcurl.
func SharedHTTPOptions() *fhttp.HTTPOptions {
	url := strings.TrimLeft(flag.Arg(0), " \t\r\n")
	httpOpts.URL = url
	httpOpts.HTTP10 = *http10Flag
	httpOpts.H2 = *h2Flag
	httpOpts.DisableFastClient = *stdClientFlag
	httpOpts.DisableKeepAlive = !*keepAliveFlag
	httpOpts.AllowHalfClose = *halfCloseFlag
	httpOpts.Compression = *compressionFlag
	httpOpts.HTTPReqTimeOut = *httpReqTimeoutFlag
	httpOpts.Insecure = TLSInsecure()
	httpOpts.Resolve = *resolve
	httpOpts.UserCredentials = *userCredentialsFlag
	if len(*contentTypeFlag) > 0 {
		// only set content-type from flag if flag isn't empty as it can come also from -H content-type:...
		httpOpts.ContentType = *contentTypeFlag
	}
	if *PayloadStreamFlag {
		httpOpts.PayloadReader = os.Stdin
	} else {
		// Returns nil if file read error, an empty but non nil slice if no payload is requested.
		httpOpts.Payload = fnet.GeneratePayload(*PayloadFileFlag, *PayloadSizeFlag, *PayloadFlag)
		if httpOpts.Payload == nil {
			// Error already logged
			os.Exit(1)
		}
	}
	httpOpts.UnixDomainSocket = *unixDomainSocketFlag
	if *followRedirectsFlag {
		httpOpts.FollowRedirects = true
		httpOpts.DisableFastClient = true
	}
	httpOpts.CACert = *CACertFlag
	httpOpts.Cert = *CertFlag
	httpOpts.Key = *KeyFlag
	httpOpts.MTLS = *mTLS
	httpOpts.LogErrors = *LogErrorsFlag
	httpOpts.SequentialWarmup = *warmupFlag
	httpOpts.NoResolveEachConn = *NoReResolveFlag
	httpOpts.MethodOverride = *MethodFlag
	return &httpOpts
}

repository: fortio/fortio

repo_name: fortio/fortio


text:
DESCRIPTION = "libnfnetlink is the low-level library for netfilter related \
kernel/userspace communication. It provides a generic messaging \
infrastructure for in-kernel netfilter subsystems (such as nfnetlink_log, \
nfnetlink_queue, nfnetlink_conntrack) and their respective users and/or \
management tools in userspace."

SECTION = "devel/libs"
LICENSE = "GPL"
HOMEPAGE = "http://www.netfilter.org/projects/libnfnetlink/index.html"
PR = "r0"

SRC_URI = "http://www.netfilter.org/projects/libnfnetlink/files/libnfnetlink-${PV}.tar.bz2"

inherit autotools pkgconfig

#do_configure() {
#	gnu-configize
#	libtoolize --force
#	oe_runconf
#}

do_stage() {
	autotools_stage_all
}


text:
// Package ihome 包含iHome API相关结构体
//
// https://open.taobao.com/API.htm?docId=43219&docType=2
package ihome

repository: wp-jackliu/opentaobao

repo_name: wp-jackliu/opentaobao


text:
import React, { useState } from "react";
import { graphql, useStaticQuery } from "gatsby";
import Layout from "../components/Layout";
import CollectionPostTemplate from "./collection-post";
import { Link } from "gatsby";
import { SidebarNav } from "../components/SidebarNav";
import DetailModal from "../components/DetailModal";
import TypeSectionCollection from "../components/TypeSectionCollection";

export default () => {
  const [modalOpen, setModalOpen] = useState(false);
  const [detailInfo, setDetailInfo] = useState({});

  const data = useStaticQuery(graphql`
    query collectionPostQuery {
      allMarkdownRemark(
        filter: { frontmatter: { templateKey: { eq: "collection-post" } } }
      ) {
        edges {
          node {
            html
            frontmatter {
              name
              description
              featuredimage {
                childImageSharp {
                  fluid(maxWidth: 640, quality: 100) {
                    ...GatsbyImageSharpFluid
                  }
                }
              }
              dob
              genetics
            }
          }
        }
      }
    }
  `);

  const getArray = (name) => {
    return data.allMarkdownRemark.edges.filter(
      (item) => item.node.frontmatter.genetics == name
    );
  };

  const setDetailsAndOpen = (name, image, content, price, sex, dob) => {
    setModalOpen(true);
    setDetailInfo({
      name,
      image,
      content,
      price,
      sex,
      dob,
    });
  };

  const showDetailModal = () => {
    return <DetailModal setModal={setModalOpen} details={detailInfo} />;
  };

  return (
    <Layout navbarBackground="#032108" currentPage=" Our Collection">
      {modalOpen ? showDetailModal() : null}

        <SidebarNav currentPage="/collection-container" />

Collection

Jump To...

                <Link to="#wild-type">Wild Type</Link>

                <Link to="#hypo">Hypo</Link>

                <Link to="#t+">T +</Link>

                <Link to="#t-">T -</Link>

                <Link to="#pied">Pied</Link>

                <Link to="#xanthic">Xanthic</Link>

          <TypeSectionCollection
            title="Wild Type"
            typeArray={getArray("wild-type")}
            id="wild-type"
            setDetailsAndOpen={setDetailsAndOpen}
          />
          <TypeSectionCollection
            title="Hypo"
            typeArray={getArray("hypo")}
            id="hypo"
            setDetailsAndOpen={setDetailsAndOpen}
          />

          <TypeSectionCollection
            title="T +"
            typeArray={getArray("t+")}
            id="t+"
            setDetailsAndOpen={setDetailsAndOpen}
          />

          <TypeSectionCollection
            title="T -"
            typeArray={getArray("t-")}
            id="t-"
            setDetailsAndOpen={setDetailsAndOpen}
          />

          <TypeSectionCollection
            title="Pied"
            typeArray={getArray("pied")}
            id="pied"
            setDetailsAndOpen={setDetailsAndOpen}
          />

          <TypeSectionCollection
            title="Xanthic"
            typeArray={getArray("xanthic")}
            id="xanthic"
            setDetailsAndOpen={setDetailsAndOpen}
          />

    </Layout>
  );
};

repository: TheHuns/durango-boas

repo_name: TheHuns/durango-boas

gha_language: JavaScript

extension: js


text:
DESCRIPTION = "A console-only with QtXBee temperature monitor demo installed"

# customize IMAGE_FEATURES as follows
IMAGE_FEATURES += " \
    debug-tweaks \
    ssh-server-openssh \
    "

# packagegroup-core-tools-profile will build and install tracing and profiling tools to the target image.
# packagegroup-core-buildessential will build and install autotools, gcc, etc. to the target image.
# kernel-modules for install of the kernel modules.
# kernel-devsrc for building out of tree modules.
# IMAGE_ROOTFS_EXTRA_SPACE_append for adding extra space to the target rootfs image.

# customize IMAGE_INSTALL as follows
IMAGE_INSTALL = "\
    packagegroup-core-boot \
    kernel-modules \
    ${CORE_IMAGE_EXTRA_INSTALL} \
    qtxbee-examples \
    qtxbee-temp-monitor-init-script \
    kernel-module-ftdi-sio \
    "
inherit core-image

# Add extra space to the rootfs image
IMAGE_ROOTFS_EXTRA_SPACE_append += "+ 30000"

repository: ThomArmax/meta-armax

repo_name: ThomArmax/meta-armax


text:
package pluginutil

import (
	"strconv"
	"strings"

	"code.cloudfoundry.org/cli/plugin"
)

const numComponents = 3

// ParsePluginVersion parses the given plugin version and return its parsed form. If the given plugin
// version is invalid, calls the given fail function with a suitable message. The fail function will
// typically, except in testing, exit the process or panic.
func ParsePluginVersion(pv string, fail func(format string, inserts ...interface{})) plugin.VersionType {
	v := getPluginVersionComponents(pv, fail)

	return plugin.VersionType{
		Major: v[0],
		Minor: v[1],
		Build: v[2],
	}
}

func getPluginVersionComponents(pv string, fail func(format string, inserts ...interface{})) []int {
	intComponents := make([]int, numComponents)
	components := strings.Split(pv, ".")
	if len(components) != numComponents {
		fail(`pluginVersion %q has invalid format. Expected %d dot-separated integer components.`, pv, numComponents)
		return intComponents
	}

	for c := 0; c < numComponents; c++ {
		v, err := strconv.Atoi(components[c])
		if err != nil {
			fail(`pluginVersion %q has invalid format. Expected integer components.`, pv)
			return intComponents
		}
		intComponents[c] = v
	}
	return intComponents
}


text:
// Copyright 2015-2016 Apcera Inc. All rights reserved.

package commands

import (
	"encoding/json"
	"fmt"
	"os"
	"strings"

	"github.com/apcera/kurma/pkg/apiclient"
	"github.com/apcera/kurma/pkg/cli"
	"github.com/apcera/kurma/pkg/image"
	"github.com/apcera/util/tempfile"
	"github.com/appc/spec/schema"
	"github.com/appc/spec/schema/types"
	"github.com/spf13/cobra"

	kschema "github.com/apcera/kurma/schema"
)

var (
	CreateCmd = &cobra.Command{
		Use:   "create FILE",
		Short: "Create a new pod",
		Run:   cmdCreate,
	}

	createManifestFile string
	createName         string
	createNetworks     []string
)

func init() {
	cli.RootCmd.AddCommand(CreateCmd)
	CreateCmd.Flags().StringVarP(&createName, "name", "n", "", "pod's name")
	CreateCmd.Flags().StringVarP(&createManifestFile, "manifest", "", "", "specific manifest to use")
	CreateCmd.Flags().StringSliceVarP(&createNetworks, "net", "", []string{}, "network to attach to the pod")
}

func createPodFromFile(file string) (*apiclient.Image, error) {
	var f tempfile.ReadSeekCloser

	// open the file
	f, err := os.Open(file)
	if err != nil {
		if os.IsNotExist(err) {
			info, err := cli.GetClient().Info()
			if err != nil {
				fmt.Printf("Failed to retrieve host information: %v\n", err)
				os.Exit(1)
			}
			labels := make(map[types.ACIdentifier]string)
			labels[types.ACIdentifier("os")] = "linux"
			labels[types.ACIdentifier("arch")] = info.Arch

			layers, err := image.Fetch(file, labels, true)
			if err != nil {
				fmt.Printf("Failed to retrieve the container image: %v\n", err)
				os.Exit(1)
			}
			if len(layers) != 1 {
				fmt.Println("Multi-layer images currently not supported")
				os.Exit(1)
			}
			f = layers[0]
		} else {
			fmt.Printf("Failed to open the container image: %v\n", err)
			os.Exit(1)
		}
	}
	defer f.Close()

	// create the image
	image, err := cli.GetClient().CreateImage(f)
	if err != nil {
		fmt.Printf("Failed to create the image: %v\n", err)
		os.Exit(1)
	}

	return image, nil
}

func cmdCreate(cmd *cobra.Command, args []string) {
	// if a manifest file is given, then read it and use it as the manifest
	manifest := schema.BlankPodManifest()
	if createManifestFile != "" {
		manifestFile, err := os.Open(createManifestFile)
		if err != nil {
			fmt.Printf("Failed to open the manifest file: %v\n", err)
			os.Exit(1)
		}
		defer manifestFile.Close()

		if err := json.NewDecoder(manifestFile).Decode(&manifest); err != nil {
			fmt.Printf("Failed to parse the provided manifest: %v\n", err)
			os.Exit(1)
		}
	} else {
		if len(args) == 0 {
			cmd.Help()
			os.Exit(1)
		}

		image, err := createPodFromFile(args[0])
		if err != nil {
			fmt.Printf("Failed to handle image: %v\n", err)
			os.Exit(1)
		}

		// handle a blank name
		if createName == "" {
			n, err := convertACIdentifierToACName(image.Manifest.Name)
			if err != nil {
				fmt.Printf("Failed to convert the pod name: %v\n", err)
				os.Exit(1)
			}
			createName = n.String()
		}

		imageID, err := types.NewHash(image.Hash)
		if err != nil {
			fmt.Printf("Failed to parse the image hash: %v\n", err)
			os.Exit(1)
		}

		// create the app
		app := image.Manifest.App
		// override the exec command if more than 1 args are given
		if len(args) > 1 {
			app.Exec = args[1:]
		}

		// create the RuntimeApp
		runtimeApp := schema.RuntimeApp{
			Name: *types.MustACName(createName),
			Image: schema.RuntimeImage{
				ID: *imageID,
			},
			App: app,
		}
		manifest.Apps = append(manifest.Apps, runtimeApp)
	}

	// check for host networking to add the isolator on
	hostNetworking := false
	for _, n := range createNetworks {
		if n == "host" {
			hostNetworking = true
			createNetworks = nil
			break
		}
	}
	if hostNetworking {
		if err := setHostNetworking(manifest); err != nil {
			fmt.Printf("Failed to update the pod for host networking: %v\n", err)
			os.Exit(1)
		}
	}

	req := &apiclient.PodCreateRequest{
		Name:     createName,
		Pod:      manifest,
		Networks: createNetworks,
	}

	// create the container
	pod, err := cli.GetClient().CreatePod(req)
	if err != nil {
		fmt.Printf("Failed to launch the new container: %v\n", err)
		os.Exit(1)
	}

	fmt.Printf("Launched pod %s\n", pod.UUID)
}

func convertACIdentifierToACName(name types.ACIdentifier) (*types.ACName, error) {
	parts := strings.Split(name.String(), "/")
	n, err := types.SanitizeACName(parts[len(parts)-1])
	if err != nil {
		return nil, err
	}
	return types.NewACName(n)
}

func setHostNetworking(pod *schema.PodManifest) error {
	for _, i := range pod.Isolators {
		if i.Name.String() != kschema.LinuxNamespacesName {
			continue
		}

		if iso, ok := i.Value().(*kschema.LinuxNamespaces); ok {
			iso.SetNet(kschema.LinuxNamespaceHost)
			return nil
		}
	}

	iso := kschema.NewLinuxNamespace().(*kschema.LinuxNamespaces)
	iso.SetNet(kschema.LinuxNamespaceHost)

	var interim struct {
		Name  string              `json:"name"`
		Value types.IsolatorValue `json:"value"`
	}
	interim.Name = kschema.LinuxNamespacesName
	interim.Value = iso

	b, err := json.Marshal(interim)
	if err != nil {
		return err
	}

	var i types.Isolator
	if err := i.UnmarshalJSON(b); err != nil {
		return err
	}

	pod.Isolators = append(pod.Isolators, i)
	return nil
}

repository: krobertson/kurma

repo_name: krobertson/kurma


text:
package plugins

import (
	"sync"

	"github.com/helmfile/vals"
)

const (
	// cache size for improving performance of ref+.* secrets rendering
	valsCacheSize = 512
)

var instance *vals.Runtime
var once sync.Once

func ValsInstance() (*vals.Runtime, error) {
	var err error
	once.Do(func() {
		instance, err = vals.New(vals.Options{CacheSize: valsCacheSize})
	})

	return instance, err
}

repository: olivierboudet/helmfile

repo_name: olivierboudet/helmfile


text:
DESCRIPTION = "Evince is simply a document viewer"
LICENSE = "GPL"
DEPENDS = "tiff espgs poppler gtk+ libgnomeui libgnomeprint libgnomeprintui"
RDEPENDS = "espgs gconf"
RRECOMMENDS = "gnome-vfs-plugin-file"
PR = "r1"

SRC_URI = "http://ftp.gnome.org/pub/GNOME/sources/evince/0.3/${PN}-${PV}.tar.bz2 \
		file://no-doc.patch;patch=1"

EXTRA_OECONF = "--disable-tiff"

inherit gnome pkgconfig

repository: Terentyev/familiar-linux

repo_name: Terentyev/familiar-linux


text:
@article{tang_integrating_2009,
	title = {Integrating post-genomic approaches as a strategy to advance our understanding of health and disease},
	rights = {Copyright 2009 {BioMed} Central Ltd},
	url = {http://genomemedicine.com/content/1/3/35/},
	author = {Tang, Jing and Tan, Chong and Oresic, Matej and Vidal-Puig, Antonio},
	urldate = {2009-04-22},
	date = {2009-03-30},
	note = {Abstract Following the publication of the complete human genomic sequence, the post-genomic era is driven by the need to extract useful information from genomic data. Genomics, transcriptomics, proteomics, metabolomics, epidemiological data and microbial data provide different angles to our understanding of gene-environment interactions and the determinants of disease and health. Our goal and our challenge are to integrate these very different types of data and perspectives of disease into a global model suitable for dissecting the mechanisms of disease and for predicting novel therapeutic strategies. This review aims to highlight the need for and problems with complex data integration, and proposes a framework for data integration. While there are many obstacles to overcome, biological models based upon multiple datasets will probably become the basis that drives future biomedical research.}
}

repository: pmean/build-website

repo_name: pmean/build-website


text:
@article{RUFFINO2022103495,
title = {Physically-admissible polarimetric data augmentation for road-scene analysis},
journal = {Computer Vision and Image Understanding},
volume = {222},
pages = {103495},
year = {2022},
issn = {1077-3142},
doi = {https://doi.org/10.1016/j.cviu.2022.103495},
url = {https://www.sciencedirect.com/science/article/pii/S1077314222000959},
author = {Cyprien Ruffino and Rachel Blin and Samia Ainouz and Gilles Gasso and Romain H  rault and Fabrice Meriaudeau and St  phane Canu},
keywords = {Polarimetric imaging, Generative modeling: Road-scene analysis, Data augmentation: Generative Adversarial Networks},
abstract = {Polarimetric imaging, along with deep learning, has shown improved performances on different tasks including scene analysis. However, its robustn>
}

repository: cyprienruffino/academic-kickstart

repo_name: cyprienruffino/academic-kickstart


text:
LICENSE     = "LiPS"
DESCRIPTION = "LiPS address book"
SECTION = "gpe"
PRIORITY    = "optional"
PR          = "r0"
PV = "0.1+svnr-${SRCREV}"

DEFAULT_PREFERENCE = "-1"

DEPENDS = "gtk+ libgpewidget libgpephone dbus-glib libabenabler libiac libim"

inherit gpephone autotools

SRC_URI = "${GPEPHONE_SVN}"

S = "${WORKDIR}/${PN}"

FILES_${PN} += "${datadir}/database"


text:
package service

import (
	"database/sql"
	"time"
	"gitlab.xunlei.cn/xllive/common/log"
	"os"
	"github.com/go-redis/redis"
	"sync/atomic"
)

type Service struct {
	db            *sql.DB                       `json:"-"`
	leaderKey     string                        `json:"-"`
	redis         *redis.Client                 `json:"-"`
	ID            int64   `json:"ID"`
	Address       string  `json:"Address"`
	Updated       int64   `json:"Updated"`
	Status        int64   `json:"Status"`    // 1在线 0离线
	Name          string  `json:"Name"`
	Leader        int64   `json:"Leader"`
	Unique        string  `json:"Unique"`
	Offline       int64   `json:"Offline"`
}

// new service
func NewService(
	db *sql.DB,                // 数据库操作资源句柄
	Address string,            // 服务地址， 如 127.0.0.1：38001
	leaderKey string,
	redis *redis.Client,
) *Service {
	name := "wing-crontab"
	n, _ := os.Hostname()
	if "" != n {
		name = n
	}
 	s := &Service{
		db:            db,
		Address:       Address,
		Name:          name,
		Status:        1,
		leaderKey:     leaderKey,
		redis:         redis,
		Leader:        0,
		Unique:        name + "-" + Address,
		Offline:       0,
	}
	// 初始化，主要检查服务是否存在，如果存在会初始化ID
	s.init()
	s.register()
 	go s.keepAlive()
	return s
}

// set node to offline or online
func (s *Service) SetOffline(serviceId int64, offline bool) {
	if serviceId != s.ID {
		return
	}
	if offline {
		atomic.StoreInt64(&s.Offline, 1)
	} else {
		atomic.StoreInt64(&s.Offline, 0)
	}
}

// check node is offline
func (s *Service) IsOffline() bool {
	if atomic.LoadInt64(&s.Offline) == 1 {
		log.Warnf("node [%v] is offline", s.ID)
		return true
	}
	return false
}

// panic if query database error
// init service info at start
func (s *Service) init() {
	row := s.db.QueryRow("SELECT `id`, `updated`, `offline` FROM `services` WHERE `name`=? and `address`=?", s.Name, s.Address)
	var id, updated, offline int64
	err := row.Scan(&id, &updated, &offline)
	if err != nil && err != sql.ErrNoRows {
		panic(err)
	}
	if err == nil {
		s.ID = id
		s.Updated = updated
		atomic.StoreInt64(&s.Offline, offline)
	}
}

// panic if error happened
func (s *Service) SelectLeader() bool {
	v, err := s.redis.Incr(s.leaderKey).Result()
	if err != nil {
		log.Errorf("selectLeader s.redis.Incr fail, error=[%v]", err)
		return false
	}
	if 1 != v {
		atomic.StoreInt64(&s.Leader, 0)
		return false
	}
	if err = s.redis.Expire(s.leaderKey, time.Second * 3).Err(); nil != err {
		log.Errorf("selectLeader s.redis.Expire fail, error=[%v]", err)
		//return false
	}
	atomic.StoreInt64(&s.Leader, 1)
	return true
}

func (s *Service) FreeLeader() {
	s.redis.Del(s.leaderKey)
	atomic.StoreInt64(&s.Leader, 0)
}

// keep service alive
func (s *Service) keepAlive() (error) {
	for {
		if s.ID <= 0 {
			time.Sleep(time.Second * 1)
			continue
		}

		t := time.Now().Unix()
		res, err := s.db.Exec("UPDATE `services` SET `updated`=? WHERE id=?", t, s.ID)
		if err != nil {
			log.Errorf("keepAlive s.db.Exec fail, error=[%v]", err)
			time.Sleep(time.Second * 1)
			continue
		}
		_, err = res.RowsAffected()
		if err != nil {
			log.Errorf("keepAlive res.RowsAffected fail, error=[%v]", err)
			time.Sleep(time.Second * 1)
			continue
		}

		s.Updated = t
		time.Sleep(time.Second * 1)
	}
}

// update db
// update service to leader
func (s *Service) updateIsLeader() error {
	sqlStr := "UPDATE `services` SET `is_leader`=0 WHERE id!=?"
	_, err := s.db.Exec(sqlStr, s.ID)
	if err != nil {
		log.Errorf("updateIsLeader s.db.Exec fail, error=[%v]", err)
		return err
	}
	sqlStr = "UPDATE `services` SET `is_leader`=1 WHERE id=?"
	_, err = s.db.Exec(sqlStr, s.ID)
	if err != nil {
		log.Errorf("updateIsLeader s.db.Exec fail, error=[%v]", err)
		return err
	}
	return nil
}

func (s *Service) updateNotIsLeader() error {
	sqlStr := "UPDATE `services` SET `is_leader`=0 WHERE id=?"
	_, err := s.db.Exec(sqlStr, s.ID)
	if err != nil {
		log.Errorf("updateNotIsLeader s.db.Exec fail, error=[%v]", err)
		return err
	}
	return nil
}

// update db
// update service to offline or online
func (s *Service) UpdateOffline(serviceId, offline int64) error {
	sqlStr := "UPDATE `services` SET `offline`=? WHERE id=?"
	_, err := s.db.Exec(sqlStr, offline, serviceId)
	if err != nil {
		log.Errorf("UpdateOffline s.db.Exec fail, error=[%v]", err)
		return err
	}
	return nil
}

// 服务注册
// panic if error happened
// only register at start
func (s *Service) register() (int64, error) {
	//defer s.onRegister(s.ID)
	if s.ID > 0 {
		return s.ID, nil
	}
	res, err := s.db.Exec("INSERT INTO `services`(`name`, `address`, `updated`) VALUES (?,?,?)", s.Name, s.Address, time.Now().Unix())
	if err != nil {
		log.Errorf("Register s.db.Exec fail, error=[%v]", err)
		panic(err)
		return 0, err
	}
	id, err := res.LastInsertId()
	if err != nil {
		log.Errorf("Register res.LastInsertId fail, error=[%v]", err)
		panic(err)
		return 0, err
	}
	s.ID = id
	s.Updated = time.Now().Unix()
	return id, nil
}

// 服务注销
func (s *Service) Deregister() error {
	res, err := s.db.Exec("DELETE FROM `services` WHERE id=?", s.ID)
	if err != nil {
		log.Errorf("Deregister s.db.Exec fail, error=[%v]", err)
		return err
	}
	_, err = res.RowsAffected()
	if err != nil {
		log.Errorf("Deregister res.RowsAffected fail, error=[%v]", err)
		return err
	}
	if 1 == atomic.LoadInt64(&s.Leader) {
		s.redis.Del(s.leaderKey)
		atomic.StoreInt64(&s.Leader, 0)
		//s.onLeader(false, s.ID)
	}
	return nil
}

func (s *Service) IsLeader() bool {
	return 1 == atomic.LoadInt64(&s.Leader)
}

// get all service
func (s *Service) GetServices() ([]*Service, error) {
	services := make([]*Service, 0)
	rows, err := s.db.Query("SELECT `id`,`name`, `address`, `is_leader`, `updated`, `offline` FROM `services` WHERE 1")
	if err != nil {
		log.Errorf("GetServices s.db.Query fail, error=[%v]", err)
		return nil, err
	}
	for rows.Next() {
		sr := new(Service)
		err = rows.Scan(&sr.ID, &sr.Name, &sr.Address, &sr.Leader, &sr.Updated, &sr.Offline)
		if err != nil {
			log.Errorf("GetServices rows.Scan fail, error=[%v]", err)
			continue
		}
		atomic.StoreInt64(&sr.Status, 1)
		if time.Now().Unix() - sr.Updated >= 6 {
			atomic.StoreInt64(&sr.Status, 0)
		}
		sr.Unique = sr.Name + "-" + sr.Address
		services = append(services, sr)
	}
	return services, nil
}

func (s *Service) SearchService(id int64) (*Service, error) {
	//services := make([]*Service, 0)
	rows := s.db.QueryRow("SELECT `id`,`name`, `address`, `is_leader`, `updated`, `offline` " +
		"FROM `services` WHERE id=?", id)

	sr := new(Service)
	err := rows.Scan(&sr.ID, &sr.Name, &sr.Address, &sr.Leader, &sr.Updated, &sr.Offline)
	if err != nil {
		log.Errorf("SearchService rows.Scan fail, error=[%v]", err)
		return nil, err
	}
	atomic.StoreInt64(&sr.Status, 1)
	if time.Now().Unix() - sr.Updated >= 6 {
		atomic.StoreInt64(&sr.Status, 0)
	}
	sr.Unique = sr.Name + "-" + sr.Address

	return sr, nil
}

repository: sanchahua/wing-crontab

repo_name: sanchahua/wing-crontab


text:
SUMMARY = "Init BMC Hostname"
DESCRIPTION = "Setup BMC Unique hostname"
PR = "r1"
LICENSE = "Apache-2.0"
LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/Apache-2.0;md5=89aea4e17d99a7cacdbeed46a0096b10"

inherit allarch systemd

RDEPENDS:${PN} = "${VIRTUAL-RUNTIME_base-utils}"

SYSTEMD_SERVICE:${PN} = "first-boot-set-hostname.service"

SRC_URI = "file://${BPN}.sh file://${BPN}.service"

S = "${WORKDIR}"
do_install() {
    sed "s/{MACHINE}/${MACHINE}/" -i ${BPN}.sh
    install -d ${D}${bindir} ${D}${systemd_system_unitdir}
    install ${BPN}.sh ${D}${bindir}/
    install -m 644 ${BPN}.service ${D}${systemd_system_unitdir}/
}

repository: openbmc/openbmc

repo_name: openbmc/openbmc

gha_license_id: NOASSERTION

gha_language: Python


text:
PV = "0.0+cvs${SRCDATE}"
LICENSE = "BSD-X"
SECTION = "x11/libs"
DEPENDS = "randrext virtual/libx11 libxrender libxext"
DESCRIPTION = "X Resize and Rotate extension library."
PR = "r1"

SRC_URI = "${FREEDESKTOP_CVS}/xlibs;module=Xrandr"
S = "${WORKDIR}/Xrandr"

inherit autotools pkgconfig

do_stage() {
	autotools_stage_all
}


text:
@InProceedings{matthew15,
  title = {Bayesian and Empirical Bayesian Forests},
  author = {Taddy Matthew and Chun-Sheng Chen and Jun Yu and Mitch Wyle},
  pages = {967-976},
  abstract = {We derive ensembles of decision trees through a nonparametric Bayesian model, allowing us to view such ensembles as samples from a posterior distribution. This insight motivates a class of Bayesian Forest (BF) algorithms that provide small gains in performance and large gains in interpretability. Based on the BF framework, we are able to show that high-level tree hierarchy is stable in large samples. This motivates an empirical Bayesian Forest (EBF) algorithm for building approximate BFs on massive distributed datasets and we show that EBFs outperform sub-sampling based alternatives by a large margin.},
}

repository: mreid/papersite

repo_name: mreid/papersite

gha_language: TeX


text:
const { matrixFromArray, getRowAndCol } = require('./createMatrix');
const { waterBlocks } = require('./waterBlocks');

const generateBlocks = (row, col, matrix, arr) => {
  for (var i = 0; i < row; i++) {
    for (var k = 0; k < col; k++) {
      if (row - i - arr[k] <= 0) {
        matrix[i][k] = 1;
      }
    }
  }
  return matrix;
};

const generateWater = (row, col, matrix, arr, waterArr) => {
  for (var i = 0; i < row; i++) {
    for (var k = 0; k < col; k++) {
      if ((row - arr[k] - waterArr[k] - i <= 0) && (matrix[i][k] !== 1)) {
        matrix[i][k] = 2;
      }
    }
  }
  return matrix;
};

const generateWalls = (row, col, matrix, waterWalls) => {
  let [left, right] = waterWalls;
  left = left - 1;
  right = right - 1;
  for (var i = 0; i < row; i++) {
    for (var k = 0; k < col; k++) {
      if ((k === left && matrix[i][k] === 1)|| (k === right && matrix[i][k] === 1)) {
        matrix[i][k] = 3;
      }
    }
  }
  return matrix;
};

const completeMatrix = arr => {
  const { row, col } = getRowAndCol(arr);
  const matrix = matrixFromArray(arr);
  const { waterBlocksArr, waterWallsArr } = waterBlocks(arr);
  const withBlocks = generateBlocks(row, col, matrix, arr);
  const withWater = generateWater(row, col, withBlocks, arr, waterBlocksArr);
  const withWalls = generateWalls(row, col, withWater, waterWallsArr);

  return withWalls;
};

module.exports = {
  generateBlocks,
  generateWater,
  generateWalls,
  completeMatrix
}

repository: d-kang/water-walls-react

repo_name: d-kang/water-walls-react


text:
#!/usr/bin/env node

FORCE_PRODUCTION = false;

var debug = require('debug')('your-priorities-app');
var express = require('express');
var session = require('express-session');
var path = require('path');
var favicon = require('serve-favicon');
var logger = require('morgan');
var bodyParser = require('body-parser');
var morgan = require('morgan');
var ConnectRoles = require('connect-roles');
var RedisStore = require('connect-redis')(session);
var useragent = require('express-useragent');
var requestIp = require('request-ip');

var passport = require('passport')
  , LocalStrategy = require('passport-local').Strategy
  , FacebookStrategy = require('passport-facebook').Strategy
  , GitHubStrategy = require('passport-github').Strategy
  , TwitterStrategy = require('passport-twitter').Strategy
  , GoogleStrategy = require('passport-google-oauth').OAuth2Strategy;

var index = require('./controllers/index');
var news_feeds = require('./active-citizen/controllers/news_feeds');
var activities = require('./active-citizen/controllers/activities');
var notifications = require('./active-citizen/controllers/notifications');
var recommendations = require('./active-citizen/controllers/recommendations');

var posts = require('./controllers/posts');
var groups = require('./controllers/groups');
var communities = require('./controllers/communities');
var domains = require('./controllers/domains');
var organizations = require('./controllers/organizations');
var points = require('./controllers/points');
var users = require('./controllers/users');
var categories = require('./controllers/categories');
var images = require('./controllers/images');
var bulkStatusUpdates = require('./controllers/bulkStatusUpdates');

var legacyPosts = require('./controllers/legacyPosts');
var legacyUsers = require('./controllers/legacyUsers');
var legacyPages = require('./controllers/legacyPages');

var nonSPArouter = require('./controllers/nonSpa');

var generateSitemap = require('./utils/sitemap_generator');

var models = require('./models');
var auth = require('./authorization');
var log = require('./utils/logger');
var toJson = require('./utils/to_json');
var sso = require('passport-sso');
var cors = require('cors');

if (process.env.REDISTOGO_URL) {
  process.env.REDIS_URL = process.env.REDISTOGO_URL;
}

var app = express();
app.set('port', process.env.PORT || 4242);

var airbrake = null;

if (process.env.AIRBRAKE_PROJECT_ID) {
  airbrake = require('airbrake').createClient(process.env.AIRBRAKE_PROJECT_ID, process.env.AIRBRAKE_API_KEY);
  airbrake.handleExceptions();
  app.use(airbrake.expressHandler());
}

if (app.get('env') != 'development' && !process.env.DISABLE_FORCE_HTTPS) {
  app.use(function (req, res, next) {
    if (!/https/.test(req.protocol)) {
      res.redirect("https://" + req.headers.host + req.url);
    } else {
      return next();
    }
  });
}

app.set('views', __dirname + '/views');
app.set('view engine', 'jade');

app.use(cors());

app.use(morgan('combined'));
app.use(useragent.express());
app.use(requestIp.mw());
app.use(bodyParser.json({limit: '5mb'}));
app.use(bodyParser.urlencoded({limit: '5mb', extended: true}));

var sessionConfig = {
  store: new RedisStore({url: process.env.REDIS_URL}),
  name: 'yrpri.sid',
  secret: process.env.SESSION_SECRET ? process.env.SESSION_SECRET : 'not so secret... use env var.',
  resave: true,
  cookie: {autoSubDomain: true},
  saveUninitialized: true
};

if (app.get('env') === 'production') {
  app.set('trust proxy', 1); // trust first proxy
  sessionConfig.cookie.secure = true; // serve secure cookies
}

app.use(session(sessionConfig));

app.use(passport.initialize());
app.use(passport.session());

// Setup the current domain from the host
app.use(function (req, res, next) {
  models.Domain.setYpDomain(req, res, function () {
    log.info("Setup Domain Completed", {context: 'setYpDomain', domain: toJson(req.ypDomain.simple())});
    next();
  });
});

// Setup the current community from the host
app.use(function (req, res, next) {
  models.Community.setYpCommunity(req, res, function () {
    log.info("Setup Community Completed", {context: 'setYpCommunity', community: req.ypCommunity.hostname});
    next();
  });
});

app.use(function (req, res, next) {
  var ua = req.headers['user-agent'];
  if (/^(facebookexternalhit)|(web\/snippet)|(Twitterbot)|(Slackbot)|(Embedly)|(LinkedInBot)|(Pinterest)/gi.test(ua)) {
    console.log(ua, ' is a bot');
    nonSPArouter(req, res, next);
  } else {
    next();
  }
});

if (!FORCE_PRODUCTION && app.get('env') === 'development') {
  app.use(express.static(path.join(__dirname, '../client_app')));
} else {
  app.use(express.static(path.join(__dirname, '../client_app/build/bundled')));
}

var bearerCallback = function (req, token) {
  return console.log('The user has tried to authenticate with a bearer token');
};

app.use(function (req, res, next) {
  if (req.url.indexOf('/auth') > -1 || req.url.indexOf('/login') > -1) {
    sso.init(req.ypDomain.loginHosts, req.ypDomain.loginProviders, {
      authorize: bearerCallback,
      login: models.User.localCallback
    });
    req.sso = sso;
  }
  next();
});

passport.serializeUser(function (req, profile, done) {
  log.info("User Serialized From", {profile: profile});
  if (profile.provider && profile.provider == 'facebook') {
    models.User.serializeFacebookUser(profile, req.ypDomain, function (error, user) {
      if (error) {
        log.error("Error in User Serialized from Facebook", {err: error});
        done(error);
      } else {
        log.info("User Serialized Connected to Facebook", {context: 'loginFromFacebook', user: toJson(user)});
        done(null, {userId: user.id, loginProvider: 'facebook'});
      }
    });
  } else if (profile.provider && profile.UserSSN) {
    models.User.serializeSamlUser(profile, function (error, user) {
      if (error) {
        log.error("Error in User Serialized from SAML", {err: error});
        done(error);
      } else {
        log.info("User Serialized Connected to SAML", {context: 'loginFromSaml', user: toJson(user)});
        done(null, {userId: user.id, loginProvider: 'saml'});
      }
    });
  } else {
    log.info("User Serialized", {
      profile: profile,
      context: 'deserializeUser',
      userEmail: profile.email,
      userId: profile.id
    });
    done(null, {userId: profile.id, loginProvider: 'email'});
  }
});

passport.deserializeUser(function (sessionUser, done) {
  models.User.find({
    where: {id: sessionUser.userId},
    attributes: ["id", "name", "email", "default_locale", "facebook_id", "twitter_id", "google_id", "github_id", "ssn", "profile_data"],
    include: [
      {
        model: models.Image, as: 'UserProfileImages',
        required: false
      },
      {
        model: models.Image, as: 'UserHeaderImages',
        required: false
      }
    ]
  }).then(function (user) {
    if (user) {
      log.info("User Deserialized", {context: 'deserializeUser', user: user.email});
      user.loginProvider = sessionUser.loginProvider;
      done(null, user);
      return null;
    } else {
      log.error("User Deserialized Not found", {context: 'deserializeUser'});
      if (airbrake) {
        airbrake.notify("User Deserialized Not found", function (airbrakeErr, url) {
          if (airbrakeErr) {
            log.error("AirBrake Error", {
              context: 'airbrake',
              user: toJson(req.user),
              err: airbrakeErr,
              errorStatus: 500
            });
          }
        });
      }
      return done(null, false);
    }
  }).catch(function (error) {
    log.error("User Deserialize Error", {context: 'deserializeUser', user: sessionUser.userId, err: error, errorStatus: 500});
    if (airbrake) {
      airbrake.notify(error, function (airbrakeErr, url) {
        if (airbrakeErr) {
          log.error("AirBrake Error", {
            context: 'airbrake',
            user: toJson(req.user),
            err: airbrakeErr,
            errorStatus: 500
          });
        }
      });
    }
    return done(null, false);
  });
});

app.use('/', index);

// Set caching for IE so it wont cache the json queries
app.use(function (req, res, next) {
  var ua = req.headers['user-agent'];
  if (/Trident/gi.test(ua)) {
    res.set("Cache-Control", "no-cache,no-store");
  }
  next();
});

app.get('/sitemap.xml', function (req, res) {
  generateSitemap(req, res);
});

app.use('/domain', index);
app.use('/community', index);
app.use('/group', index);
app.use('/post', index);
app.use('/user', index);
app.use('/api/domains', domains);
app.use('/api/organizations', organizations);
app.use('/api/communities', communities);
app.use('/api/groups', groups);
app.use('/api/posts', posts);
app.use('/api/points', points);
app.use('/api/images', images);
app.use('/api/categories', categories);
app.use('/api/users', users);
app.use('/api/news_feeds', news_feeds);
app.use('/api/activities', activities);
app.use('/api/notifications', notifications);
app.use('/api/bulk_status_updates', bulkStatusUpdates);
app.use('/api/recommendations', recommendations);
app.use('/ideas', legacyPosts);
app.use('/users', legacyUsers);
app.use('/pages', legacyPages);

app.post('/authenticate_from_island_is', function (req, res) {
  log.info("SAML SAML 1", {domainId: req.ypDomain.id});
  req.sso.authenticate('saml-strategy-' + req.ypDomain.id, {}, req, res, function (error, user) {
    log.info("SAML SAML 2", {domainId: req.ypDomain.id, err: error});
    if (error) {
      log.error("Error from SAML login", {err: error});
      error.url = req.url;
      if (airbrake) {
        airbrake.notify(error, function (airbrakeErr, url) {
          if (airbrakeErr) {
            log.error("AirBrake Error", {context: 'airbrake', err: airbrakeErr, errorStatus: 500});
          }
          res.sendStatus(500);
        });
      }
    } else {
      log.info("SAML SAML 3", {domainId: req.ypDomain.id});
      res.render('samlLoginComplete', {});
    }
  })
});

app.use(function (err, req, res, next) {
  if (err instanceof auth.UnauthorizedError) {
    log.error("User Unauthorized", {
      context: 'unauthorizedError',
      user: toJson(req.user),
      err: 'Unauthorized',
      errorStatus: 401
    });
    res.sendStatus(401);
  } else {
    next(err);
  }
});

// catch 404 and forward to error handler
app.use(function (req, res, next) {
  var err = new Error('Not Found');
  err.status = 404;
  log.warn("Not Found", {context: 'notFound', user: toJson(req.user), err: 'Not Found', errorStatus: 404});
  next(err);
});

// Error handlers
app.use(function (err, req, res, next) {
  var status = err.status || 500;
  if (status == 404) {
    log.warn("Not found", {context: 'notFound', errorStatus: status, url: req.url});
  } else {
    log.error("General Error", {
      context: 'generalError',
      user: toJson(req.user),
      err: err,
      errStack: err.stack,
      errorStatus: status
    });
  }
  err.url = req.url;
  err.params = req.params;
  if (status != 404 && status != 401) {
    if (airbrake) {
      airbrake.notify(err, function (airbrakeErr, url) {
        if (airbrakeErr) {
          log.error("AirBrake Error", {
            context: 'airbrake',
            user: toJson(req.user),
            err: airbrakeErr,
            errorStatus: 500
          });
        }
        res.status(status).send({
          message: err.message,
          error: err
        });
      });
    } else {
      res.status(status).send({
        message: err.message,
        error: err
      });
    }
  } else {
    res.status(status).send({
      message: err.message,
      error: err
    });
  }
});

var server = app.listen(app.get('port'), function () {
  debug('Your Priorities server listening on port ' + server.address().port);
});

module.exports = app;

repository: adebas/your-priorities-app

repo_name: adebas/your-priorities-app


text:
require xorg-lib-common.inc
DESCRIPTION = "X11 Video extension library"
LICENSE = "GPL"
DEPENDS += "libxext videoproto"
PR = "${INC_PR}.0"

SRC_URI[archive.md5sum] = "723a0275227165383e967a1ca8899b52"
SRC_URI[archive.sha256sum] = "4d3cc49b6f4da6d396196054eca23a91df1a41001c736dcfd22fec5a5c7428c8"

XORG_PN = "libXv"

repository: trini/openembedded

repo_name: trini/openembedded


text:
#Note: the cmake patch for redland could be resolved with a TryRun.cmake file, however since the cmake file will be installed for other programs it would be needed at every program using it.
LICENSE = "GPLv2"
LIC_FILES_CHKSUM = "file://COPYING;md5=58ea69e00c0f1a17ba58451500255625"
DEPENDS = "redland virtuoso raptor libiodbc"
SRCREV = "4085f0cb1a38ef3e5b9a223b395db82186b2de93"
PV = "2.9.0+git${SRCPV}"
PR = "r1"

SRC_URI = "git://anongit.kde.org/soprano.git;branch=master \
           file://Fix-Redland-cross-compile-error.patch \
           file://WORKAROUND-export-visibility.patch \
          "

S = "${WORKDIR}/git"

inherit kde_cmake

EXTRA_OECMAKE =+ "\
                  -DBUILD_VIRTUOSO_BACKEND=TRUE \
                  -DBUILD_RAPTOR_PARSER=TRUE \
                  -DBUILD_REDLAND_BACKEND=TRUE \
                  -DREDLAND_CONFIG_EXECUTABLE=${STAGING_DIR_TARGET}${bindir_crossscripts}/redland-config \
                 "

RDEPENDS_${PN} = "virtuoso raptor rasqal redland"

FILES_${PN} =+ "${libdir}/soprano/* \
                ${datadir}/dbus-1/* \
               "
FILES_${PN}-dev += "${datadir}/soprano/cmake/*"


text:
package bundle

import (
	"github.com/crc-org/crc/pkg/crc/config"
	"github.com/crc-org/crc/pkg/crc/constants"
	"github.com/crc-org/crc/pkg/crc/logging"
	"github.com/crc-org/crc/pkg/crc/machine"
	"github.com/spf13/cobra"
)

func getGenerateCmd(config *config.Config) *cobra.Command {
	var forceStop bool
	generateCmd := &cobra.Command{
		Use:   "generate",
		Short: "Generate a custom bundle from the running OpenShift cluster",
		Long:  "Generate a custom bundle from the running OpenShift cluster",
		RunE: func(cmd *cobra.Command, args []string) error {
			return runGenerate(config, forceStop)
		},
	}
	generateCmd.PersistentFlags().BoolVarP(&forceStop, "force-stop", "f", false, "Forcefully stop the instance")
	return generateCmd
}

func runGenerate(config *config.Config, forceStop bool) error {
	client := machine.NewClient(constants.DefaultName, logging.IsDebug(), config)

	return client.GenerateBundle(forceStop)
}

repository: cfergeau/crc

repo_name: cfergeau/crc


text:
package common

const DB_RECORD_NOT_EXIST = "record not found"

//删除标识
const DEL = 1

//未删除标识
const NOT_DEL = 0

const RESP_TYPE_CODE = "code"
const RESP_TYPE_TOKEN = "token"

type ResultCode int

const (
	SUCESS                ResultCode = 0
	ERROR                 ResultCode = -1
	PARAMS_BINGDING_ERROR ResultCode = 100001
	NOT_LOGIN             ResultCode = 100002
	DB_QUERY_ERROR        ResultCode = 100003
	USER_NOT_EXIST        ResultCode = 100004
	PASSWORD_ERROR        ResultCode = 100005
	PARAMS_ERROR          ResultCode = 100006
	NO_NSUPPORT_GRANTTYPE ResultCode = 100007
	CLIENT_ID_NOT_EXIST   ResultCode = 100008
	CLIENT_SECRET_ERROR   ResultCode = 100009
	CODE_EMPTY            ResultCode = 100010
	CODE_ERROR            ResultCode = 100011
	DB_TX_ERROR           ResultCode = 100012
	DB_ERROR              ResultCode = 100013
	CLIENT_NOT_SUPPORT    ResultCode = 100014
	USER_NOT_AUTH         ResultCode = 100015
	TOKEN_INVALID         ResultCode = 100016
	TOKEN_EMPTY           ResultCode = 100017
	REFRESH_TOKEN_EMPTY   ResultCode = 100018
	REFRESH_TOKEN_INVALID ResultCode = 100019
	AUTHORIZATION_EMPTY   ResultCode = 100020
	BASE64_ERROR          ResultCode = 100021
	CLIENT_ID_EMPTY       ResultCode = 100022
)

func (code ResultCode) GetCode() int {
	return int(code)
}

func (code ResultCode) GetDesc() string {
	switch code {
	case SUCESS:
		return "成功"
	case ERROR:
		return "失败"
	case PARAMS_BINGDING_ERROR:
		return "参数绑定错误"
	case NOT_LOGIN:
		return "未登录"
	case DB_QUERY_ERROR:
		return "数据库查询错误"
	case USER_NOT_EXIST:
		return "用户不存在"
	case PASSWORD_ERROR:
		return "密码错误"
	case PARAMS_ERROR:
		return "参数错误"
	case NO_NSUPPORT_GRANTTYPE:
		return "不支持的授权模式"
	case CLIENT_ID_NOT_EXIST:
		return "client_id不存在"
	case CODE_EMPTY:
		return "授权码模式下，code不能为空"
	case CODE_ERROR:
		return "授权码不正确或者已失效"
	case CLIENT_SECRET_ERROR:
		return "secret不正确"
	case DB_TX_ERROR:
		return "数据库开启事务错误"
	case DB_ERROR:
		return "数据库错误"
	case CLIENT_NOT_SUPPORT:
		return "当前客户端不支持的授权模式"
	case USER_NOT_AUTH:
		return "用户未授权"
	case TOKEN_EMPTY:
		return "token不能为空"
	case TOKEN_INVALID:
		return "token无效"
	case REFRESH_TOKEN_EMPTY:
		return "refreshToken不能为空"
	case REFRESH_TOKEN_INVALID:
		return "refreshToken无效或者不支持refreshToken机制"
	case AUTHORIZATION_EMPTY:
		return "密码模式下Authorization不能为空"
	case BASE64_ERROR:
		return "base64解码错误"
	case CLIENT_ID_EMPTY:
		return "clientId不能为空"
	default:
		return "未知"
	}
}


text:
require live555.inc

LIC_FILES_CHKSUM = "file://COPYING;md5=68ad62c64cc6c620126241fd429e68fe"

PR = "${INC_PR}.0"

SRC_URI[md5sum] = "ff65b2c598e970b4b6c8219a1811de00"
SRC_URI[sha256sum] = "c6ce050a7f9f69901e6f7f81a6745c82d9419e3904a753b2d5db1139caaf6738"

repository: ExorEmbedded/exor-workspace

repo_name: ExorEmbedded/exor-workspace


text:
##
 #######################################################################################################################
 #
 #  Copyright (c) 2020 Advanced Micro Devices, Inc. All Rights Reserved.
 #
 #  Permission is hereby granted, free of charge, to any person obtaining a copy
 #  of this software and associated documentation files (the "Software"), to deal
 #  in the Software without restriction, including without limitation the rights
 #  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 #  copies of the Software, and to permit persons to whom the Software is
 #  furnished to do so, subject to the following conditions:
 #
 #  The above copyright notice and this permission notice shall be included in all
 #  copies or substantial portions of the Software.
 #
 #  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 #  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 #  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 #  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 #  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 #  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 #  SOFTWARE.
 #
 #######################################################################################################################

include(PalVersionHelper)
include(PalOverridesGpu)

pal_include_guard(PalOverrides)

# These are options that override PAL subproject options.  As these overrides are managed and force
# set by PAL, mark_as_advanced is used to hide them from the CMake GUI.
macro(pal_overrides)

    # ADDRLIB
    set(ADDR_ENABLE_LTO ${PAL_ENABLE_LTO} CACHE BOOL "PAL override to build ADDRLIB without lto support." FORCE)
    mark_as_advanced(ADDR_ENABLE_LTO)

    set(ADDR_SI_BUILD ON CACHE BOOL "PAL override to build ADDRLIB with SI support." FORCE)
    mark_as_advanced(ADDR_SI_BUILD)
    set(ADDR_CI_BUILD ON CACHE BOOL "PAL override to build ADDRLIB with CI support." FORCE)
    mark_as_advanced(ADDR_CI_BUILD)
    set(ADDR_VI_BUILD ON CACHE BOOL "PAL override to build ADDRLIB with VI support." FORCE)
    mark_as_advanced(ADDR_VI_BUILD)

    set(ADDR_SI_CHIP_DIR ${PROJECT_SOURCE_DIR}/src/core/hw/gfxip/gfx6/chip CACHE PATH "PAL override for ADDRLIB SI/CI/VI register chip headers." FORCE)
    mark_as_advanced(ADDR_SI_CHIP_DIR)

    # VAM
    set(VAM_ENABLE_LTO ${PAL_ENABLE_LTO} CACHE BOOL "PAL override to build ADDRLIB without lto support." FORCE)
    mark_as_advanced(VAM_ENABLE_LTO)

    # GPUOPEN
    if(PAL_BUILD_GPUOPEN)
        set(GPUOPEN_BUILD_METROHASH OFF CACHE BOOL "PAL override to build GPUOpen without the Metrohash library since PAL has its own." FORCE)
        mark_as_advanced(GPUOPEN_BUILD_METROHASH)

        set(METROHASH_PATH ${PAL_METROHASH_PATH}/src CACHE PATH "PAL override to specify the path to the MetroHash module." FORCE)
        mark_as_advanced(METROHASH_PATH)

        set(GPUOPEN_BUILD_SERVER_HELPERS ON CACHE BOOL "PAL override to build GPUOpen with server helper classes." FORCE)
        mark_as_advanced(GPUOPEN_BUILD_SERVER_HELPERS)

        set(GPUOPEN_BUILD_STANDARD_DRIVER_PROTOCOLS ON CACHE BOOL "PAL override to build GPUOpen with support for the standard driver protocols." FORCE)
        mark_as_advanced(GPUOPEN_BUILD_STANDARD_DRIVER_PROTOCOLS)
    endif()

    # ADDRLIB/SC GPU Overrides
    pal_overrides_gpu()
endmacro()

repository: npcdoom/pal

repo_name: npcdoom/pal

extension: cmake


text:
package main

import (
	"flag"
	"fmt"
)

func printUsage() {
	fmt.Println(`Stout Static Deploy Tool
Supports three commands, create, deploy and rollback.

Example Usage:

To create a site which will be hosted at my.awesome.website:

stout create --bucket my.awesome.website --key AWS_KEY --secret AWS_SECRET

To deploy the current folder to the root of the my.awesome.website site:

stout deploy --bucket my.awesome.website --key AWS_KEY --secret AWS_SECRET

To rollback to a specific deploy:

stout rollback --bucket my.awesome.website --key AWS_KEY --secret AWS_SECRET c4a22bf94de1

See the README for more configuration information.
`)
}

func main() {
	flag.Parse()

	command := flag.Arg(0)

	switch command {
	case "help":
		printUsage()
	case "deploy":
		deployCmd()
	case "rollback":
		rollbackCmd()
	case "create":
		createCmd()
	default:
		fmt.Println("Command not understood")
		fmt.Println("")
		printUsage()
	}
}

repository: vectorstorm/Stout

repo_name: vectorstorm/Stout


text:
@article{pmid31364989,
 abstract = {Protein-correlation-profiling (PCP), in combination with quantitative proteomics, has emerged as a high-throughput method for the rapid identification of dynamic protein complexes in native conditions. While PCP has been successfully applied to soluble proteomes, characterization of the membrane interactome has lagged, partly due to the necessary use of detergents to maintain protein solubility. Here, we apply the peptidisc, a 'one-size fits all' membrane mimetic, for the capture of the Escherichia coli cell envelope proteome and its high-resolution fractionation in the absence of detergent. Analysis of the SILAC-labeled peptidisc library via PCP allows generation of over 4900 possible binary interactions out of >700,000 random associations. Using well-characterized membrane protein systems such as the SecY translocon, the Bam complex and the MetNI transporter, we demonstrate that our dataset is a useful resource for identifying transient and surprisingly novel protein interactions. For example, we discover a trans-periplasmic supercomplex comprising subunits of the Bam and Sec machineries, including membrane-bound chaperones YfgM and PpiD. We identify RcsF and OmpA as bone fide interactors of BamA, and we show that MetQ association with the ABC transporter MetNI depends on its N-terminal lipid anchor. We also discover NlpA as a novel interactor of MetNI complex. Most of these interactions are largely undetected by standard detergent-based purification. Together, the peptidisc workflow applied to the proteomic field is emerging as a promising novel approach to characterize membrane protein interactions under native expression conditions and without genetic manipulation.},
 author = {Michael Luke Carlson and R Greg Stacey and John William Young and Irvinder Singh Wason and Zhiyu Zhao and David G Rattray and Nichollas Scott and Craig H Kerr and Mohan Babu and Leonard J Foster and Franck Duong Van Hoa},
 doi = {10.7554/eLife.46615},
 journal = {Elife},
 month = {07},
 nlmuniqueid = {101579614},
 pages = {},
 pii = {46615},
 pmc = {PMC6697469},
 pubmed = {31364989},
 title = {Profiling the Escherichia coli membrane protein interactome captured in Peptidisc libraries.},
 volume = {8},
 year = {2019}
}

repository: zqzneptune/BabuLab

repo_name: zqzneptune/BabuLab


text:
@article{hausman2015cooperative,
  title={Cooperative multi-robot control for target tracking with onboard sensing},
  author={Hausman, Karol and M{\"u}ller, J{\"o}rg and Hariharan, Abishek and Ayanian, Nora and Sukhatme, Gaurav S},
  journal={The International Journal of Robotics Research},
  volume={34},
  number={13},
  pages={1660--1677},
  year={2015},
  publisher={SAGE Publications}
}

gha_language: HTML


text:
@book{fehlberg1969low,
  title={Low-order Classical Runge-Kutta Formulas with Stepsize Control and Their Application to Some Heat Transfer Problems},
  author={Fehlberg, E.},
  series={NASA technical report},
  url={https://books.google.com/books?id=IMaJw5g4hGkC},
  year={1969},
  publisher={National Aeronautics and Space Administration}
}

gha_language: Jupyter Notebook

extension: bibtex