hammer_cli 0.15.1 → 0.16.0

data/lib/hammer_cli/exception_handler.rb

@@ -50,7 +50,7 @@ module HammerCLI
     end
 
     def print_message(msg, options = {})
-      output.print_message(msg, nil, options)
+      output.print_message(msg, {}, options)
     end
 
     def log_full_error(e, message = e.message)

data/lib/hammer_cli/help/definition.rb

@@ -0,0 +1,55 @@
+require_relative 'definition/abstract_item'
+require_relative 'definition/text'
+require_relative 'definition/list'
+require_relative 'definition/section'
+
+module HammerCLI
+  module Help
+    class Definition < Array
+      def build_string
+        @out = StringIO.new
+        each do |item|
+          next unless item.is_a? AbstractItem
+          @out.puts unless first_print?
+          @out.puts item.build_string
+        end
+        @out.string
+      end
+
+      def find_item(item_id)
+        self[item_index(item_id)]
+      end
+
+      def at(path)
+        return super(path) if path.is_a? Integer
+        return self if path.empty?
+        expand_path(path)
+      end
+
+      def insert_definition(mode, item_id, definition)
+        HammerCLI.insert_relative(self, mode, item_index(item_id), *definition)
+      end
+
+      private
+
+      def expand_path(path)
+        path = [path] unless path.is_a? Array
+        item = find_item(path[0])
+        return item if path[1..-1].empty?
+        item.definition.at(path[1..-1])
+      end
+
+      def first_print?
+        @out.size.zero?
+      end
+
+      def item_index(item_id)
+        index = find_index do |item|
+          item.id == item_id
+        end
+        raise ArgumentError, "Help item '#{item_id}' not found" if index.nil?
+        index
+      end
+    end
+  end
+end

data/lib/hammer_cli/help/definition/abstract_item.rb

@@ -0,0 +1,38 @@
+module HammerCLI
+  module Help
+    class AbstractItem
+      INDENT_STEP = 2
+
+      attr_reader :id
+      attr_accessor :definition
+
+      def initialize(options = {})
+        @id = options[:id]
+        @indentation = options[:indentation]
+      end
+
+      def build_string
+        raise NotImplementedError
+      end
+
+      def self.indent(content, indentation = nil)
+        indentation ||= ' ' * INDENT_STEP
+        content = content.split("\n") unless content.is_a? Array
+        content.map do |line|
+          (indentation + line).rstrip
+        end.join("\n")
+      end
+
+      protected
+
+      def build_definition(content)
+        raise NotImplementedError
+      end
+
+      def indent(content, indentation = nil)
+        indentation ||= @indentation
+        self.class.indent(content, indentation)
+      end
+    end
+  end
+end

data/lib/hammer_cli/help/definition/list.rb

@@ -0,0 +1,53 @@
+module HammerCLI
+  module Help
+    class List < AbstractItem
+      LIST_INDENT = 20
+
+      def initialize(items, options = {})
+        super(options)
+        @indent_size = options[:indent_size] || indent_size(items)
+        build_definition(items || [])
+      end
+
+      def build_string
+        out = StringIO.new
+        @definition.each do |item|
+          out.puts item.build_string
+        end
+        out.string
+      end
+
+      protected
+
+      def build_definition(items)
+        @definition = Definition.new
+        items.each do |item|
+          @definition << Text.new(format_item(item))
+        end
+        @definition
+      end
+
+      private
+
+      def indent_size(items)
+        items = normalize(items)
+        max_len = items.map { |i| i[0].to_s.length }.max
+        (max_len + INDENT_STEP > LIST_INDENT) ? (max_len + INDENT_STEP) : LIST_INDENT
+      end
+
+      def format_item(item)
+        col1, col2 = item
+        col2 = indent(col2.to_s, ' ' * @indent_size).lstrip
+        line = "%-#{@indent_size}s%s" % [col1, col2]
+        line.strip!
+        line
+      end
+
+      def normalize(items)
+        items.map do |i|
+          i.is_a?(Array) ? i : [i]
+        end
+      end
+    end
+  end
+end

data/lib/hammer_cli/help/definition/section.rb

@@ -0,0 +1,36 @@
+module HammerCLI
+  module Help
+    class Section < AbstractItem
+      attr_reader :label
+
+      def initialize(label, definition = nil, options = {})
+        super(options)
+        @label = label
+        @richtext = options[:richtext] || false
+        @id ||= label
+        build_definition(definition)
+      end
+
+      def build_string
+        out = StringIO.new
+        out.puts heading
+        out.puts indent(@definition.build_string)
+        out.string
+      end
+
+      protected
+
+      def build_definition(content)
+        @definition = content || Definition.new
+      end
+
+      private
+
+      def heading
+        label = "#{@label}:"
+        label = HighLine.color(label, :bold) if @richtext
+        label
+      end
+    end
+  end
+end

data/lib/hammer_cli/help/definition/text.rb

@@ -0,0 +1,21 @@
+module HammerCLI
+  module Help
+    class Text < AbstractItem
+      def initialize(text = nil, options = {})
+        super(options)
+        build_definition(text)
+      end
+
+      def build_string
+        @text
+      end
+
+      protected
+
+      def build_definition(content)
+        @text = content || ''
+        @definition = Definition.new([self])
+      end
+    end
+  end
+end

data/lib/hammer_cli/help/text_builder.rb

@@ -1,78 +1,55 @@
+require 'hammer_cli/help/definition'
+
 module HammerCLI
   module Help
     class TextBuilder
-      INDENT_STEP = 2
-      LIST_INDENT = 20
+      attr_accessor :definition
 
       def initialize(richtext = false)
-        @out = StringIO.new
         @richtext = richtext
+        @definition = HammerCLI::Help::Definition.new
       end
 
       def string
-        @out.string
+        @definition.build_string
       end
 
-      def text(content)
-        puts unless first_print?
-        puts content
+      def text(content, options = {})
+        @definition << HammerCLI::Help::Text.new(content, options)
       end
 
-      def list(items)
+      def list(items, options = {})
         return if items.empty?
-
-        items = normalize_list(items)
-        max_len = items.map { |i| i[0].to_s.length }.max
-        indent_size = (max_len + INDENT_STEP > LIST_INDENT) ? (max_len + INDENT_STEP) : LIST_INDENT
-
-        puts unless first_print?
-        items.each do |col1, col2|
-          # handle multiple lines in the second column
-          col2 = indent(col2.to_s, ' ' * indent_size).lstrip
-
-          line = "%-#{indent_size}s%s" % [col1, col2]
-          line.strip!
-          puts line
-        end
+        @definition << HammerCLI::Help::List.new(items, options)
       end
 
-      def section(label, &block)
-        puts unless first_print?
-        heading(label)
-
+      def section(label, options = {}, &block)
         sub_builder = TextBuilder.new(@richtext)
         yield(sub_builder) if block_given?
-        puts indent(sub_builder.string)
-      end
-
-      def indent(content, indentation = nil)
-        indentation ||= " " * INDENT_STEP
-        content = content.split("\n") unless content.is_a? Array
-        content.map do |line|
-          (indentation + line).rstrip
-        end.join("\n")
+        options[:richtext] ||= @richtext
+        @definition << HammerCLI::Help::Section.new(label, sub_builder.definition, options)
       end
 
-      protected
-
-      def heading(label)
-        label = "#{label}:"
-        label = HighLine.color(label, :bold) if @richtext
-        puts label
+      def find_item(item_id)
+        @definition.find_item(item_id)
       end
 
-      def puts(*args)
-        @out.puts(*args)
+      def at(path = [])
+        item = path.empty? ? self : @definition.at(path)
+        sub_builder = TextBuilder.new(@richtext)
+        sub_builder.definition = item.definition
+        yield(sub_builder)
+        item.definition = sub_builder.definition
       end
 
-      def first_print?
-        @out.size == 0
+      def insert(mode, item_id)
+        sub_builder = TextBuilder.new(@richtext)
+        yield(sub_builder)
+        @definition.insert_definition(mode, item_id, sub_builder.definition)
       end
 
-      def normalize_list(items)
-        items.map do |i|
-          i.is_a?(Array) ? i : [i]
-        end
+      def indent(content, indentation = nil)
+        HammerCLI::Help::AbstractItem.indent(content, indentation)
       end
     end
   end

data/lib/hammer_cli/i18n.rb

@@ -146,4 +146,3 @@ include FastGettext::Translation
 
 domain = [HammerCLI::I18n::LocaleDomain.new, HammerCLI::I18n::SystemLocaleDomain.new].find { |d| d.available? }
 HammerCLI::I18n.add_domain(domain) if domain
-

data/lib/hammer_cli/options/option_collector.rb

@@ -1,17 +1,20 @@
 module HammerCLI
   module Options
     class OptionCollector
-      attr_accessor :option_sources
+      attr_accessor :option_processor
 
-      def initialize(recognised_options, option_sources)
+      def initialize(recognised_options, option_processor)
         @recognised_options = recognised_options
-        @option_sources = option_sources
+
+        if !option_processor.is_a?(HammerCLI::Options::ProcessorList)
+          @option_processor = HammerCLI::Options::ProcessorList.new(option_processor)
+        else
+          @option_processor = option_processor
+        end
       end
 
       def all_options_raw
-        @all_options_raw ||= @option_sources.inject({}) do |all_options, source|
-          source.get_options(@recognised_options, all_options)
-        end
+        @all_options_raw ||= @option_processor.process(@recognised_options, {})
       end
 
       def all_options
@@ -21,13 +24,13 @@ module HammerCLI
       def options
         @options ||= all_options.reject { |key, value| value.nil? && all_options_raw[key].nil? }
       end
-      
+
       private
-      
+
       def translate_nils(opts)
         Hash[ opts.map { |k,v| [k, translate_nil(v)] } ]
       end
-      
+
       def translate_nil(value)
         value == HammerCLI::NilValue ? nil : value
       end

data/lib/hammer_cli/options/option_processor.rb

@@ -0,0 +1,17 @@
+module HammerCLI
+  module Options
+    class OptionProcessor
+      def initialize(name: nil)
+        @name = name
+      end
+
+      def name
+        @name || self.class.name.split('::')[-1]
+      end
+
+      def process(defined_options, result)
+        result
+      end
+    end
+  end
+end

data/lib/hammer_cli/options/processor_list.rb

@@ -0,0 +1,37 @@
+module HammerCLI
+  module Options
+    class ProcessorList < Array
+      attr_reader :name
+
+      def initialize(sources = [], name: nil)
+        @name = name
+        self.push(*sources)
+      end
+
+      def insert_relative(mode, target_name, processor)
+        index = target_name.nil? ? nil : item_index(target_name)
+        HammerCLI.insert_relative(self, mode, index, processor)
+      end
+
+      def find_by_name(name)
+        self[item_index(name)]
+      end
+
+      def process(defined_options, result)
+        self.inject(result) do |all_options, processor|
+          processor.process(defined_options, all_options)
+        end
+      end
+
+      private
+
+      def item_index(target_name)
+        idx = find_index do |item|
+          item.respond_to?(:name) && (item.name == target_name)
+        end
+        raise ArgumentError, "Option processor '#{target_name}' not found" if idx.nil?
+        idx
+      end
+    end
+  end
+end

data/lib/hammer_cli/options/sources/base.rb

@@ -0,0 +1,17 @@
+require_relative '../option_processor'
+
+module HammerCLI
+  module Options
+    module Sources
+      class Base < HammerCLI::Options::OptionProcessor
+        def process(defined_options, result)
+          get_options(defined_options, result)
+        end
+
+        def get_options(defined_options, result)
+          result
+        end
+      end
+    end
+  end
+end