fluid_cli 0.1.2

data/lib/fluid_cli/db.rb

@@ -0,0 +1,114 @@
+require "pstore"
+require "forwardable"
+
+module FluidCLI
+  # Persists transient data like access tokens that may be cleared
+  # when user clears their session
+  #
+  # All of the instance methods documented here can be used as class methods. All class
+  # methods are forwarded to a new instance of the database, pointing at the default
+  # path.
+  class DB
+    extend SingleForwardable
+    def_delegators :new, :keys, :exists?, :set, :get, :del, :clear
+
+    attr_reader :db # :nodoc:
+
+    def initialize(path: File.join(FluidCLI.cache_dir, ".db.pstore")) # :nodoc:
+      @db = PStore.new(path)
+    end
+
+    # Get all keys that exist in the database.
+    #
+    # #### Returns
+    # - `keys`: an array of string or symbol keys that exist in the database
+    #
+    # #### Usage
+    #
+    #   FluidCLI::DB.keys
+    #
+    def keys
+      db.transaction(true) { db.roots }
+    end
+
+    # Check to see if a key exists in the database, the key will only exist if it
+    # has a value so if the key exists then there is also a value.
+    #
+    # #### Parameters
+    # - `key`: a string or a symbol representation of a key that is stored in the DB
+    #
+    # #### Returns
+    # - `exists`: a boolean value if the key exists in the database
+    #
+    # #### Usage
+    #
+    #   exists = FluidCLI::DB.exists?('fluid_exchange_token')
+    #
+    def exists?(key)
+      db.transaction(true) { db.root?(key) }
+    end
+
+    # Persist a value by key in the local storage
+    #
+    # #### Parameters
+    # - `**args`: a hash of keys and values to persist in the database
+    #
+    # #### Usage
+    #
+    #   FluidCLI::DB.set(fluid_exchange_token: 'token', metric_consent: true)
+    #
+    def set(**args)
+      db.transaction do
+        args.each do |key, val|
+          if val.nil?
+            db.delete(key)
+          else
+            db[key] = val
+          end
+        end
+      end
+    end
+
+    # Gets a value from the DB that is associated with the supplied key
+    #
+    # #### Parameters
+    # - `key`: a string or a symbol representation of a key that is stored in the DB
+    #
+    # #### Returns
+    # - `value`: will be the previously saved value or nil if the key does not exist
+    #   in the database.
+    #
+    # #### Usage
+    #
+    #   FluidCLI::DB.get(:fluid_exchange_token)
+    #
+    def get(key)
+      val = db.transaction(true) { db[key] }
+      val = yield if val.nil? && block_given?
+      val
+    end
+
+    # Deletes a value from the local storage
+    #
+    # #### Parameters
+    # - `*args`: an array of strings or symbols that are keys to be removed from the database
+    #
+    # #### Usage
+    #
+    #   FluidCLI::DB.del(:fluid_exchange_token)
+    #
+    def del(*args)
+      db.transaction { args.each { |key| db.delete(key) } }
+    end
+
+    # Drops all keys from the database.
+    #
+    # #### Usage
+    #
+    #   FluidCLI::DB.clear
+    #
+    def clear
+      del(*keys)
+    end
+  end
+end

data/lib/fluid_cli/entry_point.rb

@@ -0,0 +1,10 @@
+require 'fluid_cli'
+
+module FluidCLI
+  module EntryPoint
+    def self.call(args)
+      cmd, command_name, args = FluidCLI::Resolver.call(args)
+      FluidCLI::Executor.call(cmd, command_name, args)
+    end
+  end
+end

data/lib/fluid_cli/environment.rb

@@ -0,0 +1,32 @@
+module FluidCLI
+  # The environment module provides an interface to get information from
+  # the environment in which the CLI runs
+  module Environment
+    def self.ruby_version(context: Context.new)
+      output, status = context.capture2e("ruby", "--version")
+      raise FluidCLI::Abort, context.message("core.errors.missing_ruby") unless status.success?
+      version = output.match(/ruby (\d+\.\d+\.\d+)/)[1]
+      puts "Ruby version: #{version}"
+    end
+
+    def self.company(env_variables: ENV)
+      env_variables["FLUID_COMPANY"]
+    end
+
+    def self.auth_token(env_variables: ENV)
+      env_variables["FLUID_AUTH_TOKEN"]
+    end
+
+    def self.interactive=(interactive)
+      @interactive = interactive
+    end
+
+    def self.interactive?(env_variables: ENV)
+      if env_variables.key?("FLUID_CLI_TTY")
+        @interactive = env_variables["FLUID_CLI_TTY"] == "true"
+      else
+        @interactive ||= STDIN.tty?
+      end
+    end
+  end
+end

data/lib/fluid_cli/file_system_listener.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require "listen"
+require "observer"
+
+module FluidCLI
+  class FileSystemListener
+    include Observable
+
+    def initialize(root:, force_poll:)
+      @root = root
+      @force_poll = force_poll
+
+      @listener = Listen.to(@root, force_polling: @force_poll) do |updated, added, removed|
+        changed
+        notify_observers(updated, added, removed)
+      end
+    end
+
+    def start
+      @listener.start
+    rescue ArgumentError
+      # Ignore errors during the transition of 'listen' events
+    end
+
+    def stop
+      @listener.stop
+    end
+  end
+end

data/lib/fluid_cli/form.rb

@@ -0,0 +1,42 @@
+require "fluid_cli"
+
+module FluidCLI
+  class Form
+    class << self
+      def ask(ctx, args, flags)
+        attrs = {}
+        (@positional_arguments || []).each { |name| attrs[name] = args.shift }
+        return nil if attrs.any? { |_k, v| v.nil? }
+        (@flag_arguments || []).each { |arg| attrs[arg] = flags[arg] }
+        form = new(ctx, args, attrs)
+        begin
+          form.ask
+          form
+        rescue CLI::Kit::Abort => err
+          ctx.puts(err.message)
+          nil
+        rescue CLI::Kit::AbortSilent
+          nil
+        end
+      end
+
+      def positional_arguments(*args)
+        @positional_arguments = args
+        attr_accessor(*args)
+      end
+
+      def flag_arguments(*args)
+        @flag_arguments = args
+        attr_accessor(*args)
+      end
+    end
+
+    attr_accessor :ctx, :xargs
+
+    def initialize(ctx, xargs, attributes)
+      @ctx = ctx
+      @xargs = xargs
+      attributes.each { |k, v| send("#{k}=", v) unless v.nil? }
+    end
+  end
+end

data/lib/fluid_cli/git.rb

@@ -0,0 +1,319 @@
+module FluidCLI
+  ##
+  # FluidCLI::Git wraps git functionality to make it easier to integrate with git.
+  class Git
+    class << self
+      # Check if Git exists in the environment
+      def exists?(ctx)
+        _output, status = ctx.capture2e("git", "version")
+        status.success?
+      rescue Errno::ENOENT # git is not installed
+        false
+      end
+
+      # Check if the current working directory is a Git repository
+      def available?(ctx)
+        _output, status = ctx.capture2e("git", "status")
+        status.success?
+      rescue Errno::ENOENT # git is not installed
+        false
+      end
+
+      ##
+      # will return the current sha of the cli repo
+      #
+      # #### Parameters
+      #
+      # * `dir` - the directory of the git repo. This defaults to the cli repo
+      # * `ctx` - the current running context of your command
+      #
+      # #### Returns
+      #
+      # * `sha_string` - string of the sha of the most recent commit to the repo
+      #
+      # #### Example
+      #
+      #   FluidCLI::Git.sha
+      #
+      # Some environments don't have git in PATH and this prevents
+      # the execution from raising an error
+      # https://app.bugsnag.com/shopify/shopify-cli/errors/615dd36365ce57000889d4c5
+      def sha(dir: Dir.pwd, ctx: Context.new)
+        if available?(ctx)
+          rev_parse("HEAD", dir: dir, ctx: ctx)
+        end
+      end
+
+      ##
+      # returns array with components of git clone command
+      #
+      # #### Parameters
+      #
+      # * `repo` - repo url without branch name
+      # * `dest` - a filepath to where the repo should be cloned to
+      # * `branch` - branch name when cloning
+      #
+      # #### Returns
+      #
+      # * array of strings
+      #
+      # #### Example
+      #
+      #   ["clone", "--single-branch", "--branch", "test-branch", "test-app"]
+      #
+      def git_clone_command(repo, dest, branch)
+        if branch
+          ["clone", "--single-branch", "--branch", branch, repo, dest]
+        else
+          ["clone", "--single-branch", repo, dest]
+        end
+      end
+
+      ##
+      # calls git to clone a new repo into a supplied destination,
+      # it will also call a supplied block with the percentage of clone completion
+      #
+      # #### Parameters
+      #
+      # * `repo_with_branch` - a git url for git to clone the repo from
+      # * `dest` - a filepath to where the repo should be cloned to
+      # * `ctx` - the current running context of your command, defaults to a new context.
+      #
+      # #### Returns
+      #
+      # * `sha_string` - string of the sha of the most recent commit to the repo
+      #
+      # #### Example
+      #
+      #   FluidCLI::Git.raw_clone('git@github.com:fluid-commerce/test.git', 'test-app')
+      #
+      def raw_clone(repo_with_branch, dest, ctx: Context.new)
+        if Dir.exist?(dest) && !Dir.empty?(dest)
+          ctx.abort(ctx.message("core.git.error.directory_exists"))
+        else
+          msg = []
+          # require at usage point to not slow down CLI startup
+          # https://github.com/Shopify/shopify-cli/pull/698#discussion_r444342445
+          require "open3"
+
+          repo, branch = repo_with_branch.split("#")
+          git_cmd = git_clone_command(repo, dest, branch)
+
+          success = Open3.popen3("git", *git_cmd, "--progress") do |_stdin, _stdout, stderr, thread|
+            msg = clone_progress(stderr, bar: nil)
+
+            thread.value
+          end.success?
+
+          ctx.abort((msg.join("\n"))) unless success
+        end
+      end
+
+      ##
+      # calls git to clone a new repo into a supplied destination,
+      # it will also output progress of the cloning process into a new progress bar
+      #
+      # #### Parameters
+      #
+      # * `repo_with_branch` - a git url for git to clone the repo from
+      # * `dest` - a filepath to where the repo should be cloned to
+      # * `ctx` - the current running context of your command, defaults to a new context.
+      #
+      # #### Returns
+      #
+      # * `sha_string` - string of the sha of the most recent commit to the repo
+      #
+      # #### Example
+      #
+      #   FluidCLI::Git.clone('git@github.com:fluid-commerce/test.git', 'test-app')
+      #
+      def clone(repo_with_branch, dest, ctx: Context.new)
+        if Dir.exist?(dest) && !Dir.empty?(dest)
+          ctx.abort("Directory #{dest} already exists and is not empty.")
+        else
+          msg = []
+          # require at usage point to not slow down CLI startup
+          # https://github.com/Shopify/shopify-cli/pull/698#discussion_r444342445
+          require "open3"
+
+          repo, branch = repo_with_branch.split("#")
+          git_cmd = git_clone_command(repo, dest, branch)
+
+          success_message = "{{success:Cloned repository into #{dest}}}"
+
+          CLI::UI::Frame.open("Cloning #{repo} into #{dest}", success_text: success_message) do
+            CLI::UI::Progress.progress do |bar|
+              success = Open3.popen3("git", *git_cmd, "--progress") do |_stdin, _stdout, stderr, thread|
+                msg = clone_progress(stderr, bar: bar)
+
+                thread.value
+              end.success?
+
+              ctx.abort((msg.join("\n"))) unless success
+              bar.tick(set_percent: 1.0)
+            end
+          end
+        end
+      end
+
+      ##
+      # will fetch the repos list of branches.
+      #
+      # #### Parameters
+      #
+      # * `ctx` - the current running context of your command, defaults to a new context.
+      #
+      # #### Returns
+      #
+      # * `branches` - [String] an array of strings that are branch names
+      #
+      # #### Example
+      #
+      #   branches = FluidCLI::Git.branches(@ctx)
+      #
+      def branches(ctx)
+        output, status = ctx.capture2e("git", "branch", "--list", "--format=%(refname:short)")
+        ctx.abort(ctx.message("core.git.error.no_branches_found")) unless status.success?
+
+        branches = if output == ""
+          ["master"]
+        else
+          output.split("\n")
+        end
+
+        branches
+      end
+
+      ##
+      # Run git three-way file merge (it doesn't require an initialized git repository)
+      #
+      # #### Parameters
+      #
+      # * `current_file  - string path of the current file
+      # * `base_file`    - string path of the base file
+      # * `other_file`   - string path of the other file
+      # * `opts`         - list of "git merge-file" options. Valid values:
+      #                    - "-q"       - do not warn about conflicts
+      #                    - "--diff3"  - show conflicts
+      #                    - "--ours"   - resolve conflicts favoring lines from `current_file`
+      #                    - "--theirs" - resolve conflicts favoring lines from `other_file`
+      #                    - "--union"  - resolve conflicts favoring lines from both files
+      #                    - "-p"       - send results to standard output instead of
+      #                                 overwriting the `current_file`
+      # * `ctx`          - the current running context of your command, defaults to a new context
+      #
+      # #### Returns
+      #
+      # * standard output from git
+      #
+      # #### Example
+      #
+      #   output = FluidCLI::Git.merge_file(current_file, base_file, other_file, opts, ctx: ctx)
+      #
+      def merge_file(current_file, base_file, other_file, opts = [], ctx: Context.new)
+        output, status = ctx.capture2e("git", "merge-file", current_file, base_file, other_file, *opts)
+
+        unless status.success?
+          ctx.abort(ctx.message("core.git.error.merge_failed"))
+        end
+
+        output
+      end
+
+      ##
+      # will initialize a new repo in the current directory. This will output
+      # if it was successful or not.
+      #
+      # #### Parameters
+      #
+      # * `ctx` - the current running context of your command, defaults to a new context.
+      #
+      # #### Example
+      #
+      #   FluidCLI::Git.init(@ctx)
+      #
+      def init(ctx)
+        output, status = ctx.capture2e("git", "status")
+
+        unless status.success?
+          ctx.abort(ctx.message("core.git.error.repo_not_initiated"))
+        end
+
+        if output.include?("No commits yet")
+          ctx.abort(ctx.message("core.git.error.no_commits_made"))
+        end
+      end
+
+      def sparse_checkout(repo, set, branch, ctx)
+        _, status = ctx.capture2e("git init")
+        unless status.success?
+          ctx.abort(ctx.message("core.git.error.repo_not_initiated"))
+        end
+
+        _, status = ctx.capture2e("git remote add -f origin #{repo}")
+        unless status.success?
+          ctx.abort(ctx.message("core.git.error.remote_not_added"))
+        end
+
+        _, status = ctx.capture2e("git config core.sparsecheckout true")
+        unless status.success?
+          ctx.abort(ctx.message("core.git.error.sparse_checkout_not_enabled"))
+        end
+
+        _, status = ctx.capture2e("git sparse-checkout set #{set}")
+        unless status.success?
+          ctx.abort(ctx.message("core.git.error.sparse_checkout_not_set"))
+        end
+
+        resp, status = ctx.capture2e("git pull origin #{branch}")
+        unless status.success?
+          if resp.include?("fatal: couldn't find remote ref")
+            ctx.abort(ctx.message("core.git.error.pull_failed_bad_branch", branch))
+          end
+          ctx.abort(ctx.message("core.git.error.pull_failed"))
+        end
+      end
+
+      ##
+      # handles showing the progress of the git clone command.
+      # if block given, assumes passing percent to block, otherwise
+      # increments bar for progress bar
+      #
+      # #### Parameters
+      #
+      # * `stderr` - Open3.popen3 output stream
+      # * `bar` - progress bar object to set percent
+      #
+      def clone_progress(stderr, bar: nil)
+        msg = []
+
+        while (line = stderr.gets)
+          msg << line.chomp
+          next unless line.strip.start_with?("Receiving objects:")
+          percent = (line.match(/Receiving objects:\s+(\d+)/)[1].to_f / 100).round(2)
+
+          if block_given?
+            yield percent
+          elsif !bar.nil?
+            bar.tick(set_percent: percent)
+          end
+        end
+
+        msg
+      end
+
+      private
+
+      def exec(*args, dir: Dir.pwd, default: nil, ctx: Context.new)
+        args = %w(git) + ["--git-dir", File.join(dir, ".git")] + args
+        out, _, stat = ctx.capture3(*args)
+        return default unless stat.success?
+        out.chomp
+      end
+
+      def rev_parse(*args, dir: nil, ctx: Context.new)
+        exec("rev-parse", *args, dir: dir, ctx: ctx)
+      end
+    end
+  end
+end

data/lib/fluid_cli/http_request.rb

@@ -0,0 +1,54 @@
+require "net/http"
+require "openssl"
+require 'net/http/post/multipart'
+
+module FluidCLI
+  class HttpRequest
+    class << self
+      def post(uri, body, headers)
+        req = ::Net::HTTP::Post.new(uri.request_uri)
+        request(uri, body, headers, req)
+      end
+
+      def put(uri, body, headers)
+        req = ::Net::HTTP::Put.new(uri.request_uri)
+        request(uri, body, headers, req)
+      end
+
+      def get(uri, body, headers)
+        req = ::Net::HTTP::Get.new(uri.request_uri)
+        request(uri, body, headers, req)
+      end
+
+      def delete(uri, body, headers)
+        req = ::Net::HTTP::Delete.new(uri.request_uri)
+        request(uri, body, headers, req)
+      end
+
+      def multipart_put(uri, body, headers)
+        req = Net::HTTP::Put::Multipart.new(uri.request_uri, body)
+        request(uri, nil, headers, req)
+      end
+
+      def request(uri, body, headers, req)
+        cert_store = OpenSSL::X509::Store.new
+        cert_store.set_default_paths
+
+        http = ::Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.cert_store = cert_store
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE if ENV["SSL_VERIFY_NONE"]
+
+        unless req.is_a?(Net::HTTP::Put::Multipart)
+          req.body = body unless body.nil?
+          req["Content-Type"] = "application/json"
+          headers.each { |header, value| req[header] = value }
+        else
+          headers.each { |header, value| req.add_field(header, value) }
+        end
+
+        http.request(req)
+      end
+    end
+  end
+end

data/lib/fluid_cli/identity_auth/servlet.rb

@@ -0,0 +1,39 @@
+module FluidCLI
+  class IdentityAuth
+    class Servlet < WEBrick::HTTPServlet::AbstractServlet
+      ERB_FILENAME = File.join(FluidCLI::ROOT, "lib/fluid_cli/assets/post_auth_page/index.html.erb")
+      CSS_FILENAME = File.join(FluidCLI::ROOT, "lib/fluid_cli/assets/post_auth_page/style.css")
+
+      def initialize(server, identity_auth, token)
+        super
+        @server = server
+        @identity_auth = identity_auth
+      end
+
+      def do_GET(req, res) # rubocop:disable Naming/MethodName
+        if !req.query["error"].nil?
+          respond_with(
+            res,
+            400,
+            req.query["error"],
+          )
+        else
+          respond_with(res, 200, "Authentication successful! You can close this window.")
+        end
+        @identity_auth.response_query = req.query
+        @server.shutdown
+      end
+
+      def respond_with(response, status, message)
+        successful = status == 200
+        locals = {
+          status: status,
+          message: message,
+          css: File.read(CSS_FILENAME),
+        }
+        response.status = status
+        response.body = ERB.new(File.read(ERB_FILENAME)).result(binding)
+      end
+    end
+  end
+end