gitdocs 0.5.0 → 0.6.0

data/lib/gitdocs/cli.rb

@@ -13,20 +13,28 @@ module Gitdocs
     end
 
     desc 'start', 'Starts a daemonized gitdocs process'
-    method_option :debug, type: :boolean, aliases: '-D'
-    method_option :port, type: :string, aliases: '-p'
-    method_option :pid, type: :string, aliases: '-P'
+    method_option :foreground, type: :boolean, aliases: '-fg'
+    method_option :verbose,    type: :boolean, aliases: '-v'
+    method_option :port,       type: :string,  aliases: '-p'
+    method_option :pid,        type: :string,  aliases: '-P'
     def start
       unless stopped?
         say 'Gitdocs is already running, please use restart', :red
         return
       end
 
-      if options[:debug]
-        say 'Starting in debug mode', :yellow
-        Gitdocs.start(debug: true, port: options[:port])
+      Gitdocs::Initializer.verbose = options[:verbose]
+
+      if options[:foreground]
+        say 'Run in the foreground', :yellow
+        Gitdocs::Initializer.foreground = true
+        Manager.start(web_port)
       else
-        runner.execute { Gitdocs.start(port: options[:port]) }
+        # Clear the arguments so that they will not be processed by the
+        # Dante execution.
+        ARGV.clear
+        runner.execute { Manager.start(web_port) }
+
         if running?
           say 'Started gitdocs', :green
         else
@@ -57,7 +65,7 @@ module Gitdocs
     method_option :pid, type: :string, aliases: '-P'
     desc 'add PATH', 'Adds a path to gitdocs'
     def add(path)
-      config.add_path(path)
+      Share.create_by_path!(normalize_path(path))
       say "Added path #{path} to doc list"
       restart if running?
     end
@@ -65,21 +73,23 @@ module Gitdocs
     method_option :pid, type: :string, aliases: '-P'
     desc 'rm PATH', 'Removes a path from gitdocs'
     def rm(path)
-      config.remove_path(path)
+      Share.remove_by_path(path)
       say "Removed path #{path} from doc list"
       restart if running?
     end
 
+    method_option :pid, type: :string, aliases: '-P'
     desc 'clear', 'Clears all paths from gitdocs'
     def clear
-      config.clear
+      Share.destroy_all
       say 'Cleared paths from gitdocs'
+      restart if running?
     end
 
     method_option :pid, type: :string, aliases: '-P'
     desc 'create PATH REMOTE', 'Creates a new gitdoc root based on an existing remote'
     def create(path, remote)
-      Gitdocs::Repository.clone(path, remote)
+      Repository.clone(path, remote)
       add(path)
       say "Created #{path} path for gitdoc"
     end
@@ -89,11 +99,11 @@ module Gitdocs
     def status
       say "GitDoc v#{VERSION}"
       say "Running: #{running?}"
-      say "File System Watch Method: #{file_system_watch_method}"
+      say "File System Watch Method: #{Gitdocs::Manager.listen_method}"
       say 'Watched repositories:'
       tp.set(:max_width, 100)
       status_display = lambda do |share|
-        repository = Gitdocs::Repository.new(share)
+        repository = Repository.new(share)
 
         status = ''
         status += '*' if repository.dirty?
@@ -103,7 +113,7 @@ module Gitdocs
         status
       end
       tp(
-        config.shares,
+        Share.all,
         { sync: { display_method: :sync_type } },
         { s: status_display },
         :path
@@ -119,8 +129,6 @@ module Gitdocs
         return
       end
 
-      web_port = options[:port]
-      web_port ||= config.web_frontend_port
       Launchy.open("http://localhost:#{web_port}/")
     end
 
@@ -137,42 +145,43 @@ module Gitdocs
 
     # Helpers for thor
     no_tasks do
+      # @return [Dante::Runner]
       def runner
         Dante::Runner.new(
           'gitdocs',
           debug:     false,
           daemonize: true,
-          pid_path: pid_path
+          pid_path:  pid_path,
+          log_path:  Gitdocs.log_path
         )
       end
 
-      def config
-        @config ||= Configuration.new
-      end
-
+      # @return [Boolean]
       def running?
         runner.daemon_running?
       end
 
+      # @return [Boolean]
       def stopped?
         runner.daemon_stopped?
       end
 
+      # @return [String]
       def pid_path
         options[:pid] || '/tmp/gitdocs.pid'
       end
 
-      # @return [Symbol] to indicate how the file system is being watched
-      def file_system_watch_method # rubocop:disable CyclomaticComplexity
-        if Guard::Listener.mac? && Guard::Darwin.usable?
-          :notification
-        elsif Guard::Listener.linux? && Guard::Linux.usable?
-          :notification
-        elsif Guard::Listener.windows? && Guard::Windows.usable?
-          :notification
-        else
-          :polling
-        end
+      # @return [Integer]
+      def web_port
+        result = options[:port]
+        result ||= Configuration.web_frontend_port
+        result.to_i
+      end
+
+      # @param [String] path
+      # @return [String]
+      def normalize_path(path)
+        File.expand_path(path, Dir.pwd)
       end
     end
   end

data/lib/gitdocs/configuration.rb

@@ -1,112 +1,51 @@
 # -*- encoding : utf-8 -*-
 
 require 'active_record'
-require 'grit'
 
-class Gitdocs::Configuration
-  attr_reader :config_root
-
-  def initialize(config_root = nil)
-    @config_root = config_root || File.expand_path('.gitdocs', ENV['HOME'])
-    FileUtils.mkdir_p(@config_root)
-    ActiveRecord::Base.establish_connection(
-      adapter: 'sqlite3',
-      database: ENV['TEST'] ? ':memory:' : File.join(@config_root, 'config.db')
-    )
-    ActiveRecord::Migrator.migrate(File.expand_path('../migration', __FILE__))
-    import_old_shares unless ENV['TEST']
-  end
-
-  class Share < ActiveRecord::Base
-    #attr_accessible :polling_interval, :path, :notification, :branch_name, :remote_name, :sync_type
-  end
-
-  class Config < ActiveRecord::Base
-    #attr_accessible :start_web_frontend, :web_frontend_port
-  end
-
-  # return [Boolean]
-  def start_web_frontend
-    global.start_web_frontend
-  end
-
-  # @return [Integer]
-  def web_frontend_port
-    global.web_frontend_port
-  end
-
-  # @param [String] path
-  # @param [Hash] opts
-  def add_path(path, opts = nil)
-    path = normalize_path(path)
-    path_opts = { path: path }
-    path_opts.merge!(opts) if opts
-    Share.new(path_opts).save!
-  end
-
-  # @param [Hash] new_config
-  # @option new_config [Hash] 'config'
-  # @option new_config [Array<Hash>] 'share'
-  def update_all(new_config)
-    global.update_attributes(new_config['config'])
-    new_config['share'].each do |index, share_config|
-      # Skip the share update if there is no path specified.
-      next unless share_config['path'] && !share_config['path'].empty?
-
-      # Split the remote_branch into remote and branch
-      remote_branch = share_config.delete('remote_branch')
-      if remote_branch
-        share_config['remote_name'], share_config['branch_name'] = remote_branch.split('/', 2)
-      end
-      shares[index.to_i].update_attributes(share_config)
+# @!attribute path
+#   @return [String]
+# @!attribute polling_interval
+#   @return [Double] defaults to 15.0
+# @!attribute notification
+#   @return [Boolean] default to true
+# @!attribute remote_name
+#   @return [String] default to 'origin'
+# @!attribute remote_branch
+#   @return [String] default to 'master'
+# @attribute sync_type
+#   @return ['full','fetch']
+module Gitdocs
+  class Configuration
+    # @return [Boolean]
+    def self.start_web_frontend
+      Config.global.start_web_frontend
     end
-  end
 
-  # @param [String] path of the share to remove
-  def remove_path(path)
-    path = normalize_path(path)
-    Share.where(path: path).destroy_all
-  end
-
-  # @param [Integer] id of the share to remove
-  #
-  # @return [true] share was deleted
-  # @return [false] share does not exist
-  def remove_by_id(id)
-    Share.find(id).destroy
-    true
-  rescue ActiveRecord::RecordNotFound
-    false
-  end
-
-  def clear
-    Share.destroy_all
-  end
-
-  def shares
-    Share.all
-  end
-
-  ##############################################################################
-
-  private
-
-  def global
-    fail if Config.all.size > 1
-    Config.create! if Config.all.empty?
-    Config.all.first
-  end
-
-  def normalize_path(path)
-    File.expand_path(path, Dir.pwd)
-  end
+    # @return [Integer]
+    def self.web_frontend_port
+      Config.global.web_frontend_port
+    end
 
-  def import_old_shares
-    full_path = File.expand_path('paths', config_root)
-    return unless File.exist?(full_path)
+    # @param [Hash] new_config
+    def self.update(new_config)
+      Config.global.update_attributes(new_config)
+    end
 
-    File.read(full_path).split("\n").each do |path|
-      Share.find_or_create_by_path(path)
+    # NOTE: This record has been kept as a subclass to avoid changing the
+    # database table. There are other ways to achieve this, but this seemed most
+    # clear for now. [2015-06-26 -- acant]
+    #
+    # @!attribute start_frontend_port
+    #   @return [Boolean] defaults to true
+    # @!attribute web_frontend_port
+    #   @return [Integer] defaults to 8888
+    class Config < ActiveRecord::Base
+      # @return [Gitdocs::Configuration::Config]
+      def self.global
+        fail if all.size > 1
+        create! if all.empty?
+        all.first
+      end
     end
   end
 end

data/lib/gitdocs/git_notifier.rb

@@ -0,0 +1,111 @@
+# -*- encoding : utf-8 -*-
+
+# Notifications about git specific operations
+module Gitdocs
+  class GitNotifier
+    # @param [String] root
+    # @param [Boolean] show_notifications
+    def initialize(root, show_notifications)
+      @root               = root
+      @show_notifications = show_notifications
+    end
+
+    # @param [nil, Symbol, Array<String>, Hash<String => Integer>, #to_s] result
+    #
+    # @return [void]
+    def for_merge(result)
+      return if result.nil?
+      return if result == :no_remote
+      return if result == :ok
+      return if result == {}
+
+      if result.is_a?(Array)
+        Notifier.warn(
+          'There were some conflicts',
+          result.map { |f| "* #{f}" }.join("\n"),
+          @show_notifications
+        )
+      elsif result.is_a?(Hash)
+        Notifier.info(
+          "Updated with #{change_to_s(result)}",
+          "In #{@root}:\n#{author_list(result)}",
+          @show_notifications
+        )
+      else
+        Notifier.error(
+          'There was a problem synchronizing this gitdoc',
+          "A problem occurred in #{@root}:\n#{result}",
+          @show_notifications
+        )
+      end
+      nil
+    end
+
+    # @param [nil, Symbol, Hash<String => Integer>, #to_s] result of push
+    #
+    # @return [void]
+    def for_push(result)
+      return if result.nil?
+      return if result == :no_remote
+      return if result == :nothing
+
+      if result == :conflict
+        Notifier.warn(
+          "There was a conflict in #{@root}, retrying",
+          '',
+          @show_notifications
+        )
+      elsif result.is_a?(Hash)
+        Notifier.info(
+          "Pushed #{change_to_s(result)}",
+          "#{@root} has been pushed",
+          @show_notifications
+        )
+      else
+        Notifier.error(
+          "BAD Could not push changes in #{@root}",
+          result.to_s,
+          @show_notifications
+        )
+      end
+      nil
+    end
+
+    # @param [Exception] exception
+    #
+    # @return [void]
+    def on_error(exception)
+      Notifier.error(
+        "Unexpected error when fetching/pushing in #{@root}",
+        exception.to_s,
+        @show_notifications
+      )
+      nil
+    end
+
+    ############################################################################
+
+    private
+
+    # @param [Hash<String => Integer>] changes
+    # @return [String]
+    def author_list(changes)
+      changes
+        .map { |author, count| "* #{author} (#{change_to_s(count)})" }
+        .join("\n")
+    end
+
+    # @param [Integer, Hash<String => Integer>] count_or_hash
+    # @return [String]
+    def change_to_s(count_or_hash)
+      count =
+        if count_or_hash.respond_to?(:values)
+          count_or_hash.values.reduce(:+)
+        else
+          count_or_hash
+        end
+
+      "#{count} change#{count == 1 ? '' : 's'}"
+    end
+  end
+end

data/lib/gitdocs/initializer.rb

@@ -0,0 +1,83 @@
+# -*- encoding : utf-8 -*-
+
+require 'active_record'
+
+module Gitdocs
+  class Initializer
+    # @return [nil]
+    def self.initialize_all
+      initialize_database
+      initialize_old_paths
+    end
+
+    # @return [nil]
+    def self.initialize_database
+      FileUtils.mkdir_p(root_dirname)
+      ActiveRecord::Base.establish_connection(
+        adapter: 'sqlite3',
+        database: database
+      )
+      ActiveRecord::Migrator.migrate(
+        File.expand_path('../migration', __FILE__)
+      )
+    end
+
+    # @return [nil]
+    def self.initialize_old_paths
+      old_path_dirname = File.expand_path('paths', root_dirname)
+      return unless File.exist?(old_path_dirname)
+
+      File.read(old_path_dirname).split("\n").each do |path|
+        begin
+          Share.create_by_path!(path)
+        rescue # rubocop:disable HandleExceptions
+          # Nothing to do, because we want the process to keep going.
+        end
+      end
+    end
+
+    # @return [String]
+    def self.root_dirname
+      @root_dirname ||= File.expand_path('.gitdocs', ENV['HOME'])
+    end
+
+    # @param [nil, String] value
+    # @return [nil]
+    def self.root_dirname=(value)
+      return if value.nil?
+      @root_dirname = value
+    end
+
+    # @return [String]
+    def self.database
+      @database ||= File.join(root_dirname, 'config.db')
+    end
+
+    # @param [nil, String] value
+    # @return [nil]
+    def self.database=(value)
+      return if value.nil?
+      @database = value
+    end
+
+    # @return [Boolean]
+    def self.foreground
+      @foreground ||= false
+    end
+
+    def self.foreground=(value)
+      return if value.nil?
+      @foreground = value
+    end
+
+    # @return [Boolean]
+    def self.verbose
+      @verbose ||= false
+    end
+
+    # @param [Boolean] value
+    def self.verbose=(value)
+      @verbose = !!value # rubocop:disable DoubleNegation
+    end
+  end
+end