tty 0.7.0 → 0.8.0

data/lib/tty/commands/new.rb

@@ -0,0 +1,256 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'pastel'
+require 'pathname'
+require 'ostruct'
+
+require_relative '../cmd'
+require_relative '../gemspec'
+require_relative '../licenses'
+require_relative '../plugins'
+require_relative '../templater'
+require_relative '../version'
+
+
+module TTY
+  module Commands
+    # The `new` command
+    #
+    # @api private
+    class New < TTY::Cmd
+      include TTY::Licenses
+
+      GEMSPEC_PATH = Pathname(__dir__).join('../../../tty.gemspec').realpath.to_s
+
+      # @api private
+      attr_reader :app_name
+
+      attr_reader :app_path
+
+      # @api private
+      attr_reader :options
+
+      # @api private
+      attr_reader :target_path
+
+      attr_reader :templates
+
+      def initialize(app_path, options)
+        @app_path = relative_path_from(root_path, app_path)
+        @app_name = name_from_path(app_path)
+        @options  = options
+        @pastel   = Pastel.new(enabled: !options['no-color'])
+
+        @target_path = root_path.join(@app_path)
+        @templater = Templater.new('new', @app_path)
+        @runner = command(printer: :null)
+      end
+
+      def git_exist?
+        exec_exist?('git')
+      end
+
+      def git_author
+        git_exist? ? `git config user.name`.chomp : ''
+      end
+
+      def author
+        if !Array(options['author']).empty?
+          options['author'].join(', ')
+        elsif !git_author.empty?
+          git_author
+        else
+          'TODO: Write your name'
+        end
+      end
+
+      def namespaced_path
+        app_name.tr('-', '/')
+      end
+
+      def underscored_name
+        app_name.tr('-', '_')
+      end
+
+      def constantinized_name
+        constantinize(app_name)
+      end
+
+      def template_context
+        opts = OpenStruct.new
+        opts[:app_name] = app_name
+        opts[:author]   = author
+        opts[:namespaced_path]  = namespaced_path
+        opts[:underscored_name] = underscored_name
+        opts[:constantinized_name] = constantinized_name
+        opts[:constantinized_parts] = constantinized_name.split('::')
+        opts[:indent] = '  ' * constantinized_name.split('::').size
+        opts
+      end
+
+      def file_options
+        opts = {}
+        opts[:force] = true if options['force']
+        opts[:color] = false if options['no-color']
+        opts
+      end
+
+      def gemspec_name
+        "#{app_name}.gemspec"
+      end
+
+      def gemspec_path
+        target_path.join("#{app_name}.gemspec").to_s
+      end
+
+      # Execute the command
+      #
+      # @api public
+      def execute(input: $stdin, output: $stdout)
+        output.puts "OPTS: #{options}" if options['debug']
+
+        coc_opt  = options['coc'] ? '--coc' : '--no-coc'
+        ext_opt  = options['ext'] ? '--ext' : '--no-ext'
+        test_opt = options['test']
+        command = [
+          "bundle gem #{target_path}",
+          '--no-mit',
+          '--no-exe',
+          coc_opt,
+          ext_opt,
+          "-t #{test_opt}"
+        ].join(' ')
+
+        install_info = []
+
+        @runner.run(command) do |out, err|
+          next unless out
+          out.each_line do |line|
+            if line =~ /^Initializing git/
+              install_info << line.dup
+              next
+            elsif line =~ /^(Gem.*?was successfully created)/
+              next
+            end
+
+            if !options['no-color']
+              output.puts color_actions(line)
+            else
+              output.puts line
+            end
+          end
+        end
+
+        add_app_templates
+        add_empty_directories
+        add_required_libs_to_gemspec
+        @templater.generate(template_context, file_options)
+        make_executable
+        output.puts install_info.join("\n") unless install_info.empty?
+
+        output.puts "\n" + @pastel.green("Your teletype project has been created successfully.")
+        output.puts "\n" + @pastel.green("Run \"teletype help\" for more commands.\n")
+      end
+
+      private
+
+      def color_actions(out)
+        out.gsub(/^(\s+)(create)/, '\1' + @pastel.green('\2'))
+           .gsub(/^(\s+)(identical)/, '\1' + @pastel.blue('\2'))
+           .gsub(/^(\s+)(conflict)/, '\1' + @pastel.red('\2'))
+           .gsub(/^(\s+)(forced|skipped)/, '\1' + @pastel.yellow('\2'))
+      end
+
+      def make_executable
+        exec_path = target_path.join("exe/#{app_name}")
+        exec_path.chmod(exec_path.stat.mode | 0o111)
+      end
+
+      def add_app_templates
+        @templater.add_mapping('lib/newcli/cli.rb.tt',
+                               "lib/#{namespaced_path}/cli.rb")
+        @templater.add_mapping('lib/newcli/command.rb.tt',
+                               "lib/#{namespaced_path}/command.rb")
+        @templater.add_mapping('exe/newcli.tt', "exe/#{app_name}")
+
+        license = options['license'] == 'none' ? false : options['license']
+        if license
+          @templater.add_mapping("#{license}_LICENSE.txt.tt", 'LICENSE.txt')
+          add_license_to_gemspec(license)
+          add_license_to_readme(license)
+        end
+      end
+
+      def test_dir
+        options['test'] == 'rspec' ? 'spec' : 'test'
+      end
+
+      def add_empty_directories
+        @templater.add_mapping('gitkeep.tt', "lib/#{namespaced_path}/commands/.gitkeep")
+        @templater.add_mapping('gitkeep.tt', "lib/#{namespaced_path}/templates/.gitkeep")
+        @templater.add_mapping('gitkeep.tt', "#{test_dir}/integration/.gitkeep")
+        @templater.add_mapping('gitkeep.tt', "#{test_dir}/support/.gitkeep")
+        @templater.add_mapping('gitkeep.tt', "#{test_dir}/unit/.gitkeep")
+      end
+
+      # Add license definition to gemspec
+      #
+      # @api private
+      def add_license_to_gemspec(license)
+        gemspec = TTY::Gemspec.new
+        gemspec.read(gemspec_path)
+        license_regex = /(^\s*#{gemspec.var_name}\.license\s*=\s*).*/
+
+        if gemspec.content =~ license_regex
+          gemspec.content.gsub!(liecense_regex,
+                                "\\1\"#{licenses[license][:name]}\"")
+        else
+          gem_license = ' ' * gemspec.pre_var_indent
+          gem_license << "#{gemspec.var_name}.license"
+          gem_license << ' ' * (gemspec.post_var_indent - '.license'.size)
+          gem_license << "= \"#{licenses[license][:name]}\""
+          gemspec.content.gsub!(/(^\s*#{gemspec.var_name}\.name\s*=\s*.*$)/,
+                                "\\1\n#{gem_license}")
+        end
+        gemspec.write(gemspec_path)
+      end
+
+      def add_license_to_readme(license)
+        desc = licenses[license][:desc]
+        readme_path = Dir["#{app_path}/README*"].first
+        content = "\n## Copyright\n\n" \
+                  "Copyright (c) #{Time.now.year} #{author}. "\
+                  "See [#{desc}](LICENSE.txt) for further details."
+        within_root_path do
+          generator.append_to_file(readme_path, content, file_options)
+        end
+      end
+
+      def add_required_libs_to_gemspec
+        gemspec = TTY::Gemspec.new
+        gemspec.read(gemspec_path)
+        dependencies = ['']
+        plugins = TTY::Plugins.new
+        plugins.load_from(GEMSPEC_PATH, /^tty-(.*)|pastel|thor/)
+
+        plugins.each do |plugin|
+          dependency = ' ' * gemspec.pre_var_indent
+          dependency << "#{gemspec.var_name}.add_dependency "
+          dependency << "\"#{plugin.gem.name}\", "
+          dependency << "\"#{plugin.gem.requirements_list.join(', ')}\""
+          dependencies << dependency.dup
+        end
+        dependencies << '' # add extra line
+        content = dependencies.join("\n")
+
+        within_root_path do
+          path = app_path.join(gemspec_name)
+          generator.inject_into_file(path, content,
+            { before: /^\s*spec\.add_development_dependency\s*"bundler.*$/ }
+            .merge(file_options))
+        end
+      end
+    end # New
+  end # Commands
+end # TTY

data/lib/tty/gemspec.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module TTY
+  class Gemspec
+    # The gemspec content
+    attr_accessor :content
+
+    # The gemspec variable name
+    attr_accessor :var_name
+
+    # The gemspec indentation before variable name
+    attr_accessor :pre_var_indent
+
+    # The gemspec indentation size afater variable name
+    attr_accessor :post_var_indent
+
+    def read(path)
+      self.content = ::File.read(path.to_s)
+      self.var_name = content.match(/(\w+)\.name/)[1]
+      matches = content.match(/^(\s*)#{var_name}(\.name\s*)=.*$/)
+      self.pre_var_indent  = matches[1].size
+      self.post_var_indent = matches[2].size
+    end
+
+    def write(path)
+      ::File.write(path, content)
+    end
+  end # Gemspec
+end # TTY

data/lib/tty/licenses.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+module TTY
+  module Licenses
+    CUSTOM = 'custom'.freeze
+
+    LICENSES = {
+      'agplv3' => { name: 'AGPL-3.0',
+                    desc: 'GNU Affero General Public License v3.0' },
+      'apache' => { name: 'Apache-2.0', desc: 'Apache License 2.0' },
+      'bsd2'   => { name: 'BSD-2-Clause',
+                    desc: 'BSD 2-Clause License (FreeBSD/Simplified)'},
+      'bsd3'   => { name: 'BSD-3-Clause',
+                    desc: 'BSD 3-Clause License (Revised)'},
+      'gplv2'  => { name: 'GPL-2.0',
+                    desc: 'GNU General Public License v2.0' },
+      'gplv3'  => { name: 'GPL-3.0',
+                    desc: 'GNU General Public License v3.0' },
+      'lgplv3' => { name: 'LGPL-3.0',
+                    desc: 'GNU Lesser General Public License v3.0' },
+      'mit'    => { name: 'MIT', desc: 'MIT License' },
+      'mplv2'  => { name: 'MPL-2.0', desc: 'Mozilla Public License 2.0' }
+    }.freeze
+
+    def licenses
+      LICENSES
+    end
+
+    def license_identifiers
+      licenses.values.map { |key, val| val if key == :name }
+    end
+  end # Licenses
+end # TTY

data/lib/tty/path_helpers.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+module TTY
+  module PathHelpers
+    # The root path of the app running this command
+    #
+    # @return [Pathname]
+    #
+    # @api public
+    def root_path
+      @root_path ||= Pathname.pwd
+    end
+
+    # Execute command within root path
+    #
+    # @api public
+    def within_root_path(&block)
+      Dir.chdir(root_path, &block)
+    end
+
+    # Extract name from a path
+    #
+    # @api public
+    def name_from_path(path)
+      Pathname(path).basename.to_s
+    end
+
+    # Extract a relative path for the app
+    #
+    # @api private
+    def relative_path_from(root_path, path)
+      project_path = Pathname.new(path)
+      return project_path if project_path.relative?
+      project_path.relative_path_from(root_path)
+    end
+  end # PathHelpers
+end # TTY

data/lib/tty/plugins.rb

@@ -1,5 +1,7 @@
 # encoding: utf-8
 
+require_relative 'plugins/plugin'
+
 module TTY
   # A class responsible for managing plugins installation
   class Plugins
@@ -39,28 +41,34 @@ module TTY
       @plugins << plugin
     end
 
-    # Find all installed TTY plugins and store them
+    # Loads gemspec from a file and registers gems matching pattern.
     #
-    # @param [String] :lib_name
+    # @param [String|Pathname] gemspec_path
+    #   the path to gemspec
+    # @param [Regex] pattern
+    #   the pattern to match gems by
     #
-    # @return [self]
+    # @example
+    #   plugins.load_from('foo.gemspec', /tty-(.*)/)
     #
-    # @api private
-    def find(lib_name = 'tty')
+    # @api public
+    def load_from(gemspec_path, pattern)
       Gem.refresh
-      spec = Gem::Specification.find_by_name(lib_name)
-      spec.runtime_dependencies.each do |gem|
-        next unless gem.name =~ /^#{lib_name}/
-        plugin_name = gem.name[/^#{lib_name}-(.*)/]
-        register(plugin_name, Plugin.new(plugin_name, gem))
+      spec = Gem::Specification.load(gemspec_path)
+      dependencies = spec.runtime_dependencies.concat(spec.development_dependencies)
+      dependencies.each do |gem|
+        gem_name = gem.name[pattern]
+        next if gem_name.to_s.empty?
+        register(gem_name, Plugin.new(gem_name, gem))
       end
       self
     end
 
-    # Load all plugins that are not enabled
+    # Activate all registered plugins that are not already enabled and
+    # add lib paths to $LOAD_PATH.
     #
     # @api public
-    def load
+    def activate
       plugins.each do |plugin|
         plugin.load! unless plugin.enabled?
       end

data/lib/tty/templater.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+require 'tty-file'
+
+require_relative 'path_helpers'
+
+module TTY
+  class Templater
+    include PathHelpers
+
+    attr_reader :templates
+
+    def initialize(source_path, target_path)
+      @source_path = templates_root_path.join(source_path)
+      @target_path = target_path
+      @templates = []
+    end
+
+    # The root path for all the templates
+    #
+    # @api public
+    def templates_root_path
+      Pathname(__dir__).join('templates')
+    end
+
+    # Add mapping to templates
+    #
+    # @param [String] source
+    #   the source template location
+    # @param [String] target
+    #   the target template location
+    #
+    # @api public
+    def add_mapping(source, target)
+      @templates << [source, target]
+    end
+
+    # Process templates by injecting vars and moving to location
+    #
+    # @api private
+    def generate(template_options, color_option)
+      templates.each do |src, dst|
+        source      = @source_path.join(src)
+        destination = @target_path.join(dst).to_s
+        next unless ::File.exist?(source)
+        within_root_path do
+          TTY::File.copy_file(source, destination,
+                    { context: template_options }.merge(color_option))
+        end
+      end
+    end
+  end # Templater
+end # TTY