zashoku 1.0.0

data/lib/core/net/server.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'json'
+require 'thread'
+
+module Zashoku
+  module Net
+    class Server
+      attr_accessor :clients, :handler
+
+      def initialize(port)
+        @clients = []
+        @client_queue = {}
+        @semaphore = Mutex.new
+        @handler = ->(message) {}
+        @server =
+          begin
+            TCPServer.new(port)
+          rescue Errno::EADDRINUSE
+            raise "error, port #{port} is busy"
+          end
+        @server_thread = Thread.new { serve_clients! }
+      end
+
+      def exit
+        @server_thread.exit
+      end
+
+      def event(e)
+        clients.each do |client|
+          client.puts JSON.generate(e)
+        end
+      end
+
+      def handle(client)
+        loop do
+          message =
+            begin
+              JSON.parse(client.readline.chomp)
+            rescue EOFError
+              { 'msg' => 'disconnect' }
+            end
+          begin
+            response = @handler.call(message)
+            client.puts JSON.generate(response: response)
+          rescue Errno::EPIPE
+            break
+          else
+            break unless response
+          end
+        end
+        @clients.delete(client)
+        @client_queue.delete(client)
+        client.close
+      end
+
+      def serve_clients!
+        Thread.abort_on_exception = true
+        loop do
+          Thread.start(@server.accept) do |client|
+            @clients << client
+            @client_queue[client] = Queue.new
+            handle(client)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/core/options.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+class Options
+  def self.parse(args)
+    options = {
+      daemon: false,
+      generate: false,
+      template: nil,
+      generate_name: nil
+    }
+
+    parser = OptionParser.new do |opts|
+      opts.banner = 'Usage: zashoku [options]'
+
+      opts.on('-d', '--daemon', 'pass commands to the daemon') do |d|
+        options[:daemon] = d
+      end
+
+      opts.on('-g TEMPLATE', '--generate TEMPLATE', 'generate a template') do |template|
+        options[:template] = template
+        options[:generate] = true
+      end
+
+      opts.on_tail('-h', '--help', 'Show this message') do
+        puts opts
+        exit
+      end
+
+      opts.on_tail('--version', 'Show version') do
+        puts Zashoku::Version.join('.')
+        exit
+      end
+    end
+
+    parser.parse!(args)
+
+    options[:generate_name] = args.pop if options[:template]
+
+    options
+  end
+end

data/lib/core/util/folder_listen.rb

@@ -0,0 +1,53 @@
+# watch for changes in a folder's existance
+
+module Zashoku
+  module Util
+    module FolderListen
+
+      def self.to(dirs, &block)
+        Listener.new(dirs, &block)
+      end
+
+      ##
+      ## @brief      Similar to Listen gem but uses polling and is only intended
+      ##             to be used on a small number of files. the Listen gem
+      ##             wouldn't support watching an individual FOLDER to see if
+      ##             the folder went away so this is that!
+      ##
+      class Listener
+        def initialize(dirs, &block)
+          @dirs           = dirs
+          @block          = block
+          @sleep_duration = 1
+          @dir_hash       = dir_hash
+        end
+
+        def dir_hash
+          @dirs.map { |dir| [dir, File.exist?(dir)]}.to_h
+        end
+
+        def changed?
+          @dir_hash != dir_hash
+        end
+
+        def stop
+          @listen_thread.exit if @listen_thread
+        end
+
+        def start
+          Thread.abort_on_exception = true
+          @listen_thread = Thread.new do
+            while true
+              if changed?
+                @block.call
+                @dir_hash = dir_hash
+              end
+              sleep 1
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/core/util/term.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Zashoku
+  module Util
+    module Term
+      {
+        save: `tput smcup`,
+        restore: `tput rmcup`,
+        hide_cursor: `tput civis`,
+        show_cursor: `tput cnorm`,
+        clear_line: "\e[2K",
+        bold: `tput bold`,
+        nobold: `tput sgr0`,
+        clear: "\033[2J"
+      }.each do |command, code|
+        define_singleton_method(command) do
+          print code
+          self
+        end
+      end
+
+      def self.echo_off
+        `stty -echo`
+        self
+      end
+
+      def self.echo_on
+        `stty echo`
+        self
+      end
+
+      def self.cols
+        HighLine::SystemExtensions.terminal_size[0]
+      end
+
+      def self.rows
+        HighLine::SystemExtensions.terminal_size[1]
+      end
+
+      def get_key
+        STDIN.getch
+             .gsub("\r", 'enter')
+             .gsub(' ',  'space')
+             .gsub('A',  'up')
+             .gsub('B',  'down')
+             .gsub('C',  'right')
+             .gsub('D',  'left')
+             .gsub("\e", 'skip')
+             .gsub('[',  'skip')
+      end
+
+      def self.reset
+        restore.show_cursor.echo_on
+      end
+
+      def self.ini
+        save.hide_cursor.echo_off
+      end
+    end
+  end
+end

data/lib/core/util/util.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'base64'
+require 'readline'
+
+module Zashoku
+  module Util
+    def self.readline(prompt = '', default = '')
+      Term.bold.echo_on
+      print "\033[" + String(Term.rows) + ';1H'
+      Term.show_cursor
+      Readline.completion_append_character = ''
+      Readline.pre_input_hook = lambda do
+        Readline.insert_text default.to_s
+        Readline.redisplay
+        Readline.pre_input_hook = nil
+      end
+      input = Readline.readline(prompt, false)
+      Term.hide_cursor.nobold.echo_off.clear
+      input
+    end
+
+    def self.error_message(message)
+      # use statusline to show error messages
+      print "\e[#{Term.rows - 1};1H\e[31m #{message}\e[K"
+    end
+
+    def self.encode_object(d)
+      Base64.strict_encode64(Marshal.dump(d))
+    end
+
+    def self.decode_object(e)
+      Marshal.load(Base64.decode64(e))
+    rescue ArgumentError
+      {}
+    rescue TypeError
+      {}
+    end
+
+    def self.get_yaml(file)
+      YAML.safe_load(File.open(file, 'r', &:read)) || {}
+    rescue Errno::ENOENT
+      puts 'failed'
+      {}
+    end
+  end
+end

data/lib/core/view.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+# require 'benchmark'
+
+# require_relative 'color'
+# require_relative '../util/util'
+
+module Zashoku
+  class View
+    include Zashoku::Util
+    include Observable
+
+    attr_accessor :attributes, :format, :items_formatted
+
+    def initialize
+      @attributes = {}
+
+      @children = true
+      @expanded = -1
+      @selected = 0
+
+      @items_formatted  = {}
+
+      @old_rows = Term.rows
+
+      # @win = Curses::Window.new(0,0,0,0)
+      Zashoku.logger.debug('refreshing')
+      refresh
+
+      dirty_all_lines
+      @view = [0, Term.rows - 3]
+    end
+
+    def dirty_all_lines
+      @dirty_lines = 0.step(get_len).to_a
+    end
+
+    def unpause; end
+
+    def pause; end
+
+    def changed!
+      fix_cursor
+      changed
+      notify_observers
+    end
+
+    def auto_update(s: :start)
+      case s
+      when :start
+        @update_thread = Thread.new do
+          loop do
+            refresh
+            changed!
+            sleep 1
+          end
+        end
+      when :stop
+        @update_thread.exit if @update_thread
+      end
+    end
+
+    def change_screen_size(redraw: true)
+      @items_formatted = {}
+      refresh_formats
+
+      diff = Term.rows - @old_rows
+      # @view[0] += diff
+      @view[1] += diff
+
+      @old_rows = Term.rows
+      adjust_view
+      if redraw
+        dirty_all_lines
+        draw
+      end
+    end
+
+    def refresh
+      @items = refresh_items
+      refresh_attributes
+      refresh_formats
+      dirty_all_lines
+      @expanded = -1 if @children && @items.values[@expanded].nil?
+      changed!
+    end
+
+    def expand(i)
+      return if i > @items.length
+      oexpanded = @expanded
+
+      if @expanded == i
+        @selected = @expanded
+        @expanded = -1
+      else
+        @selected = i
+        @expanded = i
+      end
+      #adjust_view
+
+      arr = [@expanded, oexpanded] - [-1]
+      @dirty_lines = arr.min.step(@view[1]).to_a
+      changed!
+    end
+
+    def resolve_selected(resolve_me = @selected)
+      in_expanded = false
+      inside = 0
+      outside = resolve_me
+      if @expanded > -1
+        if (resolve_me > @expanded) && (resolve_me <= (@items.values[@expanded].length + @expanded))
+          outside = @expanded
+          inside = resolve_me - @expanded - 1
+          in_expanded = true
+        elsif resolve_me > @expanded
+          outside = resolve_me - @items.values[@expanded].length
+        end
+      end
+
+      {
+        'out' => outside,
+        'in' => inside,
+        'in_expanded' => in_expanded
+      }
+    end
+
+    def selected_group
+      resolve_selected['out']
+    end
+
+    def selected_item
+      rs = resolve_selected
+      if rs['in_expanded']
+        @items.values[rs["out"]][rs["in"]]
+      else
+        @items.keys[rs['out']]
+      end
+    end
+
+    def move_cursor(dir)
+      os = @selected
+      @selected -= 1 if dir == 'up'
+      @selected += 1 if dir == 'down'
+      @dirty_lines += [os, @selected]
+
+      adjust_view
+      fix_cursor
+      changed
+      notify_observers
+    end
+
+    def fix_cursor
+      @selected = 0 if @selected < 0
+      @selected = get_len - 1 if @selected >= get_len
+    end
+
+    def get_len
+      len = @items.length
+      len += @items.values[@expanded].length if @expanded >= 0
+      len
+    end
+
+    def color(index)
+      if index == @selected
+        Zashoku.conf.get(%w[color selected])
+      else
+        Zashoku.conf.get(%w[color secondary])
+      end
+    end
+
+    def adjust_view
+      buffer = 2
+      bottom = Term.rows - 3
+
+      ov = @view.clone
+      diff = 0
+      if @selected < @view[0] + buffer # and @selected > buffer
+        while @selected < @view[0] + buffer
+          @view[0] -= 1
+          @view[1] -= 1
+        end
+      elsif (@selected > @view[1] - (buffer + 1)) && (@selected < get_len - buffer)
+        while (@selected > @view[1] - (buffer + 1)) && (@selected < get_len - buffer)
+          @view[0] += 1
+          @view[1] += 1
+        end
+      end
+
+      diff = 0      - @view[0] if @view[0].negative?
+      diff = bottom - @view[1] if @view[1] < bottom
+
+
+      @view[0] += diff
+      @view[1] += diff
+
+      dirty_all_lines unless ov == @view
+    end
+
+    def refresh_formats
+      @cl = {
+        's' => Zashoku.conf.get(%w[color selected]),
+        '1' => Zashoku.conf.get(%w[color primary]),
+        '2' => Zashoku.conf.get(%w[color secondary]),
+        'm' => Zashoku.conf.get(%w[color main])
+      }
+
+      @title_formatted = Zashoku::Formatter.format_line(
+        get_format['title'],
+        @attributes
+      )
+
+      @items_formatted = Zashoku::Formatter.items(get_format, @items)
+      changed
+      notify_observers
+    end
+
+    def draw_line(line_on)
+      in_outer_region = line_on < get_len
+      rs              = resolve_selected(line_on)
+      line            = line_on - @view[0] + 2
+
+      lc =
+        if line_on == @selected
+          @cl['s']
+        elsif rs['in_expanded']
+          @cl['2']
+        else
+          @cl['1']
+        end
+
+      lo = "\e[#{line};1H#{lc}"
+
+      item =
+        if rs['in_expanded'] && @children
+          "#{@items_formatted.values[@expanded][rs['in']]}"
+        elsif in_outer_region
+          "#{@items_formatted.keys[rs['out']]}"
+        else
+          ''
+        end
+
+      print "#{lo}#{item}\e[K" #.tr(' ', '#')
+    end
+
+    def draw
+      # set the view
+      line_on = @view[0]
+      lines_to_draw = @view[1]
+
+      # print the menu title
+      lo = "\e[1;1H"
+      print lo + @cl['m'] + @title_formatted + "\e[K"
+
+      while line_on < lines_to_draw
+        draw_line(line_on) if @dirty_lines.include?(line_on)
+        line_on += 1
+      end
+
+      @dirty_lines.clear
+    end
+
+    def refresh_attributes; end
+
+    def refresh_items; [] end
+
+    def get_format; '' end
+  end
+end