gurl 1.0.0.pre.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1a768efa1cf346a124d593c8fd1351fd142187ac6aff5b7dff9d9ca8c3df6718
+  data.tar.gz: 99be94f373b5a07681cabfcdd5a160258407f6584bcdf2033f712b847728582e
+SHA512:
+  metadata.gz: d38e2df77a70083e914dbb1e34b9a9b4a0fa03fac84808668851ba44d395411df25c09e7671d9c05e871256ebcae17300d3d945a2842498e51a7dd83f028dd1a
+  data.tar.gz: df21e6ef1db8de5d126a938b683b501a70ee6bb73938b6bc2b056e7211b979b9edfa06657446df6630996b7d07a42a6c508c832f8ac358e7cf922d41ac4e5df9

data/bin/gurl

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "#{__dir__}/../lib/gurl.rb"

data/lib/core/builder/base.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+GET = 'GET'
+POST = 'POST'
+PUT = 'PUT'
+PATCH = 'PATCH'
+DELETE = 'DELETE'
+
+module Builder
+  class Base
+    include BaseSupport::FlagConcern
+
+    def initialize
+      @url = ''
+      @method = GET
+      @headers = []
+      @data = nil
+      @params = []
+
+      self.class.ancestors.reverse_each do |ancestor|
+        next unless ancestor.instance_methods(false).include?(:start)
+
+        ancestor.instance_method(:start).bind_call(self)
+      end
+    end
+
+    def build(**options)
+      execute
+      one_line = options[:one_line]
+
+      parts = ['curl']
+      parts << _build_url
+      parts << "-X #{@method}" if @method != GET
+      @headers.each do |k, v|
+        parts << "-H '#{k}: #{v}'"
+      end
+      parts << data_to_curl_argument(one_line) if @data
+      parts.join(' ')
+    end
+
+    def execute; end
+
+    private
+
+    def data_to_curl_argument(one_line)
+      return "-d @- << EOF\n #{@data}\nEOF" unless one_line || !@data.include?("\n")
+
+      "-d '#{@data.split("\n").map(&:strip).join(' ')}'"
+    end
+
+    def url(url_argument)
+      @url = url_argument
+    end
+
+    def method(method_argument)
+      @method = method_argument
+    end
+
+    def header(key, value)
+      @headers << [key, value]
+    end
+
+    def query_param(key, value)
+      @params << [key, value]
+    end
+
+    def body(body_argument)
+      @data = body_argument
+    end
+
+    def json_body(json_body_argument)
+      require 'json'
+      @data = JSON.pretty_generate(json_body_argument)
+    end
+
+    def _build_url
+      return @url unless @params.any?
+
+      q = @params.map { |k, v| "#{k}=#{v}" }.join('&')
+      "#{@url}?#{q}"
+    end
+  end
+end

data/lib/core/builder/base_support/flag_concern.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Builder
+  module BaseSupport
+    module FlagConcern
+      def process_flags(opts)
+        _flags.each do |names, block|
+          opts.on(*names, &block)
+        end
+      end
+
+      private
+
+      def flag(name, *list_options, **options)
+        return _flag_variables[name] if _flag_variables.key?(name)
+
+        flag_args = _build_flag_arguments(name, *list_options, **options)
+
+        _add_flag(flag_args) { |value| _flag_variables[name] = value }
+        nil
+      end
+
+      def _build_flag_arguments(name, *list_options, label: nil)
+        bool = list_options.include?(:bool)
+        shorten = list_options.include?(:shorten)
+        one_char_only = name.length == 1
+
+        flag_args = []
+        flag_args << _long_flag_for(name, bool) unless one_char_only
+        flag_args << _short_flag_for(name, bool) if shorten || one_char_only
+        flag_args << (label || "Sets #{name}")
+        flag_args
+      end
+
+      def _short_flag_for(name, bool)
+        "-#{name[0]}#{'ARG' unless bool}"
+      end
+
+      def _long_flag_for(name, bool)
+        "--#{name}#{'=ARG' unless bool}"
+      end
+
+      def _add_flag(flag_args, &block)
+        _flags[flag_args] = block
+      end
+
+      def _flags
+        @_flags ||= {}
+      end
+
+      def _flag_variables
+        @_flag_variables ||= {}
+      end
+    end
+  end
+end

data/lib/core/main.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+class Main
+  class << self
+    def execute
+      MainPipeline::BuilderRunner
+        .call(builder, main_options(builder))
+        .error { exit(_1[:exit_status]) }
+    end
+
+    private
+
+    def path
+      @path ||=
+        MainPipeline::PathFetcher
+        .call(user_builders_dir)
+        .error { exit_without_builder(1) }
+        .ok
+    end
+
+    def user_builders_dir
+      @user_builders_dir ||= Pathname.new(Dir.pwd)
+    end
+
+    def builder
+      @builder ||=
+        MainPipeline::BuilderFetcher
+        .call(path, user_builders_dir)
+        .ok
+    end
+
+    def main_options(target_builder = nil)
+      MainPipeline::ParseOptions
+        .call(target_builder)
+        .error { exit(1) }
+        .ok
+    end
+
+    def exit_without_builder(status = 0)
+      main_options
+      exit(status)
+    end
+  end
+end

data/lib/core/main_pipeline/builder_fetcher.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module MainPipeline
+  class BuilderFetcher < Service::Base
+    def call(path, user_builders_dir)
+      cls = path
+            .relative_path_from(user_builders_dir)
+            .each_filename
+            .to_a
+            .tap { |parts| parts[-1] = parts[-1].delete_suffix('.rb') }
+            .map { |p| p.split('_').map!(&:capitalize).join }
+            .inject(Object) { |acc, name| acc.const_get(name) }
+      ok(cls.new)
+    end
+  end
+end

data/lib/core/main_pipeline/builder_runner.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'English'
+module MainPipeline
+  class BuilderRunner < Service::Base
+    def call(builder, main_options)
+      curl_command = builder.build(**main_options)
+      verbose_output(curl_command) if main_options[:verbose]
+
+      run(curl_command)
+      ok
+    end
+
+    private
+
+    def run(curl_command)
+      system(curl_command)
+      return error({ exit_status: $CHILD_STATUS.exitstatus }) unless $CHILD_STATUS.success?
+
+      puts
+    end
+
+    def verbose_output(curl_command)
+      puts "\e[32mRunning:\e[0m"
+      puts curl_command
+      puts "\e[34mOutput:\e[0m"
+    end
+  end
+end

data/lib/core/main_pipeline/parse_options.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module MainPipeline
+  class ParseOptions < Service::Base
+    def call(builder)
+      # NOTE: the line below is necessary to load flags in builder#execute
+      builder&.execute
+
+      main_options = {}
+      option_parser = build_option_parser(builder, main_options)
+      return unless option_parser
+
+      option_parser.parse!
+
+      ok(main_options)
+    rescue OptionParser::InvalidOption => e
+      puts e.message
+      error
+    end
+
+    private
+
+    def build_option_parser(builder, main_options)
+      OptionParser.new do |opts|
+        opts.banner = 'Usage: gurl FILE [options]'
+        opts.separator ''
+        opts.separator 'Global options:'
+        opts.on('-v', '--verbose', 'Enable verbose output') { main_options[:verbose] = true }
+        opts.on('--one-line', 'Generate cURL command as a single line') { main_options[:one_line] = true }
+        add_help_flag(opts)
+        add_builder_flags(opts, builder) if builder
+      end
+    end
+
+    def add_builder_flags(opts, builder)
+      opts.separator ''
+      opts.separator 'Builder-specific flags:'
+      builder.process_flags(opts)
+    end
+
+    def add_help_flag(opts)
+      opts.on('-h', '--help', 'Show this help message') do
+        puts opts
+        exit
+      end
+    end
+  end
+end

data/lib/core/main_pipeline/path_fetcher.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module MainPipeline
+  class PathFetcher < Service::Base
+    def call(user_builders_dir)
+      return if argv_empty?
+
+      arg_path = ARGV[0]
+      arg_path += '.rb' unless arg_path.end_with?('.rb')
+
+      path = user_builders_dir + arg_path
+      return unless path_exists?(path)
+
+      ok(path.realpath)
+    end
+
+    def path_exists?(path)
+      return true if path.exist?
+
+      puts "File does not exist: #{path}"
+      error
+      false
+    end
+
+    def argv_empty?
+      return false if ARGV.any?
+
+      puts 'Path not specified'
+      error
+      true
+    end
+  end
+end

data/lib/core/service/base.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Service
+  class Base
+    def self.call(*args)
+      instance = new
+      instance.call(*args)
+      instance.response
+    end
+
+    attr_reader :response
+
+    private
+
+    def error(error_data = nil)
+      @response = Response.new(:error, error_data)
+    end
+
+    def ok(success_data = nil)
+      @response = Response.new(:ok, success_data)
+    end
+  end
+end

data/lib/core/service/response.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Service
+  class Response
+    attr_reader :data
+
+    def initialize(status, data)
+      @status = status
+      @data = data
+    end
+
+    def ok
+      yield(data) if ok? && block_given?
+      data
+    end
+
+    def error
+      yield(data) if error? && block_given?
+      self
+    end
+
+    def ok?
+      @status == :ok
+    end
+
+    def error?
+      @status == :error
+    end
+  end
+end

data/lib/gurl.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'pathname'
+require 'open3'
+require 'optparse'
+require 'bundler/setup'
+require 'zeitwerk'
+Bundler.require(:default)
+
+loader = Zeitwerk::Loader.new
+loader.push_dir(Dir.pwd)
+loader.push_dir(File.join(__dir__, 'core'))
+loader.setup
+
+Main.execute

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: gurl
+version: !ruby/object:Gem::Version
+  version: 1.0.0.pre.alpha
+platform: ruby
+authors:
+- Hikari Luz
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2026-02-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+description: Utility tool for building and executing cURL commands using Ruby.
+email: hikaridesuyoo@gmail.com
+executables:
+- gurl
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/gurl
+- lib/core/builder/base.rb
+- lib/core/builder/base_support/flag_concern.rb
+- lib/core/main.rb
+- lib/core/main_pipeline/builder_fetcher.rb
+- lib/core/main_pipeline/builder_runner.rb
+- lib/core/main_pipeline/parse_options.rb
+- lib/core/main_pipeline/path_fetcher.rb
+- lib/core/service/base.rb
+- lib/core/service/response.rb
+- lib/gurl.rb
+homepage:
+licenses:
+- GPL-3.0
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: Build cURL commands with Ruby
+test_files: []