zashoku 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d4fa01a68fedb50955e21f463118c0b40b7a3ea3
+  data.tar.gz: f6c95b13d29fbde419815753ed527fef44a6de14
+SHA512:
+  metadata.gz: b4f12efc2dc904b9ffe2d5d1204be2b083e77318d6673398bbc805d3677a1503e8cb1e19cfe72d9e52b8cdeea9392d53263360c3b64846802a82659df534bca2
+  data.tar.gz: 62b9a8b0d03efba68fd7523fe5a093de69789423d2a59ff1ffa6600903aace9d3db2720227fdad9a8c130b59166043d0f371d24d1bbfc42fc32c94c3bba269eb

data/README.md

@@ -0,0 +1,16 @@
+# zashoku
+command line application framework
+
+## features
++ for lazy people
++ generators
++ optimized view
++ mvc
++ client / server model
+
+## installation
+`gem install zashoku`
+
+## documentation
++ [rubydoc.info](http://www.rubydoc.info/gems/zashoku/)
++ [wiki](https://github.com/annacrombie/zashoku/wiki/)

data/bin/zashoku

@@ -0,0 +1,17 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+begin
+  if File.exist?(File.join(File.dirname(__FILE__), '../lib/zashoku.rb'))
+    require_relative '../lib/zashoku'
+  end
+  # rescue LoadError
+  #  require 'zashoku'
+end
+
+unless defined? Zashoku
+  puts 'cant find zashoku library'
+  exit
+end
+
+Zashoku.main(ARGV)

data/config/daemon.yml

@@ -0,0 +1,8 @@
+---
+log_file: '$conf_dir/aw.log'
+conf_dir: '~/.config/zashoku'
+
+modules:
+  disabled: []
+  enabled:
+    - Bandcamp

data/config/view.yml

@@ -0,0 +1,16 @@
+---
+color:
+  selected: "\e[47m\e[31m"
+  primary: "\e[0m\e[32m"
+  secondary: "\e[0m\e[33m"
+  main: "\e[0m\e[34m"
+modules:
+  disabled: []
+  enabled:
+  - Bandcamp
+keymaps:
+  global:
+    259: current_view move_cursor up
+    258: current_view move_cursor down
+    " ": current_view expand $selected_group
+    q: quit

data/lib/core/config/config.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'fileutils'
+
+module Zashoku
+  class Config < Controller
+    CONF_DIR  = File.join(Dir.home, '.config/zashoku')
+    CONF_FILE = File.join(CONF_DIR, '/conf.yml')
+
+    def initialize
+      FileUtils.mkdir_p(CONF_DIR) unless File.directory?(CONF_DIR)
+      reload
+      save unless File.exist?(self.class::CONF_FILE)
+    end
+
+    def reload
+      @conf = merge!(default_conf, user_conf)
+    end
+
+    def merge!(this, that)
+      this&.merge(that) do |_k, old, nu|
+        old.class == Hash ? merge!(old, nu) : nu
+      end
+    end
+
+    def base_conf
+      {}
+    end
+
+    def default_conf
+      module_conf.reduce(base_conf) do |mem, mc|
+        merge!(mem, mc)
+      end
+    end
+
+    def module_conf
+      {}
+    end
+
+    def user_conf
+      read(self.class::CONF_FILE)
+    end
+
+    def pref_model(title, value, trail)
+      Model.new(title: title, value: value, trail: trail)
+    end
+
+    def items
+      @conf.map do |title, pref|
+        next if IGNORE.key? title
+        case pref
+        when Hash
+          pref.map do |subt, subpref|
+            pref_model("#{title}_#{subt}", subpref, [title, subt])
+          end
+        when Array
+          pref_model(title, pref.join(':'), [title])
+        else
+          pref_model(title, pref, [title])
+        end
+      end.flatten.compact
+    end
+
+    def parse_dir(path)
+      {
+        # '$airing_dir' => @conf['airing_dir'],
+        # '$conf_dir'   => @conf['conf_dir'],
+        '~' => Dir.home
+      }.inject(path) { |p, r| p.gsub(r[0], r[1]) }
+    end
+
+    def set(trail, destination)
+      trail = [trail] if trail.class == String
+
+      trail[0...-1].inject(@conf, :fetch)[trail.last] = destination
+      save
+      changed
+      notify_observers
+    end
+
+    def get(trail)
+      @conf.dig(*trail)
+    end
+
+    def save
+      File.open(self.class::CONF_FILE, 'w') { |f| f.write(YAML.dump(@conf)) }
+    end
+
+    def read(file)
+      YAML.safe_load(File.open(file, 'r', &:read))
+    rescue
+      {}
+    end
+  end
+end

data/lib/core/config/daemon_config.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'config'
+
+module Zashoku
+  class DaemonConfig < Zashoku::Config
+    CONF_FILE = File.join(CONF_DIR, '/daemon.yml')
+
+    def module_conf
+      Zashoku.modules.map do |_k, mod|
+        mod.send(:daemon_config)
+      end
+    end
+
+    def base_conf
+      read(File.join(Zashoku::Root, 'config/daemon.yml'))
+    end
+  end
+end

data/lib/core/config/view_config.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'config'
+
+module Zashoku
+  class ViewConfig < Zashoku::Config
+    CONF_FILE = File.join(CONF_DIR, '/view.yml')
+
+    def module_conf
+      Zashoku.modules.map do |_k, mod|
+        mod.send(:view_config)
+      end
+    end
+
+    def base_conf
+      read(File.join(Zashoku::Root, 'config/view.yml'))
+    end
+  end
+end

data/lib/core/controller.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'observer'
+
+module Zashoku
+  class Controller
+    # include Zashoku::Util
+    include Observable
+    def items
+      {}
+    end
+  end
+end

data/lib/core/formatter.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'unicode/display_width'
+
+module Zashoku
+  module Formatter
+    PAD   = ' '
+    SPLIT = '@split@'
+    BYTE_SUFFIXES = {
+      1_000_000_000_000 => 'T',
+      1_000_000_000     => 'G',
+      1_000_000         => 'M',
+      1_000             => 'K',
+      1                 => ''
+    }.freeze
+
+    def self.round(n, precision = 10.0)
+      (Float(n) * precision).round / precision
+    end
+
+    def self.duration(secs)
+      [secs / 3_600, (secs / 60) % 60, secs % 60].map do |i|
+        i.round.to_s.rjust(2, '0')
+      end.join(":")
+    end
+
+    def self.size(bytes)
+      return '0B' if bytes < 1
+      suffix = BYTE_SUFFIXES.select { |b, _s| bytes >= b }.max
+
+      "#{round(Float(bytes) / suffix[0])}#{suffix[1]}B"
+    end
+
+    def self.progress(progress)
+      "#{Integer(progress)}.#{Integer(progress * 10.0) % 10}"
+    end
+
+    def self.items(format, items)
+      items.map do |parent, children|
+        [
+          format_line(format['parent'], parent.attr),
+          children&.map do |child|
+            format_line(format['child'], child.attr)
+          end || []
+        ]
+      end.to_h
+    end
+
+    def self.pre_format(string, obj)
+      split_chars = []
+      mode        = :char
+      padding     = 0
+
+      string.chars.reduce('') do |str, char|
+        str +
+          case mode
+          when :escape
+            mode = :char
+            char.to_s
+          when :split
+            mode = :char
+            split_chars << char
+            SPLIT
+          when :attribute
+            mode = :char
+            str = obj.key?(char) ? obj[char].to_s : ''
+            pad =
+              if padding > Unicode::DisplayWidth.of(str)
+                PAD * (padding - Unicode::DisplayWidth.of(str))
+              else
+                ''
+              end
+            padding = 0
+            "#{pad}#{str}"
+          when :char
+            case char
+            when '%'
+              mode = :attribute
+              ''
+            when '@'
+              mode = :split
+              ''
+            when '#'
+              padding += 1
+              ''
+            when '\\'
+              mode = :escape
+              ''
+            else
+              char.to_s
+            end
+          end
+      end.split(SPLIT).zip(split_chars)
+    end
+
+    def self.format_line(string, obj)
+      pfs = pre_format(string, obj)
+      len = pfs.reduce(0) { |l, s| l + Unicode::DisplayWidth.of(s[0]) } + 1
+      Zashoku.logger.debug("formatting #{pfs}, len: #{len}\n--->#{Util::Term.cols} - #{len} / #{pfs.length - 1}")
+      buffer = pfs.length > 1 ? (Util::Term.cols - len) / (pfs.length - 1) : 0
+
+      buffer -= (Util::Term.cols - len - buffer)
+
+      pfs.reduce('') do |final, seg|
+        buf = pfs.last != seg && buffer.positive? ? (seg[1] || PAD) * buffer : ''
+        "#{final}#{seg[0]}#{buf}"
+      end #[0..Util::Term.cols - 1]
+
+      #f.chars.reduce('') do |m,v|
+      #  m + (Unicode::DisplayWidth.of(m + v) <= Util::Term.cols ? v : '')
+      #end
+    end
+  end
+end
+

data/lib/core/item.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Zashoku
+  class Item
+    attr_accessor :attr
+    def initialize(attributes)
+      @attributes = attributes
+      keys = []
+      @attr = attributes.map { |k, v|
+        pk = k.chars.map { |c| [c, c.swapcase] }.flatten
+        kc = 0
+        kc += 1 while kc < pk.length && keys.include?(pk[kc])
+        keys << pk[kc]
+        [pk[kc], v]
+      }.to_h
+    end
+
+    def method_missing(m, *args, &block)
+      p @attributes[m.to_s]
+      return @attributes[m.to_s] if @attributes.key?(m.to_s)
+      super
+    end
+  end
+end

data/lib/core/module.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Zashoku
+  module Module
+    LoadPaths = [
+      File.join(Zashoku::Root, 'lib/core/modules/'),
+      File.join(Zashoku::Root, 'modules/'),
+      File.join(Dir.home, '.config/zashoku/modules/')
+    ].freeze
+
+    def self.require_module(mod)
+      mod = mod.downcase
+      LoadPaths.map do |path|
+        mod_path = File.join(path, "#{mod}/lib/#{mod}.rb")
+        next unless File.exist?(mod_path)
+        begin
+          require mod_path
+        rescue LoadError
+          false
+        end
+      end.any?
+    end
+
+    def self.load(modules)
+      require_all(modules).map do |mod|
+        [mod.name.split(':').last.downcase, mod]
+      end.to_h
+    end
+
+    def self.require_all(modules)
+      modules.map do |mod|
+        Zashoku.const_get(mod) if require_module(mod)
+      end.compact
+    end
+
+    ###
+
+    def view; end
+
+    def controller; end
+
+    def view_config
+      Util.get_yaml(File.join(self::Root, 'config/view.yml'))
+    end
+
+    def daemon_config
+      Util.get_yaml(File.join(self::Root, 'config/daemon.yml'))
+    end
+  end
+end

data/lib/core/net/client.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require 'socket'
+require 'json'
+require 'thread'
+
+module Zashoku
+  module Net
+    class Client
+      attr_accessor :callbacks
+
+      def initialize(port, host = 'localhost')
+        @socket = connect(host, port)
+        @alive = true
+
+        @callbacks = []
+
+        @command_queue = Queue.new
+        @result_queue = Queue.new
+        @event_queue = Queue.new
+
+        @command_thread = Thread.new { pump_commands! }
+        @results_thread = Thread.new { pump_results! }
+        @events_thread = Thread.new { dispatch_events! }
+
+        @semaphore = Mutex.new
+      end
+
+      def connect(host, port)
+        TCPSocket.new(host, port)
+      rescue Errno::ECONNREFUSED
+        puts "error: could not connect to #{host}:#{port}"
+        exit
+      end
+
+      def alive?
+        @alive
+      end
+
+      def lost_connection
+        @alive = false
+        Zashoku.logger.debug('lost connection')
+        Zashoku.alert('no connection')
+        Thread.exit
+      end
+
+      def disconnect
+        command('disconnect')
+        @command_thread.exit
+        @results_thread.exit
+        @events_thread.exit
+        @alive = false
+      end
+
+      def command(msg, args = {})
+        return unless alive?
+        @semaphore.synchronize {
+        id = Random.rand
+
+        payload = { 'msg' => msg }.merge(args)
+        Zashoku.logger.debug("client.command #{id} #{payload}")
+        @command_queue << JSON.generate(payload)
+
+        result = @result_queue.pop
+        result.keys.length == 1 ? result['response'] : result
+        }
+      end
+
+      def pump_commands!
+        loop do
+          begin
+            @socket.puts(@command_queue.pop)
+          rescue
+            lost_connection
+          end
+        end
+      end
+
+      def pump_results!
+        loop do
+          distribute_results!
+        end
+      end
+
+      def distribute_results!
+        response = JSON.parse(@socket.readline)
+        Zashoku.logger.debug("distributing #{response.class} #{response.length}")
+        if response['event']
+          @event_queue << response
+        else
+          @result_queue << response
+        end
+      rescue
+        lost_connection
+      end
+
+      def dispatch_events!
+        loop do
+          event = @event_queue.pop
+
+          callbacks.each do |callback|
+            Thread.new do
+              callback.call event
+            end
+          end
+        end
+      end
+
+      def get_items(_mod)
+        {}
+        # Util.decode_object(send("items #{mod}"))
+      end
+    end
+  end
+end