amber_extension_generator 0.0.5

data/lib/amber_extension_generator/cli/gem_generator.rb

@@ -0,0 +1,406 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+
+require 'rainbow/refinement'
+require 'cli/ui'
+require 'tty-command'
+require 'erb'
+
+using ::Rainbow
+
+module ::AmberExtensionGenerator
+  module CLI
+    # Generates a new extension gem
+    class GemGenerator
+      class << self
+        # @param args [::AmberExtensionGenerator::CLI::Args]
+        # @return [void]
+        def call(args)
+          new(args).call
+        end
+      end
+
+      # @param args [::AmberExtensionGenerator::CLI::Args]
+      def initialize(args)
+        @args = args
+      end
+
+      # @return [void]
+      def call
+        ::CLI::UI::StdoutRouter.enable
+        generate_amber_gem
+        puts
+        generate_rails_dummy_app
+      end
+
+      private
+
+      # @return [void]
+      def generate_amber_gem
+        ::CLI::UI::Frame.open 'Create gem', color: :green do # rubocop:disable Metrics/BlockLength
+          ::CLI::UI::Frame.open 'Generate gem with bundler' do
+            syscall "bundle gem #{root_path} --linter=rubocop --ci=github --test=minitest", input: "y\n"
+          end
+
+          ::CLI::UI::Frame.open 'Patch gem' do
+            template 'components/base_component.rb.erb', gem_entry_folder_path / 'components' / 'base_component.rb'
+
+            copy 'components.rb', gem_entry_folder_path / 'components.rb'
+            template 'railtie.rb.erb', gem_entry_folder_path / 'railtie.rb'
+
+            substitute gem_entry_file_path, /^end/, <<~RUBY.chomp
+              end
+
+              require 'pathname'
+              require_relative '#{gem_entry_folder_path.basename}/railtie' if defined?(::Rails::Railtie)
+              require_relative '#{gem_entry_folder_path.basename}/components'
+
+              # Override this if you want to have a different name for the
+              # base component of your gem
+              #{root_module_name}::ABSTRACT_COMPONENT = #{root_module_name}::BaseComponent
+              #{root_module_name}::ROOT_PATH = ::Pathname.new ::File.expand_path('#{relative_path_to_root}', __dir__)
+            RUBY
+
+            create '.rubocop.yml', ::File.read(ROOT_GEM_PATH / '.rubocop.yml')
+
+            template 'bin/generate.erb', 'bin/generate'
+            template 'bin/dev.erb', 'bin/dev'
+            make_executable 'bin/generate'
+            make_executable 'bin/dev'
+
+            make_dir 'assets/stylesheets'
+            template 'assets/stylesheets/main.scss.erb', main_stylesheet_path
+            copy 'assets/stylesheets/components.scss', stylesheet_dir_path / 'components.scss'
+
+            make_dir 'templates'
+            copy 'templates/component.rb.tt'
+            copy 'templates/style.scss.tt'
+            copy 'templates/view.html.erb.tt'
+            copy 'templates/component_test.rb.tt'
+
+            substitute "#{gem_name}.gemspec", /^end/, <<~RUBY.chomp
+                # ignore the dummy Rails app when building the gem
+                spec.files.reject! { _1.match(/^#{rails_dummy_path}/) }
+                spec.add_dependency 'amber_component'
+                spec.add_development_dependency 'thor'
+                spec.add_development_dependency 'sassc'
+              end
+            RUBY
+
+            copy 'test/component_test_case.rb'
+            substitute 'Rakefile', /test_\*\.rb/, '*_test.rb'
+            inner_module_name = gem_name.split('-').last
+            move gem_test_folder_path.parent / "test_#{inner_module_name}.rb",
+                 gem_test_folder_path.parent / "#{inner_module_name}_test.rb"
+
+            append 'test/test_helper.rb',
+                   "require_relative 'component_test_case'\n"
+          end
+        end
+      end
+
+      # @return [void]
+      def generate_rails_dummy_app
+        ::CLI::UI::Frame.open 'Rails dummy app', color: :magenta do
+          unless syscall? 'gem list -i rails'
+            ::CLI::UI::Frame.open 'Install Rails' do
+              syscall 'gem install rails'
+              syscall 'gem install sqlite3'
+            end
+          end
+
+          ::CLI::UI::Frame.open 'Generate app' do
+            syscall "rails new #{root_path / rails_dummy_path} -m #{rails_template_path}",
+                    env: { GEM_NAME: gem_name },
+                    input: "y\n"
+          end
+
+          ::CLI::UI::Frame.open 'Patch app' do
+            append rails_dummy_path / 'Gemfile', template_content('rails_dummy/Gemfile.erb')
+
+            if exist?(rails_dummy_path / 'app' / 'assets' / 'stylesheets' / 'application.css')
+              move rails_dummy_path / 'app' / 'assets' / 'stylesheets' / 'application.css',
+                   rails_dummy_path / 'app' / 'assets' / 'stylesheets' / 'application.scss'
+
+              append rails_dummy_path / 'app' / 'assets' / 'stylesheets' / 'application.scss', <<~SCSS
+                @import "#{gem_name_path}";
+              SCSS
+            else
+              append rails_dummy_path / 'app' / 'assets' / 'stylesheets' / 'application.sass.scss', <<~SCSS
+                @import "#{gem_name_path}";
+              SCSS
+            end
+          end
+        end
+      end
+
+      # @return [String]
+      def relative_path_to_root
+        (['..'] * root_module_name.split('::').length).join('/')
+      end
+
+      # Performs a shell command with a PTY,
+      # captures its output and logs it to this process's STDOUT.
+      #
+      # @param command [String]
+      # @param env [Hash{Symbol => String}] Environment variables
+      # @param input [String, nil] Input to the process
+      # @return [String] STDOUT
+      def syscall(command, env: {}, input: nil)
+        cmd = ::TTY::Command.new(color: true, printer: :quiet)
+        cmd.run!(command, pty: true, input: input, env: env)
+      end
+
+      # Performs a quiet shell command (without logging to STDOUT)
+      # and returns the process's exit status as a `Boolean`.
+      #
+      # @param command [String]
+      # @param env [Hash{Symbol => String}] Environment variables
+      # @param input [String, nil] Input to the process
+      # @return [Boolean] whether the command was successful
+      def syscall?(command, env: {}, input: nil)
+        cmd = ::TTY::Command.new(printer: :null)
+        !cmd.run!(command, input: input, env: env).failure?
+      end
+
+      # Make a file in the newly generated gem executable.
+      #
+      # @param path [String, Pathname]
+      # @return [void]
+      def make_executable(path)
+        ::FileUtils.chmod 'ugo+x', root_path / path
+      end
+
+      # Relative path to the main entry file of the generated gem.
+      #
+      # @return [Pathname]
+      def gem_entry_file_path
+        gem_entry_folder_path.sub_ext('.rb')
+      end
+
+      # Relative path to the main folder of the generated gem.
+      #
+      # @return [Pathname]
+      def gem_entry_folder_path
+        ::Pathname.new('lib') / gem_name_path
+      end
+
+      # Relative path to the test folder of the generated gem.
+      #
+      # @return [Pathname]
+      def gem_test_folder_path
+        ::Pathname.new('test') / gem_name_path
+      end
+
+      # @return [Pathname]
+      def gem_name_path
+        @gem_name_path ||= ::Pathname.new gem_name.gsub('-', '/')
+      end
+
+      # Name of the generated gem.
+      #
+      # @return [String]
+      def gem_name
+        @gem_name ||= root_path.basename.to_s
+      end
+
+      # Relative path to the stylesheet directory of the generated gem.
+      #
+      # @return [Pathname]
+      def stylesheet_dir_path
+        ::Pathname.new('assets') / 'stylesheets' / gem_name_path
+      end
+
+      # Relative path to the main stylesheet file of the generated gem.
+      #
+      # @return [Pathname]
+      def main_stylesheet_path
+        stylesheet_dir_path.sub_ext '.scss'
+      end
+
+      # @return [Pathname]
+      def rails_dummy_path
+        ::Pathname.new 'dummy_app'
+      end
+
+      # Path to the root folder of the generated gem.
+      #
+      # @return [Pathname]
+      def root_path
+        @args.gem_path
+      end
+
+      # @return [Pathname]
+      def rails_template_path
+        ROOT_GEM_PATH / 'lib' / 'dummy_rails_app_template.rb'
+      end
+
+      # Check whether the given file/directory exists
+      # in the generated gem.
+      #
+      # @param path [String, Pathname]
+      # @return [Boolean]
+      def exist?(path)
+        (root_path / path).exist?
+      end
+
+      # Create a directory in the generated gem
+      # if it doesn't exist already.
+      #
+      # @param path [String, Pathname]
+      # @return [void]
+      def make_dir(path)
+        dir_path = root_path / path
+        ::FileUtils.mkdir_p dir_path unless dir_path.exist?
+      end
+      alias mkdir make_dir
+
+      # @param string [String, Symbol]
+      # @return [String]
+      def action_message(string)
+        "#{string.to_s.rjust(12, ' ')}  "
+      end
+
+      # Parse a template file from this gem using ERB and
+      # and copy it to the newly generated gem.
+      #
+      # @param template_path [String, Pathname]
+      # @param target_path [String, Pathname]
+      # @return [void]
+      def template(template_path, target_path)
+        create target_path, template_content(template_path)
+      end
+
+      # Copy a file from this gem's template folder to
+      # the newly generated gem.
+      #
+      # @param source_path [String, Pathname]
+      # @param target_path [String, Pathname]
+      # @return [void]
+      def copy(source_path, target_path = source_path, recursive: false)
+        print action_message(__method__).green
+        puts target_path
+
+        source = TEMPLATES_FOLDER_PATH / source_path
+        target = root_path / target_path
+        ::FileUtils.mkdir_p(target.dirname) unless target.dirname.directory?
+        return ::FileUtils.cp_r source, target if recursive
+
+        ::FileUtils.cp source, target
+      end
+
+      # Move a file inside the generated gem.
+      #
+      # @param source_path [String, Pathname]
+      # @param target_path [String, Pathname]
+      # @return [void]
+      def move(source_path, target_path)
+        print action_message(__method__).yellow
+        puts "#{source_path} -> #{target_path}"
+
+        source = root_path / source_path
+        target = root_path / target_path
+        ::FileUtils.move source, target
+      end
+
+      # Read and parse a template with ERB and
+      # return the result as a `String`.
+      #
+      # @param path [String, Pathname]
+      # @return [String] Parsed content of the template
+      def template_content(path)
+        template_path = TEMPLATES_FOLDER_PATH / path
+        ::ERB.new(template_path.read).result(binding)
+      end
+
+      # Create a new file with the specified content
+      # in the newly generated gem.
+      #
+      # @param file_path [String, Pathname]
+      # @param content [String]
+      def create(file_path, content)
+        print action_message(__method__).green
+        puts file_path
+
+        path = root_path / file_path
+        ::FileUtils.mkdir_p(path.dirname) unless path.dirname.directory?
+
+        path.write(content)
+      end
+
+      # Substitute a part of a certain file in the generated gem.
+      #
+      # @param file_path [String, Pathname]
+      # @param regexp [Regexp]
+      # @param replacement [String]
+      # @return [void]
+      def substitute(file_path, regexp, replacement)
+        print action_message(:gsub).yellow
+        puts file_path
+
+        path = root_path / file_path
+        file_content = path.read
+        raise "Cannot substitute #{path} because #{regexp.inspect} was not found" unless file_content.match?(regexp)
+
+        path.write file_content.sub(regexp, replacement)
+      end
+
+      # Prepend some content to a file in the generated gem.
+      #
+      # @param file_path [String, Pathname]
+      # @param content [String]
+      # @return [void]
+      def prepend(file_path, content)
+        print action_message(__method__).yellow
+        puts file_path
+
+        # @type [Pathname]
+        path = root_path / file_path
+        current_content = ::File.read path
+        ::File.open(path, 'w') do |f|
+          f.write(content)
+          f.write(current_content)
+        end
+      end
+
+      # Append some content to a file in the generated gem.
+      #
+      # @param file_path [String, Pathname]
+      # @param content[String]
+      # @return [void]
+      def append(file_path, content)
+        print action_message(__method__).yellow
+        puts file_path
+
+        # @type [Pathname]
+        path = root_path / file_path
+        ::File.open(path, 'a') { _1.write(content) }
+      end
+
+      # Name of the root module of the generated gem.
+      #
+      # @return [String]
+      def root_module_name
+        camelize(gem_name_path)
+      end
+
+      # @param string [String]
+      # @param uppercase_first_letter [Boolean]
+      # @return [String]
+      def camelize(string, uppercase_first_letter: true)
+        string = string.to_s
+        string = if uppercase_first_letter
+                   string.sub(/^[a-z\d]*/, &:capitalize)
+                 else
+                   string.sub(/^(?:(?=\b|[A-Z_])|\w)/, &:downcase)
+                 end
+
+        string.gsub!(%r{(?:_|(/))([a-z\d]*)}) do
+          "#{::Regexp.last_match(1)}#{::Regexp.last_match(2).capitalize}"
+        end
+        string.gsub('/', '::')
+      end
+    end
+  end
+end

data/lib/amber_extension_generator/cli.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module ::AmberExtensionGenerator
+  # Contains all code which interacts with the terminal.
+  module CLI
+    class << self
+      def run
+        GemGenerator.call Args.parse
+      end
+    end
+  end
+end
+
+require_relative 'cli/args'
+require_relative 'cli/gem_generator'

data/lib/amber_extension_generator/gem_name.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module ::AmberExtensionGenerator
+  # @return [String]
+  GEM_NAME = 'amber_extension_generator'
+end

data/lib/amber_extension_generator/templates/assets/stylesheets/components.scss

@@ -0,0 +1,2 @@
+// This file imports all of your components' stylesheets
+

data/lib/amber_extension_generator/templates/assets/stylesheets/main.scss.erb

@@ -0,0 +1,6 @@
+// This is the main entry point for all your styles.
+// This file will be imported by the users of this gem,
+// so every stylesheet required by this gem should
+// be imported here.
+
+@import "<%= gem_name_path.basename %>/components";

data/lib/amber_extension_generator/templates/bin/dev.erb

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+
+BIN_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+
+echo "╔════════════════════════════════════╗"
+echo "║ Starting the development Rails App ║"
+echo "╚════════════════════════════════════╝"
+echo
+
+$BIN_DIR/../<%= rails_dummy_path %>/bin/rails server

data/lib/amber_extension_generator/templates/bin/generate.erb

@@ -0,0 +1,142 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'thor'
+require 'pathname'
+require 'fileutils'
+
+require_relative '../<%= gem_entry_folder_path %>'
+
+class ::GenerateCommand < ::Thor
+  include ::Thor::Actions
+
+  # @return [Module]
+  LIBRARY_MODULE = <%= root_module_name %>
+  # @return [String]
+  LIBRARY_NAME = '<%= gem_name %>'
+  # @return [Pathname]
+  ROOT_PATH = ::Pathname.new ::File.expand_path('..', __dir__)
+  # @return [Pathname]
+  GEM_ENTRY_FOLDER_PATH = ::Pathname.new '<%= gem_entry_folder_path %>'
+
+  class << self
+    # Define the generator's root folder
+    #
+    # @return [String]
+    def source_root
+      ::File.expand_path('..', __dir__)
+    end
+  end
+
+  desc 'component NAME', 'Generate a new component with the specified NAME'
+
+  # @param name [String]
+  # @return [void]
+  def component(name)
+    name = snake_case(name)
+    name = "#{name}_component" unless name.end_with? '_component'
+    @name = name
+
+    template 'templates/component.rb.tt', component_path
+    component_assets_path.mkdir unless component_assets_path.exist?
+
+    template 'templates/view.html.erb.tt', component_assets_path / 'view.html.erb'
+    template 'templates/style.scss.tt', component_assets_path / 'style.scss'
+    template 'templates/component_test.rb.tt', component_test_file_path
+
+    append_file main_components_stylesheet_path, %(\n@import "../../../#{component_assets_path}/style.scss";)
+  end
+
+  private
+
+  # @return [Pathname]
+  def component_test_file_path
+    components_test_folder_path / "#{@name}_test.rb"
+  end
+
+  # @return [Pathname]
+  def main_components_stylesheet_path
+    ROOT_PATH / 'assets' / 'stylesheets' / library_relative_path / 'components.scss'
+  end
+
+  # @return [Pathname]
+  def components_test_folder_path
+    ROOT_PATH / 'test' / library_relative_path / 'components'
+  end
+
+  # @return [Pathname]
+  def library_relative_path
+    @library_relative_path ||= ::Pathname.new LIBRARY_NAME.gsub('-', '/')
+  end
+
+  # @return [Pathname]
+  def component_assets_path
+    @component_assets_path ||= GEM_ENTRY_FOLDER_PATH / 'components' / @name
+  end
+
+  # @return [Pathname]
+  def component_path
+    @component_path ||= GEM_ENTRY_FOLDER_PATH / 'components' / file_name
+  end
+
+  # @return [String]
+  def full_class_name
+    "#{LIBRARY_MODULE}::#{class_name}"
+  end
+
+  # @return [String]
+  def component_css_class
+    "#{LIBRARY_NAME}--#{@name}"
+  end
+
+  # @return [String]
+  def class_name
+    @class_name ||= camelize(@name)
+  end
+
+  # @return [String]
+  def file_name
+    @file_name ||= "#{@name}.rb"
+  end
+
+  # @return [Class]
+  def abstract_component
+    LIBRARY_MODULE::ABSTRACT_COMPONENT
+  end
+
+  # Converts a string to camel/Pascal Case.
+  #
+  #     camelize('some_snake_case') #=> "SomeSnakeCase"
+  #     camelize('some/snake_case') #=> "Some::SnakeCase"
+  #
+  # @param string [String]
+  # @param uppercase_first_letter [Boolean]
+  # @return [String]
+  def camelize(string, uppercase_first_letter: true)
+    string = if uppercase_first_letter
+                string.sub(/^[a-z\d]*/, &:capitalize)
+              else
+                string.sub(/^(?:(?=\b|[A-Z_])|\w)/, &:downcase)
+              end
+
+    string.gsub!(%r{(?:_|(/))([a-z\d]*)}) do
+      "#{::Regexp.last_match(1)}#{::Regexp.last_match(2).capitalize}"
+    end
+    string.gsub('/', '::')
+  end
+
+  # Converts a string in PascalCase or camelCase to snake_case.
+  #
+  #     snake_case('SomePascalCase') => "some_pascal_case"
+  #     snake_case('Some::PascalCase') => "some/pascal_case"
+  #
+  # @param string [String]
+  # @return [String]
+  def snake_case(string)
+    string.gsub(/([^A-Z])([A-Z]+)/, '\1_\2')
+          .gsub(%r{::_|/_}, '/')
+          .downcase
+  end
+end
+
+::GenerateCommand.start

data/lib/amber_extension_generator/templates/components/base_component.rb.erb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'amber_component'
+
+module <%= root_module_name %>
+  # Abstract class which should serve as a superclass
+  # for all components.
+  #
+  # @abstract Subclass to create a new component.
+  class BaseComponent < ::AmberComponent::Base; end
+end

data/lib/amber_extension_generator/templates/components.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+require_relative 'components/base_component'
+::Dir[::File.expand_path('components/**/*.rb', __dir__)].sort.each { require_relative _1 }

data/lib/amber_extension_generator/templates/rails_dummy/Gemfile.erb

@@ -0,0 +1,33 @@
+# === GEM AUTO-RELOADING ===
+
+class ::ExtensionGem
+  # @return [String] Name of the gem.
+  attr_reader :name
+  # @return [Pathname] Path to the gem.
+  attr_reader :path
+  # @return [Array<Symbol>] Top-level constants defined by the gem.
+  attr_reader :constants
+  # @return [String]
+  attr_reader :require_path
+
+  # @param name [String]
+  # @param path [String, Pathname]
+  # @param constants [Array<Symbol>]
+  # @param require_path [String, nil]
+  def initialize(name:, path:, constants:, require_path: nil)
+    @name = name
+    @path = ::File.expand_path(path, __dir__)
+    @constants = constants
+    @require_path = require_path || @name.gsub('-', '/')
+  end
+end
+
+# @return [ExtensionGem]
+::AMBER_EXTENSION_GEM = ::ExtensionGem.new(
+  name: "<%= gem_name %>",
+  path: '..',
+  constants: %i[<%= root_module_name %>].freeze
+)
+gem ::AMBER_EXTENSION_GEM.name, path: ::AMBER_EXTENSION_GEM.path
+
+# === END GEM AUTO-RELOADING ===

data/lib/amber_extension_generator/templates/railtie.rb.erb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module <%= root_module_name %>
+  # Class which hooks into Rails
+  # and configures the application.
+  class Railtie < ::Rails::Railtie
+    initializer '<%= gem_name %>.assets' do |app|
+      (ROOT_PATH / 'assets').each_child do |asset_dir|
+        app.config.assets.paths << asset_dir.to_s
+      end
+    end
+  end
+end

data/lib/amber_extension_generator/templates/templates/component.rb.tt

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class <%= full_class_name %> < <%= abstract_component %>
+  # Props that your component accepts
+  prop :description, type: ::String, default: -> { 'Default Description' }
+
+  after_initialize do
+    # some initialization
+    @time = ::Time.now
+  end
+end

data/lib/amber_extension_generator/templates/templates/component_test.rb.tt

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class <%= full_class_name %>Test < ::ComponentTestCase
+  # For a full list of available assertions see
+  # https://rubydoc.info/github/jnicklas/capybara/Capybara/Node/Matchers
+
+  # def test_returns_correct_html
+  #   render do
+  #     <%= full_class_name %>.call
+  #   end
+  #
+  #   assert_text 'Hello from <%= full_class_name %>'
+  #   assert_selector "div.<%= component_css_class %> p", text: 'Default Description'
+  # end
+end