nugem 0.8.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8bd31585552b513ce66b36f8902a1a06bcc9e508ad45d98cd6ad327b593bc3c5
+  data.tar.gz: bf467fb473d869fbd29d648688822226f6c02cc8b63bb9de9123f2c7e2d83ded
+SHA512:
+  metadata.gz: 5fbe5a7757e4986a7b4992dbe67797a9d1a488e300e0d4611ad39daaddba91b04cc590317555f73747532aece87288e320d98312f272d80e8509c0c03a4176fe
+  data.tar.gz: b8373ad340266e1837890c29d8730f277fdfcc3e3610183a572d5e4593dff7314ecaff214c98be7a9ab7ed4ebc99e382746c9cceae6d67030aac6d6a150d44d5

data/.rubocop.yml

@@ -0,0 +1,91 @@
+require:
+  # - rubocop-jekyll
+  - rubocop-md
+  - rubocop-performance
+  - rubocop-rake
+  - rubocop-rspec
+
+AllCops:
+  Exclude:
+    - binstub/**/*
+    - exe/**/*
+    - generated/**/binstub/*
+    - generated/**/exe/**/*
+    - vendor/**/*
+    - Gemfile*
+    - Rakefile
+    - README.md
+  NewCops: enable
+  TargetRubyVersion: 3.1.3
+
+Gemspec/DeprecatedAttributeAssignment:
+  Enabled: false
+
+Gemspec/RequireMFA:
+  Enabled: false
+
+Layout/ArgumentAlignment:
+  EnforcedStyle: with_fixed_indentation
+
+Layout/HashAlignment:
+  EnforcedColonStyle: table
+  EnforcedHashRocketStyle: table
+
+Layout/LineLength:
+  Max: 150
+
+Layout/MultilineMethodCallIndentation:
+  EnforcedStyle: indented_relative_to_receiver
+
+Metrics/AbcSize:
+  Max: 45
+
+Metrics/BlockLength:
+  Exclude:
+    - nugem.gemspec
+  Max: 30
+
+Metrics/ClassLength:
+  Exclude:
+    - spec/*.rb
+
+Metrics/CyclomaticComplexity:
+  Max: 20
+
+Metrics/MethodLength:
+  Max: 40
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Max: 15
+
+Naming/FileName:
+  Exclude:
+    - Rakefile
+
+Style/Documentation:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Style/StringConcatenation:
+  Mode: conservative
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: comma
+
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: comma
+
+RSpec/FilePath:
+  IgnoreMethods: true
+  SpecSuffixOnly: true
+
+RSpec/ExampleLength:
+  Enabled: false
+
+RSpec/MultipleExpectations:
+  Max: 15

data/CHANGELOG.md

@@ -0,0 +1,12 @@
+## 0.8.0
+  * Updated dependencies and `README`.
+  * Renamed the `gem` subcommand to `plain`.
+  * Renamed the `plugin` subcommand to `rails`.
+  * Added `CHANGELOG`, `.rspec`, `.rubocop` and `.vscode/`.
+  * Added `binstubs/`.
+  * Using `require_relative` where appropriate.
+  * Changed the default for including an executable to `false`.
+  * Added the `--quiet` and `--todos` options, common to the `plain`, `jekyll` and `rails` subcommands.
+
+## 0.7.4
+  * Last release was 7 years prior without a change history.

data/README.md

@@ -0,0 +1,317 @@
+# `Nugem` [![Gem Version](https://badge.fury.io/rb/nugem.svg)](https://badge.fury.io/rb/nugem)
+
+## WORK IN PROGRESS
+
+`Nugem` creates a scaffold project for a new gem in a new git repository.
+After you add your special code to the gem scaffold,
+the project is ready to be released to a public or private gem server.
+
+This gem generates a scaffold with all files you need to start,
+with the following features:
+
+- Generates a README with badges.
+- Automatically creates local and remote git repositories (on GitHub, BitBucket or Geminabox) for your new gem.
+- Remote repositories can be private or public.
+- Can include a [Thor-based executable](https://github.com/rails/thor).
+- Creates a test infrastructure based on `rspec` or `minitest` and `minitest-reporters`.
+- Ready to publicly release to `rubygems.org` or to a private Geminabox gem server.
+- Optionally create the gem as:
+  - A Rails plugin, possibly with a mountable engine.
+  - A Jekyll plugin (tag, block tag, filter, generator, or hooks).
+
+
+## Installation
+
+```shell
+$ gem install nugem
+```
+
+To update the program:
+
+```shell
+$ gem update nugem
+```
+
+
+## Subcommands and Options
+
+`Nugem` has 4 subcommands `plain`, `jekyll`, `help` and `rails`:
+
+### `help` Subcommand
+
+The following lists the available subcommands:
+
+```shell
+$ nugem help
+```
+
+The following provides detailed help for the specified subcommand:
+
+```shell
+$ nugem help [SUBCOMMAND]
+```
+
+
+### Common Options
+
+The `plain`, `jekyll` and `rails` subcommands have common options.
+
+The default option values assume that:
+
+- You do not want an executable for your gem scaffold
+- The gem project will be hosted on a public GitHub git repository
+- The gem will be released to `rubygems.org`
+
+Common options for the `plain`, `jekyll` and `rails` subcommands are:
+
+<dl>
+  <dt><code>--executable</code></dt>
+    <dd>add an executable based on Thor.</dd>
+
+  <dt><code>--host</code></dt>
+    <dd>
+      specifies the git host; possible values are <code>bitbucket</code>, <code>github</code> and <code>geminabox</code>.
+    </dd>
+
+  <dt><code>--private</code></dt>
+    <dd>the remote repository is made private,
+        and on release the gem will be pushed to a private Geminabox server.
+    </dd>
+
+  <dt><code>--quiet</code></dt>
+    <dd>reduces verbosity.</dd>
+
+  <dt><code>--no-todos</code></dt>
+    <dd>do not generate `TODO:` strings in generated code.</dd>
+</dl>
+
+
+### Common Behavior
+
+The `plain`, `jekyll` and `rails` subcommands have common behavior.
+
+Gem scaffolds are created within the `generated/` directory.
+
+If your user name is not already stored in your git global config,
+you will be asked for your GitHub or BitBucket user name.
+You will also be asked to enter your GitHub or BitBucket password when the remote repository is created for you.
+
+After you create the gem, edit the `gemspec` and change the summary and the description.
+Then commit the changes to git and invoke `rake release`,
+and your gem will be published.
+
+
+### `plain` Subcommand
+
+```shell
+$ nugem plain NAME [COMMON_OPTIONS] [--test-framework=minitest|rspec]
+```
+
+`NAME` is the name of the gem to be generated.
+
+The default test framework for the `plain` subcommand is `rspec`,
+but you can specify `minitest` instead like this:
+
+```shell
+$ nugem plain my_gem --test-framework=minitest
+```
+
+
+### `jekyll` Subcommand
+
+The `jekyll` subcommand extends the `plain` subcommand and creates a new Jekyll plugin with the given NAME:
+
+```shell
+$ nugem jekyll NAME [OPTIONS]
+```
+
+`NAME` is the name of the Jekyll plugin gem to be generated.
+
+In addition to the common options, the `jekyll`-specific `OPTIONS` are:
+
+`--block`, `--blockn`, `--filter`, `--hooks`, `--tag`, and `--tagn`.
+
+Each of these options causes `nugem` to prompt the user for additional input.
+
+The test framework for `jekyll` plugins is `rspec`.
+
+All of the above options can be specified more than once,
+except the `--hooks` option.
+For example:
+
+```shell
+$ nugem jekyll test_tags --tag my_tag1 --tag my_tag2
+```
+
+The above creates a Jekyll plugin called `test_tags`,
+which defines Jekyll tags called `my_tag1` and `my_tag2`.
+You might use these tags in an HTML document like this:
+
+```html
+<pre>
+my_tag1 usage: {% my_tag1 %}
+my_tag2 usage: {% my_tag2 %}
+</pre>
+```
+
+For more information, type
+
+```shell
+$ nugem help jekyll
+```
+
+
+### `rails` Subcommand
+
+The `rails` subcommand extends the `plain` subcommand and creates a new Rails plugin with the given NAME:
+
+```shell
+$ nugem rails NAME [OPTIONS]
+```
+
+`NAME` is the name of the Ruby on Rails plugin gem to be generated.
+
+In addition to the common options, `rails` `OPTIONS` are
+`--engine` and `--mountable`.
+
+You can specify if the plugin should be an engine (`--engine`) or a mountable engine (`--mountable`).
+
+Each of these options causes `nugem` to prompt the user for additional input.
+
+The test framework for `rails` gems is `minitest`.
+
+For more information, type
+
+```shell
+$ nugem help rails
+```
+
+
+## Did It Work?
+
+The following shows all files that were committed to the newly created git repository,
+after `nugem jekyll` finished making two tag blocks:
+
+```shell
+$ git ls-tree --name-only --full-tree -r HEAD
+.envrc
+.gitignore
+.rspec
+.rubocop.yml
+.simplecov
+.travis.yml
+.vscode/extensions.json
+.vscode/launch.json
+.vscode/settings.json
+CHANGELOG.md
+Gemfile
+LICENCE.txt
+README.md
+Rakefile
+bin/attach
+bin/console
+bin/rake
+bin/setup
+demo/Gemfile
+demo/_bin/debug
+demo/_config.yml
+demo/_drafts/2022/2022-05-01-test2.html
+demo/_includes/block_tag_template_wrapper
+demo/_layouts/default.html
+demo/_posts/2022/2022-01-02-redact-test.html
+demo/assets/css/style.css
+demo/assets/images/404-error.png
+demo/assets/images/404-error.webp
+demo/assets/images/favicon.png
+demo/assets/images/jekyll.png
+demo/assets/images/jekyll.webp
+demo/assets/js/clipboard.min.js
+demo/assets/js/jquery-3.4.1.min.js
+demo/blog/blogsByDate.html
+demo/blog/index.html
+demo/index.html
+jekyll_test.code-workspace
+jekyll_test.gemspec
+lib/jekyll_test.rb
+lib/jekyll_test/version.rb
+lib/my_block1.rb
+lib/my_block2.rb
+spec/jekyll_test_spec.rb
+spec/spec_helper.rb
+test/jekyll_test_test.rb
+test/test_helper.rb
+```
+
+
+## Visual Studio Code Support
+
+### Nugem Project
+
+#### Plugins
+
+If you have not installed the
+[Snippets](https://marketplace.visualstudio.com/items?itemName=devonray.snippet) extension,
+Visual Studio Code will suggest that you do so the first time you open this project with Visual Studio Code.
+You can also review the list of suggested extensions of with the <kbd>Ctrl</kbd>-<kbd>P</kbd>
+`Extensions: Show Recommended Extensions` command.
+
+#### Snippets
+
+The predefined snippets for `nugem` are defined in
+[`.vscode/nugem.json.code-snippets`](.vscode/nugem.json.code-snippets).
+These snippets are focused on maintaining `nugem` itself.
+
+#### File Associations
+
+`.vscode/settings.json` defines file associations for various flavors of Thor templates in the `"files.associations"` section.
+You can disable them by commenting some or all of those definitions.
+
+
+### Generated Projects
+
+
+#### Plugins
+
+Similarly, for each gem project generated by `nugem`, Visual Studio Code will suggest
+the user install missing extensions the first time those projects are opened.
+
+
+#### Snippets
+
+The predefined snippets for gem projects generated by `nugem` are defined in
+their `.vscode/gem.json.code-snippets` file.
+These snippets are focused on writing Jekyll plugins.
+
+
+## Development
+
+After checking out the repository, run `bin/setup` to install dependencies.
+Then, run `rake test` to run the tests.
+You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run
+
+```shell
+$ bundle exec rake install
+```
+
+To release a new version, run:
+
+```shell
+$ bundle exec rake release
+```
+
+The above will create a git tag for the version, push git commits and tags,
+and push the `.gem` file to https://rubygems.org.
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/mslinn/nugem.
+
+
+## See Also
+
+- [`gem-release`](https://rubygems.org/gems/gem-release)
+- [`bundle gem`](https://bundler.io/v2.4/man/bundle-gem.1.html)
+- [Deveoping a RubyGem using Bundler](https://bundler.io/guides/creating_gem.html)

data/Rakefile

@@ -0,0 +1,40 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+desc 'Bump patch'
+task :patch do
+  system 'gem bump --tag'
+end
+
+desc 'Bump minor'
+task :minor do
+  system 'gem bump --version minor --tag'
+end
+
+desc 'Bump major'
+task :major do
+  system 'gem bump --version major --tag'
+end
+
+task publish: [:build] do
+  $VERBOSE = nil
+  load 'nugem/version.rb'
+  system "gem push pkg/nugem-#{Nugem::VERSION}.gem"
+end
+
+desc 'Bump patch version, create git tag, build the gem and release to geminabox (default)'
+task release_patch: %i[test patch publish]
+
+desc 'Bump minor version, create git tag, build the gem and release to geminabox'
+task release_minor: %i[test minor publish]
+
+desc 'Bump major version, create git tag, build the gem and release to geminabox'
+task release_major: %i[test major publish]
+
+task default: :test

data/lib/nugem/cli/cli_gem.rb

@@ -0,0 +1,61 @@
+require 'thor'
+
+# Nugem::Cli is a Thor class that is invoked when a user runs a nugem executable
+require_relative '../cli'
+
+module Nugem
+  class Cli < Thor
+    include Thor::Actions
+    include Nugem::Git
+
+    desc 'plain NAME', 'Creates a new plain gem scaffold.'
+
+    long_desc <<~END_DESC
+      Creates a new plain gem scaffold with the given NAME,
+      by default hosted by GitHub and published on RubyGems.
+    END_DESC
+
+    method_option :host, type: :string, default: 'github',
+      enum: %w[bitbucket github], desc: 'Repository host.'
+
+    method_option :private, type: :boolean, default: false,
+    desc: 'Publish the gem in a private repository.'
+
+    def plain(gem_name)
+      @dir = Nugem.dest_root gem_name
+
+      @host           = options['host']
+      @private        = options['private']
+      @test_framework = options['test_framework']
+
+      create_plain_scaffold gem_name
+      initialize_repository gem_name
+    end
+
+    private
+
+    # Defines globals for templates
+    def create_plain_scaffold(gem_name)
+      @gem_name = gem_name
+      say "Creating a scaffold for a new plain Ruby gem named #{@gem_name} in #{@dir}.", :green
+      @class_name = Nugem.camel_case @gem_name
+      @executable = options[:executable]
+      @host = options[:bitbucket] ? :bitbucket : :github
+      @private = options[:private]
+      @repository = Nugem::Repository.new(
+        host:           @host,
+        user:           git_repository_user_name(@host),
+        name:           @gem_name,
+        gem_server_url: gem_server_url(@private),
+        private:        @private
+      )
+      exclude_pattern = case @test_framework
+                        when 'minitest' then /spec.*/
+                        when 'rspec'    then /test.*/
+                        end
+      directory 'common/gem_scaffold',        @dir, force: true, mode: :preserve, exclude_pattern: exclude_pattern
+      directory 'common/executable_scaffold', @dir, force: true, mode: :preserve if @executable
+      template  'common/LICENCE.txt',         "#{@dir}/LICENCE.txt", force: true if @repository.public?
+    end
+  end
+end

data/lib/nugem/cli/cli_jekyll.rb

@@ -0,0 +1,192 @@
+require_relative '../cli'
+require_relative 'jekyll_demo'
+
+module Nugem
+  class Cli < Thor # rubocop:disable Metrics/ClassLength
+    include Thor::Actions
+    include Nugem::Git
+
+    attr_accessor :class_name, :filter_params, :trailing_args, :trailing_dump, :trailing_params
+
+    desc 'jekyll NAME', 'Creates a new Jekyll plugin scaffold.'
+
+    long_desc <<~END_DESC
+      Creates a new Jekyll plugin scaffold with the given NAME,
+      by default hosted by GitHub and published on RubyGems.
+    END_DESC
+
+    method_option :block, type: :string, repeatable: true,
+      desc: 'Specifies the name of a Jekyll block tag.'
+
+    method_option :blockn, type: :string, repeatable: true,
+      desc: 'Specifies the name of a Jekyll no-arg block tag.'
+
+    method_option :filter, type: :string, repeatable: true,
+      desc: 'Specifies the name of a Jekyll/Liquid filter module.'
+
+    method_option :generator, type: :string, repeatable: true,
+      desc: 'Specifies a Jekyll generator.'
+
+    method_option :hooks, type: :string,
+      desc: 'Specifies Jekyll hooks.'
+
+    method_option :tag, name: :string, repeatable: true,
+      desc: 'Specifies the name of a Jekyll tag.'
+
+    method_option :tagn, name: :string, repeatable: true,
+      desc: 'Specifies the name of a Jekyll no-arg tag.'
+
+    test_option 'rspec'
+
+    def jekyll(gem_name)
+      @gem_name = gem_name
+      @dir = Nugem.dest_root @gem_name
+      @class_name = Nugem.camel_case @gem_name
+      @jekyll   = true
+      @rspec    = true
+
+      @host           = options['host']
+      @private        = options['private']
+      @test_framework = options['test_framework']
+      @todos          = options['todos']
+
+      create_plain_scaffold @gem_name
+      create_jekyll_scaffold
+      options.each do |option|
+        case option.first
+        when 'block' then     option[1].each { |name| create_jekyll_block_scaffold        name }
+        when 'blockn' then    option[1].each { |name| create_jekyll_block_no_arg_scaffold name }
+        when 'filter' then    option[1].each { |name| create_jekyll_filter_scaffold       name }
+        when 'generator' then option[1].each { |name| create_jekyll_generator_scaffold    name }
+        when 'tag' then       option[1].each { |name| create_jekyll_tag_scaffold          name }
+        when 'tagn' then      option[1].each { |name| create_jekyll_tag_no_arg_scaffold   name }
+        when 'hooks' then     create_jekyll_hooks_scaffold option[1]
+        when 'host', 'executable', 'private', 'test_framework', 'todos', 'quiet' then next
+        else puts "Warning: Unrecognized option: #{option}"
+        end
+      end
+
+      initialize_repository @gem_name
+    end
+
+    no_commands do
+      # Invoked by directory action when processing Jekyll tags and block tags
+      def parse_jekyll_parameters
+        content = @jekyll_parameter_names_types.map do |name, _type|
+          "@#{name} = @helper.parameter_specified? '#{name}' # Obtain the value of parameter #{name}"
+        end
+        content.join "\n      "
+      end
+
+      # Invoked by directory action when processing Jekyll tags and block tags
+      def dump_jekyll_parameters
+        content = @jekyll_parameter_names_types.map do |name, _type|
+          "@#{name}='\#{@#{name}}'"
+        end
+        content.join "\n          "
+      end
+    end
+
+    private
+
+    # Sets @jekyll_parameter_names_types, which contains a
+    # list of pairs that describe each Jekyll/Liquid tag invocation option:
+    # [[name1, type1], ... [nameN, typeN]]
+    def ask_option_names_types(tag)
+      names = ask("Please list the names of the options for the #{tag} Jekyll/Liquid tag:").split(/[ ,\t]/)
+      types = names.reject(&:empty?).map do |name|
+        ask "What is the type of #{name}? (tab autocompletes)", default: 'string', limited_to: %w[boolean string numeric]
+      end
+      @jekyll_parameter_names_types = names.zip types
+      @jekyll_parameter_names_types
+    end
+
+    def create_jekyll_scaffold
+      say "Creating a Jekyll scaffold for a new gem named #{@gem_name} in #{@dir}", :green
+      @mute = true
+      directory 'jekyll/common_scaffold', @dir, force: true, mode: :preserve
+      directory 'jekyll/demo', @dir, force: true, mode: :preserve
+    end
+
+    def create_jekyll_block_scaffold(block_name)
+      @block_name = block_name
+      @jekyll_class_name = Nugem.camel_case block_name
+      ask_option_names_types block_name # Defines @jekyll_parameter_names_types, which is a nested array of name/value pairs:
+      # [["opt1", "string"], ["opt2", "boolean"]]
+      say "Creating Jekyll block tag #{@block_name} scaffold within #{@jekyll_class_name}", :green
+      @mute = true
+      directory 'jekyll/block_scaffold', @dir, force: true, mode: :preserve
+      append_to_file "#{Nugem.dest_root gem_name}/demo/index.html", Cli.add_demo_example(block_name, @jekyll_parameter_names_types, :block)
+    end
+
+    def create_jekyll_block_no_arg_scaffold(block_name)
+      @block_name = block_name
+      @jekyll_class_name = Nugem.camel_case block_name
+      say "Creating Jekyll block tag no_arg #{@block_name} scaffold within #{@jekyll_class_name}", :green
+      @mute = true
+      directory 'jekyll/block_no_arg_scaffold', @dir, force: true, mode: :preserve
+      append_to_file "#{Nugem.dest_root gem_name}/demo/index.html", Cli.add_demo_example(block_name, @jekyll_parameter_names_types, :block)
+    end
+
+    def create_jekyll_filter_scaffold(filter_name)
+      # rubocop:disable Style/StringConcatenation
+      @filter_name = filter_name
+      @jekyll_class_name = Nugem.camel_case filter_name
+      @filter_params = ask('Jekyll filters have at least one input. ' \
+                           "What are the names of additional inputs for #{filter_name}, if any?")
+                         .split(/[ ,\t]/)
+                         .reject(&:empty?)
+      unless @filter_params.empty?
+        @trailing_args   = ', ' + @filter_params.join(', ')
+        @trailing_params = ': ' + @filter_params.join(', ')
+        @trailing_dump1 = @filter_params.map { |arg| "#{@class_name}.logger.debug { \"#{arg} = \#{#{arg}}\" }" }.join "\n    "
+        lspace = "\n      "
+        @trailing_dump2 = lspace + @filter_params.map { |arg| "#{arg} = \#{#{arg}}" }.join(lspace) unless @filter_params.empty?
+      end
+      say "Creating a new Jekyll filter method scaffold #{@filter_name}", :green
+      @mute = true
+      directory 'jekyll/filter_scaffold', @dir, force: true, mode: :preserve
+
+      tp = ': ' + @filter_params.map { |x| "'#{x}_value'" }.join(', ') unless @filter_params.empty?
+      append_to_file "#{Nugem.dest_root gem_name}/demo/index.html", Cli.add_filter_example(filter_name, tp)
+      # rubocop:enable Style/StringConcatenation
+    end
+
+    def create_jekyll_generator_scaffold(generator_name)
+      @generator_name = generator_name
+      @jekyll_class_name = Nugem.camel_case generator_name
+      say "Creating a new Jekyll generator class scaffold #{@jekyll_class_name}", :green
+      @mute = true
+      directory 'jekyll/generator_scaffold', @dir, force: true, mode: :preserve
+    end
+
+    def create_jekyll_hooks_scaffold(plugin_name)
+      @plugin_name = plugin_name
+      @jekyll_class_name = Nugem.camel_case plugin_name
+      say 'Creating a new Jekyll hook scaffold', :green
+      @mute = true
+      directory 'jekyll/hooks_scaffold', @dir, force: true, mode: :preserve
+    end
+
+    def create_jekyll_tag_no_arg_scaffold(tag_name)
+      @tag_name = tag_name
+      @jekyll_class_name = Nugem.camel_case @tag_name
+      say "Creating Jekyll tag no_arg #{@tag_name} scaffold within #{@jekyll_class_name}", :green
+      @mute = true
+      directory 'jekyll/tag_no_arg_scaffold', @dir, force: true, mode: :preserve
+      append_to_file "#{Nugem.dest_root gem_name}/demo/index.html", Cli.add_demo_example(tag_name, @jekyll_parameter_names_types, :tag)
+    end
+
+    def create_jekyll_tag_scaffold(tag_name)
+      @tag_name = tag_name
+      @jekyll_class_name = Nugem.camel_case @tag_name
+      ask_option_names_types tag_name # Defines @jekyll_parameter_names_types, which is a nested array of name/value pairs:
+      # [["opt1", "string"], ["opt2", "boolean"]]
+      say "Creating Jekyll tag #{@tag_name} scaffold within #{@jekyll_class_name}", :green
+      @mute = true
+      # puts set_color("@jekyll_parameter_names_types=#{@jekyll_parameter_names_types}", :yellow)
+      directory 'jekyll/tag_scaffold', @dir, force: true, mode: :preserve
+      append_to_file "#{Nugem.dest_root gem_name}/demo/index.html", Cli.add_demo_example(tag_name, @jekyll_parameter_names_types, :tag)
+    end
+  end
+end

data/lib/nugem/cli/cli_rails.rb

@@ -0,0 +1,60 @@
+require_relative '../cli'
+
+module Nugem
+  class Cli < Thor
+    include Thor::Actions
+    include Nugem::Git
+
+    desc 'rails NAME', 'Creates a new Rails rails scaffold.'
+
+    long_desc <<~END_DESC
+      Creates a new Rails rails scaffold with the given NAME,
+      by default hosted by GitHub and published on RubyGems.
+    END_DESC
+
+    method_option :engine, type: :boolean, default: false,
+      desc: 'Create a gem containing a Rails engine.'
+
+    test_option 'minitest'
+
+    method_option :mountable, type: :boolean, default: false,
+      desc: 'Create a gem containing a mountable Rails engine.'
+
+    def rails(gem_name)
+      @host           = options['host']
+      @mountable      = options['mountable']
+      @private        = options['private']
+      @test_framework = options['test_framework']
+
+      @dir = Nugem.dest_root gem_name
+      @engine = @host || @mountable
+      @rails = true
+
+      create_plain_scaffold gem_name
+      create_rails_scaffold gem_name
+      create_engine_scaffold gem_name if @engine
+      create_mountable_scaffold gem_name if @mountable
+      initialize_repository gem_name
+    end
+
+    private
+
+    def create_engine_scaffold(gem_name)
+      say "Creating a new Rails engine scaffold for a new gem named #{gem_name} in #{@dir}", :green
+      directory 'rails/engine_scaffold', @dir, force: true, mode: :preserve
+    end
+
+    def create_mountable_scaffold(gem_name)
+      say "Creating a mountable Rails engine scaffold for a new gem named #{gem_name} in #{@dir}", :green
+      directory 'rails/mountable_scaffold', @dir, force: true, mode: :preserve
+    end
+
+    def create_rails_scaffold(gem_name)
+      say "Creating a new Rails plugin scaffold as a gem named #{gem_name} in #{@dir}", :green
+      directory 'rails/rails_scaffold', @dir, force: true, mode: :preserve
+      Dir.chdir @dir do
+        run 'chmod +x test/dummy/bin/*' # TODO: fix me
+      end
+    end
+  end
+end

data/lib/nugem/cli/jekyll_demo.rb

@@ -0,0 +1,60 @@
+module Nugem
+  class Cli < Thor
+    include Thor::Actions
+
+    def self.combinations(params)
+      (0..params.length).flat_map do |n|
+        params.combination(n).map do |param|
+          next [] if param.empty?
+
+          param.flat_map do |p|
+            name = p.first
+            type = p[1]
+            case type
+            when 'boolean' then name
+            when 'string' then "#{name}='somevalue'"
+            when 'numeric' then "#{name}=1234"
+            else "#{name} has unknown type: #{type}"
+            end
+          end
+        end
+      end
+    end
+
+    def self.add_demo_example(tag, params, tag_type = :tag)
+      last_tag = ''
+      examples = combinations(params).map do |option|
+        options = option.join ' '
+        label = options.empty? ? ' (invoked without parameters)' : options
+        close_tag = case tag_type
+                    when :tag then ''
+                    when :block then <<~END_BLOCK
+                      \nThis is line 1 of the block content.<br>
+                      This is line 2.
+                      {% end#{tag} %}
+                    END_BLOCK
+                    end
+        example = <<~END_EX
+          <!-- #region #{tag} #{label} -->
+          <h3 id="#{tag}" class="code">#{tag} #{label}</h3>
+          {% #{tag} #{options} %}#{close_tag}
+          <!-- endregion -->
+        END_EX
+        if tag == last_tag
+          example
+        else
+          last_tag = tag
+          "<h2 id=\"tag_#{tag}\" class='code'>#{tag}</h2>\n" + example
+        end
+      end
+      examples.join("\n\n")
+    end
+
+    def self.add_filter_example(filter_name, trailing_params)
+      <<~END_EX
+        <h2 id="filter_#{filter_name}" class='code'>#{filter_name}</h2>
+        {{ "TODO: Provide filter input here" | #{filter_name}#{trailing_params} }}
+      END_EX
+    end
+  end
+end

data/lib/nugem/cli.rb

@@ -0,0 +1,90 @@
+require 'fileutils'
+require 'rugged'
+require_relative '../nugem'
+
+# Nugem::Cli is a Thor class that is invoked when a user runs a nugem executable.
+# This file defines the common aspects of the Thor class.
+# The cli/ directory contains class extensions specific to each Thor subcommand.
+module Nugem
+  class Cli < Thor
+    include Thor::Actions
+    include Nugem::Git
+
+    class_option :executable, type: :boolean, default: false,
+      desc: 'Include an executable for the gem.'
+
+    class_option :host, type: :string, default: 'github',
+      enum: %w[bitbucket github], desc: 'Repository host.'
+
+    class_option :private, type: :boolean, default: false,
+      desc: 'Publish the gem on a private repository.'
+
+    class_option :quiet, type: :boolean, default: true,
+      desc: 'Suppress detailed messages.', group: :runtime
+
+    class_option :todos, type: :boolean, default: true,
+      desc: 'Generate TODO: messages in generated code.', group: :runtime
+
+    # Surround gem_name with percent symbols when using the property to name files
+    # within the template directory
+    # For example: "generated/%gem_name%"
+    attr_accessor :gem_name
+
+    require_relative 'cli/cli_gem'
+    require_relative 'cli/cli_jekyll'
+    require_relative 'cli/cli_rails'
+
+    def self.exit_on_failure?
+      true
+    end
+
+    # @return Path to the Thor generator templates
+    def self.source_root
+      File.expand_path '../../templates', __dir__
+    end
+
+    def self.todo
+      'TODO: ' if @todos
+    end
+
+    private
+
+    def count_todos(filename)
+      filename_fq = "#{Nugem.dest_root gem_name}/#{filename}"
+      content = File.read filename_fq
+      content.scan('TODO').length
+    end
+
+    def initialize_repository(gem_name)
+      Dir.chdir Nugem.dest_root(gem_name) do
+        # say "Working in #{Dir.pwd}", :green
+        run 'chmod +x bin/*'
+        run 'chmod +x exe/*' if @executable
+        create_local_git_repository
+        FileUtils.rm_f 'Gemfile.lock'
+        # say "Running 'bundle install'", :green
+        # run 'bundle', abort_on_failure: false
+        say 'Creating remote repository', :green
+        create_remote_git_repository @repository \
+          if yes? "Do you want to create a repository on #{@repository.host.camel_case} named #{gem_name}? (y/N)"
+      end
+      say "The #{gem_name} gem was successfully created.", :green
+      report_todos gem_name
+    end
+
+    def report_todos(gem_name)
+      gemspec_todos = count_todos "#{gem_name}.gemspec"
+      readme_todos  = count_todos 'README.md'
+      if readme_todos.zero? && gemspec_todos.zero?
+        say "There are no TODOs. You can run 'bundle install' from within your new gem project now.", :blue
+        return
+      end
+
+      msg = 'Please complete'
+      msg << " the #{gemspec_todos} TODOs in #{gem_name}.gemspec" if gemspec_todos.positive?
+      msg << ' and' if gemspec_todos.positive? && readme_todos.positive?
+      msg << " the #{readme_todos} TODOs in README.md." if readme_todos.positive?
+      say msg, :yellow
+    end
+  end
+end

data/lib/nugem/git.rb

@@ -0,0 +1,81 @@
+require 'thor'
+require 'yaml'
+
+module Nugem
+  module Git
+    include Thor::Actions
+
+    def create_local_git_repository
+      say 'Creating the local git repository', :green
+      run 'git init'
+      run 'git add .'
+
+      # See https://github.com/rails/thor/blob/v1.2.2/lib/thor/actions.rb#L236-L278
+      run "git commit -aqm 'Initial commit'", abort_on_failure: false
+    end
+
+    def github_config
+      gh_hosts_file = Nugem.expand_env('$HOME/.config/gh/hosts.yml')
+      return nil unless File.exist? gh_hosts_file
+
+      YAML.safe_load(File.read(gh_hosts_file))
+    end
+
+    def create_remote_git_repository(repository)
+      say "Creating a remote #{repository.host} repository", :green
+      if repository.github?
+        gh_config = github_config
+        token = gh_config&.dig('github.com', 'oauth_token')
+
+        token ||= ask('What is your Github personal access token', echo: false)
+        run <<~END_CURL
+          curl --request POST \
+            --user '#{repository.user}:#{token}' \
+            https://api.github.com/user/repos \
+            -d '{"name":"#{repository.name}", "private":#{repository.private?}}'
+        END_CURL
+      else # BitBucket
+        password = ask('Please enter your Bitbucket password', echo: false)
+        fork_policy = repository.public? ? 'allow_forks' : 'no_public_forks'
+        run <<~END_BITBUCKET
+          curl --request POST \
+            --user #{repository.user}:#{password} \
+            https://api.bitbucket.org/2.0/repositories/#{repository.user}/#{repository.name} \
+            -d '{"scm":"git", "fork_policy":"#{fork_policy}", "is_private":"#{repository.private?}"}'
+        END_BITBUCKET
+      end
+      run "git remote add origin #{repository.origin}"
+      say "Pushing initial commit to remote #{repository.host} repository", :green
+      run 'git push -u origin master'
+    end
+
+    def git_repository_user_name(host)
+      global_config = Rugged::Config.global
+      git_config_key = "nugem.#{host}user"
+      user = global_config[git_config_key]
+
+      gh_config = github_config
+      user ||= gh_config&.dig('github.com', 'user')
+
+      user = ask "What is your #{host} user name?" if user.to_s.empty?
+      global_config[git_config_key] = user if user != global_config[git_config_key]
+      user
+    end
+
+    def gem_server_url(private_)
+      if private_
+        global_config = Rugged::Config.global
+        git_config_key = 'nugem.gemserver'
+        url = global_config[git_config_key]
+
+        if url.to_s.empty?
+          url = ask('What is the url of your Geminabox server?')
+          global_config[git_config_key] = url
+        end
+        url
+      else
+        'https://rubygems.org'
+      end
+    end
+  end
+end

data/lib/nugem/repository.rb

@@ -0,0 +1,53 @@
+# Nugem::Repository contains informations about the git repository and the git user
+module Nugem
+  class Repository
+    attr_reader :gem_server_url, :global_config, :host, :name, :private, :user, :user_name, :user_email
+
+    Host = Struct.new(:domain, :camel_case, :id, keyword_init: true)
+    HOSTS = [
+      Host.new(domain: 'github.com',    camel_case: 'GitHub',    id: :github),
+      Host.new(domain: 'bitbucket.org', camel_case: 'BitBucket', id: :bitbucket),
+    ].freeze
+
+    def initialize(options)
+      @host = HOSTS.find { |host| host.id == options[:host] }
+      @private = options[:private]
+      @name = options[:name]
+      @user = options[:user]
+      @global_config = Rugged::Config.global
+      abort 'Git global config not found' if @global_config.nil?
+
+      @user_name  = @global_config['user.name']
+      @user_email = @global_config['user.email']
+      @gem_server_url = options[:gem_server_url]
+      @private = options[:private]
+    end
+
+    def bitbucket?
+      @host.id == :bitbucket
+    end
+
+    def github?
+      @host.id == :github
+    end
+
+    def origin
+      "git@#{@host.domain}:#{@user}/#{@name}.git"
+    end
+
+    # TODO: Currently all private repositories are on BitBucket and all public repos are on GitHub
+    # TODO: Drop BitBucket?
+    # TODO: Support private repos on GitHub
+    def private?
+      @private
+    end
+
+    def public?
+      !@private
+    end
+
+    def url
+      "https://#{@host.domain}/#{@user}/#{@name}"
+    end
+  end
+end

data/lib/nugem/version.rb

@@ -0,0 +1,3 @@
+module Nugem
+  VERSION = '0.8.0'.freeze
+end

data/lib/nugem.rb

@@ -0,0 +1,31 @@
+require 'thor'
+require_relative 'nugem/git'
+require_relative 'nugem/repository'
+require_relative 'nugem/version'
+require_relative 'util'
+
+module Nugem
+  # @return Path to the generated gem
+  def self.dest_root(gem_name)
+    File.expand_path "generated/#{gem_name}"
+  end
+
+  class Cli < Thor
+    include Thor::Actions
+
+    package_name 'Nugem'
+
+    # These declarations make the class instance variable values available as an accessor,
+    # which is necessary to name template files that are named '%variable_name%.extension'.
+    # See https://www.rubydoc.info/gems/thor/Thor/Actions#directory-instance_method
+    attr_reader :block_name, :filter_name, :generator_name, :tag_name, :test_framework
+
+    class << self
+      def test_option(default_value)
+        method_option :test_framework, type: :string, default: default_value,
+          enum: %w[minitest rspec],
+          desc: "Use rspec or minitest for the test framework (default is #{default_value})."
+      end
+    end
+  end
+end

data/lib/util.rb

@@ -0,0 +1,11 @@
+module Nugem
+  def self.camel_case(str)
+    Thor::Util.camel_case str.tr('-', '_')
+  end
+
+  def self.expand_env(str)
+    str.gsub(/\$([a-zA-Z_][a-zA-Z0-9_]*)|\${\g<1>}|%\g<1>%/) do
+      ENV.fetch(Regexp.last_match(1), nil)
+    end
+  end
+end

data/nugem.gemspec

@@ -0,0 +1,23 @@
+require_relative 'lib/nugem/version'
+
+Gem::Specification.new do |spec|
+  spec.authors       = ['Igor Jancev', 'Mike Slinn']
+  spec.bindir        = 'exe'
+  spec.email         = ['igor@masterybits.com', 'mslinn@mslinn.com']
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.files         = Dir['.rubocop.yml', 'LICENSE.*', 'Rakefile', '{lib,spec}/**/*', '*.gemspec', '*.md']
+  spec.description   = <<~END_DESC
+    Nugem creates a scaffold project for new gems. You can choose between Github and Bitbucket,
+    Rubygems or Geminabox, with or without an executable, etc.
+  END_DESC
+  spec.homepage      = 'https://github.com/mslinn/nugem'
+  spec.license       = 'MIT'
+  spec.name          = 'nugem'
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 3.1.0'
+  spec.summary       = 'Nugem creates a scaffold project for new gems.'
+  spec.version       = Nugem::VERSION
+
+  spec.add_dependency 'rugged'
+  spec.add_dependency 'thor'
+end

data/spec/jekyll_tag_spec.rb

@@ -0,0 +1,89 @@
+require_relative '../lib/nugem/cli/cli_jekyll'
+
+class JekyllTagTest
+  RSpec.describe ::Nugem::Cli do
+    it 'tests tag option combinations' do
+      params = [
+        %w[option1 string],
+        %w[option2 boolean],
+        %w[option3 numeric],
+      ]
+      expect(params.combination(0).to_a).to eq [[]]
+      expect(params.combination(1).to_a).to eq [
+        [%w[option1 string]],
+        [%w[option2 boolean]],
+        [%w[option3 numeric]],
+      ]
+      expect(params.combination(2).to_a).to eq [
+        [%w[option1 string],  %w[option2 boolean]],
+        [%w[option1 string],  %w[option3 numeric]],
+        [%w[option2 boolean], %w[option3 numeric]],
+      ]
+      expect(params.combination(3).to_a).to eq [
+        [%w[option1 string], %w[option2 boolean], %w[option3 numeric]],
+      ]
+
+      actual = described_class.combinations params
+      expected = [
+        [],
+        ["option1='somevalue'"], ['option2'], ['option3=1234'],
+        ["option1='somevalue'", 'option2'],
+        ["option1='somevalue'", 'option3=1234'],
+        ['option2', 'option3=1234'],
+        ["option1='somevalue'", 'option2', 'option3=1234']
+      ]
+      expect(actual).to eq(expected)
+
+      actual = described_class.add_demo_example 'my_tag', params, :tag
+      expected = <<~END_EX
+        <!-- #region my_tag  -->
+        <h2 id="my_tag">my_tag </h2>
+        {% my_tag  %}
+        <!-- endregion -->
+
+
+        <!-- #region my_tag option1='somevalue' -->
+        <h2 id="my_tag">my_tag option1='somevalue'</h2>
+        {% my_tag option1='somevalue' %}
+        <!-- endregion -->
+
+
+        <!-- #region my_tag option2 -->
+        <h2 id="my_tag">my_tag option2</h2>
+        {% my_tag option2 %}
+        <!-- endregion -->
+
+
+        <!-- #region my_tag option3=1234 -->
+        <h2 id="my_tag">my_tag option3=1234</h2>
+        {% my_tag option3=1234 %}
+        <!-- endregion -->
+
+
+        <!-- #region my_tag option1='somevalue' option2 -->
+        <h2 id="my_tag">my_tag option1='somevalue' option2</h2>
+        {% my_tag option1='somevalue' option2 %}
+        <!-- endregion -->
+
+
+        <!-- #region my_tag option1='somevalue' option3=1234 -->
+        <h2 id="my_tag">my_tag option1='somevalue' option3=1234</h2>
+        {% my_tag option1='somevalue' option3=1234 %}
+        <!-- endregion -->
+
+
+        <!-- #region my_tag option2 option3=1234 -->
+        <h2 id="my_tag">my_tag option2 option3=1234</h2>
+        {% my_tag option2 option3=1234 %}
+        <!-- endregion -->
+
+
+        <!-- #region my_tag option1='somevalue' option2 option3=1234 -->
+        <h2 id="my_tag">my_tag option1='somevalue' option2 option3=1234</h2>
+        {% my_tag option1='somevalue' option2 option3=1234 %}
+        <!-- endregion -->
+      END_EX
+      expect(actual).to eq(expected)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+require_relative '../lib/nugem'
+
+RSpec.configure do |config|
+  config.filter_run :focus
+  # config.order = "random"
+  config.run_all_when_everything_filtered = true
+
+  # See https://relishapp.com/rspec/rspec-core/docs/command-line/only-failures
+  config.example_status_persistence_file_path = '../spec/status_persistence.txt'
+
+  config.filter_run_when_matching focus: true
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: nugem
+version: !ruby/object:Gem::Version
+  version: 0.8.0
+platform: ruby
+authors:
+- Igor Jancev
+- Mike Slinn
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2023-07-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rugged
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Nugem creates a scaffold project for new gems. You can choose between Github and Bitbucket,
+  Rubygems or Geminabox, with or without an executable, etc.
+email:
+- igor@masterybits.com
+- mslinn@mslinn.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- CHANGELOG.md
+- README.md
+- Rakefile
+- lib/nugem.rb
+- lib/nugem/cli.rb
+- lib/nugem/cli/cli_gem.rb
+- lib/nugem/cli/cli_jekyll.rb
+- lib/nugem/cli/cli_rails.rb
+- lib/nugem/cli/jekyll_demo.rb
+- lib/nugem/git.rb
+- lib/nugem/repository.rb
+- lib/nugem/version.rb
+- lib/util.rb
+- nugem.gemspec
+- spec/jekyll_tag_spec.rb
+- spec/spec_helper.rb
+- spec/status_persistence.txt
+homepage: https://github.com/mslinn/nugem
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.3
+signing_key:
+specification_version: 4
+summary: Nugem creates a scaffold project for new gems.
+test_files: []