ruby-pomodoro 0.4.0

data/lib/ruby/pomodoro/notification_observer.rb

@@ -0,0 +1,32 @@
+module Ruby
+  module Pomodoro
+    class NotificationObserver
+      # @param stop [Ruby::Pomodoro::Notification]
+      # @param pause [Ruby::Pomodoro::Notification]
+      # @param time [Numeric] repeat notifications interval in seconds
+      def initialize(stop:, pause:, time:, printer: Printer.new)
+        @stop_notification = stop
+        @pause_notification = pause
+        @time = time
+        @printer = printer
+      end
+
+      # @param [Symbol] event
+      def update(event)
+        case event
+        when :finish
+          @stop_notification.notify(@time)
+          @printer.print_line "_Task #{Worker.instance.current_task.name} was stopped, type [\u21e7 + R] for resume\r",
+                        color: :red
+        when :pause
+          @pause_notification.notify(@time, skip_now: true)
+        when :stop, :start
+          @pause_notification.stop
+          @stop_notification.stop
+        else
+          @pause_notification.stop
+        end
+      end
+    end
+  end
+end

data/lib/ruby/pomodoro/printer.rb

@@ -0,0 +1,56 @@
+module Ruby
+  module Pomodoro
+    class Printer
+      def initialize(stream: $stdout, cursor: TTY::Cursor, palette: Pastel.new)
+        @stream = stream
+        @cursor = cursor
+        @palette = palette
+      end
+
+      def print_template(template_name, cmd_binding)
+        @__cmd_binding = cmd_binding
+        stream.print(render(template_name))
+      end
+
+      def clear_terminal
+        stream.print(cursor.up(100))
+        stream.print(cursor.clear_screen_down)
+      end
+
+      def print(text, color: nil)
+        if color
+          stream.print(palette.send(color, text))
+        else
+          stream.print(text)
+        end
+        stream.flush
+      end
+
+      def print_line(text, color: nil)
+        cursor.clear_line
+        print(text, color: color)
+      end
+
+
+      def render(file_name)
+        ERB.new(read_file(file_name)).result(@__cmd_binding)
+      end
+
+      private
+
+      attr_reader :stream, :cursor, :palette
+
+
+      def read_file(file_name_or_path)
+        if file_name_or_path.kind_of?(Symbol)
+          path = File.expand_path(
+            "../../../#{File.join("view", "#{file_name_or_path}.txt.erb")}", __FILE__
+          )
+          File.read(path)
+        else
+          File.read(file_name_or_path)
+        end
+      end
+    end
+  end
+end

data/lib/ruby/pomodoro/progressbar.rb

@@ -0,0 +1,32 @@
+module Ruby
+  module Pomodoro
+    class Progressbar
+      def initialize(seconds:, printer: Ruby::Pomodoro::Printer.new)
+        @all_seconds = seconds
+        @spent_seconds = 0
+        @printer = printer
+      end
+
+      def start(text)
+        @text = text
+      end
+
+      def increment
+        @spent_seconds += 1
+        print
+      end
+
+      private
+
+      def print
+        @printer.print " In progress: #{@text} [#{strftime}]\r", color: :green
+      end
+
+      def strftime
+        seconds = @all_seconds - @spent_seconds
+        minutes = seconds / 60
+        "#{minutes} m #{seconds - minutes * 60} s"
+      end
+    end
+  end
+end

data/lib/ruby/pomodoro/task.rb

@@ -0,0 +1,25 @@
+module Ruby
+  module Pomodoro
+    # Task for [Ruby::Pomodoro::Worker]
+    class Task
+      attr_reader :name, :pomodors, :spent_time
+
+      def initialize(name, spent_time: 0)
+        @name = name
+        @spent_time = spent_time
+        @pomodors = 0
+      end
+
+      # @return [Integer]
+      def add_pomodoro
+        @pomodors += 1
+      end
+
+      # @param [Integer] seconds
+      # @return [Integer]
+      def track(seconds)
+        @spent_time += seconds
+      end
+    end
+  end
+end

data/lib/ruby/pomodoro/tasks/editor.rb

@@ -0,0 +1,65 @@
+module Ruby
+  module Pomodoro
+    module Tasks
+      class Editor
+        attr_reader :tasks_repo, :editor, :file_path
+
+        # @param [Array<Ruby::Pomodoro::Task>] tasks_repo
+        # @param [String] file_path
+        # @param editor [Class, Object] Editor with method open, for create and open file
+        def initialize(tasks_repo: Resource, file_path: Ruby::Pomodoro.tasks_file_path, editor: TTY::Editor)
+          @tasks_repo = tasks_repo
+          @file_path = file_path
+          @editor = editor
+        end
+
+        # Open editor and save tasks from tmp file to task_repo
+        # @return [TrueClass]
+        def edit
+          save
+          editor.open(file_path)
+          create_tasks
+          true
+        end
+
+        # save list to disc
+        # @return [TrueClass]
+        def save
+          File.open(file_path, "w") do |f|
+            if @tasks_repo.size > 0
+              f.puts(@tasks_repo.all.map {|task| print_task(task) }.join("\n"))
+            end
+          end
+          true
+        end
+
+        # Load tasks form file
+        # @return [TrueClass]
+        def load
+          create_tasks
+          true
+        end
+
+        private
+
+        def read_tmp_file
+          File.readlines(file_path)
+        end
+
+        def create_tasks
+          tasks_repo.delete_all
+          read_tmp_file.each do |line|
+            next unless line
+
+            name, time = line.split("|").compact.map {|l| l.chomp.strip }
+            tasks_repo.create(name: name, spent_time: TimeConverter.to_seconds(time))
+          end
+        end
+
+        def print_task(task)
+          "#{task.name} | #{TimeConverter.to_format_string(task.spent_time)}"
+        end
+      end
+    end
+  end
+end

data/lib/ruby/pomodoro/tasks/entity.rb

@@ -0,0 +1,27 @@
+module Ruby
+  module Pomodoro
+    module Tasks
+      class Entity
+        attr_reader :name, :pomodors, :spent_time, :id
+
+        def initialize(name:, spent_time: 0, id: nil)
+          @name = name
+          @spent_time = spent_time
+          @pomodors = 0
+          @id = id
+        end
+
+        # @return [Integer]
+        def add_pomodoro
+          @pomodors += 1
+        end
+
+        # @param [Integer] seconds
+        # @return [Integer]
+        def track(seconds)
+          @spent_time += seconds
+        end
+      end
+    end
+  end
+end

data/lib/ruby/pomodoro/tasks/resource.rb

@@ -0,0 +1,42 @@
+module Ruby
+  module Pomodoro
+    module Tasks
+      class Resource
+        class << self
+          extend Forwardable
+
+          delegate size: :store
+
+          def create(attributes)
+            id = store.size.next
+            Entity.new(id: id, **attributes.slice(:name, :spent_time)).tap do |task|
+              store[id] = task
+            end
+          end
+
+          def find(id)
+            store[id]
+          end
+
+          def all
+            store.values
+          end
+
+          def delete_all
+            store.clear
+          end
+
+          def sum(attribute)
+            all.inject(0) { |sum, task| sum + task.public_send(attribute).to_i }
+          end
+
+          private
+
+          def store
+            @store ||= {}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby/pomodoro/terminal_notifier_channel.rb

@@ -0,0 +1,13 @@
+module Ruby
+  module Pomodoro
+    module TerminalNotifierChannel
+      module_function
+
+      def call(message)
+        TerminalNotifier.notify(
+          message, title: "RubyPomodoro", sound: "default"
+        )
+      end
+    end
+  end
+end

data/lib/ruby/pomodoro/time_converter.rb

@@ -0,0 +1,27 @@
+module Ruby
+  module Pomodoro
+    module TimeConverter
+      class << self
+        def to_format_string(seconds)
+          days = seconds / 60 / 60 / 24
+          hours = (seconds - days * 24 * 60 * 60) / 60 / 60
+          minutes = (seconds - (hours * 60 * 60) - (days * 24 * 60 * 60)) / 60
+          {d: days, h: hours, m: minutes}.select { |_k, v| v.positive? }.each.with_object(String.new) do |item, acc|
+            acc << item.reverse.join(":") + " "
+          end.strip
+        end
+
+        def to_seconds(format_string)
+          return 0 if format_string.nil?
+
+          match = format_string.split(" ").compact.map do |item|
+            if item
+              item.split(":").reverse.then { |res| res.size == 2 ? res : nil }
+            end
+            end.compact.to_h.select { |k| %w[m h d].include?(k) }
+          (match["d"].to_i * 24 * 60 * 60) + (match["h"].to_i * 60 * 60) + (match["m"].to_i * 60)
+        end
+      end
+    end
+  end
+end

data/lib/ruby/pomodoro/time_helpers.rb

@@ -0,0 +1,11 @@
+module Ruby
+  module Pomodoro
+    module TimeHelpers
+      # @param [Integer] seconds
+      # @return [String] as N:d N:h N:m
+      def to_format_string(seconds)
+        Ruby::Pomodoro::TimeConverter.to_format_string(seconds)
+      end
+    end
+  end
+end

data/lib/ruby/pomodoro/version.rb

@@ -0,0 +1,5 @@
+module Ruby
+  module Pomodoro
+    VERSION = "0.4.0"
+  end
+end

data/lib/ruby/pomodoro/worker.rb

@@ -0,0 +1,78 @@
+module Ruby
+  module Pomodoro
+    # Singleton for work with tasks in application
+    class Worker
+      include Observable
+      include AASM
+      include Singleton
+
+      attr_reader :current_task
+      attr_accessor :time_interval, :pomodoro_size, :progressbar
+
+      aasm do
+        state :sleeping, initial: true
+        state :working, :paused
+
+        after_all_transitions :notify
+
+        event :start, before: :changed do
+          transitions from: :sleeping, to: :working, after: ->(task) { run_task(task) }
+        end
+
+        event :resume, before: :changed do
+          transitions from: :paused, to: :working
+        end
+
+        event :pause, before: :changed do
+          transitions from: :working, to: :paused
+        end
+
+
+        event :finish, before: :changed do
+          after { @do&.kill }
+
+          transitions from: :working, to: :sleeping
+        end
+
+        event :stop, before: :changed do
+          after do
+            @do&.kill
+            @current_task = nil
+          end
+
+          transitions to: :sleeping
+        end
+      end
+
+      private
+
+      def notify
+        notify_observers(aasm.current_event)
+      end
+
+      # @param [Ruby::Pomodoro::Task] task
+      # @return [TrueClass]
+      def run_task(task)
+        raise Error, "Setup pomodoro_size" if pomodoro_size.nil?
+
+        @current_task = task
+        @do = Thread.new do
+          progress = progressbar || Ruby::Pomodoro::Progressbar.new(seconds: pomodoro_size)
+          progress.start(task.name)
+          count = 0
+          loop do
+            seconds = time_interval || 1
+            sleep seconds
+            unless paused?
+              task.track(seconds)
+              count += seconds
+              progress.increment
+              finish if count >= pomodoro_size.to_i && working?
+            end
+          end
+        end
+        true
+      end
+    end
+  end
+end

data/lib/ruby/pomodoro.rb

@@ -0,0 +1,86 @@
+require 'terminal-notifier'
+require 'observer'
+require 'tty-cursor'
+require 'tty-editor'
+require 'tty-reader'
+require 'logger'
+require 'aasm'
+require "erb"
+require "ruby/pomodoro/command_controller"
+require "ruby/pomodoro/time_helpers"
+require "ruby/pomodoro/notification_observer"
+require "ruby/pomodoro/printer"
+require "ruby/pomodoro/cmd/base"
+require "ruby/pomodoro/cmd/main"
+require "ruby/pomodoro/cmd/quit"
+require "ruby/pomodoro/cmd/choose_task"
+require "ruby/pomodoro/cmd/edit_list"
+require "ruby/pomodoro/cmd/pause"
+require "ruby/pomodoro/cmd/stop"
+require "ruby/pomodoro/cmd/error_handler"
+require "ruby/pomodoro/time_converter"
+require "ruby/pomodoro/version"
+require "ruby/pomodoro/tasks/resource"
+require "ruby/pomodoro/tasks/editor"
+require "ruby/pomodoro/task"
+require "ruby/pomodoro/tasks/entity"
+require "ruby/pomodoro/worker"
+require "ruby/pomodoro/progressbar"
+require "ruby/pomodoro/notification"
+require "ruby/pomodoro/terminal_notifier_channel"
+
+module Ruby
+  module Pomodoro
+    class Error < StandardError; end
+
+    REPEAT_ALERT_TIME = 60 * 5
+    POMODORO_SIZE = 60 * 30
+
+    class << self
+      attr_reader :editor, :tasks_file_path
+
+      def start
+        Worker.instance.then do |worker|
+          add_observer(worker)
+          worker.pomodoro_size = POMODORO_SIZE
+        end
+
+        @tasks_file_path = File.join(init_app_folder, "tasks")
+
+        @editor = Tasks::Editor.new(file_path: tasks_file_path)
+        editor.load
+        Cmd::Main.new.call
+        reader = TTY::Reader.new
+        reader.subscribe(CommandController)
+        loop do
+          reader.read_char
+        rescue => e
+          Cmd::ErrorHandler.new.call(e)
+        end
+      end
+
+      private
+
+      def add_observer(worker)
+        notify_ch = TerminalNotifierChannel
+        pause_notification = Notification.new("Task is paused, resume?", notify_ch)
+        stop_notification =
+          Notification.new("Work is stopped, choose task for resume", notify_ch)
+
+        worker.add_observer(
+          NotificationObserver.new(
+            stop: stop_notification, pause: pause_notification, time: REPEAT_ALERT_TIME
+          )
+        )
+      end
+
+      def init_app_folder
+        path = File.join(Dir.home, ".ruby-pomodoro")
+        unless Dir.exists?(path)
+          Dir.mkdir(path)
+        end
+        path
+      end
+    end
+  end
+end

data/lib/view/main.txt.erb

@@ -0,0 +1,13 @@
+Total time: <%= to_format_string(Ruby::Pomodoro::Tasks::Resource.sum(:spent_time)) %>
+List of tasks:
+<% if @tasks %>
+<% @tasks.each do |task| %>
+  <%= task.id %>. <%= task.name %> <%= task.spent_time.zero? ? nil : to_format_string(task.spent_time) %>
+<% end %>
+<% end %>
+
+[c] - Choose task to work
+[e] - Edit list of tasks
+[p] - Pause work
+[s] - Stop work
+[q] - Quit

data/ruby-pomodoro.gemspec

@@ -0,0 +1,31 @@
+require_relative 'lib/ruby/pomodoro/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ruby-pomodoro"
+  spec.version       = Ruby::Pomodoro::VERSION
+  spec.authors       = ["Alexander Shvaykin"]
+  spec.email         = ["skiline.alex@gmail.com"]
+
+  spec.summary       = %q{CLI pomodoro-tracker}
+  spec.homepage      = "https://github.com/AlexanderShvaykin"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/AlexanderShvaykin"
+  spec.metadata["changelog_uri"] = "https://github.com/AlexanderShvaykin"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.add_runtime_dependency 'terminal-notifier'
+  spec.add_runtime_dependency 'tty-cursor', '~> 0.6'
+  spec.add_runtime_dependency 'tty-editor', '~> 0.7'
+  spec.add_runtime_dependency 'pastel', '~> 0.8'
+  spec.add_runtime_dependency 'aasm', '~> 5'
+end