treely 1.0.6 → 1.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ada2893182b188a97d04a1844edbb4dab5265be041acc9cebbc6fa1c27a94d9
-  data.tar.gz: e7eda4c56eb35c0e23089f52ccf3005abfb57b2c67b1597a97c4390a232b1e57
+  metadata.gz: 653fb44ea3510d808f5682762303cdaae5ff8c72ce45e6039a7967b9a3710abc
+  data.tar.gz: cd439a0dfdef8d5945f1108fa859c0a2219d362fbe8cef2dd9daace3df549b2d
 SHA512:
-  metadata.gz: f54267ed8875380568156048cff035f281c5b635a9f9bfd64dfc783b621dfee1c3c9a5fe5e8973910cb94863447ae80466fad78b7a439608b7d28033495eccf5
-  data.tar.gz: 611dec22b0e4cd79db1987658dc59ec4131e2a1ef0fc57fedf71befd5d3d5b5b1c665ad204428e5f428d5e4f415b1cbe246e88721790cbf1264b8e0163f2f937
+  metadata.gz: ba25e2181283352c1b5f8072446cfe46b4248a0d015583dd101aeaa273f5242dd07de4541837df1b61690ad2bf9a91ac28325887d7fe2381d5e53e272cac7d17
+  data.tar.gz: 5ee904b64314c1c3d976cb5d05d8675e799487977fbac1513393738d223e880d758c02a17c526115c395c54e8422d5ed38389e036d8be48a854976b048bbe13b

data/bin/treely

@@ -1,38 +1,48 @@
 #!/usr/bin/env ruby
-
-require 'json'
-require 'pathname'
-
+require 'optparse'
+require 'ostruct'
 require 'treely'
 require 'treely/directory'
 
-require 'active_support/core_ext/object/blank'
-require 'active_support/core_ext/string/inflections'
-require 'mercenary'
+options = OpenStruct.new(
+  :dirs_first  => false,
+  :files_first => false,
+  :only_dirs   => false,
+  :show_hidden => false,
+  :no_report   => false,
+  :ignore_p    => [],
+  :level       => -1
+)
 
-Mercenary.program(:treely) do |program|
-  program.version Treely::VERSION
-  program.syntax 'treely .'
+parser = OptionParser.new do |op|
+  op.banner = 'Usage: treely [options] [PATH]'
+  op.on('-d', '--only-dirs', 'List only directories')           { options.only_dirs   = true }
+  op.on('-A', '--show-hidden', 'List hidden (dot) entries')     { options.show_hidden = true }
+  op.on('-D', '--dirs-first', 'Sort directories before files')  { options.dirs_first  = true }
+  op.on('-F', '--files-first', 'Sort files before directories') { options.files_first = true }
+  op.on('-I', '--ignore PATTERN', 'Exclude entries matching PATTERN') { options.ignore_p << Regexp.new(_1) }
+  op.on('-L', '--level N', Integer, 'Descend at most N levels')       { options.level = _1 }
+  op.on('-s', '--style NAME', 'Style: built-in UNICODE') do
+    Treely.configuration.style = _1.downcase.to_sym
+  end
 
-  program.action do |args, options|
-    contents = if args[0].present?
-      Treely::Directory.new(args[0]).contents
-    else
-      JSON.parse(ARGF.read, symbolize_names: true)
-    end
+  op.on('-h', '--help', 'Show this help message') do
+    puts op
+    exit
+  end
+end
+
+begin
+  parser.parse!
 
-    if contents.any? { |item| item.has_key?(:files) }
-      puts Treely.tree(contents[0..-2])
-      puts %{}
-      puts "%s %s, %s %s" % [
-        contents[-1].fetch(:directories),
-        %{directories}.pluralize(contents[-1][:directories]),
-        contents[-1].fetch(:files),
-        %{files}.pluralize(contents[-1][:files])
-      ]
-    else
-      puts Treely.tree(contents)
-      puts %{}
-    end
+  if options.dirs_first
+    options.files_first = false
   end
+
+  Treely.dir(ARGV.shift, options).to_tree
+    .tap { |tree| tree.render.each { puts _1 } }
+    .tap { |tree| tree.walk_dir.summary }
+rescue OptionParser::ParseError => err
+  $stderr.puts "Error: #{err.message}"
+  exit 1
 end

data/lib/treely/configuration.rb

@@ -1,21 +1,11 @@
 module Treely
   class Configuration
-    attr_reader :style
+    attr_accessor :style
+    attr_accessor :filter
+    attr_accessor :formatter
 
     def initialize
-      @style = {
-        :dot         => %{\x2e},
-        :space       => %{\x20},
-        :new_line    => %{\x0a},
-        :bar         => %{│   },
-        :indent      => %{    },
-        :branch      => %{├── },
-        :last_branch => %{└── }
-      }
-    end
-
-    def transform_style!(&block)
-      @style.transform_values!(&block)
+      @style = :unicode
     end
   end
 
@@ -23,10 +13,6 @@ module Treely
     @configuration ||= Configuration.new
   end
 
-  def self.configuration=(config)
-    @configuration = config
-  end
-
   def self.configure
     yield configuration
   end

data/lib/treely/directory.rb

@@ -1,39 +1,120 @@
 module Treely
   class Directory
-    def initialize(path)
-      @pathname = Pathname(path)
-      @directories, @files = [], []
-      @ignore_pattern = /\A\.(\.?|\w+)\z/
+    extend Forwardable
 
-      unless @pathname.directory?
-        @contents = []
+    attr_reader :root
+    attr_reader :dirs_count
+    attr_reader :files_count
+
+    def initialize(root, options = {})
+      @root = root || Dir.pwd
+      @dirs_first  = options[:dirs_first]
+      @files_first = options[:files_first]
+      @only_dirs   = options[:only_dirs]
+      @show_hidden = options[:show_hidden]
+      @no_report   = options[:no_report]
+      @ignore_p    = options[:ignore_p]
+      @dirs_count  = 0
+      @files_count = 0
+      @file_limit  = -1
+      @filters     = []
+      @level       = options[:level].to_i
+
+      add_filter(-> { directory?(_1) }) if     @only_dirs
+      add_filter(-> { !hidden?(_1)   }) unless @show_hidden
+
+      Array(@ignore_p).each do |re|
+        add_filter(-> (p) { !p.match?(re) })
       end
     end
 
-    def contents
-      @contents ||= digger.call(@pathname)
-      [*@contents, { directories: @directories.size, files: @files.size }]
+    def to_tree
+      tree = Treely.dir_tree
+      tree.walk_dir = self
+      tree
     end
 
-    private
+    def walk(root, level = 0, maybe_last = true)
+      Enumerator.new do |emit|
+        emit << [basename(root), level, maybe_last]
+
+        if directory?(root) && descend?(level)
+          paths = Dir.children(root)
+            .sort.map { join(root, _1) }
+            .select { |p| @filters.all? { |f| f.call(p) } }
+
+          if @dirs_first or @files_first
+            paths.sort_by! {
+              is_dir = directory?(_1)
+              @dirs_first ? [is_dir ? 0 : 1, _1] : [is_dir ? 1 : 0, _1]
+            }
+          end
+
+          unless @no_report
+            dirs, files = paths.partition { directory?(_1) }
+            @dirs_count += dirs.size
+            @files_count += files.size
+          end
 
-    def digger
-      lambda do |pathname|
-        pathname.children.reject { |n| @ignore_pattern.match?(n.basename.to_s) }.map do |pathname|
-          if pathname.directory?
-            @directories << pathname
-            { name: pathname.basename.to_s, contents: digger.call(pathname) }
-          else
-            @files << pathname
-            { name: pathname.basename.to_s }
+          paths.each_with_index do |path, i|
+            walk(path, level + 1, i.next == paths.length)
+              .each { |t| emit << t }
           end
-        end.sort_by do |item|
-          [
-            item[:contents].class.to_s,
-            item[:name]
-          ]
         end
       end
     end
+
+    def summary
+      return if @no_report
+      puts "\n%s %s, %s %s" % [
+        @dirs_count,  @dirs_count  == 1 ? 'directory' : 'directories',
+        @files_count, @files_count == 1 ? 'file'      : 'files'
+      ]
+    end
+
+    private
+
+    def_delegator :File, :directory?
+    def_delegator :File, :basename
+    def_delegator :File, :join
+
+    def add_filter(filter)
+      @filters << filter
+    end
+
+    def descend?(level)
+      @level <= 0 || level < @level
+    end
+
+    def hidden?(path)
+      basename(path).start_with?('.')
+    end
+
+    module Source
+      def self.included(base)
+        base.attr_reader :walk_dir
+      end
+
+      def walk_dir=(dir)
+        @walk_dir = dir
+        @buffer = Tree::Buffer.new(source)
+      end
+
+      def source
+        @source ||= @walk_dir.walk(root)
+      end
+
+      def root
+        @root ||= @walk_dir.root
+      end
+    end
+  end
+
+  if defined?(Tree)
+    Tree.include(Directory::Source)
+  end
+
+  def self.dir(*args)
+    Directory.new(*args)
   end
 end

data/lib/treely/tree/buffer.rb

@@ -0,0 +1,22 @@
+module Treely
+  class Tree
+    class Buffer
+      def initialize(source)
+        @iterator = source.each
+        @buffer   = []
+      end
+
+      def [](i)
+        while @buffer.size <= i
+          begin
+            @buffer << @iterator.next
+          rescue StopIteration
+            break
+          end
+        end
+
+        @buffer[i]
+      end
+    end
+  end
+end

data/lib/treely/tree/style.rb

@@ -0,0 +1,40 @@
+module Treely
+  class Tree
+    module Style
+      UNICODE = {
+        :indent      => '    ',
+        :bar         => '│   ',
+        :branch      => '├── ',
+        :last_branch => '└── '
+      }
+
+      UNICODE_ROUNDED = {
+        :indent      => '    ',
+        :bar         => '│   ',
+        :branch      => '├── ',
+        :last_branch => '╰── '
+      }
+
+      UNICODE_TRIANGLE = {
+        :indent      => '  ',
+        :bar         => '┆ ',
+        :branch      => '▸ ',
+        :last_branch => '▸ '
+      }
+
+      STYLES = {
+        :unicode          => UNICODE,
+        :unicode_rounded  => UNICODE_ROUNDED,
+        :unicode_triangle => UNICODE_TRIANGLE
+      }
+
+      def self.get_or_default(style)
+        STYLES[style] or UNICODE
+      end
+
+      def self.get(style)
+        STYLES[style]
+      end
+    end
+  end
+end

data/lib/treely/tree.rb

@@ -1,31 +1,127 @@
+require 'treely/tree/buffer'
+require 'treely/tree/style'
+
 module Treely
   class Tree
-    def initialize(source)
-      @style = Treely[:style]
-      @contents = %{}
-      treely source
+    attr_reader :style
+    attr_reader :filter
+    attr_reader :formatter
+
+    def initialize(elems = [], config: Configuration.new)
+      @style = Style.get_or_default(config.style)
+      @buffer = Buffer.new(walk(elems))
+
+      @formatter = -> { _1.to_s }
+      @filter    = -> { _1 }
+
+      @formatter = config.formatter if config.formatter.is_a?(Proc)
+      @filter    = config.filter    if config.filter.is_a?(Proc)
     end
 
-    def to_s
-      @contents
+    def render
+      depth = 0
+      i = 0
+
+      Enumerator.new do |emit|
+        was_last = false
+        indents  = []
+
+        loop do
+          current = @buffer[i]
+          break if current.nil?
+
+          elem, cur_depth, maybe_last = current
+          last_branch = if maybe_last
+            has_sibling = false
+            j = i + 1
+
+            loop do
+              t = @buffer[j]
+              break if t.nil?
+              break if t[1] < cur_depth
+
+              if t[1] == cur_depth
+                has_sibling = true
+                break
+              end
+
+              j += 1
+            end
+
+            !has_sibling
+          else
+            false
+          end
+
+          if cur_depth > depth
+            if was_last
+              indents << @style[:indent]
+            else
+              indents << @style[:bar]
+            end
+          elsif cur_depth < depth
+            indents = indents.take(cur_depth)
+          end
+
+          emit << render_str(elem, indents.join, last_branch)
+          was_last = last_branch
+          depth = cur_depth
+          i += 1
+        end
+      end
+    end
+
+    def render_str(elem, indent, last_branch, fn = @formatter)
+      lines = fn.call(elem).lines(chomp: true)
+      lines = [''] if lines.empty?
+
+      branch = last_branch ? @style[:last_branch] : @style[:branch]
+      bar    = last_branch ? @style[:indent]      : @style[:bar]
+
+      lines.map.with_index do |line, i|
+        indent + (i.zero? ? branch : bar) + line
+      end.join("\n")
     end
 
     private
 
-    def treely(source, *args)
-      source.each.with_index do |item, index|
-        @contents << args.map { |name| @style[name] }.join
-        @contents << @style[index.zero? ? :dot : :bar]
-        @contents << @style[:new_line]
-        @contents << args.map { |name| @style[name] }.join
-        @contents << @style[source[index.next] ? :branch : :last_branch]
-        @contents << item.fetch(:name)
-        @contents << @style[:new_line]
-
-        if item.has_key?(:contents)
-          treely item[:contents], *args, (source[index.next] ? :bar : :indent)
+    def walk(elems, level = 0, maybe_last = true)
+      last_leaf, end_marks = level_hints(elems)
+
+      Enumerator.new do |emit|
+        elems.each_with_index do |elem, i|
+          if container?(elem)
+            walk(elem, level + 1, end_marks.include?(i))
+              .each { |t| emit << t }
+          else
+            emit << [
+              elem,
+              level,
+              maybe_last && last_leaf == i
+            ]
+          end
+        end
+      end
+    end
+
+    def level_hints(elems)
+      end_leaf = elems.rindex { !container?(_1) } || -1
+      end_marks = Set.new
+
+      elems.each_with_index do |elem, i|
+        cur_is_cont = container?(elem)
+        next_is_cont = container?(elems[i + 1])
+
+        if cur_is_cont && !next_is_cont
+          end_marks << i
         end
       end
+
+      [end_leaf, end_marks]
+    end
+
+    def container?(elem)
+      elem.is_a?(Array)
     end
   end
 end

data/lib/treely/version.rb

@@ -0,0 +1,3 @@
+module Treely
+  VERSION = '1.0.8'
+end

data/lib/treely.rb

@@ -1,16 +1,15 @@
+require 'forwardable'
+require 'set'
 require 'treely/configuration'
 require 'treely/tree'
+require 'treely/version'
 
 module Treely
-  module_function
-
-  def tree(source)
-    Tree.new(source)
+  def self.dir_tree
+    Tree.new(config: configuration)
   end
 
-  def [](name)
-    configuration.send(name)
+  def self.tree(elems)
+    Tree.new(elems).render.to_a.join("\n")
   end
-
-  self.const_set 'version'.upcase, '1.0.6'
 end

metadata

@@ -1,59 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: treely
 version: !ruby/object:Gem::Version
-  version: 1.0.6
+  version: 1.0.8
 platform: ruby
 authors:
-- matark
+- oneureka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-05-22 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: minitest
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.11'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.11'
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.2'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '5.2'
-- !ruby/object:Gem::Dependency
-  name: mercenary
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.3.6
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.3.6
+date: 2026-10-06 00:00:00.000000000 Z
+dependencies: []
 description: 
-email: matark@naver.com
+email: oneureka@github.io
 executables:
 - treely
 extensions: []
@@ -64,9 +22,12 @@ files:
 - lib/treely/configuration.rb
 - lib/treely/directory.rb
 - lib/treely/tree.rb
-homepage: https://opensource.matark.de/treely
+- lib/treely/tree/buffer.rb
+- lib/treely/tree/style.rb
+- lib/treely/version.rb
+homepage: https://dub.sh/treely
 licenses:
-- MIT
+- BSD-1-Clause
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -76,15 +37,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3.0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.5.22
 signing_key: 
 specification_version: 4
-summary: A Ruby library for generating tree-like format
+summary: A gem for generating tree-like formats
 test_files: []