kuzya 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 9934032c8c87c655de6c945864e05493774586afaa993348293567cee78fd9fb
+  data.tar.gz: 38009f41e6cf724ba37e05618b7afa5a5e26e02cda414c09fba03ede81f8032e
+SHA512:
+  metadata.gz: 12e3cd198b290369fe94ae30a00f97c93053ae5b609767b960d96ce2289f8e91c713f5f6e367cf9989969ffcc2a7aeae041493f515f822fe5fa7207b74b20770
+  data.tar.gz: ff65055331b13bc43c6c77f275263fde3d1bf14900a44ad41cebb807224e67826d2690c03d42aee4171a3a5cfdfa4a29b77f988c455c9aae4738850e8190262d

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/README.md

@@ -0,0 +1,89 @@
+# Kuzya
+
+__Kuzya__ - application to quickly open links from you terminal without mouse.
+
+___
+
+## How to install
+
+### by rubygems
+
+To install Kuzya as gem run.
+```bash
+gem install kuzya
+```
+You will need Ruby 2.4.0 or higher
+
+If you using RVM you can install kuzya to @global gemset (but keep in mind that this per ruby interpeter, not for all rubies)
+```bash
+rvm @global do gem install kuzya
+```
+
+___
+
+## How to use
+
+### Open links
+
+To open the link just run
+```
+kuzya https://example.com
+```
+Kuzya will open it on your browser.
+
+### Adding Shortcuts
+
+You can make shortcuts to open links faster!
+Run
+```bash
+kuzya add SHORTCUT_NAME https://example.com
+```
+You also can create nested shortcuts, just run
+```bash
+kuzya add PARENT_SHORTCUT CHILD_SHORTCUT some_text
+```
+(Note: you need to create parent shortcuts firstly to have ability to add nested ones)  
+(Note #2: you can't create shortcuts named __add__ | __remove__ | __list__ | __help__ )
+
+Example:
+
+```bash
+kuzya add gh https://github.com`
+kuzya add gh rb ruby
+kuzya gh rb rake # Kuzya will open https://github.com/ruby/rake
+```
+
+### Removing Shurtcuts
+
+You can remove shortcuts by
+```bash
+kuzya remove SHORTCUT_NAME
+```
+But please keep in mind that if shorcut contains another shortcuts they aslo will be Add frozen_string_literal. Cleanup. Add normal path to config file
+
+### List saved shorcuts
+
+To see the list of your shorcuts run
+```bash
+kuzya list
+```
+
+### Help command
+
+Kuzya can show you information about itself, run
+```bash
+kuzya help
+```
+
+___
+___
+
+https://opensource.org/licenses/isc-license.txt
+
+ISC License (ISC)
+
+Copyright (c) 2021 Dmitry Krushinsky
+
+Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

data/bin/kuzya

@@ -0,0 +1,4 @@
+#!usr/bin/env ruby
+
+require 'kuzya'
+Kuzya::CLI.call(ARGV)

data/kuzya.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |s|
+  s.name = 'kuzya'
+  s.version = '0.0.1'
+  s.summary = 'Utility to open urls in browser from terminal.'
+  s.description = "Wrapper for 'launchy' gem to using shortcuts."
+  s.author = 'Dmitry Krushinsky'
+  s.email = 'd.krushinsky.00@gmail.com'
+  s.files = `git ls-files`.split("\n")
+  s.license = 'MIT'
+
+  s.add_dependency 'launchy'
+
+  s.executables = ['kuzya']
+end

data/lib/kuzya.rb

@@ -0,0 +1,13 @@
+require 'kuzya/core_ext/hash/deep_merge'
+require 'kuzya/core_ext/hash/deep_compact'
+require 'kuzya/core_ext/string/formatting'
+
+module Kuzya
+  SUMMARY = "#{'Kuzya'.bold} - app to open link from you lovely terminal!".freeze
+end
+
+require 'kuzya/service'
+require 'kuzya/config'
+require 'kuzya/url_builder'
+require 'kuzya/commands'
+require 'kuzya/cli'

data/lib/kuzya/cli.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Kuzya
+  class CLI < Kuzya::Service
+    def initialize(args)
+      @args = args
+    end
+
+    def call
+      config = Kuzya::Config.new
+
+      build_command.call(args, config)
+    end
+
+    private
+
+    attr_reader :args
+
+    def build_command
+      command = Kuzya::Commands.reserved?(args.first) ? args.first : 'open'
+
+      Object.const_get("Kuzya::Commands::#{command.capitalize}")
+    end
+
+    def args_without_command
+      args.dup.tap { |ary| ary.shift }
+    end
+  end
+end

data/lib/kuzya/commands.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Kuzya
+  module Commands
+    RESERVED_COMMANDS = %w[
+      add
+      remove
+      list
+      help
+    ].freeze
+
+    def self.reserved?(first_arg)
+      RESERVED_COMMANDS.include? first_arg
+    end
+  end
+end
+
+require 'kuzya/commands/base'
+require 'kuzya/commands/open'
+require 'kuzya/commands/add'
+require 'kuzya/commands/remove'
+require 'kuzya/commands/list'
+require 'kuzya/commands/help'

data/lib/kuzya/commands/add.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Kuzya
+  module Commands
+    class Add < Kuzya::Commands::Base
+      class << self
+        def info
+<<-INFO
+#{'add'.bold} - to add new shortcut use #{'kuzya add short www.example.com'.italic}.
+You can adds shortcuts inside other shurtcuts, e.g.
+  #{'kuzya add stack https://stackoverflow.com'.italic}
+  #{'kuzya add stack q questions'.italic}
+  #{'kuzya add stack q active ?tab=Active'.italic}
+And now if run '#{'kuzya stack q active'.italic}' you will see all active questions
+Note: You can't add first-level shortcuts named as [add, remove, list, help]
+INFO
+        end
+
+        def prepare(args, config)
+          [args_without_command(args), config]
+        end
+      end
+
+      def initialize(args, config)
+        @args = args
+        @config = config
+      end
+
+      def call
+        config.add(args)
+      end
+
+      private
+
+      attr_reader :args, :config
+    end
+  end
+end

data/lib/kuzya/commands/base.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Kuzya
+  module Commands
+    class Base
+      class << self
+        def info
+          raise NotImplementedError
+        end
+
+        def call(args, config)
+          new(*prepare(args, config)).call
+        end
+
+        # Returns array of arguments that will be passed to constructor
+        def prepare(_args, _config)
+          raise NotImplementedError
+        end
+
+        def args_without_command(args)
+          args.dup.tap { |ary| ary.shift }
+        end
+      end
+    end
+  end
+end

data/lib/kuzya/commands/help.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Kuzya
+  module Commands
+    class Help < Kuzya::Commands::Base
+      SUPPORTED_COMMANDS = [
+        Kuzya::Commands::Open,
+        Kuzya::Commands::Help,
+        Kuzya::Commands::Add,
+        Kuzya::Commands::Remove,
+        Kuzya::Commands::List
+      ].freeze
+
+      class << self
+        def info
+<<-INFO
+#{'help'.bold} - to read info about kuzya's commands run '#{'kuzya help'.italic}'
+INFO
+        end
+
+        def prepare(_args, _config)
+          # Do nothing
+        end
+      end
+
+      def initialize
+      end
+
+      def call
+        puts "#{Kuzya::SUMMARY}\n\n"
+
+        SUPPORTED_COMMANDS.each do |command|
+          puts "#{command.info.to_s}\n"
+        end
+      end
+    end
+  end
+end

data/lib/kuzya/commands/list.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Kuzya
+  module Commands
+    class List < Kuzya::Commands::Base
+      class << self
+        def info
+<<-INFO
+#{'list'.bold} - to see all shortcuts run '#{'kuzya list'.italic}'
+INFO
+        end
+
+        def prepare(_args, config)
+          [config]
+        end
+      end
+
+      def initialize(config)
+        @config = config
+      end
+
+      def call
+        resolved = []
+        resolve_shortcuts([], [], fetch_keys(config.shortcuts), resolved)
+
+        resolved.each do |shortcuts|
+          puts  "#{shortcuts.join(' ').bold}: #{Kuzya::UrlBuilder.call(shortcuts, config).italic}"
+        end
+      end
+
+      private
+
+      attr_reader :config
+
+      def fetch_keys(hash)
+        hash.dup.tap { |h| h.delete('_url') }.map do |key, value|
+          next key unless value.is_a?(Hash)
+
+          result = [key, fetch_keys(value)].reject(&:empty?)
+          result.length == 1 ? key : result
+        end.reject(&:empty?)
+      end
+
+      def resolve_shortcuts(com, prev_com, shortcuts, resolved)
+        shortcuts.each do |arg|
+          if arg.is_a?(String)
+            com = prev_com.dup.concat([arg])
+            resolved.push(com)
+            next
+          end
+
+          prev_com = com.dup
+          resolve_shortcuts(com, prev_com, arg, resolved)
+          com = []
+        end
+      end
+    end
+  end
+end

data/lib/kuzya/commands/open.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'launchy'
+
+module Kuzya
+  module Commands
+    class Open < Kuzya::Commands::Base
+      URL_REGEXP = /\A#{URI::regexp(['http', 'https'])}\z/.freeze
+
+      class << self
+        def info
+          <<-INFO
+#{'open'.bold} - to open any link run '#{'kuzya www.example.com'.italic}'
+Also you can use your saved shortcuts instead of writing entire URL
+e.g. add 'gh' shortcut as 'https://github.com' and 'rb' as 'ruby'
+with 'kuzya add' command and run '#{'kuzya gh rb rake'.italic}'. Kuzya will make
+the URL and open 'https://github.com/ruby/rake'.
+          INFO
+        end
+
+        def prepare(args, config)
+          [Kuzya::UrlBuilder.call(args, config)]
+        end
+      end
+
+      def initialize(url)
+        @url = url
+      end
+
+      def call
+        puts "Open #{url}"
+        raise unless url =~ URL_REGEXP
+
+        Launchy.open(url)
+      rescue
+        puts "Can't open '#{url}', please check it, maybe you don't have shortcuts or URL is invalid".red
+      end
+
+      private
+
+      attr_reader :url
+    end
+  end
+end

data/lib/kuzya/commands/remove.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Kuzya
+  module Commands
+    class Remove < Kuzya::Commands::Base
+      class << self
+        def info
+<<-INFO
+#{'remove'.bold} - if you want to remove shortcut you can run:
+  #{'kuzya remove shortcut_name'.italic}
+Also you can remove nested shortcuts, to do it run:
+  #{'kuzya remove parent_shortcut child_shortcut'.italic}
+Note: Removing shortcut that have nested shortcuts also removes them
+INFO
+        end
+
+        def prepare(args, config)
+          [args_without_command(args), config]
+        end
+      end
+
+      def initialize(args, config)
+        @args = args
+        @config = config
+      end
+
+      def call
+        config.remove(args)
+      end
+
+      private
+
+      attr_reader :args, :config
+    end
+  end
+end

data/lib/kuzya/config.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'yaml'
+
+module Kuzya
+  class Config
+    PATH_TO_DIR = "#{Dir.home}/.kuzya".freeze
+    PATH_TO_CONFIG = "#{Dir.home}/.kuzya/kuzya.yml".freeze
+
+    attr_reader :shortcuts
+
+    def initialize
+      FileUtils.mkdir_p(PATH_TO_DIR) # Creates file if not exists
+      FileUtils.touch(PATH_TO_CONFIG) # Creating file if not exists
+      @shortcuts = YAML.load(File.read(PATH_TO_CONFIG)) || {}
+    end
+
+    def add(keys)
+      value = keys.pop
+
+      scan_shortcuts(keys)
+
+      new_shortcut = build_shortcut(keys, value)
+      @shortcuts.deep_merge!(new_shortcut)
+      save
+
+      puts 'Done.'
+    end
+
+    def remove(keys)
+      scan_shortcuts(keys)
+
+      empty_shortcut = build_empty_shortcut(keys)
+      @shortcuts.deep_merge!(empty_shortcut)
+      @shortcuts = Hash.deep_compact(@shortcuts)
+
+      save
+    end
+
+    private
+
+    def save
+      File.open(PATH_TO_CONFIG, 'w') { |file| file.write(@shortcuts.to_yaml) }
+    end
+
+    def build_empty_shortcut(keys)
+      keys.reverse.inject(nil) { |assigned_value, key| { key => assigned_value } }
+    end
+
+    def build_shortcut(keys, value)
+      keys.reverse.inject({ '_url' => value }) do |assigned_value, key|
+        { key => assigned_value }
+      end
+    end
+
+    def scan_shortcuts(keys)
+      shortcuts.dup do |hash|
+        keys.each do |key|
+          next hash = hash[key] if hash.key?(key)
+
+          puts "Key '#{key}' not found. Check spelling or add it by 'kuzya #{keys.join(' ')} www.example.com'."
+          exit(1)
+        end
+      end
+    end
+  end
+end

data/lib/kuzya/core_ext/hash/deep_compact.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Hash
+  def self.deep_compact(hash)
+    result = hash.map do |key, value|
+      value = deep_compact(value) if value.is_a?(Hash)
+
+      value = nil if [{}, []].include?(value)
+      [key, value]
+    end
+
+    result.to_h.compact
+  end
+end

data/lib/kuzya/core_ext/hash/deep_merge.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Hash
+  # Copy-pasted from activesupport/lib/active_support/core_ext/hash/deep_merge.rb
+  def deep_merge!(other_hash, &block)
+    merge!(other_hash) do |key, this_val, other_val|
+      if this_val.is_a?(Hash) && other_val.is_a?(Hash)
+        this_val.deep_merge(other_val, &block)
+      elsif block_given?
+        block.call(key, this_val, other_val)
+      else
+        other_val
+      end
+    end
+  end
+
+  def deep_merge(other_hash, &block)
+    dup.deep_merge!(other_hash, &block)
+  end
+end

data/lib/kuzya/core_ext/string/formatting.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class String
+  def bold
+    "\e[1m#{self}\e[22m"
+  end
+
+  def italic
+    "\e[3m#{self}\e[23m"
+  end
+
+  def red
+    "\e[31m#{self}\e[0m"
+  end
+end

data/lib/kuzya/service.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Kuzya
+  class Service
+    def self.call(*args)
+      new(*args).call
+    end
+  end
+end

data/lib/kuzya/url_builder.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Kuzya
+  class UrlBuilder < Kuzya::Service
+    def initialize(args, config)
+      @args = args
+      @config = config
+    end
+
+    def call
+      url = ''
+
+      config.shortcuts.dup.tap do |conf|
+        args.each do |key|
+          conf = conf.fetch(key, { '_url' => key })
+          url += "#{conf.fetch('_url')}/"
+        end
+      end
+
+      url
+    end
+
+    private
+
+    attr_reader :config, :args
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: kuzya
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Dmitry Krushinsky
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-08-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: launchy
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Wrapper for 'launchy' gem to using shortcuts.
+email: d.krushinsky.00@gmail.com
+executables:
+- kuzya
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- README.md
+- bin/kuzya
+- kuzya.gemspec
+- lib/kuzya.rb
+- lib/kuzya/cli.rb
+- lib/kuzya/commands.rb
+- lib/kuzya/commands/add.rb
+- lib/kuzya/commands/base.rb
+- lib/kuzya/commands/help.rb
+- lib/kuzya/commands/list.rb
+- lib/kuzya/commands/open.rb
+- lib/kuzya/commands/remove.rb
+- lib/kuzya/config.rb
+- lib/kuzya/core_ext/hash/deep_compact.rb
+- lib/kuzya/core_ext/hash/deep_merge.rb
+- lib/kuzya/core_ext/string/formatting.rb
+- lib/kuzya/service.rb
+- lib/kuzya/url_builder.rb
+homepage: 
+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: []
+rubygems_version: 3.0.8
+signing_key: 
+specification_version: 4
+summary: Utility to open urls in browser from terminal.
+test_files: []