pantograph 0.1.0

data/pantograph/lib/pantograph/pant_file.rb

@@ -0,0 +1,377 @@
+require 'rubygems/requirement'
+
+module Pantograph
+  class PantFile
+    # Stores all relevant information from the currently running process
+    attr_accessor :runner
+
+    # the platform in which we're currently in when parsing the Pantfile
+    # This is used to identify the platform in which the lane is in
+    attr_accessor :current_platform
+
+    SharedValues = Pantograph::Actions::SharedValues
+
+    # @return The runner which can be executed to trigger the given actions
+    def initialize(path = nil)
+      return unless (path || '').length > 0
+      UI.user_error!("Could not find Pantfile at path '#{path}'") unless File.exist?(path)
+      @path = File.expand_path(path)
+      content = File.read(path, encoding: "utf-8")
+
+      # From https://github.com/orta/danger/blob/master/lib/danger/Dangerfile.rb
+      if content.tr!('“”‘’‛', %(""'''))
+        UI.error("Your #{File.basename(path)} has had smart quotes sanitised. " \
+                'To avoid issues in the future, you should not use ' \
+                'TextEdit for editing it. If you are not using TextEdit, ' \
+                'you should turn off smart quotes in your editor of choice.')
+      end
+
+      content.scan(/^\s*require ["'](.*?)["']/).each do |current|
+        gem_name = current.last
+        next if gem_name.include?(".") # these are local gems
+
+        begin
+          require(gem_name)
+        rescue LoadError
+          UI.important("You have required a gem, if this is a third party gem, please use `pantograph_require '#{gem_name}'` to ensure the gem is installed locally.")
+        end
+      end
+
+      parse(content, @path)
+    end
+
+    def parsing_binding
+      binding
+    end
+
+    def parse(data, path = nil)
+      @runner ||= Runner.new
+
+      Dir.chdir(PantographCore::PantographFolder.path || Dir.pwd) do # context: pantograph subfolder
+        # create nice path that we want to print in case of some problem
+        relative_path = path.nil? ? '(eval)' : Pathname.new(path).relative_path_from(Pathname.new(Dir.pwd)).to_s
+
+        begin
+          # We have to use #get_binding method, because some test files defines method called `path` (for example SwitcherPantfile)
+          # and local variable has higher priority, so it causes to remove content of original Pantfile for example. With #get_binding
+          # is this always clear and safe to declare any local variables we want, because the eval function uses the instance scope
+          # instead of local.
+
+          # rubocop:disable Security/Eval
+          eval(data, parsing_binding, relative_path) # using eval is ok for this case
+          # rubocop:enable Security/Eval
+        rescue SyntaxError => ex
+          match = ex.to_s.match(/#{Regexp.escape(relative_path)}:(\d+)/)
+          if match
+            line = match[1]
+            UI.content_error(data, line)
+            UI.user_error!("Syntax error in your Pantfile on line #{line}: #{ex}")
+          else
+            UI.user_error!("Syntax error in your Pantfile: #{ex}")
+          end
+        end
+      end
+
+      self
+    end
+
+    #####################################################
+    # @!group DSL
+    #####################################################
+
+    # User defines a new lane
+    def lane(lane_name, &block)
+      UI.user_error!("You have to pass a block using 'do' for lane '#{lane_name}'. Make sure you read the docs on GitHub.") unless block
+
+      self.runner.add_lane(Lane.new(platform: self.current_platform,
+                                       block: block,
+                                 description: desc_collection,
+                                        name: lane_name,
+                                  is_private: false))
+
+      @desc_collection = nil # reset the collected description again for the next lane
+    end
+
+    # User defines a new private lane, which can't be called from the CLI
+    def private_lane(lane_name, &block)
+      UI.user_error!("You have to pass a block using 'do' for lane '#{lane_name}'. Make sure you read the docs on GitHub.") unless block
+
+      self.runner.add_lane(Lane.new(platform: self.current_platform,
+                                       block: block,
+                                 description: desc_collection,
+                                        name: lane_name,
+                                  is_private: true))
+
+      @desc_collection = nil # reset the collected description again for the next lane
+    end
+
+    # User defines a lane that can overwrite existing lanes. Useful when importing a Pantfile
+    def override_lane(lane_name, &block)
+      UI.user_error!("You have to pass a block using 'do' for lane '#{lane_name}'. Make sure you read the docs on GitHub.") unless block
+
+      self.runner.add_lane(Lane.new(platform: self.current_platform,
+                                       block: block,
+                                 description: desc_collection,
+                                        name: lane_name,
+                                  is_private: false), true)
+
+      @desc_collection = nil # reset the collected description again for the next lane
+    end
+
+    # User defines a platform block
+    def platform(platform_name)
+      SupportedPlatforms.verify!(platform_name)
+
+      self.current_platform = platform_name
+
+      yield
+
+      self.current_platform = nil
+    end
+
+    # Is executed before each test run
+    def before_all(&block)
+      @runner.set_before_all(@current_platform, block)
+    end
+
+    # Is executed before each lane
+    def before_each(&block)
+      @runner.set_before_each(@current_platform, block)
+    end
+
+    # Is executed after each test run
+    def after_all(&block)
+      @runner.set_after_all(@current_platform, block)
+    end
+
+    # Is executed before each lane
+    def after_each(&block)
+      @runner.set_after_each(@current_platform, block)
+    end
+
+    # Is executed if an error occurred during pantograph execution
+    def error(&block)
+      @runner.set_error(@current_platform, block)
+    end
+
+    # Is used to look if the method is implemented as an action
+    def method_missing(method_sym, *arguments, &_block)
+      self.runner.trigger_action_by_name(method_sym, nil, false, *arguments)
+    end
+
+    #####################################################
+    # @!group Other things
+    #####################################################
+
+    # Is the given key a platform block or a lane?
+    def is_platform_block?(key)
+      UI.crash!('No key given') unless key
+
+      return false if self.runner.lanes.fetch(nil, {}).fetch(key.to_sym, nil)
+      return true if self.runner.lanes[key.to_sym].kind_of?(Hash)
+
+      if key.to_sym == :update
+        # The user ran `pantograph update`, instead of `pantograph update_pantograph`
+        # We're gonna be nice and understand what the user is trying to do
+        require 'pantograph/one_off'
+        Pantograph::OneOff.run(action: "update_pantograph", parameters: {})
+      else
+        UI.user_error!("Could not find '#{key}'. Available lanes: #{self.runner.available_lanes.join(', ')}")
+      end
+    end
+
+    def actions_path(path)
+      UI.crash!("Path '#{path}' not found!") unless File.directory?(path)
+
+      Actions.load_external_actions(path)
+    end
+
+    # Execute shell command
+    # Accepts arguments with with and without the command named keyword so that sh
+    # behaves like other actions with named keywords
+    # https://github.com/pantograph/pantograph/issues/14930
+    #
+    # Example:
+    #  sh("ls")
+    #  sh("ls", log: false)
+    #  sh(command: "ls")
+    #  sh(command: "ls", log: false)
+    def sh(*args, &b)
+      # First accepts hash (or named keywords) like other actions
+      # Otherwise uses sh method that doesn't have an interface like an action
+      if args.count == 1 && args.first.kind_of?(Hash)
+        hash = args.first
+        command = hash.delete(:command)
+
+        raise ArgumentError, "sh requires :command keyword in argument" if command.nil?
+
+        new_args = [*command, hash]
+        PantFile.sh(*new_args, &b)
+      else
+        PantFile.sh(*args, &b)
+      end
+    end
+
+    def self.sh(*command, log: true, error_callback: nil, &b)
+      command_header = log ? Actions.shell_command_from_args(*command) : "shell command"
+      Actions.execute_action(command_header) do
+        Actions.sh_no_action(*command, log: log, error_callback: error_callback, &b)
+      end
+    end
+
+    def desc(string)
+      desc_collection << string
+    end
+
+    def desc_collection
+      @desc_collection ||= []
+    end
+
+    def pantograph_require(gem_name)
+      PantographRequire.install_gem_if_needed(gem_name: gem_name, require_gem: true)
+    end
+
+    def generated_pantfile_id(id)
+      UI.important("The `generated_pantfile_id` action was deprecated, you can remove the line from your `Pantfile`")
+    end
+
+    def import(path = nil)
+      UI.user_error!("Please pass a path to the `import` action") unless path
+
+      path = path.dup.gsub("~", Dir.home)
+      unless Pathname.new(path).absolute? # unless an absolute path
+        path = File.join(File.expand_path('..', @path), path)
+      end
+
+      UI.user_error!("Could not find Pantfile at path '#{path}'") unless File.exist?(path)
+
+      # First check if there are local actions to import in the same directory as the Pantfile
+      actions_path = File.join(File.expand_path("..", path), 'actions')
+      Pantograph::Actions.load_external_actions(actions_path) if File.directory?(actions_path)
+
+      action_launched('import')
+
+      return_value = parse(File.read(path), path)
+
+      action_completed('import', status: PantographCore::ActionCompletionStatus::SUCCESS)
+
+      return return_value
+    end
+
+    # @param url [String] The git URL to clone the repository from
+    # @param branch [String] The branch to checkout in the repository
+    # @param path [String] The path to the Pantfile
+    # @param version [String, Array] Version requirement for repo tags
+    def import_from_git(url: nil, branch: 'HEAD', path: 'pantograph/Pantfile', version: nil)
+      UI.user_error!("Please pass a path to the `import_from_git` action") if url.to_s.length == 0
+
+      Actions.execute_action('import_from_git') do
+        require 'tmpdir'
+
+        action_launched('import_from_git')
+
+        # Checkout the repo
+        repo_name = url.split("/").last
+        checkout_param = branch
+
+        Dir.mktmpdir("fl_clone") do |tmp_path|
+          clone_folder = File.join(tmp_path, repo_name)
+
+          branch_option = "--branch #{branch}" if branch != 'HEAD'
+
+          UI.message("Cloning remote git repo...")
+          Helper.with_env_values('GIT_TERMINAL_PROMPT' => '0') do
+            Actions.sh("git clone #{url.shellescape} #{clone_folder.shellescape} --depth 1 -n #{branch_option}")
+          end
+
+          unless version.nil?
+            req = Gem::Requirement.new(version)
+            all_tags = fetch_remote_tags(folder: clone_folder)
+            checkout_param = all_tags.select { |t| req =~ PantographCore::TagVersion.new(t) }.last
+            UI.user_error!("No tag found matching #{version.inspect}") if checkout_param.nil?
+          end
+
+          Actions.sh("cd #{clone_folder.shellescape} && git checkout #{checkout_param.shellescape} #{path.shellescape}")
+
+          # We also want to check out all the local actions of this pantograph setup
+          containing = path.split(File::SEPARATOR)[0..-2]
+          containing = "." if containing.count == 0
+          actions_folder = File.join(containing, "actions")
+          begin
+            Actions.sh("cd #{clone_folder.shellescape} && git checkout #{checkout_param.shellescape} #{actions_folder.shellescape}")
+          rescue
+            # We don't care about a failure here, as local actions are optional
+          end
+
+          return_value = import(File.join(clone_folder, path))
+
+          action_completed('import_from_git', status: PantographCore::ActionCompletionStatus::SUCCESS)
+
+          return return_value
+        end
+      end
+    end
+
+    #####################################################
+    # @!group Versioning helpers
+    #####################################################
+
+    def fetch_remote_tags(folder: nil)
+      UI.message("Fetching remote git tags...")
+      Helper.with_env_values('GIT_TERMINAL_PROMPT' => '0') do
+        Actions.sh("cd #{folder.shellescape} && git fetch --all --tags -q")
+      end
+
+      # Fetch all possible tags
+      git_tags_string = Actions.sh("cd #{folder.shellescape} && git tag -l")
+      git_tags = git_tags_string.split("\n")
+
+      # Sort tags based on their version number
+      return git_tags
+             .select { |tag| PantographCore::TagVersion.correct?(tag) }
+             .sort_by { |tag| PantographCore::TagVersion.new(tag) }
+    end
+
+    #####################################################
+    # @!group Overwriting Ruby methods
+    #####################################################
+
+    # Speak out loud
+    def say(value)
+      # Overwrite this, since there is already a 'say' method defined in the Ruby standard library
+      value ||= yield
+
+      value = { text: value } if value.kind_of?(String) || value.kind_of?(Array)
+      self.runner.trigger_action_by_name(:say, nil, false, value)
+    end
+
+    def puts(value)
+      # Overwrite this, since there is already a 'puts' method defined in the Ruby standard library
+      value ||= yield if block_given?
+
+      action_launched('puts')
+      return_value = Pantograph::Actions::PutsAction.run([value])
+      action_completed('puts', status: PantographCore::ActionCompletionStatus::SUCCESS)
+      return return_value
+    end
+
+    def test(params = {})
+      # Overwrite this, since there is already a 'test' method defined in the Ruby standard library
+      self.runner.try_switch_to_lane(:test, [params])
+    end
+
+    def action_launched(action_name)
+      action_launch_context = PantographCore::ActionLaunchContext.context_for_action_name(action_name,
+                                                                                        pantograph_client_language: :ruby,
+                                                                                        args: ARGV)
+      PantographCore.session.action_launched(launch_context: action_launch_context)
+    end
+
+    def action_completed(action_name, status: nil)
+      completion_context = PantographCore::ActionCompletionContext.context_for_action_name(action_name,
+                                                                                         args: ARGV,
+                                                                                         status: status)
+      PantographCore.session.action_completed(completion_context: completion_context)
+    end
+  end
+end

data/pantograph/lib/pantograph/pantograph_require.rb

@@ -0,0 +1,75 @@
+module Pantograph
+  class PantographRequire
+    class << self
+      def install_gem_if_needed(gem_name: nil, require_gem: true)
+        gem_require_name = format_gem_require_name(gem_name)
+
+        # check if it's installed
+        if gem_installed?(gem_name)
+          UI.success("gem '#{gem_name}' is already installed") if PantographCore::Globals.verbose?
+          require gem_require_name if require_gem
+          return true
+        end
+
+        if Helper.bundler?
+          # User uses bundler, we don't want to install gems on the fly here
+          # Instead tell the user how to add it to their Gemfile
+          UI.important("Missing gem '#{gem_name}', please add the following to your local Gemfile:")
+          UI.important("")
+          UI.command_output("gem \"#{gem_name}\"")
+          UI.important("")
+          UI.user_error!("Add 'gem \"#{gem_name}\"' to your Gemfile and restart pantograph") unless Helper.test?
+        end
+
+        require "rubygems/command_manager"
+        installer = Gem::CommandManager.instance[:install]
+
+        UI.important("Installing Ruby gem '#{gem_name}'...")
+
+        spec_name = self.find_gem_name(gem_name)
+        UI.important("Found gem \"#{spec_name}\" instead of the required name \"#{gem_name}\"") if spec_name != gem_name
+
+        return if Helper.test?
+
+        # We install the gem like this because we also want to gem to be available to be required
+        # at this point. If we were to shell out, this wouldn't be the case
+        installer.install_gem(spec_name, Gem::Requirement.default)
+        UI.success("Successfully installed '#{gem_name}'")
+        require gem_require_name if require_gem
+      end
+
+      def gem_installed?(name, req = Gem::Requirement.default)
+        installed = Gem::Specification.any? { |s| s.name == name and req =~ s.version }
+        return true if installed
+
+        # In special cases a gem is already preinstalled, e.g. YAML.
+        # To find out we try to load a gem with that name in a child process
+        # (so we don't actually load anything we don't want to load)
+        # See https://github.com/pantograph/pantograph/issues/6951
+        require_tester = <<-RB.gsub(/^ */, '')
+          begin
+            require ARGV.first
+          rescue LoadError
+            exit(1)
+          end
+        RB
+        system(RbConfig.ruby, "-e", require_tester.lines.map(&:chomp).join("; "), name)
+        return $?.success?
+      end
+
+      def find_gem_name(user_supplied_name)
+        fetcher = Gem::SpecFetcher.fetcher
+        gems = fetcher.suggest_gems_from_name(user_supplied_name)
+
+        return gems.first
+      end
+
+      def format_gem_require_name(gem_name)
+        # from "pantograph-plugin-xcversion" to "pantograph/plugin/xcversion"
+        gem_name = gem_name.tr("-", "/") if gem_name.start_with?("pantograph-plugin-")
+
+        return gem_name
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Pantograph
+  # Use the RubyGems API to get all pantograph plugins
+  class PluginFetcher
+    require 'pantograph_core'
+    require 'pantograph/plugins/plugin_manager'
+
+    # Returns an array of PantographPlugin objects
+    def self.fetch_gems(search_query: nil)
+      require 'json'
+      require 'open-uri'
+
+      page = 1
+      plugins = []
+      loop do
+        url = "https://rubygems.org/api/v1/search.json?query=#{PluginManager.plugin_prefix}&page=#{page}"
+        PantographCore::UI.verbose("RubyGems API Request: #{url}")
+        results = JSON.parse(open(url).read)
+        break if results.count == 0
+
+        plugins += results.collect do |current|
+          PantographPlugin.new(current)
+        end
+        page += 1
+      end
+
+      return plugins if search_query.to_s.length == 0
+      plugins.keep_if do |current|
+        current.full_name.include?(search_query) or current.info.include?(search_query)
+      end
+
+      return plugins
+    end
+  end
+
+  class PantographPlugin
+    attr_accessor :full_name
+    attr_accessor :name
+    attr_accessor :downloads
+    attr_accessor :info
+    attr_accessor :homepage
+
+    def initialize(hash)
+      self.full_name = hash["name"]
+      self.name = self.full_name.gsub(PluginManager.plugin_prefix, '')
+      self.downloads = hash["downloads"]
+      self.info = hash["info"]
+      self.homepage = hash["homepage_uri"]
+    end
+
+    def linked_title
+      return "`#{name}`" if homepage.to_s.length == 0
+      return "[#{name}](#{homepage})"
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+module Pantograph
+  # Generates a sample plugin by traversing a template directory structure
+  # and reproducing it in a destination location. At the same time, it runs
+  # variable replacements on directory names, file names, and runs ERB
+  # templating on file contents whose names end with '.erb'.
+  #
+  # Directory and file name variable replacements are defined like: %gem_name%
+  # The text between the percent signs will be used to invoke an accessor
+  # method on the PluginInfo object to get the replacement value.
+  class PluginGenerator
+    def initialize(ui:             PluginGeneratorUI.new,
+                   info_collector: PluginInfoCollector.new(ui),
+                   template_root:  File.join(File.dirname(__FILE__), 'template'),
+                   dest_root:      FileUtils.pwd)
+      @ui = ui
+      @info_collector = info_collector
+      @template_root = template_root
+      @dest_root = dest_root
+    end
+
+    # entry point
+    def generate(plugin_name = nil)
+      plugin_info = @info_collector.collect_info(plugin_name)
+
+      # Traverse all the files and directories in the template root,
+      # handling each in turn
+      Find.find(@template_root) do |template_path|
+        handle_template_path(template_path, plugin_info)
+      end
+
+      @ui.success("\nYour plugin was successfully generated at #{plugin_info.gem_name}/ 🚀")
+      @ui.success("\nTo get started with using this plugin, run")
+      @ui.message("\n    pantograph add_plugin #{plugin_info.plugin_name}\n")
+      @ui.success("\nfrom a pantograph-enabled app project directory and provide the following as the path:")
+      @ui.message("\n    #{File.expand_path(plugin_info.gem_name)}\n\n")
+    end
+
+    def handle_template_path(template_path, plugin_info)
+      dest_path = derive_dest_path(template_path, plugin_info)
+
+      if File.directory?(template_path)
+        FileUtils.mkdir_p(dest_path)
+      else
+        copy_file(template_path, dest_path, plugin_info)
+      end
+    end
+
+    def derive_dest_path(template_path, plugin_info)
+      relative_template_path = template_path.gsub(@template_root, '')
+      replaced_path = replace_path_variables(relative_template_path, plugin_info)
+
+      File.join(@dest_root, plugin_info.gem_name, replaced_path)
+    end
+
+    def copy_file(template_path, dest_path, plugin_info)
+      contents = File.read(template_path)
+
+      if dest_path.end_with?('.erb')
+        contents = ERB.new(contents).result(plugin_info.get_binding)
+        dest_path = dest_path[0...-4] # Remove the .erb suffix
+      end
+
+      File.write(dest_path, contents)
+    end
+
+    # Path variables can be defined like: %gem_name%
+    #
+    # The text between the percent signs will be used to invoke an accessor
+    # method on the PluginInfo object to be the replacement value.
+    def replace_path_variables(template_path, plugin_info)
+      path = template_path.dup
+
+      loop do
+        replacement_variable_regexp = /%([\w\-]*)%/
+        match = replacement_variable_regexp.match(path)
+
+        break unless match
+
+        replacement_value = plugin_info.send(match[1].to_sym)
+        path.gsub!(replacement_variable_regexp, replacement_value)
+      end
+
+      path
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Pantograph
+  class PluginGeneratorUI
+    def success(text)
+      puts(text.green)
+    end
+
+    def message(text)
+      puts(text)
+    end
+
+    def input(text)
+      UI.input(text)
+    end
+
+    def confirm(text)
+      UI.confirm(text)
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Pantograph
+  class PluginInfo
+    attr_reader :plugin_name
+    attr_reader :author
+    attr_reader :gem_name
+    attr_reader :email
+    attr_reader :summary
+    attr_reader :details
+
+    def initialize(plugin_name, author, email, summary, details)
+      @plugin_name = plugin_name
+      @author = author
+      @email = email
+      @summary = summary
+      @details = details
+    end
+
+    def gem_name
+      "#{Pantograph::PluginManager::PANTOGRAPH_PLUGIN_PREFIX}#{plugin_name}"
+    end
+
+    def require_path
+      gem_name.tr('-', '/')
+    end
+
+    def actions_path
+      File.join(require_path, 'actions')
+    end
+
+    def helper_path
+      File.join(require_path, 'helper')
+    end
+
+    # Used to expose a local binding for use in ERB templating
+    #
+    # rubocop:disable Style/AccessorMethodName
+    def get_binding
+      binding
+    end
+    # rubocop:enable Style/AccessorMethodName
+
+    def ==(other)
+      @plugin_name == other.plugin_name &&
+        @author == other.author &&
+        @email == other.email &&
+        @summary == other.summary
+    end
+  end
+end