cli-topic 0.9.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: db41d9576d7783ae342b2baf3038f6ec6b352c0c
+  data.tar.gz: 6b4599889c0274065ae9476057cde4578c8d1fd8
+SHA512:
+  metadata.gz: 43c307785885c77a48275e7816178d086310c828b708ab0aa2e7f20969842713854be436cc35535203e320b2992541c73d2039f0d267dce208e86397df58792e
+  data.tar.gz: 9acf2789a9ffea0eed9bcebfea86de716e3e2cc2ce2018d695392796a88da7bf8457d919d4668612a453d75257eb33b2cea43de87697c02bc3e5e7c0ee8e92ef

data/Changelog

@@ -0,0 +1,3 @@
+- 0.0.1
+ * Initial version
+-- Antoine Legrand <antoine.legrand@ubudu.com>  27/07/2013

data/License

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Antoine Legrand (ant.legrand@gmail.com)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,12 @@
+Topicli
+==========
+'Small framework to build CLI. It provide simple way to declare options/descriptions/topics to focus only on the "action" part of commands.
+Some features:
+- Light DSL
+- Commands are organised in Topic (aka Subcommands)
+- DRY options declaration, it\'s use 3 layers: global -> topic -> command
+- Each topic has it\'s own description/options list
+- Load options values from a config file
+- Built-in Help command: ./cli help TOPIC/COMMAND
+- Flexible option-parser, Cli-topic use the stdlib OptionParser by default, but can be changed to Slop/Trollop or any custom one.
+- Command suggestions',

data/lib/clitopic/cli.rb

@@ -0,0 +1,34 @@
+require 'clitopic/commands'
+require 'clitopic/command'
+require 'clitopic/helpers'
+module Clitopic
+  module Cli
+
+    class << self
+
+      def run(args)
+        args = args.dup
+        $stdin.sync = true if $stdin.isatty
+        $stdout.sync = true if $stdout.isatty
+        command = args.shift.strip rescue "help"
+        if !Clitopic.commands_dir.nil?
+          Clitopic::Commands.load_commands(Clitopic.commands_dir)
+        end
+        Clitopic::Commands.run(command, args)
+      rescue Errno::EPIPE => e
+        puts e.message #error(e.message)
+        puts e.backtrace
+      rescue Interrupt => e
+        `stty icanon echo`
+        if Clitopic.debug
+          Clitopic::Helpers.styled_error(e)
+        else
+          Clitopic::Helpers.error("Command cancelled.", false)
+        end
+      rescue => error
+        Clitopic::Helpers.styled_error(error)
+        exit(1)
+      end
+    end
+  end
+end

data/lib/clitopic/command/base.rb

@@ -0,0 +1,136 @@
+require 'clitopic/utils'
+require 'clitopic/parsers'
+require 'clitopic/topic'
+
+module Clitopic
+  module Command
+    class Base
+      class << self
+        include Clitopic.parser
+
+        attr_accessor :name, :banner, :description, :hidden, :short_description
+        attr_accessor :arguments, :options
+
+        def cmd_options
+          @cmd_options ||= []
+        end
+
+        def banner
+          @banner ||= "Usage: #{Clitopic.name} #{self.fullname} [options]"
+        end
+
+        def short_description
+          if @short_description.nil?
+            if description
+              @short_description = description.split("\n").first
+            end
+          end
+          return @short_description
+        end
+
+        def option(name, *args, &blk)
+          opt = Clitopic::Utils.parse_option(name, *args, &blk)
+          if !opt[:default].nil?
+            options[name] = opt[:default]
+          end
+          cmd_options << opt
+        end
+
+        def fullname
+          if topic.nil?
+            return name
+          elsif name == 'index'
+            "#{topic.name}"
+          else
+            "#{topic.name}:#{name}"
+          end
+        end
+
+        def call()
+          puts "call with #{options} #{arguments}"
+        end
+
+        def arguments
+          @arguments ||= []
+        end
+
+        def options
+          @options ||= {}
+        end
+
+        def load_defaults(file=nil)
+          if file.nil?
+            Clitopic.default_files.each do |f|
+              if File.exist?(f)
+                file = f
+                break
+              end
+            end
+          end
+
+          if file.nil?
+            return
+          end
+
+          defaults = YAML.load_file(file)
+          if self.topic.nil?
+            cmd_defaults = defaults[self.name]
+          else
+            cmd_defaults = defaults[self.topic.name][self.name]
+          end
+
+          if cmd_defaults.nil?
+            return
+          end
+
+          cmd_defaults[:options].each do |name, value|
+            if !value.nil?
+              if options[name].nil?
+                options[name] = value
+              elsif options[name].is_a?(Array)
+                options[name] += value
+              end
+            end
+          end
+          if cmd_defaults[:arguments] && !arguments
+            arguments += Array(cmd_defaults[:arguments])
+          end
+        end
+
+        def topic(arg=nil)
+          if !arg.nil?
+            if arg.is_a?(String)
+              @topic ||= Topics[arg]
+            elsif arg.is_a?(Class) && arg < Clitopic::Topic::Base
+              @topic ||= arg.instance
+            elsif arg.is_a?(Hash)
+              @topic ||= Clitopic::Topic::Base.register(arg)
+            end
+          end
+          return @topic
+        end
+
+
+        def register(opts={})
+          opts = {hidden: false}.merge(opts)
+          if !opts.has_key?(:name)
+            raise ArgumentError.new("missing Command name")
+          end
+
+          topic(opts[:topic])
+          @description = opts[:description]
+          @name = opts[:name]
+          @hidden = opts[:hidden]
+          @banner = opts[:banner]
+          @short_description = opts[:short_description]
+
+          if @topic.nil?
+            Clitopic::Commands.global_commands[name] = self
+          else
+            topic.commands[name] = self
+          end
+        end
+      end
+    end
+  end
+end

data/lib/clitopic/command/clito.rb

@@ -0,0 +1,99 @@
+require 'yaml'
+require 'clitopic/command/base'
+require 'clitopic/helpers'
+
+module Clitopic
+  module Command
+    class ClitoTopic < Clitopic::Topic::Base
+      register name: 'clito',
+        description: 'clitopic commands',
+        hidden: true
+    end
+
+    class Suggestions < Clitopic::Command::Base
+      register name: 'suggestions',
+      description: 'suggests available commands base on incomplete input',
+      hidden: true,
+      topic: 'clito'
+
+      def self.call
+        puts Clitopic::Helpers.suggestion(@arguments[0], Clitopic::Commands.all_commands)
+      end
+
+    end
+
+    class DefaultFile < Clitopic::Command::Base
+      register name: 'defaults_file',
+      description: "create default file",
+      hidden: true,
+      topic: 'clito'
+
+      option :merge, "--[no-]merge", "Merge options with current file", default: true
+      option :force, "-f", "--force", "Overwrite file", default: false
+      option :hidden, "--with-hidden", "include hidden cmds/topics", default: false
+
+      class << self
+        def cmd_opts(cmd, opts)
+          if cmd.cmd_options.size > 0 && (!cmd.hidden || options[:hidden])
+            opts[cmd.name] = {options: {}, args: []}
+            cmd.cmd_options.each do |opt|
+              opts[cmd.name][:options][opt[:name].to_s] = opt[:default]
+            end
+          end
+        end
+
+        def dump_options(file, merge=true, force=false)
+          opts = {}
+          Clitopic::Commands.global_commands.each do |c, cmd|
+            cmd_opts(cmd, opts)
+          end
+          Clitopic::Topics.topics.each do |topic_name, topic|
+            if topic.commands.size > 0 && (!topic.hidden || options[:hidden])
+              opts[topic_name] = {}
+              topic.commands.each do |c, cmd|
+                cmd_opts(cmd, opts[topic_name])
+              end
+            end
+          end
+
+          if File.exist?(file)
+            if merge == false && force == false
+              raise ArgumentError.new("File #{file} exists, use --merge or --force")
+            end
+            if merge && !force
+              opts = opts.merge(YAML.load_file(file))
+            end
+          end
+          puts "write: #{file}"
+          File.open(file, 'wb') do  |file|
+            file.write(opts.to_yaml)
+          end
+          puts opts.to_yaml
+        end
+
+        def call
+          puts @options
+          if @arguments.size == 0
+            raise ArgumentError.new("Missing file")
+          end
+          file = @arguments[0]
+          dump_options(file, @options[:merge], @options[:force])
+        end
+      end
+
+    end
+
+    class ClitoVersion < Clitopic::Command::Base
+      register name: 'version',
+      description: "Display clitopic version",
+      hidden: true,
+      topic: 'clito'
+
+      class  << self
+        def call
+          puts "cli-topic version: #{Clitopic::VERSION}"
+        end
+      end
+    end
+  end
+end

data/lib/clitopic/command/help.rb

@@ -0,0 +1,173 @@
+require 'clitopic/command/base'
+
+module Clitopic
+  module Topic
+    class Help < Clitopic::Topic::Base
+      register name: "help", description: "topic description"
+    end
+  end
+
+  module Command
+    class Help2 < Clitopic::Command::Base
+      register name: 'help2',
+      description: "Display helps",
+      banner: "Display helps",
+      topic: "help"
+
+      option :all, "--all", "Display all topics with all commands"
+      option :topics, "--topics", "Display all availables topics"
+      option :topic, "--topic=TOPIC", "Display availables commands for the TOPIC"
+      option :with_hidden, "--with-hidden", "Include hidden commands/topics"
+    end
+
+    class Help < Clitopic::Command::Base
+      register name: 'index',
+      banner: "Usage: #{Clitopic.name} help [COMMAND]",
+      description: "list available commands or display help for a specific command",
+      topic: "help"
+
+      option :all, "--all", "Display all topics with all commands"
+      option :topics, "--topics", "Display all availables topics"
+      option :topic, "--topic=TOPIC", "Display availables commands for the TOPIC"
+      option :with_hidden, "--with-hidden", "Include hidden commands/topics"
+      class  << self
+
+
+        def header(obj)
+          puts obj.description
+          puts "\n"
+        end
+
+        def display_globals
+          puts "Primary help topics, type \"#{Clitopic.name} help TOPIC\" for more details:\n\n"
+          Clitopic::Commands.global_commands.each do |name, cmd|
+            puts ("%-#{longest_global_cmd + 3}s  # %s" % [ "#{name}", "#{cmd.short_description}"]).indent(2)
+          end
+        end
+
+        def display_cmd(cmd, with_header=false)
+          if with_header
+            header(cmd)
+          end
+          if cmd.hidden == false || options[:with_hidden] == true
+            puts cmd.help
+            puts "\n\n"
+          end
+        end
+
+        def longest_global_cmd
+          @longest_global_cmd ||= Clitopic::Commands.global_commands.keys.map{|k| k.size}.max
+        end
+
+        def longest_cmd
+          @longest_cmd ||= Clitopic::Commands.all_commands.map{|k| k.size}.max
+        end
+
+        def longest_topic
+          @longest_topic ||= Topics.topics.keys.map{|k| k.size}.max
+        end
+
+        def display_topic(topic_name, with_commands=false, with_header=false)
+          if with_commands
+            longest = longest_cmd
+          else
+            longest = longest_topic
+          end
+          topic = Topics[topic_name]
+          if with_header
+            header(topic)
+          end
+          if topic.hidden == false || options[:with_hidden] == true
+            if with_header
+              if !topic.commands['index'].nil?
+                display_cmd(topic.commands['index'])
+              end
+            else
+              puts ("%-#{longest + 3}s  # %s" % [ "#{topic_name}", "#{topic.short_description}" ]).indent(2)
+            end
+            if with_commands
+              puts "Additional commands, type \"#{Clitopic.name} help COMMAND\" for more details:\n\n" if with_header
+              topic.commands.each do |cmd_name, cmd|
+                puts ("   %-#{longest}s  # %s" % [ "#{cmd.fullname}", "#{cmd.short_description}"]).indent(2)
+              end
+              puts ""
+            end
+          end
+        end
+
+        def display_topic_help(topic_name)
+          topic = Topics[topic_name]
+          longest = topic.commands.keys.map{|a| "#{topic_name}:#{a}".size}.max
+          header(topic)
+
+          if topic.hidden == false || options[:with_hidden] == true
+            if !topic.commands['index'].nil?
+              display_cmd(topic.commands['index'], true)
+            end
+            puts "Additional commands, type \"#{Clitopic.name} help COMMAND\" for more details:\n\n"
+            topic.commands.each do |cmd_name, cmd|
+              puts ("%-#{longest}s  # %s" % [ "#{cmd.fullname}", "#{cmd.short_description}"]).indent(2)
+            end
+          end
+        end
+
+        def display_topic(topic_name, with_commands=false, with_header=false)
+          if with_commands
+            longest = longest_cmd
+          else
+            longest = longest_topic
+          end
+          topic = Topics[topic_name]
+          header(topic) if with_header
+
+          if topic.hidden == false || options[:with_hidden] == true
+            puts ("%-#{longest + 3}s  # %s" % [ "#{topic_name}", "#{topic.short_description}" ]).indent(2)
+            if with_commands
+              topic.commands.each do |cmd_name, cmd|
+                puts ("   %-#{longest}s  # %s" % [ "#{cmd.fullname}", "#{cmd.short_description}"]).indent(2)
+              end
+              puts ""
+            end
+          end
+        end
+
+        def display_topics(with_commands=false)
+          puts "Additional topics:\n\n"
+          Clitopic::Topics.topics.each do |topic_name, topic|
+            display_topic(topic_name, with_commands)
+          end
+        end
+
+        def display_all(with_commands=false)
+          puts "Usage: #{Clitopic.name} COMMAND [command-specific-options]\n\n"
+
+          header(self)
+          display_globals
+          puts "\n"
+          display_topics(with_commands)
+        end
+
+        def call
+          if options[:all] == true
+            display_all(true)
+          elsif options.has_key?(:topic)
+            display_topic_help(options[:topic])
+          elsif arguments.size > 0
+            if Clitopic::Topics.topics[arguments[0]] != nil
+              display_topic_help(arguments[0])
+            else
+              cmd, topic = Clitopic::Commands.find_cmd(arguments[0])
+              if cmd.nil?
+                puts "Unknown command: #{arguments[0]}\n show all available commands with help --all"
+              else
+                display_cmd(cmd, true)
+              end
+            end
+          else
+            display_all
+          end
+        end
+      end
+    end
+  end
+end

data/lib/clitopic/command/version.rb

@@ -0,0 +1,22 @@
+require 'clitopic/command/base'
+
+module Clitopic
+  module Command
+
+    class Version < Clitopic::Command::Base
+      register name: 'version',
+      description: "show #{Clitopic.name} current version
+
+Example:
+
+ $ #{Clitopic.name} version
+ #{Clitopic.version}
+"
+      class  << self
+        def call
+          puts Clitopic.version
+        end
+      end
+    end
+  end
+end

data/lib/clitopic/command.rb

@@ -0,0 +1,4 @@
+require 'clitopic/command/base'
+Dir[File.join(File.dirname(__FILE__), "command", "*.rb")].each do |file|
+  require file
+end

data/lib/clitopic/commands.rb

@@ -0,0 +1,123 @@
+require 'clitopic/utils'
+require 'clitopic/topics'
+
+module Clitopic
+  module Commands
+    class CommandFailed  < RuntimeError; end
+
+    module ClassMethods
+      attr_accessor :binary, :current_cmd, :current_topic
+
+      def load_commands(dir)
+        Dir[File.join(dir, "*.rb")].each do |file|
+          require file
+        end
+      end
+
+      def current_args
+        @current_args
+      end
+
+      def current_options
+        @current_options ||= {}
+      end
+
+      def global_options
+        @global_options ||= []
+      end
+
+      def global_commands
+        @global_commands ||= {}
+      end
+
+      def global_option(name, *args, &blk)
+        # args.sort.reverse gives -l, --long order
+        global_options << Clitopic::Utils.parse_option(name, *args, &blk)
+      end
+
+      def invalid_arguments
+        @invalid_arguments
+      end
+
+      def shift_argument
+        # dup argument to get a non-frozen string
+        @invalid_arguments.shift.dup rescue nil
+      end
+
+      def validate_arguments!(invalid_options)
+        unless invalid_options.empty?
+          arguments = invalid_options.map {|arg| "\"#{arg}\""}
+          if arguments.length == 1
+            message = "Invalid option: #{arguments.first}"
+          elsif arguments.length > 1
+            message = "Invalid options: "
+            message << arguments[0...-1].join(", ")
+            message << " and "
+            message << arguments[-1]
+          end
+          $stderr.puts(Clitopic::Helpers.format_with_bang(message) + "\n\n")
+          run(@current_cmd.fullname, ["--help"])
+        end
+      end
+
+      def all_commands
+        cmds = []
+        Topics.topics.each do |k,topic|
+          topic.commands.each do |name, cmd|
+            if name == 'index'
+              cmds << topic.name
+            else
+              cmds << "#{topic.name}:#{name}"
+            end
+          end
+        end
+        cmds += global_commands.keys
+        return cmds
+      end
+
+      def prepare_run(cmd, arguments)
+        @current_options, @current_args = cmd.parse(arguments.dup)
+      rescue OptionParser::ParseError => e
+        $stderr.puts Clitopic::Helpers.format_with_bang(e.message)
+        run("help", [cmd.fullname])
+      end
+
+      def run(cmd, arguments=[])
+        if cmd == "-h" || cmd == "--help"
+          cmd = 'help'
+        end
+        @current_cmd, @current_topic = find_cmd(cmd)
+        if !@current_cmd
+          Clitopic::Helpers.error([ "`#{cmd}` is not a command.",
+                                    Clitopic::Helpers.display_suggestion(cmd, all_commands),
+                                    "See `help` for a list of available commands."
+                                  ].compact.join("\n\n"))
+        end
+        prepare_run(@current_cmd, arguments)
+        if @current_cmd.options[:load_defaults] != true && Clitopic.load_defaults?
+          @current_cmd.load_defaults
+        end
+        @current_cmd.call
+      end
+
+      def find_cmd(command)
+        cmd_name, sub_cmd_name = command.split(':')
+        if global_commands.has_key?(command)
+          current_cmd = global_commands[cmd_name]
+        elsif !Topics[cmd_name].nil?
+          sub_cmd_name = 'index' if sub_cmd_name.nil?
+          current_topic = Topics[cmd_name]
+          current_cmd = current_topic.commands[sub_cmd_name]
+        else
+          current_cmd = global_commands[:help]
+        end
+        return current_cmd, current_topic
+      end
+    end
+
+    class << self
+      include ClassMethods
+    end
+  end
+
+end