GitHub Ruby Monthly Trending Repositories

opf/openproject

OpenProject is the leading open source project management software for product, project and portfolio management. A powerful Jira alternative with agile planning, issue tracking, roadmaps, Gantt charts, time tracking, collaboration features, and more. Available on premises or in the cloud. ⭐ Star us on GitHub

OpenProject

We empower teams to achieve great things together for the good of society.

OpenProject is a web-based open source project management software for teams and organizations that require transparency, flexibility, and data sovereignty. Manage projects, portfolios, products, tasks, bugs, agile workflows, roadmaps, and team collaboration in a single platform. OpenProject can be self-hosted and is designed for organizations looking for an open source enterprise-ready alternative to tools such as Jira, MS Project, Monday, Asana, YouTrack while maintaining full control over their data and infrastructure.

OpenProject is trusted by organizations worldwide, including enterprises, public institutions, and highly regulated industries.

OpenProject's key features include:

More information can be found on our website.

Start now with OpenProject

Free Trial: Start a 14-days free trial of OpenProject.
Community Edition, free of charge: Download OpenProject and get started with the self-hosted Community edition. If you want to run an instance of OpenProject in production (or for evaluation), refer to our in-depth installation guides.
Enterprise Edition: Sign up for the Enterprise version, choose between cloud or on-premises and benefit from comprehensive support and Enterprise add-ons.
Documentation: Explore our comprehensive documentation to help you get up and running quickly.
Training: Book one of our training or consulting offers to get your team on board in no time.

Report bugs

You found a bug? Please report it to our OpenProject Community. Thank you!

Contribute

OpenProject is supported by its Community members, both companies and individuals.

We are always looking for new members to our Community, so if you are interested in improving OpenProject we would be glad to welcome and support you getting into the code. There are guides as well, e.g. a Quick Start for Developers, but don't hesitate to simply contact us if you have questions.

Working on OpenProject comes with the satisfaction of working on a widely used open source application.

Also, if you do not want to be limited to working on open source in your free time, OpenProject GmbH, the company contributing to the OpenProject development, is hiring.

Stay in contact

Here you can find our contact information. As we regularly update OpenProject, we recommend staying in touch – here is where you can find us:

OpenProject Community with forum discussions: The open instance where we develop our features – transparent and open for discussions, bug reports or feature requests.
LinkedIn
Reddit
Fosstodon
Bluesky

Security / responsible disclosure

We take security very seriously at OpenProject. We value any kind of feedback that will keep our Community secure. If you happen to come across a security issue we urge you to disclose it to us privately to allow our users and Community enough time to upgrade. Security issues will always take precedence over anything else in the pipeline.

For more information on how to disclose a security vulnerability, please see this page.

License

OpenProject is licensed under the terms of the GNU General Public License version 3. See COPYRIGHT and LICENSE files for details.

Credits

Icons

Thanks to Vincent Le Moign and his fabulous Minicons icons on webalys.com.

OpenProject icon font

Published and created by the OpenProject Foundation (OPF) under Creative Commons Attribution 3.0 Unported License with icons from the following sources Minicons Free Vector Icons Pack and User Interface Design framework both by webalys

Creative Commons License

OpenProject Icon Font by the OpenProject Foundation (OPF) is licensed under Creative Commons Attribution 3.0 Unported License and Free for both personal and commercial use. You can copy, adapt, remix, distribute or transmit it.

Under this condition: provide a mention of the "OpenProject Foundation" and a link back to OpenProject www.openproject.org.

docusealco/docuseal

Open source DocuSign alternative. Create, fill, and sign digital documents ✍️

DocuSeal

Open source document filling and signing

DocuSeal is an open source platform that provides secure and efficient digital document signing and processing. Create PDF forms to have them filled and signed online on any device with an easy-to-use, mobile-optimized web tool.

✨ Live Demo | ☁️ Try in Cloud

Features

PDF form fields builder (WYSIWYG)
12 field types available (Signature, Date, File, Checkbox etc.)
Multiple submitters per document
Automated emails via SMTP
Files storage on disk or AWS S3, Google Storage, Azure Cloud
Automatic PDF eSignature
PDF signature verification
Users management
Mobile-optimized
7 UI languages with signing available in 14 languages
API and Webhooks for integrations
Easy to deploy in minutes

Pro Features

Company logo and white-label
User roles
Automated reminders
Invitation and identity verification via SMS
Conditional fields and formulas
Bulk send with CSV, XLSX spreadsheet import
SSO / SAML
Template creation with HTML API (Guide)
Template creation with PDF or DOCX and field tags API (Guide)
Embedded signing form (React, Vue, Angular or JavaScript)
Embedded document form builder (React, Vue, Angular or JavaScript)
Learn more

Deploy

Heroku	Railway

DigitalOcean	Render

Docker

docker run --name docuseal -p 3000:3000 -v.:/data docuseal/docuseal

By default DocuSeal docker container uses an SQLite database to store data and configurations. Alternatively, it is possible to use PostgreSQL or MySQL databases by specifying the DATABASE_URL env variable.

Docker Compose

Download docker-compose.yml into your private server:

curl https://raw.githubusercontent.com/docusealco/docuseal/master/docker-compose.yml > docker-compose.yml

Run the app under a custom domain over https using docker compose (make sure your DNS points to the server to automatically issue ssl certs with Caddy):

sudo HOST=your-domain-name.com docker compose up

For Businesses

Integrate seamless document signing into your web or mobile apps with DocuSeal

At DocuSeal we have expertise and technologies to make documents creation, filling, signing and processing seamlessly integrated with your product. We specialize in working with various industries, including Banking, Healthcare, Transport, Real Estate, eCommerce, KYC, CRM, and other software products that require bulk document signing. By leveraging DocuSeal, we can assist in reducing the overall cost of developing and processing electronic documents while ensuring security and compliance with local electronic document laws.

Book a Meeting

License

Tools

dependabot/dependabot-core

🤖 Dependabot's core logic for creating update PRs.

Welcome to the public home of Dependabot .

What is Dependabot-Core?

Dependabot-Core is the library at the heart of Dependabot security / version updates.

Use it to generate automated pull requests updating dependencies for projects written in Ruby, JavaScript, Python, PHP, Dart, Elixir, Elm, Go, Rust, Java, Julia, and .NET. It can also update git submodules, Docker files, Opentofu, Terraform files and Pre-Commit hooks. Features include:

Check for the latest version of a dependency that's resolvable given a project's other dependencies
Generate updated manifest and lockfiles for a new dependency version
Generate PR descriptions that include the updated dependency's changelogs, release notes, and commits

How to run Dependabot

Most people are familiar with the Dependabot service that runs on GitHub.com and GitHub Enterprise. Enabling that is as simple as checking a dependabot.yml configuration file in to your repository's .github directory.

However, if you want to run a custom version of Dependabot or run it on another platform, you're not left out in the cold. This repo provides the logic necessary for hosting your own standalone Dependabot. It currently supports opening Pull Requests against repositories hosted on GitHub, Github Enterprise, Azure DevOps, GitLab, BitBucket, and AWS CodeCommit.

Dependabot-Core is a library, so you'll need an entrypoint script of some kind. Here are a few examples to help you get started.

Note: If you're looking to run Dependabot locally for development/debugging purposes, see the Development Guide.

Dependabot CLI

The open-source Dependabot CLI is our recommended entrypoint for standalone use cases.

We use it in production here at GitHub, and advanced users can also leverage it to run a self-hosted version of Dependabot within their own projects / CI systems.

It creates dependency diffs but does not create PRs. So you will need to wire that up yourself. To aid with that, we created the example-cli-usage repo which demonstrates how to turn those diffs into actual PR's.

Write your own Ruby-based tool

Alternatively, because Dependabot-Core is a Ruby library, you can write your own ruby-based wrapper that leverages the Dependabot-core code. The tricky bit is Dependabot assumes it's running in an isolated, throw-away environment so you'll need to handle all that yourself. For example protecting against security risks of arbitrary code execution exfiltrating credentials, ensuring the appropriate version of Go or Python or whatever language you need is available, and handling when Dependabot makes changes to its runtime environment.

Dependabot on CI

In an environment such as GitHub where Dependabot runs in a container, if you want to change your build or installation process depending on whether it's running within the context of the Dependabot container, you can check the existence of the DEPENDABOT environment variable.

Contributing to Dependabot

Reporting issues and Feature Requests

👋 Want to give us feedback on Dependabot, or contribute to it? That's great - thank you so much!

Reproducible Example

Most bug reports should be accompanied by a link to a public repository that reproduces the problem. Bug reports that cannot be reproduced on a public repo using the CLI tool or dry-run script may be closed as "cannot reproduce".

No "+1" Comments

Our issue tracker is quite active, and as a result there's a good chance someone already filed the same issue. If so, please upvote that issue, because we use 👍 reactions on issues as one signal to gauge the impact of a feature request or bug.

However, please do not leave comments that contribute nothing new to the discussion. For details, see https://go.dev/wiki/NoPlusOne. This is open source, if you see something you want fixed, we are happy to coach you through contributing a pull request to fix it.

Don't file issues about Security Alerts or Dependency Graph

The issue-tracker is meant solely for issues related to Dependabot's updating logic. Issues about security alerts or Dependency Graph should instead be filed as a Code Security discussion.

A good rule of thumb is that if you have questions about the diff in a PR, it belongs here.

Disclosing Security Issues

If you believe you have found a security vulnerability in Dependabot, please review our security policy for details about disclosing them to the GitHub Bug Bounty program, so we can work to resolve the issue before it is disclosed publicly.

Submitting Pull Requests

Want to contribute to Dependabot? That's great - thank you so much!

Contribution workflow:

Fork the project.
Get the development environment running.
Make your feature addition or bug fix.
Add tests for it. This is important so we don't break it in a future version unintentionally.
Send a pull request. The tests will run on it automatically, so don't worry if you couldn't get them running locally.

Please refer to the CONTRIBUTING guidelines for more information.

New Ecosystems

If you're interested in contributing support for a new ecosystem, please refer to the contributing guidelines for more information.

Development Guide

Getting a Development Environment Running

The first step to debugging a problem or writing a new feature is getting a development environment going. We provide a custom Docker-based developer shell that bakes in all required dependencies. In most cases this is the best way to work with the project.

The developer shell uses volume mounts to incorporate your local changes to Dependabot's source code. This way you can edit locally using your favorite editor and the changes are immediately reflected within the docker container for performing dry-runs or executing tests. Note: See caveat about editing the native package manager helper scripts.

Quickstart

The script to launch the developer shell builds the docker images from scratch if it can't find them locally. This can take a while.

Skip the wait by pulling the pre-built image for the ecosystem you want to work on. The image name uses the YAML ecosystem name to specify the ecosystem. For example, for Go Modules, the YAML name is gomod:

$ docker pull ghcr.io/dependabot/dependabot-updater-gomod

Note: Pre-built images are currently only available for AMD64 / Intel architecture. They will run on ARM, but 2x-3x slower than if you manually build ARM-specific images.

Next, run the developer shell, specifying the desired ecosystem using the top-level directory name of the ecosystem in this project. For example, for Go Modules, the top-level directory is named go_modules:

$ bin/docker-dev-shell go_modules
=> running docker development shell
[dependabot-core-dev] ~ $ cd go_modules && rspec spec # to run tests for a particular package

Building Images from Scratch

Normally the Quickstart is all you need, but occasionally you'll need to rebuild the underlying images.

For example, while we don't yet publish ARM-specific images, if you are working on an ARM-based platform, we recommend manually building the images because the resulting containers run much faster.

The developer shell runs within a Dependabot Development docker image, which is built on top of an ecosystem image.

flowchart LR
    A["docker-dev-shell script"] --> B("Dependabot Development docker image")
    B --> C("Dependabot Updater Ecosystem docker image (ecosystem specific)")
    C --> D("Dependabot Updater Core docker image")

Changes to the docker files for any of these images requires building one or more of the images locally in order to be reflected in the development shell.

The simple but slow way is to delete any existing images and then run bin/docker-dev-shell which automatically builds missing images.

The faster way is to pull all the pre-built images that are dependencies of the image you actually need to build. To (re)build a specific one:

The Updater core image:

$ docker pull ghcr.io/dependabot/dependabot-updater-core # OR
$ docker build -f Dockerfile.updater-core . --tag=dependabot-manual-build/updater-core # recommended on ARM

Each language/ecosystem sits on top of the core image. You need to rebuild whichever one you’re working on so it picks up your new core bits. For instance, if you’re working on Go Modules:

The Updater ecosystem image:

$ docker pull ghcr.io/dependabot/dependabot-updater-gomod # OR
$ script/build go_modules # recommended on ARM

Or explicitly:

$ docker build \
--platform linux/amd64 \
--file go_modules/Dockerfile \
--build-arg UPDATER_CORE_IMAGE=dependabot-manual-build/updater-core \
--tag dependabot-manual-build/updater-gomod \
.

Spin-up the development container using the --rebuild flag:

$ bin/docker-dev-shell go_modules --rebuild

If successful, you should be inside the shell:

=> running docker development shell
[dependabot-core-dev] ~ $

Once inside the shell, you can run tests, e.g.:

rspec common/spec/dependabot/file_fetchers/base_exclude_spec.rb

Making Changes to native Package Manager helpers

Several Dependabot packages make use of 'native helpers', small executables in their host language.

Changes to these files are not automatically reflected inside the development container.

Once you have made any edits to the helper files, run the appropriate build script to update the installed version with your changes like so:

$ bin/docker-dev-shell bundler
=> running docker development shell
$ bundler/helpers/v2/build
$ bin/dry-run.rb bundler dependabot/demo --dir="/ruby"

To view logs and stdout from the native package manager helpers, see debugging native helpers.

Debugging Problems

The first step to debugging is getting the development environment running.

Within the development environment, you have two options for simulating a dependency update job: You can use the newly-developed CLI tool or the original Dry-run script.

CLI tool

The Dependabot CLI is a newly-developed tool that incorporates the GitHub Credentials Proxy to more realistically simulate what's happening within the Dependabot-at-GitHub service when talking to private registries.

It has a dedicated debugging guide, including support for dropping into the Ruby debugger.

Dry-Run Script

Note: Before running the dry-run script, you'll need to get the development environment running.

You can use the bin/dry-run.rb script to simulate a dependency update job, printing the diff that would be generated to the terminal. It takes two positional arguments: the package manager and the GitHub repo name (including the account):

$ bin/docker-dev-shell go_modules
=> running docker development shell
$ bin/dry-run.rb go_modules rsc/quote
=> fetching dependency files
=> parsing dependency files
=> updating 2 dependencies
...

Helpful options to speed up dry-run testing

The Dry-Run script supports many other options, all of which are documented at the top of the script's source code. For example:

LOCAL_GITHUB_ACCESS_TOKEN="fake-GitHub-PAT" allows specifying a GitHub Personal Access Token (PAT) to avoid rate-limiting.
--dir="path/to/subdir/containing/manifest is required if the manifest file is located in a subdirectory.
--dep="dep-name-that-I-want-to-test" allows specifying a single dep to try to update and all others are ignored.
--cache=files allows caching remote dep files locally for faster re-runs when testing local logic changes.
--updater-options=feature_flag_name allows passing in feature flags.

Here's an example of how to string all these together

  LOCAL_GITHUB_ACCESS_TOKEN=github_pat_123_fake_string \
  bin/dry-run.rb docker jeffwidman/secrets-store-driver \
  --dir "/manifest_staging/charts/secrets-store-provider" \
  --cache=files \
  --dep="secrets-store" \
  --updater-options=kubernetes_updates

Adding debug breakpoints

You can add a debugger statement anywhere in the ruby code, for example:

      def latest_resolvable_version
        debugger
        latest_version_finder.latest_version
      end

When you execute the job, the Ruby debugger will open. It should look something like this:

[11, 20] in ~/go_modules/lib/dependabot/go_modules/update_checker.rb
    11|   module GoModules
    12|     class UpdateChecker < Dependabot::UpdateCheckers::Base
    13|       require_relative "update_checker/latest_version_finder"
    14|
    15|       def latest_resolvable_version
=>  16|         debugger
    17|         latest_version_finder.latest_version
    18|       end
    19|
    20|       # This is currently used to short-circuit latest_resolvable_version,
=>#0    Dependabot::GoModules::UpdateChecker#latest_resolvable_version at ~/go_modules/lib/dependabot/go_modules/update_checker.rb:16
  #1    Dependabot::GoModules::UpdateChecker#latest_version at ~/go_modules/lib/dependabot/go_modules/update_checker.rb:24
  # and 9 frames (use `bt' command for all frames)
(rdbg)

At this prompt, you can run debugger commands to navigate around, or enter methods and variables to see what they contain. Try entering dependency to see what dependency Dependabot is currently working on.

Note While in the debugger, changes made to the source code will not be picked up. You will have to end your debugging session and restart it.

Debugging Native Package Manager Helpers

When you're debugging an issue you often need to peek inside these scripts that run in a separate process.

Print all log statements from native helpers using DEBUG_HELPERS=true:

DEBUG_HELPERS=true bin/dry-run.rb bundler dependabot/demo --dir="/ruby"

Pause execution to debug a single native helper function using DEBUG_FUNCTION=<function name>. The function maps to a native helper function name, for example, one of the functions in bundler/helpers/v2/lib/functions.rb.

When this function is being executed a debugger is inserted, pausing execution of the bin/dry-run.rb script, this leaves the current updates tmp directory in place allowing you to cd into the directory and run the native helper function directly:

 DEBUG_FUNCTION=parsed_gemfile bin/dry-run.rb bundler dependabot/demo --dir="/ruby"
=> fetching dependency files
=> dumping fetched dependency files: ./dry-run/dependabot/demo/ruby
=> parsing dependency files
$ cd /home/dependabot/dependabot-core/tmp/dependabot_TEMP/ruby && echo "{\"function\":\"parsed_gemfile\",\"args\":{\"gemfile_name\":\"Gemfile\",\"lockfile_name\":\"Gemfile.lock\",\"dir\":\"/home/dependabot/dependabot-core/tmp/dependabot_TEMP/ruby\"}}" | BUNDLER_VERSION=1.17.3 BUNDLE_GEMFILE=/opt/bundler/v1/Gemfile GEM_HOME=/opt/bundler/v1/.bundle bundle exec ruby /opt/bundler/v1/run.rb

Copy and run the cd... command:

cd /home/dependabot/dependabot-core/tmp/dependabot_TEMP/ruby && echo "{\"function\":\"parsed_gemfile\",\"args\":{\"gemfile_name\":\"Gemfile\",\"lockfile_name\":\"Gemfile.lock\",\"dir\":\"/home/dependabot/dependabot-core/tmp/dependabot_TEMP/ruby\"}}" | BUNDLER_VERSION=1.17.3 BUNDLE_GEMFILE=/opt/bundler/v1/Gemfile GEM_HOME=/opt/bundler/v1/.bundle bundle exec ruby /opt/bundler/v1/run.rb

This should log out the output of the parsed_gemfile function:

{"result":[{"name":"business","requirement":"~> 1.0.0","groups":["default"],"source":null,"type":"runtime"},{"name":"uk_phone_numbers","requirement":"~> 0.1.0","groups":["default"],"source":null,"type":"runtime"}]}

Keep in mind that unlike changes to the ruby source, changes on your host machine to the native helpers source code are not synced to the development container. So you have two choices for editing the native helper:

You can directly edit the temporary copy of the native helper within the development container, for example: vi /opt/bundler/v1/lib/functions/file_parser.rb. And then re-run the cd... command. This is the fastest way to debug, but any changes won't be saved outside the container.
You can edit your local copy, and then rebuild the native helper. This will require re-running the dry-run script to pickup the change.

Debugging Ignore Conditions

Most of the ecosystems in Dependabot-Core support ignore conditions which allow a user to specify dependency names or versions to exclude from upgrades. The docs for the Dependabot service at GitHub describe the feature in more detail.

The Dependabot CLI supports passing in ignore conditions as part of the job definition. See the example.

The dry-run script supports passing in one or more ignore conditions via the env var IGNORE_CONDITIONS:

IGNORE_CONDITIONS='[{"dependency-name":"*","update-types": ["version-update:semver-major"]}]' \
bin/dry-run.rb docker test_org/test-dependabot`

Debugging Security Updates

Many of the ecosystems in Dependabot-Core support security updates. These are a special form of version update where a dependency name and range of vulnerable versions are passed in. Dependabot-Core will try to upgrade any instance of that dependency to the minimum non-vulnerable version. This is in contrast to a normal version update which tries to update to the latest version.

The env var SECURITY_ADVISORIES allows passing one or more security alert notifications to the dry-run script in order to simulate a security update:

SECURITY_ADVISORIES='[{"dependency-name":"buffer","patched-versions":[],"unaffected-versions":[],"affected-versions":["<= 2.0.0"]}]' \
bin/dry-run.rb pub dart-lang/pub-dev --dir "/app" --cache=files --dep="buffer"

Visual Studio Code and Docker

There's built-in support for leveraging Visual Studio Code's ability for debugging inside a Docker container. After installing the recommended Dev Containers extension, simply press Ctrl+Shift+P (⇧⌘P on macOS) and select Dev Containers: Reopen in Container. You can also access the dropdown by clicking on the green button in the bottom-left corner of the editor. If the development Docker image isn't present on your machine, it will be built automatically. Once that's finished, start the Debug Dry Run configuration (F5) and you'll be prompted to select a package manager and a repository to perform a dry run on. Feel free to place breakpoints on the code.

There is also support to debug individual test runs by running the Debug Tests configuration (F5) and you'll be prompted to select an ecosystem and provide an rspec path.

⚠️ The Clone Repository ... commands of the Remote Containers extension are currently missing some functionality and are therefore not supported. You have to clone the repository manually and use the Reopen in Container or Open Folder in Container... command.

Running Tests

Once you get the development environment for a particular ecosystem going, execute the tests for that ecosystem by running rspec spec inside that ecosystem's folder, e.g.

$ cd go_modules
$ rspec spec

You can also limit the tests to only the file you're working on, or only tests that previously failed, for example:

$ rspec spec/dependabot/file_updaters/elixir --only-failures

Style is enforced by RuboCop. To check for style violations, simply run rubocop in each of the packages, e.g.

$ cd go_modules
$ rubocop

Profiling

You can profile a dry-run by passing the --profile flag when running it, or tag an rspec test with :profile. This will generate a stackprof-<datetime>.dump file in the tmp/ folder, and you can generate a flamegraph from this by running:

stackprof --d3-flamegraph tmp/stackprof-<data or spec name>.dump > tmp/flamegraph.html

Architecture and Code Layout

Dependabot-Core is a collection of Ruby packages (gems), which contain the logic for updating dependencies in several languages.

`dependabot-common`

The common package contains all general-purpose/shared functionality. For instance, the code for creating pull requests for the different supported platforms lives here, as does most of the logic for handling Git dependencies (as most languages support Git dependencies in one way or another). There are also base classes defined for each of the major concerns required to implement support for a language or package manager.

`dependabot-{package-manager}`

There is a gem for each package manager or language that Dependabot supports. At a minimum, each of these gems will implement the following classes:

Service	Description
`FileFetcher`	Fetches the relevant dependency files for a project (e.g., the `Gemfile` and `Gemfile.lock`). See the README for more details.
`FileParser`	Parses a dependency file and extracts a list of dependencies for a project. See the README for more details.
`UpdateChecker`	Checks whether a given dependency is up-to-date. See the README for more details.
`FileUpdater`	Updates a dependency file to use the latest version of a given dependency. See the README for more details.
`MetadataFinder`	Looks up metadata about a dependency, such as its GitHub URL. See the README for more details.
`Version`	Describes the logic for comparing dependency versions. See the hex Version class for an example.
`Requirement`	Describes the format of a dependency requirement (e.g. `>= 1.2.3`). See the hex Requirement class for an example.

The high-level flow looks like this:

`dependabot-omnibus`

This is a "meta" gem, that simply depends on all the others. If you want to automatically include support for all languages, you can just include this gem and you'll get all you need.

Private Registry Credential Management

For many ecosystems, Dependabot-Core supports private registries. Sometimes this happens by passing the private registry credentials directly to the native package managers (npm, pip, bundler, etc), other times it happens within the Dependabot-Core Ruby code.

sequenceDiagram
    Private Registry Credentials->>Dependabot-Core:<br />
    Dependabot-Core->>Native Package Managers:<br />
    Native Package Managers->>Package Registries:<br />
    Dependabot-Core->>Package Registries:<br />

While simple and straightforward, this is a security risk for ecosystems that allow running untrusted code within their manifest files. For example setup.py and .gemspec allow running native Python and Ruby code. If a package in the dependency tree gets hacked, an attacker could push a malicious manifest that forces the native package manager to expose the creds.

To guard against this, for the Dependabot service that Github runs, we wrap Dependabot-Core with a credential proxy so those private registry secrets are never exposed to Dependabot-Core.

sequenceDiagram
    Dependabot-Core->>Credentials Proxy: All requests are unauthenticated
    Credentials Proxy->>Package Registries: Creds are injected by the Proxy
    Note left of Dependabot-Core: The Dependabot Service<br /> that GitHub Runs
    Package Registries->>Credentials Proxy: Creds are stripped by the Proxy
    Credentials Proxy->>Dependabot-Core: Dependabot-Core never sees private registry credentials

This also means if Dependabot-Core ever has a security vulnerability, those creds are still not at risk of being exposed.

Trademarks

This project may contain trademarks or logos for projects, products, or services. Authorized use of GitHub trademarks or logos is subject to and must follow GitHub Logos and Usage. Use of GitHub trademarks or logos in modified versions of this project must not cause confusion or imply GitHub sponsorship. Any use of third-party trademarks or logos are subject to those third-party’s policies.

History

Dependabot and dependabot-core started life as Bump and Bump Core, back when @hmarr and @greysteil were working at GoCardless.

Dependabot became a part of GitHub in 2019!

Notes for project maintainers

📖 Release guide

Publish a new release to RubyGems by running the Gems - Bump Version workflow and following the instructions on the job summary.

In a nutshell the process will be:

Run the action to generate a version bump PR.
Merge the PR.
Tag that merge commit as a new release using the format v1.2.3. The job summary contains a URL pre-populated with the correct version for the title and tag.
Once the release is tagged, another GitHub Action workflow automatically pushes it to RubyGems.

rails/rails

Ruby on Rails

Welcome to Rails

What's Rails?

Rails is a web application framework that includes everything needed to create database-backed web applications according to the Model-View-Controller (MVC) pattern.

Understanding the MVC pattern is key to understanding Rails. MVC divides your application into three layers: Model, View, and Controller, each with a specific responsibility.

Model layer

The Model layer represents the domain model (such as Account, Product, Person, Post, etc.) and encapsulates the business logic specific to your application. In Rails, database-backed model classes are derived from ActiveRecord::Base. Active Record allows you to present the data from database rows as objects and embellish these data objects with business logic methods. Although most Rails models are backed by a database, models can also be ordinary Ruby classes, or Ruby classes that implement a set of interfaces as provided by the Active Model module.

View layer

The View layer is composed of "templates" that are responsible for providing appropriate representations of your application's resources. Templates can come in a variety of formats, but most view templates are HTML with embedded Ruby code (ERB files). Views are typically rendered to generate a controller response or to generate the body of an email. In Rails, View generation is handled by Action View.

Controller layer

The Controller layer is responsible for handling incoming HTTP requests and providing a suitable response. Usually, this means returning HTML, but Rails controllers can also generate XML, JSON, PDFs, mobile-specific views, and more. Controllers load and manipulate models, and render view templates in order to generate the appropriate HTTP response. In Rails, incoming requests are routed by Action Dispatch to an appropriate controller, and controller classes are derived from ActionController::Base. Action Dispatch and Action Controller are bundled together in Action Pack.

Frameworks and libraries

Active Record, Active Model, Action Pack, and Action View can each be used independently outside Rails.

In addition to that, Rails also comes with:

Action Mailer, a library to generate and send emails
Action Mailbox, a library to receive emails within a Rails application
Active Job, a framework for declaring jobs and making them run on a variety of queuing backends
Action Cable, a framework to integrate WebSockets with a Rails application
Active Storage, a library to attach cloud and local files to Rails applications
Action Text, a library to handle rich text content
Active Support, a collection of utility classes and standard library extensions that are useful for Rails, and may also be used independently outside Rails

Getting Started

Install Rails at the command prompt if you haven't yet:
```
$ gem install rails
```
At the command prompt, create a new Rails application:
```
$ rails new myapp
```
where "myapp" is the application name.
Change directory to myapp and start the web server:
```
$ cd myapp
$ bin/rails server
```
Run with --help or -h for options.
Go to http://localhost:3000 and you'll see the Rails bootscreen with your Rails and Ruby versions.
Follow the guidelines to start developing your application. You may find the following resources handy:

Contributing

We encourage you to contribute to Ruby on Rails! Please check out the Contributing to Ruby on Rails guide for guidelines about how to proceed. Join us!

Trying to report a possible security vulnerability in Rails? Please check out our security policy for guidelines about how to proceed.

Everyone interacting in Rails and its sub-projects' codebases, issue trackers, chat rooms, and mailing lists is expected to follow the Rails code of conduct.

License

Ruby on Rails is released under the MIT License.

rapid7/metasploit-framework

Metasploit Framework

The Metasploit Framework is an open-source tool released under a BSD-style license. For detailed licensing information, refer to the COPYING file.

Latest Version

Access the latest version of Metasploit from the Nightly Installers page.

Documentation

Comprehensive documentation, including usage guides, is available at Metasploit Docs.

Development Environment

To set up a development environment, visit the Development Setup Guide.

Bug and Feature Requests

Submit bugs and feature requests via the GitHub Issues tracker. New submissions can be made through the MSF-BUGv1 form.

API Documentation

For information on writing modules, refer to the API Documentation.

Support and Communication

For questions and suggestions, you can:

Join our GitHub Discussions for community support and general questions
Join the Metasploit Slack for real-time chat
Submit GitHub Issues for bug reports and feature requests
Follow @metasploit on X or @metasploit@infosec.exchange on Mastodon for updates

Note: Some community members may still use IRC channels and the metasploit-hackers mailing list, though the primary support channels are now GitHub Discussions and Slack.

Installing Metasploit

Recommended Installation

We recommend installation with the official Metasploit installers on Linux or macOS. Metasploit is also pre-installed with Kali.

For a manual setup, consult the Dev Environment Setup guide.

Using Metasploit

To get started with Metasploit:

Start msfconsole: This is the primary interface for interacting with Metasploit.
Explore Resources:
- Visit the Using Metasploit section of the documentation.

Contributing

To contribute to Metasploit:

Setup Development Environment: Follow the instructions in the Development Setup Guide on GitHub.
Clone the Repository: Obtain the source code from the official repository.
Submit a Pull Request: After making changes, submit a pull request for review. Additional details can be found in the Contributing Guide.

discourse/discourse

A platform for community discussion. Free, open, simple.

The online home for your community.

You can self-host Discourse on your own infrastructure. But if you'd rather skip the setup, maintenance, and server management, we offer official Discourse hosting.

👉 Learn more about Discourse hosting

Discourse is a 100% open-source community platform for those who want complete control over how and where their site is run.

Our platform has been battle-tested for over a decade and continues to evolve to meet users’ needs for a powerful community platform.

With Discourse, you can:

💬 Create discussion topics to foster meaningful conversations.
⚡️ Connect in real-time with built-in chat.
🎨 Customize your experience with an ever-growing selection of official and community themes.
🤖 Enhance your community with plugins, from chatbots powered by Discourse AI to advanced tools like SQL analysis with the Data Explorer plugin.

To learn more, visit discourse.org and join our support community at meta.discourse.org.

Here are just a few of the incredible communities using Discourse:

👉 Discover more communities using Discourse

Development

To get your environment set up, follow one of the setup guides:

Docker
- Dev Container in VS Code (recommended)
- CLI
macOS
Ubuntu/Debian
Windows

Before you get started, ensure you have the following minimum versions: Ruby 3.4+, PostgreSQL 15, Redis 7.

For more information, check out the Developer Documentation.

Setting up Discourse

If you want to set up a Discourse forum for production use, see our Discourse Install Guide.

If you're looking for official hosting, see discourse.org/pricing.

Requirements

Discourse supports the latest, stable releases of all major browsers and platforms:

Browsers	Tablets	Phones
Apple Safari	iPadOS	iOS
Google Chrome	Android	Android
Microsoft Edge
Mozilla Firefox

Additionally, we aim to support Safari on iOS 16.4+.

Built With

Ruby on Rails — Our back end API is a Rails app. It responds to requests RESTfully in JSON.
Ember.js — Our front end is an Ember.js app that communicates with the Rails API.
PostgreSQL — Our main data store is in Postgres.
Redis — We use Redis as a cache and for transient data.
BrowserStack — We use BrowserStack to test on real devices and browsers.

Plus lots of Ruby Gems, a complete list of which is at /main/Gemfile.

Contributing

Discourse is 100% free and open source. We encourage and support an active, healthy community that accepts contributions from the public – including you!

Before contributing to Discourse:

Please read the complete mission statements on discourse.org. Yes we actually believe this stuff; you should too.
Read and sign the Electronic Discourse Forums Contribution License Agreement.
Dig into CONTRIBUTING.MD, which covers submitting bugs, requesting new features, preparing your code for a pull request, etc.
Always strive to collaborate with mutual respect.
Not sure what to work on? We've got some ideas.

We look forward to seeing your pull requests!

Security

We take security very seriously at Discourse; all our code is 100% open source and peer reviewed. Please read our security guide for an overview of security measures in Discourse, or if you wish to report a security issue.

Security fixes are listed in the release notes for each version.

The Discourse Team

The original Discourse code contributors can be found in AUTHORS.MD. For a complete list of the many individuals that contributed to the design and implementation of Discourse, please refer to the official Discourse blog and GitHub's list of contributors.

Copyright / License

Licensed under the GNU General Public License Version 2.0 (or later); you may not use this work except in compliance with the License. You may obtain a copy of the License in the LICENSE file, or at:

https://www.gnu.org/licenses/old-licenses/gpl-2.0.txt

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.

Discourse logo and “Discourse Forum” ®, Civilized Discourse Construction Kit, Inc.

Accessibility

To guide our ongoing effort to build accessible software we follow the W3C’s Web Content Accessibility Guidelines (WCAG). If you'd like to report an accessibility issue that makes it difficult for you to use Discourse, email accessibility@discourse.org. For more information visit discourse.org/accessibility.

Dedication

Discourse is built with love, Internet style.

For over a decade, our amazing community has helped shape Discourse into what it is today. Your support, feedback, and contributions have been invaluable in making Discourse a powerful and versatile platform.

We’re deeply grateful for every feature request, bug report, and discussion that has driven Discourse forward. Thank you for being a part of this journey—we couldn’t have done it without you!

Freika/dawarich

Your favorite self-hostable alternative to Google Timeline (Google Location History)

🌍 Dawarich: Your Self-Hostable Location History Tracker

| | |

Screenshots

Map View

Timeline View

Insights Page

Family Page

Statistics Overview

Trips page

About Dawarich

If you're looking for Dawarich Cloud, where everything is managed for you, check out Dawarich Cloud.

Dawarich is a self-hostable web app designed to replace Google Timeline (aka Google Location History). It enables you to:

Track your location history.
Visualize your data on an interactive map.
Create trips and analyze your travel history.
Share your location with family members.
Integrate with photo management apps like Immich and Photoprism to visualize geotagged photos.
Import your location history from Google Maps Timeline, OwnTracks, GPX, GeoJSON and some other sources
Explore statistics like the number of countries and cities visited, total distance traveled, and more!
Share your location with family members.

Changelog: Find the latest updates here.

Contribute: See CONTRIBUTING.md for how to contribute to Dawarich.

⚠️ Disclaimer

Updating strategy

DO NOT UPDATE AUTOMATICALLY: Read release notes before updating. Automatic updates may break your setup.
Under active development: Expect frequent updates, bugs, and breaking changes.
Do not delete your original data after importing into Dawarich.
Backup before updates: Always backup your data before upgrading.
Stay up-to-date: Make sure you're running the latest version for the best experience.

🧭 Supported Location Tracking

You can track your location with the following apps:

💫 Dawarich for iOS
🤖 Dawarich for Android
🗺️ Dawarich Community (Android)
🌍 Overland
🛰️ OwnTracks
🧭 GPSLogger
📱 PhoneTrack
🏡 Home Assistant

Simply install one of the supported apps on your device and configure it to send location updates to your Dawarich instance.

How to Start Dawarich Locally

Clone the repository.

Run the following command to start the app:

docker compose -f docker/docker-compose.yml up

Access the app at http://localhost:3000.

To stop the app, press Ctrl+C.

You can use default values or create a .env file based on .env.example to customize your setup.

How to Install Dawarich

Docker Setup
Synology

Default Credentials

Username: demo@dawarich.app
Password: safepassword Feel free to change them in the account settings.

Features

Location Tracking

Track your live location using one of the supported apps.

Location History Visualization

View your historical data on a map with customizable layers:
- Heatmap
- Points
- Lines between points
- Fog of War

Family Sharing

Share your location with family members.
View locations of family members on the map (with their consent).
Each family member can enable or disable location sharing individually.

Areas

Draw areas on the map so Dawarich could suggest your visits there.

Visits (Beta)

Dawarich can suggest places you've visited and allow you to confirm or reject them.

Statistics

Analyze your travel history: number of countries/cities visited, distance traveled, and time spent, broken down by year and month.

Insights

Get insights about your location history, like "Your most visited place is home, with 120 visits", or "You spent 30 days in Paris in 2024".

Days in country

See how many days you've spent in each country. Useful for tax residency purposes or just to see where you spend most of your time.

Trips

Create a trip to visualize your travels between two points in time. You'll be able to see the route, distance, and time spent, and also add notes to your trip. If you have Immich or Photoprism integration, you'll also be able to see photos from your trips!

Integrations

Provide credentials for Immich or Photoprism (or both!) and Dawarich will automatically import geodata from your photos.
You'll also be able to visualize your photos on the map!

Import Your Data

Import from various sources:
- Google Maps Timeline
- OwnTracks
- Strava
- Immich
- GPX/GeoJSON files
- Photos’ EXIF data

Export Your Data

Export your data to GeoJSON or GPX formats.

📚 Guides and Tutorials

More guides available in the Docs.

Environment Variables

Check the documentation on the website for detailed information about environment variables and settings.

Star History

As you could probably guess, I like statistics.

ruby/ruby

The Ruby Programming Language

日本語

What is Ruby?

Ruby is an interpreted object-oriented programming language often used for web development. It also offers many scripting features to process plain text and serialized files, or manage system tasks. It is simple, straightforward, and extensible.

Features of Ruby

Simple Syntax
Normal Object-oriented Features (e.g. class, method calls)
Advanced Object-oriented Features (e.g. mix-in, singleton-method)
Operator Overloading
Exception Handling
Iterators and Closures
Garbage Collection
Dynamic Loading of Object Files (on some architectures)
Highly Portable (works on many Unix-like/POSIX compatible platforms as well as Windows, macOS, etc.) cf. https://docs.ruby-lang.org/en/master/maintainers_md.html#label-Platform+Maintainers

How to get Ruby

For a complete list of ways to install Ruby, including using third-party tools like rvm, see:

https://www.ruby-lang.org/en/downloads/

You can download release packages and the snapshot of the repository. If you want to download whole versions of Ruby, please visit https://www.ruby-lang.org/en/downloads/releases/.

Download with Git

The mirror of the Ruby source tree can be checked out with the following command:

$ git clone https://github.com/ruby/ruby.git

There are some other branches under development. Try the following command to see the list of branches:

$ git ls-remote https://github.com/ruby/ruby.git

You may also want to use https://git.ruby-lang.org/ruby.git (actual master of Ruby source) if you are a committer.

How to build

See Building Ruby

Ruby home page

https://www.ruby-lang.org/

Documentation

Mailing list

There is a mailing list to discuss Ruby. To subscribe to this list, please send the following phrase:

join

in the mail subject (not body) to the address ruby-talk-request@ml.ruby-lang.org.

Copying

See the file COPYING.

Feedback

Questions about the Ruby language can be asked on the Ruby-Talk mailing list or on websites like https://stackoverflow.com.

Bugs should be reported at https://bugs.ruby-lang.org. Read "Reporting Issues" for more information.

Contributing

See "Contributing to Ruby", which includes setup and build instructions.

The Author

Ruby was originally designed and developed by Yukihiro Matsumoto (Matz) in 1995.

matz@ruby-lang.org

Homebrew/homebrew-cask

🍻 Default casks (upstream binary packages) for the package manager for everywhere

Homebrew Cask

“To install, drag this icon…” no more!

Homebrew Cask extends Homebrew and brings its elegance, simplicity, and speed to the installation and management of prebuilt software artifacts distributed by upstream vendors, including GUI applications, CLI tools, fonts, plugins, and other packaged software.

We do this by providing a friendly CLI workflow for the administration of these artifacts on macOS and Linux.

Let’s try it!

To start using Homebrew Cask, you just need Homebrew installed.

Slower, now:

% brew install alfred
==> Fetching downloads for: alfred
✔︎ Cask alfred (5.7.2,2312)                                           Verified      5.6MB/  5.6MB
==> Installing Cask alfred
==> Moving App 'Alfred 5.app' to '/Applications/Alfred 5.app'
🍺  alfred was successfully installed!

And there we have it. An application installed with one quick command: no clicking, no dragging, no dropping.

Learn More

Find basic documentation on using Homebrew Cask in USAGE.md.
Want to contribute a cask? Awesome! See CONTRIBUTING.md.
More project-related details and discussion are available in the documentation.

Reporting Bugs

If you ignore this guide, your issue may be closed without review

Before reporting a bug, run brew update-reset && brew update and try your command again. This is a fix-all that will reset the state of all your taps, ensuring the problem isn’t an outdated setup on your side.

If your issue persists, search for it before opening a new one. If you find an open issue and have any new information, add it in a comment. If you find a closed issue, try the solutions there.

If the issue is still not solved, see the guides for common problems:

Requests

Issues requesting new casks will be closed. If you want a cask added to the main repositories, submit a pull request.
For a feature request, use this template.

Questions? Wanna chat?

We’re really rather friendly! Here are the best places to talk about the project:

Open an issue.
Join us on GitHub discussions (forum).

License

Code is under the BSD 2 Clause (NetBSD) license.

github/explore

Community-curated topic and collection pages on GitHub

GitHub Explore

This repository houses all of the community-curated content for GitHub Topics and Collections.

Topics help you explore repositories in a particular subject area, learn more about that subject, and find projects to contribute to.

Collections help you discover hand-picked repositories, developers, organizations, videos, and articles that share a common theme.

If you want to suggest edits to an existing Topic page or Collection, or curate a new one, read our contributing guide to get started.

Running tests

There are some lint tests in place to ensure each Topic is formatted in the way we expect. GitHub Actions will run the tests automatically. If you want to run the tests yourself locally, you will need Ruby and Bundler installed.

You can run the tests using:

bundle install
bundle exec rubocop

Licenses

Content is released under CC-BY-4.0 which gives you permission to use content for almost any purpose (but does not grant you any trademark permissions). See notices for complete details, including attribution guidelines, contribution terms, and software and third-party licenses and permissions.

antiwork/gumroad

See what sticks

See what sticks.

Gumroad is an e-commerce platform that enables creators to sell products directly to consumers. This repository contains the source code for the Gumroad web application.

Contributing

We don't run an inbound review queue on this repo. To contribute a change: fork the repo, open the pull request on your own fork, then email support@gumroad.com with a link to it. We read every submission and merge the ones we want on our side, keeping your authorship — though we can't promise a reply to each one or a timeline.

Your PR still has to meet the same bar as our own work — visual evidence for anything user-facing, QA steps, test results, and an AI disclosure naming the model. See CONTRIBUTING.md for the full guidelines and the substitutions that apply when working from a fork.

Getting Started

Prerequisites

💡 If you're on Windows, follow our Windows setup guide instead.

Before you begin, ensure you have the following installed:

Ruby

https://www.ruby-lang.org/en/documentation/installation/
Install the version listed in the .ruby-version file

Node.js

https://nodejs.org/en/download
Install the version listed in the .node-version file

Docker

We use Docker to setup the services for development environment.

For MacOS: Download the Docker app from the Docker website
For Linux:

sudo wget -qO- https://get.docker.com/ | sh
sudo usermod -aG docker $(whoami)

MySQL & Percona Toolkit

Install a local version of MySQL 8.0.x to match the version running in production.

The local version of MySQL is a dependency of the Ruby mysql2 gem. You do not need to start an instance of the MySQL service locally. The app will connect to a MySQL instance running in the Docker container.

For MacOS:

brew install mysql@8.0 percona-toolkit
brew link --force mysql@8.0

# to use Homebrew's `openssl`:
brew install openssl
bundle config --global build.mysql2 --with-opt-dir="$(brew --prefix openssl)"

# ensure MySQL is not running as a service
brew services stop mysql@8.0

For Linux:
- MySQL:
  - https://dev.mysql.com/doc/refman/8.0/en/linux-installation.html
  - apt install libmysqlclient-dev
- Percona Toolkit: https://www.percona.com/doc/percona-toolkit/LATEST/installation.html

Image Processing Libraries

ImageMagick

We use imagemagick for preview editing.

For MacOS: brew install imagemagick
For Linux: sudo apt-get install imagemagick

libvips

For newer image formats we use libvips for image processing with ActiveStorage.

For MacOS: brew install libvips
For Linux: sudo apt-get install libvips-dev

FFmpeg

We use ffprobe that comes with FFmpeg package to fetch metadata from video files.

For MacOS: brew install ffmpeg
For Linux: sudo apt-get install ffmpeg

PDFtk

We use pdftk to stamp PDF files with the Gumroad logo and the buyers' emails.

For MacOS: Download from here
- Note: pdftk may be blocked by Apple's firewall. If this happens, go to Settings > Privacy & Security and click "Open Anyways" to allow the installation.
For Linux: sudo apt-get install pdftk

wkhtmltopdf

While generating invoices, to convert HTML to PDF, PDFKit expects wkhtmltopdf to be installed on your system. Download and install the version 0.12.6 for your platform.

Note similar to pdftk, this may also be blocked by Apple's firewall on MacOS. Follow a similar process as above.

Installation

Bundler and gems

We use Bundler to install Ruby gems.

gem install bundler

Install gems:

bundle install

Also make sure to install dotenv as it is required for some console commands:

gem install dotenv

npm and Node.js dependencies

Make sure the correct version of npm is enabled:

corepack enable

Install dependencies:

npm install

Configuration

Set up Custom credentials

App can be booted without any custom credentials. But if you would like to use services that require custom credentials (e.g. S3, Stripe, Resend, etc.), you can copy the .env.example file to .env and fill in the values.

Running Locally

Start Docker services

If you installed Docker Desktop (on a Mac or Windows machine), you can run the following command to start the Docker services:

make local

If you are on Linux, or installed Docker via a package manager on a mac, you may need superuser access to expose container ports. To do that, use sudo make local instead.

This command will not terminate. You run this in one tab and start the application in another tab. If you want to run Docker services in the background, use LOCAL_DETACHED=true make local instead.

Set up the database

bin/rails db:prepare

For Linux (Debian / Ubuntu) you might need the following:

apt install libxslt-dev libxml2-dev

Start the application

bin/dev

This starts the Rails server, the JavaScript build system, and a Sidekiq worker.

You can now access the application at http://localhost:3000. Seller subdomains and the asset/api hosts use *.localhost (e.g. http://seller.localhost:3000, http://api.localhost:3000) — modern browsers auto-resolve these to 127.0.0.1, so no /etc/hosts edits are needed.

Local dev limitations

*.localhost over HTTP is treated as a secure context by browsers (so Stripe.js, Stripe Elements, and other secure-context APIs work), but a couple of features that need either HTTPS or a registrable cookie domain don't work in this setup:

Apple Pay — Stripe requires HTTPS for Apple Pay domain registration. Workaround: expose the app over HTTPS with ngrok (ngrok http 3000) and register the resulting hostname in the Stripe Apple Pay dashboard.
Cross-subdomain cookies (affiliate attribution, _gumroad_guid, multi-account "switch seller", session) — browsers reject Domain=localhost, so cookies set on localhost:3000 aren't sent to seller.localhost:3000. Test these flows on a single host, or front the app with a local HTTPS reverse proxy on a registrable hostname (e.g. gumroad.test via mkcert) where Domain=.gumroad.test works.

Testing

Run the full test suite:

bin/rspec

Run a single file or specific test:

bin/rspec spec/requests/dashboard_spec.rb
bin/rspec spec/requests/dashboard_spec.rb:75

Dependencies

Before running tests:

make local                          # start Docker services (db, Redis, etc.)
RAILS_ENV=test bin/rails db:setup   # set up the test database
RAILS_ENV=test bin/rails js:export  # generate JS constants for the test environment

Integration tests

Integration specs use Capybara with Selenium driving Chrome. Install Chrome from google.com/chrome.

See docs/testing.md for details on preventing flaky specs, VCR cassettes, debugging widgets, and purchase testing with Stripe/PayPal.

Development

Logging in

You can log in with the username seller@gumroad.com and the password password. The two-factor authentication code is 000000.

Read more about logging in as a user with a different team role at Users & authentication.

Resetting Elasticsearch indices

You will need to explicitly reindex Elasticsearch to populate the indices after setup, otherwise you will see index_not_found_exception errors when you visit the dev application. You can reset them using:

# Run this in a rails console:
DevTools.delete_all_indices_and_reindex_all

Push Notifications

To send push notifications:

INITIALIZE_RPUSH_APPS=true bundle exec rpush start -e development -f

Common Development Tasks

Rails console:

bin/rails c

Rake tasks:

bin/rake task_name

Linting

We use ESLint for JS, and Rubocop for Ruby. Your editor should support displaying and fixing issues reported by these inline, and CI checks these on every push.

If you'd like, you can run git config --local core.hooksPath .githooks to check for these locally when committing.

Common Issues

macOS Error When Running Tests (Related to `fork()`)

objc[11912]: +[__NSCFConstantString initialize] may have been in progress in another thread when fork() was called.
objc[11912]: +[__NSCFConstantString initialize] may have been in progress in another thread when fork() was called. We cannot safely call it or ignore it in the fork() child process. Crashing instead. Set a breakpoint on objc_initializeAfterForkError to debug.

This issue occurs on macOS due to how the fork() system call interacts with multithreaded Objective-C applications—commonly triggered when Spring is enabled during testing.

How to Fix:

Temporarily disable Spring before running your tests to avoid this error.

export DISABLE_SPRING=1
bin/rspec spec/requests/balance_pages_spec.rb

This will disable Spring for the current session, allowing the tests to run without triggering the fork()-related crash.

chatwoot/chatwoot

Open-source live-chat, email support, omni-channel desk. An alternative to Intercom, Zendesk, Salesforce Service Cloud etc. 🔥💬

Chatwoot

The modern customer support platform, an open-source alternative to Intercom, Zendesk, Salesforce Service Cloud etc.

Chatwoot is the modern, open-source, and self-hosted customer support platform designed to help businesses deliver exceptional customer support experience. Built for scale and flexibility, Chatwoot gives you full control over your customer data while providing powerful tools to manage conversations across channels.

✨ Captain – AI Agent for Support

Supercharge your support with Captain, Chatwoot’s AI agent. Captain helps automate responses, handle common queries, and reduce agent workload—ensuring customers get instant, accurate answers. With Captain, your team can focus on complex conversations while routine questions are resolved automatically. Read more about Captain here.

💬 Omnichannel Support Desk

Chatwoot centralizes all customer conversations into one powerful inbox, no matter where your customers reach out from. It supports live chat on your website, email, Facebook, Instagram, Twitter, WhatsApp, Telegram, Line, SMS etc.

📚 Help center portal

Publish help articles, FAQs, and guides through the built-in Help Center Portal. Enable customers to find answers on their own, reduce repetitive queries, and keep your support team focused on more complex issues.

🗂️ Other features

Collaboration & Productivity

Private Notes and @mentions for internal team discussions.
Labels to organize and categorize conversations.
Keyboard Shortcuts and a Command Bar for quick navigation.
Canned Responses to reply faster to frequently asked questions.
Auto-Assignment to route conversations based on agent availability.
Multi-lingual Support to serve customers in multiple languages.
Custom Views and Filters for better inbox organization.
Business Hours and Auto-Responders to manage response expectations.
Teams and Automation tools for scaling support workflows.
Agent Capacity Management to balance workload across the team.

Customer Data & Segmentation

Contact Management with profiles and interaction history.
Contact Segments and Notes for targeted communication.
Campaigns to proactively engage customers.
Custom Attributes for storing additional customer data.
Pre-Chat Forms to collect user information before starting conversations.

Integrations

Slack Integration to manage conversations directly from Slack.
Dialogflow Integration for chatbot automation.
Dashboard Apps to embed internal tools within Chatwoot.
Shopify Integration to view and manage customer orders right within Chatwoot.
Use Google Translate to translate messages from your customers in realtime.
Create and manage Linear tickets within Chatwoot.

Reports & Insights

Live View of ongoing conversations for real-time monitoring.
Conversation, Agent, Inbox, Label, and Team Reports for operational visibility.
CSAT Reports to measure customer satisfaction.
Downloadable Reports for offline analysis and reporting.

Documentation

Detailed documentation is available at chatwoot.com/help-center.

Translation process

The translation process for Chatwoot web and mobile app is managed at https://translate.chatwoot.com using Crowdin. Please read the translation guide for contributing to Chatwoot.

Branching model

We use the git-flow branching model. The base branch is develop. If you are looking for a stable version, please use the master or tags labelled as v1.x.x.

Deployment

Heroku one-click deploy

Deploying Chatwoot to Heroku is a breeze. It's as simple as clicking this button:

Follow this link to understand setting the correct environment variables for the app to work with all the features. There might be breakages if you do not set the relevant environment variables.

DigitalOcean 1-Click Kubernetes deployment

Chatwoot now supports 1-Click deployment to DigitalOcean as a kubernetes app.

Other deployment options

For other supported options, checkout our deployment page.

Security

Looking to report a vulnerability? Please refer our SECURITY.md file.

Community

If you need help or just want to hang out, come, say hi on our Discord server.

Contributors

Thanks goes to all these wonderful people:

jekyll/jekyll

🌐 Jekyll is a blog-aware static site generator in Ruby

Jekyll

Jekyll is a simple, blog-aware, static site generator perfect for personal, project, or organization sites. Think of it like a file-based CMS, without all the complexity. Jekyll takes your content, renders Markdown and Liquid templates, and spits out a complete, static website ready to be served by Apache, Nginx or another web server. Jekyll is the engine behind GitHub Pages, which you can use to host sites right from your GitHub repositories.

Philosophy

Jekyll does what you tell it to do — no more, no less. It doesn't try to outsmart users by making bold assumptions, nor does it burden them with needless complexity and configuration. Put simply, Jekyll gets out of your way and allows you to concentrate on what truly matters: your content.

See: https://jekyllrb.com/philosophy

Getting Started

Install the gem
Read up about its Usage and Configuration
Take a gander at some existing Sites
Fork and Contribute your own modifications
Have questions? Check out our official forum community Jekyll Talk and #jekyll Channel on Libera IRC

Diving In

Migrate from your previous system
Learn how Front Matter works
Put information on your site with Variables
Customize the Permalinks your posts are generated with
Use the built-in Liquid Extensions to make your life easier
Use custom Plugins to generate content specific to your site
Watch video tutorials from Giraffe Academy

Need help?

If you don't find the answer to your problem in our docs, or in the troubleshooting section, ask the community for help.

Code of Conduct

In order to have a more open and welcoming community, Jekyll adheres to a code of conduct adapted from the Ruby on Rails code of conduct.

Please adhere to this code of conduct in any interactions you have in the Jekyll community. It is strictly enforced on all official Jekyll repositories, websites, and resources. If you encounter someone violating these terms, please let one of our core team members know and we will address it as soon as possible.

Credits

Contributors

This project exists thanks to all the people who contribute.

Backers

Thank you to all our backers! 🙏 Become a backer

License

See the LICENSE file.

github-linguist/linguist

Language Savant. If your repository's language is being reported incorrectly, send us a pull request!

Linguist

This library is used on GitHub.com to detect blob languages, ignore binary or vendored files, suppress generated files in diffs, and generate language breakdown graphs.

Documentation

Installation

Install the gem:

gem install github-linguist

Dependencies

Linguist is a Ruby library so you will need a recent version of Ruby installed. There are known problems with the macOS/Xcode supplied version of Ruby that causes problems installing some of the dependencies. Accordingly, we highly recommend you install a version of Ruby using Homebrew, rbenv, rvm, ruby-build, asdf or other packaging system, before attempting to install Linguist and the dependencies.

Linguist uses charlock_holmes for character encoding and rugged for libgit2 bindings for Ruby. These components have their own dependencies.

charlock_holmes
- cmake
- pkg-config
- ICU
- zlib
rugged
- libcurl
- OpenSSL

You may need to install missing dependencies before you can install Linguist. For example, on macOS with Homebrew:

brew install cmake pkg-config icu4c

On Ubuntu:

sudo apt-get install build-essential cmake pkg-config libicu-dev zlib1g-dev libcurl4-openssl-dev libssl-dev ruby-dev

Usage

Application usage

Linguist can be used in your application as follows:

require 'rugged'
require 'linguist'

repo = Rugged::Repository.new('.')
project = Linguist::Repository.new(repo, repo.head.target_id)
project.language       #=> "Ruby"
project.languages      #=> { "Ruby" => 119387 }

Command line usage

The github-linguist executable operates in two distinct modes:

Git Repository mode - Analyzes an entire Git repository (when given a directory path or no path)
Single file mode - Analyzes a specific file (when given a file path)

Git Repository

A repository's languages stats can be assessed from the command line using the github-linguist executable. Without any options, github-linguist will output the language breakdown by percentage and file size.

cd /path-to-repository
github-linguist

You can try running github-linguist on the root directory in this repository itself:

$ github-linguist
66.84%  264519     Ruby
24.68%  97685      C
6.57%   25999      Go
1.29%   5098       Lex
0.32%   1257       Shell
0.31%   1212       Dockerfile

Additional options

`--rev REV`

The --rev REV flag will change the git revision being analyzed to any gitrevisions(1) compatible revision you specify.

This is useful to analyze the makeup of a repo as of a certain tag, or in a certain branch.

For example, here is the popular Jekyll open source project.

$ github-linguist jekyll

70.64%  709959     Ruby
23.04%  231555     Gherkin
3.80%   38178      JavaScript
1.19%   11943      HTML
0.79%   7900       Shell
0.23%   2279       Dockerfile
0.13%   1344       Earthly
0.10%   1019       CSS
0.06%   606        SCSS
0.02%   234        CoffeeScript
0.01%   90         Hack

And here is Jekyll's published website, from the gh-pages branch inside their repository.

$ github-linguist jekyll --rev origin/gh-pages
100.00% 2568354    HTML

`--breakdown`

The --breakdown or -b flag will additionally show the breakdown of files by language.

You can try running github-linguist on the root directory in this repository itself:

$ github-linguist --breakdown
66.84%  264519     Ruby
24.68%  97685      C
6.57%   25999      Go
1.29%   5098       Lex
0.32%   1257       Shell
0.31%   1212       Dockerfile

Ruby:
Gemfile
Rakefile
bin/git-linguist
bin/github-linguist
ext/linguist/extconf.rb
github-linguist.gemspec
lib/linguist.rb
…

`--strategies`

The --strategies or -s flag will show the language detection strategy used for each file. This is useful for understanding how Linguist determined the language of specific files. Note that unless the --json flag is specified, this flag will set the --breakdown flag implicitly.

You can try running github-linguist on the root directory in this repository itself with the strategies flag:

$ github-linguist --breakdown --strategies
66.84%  264519     Ruby
24.68%  97685      C
6.57%   25999      Go
1.29%   5098       Lex
0.32%   1257       Shell
0.31%   1212       Dockerfile

Ruby:
  Gemfile [Filename]
  Rakefile [Filename]
  bin/git-linguist [Extension]
  bin/github-linguist [Extension]
  lib/linguist.rb [Extension]
  …

If a file's language is affected by .gitattributes, the strategy will show the original detection method along with a note indicating whether the gitattributes setting changed the result or confirmed it.

For instance, if you had the following .gitattributes overrides in your repo:


*.ts linguist-language=JavaScript
*.js linguist-language=JavaScript

the output of Linguist would be something like this:

100.00% 217        JavaScript

JavaScript:
  demo.ts [Heuristics (overridden by .gitattributes)]
  demo.js [Extension (confirmed by .gitattributes)]

`--json`

The --json or -j flag output the data into JSON format.

$ github-linguist --json
{"Dockerfile":{"size":1212,"percentage":"0.31"},"Ruby":{"size":264519,"percentage":"66.84"},"C":{"size":97685,"percentage":"24.68"},"Lex":{"size":5098,"percentage":"1.29"},"Shell":{"size":1257,"percentage":"0.32"},"Go":{"size":25999,"percentage":"6.57"}}

This option can be used in conjunction with --breakdown to get a full list of files along with the size and percentage data.

$ github-linguist --breakdown --json
{"Dockerfile":{"size":1212,"percentage":"0.31","files":["Dockerfile","tools/grammars/Dockerfile"]},"Ruby":{"size":264519,"percentage":"66.84","files":["Gemfile","Rakefile","bin/git-linguist","bin/github-linguist","ext/linguist/extconf.rb","github-linguist.gemspec","lib/linguist.rb",...]}}

NB. The --strategies flag has no effect, when the --json flag is present.

Single file

Alternatively you can find stats for a single file using the github-linguist executable.

You can try running github-linguist on files in this repository itself:

$ github-linguist grammars.yml
grammars.yml: 884 lines (884 sloc)
  type:      Text
  mime type: text/x-yaml
  language:  YAML

Additional options

`--breakdown`

This flag has no effect in Single file mode.

`--strategies`

When using the --strategies or -s flag with a single file, you can see which detection method was used:

$ github-linguist --strategies lib/linguist.rb 
lib/linguist.rb: 105 lines (96 sloc)
  type:      Text
  mime type: application/x-ruby
  language:  Ruby
  strategy:  Extension

If a file's language is affected by .gitattributes, the strategy will show whether the gitattributes setting changed the result or confirmed it:

In this fictitious example, it says "confirmed by .gitattributes" since the detection process (using the Filename strategy) would have given the same output as the override:

.devcontainer/devcontainer.json: 27 lines (27 sloc)
  type:      Text
  mime type: application/json
  language:  JSON with Comments
  strategy:  Filename (confirmed by .gitattributes)

In this other fictitious example, it says "overridden by .gitattributes" since the gitattributes setting changes the detected language to something different:

test.rb: 13 lines (11 sloc)
  type:      Text
  mime type: application/x-ruby
  language:  Java
  strategy:  Extension (overridden by .gitattributes)

Here, the .rb file would normally be detected as Ruby by the Extension strategy, but .gitattributes overrides it to be detected as Java instead.

`--json`

Using the --json flag will give you the output for a single file in JSON format:

$ github-linguist --strategies --json  lib/linguist.rb
{"lib/linguist.rb":{"lines":105,"sloc":96,"type":"Text","mime_type":"application/x-ruby","language":"Ruby","large":false,"generated":false,"vendored":false}}

NB. The --strategies has no effect, when the --json flag is present.

Docker

If you have Docker installed you can either build or use our pre-built images and run Linguist within a container:

$ docker run --rm -v $(pwd):$(pwd):Z -w $(pwd) -t ghcr.io/github-linguist/linguist:latest
66.84%  264519     Ruby
24.68%  97685      C
6.57%   25999      Go
1.29%   5098       Lex
0.32%   1257       Shell
0.31%   1212       Dockerfile

Building the image

$ docker build -t linguist .
$ docker run --rm -v $(pwd):$(pwd):Z -w $(pwd) -t linguist
66.84%  264519     Ruby
24.68%  97685      C
6.57%   25999      Go
1.29%   5098       Lex
0.32%   1257       Shell
0.31%   1212       Dockerfile
$ docker run --rm -v $(pwd):$(pwd) -w $(pwd) -t linguist github-linguist --breakdown
66.84%  264519     Ruby
24.68%  97685      C
6.57%   25999      Go
1.29%   5098       Lex
0.32%   1257       Shell
0.31%   1212       Dockerfile

Ruby:
Gemfile
Rakefile
bin/git-linguist
bin/github-linguist
ext/linguist/extconf.rb
github-linguist.gemspec
lib/linguist.rb
…

Contributing

Please check out our contributing guidelines.

License

The language grammars included in this gem are covered by their repositories' respective licenses. vendor/README.md lists the repository for each grammar.

All other files are covered by the MIT license, see LICENSE.

freeCodeCamp/devdocs

API Documentation Browser

DevDocs — API Documentation Browser

DevDocs combines multiple developer documentations in a clean and organized web UI with instant search, offline support, mobile version, dark theme, keyboard shortcuts, and more.

DevDocs was created by Thibaut Courouble and is operated by freeCodeCamp.

We are currently searching for maintainers

Please reach out to the community on Discord if you would like to join the team!

Keep track of development news:

Join the #contributors chat room on Discord
Watch the repository on GitHub

Table of Contents: Quick Start · Vision · App · Scraper · Commands · Contributing · Documentation · Related Projects · License · Questions?

Quick Start

Unless you wish to contribute to the project, we recommend using the hosted version at devdocs.io. It's up-to-date and works offline out-of-the-box.

Using Docker (Recommended)

The easiest way to run DevDocs locally is using Docker:

docker run --name devdocs -d -p 9292:9292 ghcr.io/freecodecamp/devdocs:latest

This will start DevDocs at localhost:9292. We provide both regular and Alpine-based images:

ghcr.io/freecodecamp/devdocs:latest - Standard image
ghcr.io/freecodecamp/devdocs:latest-alpine - Alpine-based (smaller size)

Images are automatically built and updated monthly with the latest documentation.

Alternatively, you can build the image yourself:

git clone https://github.com/freeCodeCamp/devdocs.git && cd devdocs
docker build -t devdocs .
docker run --name devdocs -d -p 9292:9292 devdocs

Manual Installation

DevDocs is made of two pieces: a Ruby scraper that generates the documentation and metadata, and a JavaScript app powered by a small Sinatra app.

DevDocs requires Ruby 4.0.5 (defined in Gemfile), libcurl, and a JavaScript runtime supported by ExecJS (included in OS X and Windows; Node.js on Linux). On Arch Linux run pacman -S ruby ruby-bundler ruby-erb ruby-irb.

Once you have these installed, run the following commands:

git clone https://github.com/freeCodeCamp/devdocs.git && cd devdocs
gem install bundler
bundle install
bundle exec thor docs:download --default
bundle exec rackup

Finally, point your browser at localhost:9292 (the first request will take a few seconds to compile the assets). You're all set.

The thor docs:download command is used to download pre-generated documentations from DevDocs's servers (e.g. thor docs:download html css). You can see the list of available documentations and versions by running thor docs:list. To update all downloaded documentations, run thor docs:download --installed. To download and install all documentation this project has available, run thor docs:download --all.

Note: there is currently no update mechanism other than git pull origin main to update the code and thor docs:download --installed to download the latest version of the docs. To stay informed about new releases, be sure to watch this repository.

Vision

DevDocs aims to make reading and searching reference documentation fast, easy and enjoyable.

The app's main goals are to:

Keep load times as short as possible
Improve the quality, speed, and order of search results
Maximize the use of caching and other performance optimizations
Maintain a clean and readable user interface
Be fully functional offline
Support full keyboard navigation
Reduce “context switch” by using a consistent typography and design across all documentations
Reduce clutter by focusing on a specific category of content (API/reference) and indexing only the minimum useful to most developers.

Note: DevDocs is neither a programming guide nor a search engine. All our content is pulled from third-party sources and the project doesn't intend to compete with full-text search engines. Its backbone is metadata; each piece of content is identified by a unique, "obvious" and short string. Tutorials, guides and other content that don't meet this requirement are outside the scope of the project.

App

The web app is all client-side JavaScript, powered by a small Sinatra/Sprockets application. It relies on files generated by the scraper.

Many of the code's design decisions were driven by the fact that the app uses XHR to load content directly into the main frame. This includes stripping the original documents of most of their HTML markup (e.g. scripts and stylesheets) to avoid polluting the main frame, and prefixing all CSS class names with an underscore to prevent conflicts.

Another driving factor is performance and the fact that everything happens in the browser. A service worker (which comes with its own set of constraints) and localStorage are used to speed up the boot time, while memory consumption is kept in check by allowing the user to pick his/her own set of documentations. The search algorithm is kept simple because it needs to be fast even searching through 100,000 strings.

DevDocs being a developer tool, the browser requirements are high:

Recent versions of Firefox, Chrome, or Opera
Safari 11.1+
Edge 17+
iOS 11.3+

This allows the code to take advantage of the latest DOM and HTML5 APIs and make developing DevDocs a lot more fun!

Scraper

The scraper is responsible for generating the documentation and index files (metadata) used by the app. It's written in Ruby under the Docs module.

There are currently two kinds of scrapers: UrlScraper which downloads files via HTTP and FileScraper which reads them from the local filesystem. They both make copies of HTML documents, recursively following links that match a set of rules and applying all sorts of modifications along the way, in addition to building an index of the files and their metadata. Documents are parsed using Nokogiri.

Modifications made to each document include:

removing content such as the document structure (<html>, <head>, etc.), comments, empty nodes, etc.
fixing links (e.g. to remove duplicates)
replacing all external (not scraped) URLs with their fully qualified counterpart
replacing all internal (scraped) URLs with their unqualified and relative counterpart
adding content, such as a title and link to the original document
ensuring correct syntax highlighting using Prism

These modifications are applied via a set of filters using the HTML::Pipeline library. Each scraper includes filters specific to itself, one of which is tasked with figuring out the pages' metadata.

The end result is a set of normalized HTML partials and two JSON files (index + offline data). Because the index files are loaded separately by the app following the user's preferences, the scraper also creates a JSON manifest file containing information about the documentations currently available on the system (such as their name, version, update date, etc.).

More information about scrapers and filters is available in the docs folder.

Available Commands

The command-line interface uses Thor. To see all commands and options, run thor list from the project's root.

# Server
rackup              # Start the server (ctrl+c to stop)
rackup --help       # List server options

# Docs
thor docs:list      # List available documentations
thor docs:download  # Download one or more documentations
thor docs:manifest  # Create the manifest file used by the app
thor docs:generate  # Generate/scrape a documentation
thor docs:page      # Generate/scrape a documentation page
thor docs:package   # Package a documentation for use with docs:download
thor docs:clean     # Delete documentation packages

# Console
thor console        # Start a REPL
thor console:docs   # Start a REPL in the "Docs" module

# Tests can be run quickly from within the console using the "test" command.
# Run "help test" for usage instructions.
thor test:all       # Run all tests
thor test:docs      # Run "Docs" tests
thor test:app       # Run "App" tests
thor test:coverage  # Run coverage report on "App" tests

# Assets
thor assets:compile # Compile assets (not required in development mode)
thor assets:clean   # Clean old assets

If multiple versions of Ruby are installed on your system, commands must be run through bundle exec.

Contributing

Contributions are welcome. Please read the contributing guidelines.

Documentation

DevDocs Quick Usage Cheatsheet

Below are some helpful shortcuts and usage tips that are not immediately obvious to new users:

Press / or Ctrl + K to instantly focus the search bar.
Press ? to open DevDocs’ built-in help overlay.
Press ↑ or ↓ to navigate search results without touching the mouse.
Press Enter to open the highlighted search result.
Press Backspace to go back to the previously viewed page.
Press Shift + S to toggle the sidebar visibility.
Press A to open the list of all installed documentation sets.
Press Esc to close popups, overlays, and search.
Use the ⚡ Offline Mode toggle to download docs for offline use.
You can pin specific documentation sets to the sidebar for quicker access.

These shortcuts make DevDocs faster to navigate and more efficient for daily use.

Related Projects

Made something cool? Feel free to open a PR to add a new row to this table! You might want to discover new projects via https://github.com/topics/devdocs.

Project	Description	Last commit	Stars
yannickglt/alfred-devdocs	Alfred workflow
Merith-TK/devdocs_webapp_kotlin	Android application
gruehle/dev-docs-viewer	Brackets extension
egoist/devdocs-desktop	Electron application
skeeto/devdocs-lookup	Emacs function
astoff/devdocs.el	Emacs viewer
naquad/devdocs-shell	GTK shell with Vim integration
hardpixel/devdocs-desktop	GTK application
qwfy/doc-browser	Linux application
dteoh/devdocs-macos	macOS application
Sublime Text plugin	Sublime Text plugin
mohamed3nan/DevDocs-Tab	VS Code extension (view as tab)
deibit/vscode-devdocs	VS Code extension (open the browser)
mdh34/quickDocs	Vala/Python based viewer
girishji/devdocs.vim	Vim plugin & TUI (browse inside Vim)
romainl/vim-devdocs	Vim plugin
waiting-for-dev/vim-www	Vim plugin
emmanueltouzery/apidocs.nvim	Neovim plugin
toiletbril/dedoc	Terminal based viewer
Raycast Devdocs	Raycast extension	Unavailable	Unavailable
chrisgrieser/alfred-docs-searches	Alfred workflow

Copyright / License

This software is licensed under the terms of the Mozilla Public License v2.0. See the COPYRIGHT and LICENSE files.

Please do not use the name DevDocs to endorse or promote products derived from this software without the maintainers' permission, except as may be necessary to comply with the notice/attribution requirements.

We also wish that any documentation file generated using this software be attributed to DevDocs. Let's be fair to all contributors by giving credit where credit's due. Thanks!

Questions?

If you have any questions, please feel free to ask them on the #contributors chat room on Discord.

we-promise/sure

The personal finance app for everyone (by everyone)

Sure: The personal finance app for everyone

Get involved: Discord • Website • Issues

Important

This repository is a community fork of the now-abandoned Maybe Finance project.
Learn more in their final release doc.

Backstory

The Maybe Finance (archived/abandoned repo) team spent most of 2021–2022 building a full-featured personal finance and wealth management app. It even included an “Ask an Advisor” feature that connected users with a real CFP/CFA — all included with your subscription.

The business end of things didn't work out, and so they stopped developing the app in mid-2023.

After spending nearly $1 million on development (employees, contractors, data providers, infra, etc.), the team open-sourced the app. Their goal was to let users self-host it for free — and eventually launch a hosted version for a small fee.

They actually did launch that hosted version … briefly.

That also didn’t work out — at least not as a sustainable B2C business — so now here we are: hosting a community-maintained fork to keep the codebase alive and see where this can go next.

Join us!

Hosting Sure

Sure is a fully working personal finance app that can be self hosted with Docker.

Forking and Attribution

This repo is a community fork of the archived Maybe Finance repo. You’re free to fork it under the AGPLv3 license — but we’d love it if you stuck around and contributed here instead.

To stay compliant and avoid trademark issues:

Be sure to include the original AGPLv3 license and clearly state in your README that your fork is based on Maybe Finance but is not affiliated with or endorsed by Maybe Finance Inc.
"Maybe" is a trademark of Maybe Finance Inc. and therefore, use of it is NOT allowed in forked repositories (or the logo)

Performance Issues

With data-heavy apps, inevitably, there are performance issues. We've set up a public dashboard showing the problematic requests seen on the demo site, along with the stacktraces to help debug them.

https://www.skylight.io/app/applications/s6PEZSKwcklL/recent/6h/endpoints

Any contributions that help improve performance are very much welcome.

Local Development Setup

If you are trying to self-host the app, read this guide to get started.

The instructions below are for developers to get started with contributing to the app.

Requirements

See .ruby-version file for required Ruby version
PostgreSQL >9.3 (latest stable version recommended)
Redis > 5.4 (latest stable version recommended)

Getting Started

cd sure
cp .env.local.example .env.local
bin/setup
bin/dev

# Optionally, load demo data
rake demo_data:default

Visit http://localhost:3000 to view the app.

If you loaded the optional demo data, log in with these credentials:

Email: user@example.com
Password: Password1!

For further instructions, see guides below.

Setup Guides

One-click Install

Managed OpenClaw for Sure Finances

License and Trademarks

Maybe and Sure are both distributed under an AGPLv3 license.

"Maybe" is a trademark of Maybe Finance, Inc.
"Sure" is not, and refers to this community fork.

zammad/zammad

Zammad is a web based open source helpdesk/customer support system.

Welcome to Zammad

Are you juggling countless customer inquiries across multiple channels? Struggling to keep your support team on the same page? Or spending more time managing your helpdesk than delivering exceptional support to your customers?

Zammad is your Swiss Army knife - a web-based, open-source helpdesk and customer support platform packed with features to streamline customer communication across channels like email, chat, telephone and social media.

The Software

The Zammad software is and will stay open source. It is licensed under the GNU AGPLv3. The source code is available on GitHub and owned by the Zammad Foundation, which is independent of commercial providers such as Zammad GmbH.

The Company - Zammad GmbH

The development of Zammad is carried out by the amazing team of people at Zammad GmbH in collaboration with the community. We love to create open source software for you. If you want to ensure the Zammad software has a bright and sustainable future, consider becoming a Zammad customer!

Are you tired of complex setup, configuration, backup and update tasks? Let us handle this stuff for you! 🚀

The easiest and often most cost-effective way to operate Zammad is our cloud service. Give it a try with a free trial instance!

Status

Toolchain:
Docker container images:
Helm chart for Kubernetes:
Download DEB/RPM:
License:

Further Information

Installing & Getting Started
Screenshots
Developer Manual
REST API
For reporting security vulnerabilities, please see our security policy.
Contributing

Thanks! ❤️ ❤️ ❤️

Your Zammad Team

gitlabhq/gitlabhq

GitLab CE Mirror | Please open new issues in our issue tracker on GitLab.com

GitLab

Canonical source

The canonical source of GitLab where all development takes place is hosted on GitLab.com.

If you wish to clone a copy of GitLab without proprietary code, you can use the read-only mirror of GitLab located at https://gitlab.com/gitlab-org/gitlab-foss/. However, please do not submit any issues and/or merge requests to that project.

Free trial

You can request a free trial of GitLab Ultimate on our website.

Open source software to collaborate on code

To see how GitLab looks please see the features page on our website.

Manage Git repositories with fine grained access controls that keep your code secure
Perform code reviews and enhance collaboration with merge requests
Complete continuous integration (CI) and continuous deployment/delivery (CD) pipelines to build, test, and deploy your applications
Each project can also have an issue tracker, issue board, and a wiki
Used by more than 100,000 organizations, GitLab is the most popular solution to manage Git repositories on-premises
Open-core, most of the code is MIT with the files in /ee being proprietary but source available and open for contributions.

Editions

There are three editions of GitLab:

GitLab Community Edition (CE) is available freely under the MIT Expat license.
GitLab Enterprise Edition (EE) includes extra features that are more useful for organizations with more than 100 users. To use EE and get official support please become a subscriber.
JiHu Edition (JH) tailored specifically for the Chinese market.

Licensing

See the LICENSE file for licensing information as it pertains to files in this repository.

Hiring

We are hiring developers, support engineers, and production engineers all the time, please see our jobs page.

Website

On about.gitlab.com you can find more information about:

Subscriptions
Professional Services
Community
Hosted GitLab.com use GitLab as a free service
GitLab Enterprise Edition with additional features aimed at larger organizations.
GitLab CI a continuous integration (CI) server that is easy to integrate with GitLab.

Requirements

Please see the requirements documentation for system requirements and more information about the supported operating systems.

Installation

The recommended way to install GitLab is with the Omnibus packages on our package server. Compared to a self-compiled installation, this is faster and less error prone. Just select your operating system, download the respective package (Debian or RPM) and install it using the system's package manager.

For more information about other installation methods, see install GitLab.

Contributing

GitLab is an open source project and we are very happy to accept community contributions. Please refer to the CONTRIBUTING.md file for more details.

Install a development environment

To work on GitLab itself, we recommend setting up your development environment with the GitLab Development Kit (GDK). If you do not use GDK, you need to install and configure all the dependencies yourself, this is a lot of work and error prone. One small thing you also have to do when installing it yourself is to copy the example development Puma configuration file:

cp config/puma.example.development.rb config/puma.rb

Instructions on how to start GitLab and how to run the tests can be found in the getting started section of the GitLab Development Kit.

Software stack

GitLab is a Ruby on Rails application that runs on the following software:

Ubuntu/Debian/CentOS/RHEL/OpenSUSE
Ruby (MRI) 3.3.10
Git 2.33+
Redis 6.0+
PostgreSQL 16.5+

For more information please see the architecture and requirements documentation.

UX design

Please adhere to the UX Guide when creating designs and implementing code.

Third-party applications

There are a lot of third-party applications integrating with GitLab. These include GUI Git clients, mobile applications and API wrappers for various languages.

GitLab release cycle

For more information about the release process see the release documentation.

Upgrading

For upgrading information please see our update page.

Documentation

All documentation can be found on https://docs.gitlab.com.

Education

Get up to speed quickly with comprehensive learning resources at GitLab University.

Getting help

Please see Getting help for GitLab on our website for the many options to get help.

Why should I use GitLab?

Read why our customers choose GitLab.

spree/spree

Open Source eCommerce Platform for B2B, Marketplace, and Enterprise. REST API, TypeScript SDK, and production-ready Next.js storefront. Self-host it. Own your stack. No vendor lock-in. Zero platform fees.

Website · Free Sandbox · Next.js Storefront · Documentation · API · Roadmap · Discord

Open-source headless eCommerce platform with a complete REST API, TypeScript SDK, and a production-ready Next.js storefront. BSD 3-Clause licensed — keep full ownership of your code, data, and infrastructure.

Everything you need to launch cross-border storefronts, B2B wholesale, or a custom commerce backend.

Getting Started

The fastest way to try Spree is to create a free sandbox — a hosted Spree store with the Admin Dashboard and storefront, nothing to install.

To run Spree locally instead, copy and paste the following command to your terminal to set it up in 5 minutes:

npx create-spree-app@latest my-store

This sets up the Spree Commerce backend, the Admin Dashboard, and the Next.js storefront in a single project. The storefront is built with Next.js 16, React 19, Tailwind CSS 4, and TypeScript.

You need to have Node.js (22+) installed and Docker running. Learn more in the installation docs.

If you like what you see, consider giving Spree a GitHub star ⭐

Thank you for supporting Spree open-source ❤️

Agentic Development

Building with an AI coding agent? Install the Spree agent skills — they teach Claude Code, Cursor, Copilot, and 60+ other tools Spree's conventions, customization patterns, and upgrade flows:

npx skills add spree/agent-skills

Then connect the docs MCP server and let your agent build with you. Learn more in the Agentic Development docs.

Spree CLI

@spree/cli manages your Spree project from the terminal — boot the stack, run generators and migrations, tail logs — and calls the Admin API directly with simple get/post/patch/delete commands. It's a fast way to inspect and script your store, and works hands-free for AI agents (zero-config credentials in local dev):

spree dev                                                            # boot the project (web + worker + db)
spree generate api_resource Brand name:string description:rich_text  #  Creates full API endpoints, models and database schema for a Brand resource
spree api get /orders -q status_eq=complete --limit 10               # query the Admin API
spree api post /products -d '{"name":"Classic Tee","prices":[{"currency":"USD","amount":"29.99"}]}'  # create resources

spree api endpoints and spree api schema explore the full API offline. See the CLI docs.

Features

Everything below ships in this repository under the BSD 3-Clause license.

REST API & TypeScript SDK — production-grade REST API, publishable keys, rate limiting, and OpenAPI 3.0 spec. The TypeScript SDK adds autocomplete and type safety.
Spree CLI — manage projects from the terminal (boot, generate, migrate, upgrade) and call the Admin API directly with spree api get/post/... — zero-config in local dev, built for scripts and AI agents.
Next.js Storefront — open-source storefront built with Next.js 16, React 19, Tailwind CSS 4, and TypeScript. Full shopping experience, multi-region URL routing, Stripe payments (Apple Pay, Google Pay, Klarna, Affirm), customer accounts, and SEO built in. Try the demo
Cross-Border Commerce — Markets bundle currency, language, payment methods, and shipping rules per country. Translations Center for bulk product localization. EU Omnibus Directive compliance with automatic 30-day price history.
B2B & Wholesale — Price Lists for regional, B2B, and wholesale pricing. Customer Groups for segmentation. Companies, company locations, and company contacts for buyer organizations. Catalogs for curated, per-segment product assortments. Gated storefronts via publishable keys.
Sales Channels — run multiple storefronts, Points of Sale, B2B panels, mobile apps off a single Spree backend, each with its products, pricing, payment methods, and shipping rules
Payment Sessions — provider-agnostic payment processing. Shipped with Stripe, Adyen and PayPal plugins ready to use with Next.js storefront. Add your own with the Payment Provider SDK.
Promotions & Gift Cards — advanced rules-based promotions engine and native Gift Cards support.
Products & Catalog — Metafields, CSV importer/exporter, digital products, product tags, bulk operations.
MeiliSearch Integration — typo-tolerant product search and faceted filtering.
Admin Dashboard — built with Tailwind CSS with role-based permissions.
Integrations & Extensibility — Event Bus, Webhooks 2.0, native integrations (GA4, GTM, Klaviyo).
Agentic Development — 25 agent skills (npx skills add spree/agent-skills) teaching AI coding agents Spree's conventions, a docs MCP server, LLM-ready documentation (llms.txt, per-page Markdown, offline npm package), and a generated AGENTS.md/CLAUDE.md in every scaffolded project.

Deployment

Spree backend can be deployed everywhere, on cloud, on prem or VPS. We provide official Docker images and Dockerfiles so you can use AWS, Azure, GCP, Render, Railway, Fly.io, Heroku, or any other Docker-compatible host. The Next.js storefront can be deployed to Vercel, Netlify, or any Node.js host. See the Deployment Documentation for more details.

If you want to quickly evaluate Spree, you can use the free sandbox — a hosted Spree store with the Admin Dashboard and storefront, nothing to install.

Screenshots

Next.js eCommerce Storefront

A production-ready, open-source storefront built with Next.js 16, React 19, and TypeScript. Fork it, customize it, deploy it. Try the live demo

Cross-border eCommerce

Sell in multiple markets with local currencies, languages, payment methods, and shipping rules. Markets bundle per-country configuration so each customer sees a localized storefront from a single platform.

Wholesale & B2B Pricing

Price Lists, Customer Groups, and gated storefronts. Sell to multiple customer segments with the right assortment and pricing per segment.

Multi-vendor Marketplace

Launch a multi-vendor marketplace with vendor accounts, product catalog curation, split payments, vendor payouts, and commission management. The Enterprise Edition adds automated vendor onboarding (Shopify, WooCommerce sync) and Stripe Connect / Adyen for Platforms integrations.

Community & Contributing

Spree is an open-source project, and we love contributions in any form — pull requests, issues, feature ideas.

Follow our Contributing Guide
Join our Discord to meet other community members
Browse the Roadmap and open Issues

Spree Enterprise Edition

Spree is built and maintained by a funded team behind the open-source project. Beyond the open-source Core, we offer a paid Enterprise Edition for organizations that need additional modules and SLA-backed support.

Enterprise Edition is built on top of the same open-source REST API and BSD 3-Clause Core, so your team keeps full ownership of the code, the data, and the infrastructure. Zero platform fees. Zero transaction fees.

What's in Core vs. Enterprise

Capability	Open-source (this repo)	Enterprise Edition
REST API, TypeScript SDK, Next.js storefront	✅	✅
Sales Channels, Markets, cross-border, multi-currency	✅	✅
Promotions, Gift Cards, Digital Products	✅	✅
Payment integrations: Stripe, Adyen, PayPal	✅	✅
Automatic tax calculation with Avatax & Stripe Tax	✅	✅
B2B & Wholesale — Price Lists, Customer Groups, gated storefronts	✅	✅
B2B Buyer organizations (companies, locations, contacts)	Coming soon in Spree 6.0	✅
B2B Catalogs — curated per-segment product assortments	Coming soon in Spree 6.0	✅
B2B approval workflows & ERP integrations — role-based approval chains, procurement and ERP connectors	—	✅
Multi-vendor Marketplace — vendor onboarding, vendor panel, commissions, split payments, vendor payouts	Coming soon in Spree 6.0	✅
Marketplace automations — Shopify/WooCommerce vendor sync, Stripe Connect onboarding, automated commission rules, advanced reporting	—	✅
Multi-tenant SaaS — super-admin layer, tenant provisioning, white-label billing, central operations across hundreds of tenant stores	—	✅
Enterprise security — SSO (SAML/OIDC), encryption at-rest, audit logging, PCI-compliant architecture	—	✅
SLA support — dedicated success manager, guaranteed response times, LTS releases, 24/7 monitoring	—	✅

Contact our Sales team for an Enterprise Edition demo, or join Discord to use the open-source edition with the community.

License

Spree Commerce core code in the spree/spree repository is released under the free, open-source BSD-3-Clause license (LICENSE).

If you like what you see, consider giving Spree a GitHub star ⭐

Thank you for supporting Spree open-source ❤️

basecamp/once-campfire

Super simple group chat, without a subscription

Campfire

Campfire is a web-based chat application. It supports many of the features you'd expect, including:

Multiple rooms, with access controls
Direct messages
File attachments with previews
Search
Notifications (via Web Push)
@mentions
API, with support for bot integrations

Running your own Campfire instance

Campfire's Docker image contains everything needed for a fully-functional, single-machine deployment. This includes the web app, background jobs, caching, file serving, and SSL. You can use our pre-built image at ghcr.io/basecamp/once-campfire:latest, or build your own from this repo.

Deploying with ONCE

The easiest way to self-host Campfire is with ONCE. It will guide you through the initial set up and then keep your instance up to date automatically.

If you don't already have once installed, run this on the machine you want to run Campfire on:

curl https://get.once.com | sh

once will launch as soon as the install is finished.

Choose Campfire from the list of applications, follow the instructions, and ONCE will take care of the rest.

If you prefer the command line to the dashboard, you can deploy directly:

once deploy ghcr.io/basecamp/once-campfire --host chat.example.com

Deploying with Docker

If you'd rather run the Docker image yourself, you can read more about that in the self-hosting guide.

Tip

When you start Campfire for the first time, you'll be guided through a wizard to create an admin account. The email address that you enter for the admin account will be visible on the sign-in page, it's there so that people have someone to contact if they need help with their account. If that bothers you, put in any email address you want and create yourself a new admin account.

Development

You are welcome - and encouraged - to modify Campfire to your liking. Please see our development guide for how to get Campfire set up for local development.

Security

See SECURITY.md for how to report a vulnerability and a description of our trust model.

huginn/huginn

Create agents that monitor and act on your behalf. Your agents are standing by!

What is Huginn?

Huginn is a system for building agents that perform automated tasks for you online. They can read the web, watch for events, and take actions on your behalf. Huginn's Agents create and consume events, propagating them along a directed graph. Think of it as a hackable version of IFTTT or Zapier on your own server. You always know who has your data. You do.

Here are some of the things that you can do with Huginn:

Track the weather and get an email when it's going to rain (or snow) tomorrow ("Don't forget your umbrella!")
List terms that you care about and receive email when their occurrence on Twitter changes. (For example, want to know when something interesting has happened in the world of Machine Learning? Huginn will watch the term "machine learning" on Twitter and tell you when there is a spike in discussion.)
Watch for air travel or shopping deals
Follow your project names on Twitter and get updates when people mention them
Scrape websites and receive email when they change
Connect to HipChat, FTP, IMAP, Jabber, JIRA, MQTT, nextbus, Pushbullet, Pushover, RSS, Bash, Slack, StubHub, translation APIs, Twilio, Twitter, and Weibo, to name a few.
Send digest email with things that you care about at specific times during the day
Track counts of high frequency events and send an SMS within moments when they spike, such as the term "san francisco emergency"
Send and receive WebHooks
Run custom JavaScript functions
Track your location over time
Create Amazon Mechanical Turk workflows as the inputs, or outputs, of agents (the Amazon Turk Agent is called the "HumanTaskAgent"). For example: "Once a day, ask 5 people for a funny cat photo; send the results to 5 more people to be rated; send the top-rated photo to 5 people for a funny caption; send to 5 final people to rate for funniest caption; finally, post the best captioned photo on my blog."

Join us in our Gitter room to discuss the project.

Join us!

Want to help with Huginn? All contributions are encouraged! You could make UI improvements, add new Agents, write documentation and tutorials, or try tackling issues tagged with #"help wanted". Please fork, add specs, and send pull requests!

Have an awesome idea but not feeling quite up to contributing yet? Head over to our Official 'suggest an agent' thread and tell us!

Examples

Please checkout the Huginn Introductory Screencast!

And now, some example screenshots. Below them are instructions to get you started.

Getting Started

Docker

The quickest and easiest way to check out Huginn is to use the official Docker image. Have a look at the documentation.

Local Installation

If you just want to play around, you can simply fork this repository, then perform the following steps:

Run git remote add upstream https://github.com/huginn/huginn.git to add the main repository as a remote for your fork.
Copy .env.example to .env (cp .env.example .env) and edit .env, at least updating the APP_SECRET_TOKEN variable.
Make sure that you have MySQL or PostgreSQL installed. (On a Mac, the easiest way is with Homebrew. If you're going to use PostgreSQL, you'll need to prepend all commands below with DATABASE_ADAPTER=postgresql.)
Run bundle to install dependencies
Run bundle exec rake db:create, bundle exec rake db:migrate, and then bundle exec rake db:seed to create a development database with some example Agents.
Run bundle exec foreman start, visit http://localhost:3000/, and login with the username of admin and the password of password.
Setup some Agents!
Read the wiki for usage examples and to get started making new Agents.
Periodically run git fetch upstream and then git checkout master && git merge upstream/master to merge in the newest version of Huginn.

Note: By default, email messages are intercepted in the development Rails environment, which is what you just setup. You can view them at http://localhost:3000/letter_opener. If you'd like to send real email via SMTP when playing with Huginn locally, set SEND_EMAIL_IN_DEVELOPMENT to true in your .env file.

If you need more detailed instructions, see the Novice setup guide.

Develop

All agents have specs! And there's also acceptance tests that simulate running Huginn in a headless browser.

Install Google Chrome and ChromeDriver for local feature specs
Or use the Docker-based test environment in docker/test/README.md
Run all specs with bundle exec rspec
Run a specific spec with bundle exec rspec path/to/specific/test_spec.rb.
Read more about rspec for rails here.

Using Huginn Agent gems

Huginn Agents can now be written as external gems and be added to your Huginn installation with the ADDITIONAL_GEMS environment variable. See the Additional Agent gems section of .env.example for more information.

If you'd like to write your own Huginn Agent Gem, please see huginn_agent.

Our general intention is to encourage complex and specific Agents to be written as Gems, while continuing to add new general-purpose Agents to the core Huginn repository.

Deployment

Please see the Huginn Wiki for detailed deployment strategies for different providers.

Heroku

Try Huginn on Heroku: (Takes a few minutes to setup. Read the documentation while you are waiting and be sure to click 'View it' after launch!) Huginn launches only on a paid subscription plan for Heroku. For non-experimental use, we strongly recommend Heroku's 1GB paid plan or our Docker container.

OpenShift

OpenShift Online

Try Huginn on OpenShift Online

Create a new app with either mysql or postgres:

oc new-app -f https://raw.githubusercontent.com/huginn/huginn/master/openshift/templates/huginn-mysql.json

oc new-app -f https://raw.githubusercontent.com/huginn/huginn/master/openshift/templates/huginn-postgresql.json

Note: You can also use the web console to import either json file by going to "Add to Project" -> "Import YAML/JSON".

If you are on the Starter plan, make sure to follow the guide to remove any existing application.

The templates should work on a v3 installation or the current v4 online.

Manual installation on any server

Have a look at the installation guide.

Optional Setup

Setup for private development

See private development instructions on the wiki.

Enable the WeatherAgent

In order to use the WeatherAgent you need an Weather Data API key from Pirate Weather. Sign up for one and then change the value of api_key: your-key in your seeded WeatherAgent.

Disable SSL

We assume your deployment will run over SSL. This is a very good idea! However, if you wish to turn this off, you'll probably need to edit config/initializers/devise.rb and modify the line containing config.rememberable_options = { :secure => true }. You will also need to edit config/environments/production.rb and modify the value of config.force_ssl.

License

Huginn is provided under the MIT License.

Huginn was originally created by @cantino in 2013. Since then, many people's dedicated contributions have made it what it is today.

Homebrew/homebrew-core

🍻 Default and OSS formulae (built-from-source packages) for the package manager for everywhere

Homebrew Core

Core formulae for the Homebrew package manager.

Homebrew/discussions (forum)

How do I install these formulae?

Just brew install <formula>. This is the default tap for Homebrew and is installed by default.