gorails 0.1.2 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ceb227d76224d717af596ca69a9b7f670823bd20ae69e2225e21f4cccd4d349b
-  data.tar.gz: a836f4816f8c0d4b5db9e6dcb7c53005cd53f107f945d7efe611282f1e4a5137
+  metadata.gz: e64a68f47a33d15b16065e2882e19ef2fdf815e484bf5674900b6d214193bd50
+  data.tar.gz: ad7d91c0bdb7a3e9a0c41a148e4ab5658a7ad12478b5294c5ffb3de853695abb
 SHA512:
-  metadata.gz: '0541289f21a733a8af0168d9360fe50e5bd3c7a5d3a68261e2b293b2ac10e60f600dd04d6cb8167babe3908275abae1d6821da37dbd242d95e43ce6eced8b62d'
-  data.tar.gz: 659d2cb41d4fca9c4ff76dc4e10f72429547cce50a256af8832f716fae3fcb8e4a6d5a6ac11ff04faa4eb16640ea30c70bebb41b65bba549ad8e525d2f8186d0
+  metadata.gz: e11a575cd81bfaaadd2ae294dc2b03a9382f70cada35820da6abeabda074cbd2ad93c58b896bf3b2073524ebfa07c2eb63d94ce8f5d5d4e9a341637be0c04eb1
+  data.tar.gz: d4c107348f4ed57cae042618a3ff2483129c0cadf5aed553acaed1affc78d161c3dacb1ba7b29904024944da50350c00c9a3f8613df9485f89c077430a05d886

data/CHANGELOG.md

@@ -1,5 +1,22 @@
 ## [Unreleased]
 
-## [0.1.0] - 2021-12-16
+## [0.1.4] - 2022-03-13
+
+- Add `version` command
+
+## [0.1.3] - 2022-03-13
+
+- Vendor cli-kit and cli-ui for speed
+  This also skips loading bundler/setup which looks for a Gemfile
+
+## [0.1.2] - 2022-03-13
+
+- Add ability to view and apply individual Railsbytes
+
+## [0.1.1] - 2022-03-13
 
 - Initial release
+
+## [0.1.0] - 2021-12-16
+
+- Empty release

data/Gemfile.lock

@@ -1,9 +1,7 @@
 PATH
   remote: .
   specs:
-    gorails (0.1.2)
-      cli-kit (~> 4.0.0)
-      cli-ui (~> 1.5.1)
+    gorails (0.1.5)
 
 GEM
   remote: https://rubygems.org/
@@ -11,9 +9,6 @@ GEM
     ansi (1.5.0)
     ast (2.4.2)
     builder (3.2.4)
-    cli-kit (4.0.0)
-      cli-ui (>= 1.1.4)
-    cli-ui (1.5.1)
     metaclass (0.0.4)
     minitest (5.15.0)
     minitest-reporters (1.5.0)

data/bin/update-deps

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path("../../vendor/deps/cli-ui/lib", __FILE__))
+require 'open3'
+require 'fileutils'
+
+def fmt(tag, msg)
+  # Not really CLI::UI.fmt compatible: no nesting support, for example.
+  # While we could pull in CLI::UI here, it makes it more difficult to
+  # bootstrap a new project and to fix a broken vendor.
+  fmt_msg = msg
+    .gsub(/{{yellow:(.*?)}}/,     "\x1b[33m\\1\x1b[31m")
+    .gsub(/{{green:(.*?)}}/,      "\x1b[32m\\1\x1b[31m")
+    .gsub(/{{blue:(.*?)}}/,       "\x1b[34m\\1\x1b[31m")
+    .gsub(/{{bold_blue:(.*?)}}/,  "\x1b[1;34m\\1\x1b[0;31m")
+    .gsub(/{{bold_green:(.*?)}}/, "\x1b[1;32m\\1\x1b[0;31m")
+  "\x1b[1;31m[#{tag}] \x1b[0;31m#{fmt_msg}\x1b[0m"
+end
+
+def bail(msg)
+  STDERR.puts(fmt("ERROR", msg))
+  exit 1
+end
+
+def warn(msg)
+  STDERR.puts(fmt("WARNING", msg))
+end
+
+def source_path
+  File.expand_path(ENV.fetch('SOURCE_ROOT', File.expand_path('../../..', __FILE__)))
+end
+
+deps = %w(cli-ui cli-kit)
+
+deps.each do |dep|
+  path = File.expand_path(dep, source_path)
+
+  unless Dir.exist?(path)
+    bail(
+      "dependency is not checked out: {{yellow:#{dep}}}.\n" \
+      "  This repo {{bold_blue:(github.com/shopify/#{dep})}} must be cloned at {{bold_blue:#{path}}} for this script to succeed.\n" \
+      "  Currently, SOURCE_ROOT is set to {{bold_blue:#{source_path}}}.\n" \
+      "  Alternatively, you can set {{bold_blue:SOURCE_ROOT}} to a directory containing {{yellow:#{dep}}}.\n" \
+      "  {{bold_blue:SOURCE_ROOT}} defaults to {{bold_blue:../}}."
+    )
+  end
+
+  head_sha = nil
+  dirty = false
+
+  Dir.chdir(path) do
+    _, _, stat = Open3.capture3('git fetch origin main')
+    bail("couldn't git fetch in dependency: {{yellow:#{dep}}}") unless stat.success?
+
+    head_sha, stat = Open3.capture2('git rev-parse HEAD')
+    bail("couldn't determine HEAD: {{yellow:#{dep}}}") unless stat.success?
+    head_sha.chomp!
+
+    fetch_head_sha, stat = Open3.capture2('git rev-parse FETCH_HEAD')
+    bail("couldn't determine FETCH_HEAD: {{yellow:#{dep}}}") unless stat.success?
+    fetch_head_sha.chomp!
+
+    git_status, stat = Open3.capture2('git status --porcelain')
+    bail("couldn't determine git status: {{yellow:#{dep}}}") unless stat.success?
+
+    if head_sha != fetch_head_sha
+      warn(
+        "Copying files from {{yellow:#{path}}} to satisfy dependency {{yellow:#{dep}}}.\n" \
+        "  However, the repo at {{yellow:#{path}}} isn't up to date.\n" \
+        "  The checked-out revision is {{yellow:#{head_sha[0..8]}}}, and "\
+        "{{yellow:origin/master}} is {{yellow:#{fetch_head_sha[0..8]}}}.\n" \
+        "  Unless you know what you're doing, you should {{green:cd}} to that repo and {{green:git pull}}, then run this again."
+      )
+    end
+
+    unless git_status.chomp.empty?
+      dirty = true
+      warn("importing uncommitted changes from dependency: {{yellow:#{dep}}}")
+    end
+  end
+
+  depdir = File.expand_path("../../vendor/deps/#{dep}", __FILE__)
+  FileUtils.rm_rf(depdir)
+  FileUtils.mkdir_p(depdir)
+  dstlib = File.expand_path('lib', depdir)
+  srclib = File.expand_path('lib', path)
+
+  FileUtils.cp_r(srclib, dstlib)
+
+  rev = head_sha
+  rev << " (dirty)" if dirty
+  rev << "\n"
+
+  File.write("#{depdir}/REVISION", rev)
+end

data/exe/gorails

@@ -7,9 +7,10 @@ unshift_path = ->(path) {
   p = File.expand_path("../../#{path}", __FILE__)
   $LOAD_PATH.unshift(p) unless $LOAD_PATH.include?(p)
 }
+unshift_path.call("vendor/deps/cli-ui/lib")
+unshift_path.call("vendor/deps/cli-kit/lib")
 unshift_path.call("lib")
 
-require "bundler/setup"
 require "gorails"
 
 exit(Gorails::ErrorHandler.call do

data/gorails.gemspec

@@ -29,8 +29,6 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "cli-kit", "~> 4.0.0"
-  spec.add_dependency "cli-ui", "~> 1.5.1"
   spec.add_development_dependency "standard"
 
   # For more information and examples about making a new gem, checkout our

data/lib/gorails/commands/railsbytes.rb

@@ -1,6 +1,7 @@
 require "gorails"
-require "net/http"
+require "bundler"
 require "json"
+require "net/http"
 
 module Gorails
   module Commands
@@ -44,21 +45,20 @@ module Gorails
           puts
 
           CLI::UI::Prompt.ask("What would you like to do?") do |handler|
-            handler.option("View source") do |selection|
-              puts
-              puts byte["script"]
-            end
-
             handler.option("Apply Railsbyte") do |selection|
               puts
               puts "Running Railsbyte..."
+              puts
+
+              system "rails app:template LOCATION=\"https://railsbytes.com/script/#{id}\""
+            end
 
-              Bundler.with_original_env do
-                system "rails app:template LOCATION=\"https://railsbytes.com/script/#{id}\""
-              end
+            handler.option("View source") do |selection|
+              puts
+              puts byte["script"]
             end
 
-            handler.option("exit") { |selection| exit 0 }
+            handler.option("Exit") { |selection| exit 0 }
           end
         end
       end

data/lib/gorails/commands/version.rb

@@ -0,0 +1,15 @@
+require "gorails"
+
+module Gorails
+  module Commands
+    class Version < Gorails::Command
+      def call(_args, _name)
+        puts Gorails::VERSION
+      end
+
+      def self.help
+        "Prints the version.\nUsage: {{command:#{Gorails::TOOL_NAME} version}}"
+      end
+    end
+  end
+end

data/lib/gorails/commands.rb

@@ -2,10 +2,7 @@ require "gorails"
 
 module Gorails
   module Commands
-    Registry = CLI::Kit::CommandRegistry.new(
-      default: "help",
-      contextual_resolver: nil
-    )
+    Registry = CLI::Kit::CommandRegistry.new(default: "help")
 
     def self.register(const, cmd, path)
       autoload(const, path)
@@ -16,7 +13,7 @@ module Gorails
     register :Jobs, "jobs", "gorails/commands/jobs"
     register :Jumpstart, "jumpstart", "gorails/commands/jumpstart"
     register :Railsbytes, "railsbytes", "gorails/commands/railsbytes"
-    # register :Example, 'example', 'gorails/commands/example'
+    register :Version, "version", "gorails/commands/version"
     register :Help, "help", "gorails/commands/help"
   end
 end

data/lib/gorails/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Gorails
-  VERSION = "0.1.2"
+  VERSION = "0.1.5"
 end

data/lib/gorails.rb

@@ -9,30 +9,21 @@ CLI::UI::StdoutRouter.enable
 module Gorails
   class Error < StandardError; end
 
-  extend CLI::Kit::Autocall
-
   TOOL_NAME = "gorails"
   ROOT = File.expand_path("../..", __FILE__)
-  LOG_FILE = "/tmp/myproject.log"
+  LOG_FILE = "/tmp/gorails.log"
 
   autoload(:EntryPoint, "gorails/entry_point")
   autoload(:Commands, "gorails/commands")
 
-  autocall(:Config) { CLI::Kit::Config.new(tool_name: TOOL_NAME) }
-  autocall(:Command) { CLI::Kit::BaseCommand }
-
-  autocall(:Executor) { CLI::Kit::Executor.new(log_file: LOG_FILE) }
-  autocall(:Resolver) do
-    CLI::Kit::Resolver.new(
-      tool_name: TOOL_NAME,
-      command_registry: Gorails::Commands::Registry
-    )
-  end
-
-  autocall(:ErrorHandler) do
-    CLI::Kit::ErrorHandler.new(
-      log_file: LOG_FILE,
-      exception_reporter: nil
-    )
-  end
+  Config = CLI::Kit::Config.new(tool_name: TOOL_NAME)
+  Command = CLI::Kit::BaseCommand
+
+  Executor = CLI::Kit::Executor.new(log_file: LOG_FILE)
+  Resolver = CLI::Kit::Resolver.new(
+    tool_name: TOOL_NAME,
+    command_registry: Gorails::Commands::Registry
+  )
+
+  ErrorHandler = CLI::Kit::ErrorHandler.new(log_file: LOG_FILE)
 end

data/vendor/deps/cli-kit/REVISION

@@ -0,0 +1 @@
+635eab627526f34c7ce15d2c894633246493b1a4

data/vendor/deps/cli-kit/lib/cli/kit/args/definition.rb

@@ -0,0 +1,301 @@
+# typed: true
+require 'cli/kit'
+
+module CLI
+  module Kit
+    module Args
+      class Definition
+        extend T::Sig
+
+        Error = Class.new(Args::Error)
+        ConflictingFlag = Class.new(Error)
+        InvalidFlag = Class.new(Error)
+        InvalidLookup = Class.new(Error)
+        InvalidPosition = Class.new(Error)
+
+        sig { returns(T::Array[Flag]) }
+        attr_reader :flags
+
+        sig { returns(T::Array[Option]) }
+        attr_reader :options
+
+        sig { returns(T::Array[Position]) }
+        attr_reader :positions
+
+        sig { params(name: Symbol, short: T.nilable(String), long: T.nilable(String), desc: T.nilable(String)).void }
+        def add_flag(name, short: nil, long: nil, desc: nil)
+          short, long = strip_prefixes_and_validate(short, long)
+          flag = Flag.new(name: name, short: short, long: long, desc: desc)
+          add_resolution(flag)
+          @flags << flag
+        end
+
+        sig do
+          params(
+            name: Symbol, short: T.nilable(String), long: T.nilable(String),
+            desc: T.nilable(String), default: T.any(NilClass, String, T.proc.returns(String)),
+            required: T::Boolean, multi: T::Boolean,
+          ).void
+        end
+        def add_option(name, short: nil, long: nil, desc: nil, default: nil, required: false, multi: false)
+          short, long = strip_prefixes_and_validate(short, long)
+          option = Option.new(
+            name: name, short: short, long: long, desc: desc, default: default,
+            required: required, multi: multi,
+          )
+          add_resolution(option)
+          @options << option
+        end
+
+        sig { params(name: Symbol, required: T::Boolean, multiple: T::Boolean, desc: T.nilable(String)).void }
+        def add_position(name, required:, multiple:, desc: nil)
+          index = @positions.size
+          position = Position.new(name: name, desc: desc, required: required, multiple: multiple, index: index)
+          validate_order(position)
+          add_name_resolution(position)
+          @positions << position
+        end
+
+        sig { void }
+        def initialize
+          @flags = []
+          @options = []
+          @by_short = {}
+          @by_long = {}
+          @by_name = {}
+          @positions = []
+        end
+
+        class Flag
+          extend T::Sig
+
+          sig { returns(Symbol) }
+          attr_reader :name
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :short
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :long
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :desc
+
+          sig { returns(String) }
+          def as_written_by_user
+            long ? "--#{long}" : "-#{short}"
+          end
+
+          sig { params(name: Symbol, short: T.nilable(String), long: T.nilable(String), desc: T.nilable(String)).void }
+          def initialize(name:, short: nil, long: nil, desc: nil)
+            if long&.start_with?('-') || short&.start_with?('-')
+              raise(ArgumentError, 'invalid - prefix')
+            end
+
+            @name = name
+            @short = short
+            @long = long
+            @desc = desc
+          end
+        end
+
+        class Position
+          extend T::Sig
+
+          sig { returns(Symbol) }
+          attr_reader :name
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :desc
+
+          sig { returns(Integer) }
+          attr_reader :index
+
+          sig do
+            params(name: Symbol, desc: T.nilable(String), required: T::Boolean, multiple: T::Boolean, index: Integer)
+              .void
+          end
+          def initialize(name:, desc:, required:, multiple:, index:)
+            raise(ArgumentError, 'Cannot be required and multiple') if required && multiple
+
+            @name = name
+            @desc = desc
+            @required = required
+            @multiple = multiple
+            @index = index
+          end
+
+          sig { returns(T::Boolean) }
+          def required?
+            @required
+          end
+
+          sig { returns(T::Boolean) }
+          def multiple?
+            @multiple
+          end
+
+          sig { returns(T::Boolean) }
+          def optional?
+            !required?
+          end
+        end
+
+        class Option < Flag
+          extend T::Sig
+
+          sig { returns(T.nilable(String)) }
+          def default
+            if @default.is_a?(Proc)
+              @default.call
+            else
+              @default
+            end
+          end
+
+          sig { returns(T::Boolean) }
+          def dynamic_default?
+            @default.is_a?(Proc)
+          end
+
+          sig { returns(T::Boolean) }
+          attr_reader :required
+
+          sig { returns(T::Boolean) }
+          attr_reader :multi
+
+          sig do
+            params(
+              name: Symbol, short: T.nilable(String), long: T.nilable(String),
+              desc: T.nilable(String), default: T.any(NilClass, String, T.proc.returns(String)),
+              required: T::Boolean, multi: T::Boolean,
+            ).void
+          end
+          def initialize(name:, short: nil, long: nil, desc: nil, default: nil, required: false, multi: false)
+            if multi && (default || required)
+              raise(ArgumentError, 'multi-valued options cannot have a default or required value')
+            end
+
+            super(name: name, short: short, long: long, desc: desc)
+            @default = default
+            @required = required
+            @multi = multi
+          end
+        end
+
+        sig { params(name: Symbol).returns(T.nilable(Flag)) }
+        def lookup_flag(name)
+          flagopt = @by_name[name]
+          if flagopt.class == Flag
+            flagopt
+          end
+        end
+
+        sig { params(name: Symbol).returns(T.nilable(Option)) }
+        def lookup_option(name)
+          flagopt = @by_name[name]
+          if flagopt.class == Option
+            flagopt
+          end
+        end
+
+        sig { params(name: String).returns(T.any(Flag, Option, NilClass)) }
+        def lookup_short(name)
+          raise(InvalidLookup, "invalid '-' prefix") if name.start_with?('-')
+
+          @by_short[name]
+        end
+
+        sig { params(name: String).returns(T.any(Flag, Option, NilClass)) }
+        def lookup_long(name)
+          raise(InvalidLookup, "invalid '-' prefix") if name.start_with?('-')
+
+          @by_long[name]
+        end
+
+        sig { params(name: Symbol).returns(T.nilable(Position)) }
+        def lookup_position(name)
+          position = @by_name[name]
+          if position.class == Position
+            position
+          end
+        end
+
+        private
+
+        sig { params(position: Position).void }
+        def validate_order(position)
+          if @positions.last&.multiple?
+            raise(InvalidPosition, 'Cannot have any more positional arguments after multiple')
+          elsif @positions.last&.optional? && !position.optional?
+            raise(InvalidPosition, 'Cannot have any more required positional arguments after optional ones')
+          end
+        end
+
+        sig { params(short: String).returns(String) }
+        def strip_short_prefix(short)
+          unless short.match?(/^-[^-]/)
+            raise(InvalidFlag, "Short flag '#{short}' does not start with '-'")
+          end
+          if short.size != 2
+            raise(InvalidFlag, 'Short flag must be a single character')
+          end
+
+          short.sub(/^-/, '')
+        end
+
+        sig { params(long: String).returns(String) }
+        def strip_long_prefix(long)
+          unless long.match?(/^--[^-]/)
+            raise(InvalidFlag, "Long flag '#{long}' does not start with '--'")
+          end
+
+          long.sub(/^--/, '')
+        end
+
+        sig do
+          params(short: T.nilable(String), long: T.nilable(String))
+            .returns([T.nilable(String), T.nilable(String)])
+        end
+        def strip_prefixes_and_validate(short, long)
+          if short.nil? && long.nil?
+            raise(Error, 'One or more of short and long must be specified')
+          end
+
+          short = strip_short_prefix(short) if short
+          long = strip_long_prefix(long) if long
+
+          [short, long]
+        end
+
+        sig { params(flagopt: Flag).void }
+        def add_resolution(flagopt)
+          if flagopt.short
+            if (existing = @by_short[flagopt.short])
+              raise(ConflictingFlag, "Short flag '#{flagopt.short}' already defined by #{existing.name}")
+            end
+
+            @by_short[flagopt.short] = flagopt
+          end
+          if flagopt.long
+            if (existing = @by_long[flagopt.long])
+              raise(ConflictingFlag, "Long flag '#{flagopt.long}' already defined by #{existing.name}")
+            end
+
+            @by_long[flagopt.long] = flagopt
+          end
+          add_name_resolution(flagopt)
+        end
+
+        sig { params(arg: T.any(Flag, Position)).void }
+        def add_name_resolution(arg)
+          if (existing = @by_name[arg.name])
+            raise(ConflictingFlag, "Flag '#{arg.name}' already defined by #{existing.name}")
+          end
+
+          @by_name[arg.name] = arg
+        end
+      end
+    end
+  end
+end