lumise 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d82dc3a5d42d401ae1bc2bf483c99dd2bc592431
+  data.tar.gz: 3ee4e2003df33f6e899476ee8c79b2cb565fc678
+SHA512:
+  metadata.gz: 032b661e3f4e3d87e8cbe7aca8c3271c00682fd7c7d0acdefeec896f0551e3f059ebc3c1c46ca511df93b489cc956abe4a84c9535425aa892d005740c2a66979
+  data.tar.gz: 3ff36cbaba6e560e538f1375a620585f5d84c8f098fceef515193af3f773703a19c344a0d291548518ae50652462197f18757f7af1c8a510dc39718b67cba8a7

data/exe/lumise

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/lumise'
+
+Signal.trap('INT') do
+  warn("\n#{caller.join("\n")}: interrupted")
+  exit(1)
+end
+
+begin
+  Lumise::CLI.start
+rescue Lumise::CLI::Error => e
+  puts "ERROR: #{e.message}"
+  exit 1
+end

data/lib/lumise/cli.rb

@@ -0,0 +1,31 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Lumise
+  class CLI < Thor
+    Error = Class.new(StandardError)
+
+    desc 'version', 'lumise version'
+    def version
+      $stdout.puts "v#{Lumise::VERSION}"
+    end
+    map %w[--version -v] => :version
+
+    desc 'rubocop', 'Set up rubocop'
+    method_option :help, aliases: '-h', type: :boolean,
+                         desc: 'Display usage information'
+    def rubocop(*)
+      if options[:help]
+        invoke :help, ['rubocop']
+      else
+        execute_rubocop
+      end
+    end
+
+    private
+
+    def execute_rubocop
+      Lumise::Commands::Rubocop.new(options).execute
+    end
+  end
+end

data/lib/lumise/cli.rbi

@@ -0,0 +1,28 @@
+# typed: strong
+# frozen_string_literal: true
+
+module Lumise
+  class CLI < Thor
+    sig do
+      params(
+        mappings: T::Hash[T.untyped, T.untyped]
+      ).void
+    end
+    def self.map(mappings)
+    end
+
+    sig { void }
+    def version
+    end
+
+    sig { params(arr: T.untyped).void }
+    def rubocop(*arr)
+    end
+
+    private
+
+    sig { void }
+    def execute_rubocop
+    end
+  end
+end

data/lib/lumise/command.rb

@@ -0,0 +1,8 @@
+# typed: strong
+# frozen_string_literal: true
+
+module Lumise
+  class Command
+    include Commands
+  end
+end

data/lib/lumise/commands/rubocop.rb

@@ -0,0 +1,56 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Lumise
+  module Commands
+    class Rubocop < Lumise::Command
+      include L
+
+      def initialize(_options)
+        verify_dependencies
+        @plugins = set_plugins
+      rescue Which::Curl::CurlError
+        logger.error 'Please install curl'
+      end
+
+      attr_reader :plugins
+
+      def execute
+        update_gems
+        create_files
+        update_todo
+      end
+
+      private
+
+      def set_plugins
+        l.plugins || prompt_plugins
+      end
+
+      def verify_dependencies
+        Which::Curl.call
+      end
+
+      def prompt_plugins
+        choices = %w[performance rails rspec sorbet]
+
+        prompt.multi_select 'Which plugins are you using?' do |menu|
+          menu.default 1, 3
+          menu.choices choices
+        end
+      end
+
+      def update_gems
+        UpdateGems.call plugins: plugins
+      end
+
+      def create_files
+        UpdateFiles.call plugins: plugins
+      end
+
+      def update_todo
+        UpdateTodo.call plugins: plugins
+      end
+    end
+  end
+end

data/lib/lumise/commands/rubocop.rbi

@@ -0,0 +1,48 @@
+# typed: strong
+# frozen_string_literal: true
+
+module Lumise
+  module Commands
+    class Rubocop < Lumise::Command
+      include L
+
+      sig { params(_options: T.untyped).void }
+      def initialize(_options)
+        @plugins = T.let nil, T::Array[String]
+      end
+
+      sig { returns T::Array[String] }
+      attr_reader :plugins
+
+      sig { void }
+      def execute
+      end
+
+      private
+
+      sig { returns T::Array[String] }
+      def set_plugins
+      end
+
+      sig { void }
+      def verify_dependencies
+      end
+
+      sig { returns T::Array[String] }
+      def prompt_plugins
+      end
+
+      sig { void }
+      def update_gems
+      end
+
+      sig { void }
+      def create_files
+      end
+
+      sig { void }
+      def update_todo
+      end
+    end
+  end
+end

data/lib/lumise/commands.rb

@@ -0,0 +1,36 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'tty-command'
+require 'tty-file'
+require 'tty-logger'
+require 'tty-prompt'
+require 'tty-which'
+
+module Lumise
+  module Commands
+    def command(options)
+      TTY::Command.new(options)
+    end
+
+    def generator
+      TTY::File
+    end
+
+    def logger
+      TTY::Logger.new
+    end
+
+    def prompt(**options)
+      TTY::Prompt.new(options)
+    end
+
+    def which(cmd)
+      TTY::Which.which(cmd)
+    end
+
+    def exec_exist?(cmd)
+      TTY::Which.exist?(cmd)
+    end
+  end
+end

data/lib/lumise/commands.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+# frozen_string_literal: true
+
+module Lumise
+  module Commands
+    sig { params(options: T.untyped).returns(TTY::Command) }
+    def command(options)
+    end
+
+    sig { returns(T.class_of(TTY::File)) }
+    def generator
+    end
+
+    sig { returns(TTY::Logger) }
+    def logger
+    end
+
+    sig { params(options: T::Hash[T.untyped, T.untyped]).returns TTY::Prompt }
+    def prompt(**options)
+    end
+
+    sig { params(cmd: String).returns T::Array[String] }
+    def which(cmd)
+    end
+
+    sig { params(cmd: String).returns T::Boolean }
+    def exec_exist?(cmd)
+    end
+  end
+end

data/lib/lumise/configurations.rb

@@ -0,0 +1,16 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Lumise
+  class Configurations < T::Struct
+    include Singleton
+
+    prop :force,        T::Boolean, default: false
+    prop :plugins,      T.nilable(T::Array[String])
+    prop :repo,         T.nilable(String)
+    prop :branch,       T.nilable(String)
+    prop :update_gems,  T.nilable(T::Boolean)
+    prop :update_files, T.nilable(T::Boolean)
+    prop :update_todo,  T.nilable(T::Boolean)
+  end
+end

data/lib/lumise/configurations.rbi

@@ -0,0 +1 @@
+# typed: strong

data/lib/lumise/error.rb

@@ -0,0 +1,6 @@
+# typed: strong
+# frozen_string_literal: true
+
+module Lumise
+  class Error < StandardError; end
+end

data/lib/lumise/l.rb

@@ -0,0 +1,10 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Lumise
+  module L
+    def l
+      Lumise::Configurations.instance
+    end
+  end
+end

data/lib/lumise/l.rbi

@@ -0,0 +1,10 @@
+# typed: strong
+# frozen_string_literal: true
+
+module Lumise
+  module L
+    sig { returns Configurations }
+    def l
+    end
+  end
+end

data/lib/lumise/logger.rb

@@ -0,0 +1,7 @@
+# typed: strong
+# frozen_string_literal: true
+
+module Lumise
+  class Logger < TTY::Logger
+  end
+end

data/lib/lumise/services/commands/rubocop/repo_files.rb

@@ -0,0 +1,56 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Lumise
+  module Commands
+    class Rubocop < Lumise::Command
+      class RepoFiles
+        include Commands
+        include L
+
+        def self.call
+          new.call
+        end
+
+        def call
+          remove_tmp_lumise
+          recreate_tmp_lumise
+          clone_repo_onto_tmp_lumise
+          rubocop_files
+        end
+
+        private
+
+        def rubocop_files
+          Dir['tmp/lumise/rubocop/**/{*,.*}']
+        end
+
+        def clone_repo_onto_tmp_lumise
+          command(printer: :null).run(git_clone_command) do |_out, err|
+            logger.info err.force_encoding(Encoding::UTF_8)
+          end
+        end
+
+        def git_clone_command
+          "git clone --single-branch --branch #{branch} #{repo} tmp/lumise"
+        end
+
+        def repo
+          T.must(l.repo)
+        end
+
+        def branch
+          l.branch || 'master'
+        end
+
+        def recreate_tmp_lumise
+          command(printer: :quiet).run('mkdir -p tmp/lumise')
+        end
+
+        def remove_tmp_lumise
+          command(printer: :quiet).run('rm -rf tmp/lumise')
+        end
+      end
+    end
+  end
+end

data/lib/lumise/services/commands/rubocop/repo_files.rbi

@@ -0,0 +1,51 @@
+# typed: strong
+# frozen_string_literal: true
+
+module Lumise
+  module Commands
+    class Rubocop < Lumise::Command
+      class RepoFiles
+        include Commands
+        include L
+
+        sig { returns T::Array[String] }
+        def self.call
+        end
+
+        sig { returns T::Array[String] }
+        def call
+        end
+
+        private
+
+        sig { returns T::Array[String] }
+        def rubocop_files
+        end
+
+        sig { void }
+        def clone_repo_onto_tmp_lumise
+        end
+
+        sig { returns String }
+        def git_clone_command
+        end
+
+        sig { returns String }
+        def repo
+        end
+
+        sig { returns String }
+        def branch
+        end
+
+        sig { void }
+        def recreate_tmp_lumise
+        end
+
+        sig { void }
+        def remove_tmp_lumise
+        end
+      end
+    end
+  end
+end

data/lib/lumise/services/commands/rubocop/update_files.rb

@@ -0,0 +1,87 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Lumise
+  module Commands
+    class Rubocop < Lumise::Command
+      class UpdateFiles
+        include Commands
+        include L
+
+        def self.call(plugins:)
+          new(plugins: plugins).send :perform
+        end
+
+        def initialize(plugins:)
+          @plugins = plugins
+        end
+
+        private
+
+        attr_reader :plugins
+
+        def perform
+          if yes?
+            files.each do |file|
+              parse_template file
+            end
+          end
+        end
+
+        def parse_template(file)
+          generator.create_file File.basename(file), mustacho(file),
+                                force: l.force
+        end
+
+        def mustacho(file)
+          Mustache.render File.read(file),
+                          require: plugins?, plugins: plugins_list,
+                          rspec: plugins.include?('rspec'),
+                          sorbet: plugins.include?('sorbet')
+        end
+
+        def plugins_list
+          plugins.map do |plugin|
+            "  - rubocop-#{plugin}"
+          end.join("\n")
+        rescue NoMethodError
+          []
+        end
+
+        def files
+          if l.repo
+            repo_files
+          else
+            template_files
+          end
+        end
+
+        def template_files
+          Dir[templates_path + '**/{*,.*}'].reject do |file|
+            file.scan(/\.$/).first
+          end
+        end
+
+        def repo_files
+          RepoFiles.call
+        end
+
+        def templates_path
+          File.expand_path('../../../templates/rubocop', __dir__)
+        end
+
+        def plugins?
+          !plugins&.first.nil?
+        end
+
+        def yes?
+          if l.update_files.nil?
+            prompt.yes? 'Update .rubocop files?', suffix: 'Yeah/nah'
+          else
+            l.update_files
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lumise/services/commands/rubocop/update_files.rbi

@@ -0,0 +1,67 @@
+# typed: strong
+# frozen_string_literal: true
+
+module Lumise
+  module Commands
+    class Rubocop < Lumise::Command
+      class UpdateFiles
+        include Commands
+        include L
+
+        sig { params(plugins: T::Array[String]).void }
+        def self.call(plugins:)
+        end
+
+        sig { params(plugins: T::Array[String]).void }
+        def initialize(plugins:)
+          @plugins = plugins
+        end
+
+        private
+
+        sig { returns T::Array[String] }
+        attr_reader :plugins
+
+        sig { void }
+        def perform
+        end
+
+        sig { params(file: T.any(String, Pathname)).void }
+        def parse_template(file)
+        end
+
+        sig { params(file: T.any(File, String, Pathname)).returns String }
+        def mustacho(file)
+        end
+
+        sig { returns T.any(T::Array[T.untyped], String) }
+        def plugins_list
+        end
+
+        sig { returns(T::Array[String]) }
+        def files
+        end
+
+        sig { returns T::Array[String] }
+        def template_files
+        end
+
+        sig { returns T::Array[String] }
+        def repo_files
+        end
+
+        sig { returns(String) }
+        def templates_path
+        end
+
+        sig { returns(T::Boolean) }
+        def plugins?
+        end
+
+        sig { returns(T::Boolean) }
+        def yes?
+        end
+      end
+    end
+  end
+end

data/lib/lumise/services/commands/rubocop/update_gems.rb

@@ -0,0 +1,64 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Lumise
+  module Commands
+    class Rubocop < Lumise::Command
+      class UpdateGems
+        include Commands
+        include L
+
+        def self.call(plugins:)
+          new(plugins: plugins).send :perform
+        end
+
+        def initialize(plugins:)
+          @plugins = plugins
+        end
+
+        private
+
+        attr_reader :plugins
+
+        def perform
+          if yes?
+            logger.info "#Running #{bundle_update_command}"
+            bundle_update
+          end
+        end
+
+        def bundle_update
+          command(printer: :quiet).run(bundle_update_command)
+        rescue TTY::Command::ExitError, StandardError => e
+          # Could not find gem 'rubocop'.
+          #
+          # Could not locate Gemfile
+          #
+          # This Bundle hasn't been installed yet. Run `bundle install` to
+          # update and install the bundled gems.
+
+          logger.error e.message
+          exit 1
+        end
+
+        def yes?
+          if l.update_gems.nil?
+            prompt.yes? 'Update rubocop gems?', suffix: 'Yeah/nah'
+          else
+            l.update_gems
+          end
+        end
+
+        def bundle_update_command
+          "bundle update --conservative rubocop #{gems}"
+        end
+
+        def gems
+          plugins.map do |plugin|
+            'rubocop-' + plugin
+          end.join(' ')
+        end
+      end
+    end
+  end
+end

data/lib/lumise/services/commands/rubocop/update_gems.rbi

@@ -0,0 +1,47 @@
+# typed: strong
+# frozen_string_literal: true
+
+module Lumise
+  module Commands
+    class Rubocop < Lumise::Command
+      class UpdateGems
+        include Commands
+        include L
+
+        sig { params(plugins: T::Array[String]).void }
+        def self.call(plugins:)
+        end
+
+        sig { params(plugins: T::Array[String]).void }
+        def initialize(plugins:)
+          @plugins = plugins
+        end
+
+        private
+
+        sig { returns T::Array[String] }
+        attr_reader :plugins
+
+        sig { void }
+        def perform
+        end
+
+        sig { void }
+        def bundle_update
+        end
+
+        sig { returns T::Boolean }
+        def yes?
+        end
+
+        sig { returns String }
+        def bundle_update_command
+        end
+
+        sig { returns String }
+        def gems
+        end
+      end
+    end
+  end
+end