abak-flow 1.0.10 → 1.1.0

data/lib/abak-flow/commands/done.rb

@@ -0,0 +1,80 @@
+# coding: utf-8
+module Abak::Flow
+  module Commands
+    class Done
+      include ANSI::Code
+
+      def run(args, options)
+        Checkup.new.process(Array.new, ::Commander::Command::Options.new)
+
+        branch = Branch.new(Manager.git.current_branch)
+
+        if branch.develop? || branch.master?
+          say red {
+            Manager.locale.error(self,
+              'branch.delete_now_allowed', branch: ANSI.bold { branch })
+          }
+
+          exit 105
+        end
+
+        delete_on_remote(branch)
+
+        # TODO : Быть может стоит вынести это в настройки
+        #        и позволить выбирать, куда отправлять
+        #        при удалении ветки, а по умолчанию использовать master
+        Manager.git.checkout(
+          branch.extract_base_name(if_undef: Branch::MASTER))
+
+        delete_on_local(branch)
+      end
+
+      private
+
+      def delete_on_remote(branch)
+        print white {
+          Manager.locale.word(self,
+            "deleting", branch: bold { branch },
+                        upstream: bold { "#{Manager.repository.origin}" })
+        }
+
+        begin
+          branch.delete_on_remote
+        rescue
+          say_branch_missed(branch, "#{Manager.repository.origin}")
+        else
+          say_done
+        end
+      end
+
+      def delete_on_local(branch)
+        print white {
+          Manager.locale.word(self,
+            "deleting", branch: bold { branch },
+                        upstream: bold { "working tree" })
+        }
+
+        begin
+          branch.delete_on_local
+        rescue
+          say_branch_missed(branch, "working tree")
+        else
+          say_done
+        end
+      end
+
+      def say_done
+        say green { " " << Manager.locale.word(self, "done") }
+      end
+
+      def say_branch_missed(branch, upstream)
+        puts
+        say yellow {
+          Manager.locale.error(self,
+            "branch.missed_on", branch: branch,
+                                upstream: upstream)
+        }
+      end
+    end
+  end
+end

data/lib/abak-flow/commands/publish.rb

@@ -0,0 +1,62 @@
+# coding: utf-8
+module Abak::Flow
+  module Commands
+    class Publish
+      include ANSI::Code
+
+      def run(args, options)
+        Checkup.new.process(Array.new, ::Commander::Command::Options.new)
+
+        head = Branch.new(Manager.git.current_branch)
+        base = Branch.new(options.base || head.extract_base_name)
+
+        title = options.title || head.extract_title
+        body  = options.body || head.extract_body
+
+        pr = PullRequest.new(base: base, head: head, title: title, body: body)
+        validate_request(pr)
+
+        say white {
+          Manager.locale.word(self, "updating",
+            branch: bold { head },
+            upstream: bold { "#{Manager.repository.origin}" })
+        }
+
+        head.update
+
+        say white {
+          Manager.locale.word(self, "publicating",
+            branch: bold { "#{Manager.repository.origin.owner}:#{head}" },
+            upstream: bold { "#{Manager.repository.origin}" })
+        }
+
+        publicate_request(pr)
+
+        say green { pr.link }
+      end
+
+      private
+
+      def validate_request(request)
+        inspector = Inspector.new(call_method: :valid?, collect_attribute: :errors)
+        inspector.examine(request).on_fail do |insp|
+          say red { Manager.locale.error(self) }
+          say yellow { insp.output }
+
+          exit 106
+        end
+      end
+
+      def publicate_request(request)
+        inspector = Inspector.new(call_method: :publish, collect_attribute: :errors)
+        inspector.examine(request).on_fail do |insp|
+          say red { Manager.locale.error(self, 'publication.failed') }
+          say yellow { insp.output }
+
+          exit 107
+        end
+      end
+
+    end
+  end
+end

data/lib/abak-flow/configuration.rb

@@ -1,68 +1,91 @@
 # coding: utf-8
-require "i18n"
-require "ruler"
 
 module Abak::Flow
   class Configuration
-    include Ruler
-
-    OPTIONS = [:oauth_user, :oauth_token, :locale, :http_proxy].freeze
-    LOCALE_FILES = File.join(File.dirname(__FILE__), "locales/*.{rb,yml}").freeze
+    # TODO: Add old oauth_login and oauth_token
+    AVAILABLE_OPTIONS = %w{login password locale http_proxy}.map(&:freeze)
+    GITCONFIG_PATTERN = /abak\-flow\.([\w\d\-\_]+)/.freeze
+
+    def initialize(options = nil)
+      @_errors = Hash.new
+      @options = {
+        login: nil,
+        password: nil,
+        locale: "en",
+        http_proxy: ENV["http_proxy"] || ENV["HTTP_PROXY"]
+      }
+
+      options.nil? ? define_options_from_gitconfig
+        : define_options_from_hash(options)
+
+      create_public_instance_methods
+    end
 
-    attr_reader :errors
+    def rewrite(options)
+      define_options_from_hash(options)
+      write_to_gitconfig!
+    end
 
-    def initialize(manager)
-      @manager = manager
-      @errors = []
+    def valid?
+      @_errors = Hash.new
+      @_errors["login"] = ['blank'] if @options[:login].to_s.empty?
+      @_errors["password"] = ['blank'] if @options[:password].to_s.empty?
 
-      configure!
+      @_errors.empty?
     end
 
-    def ready?
-      @errors = []
+    def errors
+      ErrorsPresenter.new(self, @_errors)
+    end
 
-      multi_ruleset do
-        fact(:oauth_user_not_setup)  { oauth_user.nil? }
-        fact(:oauth_token_not_setup) { oauth_token.nil? }
+    private
 
-        rule([:oauth_user_not_setup])  { @errors << I18n.t("configuration.errors.oauth_user_not_setup") }
-        rule([:oauth_token_not_setup]) { @errors << I18n.t("configuration.errors.oauth_token_not_setup") }
+    def create_public_instance_methods
+      AVAILABLE_OPTIONS.each do |name|
+        self.class.send(:define_method, name, -> { @options[name.to_sym] })
       end
-
-      @errors.empty? ? true : false
     end
 
-    def display_name
-      I18n.t("configuration.name")
-    end
+    def write_to_gitconfig!
+      AVAILABLE_OPTIONS.each do |name|
+        value = @options[name.to_sym]
 
-    private
-    def configure!
-      load_gitconfig
-      setup_locale
+        next if value.nil? || value.empty?
+        Manager.git.lib.global_config_set("abak-flow.#{name}", value)
+      end
     end
 
-    def setup_locale
-      I18n.enforce_available_locales = false
-      I18n.load_path += Dir.glob(LOCALE_FILES)
-      I18n.locale = locale
+    def define_options_from_hash(hash)
+      hash.each do|name, value|
+        name = underscore(name.to_s)
+        next unless AVAILABLE_OPTIONS.include?(name)
+
+        @options[name.to_sym] = value
+      end
     end
 
-    def load_gitconfig
-      git_config = @manager.git.config.select { |k, _| k.include? "abak-flow." }
-                               .map { |k,v| [to_method_name(k), v] }
+    def define_options_from_gitconfig
+      read_git_config do |name, value|
+        name = underscore(name)
+        next unless AVAILABLE_OPTIONS.include?(name)
 
-      config = Hash[git_config]
-      config[:locale] ||= "en"
-      config[:http_proxy] ||= ENV["http_proxy"] || ENV["HTTP_PROXY"]
+        @options[name.to_sym] = value
+      end
+    end
 
-      OPTIONS.each do |name|
-        define_singleton_method(name) { config[name] }
+    def read_git_config(&block)
+      Manager.git.config.each do |option, value|
+        matches = option.match(GITCONFIG_PATTERN)
+        block.call(underscore(matches[1]), value) if matches && matches[1]
       end
     end
 
-    def to_method_name(name)
-      name.sub(/abak-flow./, "").gsub(/\W/, "_").to_sym
+    def underscore(name)
+      name.tr("-", "_")
+    end
+
+    def dasherize(name)
+      name.tr("_", "-")
     end
-  end
-end
+  end # class Configuration
+end # module Abak::Flow

data/lib/abak-flow/errors_presenter.rb

@@ -0,0 +1,31 @@
+# coding: utf-8
+require "forwardable"
+
+module Abak::Flow
+  class ErrorsPresenter
+    extend Forwardable
+
+    def_delegators :@errors, :empty?, :each, :each_with_index
+
+    def initialize(object, errors)
+      @object = object
+      @object_errors = errors
+      @errors = create_human_readable_errors
+    end
+
+    private
+
+    def create_human_readable_errors
+      @object_errors.map do |field, errors|
+        field_name = Manager.locale.field(@object, field)
+
+        errors = errors.map do |error|
+          error = {field: error, options: Hash.new} unless error.is_a?(Hash)
+          Manager.locale.error(@object, "#{field}.#{error[:field]}", error[:options])
+        end
+
+        "#{field_name} – #{errors * ", "}"
+      end
+    end
+  end
+end

data/lib/abak-flow/inspector.rb

@@ -0,0 +1,36 @@
+# coding: utf-8
+require "ansi/code"
+
+module Abak::Flow
+  class Inspector
+    def initialize(options = Hash.new)
+      @objects = Array.new
+      @call_method = options.fetch(:call_method)
+      @collect_attribute = options.fetch(:collect_attribute)
+    end
+
+    def examine(*args)
+      @objects = args
+      @fail = @objects.map { |x| x.send(@call_method) }.any? { |x| not !!x }
+
+      self
+    end
+
+    def output
+      @objects.map do |object|
+        next if object.send(@collect_attribute).empty?
+
+        info = ""
+        object.send(@collect_attribute).each_with_index do |inf, idx|
+          info << "\n  #{idx + 1}. #{inf}"
+        end
+
+        "#{Manager.locale.name(object)}#{info}"
+      end * "\n"
+    end
+
+    def on_fail(&block)
+      block.call(self) if @fail
+    end
+  end # class Inspector
+end # module Abak::Flow

data/lib/abak-flow/locale.rb

@@ -0,0 +1,45 @@
+# coding: utf-8
+require "i18n"
+
+module Abak::Flow
+  class Locale
+    FILES = File.join(File.dirname(__FILE__), "locales/*.{rb,yml}").freeze
+
+    def initialize(locale)
+      I18n.enforce_available_locales = false
+      I18n.load_path += Dir.glob(FILES)
+      I18n.locale = locale
+    end
+
+    def name(object)
+      I18n.t("#{namenize object}.name")
+    end
+
+    def field(object, key)
+      I18n.t(key, scope: "#{namenize object}.fields")
+    end
+
+    def word(object, key, options = {})
+      I18n.t(key, options.merge(scope: "#{namenize object}.words"))
+    end
+
+    def error(object, key = nil, options = {})
+      key.nil? ? I18n.t("#{namenize object}.fail", options)
+        : I18n.t(key, options.merge(scope: "#{namenize object}.errors"))
+    end
+
+    def success(object, *args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      key = args[0]
+
+      key.nil? ? I18n.t("#{namenize object}.success", options)
+        : I18n.t(key, options.merge(scope: "#{namenize object}.success"))
+    end
+
+    private
+
+    def namenize(object)
+      object.class.name.downcase.gsub(/\:\:/, ".")
+    end
+  end # class Locale
+end # module Abak::Flow

data/lib/abak-flow/locales/en.yml

@@ -1,44 +1,82 @@
 en:
-  configuration:
-    name: Configuration
-    errors:
-      oauth_user_not_setup: Options oauth_user not setted
-      oauth_token_not_setup: Options oauth_token not setted
-    recommendations: "Check [abak-flow] section in ~/.gitcofig file"
+  abak:
+    flow:
+      commands:
+        checkup:
+          fail: You are not prepared!
+          success: Congratulations, you are ready to ROCK :)
 
-  repository:
-    name: Repository
-    errors:
-      origin_not_setup: Repository with name 'origin' not found
-      upstream_not_setup: Repository with name 'upstream' not found
-    recommendations: "Check .git/cofig file"
+        compare:
+          words:
+            updating: "Updating %{branch} → %{upstream}"
+            diverging: "Branches may diverging\nAdvice: switch to branch '%{branch}' and retry operation"
 
-  pull_request:
-    name: Pull Request
-    errors:
-      head_is_incorrect: Something wrong with 'head' branch
-      base_is_incorrect: Something wrong with 'base' branch
-      title_is_incorrect: Title is not specified
-      body_is_incorrect: Message body is not specified
+        configure:
+          fail: Something goes wrong!
+          success: Configuration generated and saved ↓
+          words:
+            email: Email
+            password: Password
+            locale: Locale
+            http_proxy: HTTP proxy
+            sms_otp: SMS OTP
+            configuring: Configuring
+          errors:
+            execution_failed: Github api request failed
+            empty_response: Github service respond with empty response body
 
-  commands:
-    default:
-      fail: Something goes wrong!
-    checkup:
-      fail: You are not prepared!
-      success: "Congratulations, you are ready to ROCK :)"
-    compare:
-      fail: Something goes wrong!
-      updating: "Updating %{branch} → %{upstream}"
-      diverging: "Branches may diverging\nAdvice: switch to branch '%{branch}' and retry operation"
-    publish:
-      fail: Something goes wrong!
-      success: "Pull request successfuly created %{link}"
-      requesting: "Creating pull request %{branch} → %{upstream}"
-      updating: "Updating %{branch} → %{upstream}"
-      nothing: I have nothing to say ...
-    done:
-      fail: Something goes wrong!
-      deleting: "Deleting %{branch} in %{upstream}"
-      errors:
-        branch_is_incorrect: "You can't delete %{branch}"
+        done:
+          words:
+            deleting: Deleting %{branch} in %{upstream}
+            done: √
+          errors:
+            branch:
+              delete_now_allowed: You can't delete %{branch}
+              missed_on: Branch %{branch} doesn`t exists on %{upstream}
+
+        publish:
+          fail: Goddamned, not again!
+          words:
+            updating: Updating %{branch} → %{upstream}
+            publicating: Creating pull request %{branch} → %{upstream}
+          errors:
+            publication:
+              failed: Some errors occurs while request publicating
+
+      configuration:
+        name: Configuration
+        fields:
+          login: Login
+          password: Password
+        errors:
+          login:
+            blank: Can't be blank
+          password:
+            blank: Can't be blank
+
+      repository:
+        name: Repository
+        fields:
+          origin: Origin
+          upstream: Upstream
+        errors:
+          origin:
+            not_set: Git remote 'origin' not set
+          upstream:
+            not_set: Git remote 'upstream' not set
+
+      pullrequest:
+        name: Pull Request
+        fields:
+          title: Title message
+          body: Body message
+          head: Head branch
+          base: Base branch
+          exception: Exception
+        errors:
+          head:
+            invalid: Branch name is invalid
+          base:
+            invalid: Branch name is invalid
+          exception:
+            message: "%{backtrace}"