gtlab 0.1.0

data/lib/commands/start.rb

@@ -0,0 +1,116 @@
+require 'sub_command'
+
+module Gitl
+  class Start < SubCommand
+
+    self.summary = '创建对应工作分支，并同步到gitlab.'
+
+    self.description = <<-DESC
+      创建对应工作分支，并同步到gitlab.
+    DESC
+
+    self.arguments = [
+        CLAide::Argument.new('working_branch', true, false),
+        CLAide::Argument.new('remote_branch', true, false),
+    ]
+
+    def self.options
+      [
+          ["--force", "忽略工作分支是否存在，强制执行"],
+      ].concat(super)
+    end
+
+    def initialize(argv)
+      @working_branch = argv.shift_argument
+      @remote_branch = argv.shift_argument
+      @force = argv.flag?('force')
+      super
+    end
+
+    def validate!
+      super
+      if @working_branch.nil?
+        help! 'working_branch is required.'
+      end
+      if @remote_branch.nil?
+        help! 'remote_branch is required.'
+      end
+    end
+
+    def run
+      remote = 'origin'
+      workspace_config = WorkSpaceConfig.new(@remote_branch, @working_branch)
+
+      self.gitl_config.projects.each do |project|
+        project_path = File.expand_path(project.name, './')
+        if File.exist?(project_path)
+          g = Git.open(project_path)
+        else
+          g = Git.clone(project.git, project.name, :path => './')
+        end
+
+        if self.verbose?
+          # g.setLogger(Logger.new(STDOUT))
+        end
+
+        check_uncommit(g, project.name)
+
+        # 更新本地代码
+        g.fetch(remote, :p => true, :t => true)
+        # g.pull_opts(remote, g.current_branch, :p => true)
+
+        if !g.is_remote_branch?(@remote_branch)
+          raise Error.new("remote branch '#{@remote_branch}' does not exist for project '#{project.name}'.")
+        end
+
+        if g.is_remote_branch?(@working_branch) && !@force
+          raise Error.new("branch '#{@working_branch}' exist in remote '#{remote}' for project '#{project.name}'.")
+        end
+
+        if g.is_local_branch?(@working_branch) && !@force
+          raise Error.new("branch '#{@working_branch}' exist in local for project '#{project.name}'.")
+        end
+
+        # g.remote(remote).branch(@remote_branch).checkout()
+        # g.branch(@remote_branch).checkout
+
+        # git_cmd = "git remote set-branches #{remote} '#{@remote_branch}'"
+        # puts `#{git_cmd}`.chomp
+        #
+        # git_cmd = "git fetch --depth 1 #{remote} '#{@remote_branch}'"
+        # puts `#{git_cmd}`.chomp
+        #
+        # $ git remote set-branches origin 'remote_branch_name'
+        # $ git fetch --depth 1 origin remote_branch_name
+        # $ git checkout remote_branch_name
+
+        g.checkout(@remote_branch)
+
+        g.pull(remote, @remote_branch)
+
+        if g.is_local_branch?(@working_branch)
+          g.checkout(@working_branch)
+          g.pull(remote, @working_branch)
+        else
+          puts "create branch '#{@working_branch}' for project '#{project.name}'.".green
+          # 创建本地工作分支
+          g.checkout(@working_branch, :new_branch => true)
+        end
+
+        # 跟踪远程分支
+        g.track(remote, @remote_branch)
+
+        puts "push branch '#{@working_branch}' to remote for project '#{project.name}'.".green
+        # push到origin
+        g.push(remote, @working_branch)
+
+        puts
+      end
+
+      #保存新的workspace配置
+      self.save_workspace_config(workspace_config)
+
+      puts "create work branch '#{@working_branch}' from #{@remote_branch} and push to '#{remote}' success.".green
+    end
+  end
+end

data/lib/commands/status.rb

@@ -0,0 +1,2 @@
+class Status
+end

data/lib/commands/sync.rb

@@ -0,0 +1,45 @@
+require 'sub_command'
+
+
+module Gitl
+
+  class Sync < SubCommand
+
+    self.summary = '更新工作分支代码'
+
+    self.description = <<-DESC
+      根据yml配置，更新代码.
+    DESC
+
+    def run_in_workspace
+
+      remote = 'origin'
+      workspace_config = self.workspace_config
+
+      info "current work branch '#{workspace_config.workspace_branch}', remote branch '#{workspace_config.remote_branch}'."
+
+      self.gitl_config.projects.each do |project|
+        project_path = File.expand_path(project.name, './')
+
+        if File.exist?(project_path)
+          info "sync project '#{project.name}'..."
+          g = Git.open(project_path)
+          if workspace_config.workspace_branch != g.current_branch
+            error "current branch is not work branch(#{workspace_config.workspace_branch})."
+            exit(1)
+          end
+          g.fetch(remote, :p => true, :t => true)
+          g.pull("origin", workspace_config.workspace_branch)
+          g.pull("origin", workspace_config.remote_branch)
+          puts
+
+        else
+          error "please run 'gitl init' first."
+          break
+        end
+
+      end
+    end
+
+  end
+end

data/lib/config/gitl_config.rb

@@ -0,0 +1,71 @@
+module Gitl
+  class GitlConfig
+
+    attr_reader :projects
+    attr_reader :gitlab
+    attr_reader :config_path
+
+    def initialize(config_path, node)
+      @config_path = config_path
+
+      gitlab = node['gitlab']
+      @gitlab = GitlabConfig.new(gitlab)
+
+      @projects = []
+      projects = node['projects']
+      projects.each do |project|
+        projectConfig = ProjectConfig.new(project)
+        @projects << projectConfig
+      end
+    end
+
+    def self.load_file(config_path)
+      node = YAML.load_file(config_path)
+      GitlConfig.new(config_path, node)
+    end
+
+    def self.load_yml(yml)
+      node = YAML.load(yml)
+      GitlConfig.new(nil, node)
+    end
+
+    def to_dictionary
+      projects = self.projects.map do |project|
+        project.to_dictionary
+      end
+      {"projects"=>projects, "gitlab"=>self.gitlab.to_dictionary}
+    end
+
+    class ProjectConfig
+      attr_reader :name
+      attr_reader :git
+
+      def initialize(node)
+        @name = node['name']
+        @git = node['git']
+      end
+
+      def to_dictionary
+        {"name"=>self.name, "git"=>self.git}
+      end
+
+    end
+
+    class GitlabConfig
+      attr_reader :endpoint
+      attr_accessor :private_token
+
+      def initialize(node)
+        @endpoint = node['endpoint']
+        @private_token = node['private_token']
+      end
+
+      def to_dictionary
+        {"endpoint"=>self.endpoint, "private_token"=>private_token}
+      end
+
+    end
+
+  end
+end
+

data/lib/config/work_space_config.rb

@@ -0,0 +1,25 @@
+
+module Gitl
+  class WorkSpaceConfig
+    attr_reader :remote_branch
+    attr_reader :workspace_branch
+
+    def initialize(remote_branch, workspace_branch)
+      @remote_branch = remote_branch
+      @workspace_branch = workspace_branch
+    end
+
+    def self.load_file(yaml_filename)
+      node = YAML.load_file(yaml_filename)
+      remote_branch = node['remote_branch']
+      workspace_branch = node['workspace_branch']
+      return WorkSpaceConfig.new(remote_branch, workspace_branch)
+    end
+
+    def save(path)
+      File.open(path, 'w') do |file|
+        Psych.dump({'remote_branch' => @remote_branch, 'workspace_branch' => @workspace_branch}, file)
+      end
+    end
+  end
+end

data/lib/git_ext.rb

@@ -0,0 +1,120 @@
+require 'git'
+
+
+module Git
+  def self.clone_without_env(repository, name, opts = {})
+    opts = Git::Lib.new.clone_without_env(repository, name, opts)
+    Base.new(opts)
+  end
+end
+
+module Patches
+  module Git
+
+    module Base
+
+      def track(remote, branch)
+        self.lib.track(remote, branch)
+      end
+
+    end
+    module Lib
+      def initialize(*args)
+        super
+        # @logger = Logger.new(STDOUT)
+      end
+
+      def run_command(git_cmd, &block)
+        git_cmd = git_cmd.gsub(/2>&1$/, '')
+        return IO.popen(git_cmd, &block) if block_given?
+
+        `#{git_cmd}`.chomp
+      end
+
+      def track(remote, branch)
+        arr_opts = []
+        arr_opts << '-u'
+        arr_opts << "#{remote}/#{branch}"
+        command('branch', arr_opts)
+      end
+
+      def clone_without_env(repository, name, opts = {})
+        @path = opts[:path] || '.'
+        clone_dir = opts[:path] ? File.join(@path, name) : name
+
+        arr_opts = []
+        arr_opts << '--bare' if opts[:bare]
+        arr_opts << '--branch' << opts[:branch] if opts[:branch]
+        arr_opts << '--depth' << opts[:depth].to_i if opts[:depth] && opts[:depth].to_i > 0
+        arr_opts << '--config' << opts[:gitl_config] if opts[:gitl_config]
+        arr_opts << '--origin' << opts[:remote] || opts[:origin] if opts[:remote] || opts[:origin]
+        arr_opts << '--recursive' if opts[:recursive]
+        arr_opts << "--mirror" if opts[:mirror]
+
+        arr_opts << '--'
+
+        arr_opts << repository
+        arr_opts << clone_dir
+
+        command_without_env('clone', arr_opts)
+
+        (opts[:bare] or opts[:mirror]) ? {:repository => clone_dir} : {:working_directory => clone_dir}
+      end
+
+      def command_without_env(cmd, opts = [], chdir = true, redirect = '', &block)
+        global_opts = []
+        global_opts << "--git-dir=#{@git_dir}" if !@git_dir.nil?
+        global_opts << "--work-tree=#{@git_work_dir}" if !@git_work_dir.nil?
+
+        opts = [opts].flatten.map {|s| escape(s) }.join(' ')
+
+        global_opts = global_opts.flatten.map {|s| escape(s) }.join(' ')
+
+        git_cmd = "#{::Git::Base.config.binary_path} #{global_opts} #{cmd} #{opts} #{redirect} 2>&1"
+
+        output = nil
+
+        command_thread = nil;
+
+        exitstatus = nil
+
+        command_thread = Thread.new do
+          output = run_command(git_cmd, &block)
+          exitstatus = $?.exitstatus
+        end
+        command_thread.join
+
+        if @logger
+          @logger.info(git_cmd)
+          @logger.debug(output)
+        end
+
+        if exitstatus > 1 || (exitstatus == 1 && output != '')
+          raise Git::GitExecuteError.new(git_cmd + ':' + output.to_s)
+        end
+
+        return output
+      end
+
+    end
+
+    module Status
+      def fetch_untracked
+        ignore = @base.lib.ignored_files
+
+        Dir.chdir(@base.dir.path) do
+          Dir.glob('**/*', File::FNM_DOTMATCH) do |file|
+            next if @files[file] || File.directory?(file) ||
+                ignore.include?(file) || file =~ %r{^.git\/.+} || file =~ %r{^(.*\/)?.gitkeep$}
+
+            @files[file] = { path: file, untracked: true }
+          end
+        end
+      end
+    end
+  end
+end
+
+Git::Status.prepend(Patches::Git::Status)
+Git::Lib.prepend(Patches::Git::Lib)
+Git::Base.prepend(Patches::Git::Base)

data/lib/gitl.rb

@@ -0,0 +1,8 @@
+require 'gitl/version'
+
+
+module Gitl
+
+
+
+end

data/lib/gitl/version.rb

@@ -0,0 +1,3 @@
+module Gitl
+  VERSION = "0.1.0"
+end

data/lib/gitlab_ext.rb

@@ -0,0 +1,26 @@
+
+
+module Patches
+  # Defines methods related to projects.
+  # @see https://docs.gitlab.com/ce/api/projects.html
+  module Projects
+
+    # Gets a list of project users.
+    #
+    # @example
+    #   Gitlab.project_usesrs(42)
+    #   Gitlab.project_usesrs('gitlab')
+    #
+    # @param  [Integer, String] project The ID or path of a project.
+    # @param  [Hash] options A customizable set of options.
+    # @option options [Integer] :page The page number.
+    # @option options [Integer] :per_page The number of results per page.
+    # @return [Array<Gitlab::ObjectifiedHash>]
+    def project_usesrs(project, options = {})
+      get("/projects/#{url_encode project}/users", query: options)
+    end
+  end
+end
+
+
+Gitlab::Client.prepend(Patches::Projects)

data/lib/sub_command.rb

@@ -0,0 +1,139 @@
+require 'command'
+require 'rubygems'
+require 'config/gitl_config'
+require 'colored2'
+require 'gitlab'
+require 'git_ext'
+require 'yaml'
+
+module Gitl
+  class SubCommand < Command
+
+    self.ignore_in_command_lookup = true
+    attr_reader :gitl_config
+
+    def self.options
+      [
+          ['--config=[Gitl.yml]', 'gitl配置, 默认为Gitl.yml'],
+      ].concat(super)
+    end
+
+    def initialize(argv)
+      @yml = argv.option('config')
+      if @yml.nil?
+        @yml = 'Gitl.yml'
+      end
+      super
+    end
+
+    def validate!
+      super
+    end
+
+    def run
+      workspace_path = "./"
+      find_workspace = false;
+      begin
+        result = nil
+        Dir.chdir(workspace_path) do
+          result = Dir.glob('.gitl', File::FNM_DOTMATCH)
+        end
+        if result.length > 0
+          find_workspace = true
+          break
+        else
+          workspace_path = File.expand_path("../", workspace_path)
+        end
+      end while workspace_path.length > 0 && workspace_path != "/"
+
+      if find_workspace
+        Dir.chdir(workspace_path) do
+          self.run_in_workspace()
+        end
+      else
+        raise Error.new("Current path is not gitl workspace.")
+      end
+    end
+
+    def run_in_workspace
+
+    end
+
+    def gitl_config
+      if File.exist?(@yml)
+        @gitl_config = GitlConfig.load_file(@yml)
+      else
+        help! 'config is required.'
+      end
+      @gitl_config
+    end
+
+    def workspace_config
+      if @workspace_config.nil?
+        filename = '.gitl'
+        # workspace_config_path = File.expand_path(filename, File.dirname(self.gitl_config.config_path))
+        workspace_config_path = filename
+        if !File.exist?(workspace_config_path)
+          help! "workspace config not found. please run 'gitl start' first."
+        end
+        @workspace_config = WorkSpaceConfig.load_file(workspace_config_path)
+      end
+      @workspace_config
+    end
+
+    def save_workspace_config(workspace_config)
+      filename = '.gitl'
+      # workspace_config_path = File.expand_path(filename, File.dirname(self.gitl_config.config_path))
+      workspace_config_path = filename
+      workspace_config.save(workspace_config_path)
+      @workspace_config = workspace_config
+    end
+
+    def check_uncommit(g, project_name)
+      changed = g.status.changed
+      added = g.status.added
+      deleted = g.status.deleted
+      untracked = g.status.untracked
+
+      if !changed.empty?
+        alert = true
+        puts "modified files:".red
+        changed.each do |file, status|
+          puts ("        M:        " << file).red
+        end
+      end
+
+      if !added.empty?
+        alert = true
+        puts "added files:".red
+        added.each do |file, status|
+          puts ("        A:        " << file).red
+        end
+      end
+
+      if !deleted.empty?
+        alert = true
+        puts "deleted files:".red
+        deleted.each do |file, status|
+          puts ("        D:        " << file).red
+        end
+      end
+
+      if !untracked.empty?
+        alert = true
+        puts "untracked files:".red
+        untracked.each do |file, status|
+          puts ("        " << file).red
+        end
+      end
+
+      if alert
+        puts "exist uncommit files in current branch '#{g.current_branch}' for '#{project_name}'. ignore it? y/n "
+        flag = STDIN.gets.chomp
+        unless flag.downcase == "y"
+          exit
+        end
+      end
+    end
+  end
+end