overpath 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f8be652dae7a95b56a2a470dac2e794bcca7ede3
+  data.tar.gz: 075eeb68462839818003675154bf2462f717da24
+SHA512:
+  metadata.gz: 70b53e13618d162fc0f97536b032ec5d37593ddd3419b83045de5085e48b58c09e1616ea5fcffa6b05e54340c391772de5b84717ac826e2f989c8fab32b0e972
+  data.tar.gz: 7afd3db406c31a07d49d2c401cb83a6f97a55b2276645509ce8ddcef6880bee57a82b6dd40fa9dff42ce425e5544db767eecb6c925e6f81a3ec83220a5a4f2c0

data/bin/overpath

@@ -0,0 +1,195 @@
+#!/usr/bin/env ruby
+require 'overpath'
+require 'gli'
+
+include GLI::App
+program_desc 'Valhalla awaits!'
+program_long_desc 'Find your path before Ragnarök comes!'
+default_command 'help'
+hide_commands_without_desc true
+version '0.0.1'
+sort_help :manually
+accept(File) do |string|
+  File.path(string)
+end
+flag %i[file], desc: 'Specify a file to store paths',
+               default_value: File.join(Dir.home, '.overpath/overpath'),
+               arg_name: 'filepath',
+               type: File
+
+pre do |global_options, _command, _options, _args|
+  path = global_options[:file]
+  dir = File.dirname(path)
+  Dir.mkdir(dir) unless Dir.exist?(dir)
+  @table = PathTable.new(path)
+  @table.load
+end
+
+post do
+  @table.save
+end
+
+desc 'Set one path with one key'
+arg 'key'
+arg 'path', :optional
+command :add do |c|
+  c.desc 'Set favorite path'
+  c.switch %i[f favorite]
+  c.action do |_global_options, options, args|
+    key = args[0]
+    if key
+      value = File.expand_path(args[1] ? args[1] : Dir.pwd)
+      @table.table[key] = value
+      puts PathPrinter.str([key, value])
+      @table.favorite = key if options[:f]
+    end
+  end
+end
+
+desc 'Get paths with keys'
+arg 'key, ...'
+command :get do |c|
+  c.desc 'Get the path of directory instead of file'
+  c.switch %i[d directory]
+  c.desc 'List all paths'
+  c.switch %i[a all]
+  c.desc 'Don\'t escape the path'
+  c.switch [:E]
+  c.action do |_global_options, options, args|
+    list = if options[:a]
+             @table.table.values
+           elsif args.empty? && @table.favorite
+             [@table.table[@table.favorite]]
+           else
+             @table.table.values_at(*args).select { |item| item }
+           end
+    if options[:d]
+      list.map! { |path| (File.directory?(path) ? path : File.dirname(path)) }
+    end
+    puts PathPrinter.string(list, true, !options[:E])
+  end
+end
+
+desc 'Choose your favorite path'
+arg 'key', :optional
+command :fav do |c|
+  c.desc 'Clean current favorite path'
+  c.switch %i[c clean]
+  c.action do |_global_options, options, args|
+    if options[:c]
+      if @table.favorite
+        key_value = [@table.favorite, @table.table[@table.favorite]]
+        puts PathPrinter.str_del(key_value)
+        @table.favorite = nil
+      end
+    elsif args[0]
+      value = @table.table[args[0]]
+      if value
+        @table.favorite = args[0]
+        puts PathPrinter.str_mark([@table.favorite, value], @table.favorite)
+      end
+    elsif @table.favorite
+      key_value = [@table.favorite, @table.table[@table.favorite]]
+      puts PathPrinter.str_mark(key_value, @table.favorite)
+    end
+  end
+end
+
+desc 'List paths and their keys'
+command :ls do |c|
+  c.desc 'List keys only'
+  c.switch %i[k keys-only]
+  c.desc 'List paths only'
+  c.switch %i[p paths-only]
+  c.desc 'Don\'t escape the paths'
+  c.switch [:E]
+  c.action do |_global_options, options, _args|
+    list = nil
+    if options[:k] == options[:p]
+      list = PathPrinter.string_with_mark(@table.table.to_a,
+                                          true,
+                                          !options[:E],
+                                          @table.favorite)
+    elsif options[:k]
+      list = PathPrinter.string(@table.table.keys,
+                                true,
+                                false)
+    elsif options[:p]
+      list = PathPrinter.string(@table.table.values,
+                                true,
+                                !options[:E])
+    end
+    puts list
+  end
+end
+
+desc '(Ex)change key of path to another'
+arg 'key'
+arg 'another'
+command :mv do |c|
+  c.desc 'Exchange keys'
+  c.switch %i[e exchange]
+  c.action do |_global_options, options, args|
+    if args[0] && args[1]
+      @table.favorite = nil if args[0] == @table.favorite && !options[:e]
+      value = @table.table.delete(args[0])
+      another_value = @table.table.delete(args[1])
+      if value
+        puts PathPrinter.str_del([args[0], value]) unless options[:e]
+        value = File.expand_path(value)
+        @table.table[args[1]] = value
+        puts PathPrinter.str([args[1], value])
+      end
+      if options[:e] && another_value
+        another_value = File.expand_path(another_value)
+        @table.table[args[0]] = another_value
+        puts PathPrinter.str([args[0], another_value])
+      end
+    end
+  end
+end
+
+desc 'Sort paths by key'
+command :so do |c|
+  c.action do |_global_options, _options, _args|
+    @table.table = Hash[@table.table.sort_by { |key, _value| key }]
+    puts PathPrinter.string_with_mark(@table.table.to_a,
+                                      true,
+                                      true,
+                                      @table.favorite)
+  end
+end
+
+desc 'Delete paths with keys'
+arg 'key, ...'
+command :rm do |c|
+  c.desc 'Delete all paths'
+  c.switch %i[a all]
+  c.action do |_global_options, options, args|
+    list = (options[:a] ? @table.table.keys : args)
+    list.each do |key|
+      @table.favorite = nil if key == @table.favorite
+      value = @table.table.delete(key)
+      puts PathPrinter.str_del([key, value]) if value
+    end
+  end
+end
+
+command :'.' do |c|
+  c.action do |global_options, _options, args|
+    key = @app.exe_name
+    path = (File.symlink?(__FILE__) ? File.readlink(__FILE__) : __FILE__)
+    path = File.expand_path(path)
+    if args[0] == 'path'
+      puts PathPrinter.str(path)
+    elsif args[0] == 'command'
+      puts @commands_declaration_order.map(&:name).drop(2).join(' ')
+    elsif args[0] == 'file'
+      puts global_options[:file]
+    else
+      puts PathPrinter.str([key, path])
+    end
+  end
+end
+
+exit run(ARGV)

data/lib/overpath.rb

@@ -0,0 +1,2 @@
+require_relative 'overpath/path_table'
+require_relative 'overpath/path_printer'

data/lib/overpath/path_printer.rb

@@ -0,0 +1,61 @@
+require 'shellwords'
+
+# Generator for print key-value pairs
+class PathPrinter
+  class << self
+    def str(data)
+      string(data, false, true)
+    end
+
+    def str_del(data)
+      string_with_mark_deletion(data, false, true, '', true)
+    end
+
+    def str_mark(data, mark)
+      string_with_mark(data, false, true, mark)
+    end
+
+    def string(data, is_list, escaped)
+      string_with_mark(data, is_list, escaped, '')
+    end
+
+    def string_with_mark(data, is_list, escaped, mark)
+      string_with_mark_deletion(data, is_list, escaped, mark, false)
+    end
+
+    def string_with_mark_deletion(data, is_list, escaped, mark, deletion)
+      output = []
+      if is_list
+        data.each do |o|
+          output << string_from_key_value(o, escaped, mark, deletion)
+        end
+      else
+        output << string_from_key_value(data, escaped, mark, deletion)
+      end
+      output
+    end
+
+    def string_from_key_value(o, escaped, mark, deletion)
+      line = nil
+      if o.is_a?(Array) && o.size == 2
+        line = string_from_key_and_value(o, escaped, mark, deletion)
+      elsif o.is_a?(String)
+        line = string_from_key_or_value(o, escaped, mark, deletion)
+      end
+      line
+    end
+
+    def string_from_key_and_value(key_value, escaped, mark, deletion)
+      value = (escaped ? Shellwords.escape(key_value[1]) : key_value[1])
+      mark = (mark == key_value[0] ? " \u{2764}" : '')
+      deletion_mark = (deletion ? " \u{2716}" : '')
+      "\"#{key_value[0]}\" => \"#{value}\"#{mark}#{deletion_mark}"
+    end
+
+    def string_from_key_or_value(string, escaped, mark, deletion)
+      string += (mark == string ? " \u{2764}" : '')
+      string += (deletion ? " \u{2716}" : '')
+      (escaped ? Shellwords.escape(string) : string)
+    end
+  end
+end

data/lib/overpath/path_table.rb

@@ -0,0 +1,41 @@
+require 'json'
+
+# Controller for paths
+class PathTable
+  def initialize(file_path)
+    @file_path = file_path
+    @table = {}
+  end
+  PATHTABLE_FAVORITE_KEY = 'PATHTABLE_FAVORITE_KEY'.freeze
+  def save
+    File.open(@file_path + '.new', 'w+') do |file|
+      save_to_file(file)
+    end
+    File.rename(@file_path, @file_path + '.old') if File.exist?(@file_path)
+    File.rename(@file_path + '.new', @file_path)
+  end
+
+  def save_to_file(file)
+    favorite = { PATHTABLE_FAVORITE_KEY => @favorite }
+    table = @favorite ? @table.merge(favorite) : @table
+    file.puts JSON.generate(table)
+    File.foreach(@file_path).with_index do |line, i|
+      break if i > 14
+      file.puts line
+    end
+  end
+
+  def load
+    if File.exist?(@file_path)
+      table = JSON.parse(File.open(@file_path, 'r').gets)
+      if table.is_a?(Hash)
+        @table = table.reject { |key, _value| key == PATHTABLE_FAVORITE_KEY }
+        @table.each_value { |value| value.chomp!('/') }
+        @favorite = table[PATHTABLE_FAVORITE_KEY]
+      end
+    end
+    @table
+  end
+  attr_accessor :table
+  attr_accessor :favorite
+end

data/overpath.rdoc

@@ -0,0 +1,120 @@
+== overpath - Valhalla awaits!
+
+Find your path before Ragnarök comes!
+
+v0.0.1
+
+=== Global Options
+=== --file filepath
+
+Specify a file to store paths
+
+[Default Value] /Users/fangqiuming/.overpath/overpath
+
+
+=== --help
+Show this message
+
+
+
+=== --version
+Display the program version
+
+
+
+=== Commands
+==== Command: <tt>add </tt>
+Set one path with one key
+
+
+===== Options
+===== -f|--[no-]favorite
+Set favorite path
+
+
+
+==== Command: <tt>fav </tt>
+Choose your favorite path
+
+
+===== Options
+===== -c|--[no-]clean
+Clean current favorite path
+
+
+
+==== Command: <tt>get </tt>
+Get paths with keys
+
+
+===== Options
+===== -E
+Don't escape the path
+
+
+
+===== -a|--[no-]all
+List all paths
+
+
+
+===== -d|--[no-]directory
+Get the path of directory instead of file
+
+
+
+==== Command: <tt>help  command</tt>
+Shows a list of commands or help for one command
+
+Gets help for the application or its commands. Can also list the commands in a way helpful to creating a bash-style completion function
+===== Options
+===== -c
+List commands one per line, to assist with shell completion
+
+
+
+==== Command: <tt>ls </tt>
+List paths and their keys
+
+
+===== Options
+===== -E
+Don't escape the paths
+
+
+
+===== -k|--[no-]keys-only
+List keys only
+
+
+
+===== -p|--[no-]paths-only
+List paths only
+
+
+
+==== Command: <tt>mv </tt>
+(Ex)change key of path to another
+
+
+===== Options
+===== -e|--[no-]exchange
+Exchange keys
+
+
+
+==== Command: <tt>rm </tt>
+Delete paths with keys
+
+
+===== Options
+===== -a|--[no-]all
+Delete all paths
+
+
+
+==== Command: <tt>so </tt>
+Sort paths by key
+
+
+[Default Command] help

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: overpath
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Fang Qiuming
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-08-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: gli
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.16'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.16'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: A manager of your common paths
+email: fangqiuming@outlook.com
+executables:
+- overpath
+extensions: []
+extra_rdoc_files:
+- overpath.rdoc
+files:
+- bin/overpath
+- lib/overpath.rb
+- lib/overpath/path_printer.rb
+- lib/overpath/path_table.rb
+- overpath.rdoc
+homepage: http://rubygems.org/gems/overpath
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: Drive in Bash like a Pro
+test_files: []