pantograph 0.1.0

data/pantograph/lib/pantograph/plugins/plugin_info_collector.rb

@@ -0,0 +1,159 @@
+module Pantograph
+  class PluginInfoCollector
+    def initialize(ui = PluginGeneratorUI.new)
+      @ui = ui
+    end
+
+    def collect_info(initial_name = nil)
+      plugin_name = collect_plugin_name(initial_name)
+      author = collect_author(detect_author)
+      email = collect_email(detect_email)
+      summary = collect_summary
+      details = collect_details
+
+      PluginInfo.new(plugin_name, author, email, summary, details)
+    end
+
+    #
+    # Plugin name
+    #
+
+    def collect_plugin_name(initial_name = nil)
+      plugin_name = initial_name
+      first_try = true
+
+      loop do
+        if !first_try || plugin_name.to_s.empty?
+          plugin_name = @ui.input("What would you like to be the name of your plugin?")
+        end
+        first_try = false
+
+        unless plugin_name_valid?(plugin_name)
+          fixed_name = fix_plugin_name(plugin_name)
+
+          if plugin_name_valid?(fixed_name)
+            plugin_name = fixed_name if @ui.confirm("\nWould '#{fixed_name}' be okay to use for your plugin name?")
+          end
+        end
+
+        break if plugin_name_valid?(plugin_name)
+
+        gem_name = PluginManager.to_gem_name(plugin_name)
+
+        if gem_name_taken?(gem_name)
+          # Gem name is already taken on RubyGems
+          @ui.message("\nThe gem name '#{gem_name}' is already taken on RubyGems, please choose a different plugin name.")
+        else
+          # That's a naming error
+          @ui.message("\nPlugin names can only contain lower case letters, numbers, and underscores")
+          @ui.message("and should not contain 'pantograph' or 'plugin'.")
+        end
+      end
+
+      plugin_name
+    end
+
+    def plugin_name_valid?(name)
+      # Only lower case letters, numbers and underscores allowed
+      /^[a-z0-9_]+$/ =~ name &&
+        # Does not contain the words 'pantograph' or 'plugin' since those will become
+        # part of the gem name
+        [/pantograph/, /plugin/].none? { |regex| regex =~ name } &&
+        # Gem name isn't taken on RubyGems yet
+        !gem_name_taken?(PluginManager.to_gem_name(name))
+    end
+
+    # Checks if the gem name is still free on RubyGems
+    def gem_name_taken?(name)
+      require 'open-uri'
+      require 'json'
+      url = "https://rubygems.org/api/v1/gems/#{name}.json"
+      response = JSON.parse(open(url).read)
+      return !!response['version']
+    rescue
+      false
+    end
+
+    # Applies a series of replacement rules to turn the requested plugin name into one
+    # that is acceptable, returning that suggestion
+    def fix_plugin_name(name)
+      name = name.to_s.downcase
+      fixes = {
+        /[\- ]/ => '_', # dashes and spaces become underscores
+        /[^a-z0-9_]/ => '', # anything other than lower case letters, numbers and underscores is removed
+        /pantograph[_]?/ => '', # 'pantograph' or 'pantograph_' is removed
+        /plugin[_]?/ => '' # 'plugin' or 'plugin_' is removed
+      }
+      fixes.each do |regex, replacement|
+        name = name.gsub(regex, replacement)
+      end
+      name
+    end
+
+    #
+    # Author
+    #
+
+    def detect_author
+      git_name = Helper.backticks('git config --get user.name', print: PantographCore::Globals.verbose?).strip
+      return git_name.empty? ? nil : git_name
+    end
+
+    def collect_author(initial_author = nil)
+      return initial_author if author_valid?(initial_author)
+      author = nil
+      loop do
+        author = @ui.input("What is the plugin author's name?")
+        break if author_valid?(author)
+
+        @ui.message('An author name is required.')
+      end
+
+      author
+    end
+
+    def author_valid?(author)
+      !author.to_s.strip.empty?
+    end
+
+    #
+    # Email
+    #
+
+    def detect_email
+      git_email = Helper.backticks('git config --get user.email', print: PantographCore::Globals.verbose?).strip
+      return git_email.empty? ? nil : git_email
+    end
+
+    def collect_email(initial_email = nil)
+      return initial_email || @ui.input("What is the plugin author's email address?")
+    end
+
+    #
+    # Summary
+    #
+
+    def collect_summary
+      summary = nil
+      loop do
+        summary = @ui.input("Please enter a short summary of this pantograph plugin:")
+        break if summary_valid?(summary)
+
+        @ui.message('A summary is required.')
+      end
+
+      summary
+    end
+
+    def summary_valid?(summary)
+      !summary.to_s.strip.empty?
+    end
+    #
+    # Summary
+    #
+
+    def collect_details
+      return @ui.input("Please enter a detailed description of this pantograph plugin:").to_s
+    end
+  end
+end

data/pantograph/lib/pantograph/plugins/plugin_manager.rb

@@ -0,0 +1,387 @@
+require "pantograph/cli_tools_distributor"
+
+module Pantograph
+  class PluginManager
+    require "bundler"
+
+    PLUGINFILE_NAME = "Pluginfile".freeze
+    DEFAULT_GEMFILE_PATH = "Gemfile".freeze
+    AUTOGENERATED_LINE = "# Autogenerated by pantograph\n#\n# Ensure this file is checked in to source control!\n\n"
+    GEMFILE_SOURCE_LINE = "source \"https://rubygems.org\"\n"
+    PANTOGRAPH_PLUGIN_PREFIX = "pantograph-plugin-"
+    TROUBLESHOOTING_URL = "https://docs.pantograph.tools/plugins/plugins-troubleshooting/"
+
+    #####################################################
+    # @!group Reading the files and their paths
+    #####################################################
+
+    def gemfile_path
+      # This is pretty important, since we don't know what kind of
+      # Gemfile the user has (e.g. Gemfile, gems.rb, or custom env variable)
+      Bundler::SharedHelpers.default_gemfile.to_s
+    rescue Bundler::GemfileNotFound
+      nil
+    end
+
+    def pluginfile_path
+      if PantographCore::PantographFolder.path
+        return File.join(PantographCore::PantographFolder.path, PLUGINFILE_NAME)
+      else
+        return nil
+      end
+    end
+
+    def gemfile_content
+      File.read(gemfile_path) if gemfile_path && File.exist?(gemfile_path)
+    end
+
+    def pluginfile_content
+      File.read(pluginfile_path) if pluginfile_path && File.exist?(pluginfile_path)
+    end
+
+    #####################################################
+    # @!group Helpers
+    #####################################################
+
+    def self.plugin_prefix
+      PANTOGRAPH_PLUGIN_PREFIX
+    end
+
+    def self.to_gem_name(plugin_name)
+      plugin_name.start_with?(plugin_prefix) ? plugin_name : (plugin_prefix + plugin_name)
+    end
+
+    # Returns an array of gems that are added to the Gemfile or Pluginfile
+    def available_gems
+      return [] unless gemfile_path
+      dsl = Bundler::Dsl.evaluate(gemfile_path, nil, true)
+      return dsl.dependencies.map(&:name)
+    end
+
+    # Returns an array of pantograph plugins that are added to the Gemfile or Pluginfile
+    # The returned array contains the string with their prefixes (e.g. pantograph-plugin-xcversion)
+    def available_plugins
+      available_gems.keep_if do |current|
+        current.start_with?(self.class.plugin_prefix)
+      end
+    end
+
+    # Check if a plugin is added as dependency to either the
+    # Gemfile or the Pluginfile
+    def plugin_is_added_as_dependency?(plugin_name)
+      UI.user_error!("pantograph plugins must start with '#{self.class.plugin_prefix}' string") unless plugin_name.start_with?(self.class.plugin_prefix)
+      return available_plugins.include?(plugin_name)
+    end
+
+    #####################################################
+    # @!group Modifying dependencies
+    #####################################################
+
+    def add_dependency(plugin_name)
+      UI.user_error!("pantograph is not setup for this project, make sure you have a pantograph folder") unless pluginfile_path
+      plugin_name = self.class.plugin_prefix + plugin_name unless plugin_name.start_with?(self.class.plugin_prefix)
+
+      if plugin_name.gsub(self.class.plugin_prefix, '').include?("-")
+        # e.g. "pantograph-plugin-ya_tu-sabes" (which is invalid)
+        UI.user_error!("Plugin name must not contain a '-', did you mean '_'?")
+      end
+
+      unless plugin_is_added_as_dependency?(plugin_name)
+        content = pluginfile_content || AUTOGENERATED_LINE
+
+        unless content.end_with?("\n")
+          content += "\n"
+        end
+
+        line_to_add = "gem '#{plugin_name}'"
+        line_to_add += gem_dependency_suffix(plugin_name)
+        UI.verbose("Adding line: #{line_to_add}")
+
+        content += "#{line_to_add}\n"
+        File.write(pluginfile_path, content)
+        UI.success("Plugin '#{plugin_name}' was added to '#{pluginfile_path}'")
+      end
+
+      # We do this *after* creating the Plugin file
+      # Since `bundle exec` would be broken if something fails on the way
+      ensure_plugins_attached!
+
+      true
+    end
+
+    # Get a suffix (e.g. `path` or `git` for the gem dependency)
+    def gem_dependency_suffix(plugin_name)
+      return "" unless self.class.fetch_gem_info_from_rubygems(plugin_name).nil?
+
+      selection_git_url = "Git URL"
+      selection_path = "Local Path"
+      selection_rubygems = "RubyGems.org ('#{plugin_name}' seems to not be available there)"
+      selection_gem_server = "Other Gem Server"
+      selection = UI.select(
+        "Seems like the plugin is not available on RubyGems, what do you want to do?",
+        [selection_git_url, selection_path, selection_rubygems, selection_gem_server]
+      )
+
+      if selection == selection_git_url
+        git_url = UI.input('Please enter the URL to the plugin, including the protocol (e.g. https:// or git://)')
+        return ", git: '#{git_url}'"
+      elsif selection == selection_path
+        path = UI.input('Please enter the relative path to the plugin you want to use. It has to point to the directory containing the .gemspec file')
+        return ", path: '#{path}'"
+      elsif selection == selection_rubygems
+        return ""
+      elsif selection == selection_gem_server
+        source_url = UI.input('Please enter the gem source URL which hosts the plugin you want to use, including the protocol (e.g. https:// or git://)')
+        return ", source: '#{source_url}'"
+      else
+        UI.user_error!("Unknown input #{selection}")
+      end
+    end
+
+    # Modify the user's Gemfile to load the plugins
+    def attach_plugins_to_gemfile!(path_to_gemfile)
+      content = gemfile_content || (AUTOGENERATED_LINE + GEMFILE_SOURCE_LINE)
+
+      # We have to make sure pantograph is also added to the Gemfile, since we now use
+      # bundler to run pantograph
+      content += "\ngem 'pantograph'\n" unless available_gems.include?('pantograph')
+      content += "\n#{self.class.code_to_attach}\n"
+
+      File.write(path_to_gemfile, content)
+    end
+
+    #####################################################
+    # @!group Accessing RubyGems
+    #####################################################
+
+    def self.fetch_gem_info_from_rubygems(gem_name)
+      require 'open-uri'
+      require 'json'
+      url = "https://rubygems.org/api/v1/gems/#{gem_name}.json"
+      begin
+        JSON.parse(open(url).read)
+      rescue
+        nil
+      end
+    end
+
+    #####################################################
+    # @!group Installing and updating dependencies
+    #####################################################
+
+    # Warning: This will exec out
+    # This is necessary since the user might be prompted for their password
+    def install_dependencies!
+      # Using puts instead of `UI` to have the same style as the `echo`
+      puts("Installing plugin dependencies...")
+      ensure_plugins_attached!
+      with_clean_bundler_env do
+        cmd = "bundle install"
+        cmd << " --quiet" unless PantographCore::Globals.verbose?
+        cmd << " && echo 'Successfully installed plugins'"
+        UI.command(cmd) if PantographCore::Globals.verbose?
+        exec(cmd)
+      end
+    end
+
+    # Warning: This will exec out
+    # This is necessary since the user might be prompted for their password
+    def update_dependencies!
+      puts("Updating plugin dependencies...")
+      ensure_plugins_attached!
+      plugins = available_plugins
+      if plugins.empty?
+        UI.user_error!("No plugins are installed")
+      end
+      with_clean_bundler_env do
+        cmd = "bundle update"
+        cmd << " #{plugins.join(' ')}"
+        cmd << " --quiet" unless PantographCore::Globals.verbose?
+        cmd << " && echo 'Successfully updated plugins'"
+        UI.command(cmd) if PantographCore::Globals.verbose?
+        exec(cmd)
+      end
+    end
+
+    def with_clean_bundler_env
+      # There is an interesting problem with using exec to call back into Bundler
+      # The `bundle ________` command that we exec, inherits all of the Bundler
+      # state we'd already built up during this run. That was causing the command
+      # to fail, telling us to install the Gem we'd just introduced, even though
+      # that is exactly what we are trying to do!
+      #
+      # Bundler.with_clean_env solves this problem by resetting Bundler state before the
+      # exec'd call gets merged into this process.
+
+      Bundler.with_clean_env do
+        yield if block_given?
+      end
+    end
+
+    #####################################################
+    # @!group Initial setup
+    #####################################################
+
+    def setup
+      UI.important("It looks like pantograph plugins are not yet set up for this project.")
+
+      path_to_gemfile = gemfile_path || DEFAULT_GEMFILE_PATH
+
+      if gemfile_content.to_s.length > 0
+        UI.important("pantograph will modify your existing Gemfile at path '#{path_to_gemfile}'")
+      else
+        UI.important("pantograph will create a new Gemfile at path '#{path_to_gemfile}'")
+      end
+
+      UI.important("This change is necessary for pantograph plugins to work")
+
+      unless UI.confirm("Should pantograph modify the Gemfile at path '#{path_to_gemfile}' for you?")
+        UI.important("Please add the following code to '#{path_to_gemfile}':")
+        puts("")
+        puts(self.class.code_to_attach.magenta) # we use `puts` instead of `UI` to make it easier to copy and paste
+        UI.user_error!("Please update '#{path_to_gemfile} and run pantograph again")
+      end
+
+      attach_plugins_to_gemfile!(path_to_gemfile)
+      UI.success("Successfully modified '#{path_to_gemfile}'")
+    end
+
+    # The code required to load the Plugins file
+    def self.code_to_attach
+      if PantographCore::PantographFolder.path
+        pantograph_folder_name = File.basename(PantographCore::PantographFolder.path)
+      else
+        pantograph_folder_name = "pantograph"
+      end
+      "plugins_path = File.join(File.dirname(__FILE__), '#{pantograph_folder_name}', '#{PluginManager::PLUGINFILE_NAME}')\n" \
+      "eval_gemfile(plugins_path) if File.exist?(plugins_path)"
+    end
+
+    # Makes sure, the user's Gemfile actually loads the Plugins file
+    def plugins_attached?
+      gemfile_path && gemfile_content.include?(PluginManager::PLUGINFILE_NAME)
+    end
+
+    def ensure_plugins_attached!
+      return if plugins_attached?
+      self.setup
+    end
+
+    #####################################################
+    # @!group Requiring the plugins
+    #####################################################
+
+    # Iterate over all available plugins
+    # which follow the naming convention
+    #   pantograph-plugin-[plugin_name]
+    # This will make sure to load the action
+    # and all its helpers
+    def load_plugins
+      UI.verbose("Checking if there are any plugins that should be loaded...")
+
+      loaded_plugins = false
+      available_plugins.each do |gem_name|
+        UI.verbose("Loading '#{gem_name}' plugin")
+        begin
+          # BEFORE requiring the gem, we get a list of loaded actions
+          # This way we can check inside `store_plugin_reference` if
+          # any actions were overwritten
+          self.loaded_pantograph_actions.concat(Pantograph::Actions.constants)
+
+          PantographRequire.install_gem_if_needed(gem_name: gem_name, require_gem: true)
+
+          store_plugin_reference(gem_name)
+          loaded_plugins = true
+        rescue StandardError, ScriptError => ex # some errors, like ScriptError are not caught unless explicitly
+          UI.error("Error loading plugin '#{gem_name}': #{ex}")
+
+          # We'll still add it to the table, to make the error
+          # much more visible and obvious
+          self.plugin_references[gem_name] = {
+            version_number: Pantograph::ActionCollector.determine_version(gem_name),
+            actions: []
+          }
+        end
+      end
+
+      if !loaded_plugins && self.pluginfile_content.to_s.include?(PluginManager.plugin_prefix)
+        UI.error("It seems like you wanted to load some plugins, however they couldn't be loaded")
+        UI.error("Please follow the troubleshooting guide: #{TROUBLESHOOTING_URL}")
+      end
+
+      skip_print_plugin_info = self.plugin_references.empty? || CLIToolsDistributor.running_version_command? || PantographCore::Env.truthy?("PANTOGRAPH_ENV_PRINTER")
+
+      # We want to avoid printing output other than the version number if we are running `pantograph -v`
+      print_plugin_information(self.plugin_references) unless skip_print_plugin_info
+    end
+
+    # Prints a table all the plugins that were loaded
+    def print_plugin_information(references)
+      rows = references.collect do |current|
+        if current[1][:actions].empty?
+          # Something is wrong with this plugin, no available actions
+          [current[0].red, current[1][:version_number], "No actions found".red]
+        else
+          [current[0], current[1][:version_number], current[1][:actions].join("\n")]
+        end
+      end
+
+      require 'terminal-table'
+      puts(Terminal::Table.new({
+        rows: PantographCore::PrintTable.transform_output(rows),
+        title: "Used plugins".green,
+        headings: ["Plugin", "Version", "Action"]
+      }))
+      puts("")
+    end
+
+    #####################################################
+    # @!group Reference between plugins to actions
+    #####################################################
+
+    # Connection between plugins and their actions
+    # Example value of plugin_references
+    # => {"pantograph-plugin-ruby" => {
+    #          version_number: "0.1.0",
+    #          actions: [:rspec, :rubocop]
+    #     }}
+    def plugin_references
+      @plugin_references ||= {}
+    end
+
+    # Contains an array of symbols for the action classes
+    def loaded_pantograph_actions
+      @pantograph_actions ||= []
+    end
+
+    def store_plugin_reference(gem_name)
+      module_name = gem_name.gsub(PluginManager.plugin_prefix, '').pantograph_class
+      # We store a collection of the imported plugins
+      # This way we can tell which action came from what plugin
+      # (a plugin may contain any number of actions)
+      version_number = Pantograph::ActionCollector.determine_version(gem_name)
+      references = Pantograph.const_get(module_name).all_classes.collect do |path|
+        next unless File.dirname(path).end_with?("/actions") # we only want to match actions
+
+        File.basename(path).gsub("_action", "").gsub(".rb", "").to_sym # the _action is optional
+      end
+      references.compact!
+
+      # Check if this overwrites a built-in action and
+      # show a warning if that's the case
+      references.each do |current_ref|
+        # current_ref is a symbol, e.g. :emoji_fetcher
+        class_name = (current_ref.to_s.pantograph_class + 'Action').to_sym
+
+        if self.loaded_pantograph_actions.include?(class_name)
+          UI.important("Plugin '#{module_name}' overwrites already loaded action '#{current_ref}'")
+        end
+      end
+
+      self.plugin_references[gem_name] = {
+        version_number: version_number,
+        actions: references
+      }
+    end
+  end
+end

data/pantograph/lib/pantograph/plugins/plugin_search.rb

@@ -0,0 +1,46 @@
+module Pantograph
+  class PluginSearch
+    require 'terminal-table'
+    require 'word_wrap'
+
+    def self.print_plugins(search_query: nil)
+      if search_query
+        UI.message("Looking for pantograph plugins containing '#{search_query}'...")
+      else
+        UI.message("Listing all available pantograph plugins")
+      end
+
+      plugins = Pantograph::PluginFetcher.fetch_gems(search_query: search_query)
+
+      if plugins.empty?
+        UI.user_error!("Couldn't find any available pantograph plugins containing '#{search_query}'")
+      end
+
+      rows = plugins.collect do |current|
+        [
+          current.name.green,
+          WordWrap.ww(current.info, 50),
+          current.downloads
+        ]
+      end
+
+      params = {
+        rows: PantographCore::PrintTable.transform_output(rows),
+        title: (search_query ? "pantograph plugins '#{search_query}'" : "Available pantograph plugins").green,
+        headings: ["Name", "Description", "Downloads"]
+      }
+
+      puts("")
+      puts(Terminal::Table.new(params))
+      puts("")
+
+      if plugins.count == 1
+        print_plugin_details(plugins.last)
+      end
+    end
+
+    def self.print_plugin_details(plugin)
+      UI.message("You can find more information for #{plugin.name} on #{plugin.homepage.green}")
+    end
+  end
+end

data/pantograph/lib/pantograph/plugins/plugin_update_manager.rb

@@ -0,0 +1,70 @@
+module Pantograph
+  # Alert the user when updates for plugins are available
+  class PluginUpdateManager
+    def self.start_looking_for_updates
+      return if PantographCore::Env.truthy?("PANTOGRAPH_SKIP_UPDATE_CHECK")
+
+      Thread.new do
+        self.plugin_references.each do |plugin_name, current_plugin|
+          begin
+            self.server_results[plugin_name] = fetch_latest_version(plugin_name)
+          rescue
+          end
+        end
+      end
+    end
+
+    def self.show_update_status
+      return if PantographCore::Env.truthy?("PANTOGRAPH_SKIP_UPDATE_CHECK")
+
+      # We set self.server_results to be nil
+      # this way the table is not printed twice
+      # (next to the summary table or when an exception happens)
+      return unless self.server_results.count > 0
+
+      rows = []
+      self.plugin_references.each do |plugin_name, current_plugin|
+        latest_version = self.server_results[plugin_name]
+        next if latest_version.nil?
+        current_version = Gem::Version.new(current_plugin[:version_number])
+        next if current_version >= latest_version
+
+        rows << [
+          plugin_name.gsub(PluginManager.plugin_prefix, ''),
+          current_version.to_s.red,
+          latest_version.to_s.green
+        ]
+      end
+
+      if rows.empty?
+        UI.verbose("All plugins are up to date")
+        return
+      end
+
+      require 'terminal-table'
+      puts(Terminal::Table.new({
+        rows: PantographCore::PrintTable.transform_output(rows),
+        title: "Plugin updates available".yellow,
+        headings: ["Plugin", "Your Version", "Latest Version"]
+      }))
+      UI.message("To update all plugins, just run")
+      UI.command "bundle exec pantograph update_plugins"
+      puts('')
+      @server_results = nil
+    end
+
+    def self.plugin_references
+      Pantograph.plugin_manager.plugin_references
+    end
+
+    def self.fetch_latest_version(gem_name)
+      Gem::Version.new(PluginManager.fetch_gem_info_from_rubygems(gem_name)["version"])
+    rescue
+      nil
+    end
+
+    def self.server_results
+      @server_results ||= {}
+    end
+  end
+end

data/pantograph/lib/pantograph/plugins/plugins.rb

@@ -0,0 +1,12 @@
+require 'fileutils'
+require 'erb'
+require 'find'
+
+require 'pantograph/plugins/plugin_info'
+require 'pantograph/plugins/plugin_generator'
+require 'pantograph/plugins/plugin_generator_ui'
+require 'pantograph/plugins/plugin_info_collector'
+require 'pantograph/plugins/plugin_manager'
+require 'pantograph/plugins/plugin_search'
+require 'pantograph/plugins/plugin_fetcher'
+require 'pantograph/plugins/plugin_update_manager'