diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml new file mode 100644 index 0000000..2c6fd97 --- /dev/null +++ b/.github/workflows/release.yml @@ -0,0 +1,168 @@ +# Copyright 2022-2023, axodotdev +# SPDX-License-Identifier: MIT or Apache-2.0 +# +# CI that: +# +# * checks for a Git Tag that looks like a release +# * builds artifacts with cargo-dist (archives, installers, hashes) +# * uploads those artifacts to temporary workflow zip +# * on success, uploads the artifacts to a Github Release™ +# +# Note that the Github Release™ will be created with a generated +# title/body based on your changelogs. +name: Release + +permissions: + contents: write + +# This task will run whenever you push a git tag that looks like a version +# like "1.0.0", "v0.1.0-prerelease.1", "my-app/0.1.0", "releases/v1.0.0", etc. +# Various formats will be parsed into a VERSION and an optional PACKAGE_NAME, where +# PACKAGE_NAME must be the name of a Cargo package in your workspace, and VERSION +# must be a Cargo-style SemVer Version (must have at least major.minor.patch). +# +# If PACKAGE_NAME is specified, then the release will be for that +# package (erroring out if it doesn't have the given version or isn't cargo-dist-able). +# +# If PACKAGE_NAME isn't specified, then the release will be for all +# (cargo-dist-able) packages in the workspace with that version (this mode is +# intended for workspaces with only one dist-able package, or with all dist-able +# packages versioned/released in lockstep). +# +# If you push multiple tags at once, separate instances of this workflow will +# spin up, creating an independent Github Release™ for each one. However Github +# will hard limit this to 3 tags per commit, as it will assume more tags is a +# mistake. +# +# If there's a prerelease-style suffix to the version, then the Github Release™ +# will be marked as a prerelease. +on: + push: + tags: + - '**[0-9]+.[0-9]+.[0-9]+*' + pull_request: + +jobs: + # Run 'cargo dist plan' to determine what tasks we need to do + plan: + runs-on: ubuntu-latest + outputs: + val: ${{ steps.plan.outputs.manifest }} + tag: ${{ !github.event.pull_request && github.ref_name || '' }} + tag-flag: ${{ !github.event.pull_request && format('--tag={0}', github.ref_name) || '' }} + publishing: ${{ !github.event.pull_request }} + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + steps: + - uses: actions/checkout@v4 + with: + submodules: recursive + - name: Install cargo-dist + run: "curl --proto '=https' --tlsv1.2 -LsSf https://github.com/axodotdev/cargo-dist/releases/download/v0.4.2/cargo-dist-installer.sh | sh" + - id: plan + run: | + cargo dist plan ${{ !github.event.pull_request && format('--tag={0}', github.ref_name) || '' }} --output-format=json > dist-manifest.json + echo "cargo dist plan ran successfully" + cat dist-manifest.json + echo "manifest=$(jq -c "." dist-manifest.json)" >> "$GITHUB_OUTPUT" + - name: "Upload dist-manifest.json" + uses: actions/upload-artifact@v3 + with: + name: artifacts + path: dist-manifest.json + + # Build and packages all the platform-specific things + upload-local-artifacts: + # Let the initial task tell us to not run (currently very blunt) + needs: plan + if: ${{ fromJson(needs.plan.outputs.val).releases != null && (needs.plan.outputs.publishing == 'true' || fromJson(needs.plan.outputs.val).ci.github.pr_run_mode == 'upload') }} + strategy: + fail-fast: false + # Target platforms/runners are computed by cargo-dist in create-release. + # Each member of the matrix has the following arguments: + # + # - runner: the github runner + # - dist-args: cli flags to pass to cargo dist + # - install-dist: expression to run to install cargo-dist on the runner + # + # Typically there will be: + # - 1 "global" task that builds universal installers + # - N "local" tasks that build each platform's binaries and platform-specific installers + matrix: ${{ fromJson(needs.plan.outputs.val).ci.github.artifacts_matrix }} + runs-on: ${{ matrix.runner }} + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + BUILD_MANIFEST_NAME: target/distrib/${{ join(matrix.targets, '-') }}-dist-manifest.json + steps: + - uses: actions/checkout@v4 + with: + submodules: recursive + - uses: swatinem/rust-cache@v2 + - name: Install cargo-dist + run: ${{ matrix.install_dist }} + - name: Install dependencies + run: | + ${{ matrix.packages_install }} + - name: Build artifacts + run: | + # Actually do builds and make zips and whatnot + cargo dist build ${{ needs.plan.outputs.tag-flag }} --print=linkage --output-format=json ${{ matrix.dist_args }} > dist-manifest.json + echo "cargo dist ran successfully" + - id: cargo-dist + name: Post-build + # We force bash here just because github makes it really hard to get values up + # to "real" actions without writing to env-vars, and writing to env-vars has + # inconsistent syntax between shell and powershell. + shell: bash + run: | + # Parse out what we just built and upload it to the Github Release™ + echo "paths<> "$GITHUB_OUTPUT" + jq --raw-output ".artifacts[]?.path | select( . != null )" dist-manifest.json >> "$GITHUB_OUTPUT" + echo "EOF" >> "$GITHUB_OUTPUT" + + cp dist-manifest.json "$BUILD_MANIFEST_NAME" + - name: "Upload artifacts" + uses: actions/upload-artifact@v3 + with: + name: artifacts + path: | + ${{ steps.cargo-dist.outputs.paths }} + ${{ env.BUILD_MANIFEST_NAME }} + + should-publish: + needs: + - plan + - upload-local-artifacts + if: ${{ needs.plan.outputs.publishing == 'true' }} + runs-on: ubuntu-latest + steps: + - name: print tag + run: echo "ok we're publishing!" + + # Create a Github Release with all the results once everything is done + publish-release: + needs: [plan, should-publish] + runs-on: ubuntu-latest + env: + GH_TOKEN: ${{ secrets.GITHUB_TOKEN }} + steps: + - uses: actions/checkout@v4 + with: + submodules: recursive + - name: "Download artifacts" + uses: actions/download-artifact@v3 + with: + name: artifacts + path: artifacts + - name: Cleanup + run: | + # Remove the granular manifests + rm artifacts/*-dist-manifest.json + - name: Create Release + uses: ncipollo/release-action@v1 + with: + tag: ${{ needs.plan.outputs.tag }} + name: ${{ fromJson(needs.plan.outputs.val).announcement_title }} + body: ${{ fromJson(needs.plan.outputs.val).announcement_github_body }} + prerelease: ${{ fromJson(needs.plan.outputs.val).announcement_is_prerelease }} + artifacts: "artifacts/*" diff --git a/Cargo.toml b/Cargo.toml index d3b2c03..bb196bb 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -3,6 +3,29 @@ name = "ortty" version = "0.1.0" edition = "2021" +# Config for 'cargo dist' +[workspace.metadata.dist] +# include = ["RELEASE_NOTES.md"] +# The preferred cargo-dist version to use in CI (Cargo.toml SemVer syntax) +cargo-dist-version = "0.4.2" +# CI backends to support +ci = ["github"] +# The installers to generate for each app +installers = [] +# Target platforms to build apps for (Rust target-triple syntax) +targets = [ + "x86_64-unknown-linux-gnu", + "aarch64-apple-darwin", + "x86_64-apple-darwin", + "x86_64-pc-windows-msvc", +] +# Publish jobs to run in CI +pr-run-mode = "plan" + +# The profile that 'cargo dist' will build with +[profile.dist] +inherits = "release" +lto = "thin" # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html [dependencies] diff --git a/TODO b/TODO deleted file mode 100644 index e4a8d47..0000000 --- a/TODO +++ /dev/null @@ -1,4 +0,0 @@ -[x] Remove --input option for scan, only allow transaction level scanning -[x] Allow scanning multiple inscriptions per witness -[x] Add transaction scanning tests -[ ] Attempt to support recursive content extraction for recursive inscriptions diff --git a/src/args.rs b/src/args.rs index 431e4fd..5cda617 100644 --- a/src/args.rs +++ b/src/args.rs @@ -1,8 +1,9 @@ -use std::path::PathBuf; +use std::{io::stdout, path::PathBuf}; use anyhow::{anyhow, bail}; use bitcoin::{BlockHash, Txid}; use bitcoincore_rpc::Auth; +use crossterm::tty::IsTty; use directories::BaseDirs; use crate::{filter::Filter, inscription::InscriptionId}; @@ -111,6 +112,19 @@ impl Args { _ => None, } } + + pub fn raw(&self) -> bool { + // If it's not a TTY, then never print colored text + if !stdout().is_tty() { + return true; + } + + match &self.command { + Commands::Scan { raw, .. } => *raw, + Commands::Inscription { raw, .. } => *raw, + _ => false, + } + } } #[derive(clap::Subcommand, Debug)] @@ -144,13 +158,23 @@ pub enum Commands { /// Print inscription ID along with the output #[arg(long)] inscription_id: bool, + + /// Prints JSON as unformatted plain text + #[arg(long)] + raw: bool, }, /// Explore the blockchain interactively Explore, /// View a single inscription by inscription id. Requires node with txindex=1 - Inscription { inscription_id: InscriptionId }, + Inscription { + inscription_id: InscriptionId, + + /// Prints JSON as unformatted plain text + #[arg(long)] + raw: bool, + }, } pub enum ScanMode { diff --git a/src/explore.rs b/src/explore.rs index 04a86d6..44652be 100644 --- a/src/explore.rs +++ b/src/explore.rs @@ -276,7 +276,7 @@ fn print_inscription(state: &mut State, inscription: Arc) -> anyhow } if state.extra_opts.render { - inscription.print()?; + inscription.print(false)?; } println!(); diff --git a/src/inscription.rs b/src/inscription.rs index c9b4761..eb1590f 100644 --- a/src/inscription.rs +++ b/src/inscription.rs @@ -125,12 +125,12 @@ impl Inscription { Ok(Vec::new()) } - pub fn print(&self) -> anyhow::Result<()> { + pub fn print(&self, raw_json: bool) -> anyhow::Result<()> { match &self.parsed { ParsedData::Binary => println!("{}", hex::encode(self.data.as_bytes())), ParsedData::Html(text) | ParsedData::Text(text) => println!("{text}"), ParsedData::Image(image) => print_image(image)?, - ParsedData::Json(value) => print_json(value)?, + ParsedData::Json(value) => print_json(value, raw_json)?, } Ok(()) @@ -317,8 +317,12 @@ fn print_image(image: &DynamicImage) -> anyhow::Result<()> { Ok(()) } -fn print_json(value: &serde_json::Value) -> anyhow::Result<()> { - let formatted = to_colored_json(value, ColorMode::On)?; +fn print_json(value: &serde_json::Value, raw_json: bool) -> anyhow::Result<()> { + let formatted = if raw_json { + serde_json::to_string(value)? + } else { + to_colored_json(value, ColorMode::On)? + }; println!("{formatted}"); Ok(()) } @@ -332,9 +336,8 @@ pub(crate) fn fetch_and_print( let inscriptions = Inscription::extract_witness(&tx, inscription_id.1) .map_err(|_| anyhow!("Inscription not found"))?; for inscription in inscriptions { - inscription.print()?; + inscription.print(args.raw())?; } - // inscription.print()?; println!(); Ok(()) diff --git a/src/main.rs b/src/main.rs index c40b38f..eb1f931 100644 --- a/src/main.rs +++ b/src/main.rs @@ -11,16 +11,16 @@ mod inscription; mod scan; fn main() -> anyhow::Result<()> { - dotenv::dotenv()?; + dotenv::dotenv().ok(); let args = Args::parse(); match args.command { args::Commands::Scan { .. } => scan(&args)?, args::Commands::Explore => explore(&args)?, - args::Commands::Inscription { ref inscription_id } => { - inscription::fetch_and_print(&args, inscription_id)? - } + args::Commands::Inscription { + ref inscription_id, .. + } => inscription::fetch_and_print(&args, inscription_id)?, } Ok(()) } @@ -45,7 +45,7 @@ fn scan(args: &Args) -> Result<(), anyhow::Error> { if args.inscription_id().unwrap_or_default() { println!("{}:", inscription.inscription_id().yellow()); } - inscription.print()?; + inscription.print(args.raw())?; println!(); } }