fled 0.0.2 → 0.0.3

data/lib/dtc/utils/text/line_writer.rb

@@ -0,0 +1,70 @@
+module DTC
+  module Utils
+    module Text
+      # Helper class for writting lines of text,
+      # with some indentation processing.
+      #
+      # Blocks of text can be indented and/or
+      # captured.
+      #
+      # Output is written to an array in `lines`
+      # by `push_raw`. Other methods use `split_lines`
+      # and/or `indent_lines` to preprocess input.
+      #
+      # Get the result by 
+      class LineWriter
+        def lines ; @lines || [] end
+        def to_s sep = "\n"
+          lines.join(sep)
+        end
+        def begin_capture
+          (@lines_stack ||= []) << @lines
+          @lines = []
+          if block_given?
+            yield
+            end_capture
+          end
+        end
+        def end_capture
+          result = @lines
+          @lines = @lines_stack.pop
+          result
+        end
+        def push_raw *raw_lines
+          @lines = lines + raw_lines.flatten
+        end
+        def push_indent *indent, &blk
+          (@indents ||= []) << indent
+          if block_given?
+            yield
+            pop_indent
+          end
+        end
+        def pop_indent
+          @indents.pop
+        end
+        def current_indent
+          @indents && @indents.last
+        end
+        def push *lines
+          if (indent = current_indent)
+            push_raw(indent_lines(split_lines(*lines), indent))
+          else
+            push_raw *lines
+          end
+        end
+        alias_method :<<, :push
+        protected
+        def split_lines *lines
+          lines.flatten
+        end
+        def indent_lines lines, indent
+          lines = split_lines(lines)
+          lines.map { |line|
+            indent.join("") + line
+          }
+        end
+      end
+    end
+  end
+end

data/lib/dtc/utils/text.rb

@@ -0,0 +1,23 @@
+
+module DTC
+  module Utils
+    module Text
+      def self.lines str
+        str.split(/\r?\n/).to_a
+      end
+      # Remove common space-only indent to all non-empty lines
+      def self.lines_without_indent lines
+        lines = self.lines(lines) unless lines.is_a?(Array)
+        lines.shift if lines.first.empty?
+        min_spaces = lines.map { |l|
+          l == "" ? nil : (l =~ /^( +)/ ? $1.length : 0)
+        }.select{ |e| e }.min || 0
+        lines.map { |l| (min_spaces == 0 ? l : l[min_spaces..-1]) || "" }
+      end
+
+      autoload :HTML, 'dtc/utils/text/html'
+      autoload :LineWriter, 'dtc/utils/text/line_writer'
+    end
+  end
+end
+

data/lib/dtc/utils/visitor/dsl.rb

@@ -0,0 +1,98 @@
+module DTC
+  module Utils
+    module Visitor
+      # Utilities for visiting a DSL block
+      #
+      # Tolerates chained method calls and
+      # recursive blocks, as long as intermediary
+      # method calls have no arguments.
+      #
+      # eg: `some.calls.are.fine(true)`
+      #     `some(true).arent`
+      #
+      # Enters/leaves for methods called with a
+      # block. `Visitor#enter`s return is ignored.
+      module DSL
+        # Utility class to keep track of the
+        # running prefix as the DSL is visited
+        class RecursiveDSLDelegate
+          def initialize visitor, prefix = nil
+            @visitor = visitor
+            @prefix = prefix
+            @pending_prefix = nil
+            @called = false
+          end
+          def prefix sym
+            @called = true
+            flush
+            @pending_prefix = self.class.new(@visitor, with_prefix(sym))
+          end
+          def flush
+            if @pending_prefix
+              @pending_prefix.add_unless_called
+              @pending_prefix = nil
+            end
+          end
+          def add sym, *args
+            @called = true
+            @visitor.add(with_prefix(sym), *args)
+          end
+          def enter sym, *args
+            flush
+            @called = true
+            @visitor.enter(with_prefix(sym), *args)
+          end
+          def leave
+            flush
+            @visitor.leave
+          end
+          protected
+          def with_prefix sym
+            @prefix ? (sym ? "#{@prefix}.#{sym}".to_sym : @prefix) : sym
+          end
+          def add_unless_called
+            flush
+            @visitor.add(@prefix) unless @called
+          end
+        end
+        # Blank slate object providing the `self` context
+        # in which DSL blocks are evaluated
+        class RecursiveDSLContextBlank
+          extend DTC::Utils::Meta
+          blank_class :instance_exec, :class
+          def initialize delegate, unprefixed = delegate
+            @delegate = delegate
+            @unprefixed = unprefixed
+          end
+          def method_missing(meth, *args, &block)
+            if block
+              @delegate.enter meth, *args
+              self.class.new(@unprefixed, @unprefixed).instance_exec(&block)
+              @unprefixed.flush
+              @delegate.leave
+            else
+              if args.empty?
+                return self.class.new(@delegate.prefix(meth), @unprefixed)
+              else
+                @delegate.add(meth, *args)
+              end
+            end
+            self
+          end
+        end
+        # Visit the DSL provided in `blk` using `visitor`
+        #
+        # Context and delegate classes may be subclassed.
+        def self.accept visitor, context_klass = RecursiveDSLContextBlank,
+            delegate_klass = RecursiveDSLDelegate,
+            &blk
+          visitor = visitor.new() if visitor.is_a?(Class)
+          builder = delegate_klass.new(visitor)
+          context_klass.new(builder).instance_exec(&blk)
+          builder.flush
+          visitor
+        end
+      end
+    end
+  end
+end

data/lib/dtc/utils/visitor/folder.rb

@@ -0,0 +1,87 @@
+module DTC
+  module Utils
+    module Visitor
+      module Folder
+        # Forwards visits only when file/folder name
+        # match the suite of regexen.
+        class FilenameFilteringVisitor < DTC::Utils::Visitor::FilteringForwarder
+          # `options` may define:
+          #
+          # - `:excluded`
+          # - `:excluded_files`
+          # - `:excluded_directories`
+          # - `:included`
+          # - `:included_files`
+          # - `:included_directories`
+          #
+          # Each item is then included only if no includes are defined,
+          # or it matches one of the includes, and if no exclusions are
+          # defined, or it does not match one of the exclusions.
+          #
+          # Each key of `options` is an array of strings that will be
+          # compiled into case-insensitive regexen
+          def initialize listener, options = {}
+            super listener
+            @excluded = compile_regexp(options[:excluded])
+            @excluded_files = compile_regexp(options[:excluded_files])
+            @excluded_directories = compile_regexp(options[:excluded_directories])
+            @included = compile_regexp(options[:included])
+            @included_files = compile_regexp(options[:included_files])
+            @included_directories = compile_regexp(options[:included_directories])
+          end
+          protected
+          def compile_regexp(rx_list)
+            return nil if rx_list.nil? || rx_list.reject { |e| e.length == 0 }.empty?
+            Regexp.union(*rx_list.map { |e| /#{e}/i })
+          end
+          def include?(is_file, name, *args)
+            name = File.basename(name) unless is_file
+            can_include = (@included.nil? || @included.match(name)) &&
+              ((is_file && (@included_files.nil? || @included_files.match(name))) ||
+               (!is_file && (@included_directories.nil? || @included_directories.match(name))))
+            if can_include
+              can_include = (@excluded.nil? || !@excluded.match(name)) &&
+                ((is_file && (@excluded_files.nil? || !@excluded_files.match(name))) ||
+                 (!is_file && (@excluded_directories.nil? || !@excluded_directories.match(name))))
+            end
+            can_include
+          end
+        end
+        # Visit the path provided using `visitor`,
+        # (or a transparent FilenameFilteringVisitor if options
+        # include filtering)
+        #
+        # `options` may include a `:max_depth` key,
+        # or any keys used by `FilenameFilteringVisitor`
+        def self.accept visitor, path, options = {}
+          visitor = visitor.new() if visitor.is_a?(Class)
+          options = options.is_a?(Fixnum) ? ({:max_depth => options}) : options.dup
+          max_depth = options.delete(:max_depth) { -1 }
+          filter = options.empty? ? visitor :
+            FilenameFilteringVisitor.new(visitor, options)
+          accept_path filter, File.expand_path(path), max_depth
+          visitor
+        end
+        def self.accept_path visitor, path, max_depth = -1
+          dir = Dir.new(path)
+          return unless visitor.enter path
+          dir.each do |f|
+            full_path = File.join(path, f)
+            next if f == "." || f == ".."
+            if File.directory? full_path
+              return unless File.readable?(path)
+              if max_depth == 0
+                visitor.leave if visitor.enter(full_path)
+              else
+                self.accept_path(visitor, full_path, max_depth - 1)
+              end
+            else
+              visitor.add f, full_path
+            end
+          end
+          visitor.leave
+        end
+      end
+    end
+  end
+end

data/lib/dtc/utils/visitor.rb

@@ -0,0 +1,272 @@
+module DTC
+  module Utils
+    # Utilities for objects that repond to:
+    #
+    # - `enter(*arguments)`: return true to enter branch
+    # - `leave()`
+    # - `add(*arguments)
+    module Visitor
+      autoload :DSL, 'dtc/utils/visitor/dsl'
+      autoload :Folder, 'dtc/utils/visitor/folder'
+
+      # Forward visitor events to current
+      # value of `next_visitor`. Defaults
+      # to returning `true` for all `enter()`
+      class Forwarder
+        attr_accessor :next_visitor
+        def initialize next_visitor = nil
+          self.next_visitor = next_visitor if next_visitor
+        end
+        def enter *args
+          next_visitor ? next_visitor.enter(*args) : true
+        end
+        def add *args
+          next_visitor.add(*args) if next_visitor
+        end
+        def leave
+          next_visitor.leave if next_visitor
+        end
+      end
+
+      # Base class for visitors that redirect their calls
+      # to other visitors for sub-branches.
+      #
+      # Override `visitor_for_subtree` and return a new visitor
+      # to begin receiving calls *below* current symbol.
+      #
+      # When the branch is visited and after the new visitor
+      # is popped, `visitor_left_subtree` is called with original
+      # arguments as given to `enter`.
+      class Switcher < Forwarder
+        def initialize receiver
+          @visitor_full_stack = [receiver]
+          @visitor_stack = [[receiver]]
+          super receiver
+        end
+        def enter *args
+          sub_visitor = visitor_for_subtree(*args)
+          @visitor_full_stack.push(sub_visitor)
+          if sub_visitor
+            @visitor_stack.push([sub_visitor, *args])
+            self.next_visitor = sub_visitor
+          else
+            super
+          end
+        end
+        def leave
+          visitor = @visitor_full_stack.pop
+          if visitor
+            previous_visitor = @visitor_stack.pop
+            self.next_visitor = (@visitor_stack.last || []).first
+            visitor_left_subtree *previous_visitor
+          else
+            super
+          end
+        end
+        protected
+        def visitor_for_subtree *args
+          nil
+        end
+        def visitor_left_subtree visitor, *args
+        end
+      end
+
+      # Printing forwarding visitor
+      #
+      # The constructor accepts a block to replace the
+      # default printing mecanism.
+      class Printer < Forwarder
+        def initialize next_visitor = nil, &printer # :yields: depth, method, *args
+          @printer = printer || lambda { |depth, method, *args|
+            puts(
+              ("  " * depth) +
+              method.inspect +
+              (args.empty? ? "" : " " + args.inspect)
+            )
+          }
+          @depth = 0
+          super next_visitor
+        end
+        def enter *args
+          print :enter, *args
+          @depth += 1
+          super
+        end
+        def leave
+          @depth -= 1
+          super
+        end
+        def add *args
+          print :add, *args
+          super
+        end
+        protected
+        def print method, *args
+          @printer.call(@depth, method, *args)
+        end
+      end
+
+      # Base class for visitors that create a data
+      # structure based on calls.
+      #
+      # Obtain result of visit with `root`
+      #
+      # Default behaviour is to build an
+      # array based structure. Override `new_inner`
+      # to create and return new inner nodes,
+      # and `new_outer` to create and return outer
+      # nodes.
+      #
+      # Example:
+      #     DTC::Utils::Visitor::DSL::accept(DTC::Utils::Visitor::Builder) {
+      #       container(:arg1) { child_item(:arg2) }
+      #       root_child_item
+      #     }.root
+      #    
+      #     =>
+      #    
+      #     [[:inner, [:container, :arg1], [:outer, [:child_item, :arg2]]],
+      #      [:outer, [:root_child_item]]]
+      class Builder
+        def initialize root = []
+          @stack = [root]
+        end
+        def root
+          @stack.first
+        end
+        def enter *args
+          container = new_inner(*args)
+          @stack.push(container) if container
+          container
+        end
+        def leave
+          @stack.pop
+        end
+        def add *args
+          new_outer *args
+        end
+        protected
+        # Last value provided by `new_inner`, also
+        # known as "current parent"
+        def current_inner_node
+          @stack.last
+        end
+        def new_inner *args
+          container = [:inner, args]
+          current_inner_node << container
+          container
+        end
+        def new_outer *args
+          current_inner_node << [:outer, args]
+        end
+      end
+
+      # Adds a replay ability to the builder visitor.
+      class Recorder < Builder
+        # Replay all calls made on self to `visitor`
+        def accept visitor
+          visitor = visitor.new if visitor.is_a?(Class)
+          accept_inner visitor, root
+        end
+        protected
+        def accept_inner visitor, inner
+          inner.each do |node|
+            case node.first
+            when :outer
+              visitor.add *node.last
+            when :inner
+              if visitor.enter(*node[1])
+                accept_inner(visitor, node.drop(2))
+                visitor.leave
+              else
+                puts"NO"
+              end
+            else
+              raise RuntimeError, "Unknown node: #{node.inspect}"
+            end
+          end
+          visitor
+        end
+      end
+
+      # Subclasses the `Builder` to create
+      # hash based hierarchies, using the first
+      # argument as the key in the parent hash
+      #
+      # Does not tolerate duplicate keys by default.
+      # Override `key_collision` to change this.
+      #
+      # Example:
+      #
+      #     DTC::Utils::Visitor::DSL::accept(DTC::Utils::Visitor::HashBuilder) {
+      #       container(:arg1) { child_item(:arg2) }
+      #       root_child_item
+      #     }.root
+      #    
+      #     =>
+      #    
+      #     {:container=>{nil=>[:arg1], :child_item=>[:arg2]}, :root_child_item=>[]}
+      class HashBuilder < Builder
+        def initialize root = {}
+          super root
+        end
+        protected
+        def key_collision key, new_args, previous_args
+          raise RuntimeError, "Key #{key.inspect} already defined" if container[key]
+        end
+        def add_child key, value
+          container = current_inner_node
+          if (previous = container[key])
+            value = key_collision(key, value, previous)
+          end
+          container[key] = value
+          value
+        end
+        def new_inner key, *args
+          container = {}
+          container[nil] = args unless args.empty?
+          add_child key, container
+        end
+        def new_outer key, *args
+          add_child key, args
+          args
+        end
+      end
+
+      # Base class for forwarding visitors
+      # that forward events only for items
+      # on which a call to `include?(is_leaf, *args)`
+      # returns true.
+      #
+      # You can include, but not descend,
+      # a node by overriding `descend?(*args)` too.
+      class FilteringForwarder < Forwarder
+        def enter *args
+          return false unless include?(false, *args)
+          if (result = super) && !descend?(*args)
+            leave
+            return false
+          end
+          result
+        end
+        def add *args
+          return false unless include?(true, *args)
+          super
+        end
+        protected
+        def descend?(*args) ; true ; end
+        def include?(is_leaf, *args) ; true ; end
+      end
+
+      # Include this module in a class that
+      # responds to a flat tree visit, so only `add`
+      # methods, where the first argument is expected
+      # to be a symbol the class responds to
+      module AcceptAsFlatMethodCalls
+        def enter *args ; raise RuntimeError, "Blocks are not supported for #{self.class.name} (got on #{args.inspect})" ; end
+        def leave ; end
+        def add sym, *args ; self.__send__(sym, *args) ; end
+      end
+    end
+  end
+end

data/lib/dtc/utils.rb

@@ -2,8 +2,10 @@ module DTC
   module Utils
     autoload :Exec, 'dtc/utils/exec'
     autoload :InteractiveEditor, 'dtc/utils/interactive_edit'
+    autoload :Meta, 'dtc/utils/meta'
     autoload :MiniSelect, 'dtc/utils/mini_select'
-    autoload :DSLDSL, 'dtc/utils/dsldsl'
     autoload :FileVisitor, 'dtc/utils/file_visitor'
+    autoload :Text, 'dtc/utils/text'
+    autoload :Visitor, 'dtc/utils/visitor'
   end
 end