fled 0.0.2 → 0.0.3

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fled
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -19,13 +19,19 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/dtc/utils/dsldsl.rb
 - lib/dtc/utils/exec.rb
-- lib/dtc/utils/file_visitor.rb
 - lib/dtc/utils/interactive_edit.rb
+- lib/dtc/utils/meta.rb
 - lib/dtc/utils/mini_select.rb
+- lib/dtc/utils/text/html.rb
+- lib/dtc/utils/text/line_writer.rb
+- lib/dtc/utils/text.rb
+- lib/dtc/utils/visitor/dsl.rb
+- lib/dtc/utils/visitor/folder.rb
+- lib/dtc/utils/visitor.rb
 - lib/dtc/utils.rb
 - lib/fled/file_listing.rb
+- lib/fled/file_listing_builder.rb
 - lib/fled.rb
 - bin/fled
 - tests/helper.rb

data/lib/dtc/utils/dsldsl.rb

@@ -1,259 +0,0 @@
-module DTC
-  module Utils
-    module DSLDSL
-      class DSLVisitor
-        # very approximate visitor =)
-        def enter key, *args ;  end
-        def leave ; end
-        def add key, *args ; end
-        def visit_dsl &blk
-          builder = self.class.delegate_klass.new(self)
-          self.class.context_klass.new(builder).__instance_exec(&blk)
-          builder.flush
-        end
-        protected
-        def self.delegate_klass ; StaticTreeDSLDelegate ; end
-        def self.context_klass ; StaticTreeDSLContextBlank ; end
-      end
-
-      class DSLArrayWriter < DSLVisitor
-        attr_reader :stack
-        def initialize
-          @stack = [[]]
-        end
-        def enter sym, *args
-          @stack.push [[sym, *args]]
-        end
-        def leave
-          @stack.pop
-        end
-        def add sym, *args
-          @stack.last << [sym, *args]
-        end
-        def each &blk
-          return enum_for(:each) unless block_given?
-          each_call_of @stack.first, &blk
-        end
-        protected
-        def each_call_of parent, &block
-          parent.each do |item|
-            if item.first.is_a?(Symbol)
-              yield item
-            else
-              each_call_of item, &block
-            end
-          end
-        end
-      end
-
-      class DSLHashWriter < DSLVisitor
-        def initialize target
-          @stack = [target]
-        end
-        def enter key, *args
-          container = add_container(key, *args)
-          @stack.push(container) if container
-          container
-        end
-        def leave
-          @stack.pop
-        end
-        def add key, *args
-          add_key key, args
-        end
-        def self.write_static_tree_dsl target = {}, &blk
-          visitor = self.new(result = target)
-          visitor.visit_dsl(&blk)
-          result
-        end
-        def add_container key, *args
-          container = {}
-          container[:options] = args unless args.empty?
-          add_key key, container
-        end
-        def add_key key, val
-          container = @stack.last
-          key = key.to_s
-          raise RuntimeError, "Key #{key.inspect} already defined" if container[key]
-          container[key] = val
-          val
-        end
-      end
-
-      class StaticTreeDSLDelegate
-        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
-
-      class StaticTreeDSLContextBlank
-        alias_method :__instance_exec, :instance_exec
-        alias_method :__class, :class
-        instance_methods.each { |meth| undef_method(meth) unless meth =~ /\A__/ || meth == :object_id }
-        def initialize delegate, unprefixed = delegate
-          @delegate = delegate
-          @unprefixed = unprefixed
-        end
-        def method_missing(meth, *args, &block)
-          if block
-            @delegate.enter meth, *args
-            __class.new(@unprefixed, @unprefixed).__instance_exec(&block)
-            @unprefixed.flush
-            @delegate.leave
-          else
-            if args.empty?
-              return __class.new(@delegate.prefix(meth), @unprefixed)
-            else
-              @delegate.add(meth, *args)
-            end
-          end
-          self
-        end
-      end
-
-      if __FILE__ == $0
-
-        class DebugStaticTreeDSLDelegate < StaticTreeDSLDelegate
-          def prefix sym
-            p [:prefix, sym, @prefix]
-            super
-          end
-          def flush
-            p [:flush, @prefix] if @pending_prefix
-            super
-          end
-          def add sym, *args
-            p [:add, sym, @prefix]
-            super
-          end
-          def enter sym, *args
-            p [:enter, sym, @prefix]
-            super
-          end
-          def leave
-            p [:leave, @prefix]
-            super
-          end
-          def add_unless_called
-            p [:flush_self, @prefix] unless @called
-            super
-          end
-        end
-
-        class DebugDSLHashWriter < DSLHashWriter
-          def enter sym, *args
-            p [:wenter, sym]
-            super
-          end
-          def leave
-            p [:wleave]
-            super
-          end
-          def add sym, *args
-            p [:wadd, sym, args]
-            super
-          end
-          def self.delegate_klass ; DebugStaticTreeDSLDelegate ; end
-        end
-
-        module Examples
-          module Simple
-            result = DSLHashWriter.write_static_tree_dsl do
-              fichier "value"
-              fichier2.txt "one", "two"
-            end
-            result # => {"fichier"=>["value"], "fichier2.txt"=>["one", "two"]}
-
-            result = DSLHashWriter.write_static_tree_dsl do
-              dossier {
-                sous.dossier "valeur" do
-                  file.txt
-                end
-              }
-            end
-            result # => {"dossier"=>{"sous.dossier"=>{:options=>["valeur"], "file.txt"=>[]}}}
-
-            result = DSLHashWriter.write_static_tree_dsl do
-              %w[hdpi mdpi ldpi].each do |resolution|
-                image.__send__(resolution.to_sym).png
-              end
-            end
-            result # => {"image.ldpi.png"=>[], "image.hdpi.png"=>[], "image.mdpi.png"=>[]}
-
-            result = DSLHashWriter.write_static_tree_dsl do
-              user {
-                name :string
-                email :string
-                address(:json) {
-                  line :string
-                  country
-                }
-              }
-            end
-            result # => {"user"=>{"address"=>{"country"=>[], "line"=>[:string], :options=>[:json]}, "name"=>[:string], "email"=>[:string]}}
-
-            result = DSLHashWriter.write_static_tree_dsl do
-              def base_file
-                yes.this.is.base
-              end
-              base_file.txt
-              base_file.png
-            end
-            result # => {"yes.this.is.base.png"=>[], "yes.this.is.base.txt"=>[]}
-          end
-          module CustomBuilder
-            class EscapableStaticTreeDSLContextBlank < StaticTreeDSLContextBlank
-              def method_missing(meth, *args, &block)
-                meth = args.shift if meth == :raw
-                super(meth, *args, &block)
-              end
-            end
-            class EscapableDSLHashWriter < DSLHashWriter
-              def self.context_klass ; EscapableStaticTreeDSLContextBlank ; end
-            end
-            result = EscapableDSLHashWriter.write_static_tree_dsl do
-              3.times { |i| raw(i).png }
-              image.raw("%!") { file }
-            end
-            result # => {"0.png"=>[], "1.png"=>[], "image.%!"=>{"file"=>[]}, "2.png"=>[]}
-          end
-        end
-      end
-    end
-  end
-end

data/lib/dtc/utils/file_visitor.rb

@@ -1,79 +0,0 @@
-module DTC
-  module Utils
-    class FileVisitor
-      def depth ; @folders.nil? ? 0 : @folders.count ; end
-      def current_path *args ; File.join(@folders + args) ; end
-      attr_accessor :next_visitor
-      def enter_folder dir
-        return false unless next_visitor ? next_visitor.enter_folder(dir) : true
-        (@folders ||= []) << dir
-        true
-      end
-      def visit_file name, full_path
-        next_visitor.visit_file(name, full_path) if next_visitor
-      end
-      def leave_folder
-        next_visitor.leave_folder if next_visitor
-        @folders.pop
-      end
-      def self.browse path, visitor, max_depth = -1
-        return unless File.readable?(path)
-        dir = Dir.new(path)
-        return unless visitor.enter_folder path
-        dir.each do |f|
-          full_path = File.join(path, f)
-          next if f == "." || f == ".."
-          if File.directory? full_path
-            self.browse(full_path, visitor, max_depth - 1) unless max_depth == 0
-          else
-            visitor.visit_file f, full_path
-          end
-        end
-        visitor.leave_folder
-      end
-    end
-    class FilteringFileVisitor < FileVisitor
-      def initialize listener, options = {}
-        @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])
-        @recurse = options[:max_depth] || -1
-        self.next_visitor = listener
-      end
-      def enter_folder dir
-        return false unless include?(File.basename(dir), false)
-        if (result = super) && !descend?(dir)
-          leave_folder
-          return false
-        end
-        result
-      end
-      def visit_file name, full_path
-        return false unless include?(name, true)
-        super
-      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 descend?(name)
-        @recurse == -1 || @recurse >= (depth - 1)
-      end
-      def include?(name, 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
-  end
-end