lhj-tools 0.1.1 → 0.1.5

data/lib/lhj/helper/local_config.rb

@@ -0,0 +1,40 @@
+require 'yaml'
+require 'lhj/helper/oss_config'
+
+module Lhj
+  class LocalConfig
+    def config_file
+      File.join(Lhj::Config.instance.home_dir, config_file_name)
+    end
+
+    def config_file_name
+      'localizable_config.yml'
+    end
+
+    def syn_config_file
+      Lhj::OSS::Helper.instance.down_load(config_file_name, config_file)
+    end
+
+    def load_config
+      syn_config_file unless File.exist?(config_file)
+      YAML.load_file(config_file)
+    end
+
+    def get_col_by_name(file_name, col_name = 'csv_key_col')
+      m = config
+      col = m[col_name]
+      fo = m['read_targets'].find{ |o| /#{o['csv_file']}/ =~ file_name }
+      col = fo[col_name] if fo
+      col
+    end
+
+    def config
+      @config ||= load_config
+    end
+
+    def self.instance
+      @instance ||= new
+    end
+
+  end
+end

data/lib/lhj/helper/oss_config.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+require 'yaml'
+require 'lhj/config'
+
+module Lhj
+  class OSSConfig
+    def self.config_file
+      file = 'oss_config.yml'
+      File.expand_path("#{Lhj::Config.instance.home_dir}/#{file}")
+    end
+
+    def self.config
+      @yaml ||= YAML.load_file(config_file)
+    end
+
+    def self.oss_endpoint
+      config['oss_endpoint']
+    end
+
+    def self.oss_access_key_id
+      config['oss_access_key_id']
+    end
+
+    def self.oss_access_key_secret
+      config['oss_access_key_secret']
+    end
+
+    def self.oss_bucket
+      config['oss_bucket']
+    end
+  end
+end

data/lib/lhj/helper/oss_helper.rb

@@ -0,0 +1,43 @@
+require 'aliyun/oss'
+require 'lhj/helper/oss_config'
+
+module Lhj
+  class OSS
+    class Helper
+      def initialize
+        @client = Aliyun::OSS::Client.new(endpoint: Lhj::OSSConfig.oss_endpoint,
+                                          access_key_id: Lhj::OSSConfig.oss_access_key_id,
+                                          access_key_secret: Lhj::OSSConfig.oss_access_key_secret)
+        @bucket = @client.get_bucket(Lhj::OSSConfig.oss_bucket)
+      end
+
+      def url_path
+        "http://#{Lhj::OSSConfig.oss_bucket}.#{Lhj::OSSConfig.oss_endpoint}"
+      end
+
+      def upload(key, file)
+        @bucket.put_object(key, :file => file)
+      end
+
+      def down_load(key, file, &block)
+        @bucket.get_object(key, :file => file, &block)
+      end
+
+      def object_url(key)
+        @bucket.object_url(key, false)
+      end
+
+      def list
+        @bucket.list_objects
+      end
+
+      def delete(key)
+        @bucket.delete_object(key)
+      end
+
+      def self.instance
+        @instance ||= new
+      end
+    end
+  end
+end

data/lib/lhj/helper/trans_helper.rb

@@ -0,0 +1,49 @@
+require 'lhj/config'
+
+module Lhj
+  class Trans
+    class Helper
+      def self.instance
+        @instance ||= new
+      end
+
+      def yaml_file
+        File.join(Lhj::Config.instance.home_dir, 'zh2hant.yml')
+      end
+
+      def load_trans_map
+        require 'yaml'
+        down_load_yaml unless File.exist?(yaml_file)
+        contents = YAML.safe_load(File.open(yaml_file))
+        contents.to_hash
+      end
+
+      def down_load_yaml
+        require 'open-uri'
+        URI.open('http://aomi-ios-repo.oss-cn-shenzhen.aliyuncs.com/zh2hant.yml') do |i|
+          File.open(yaml_file, 'w+') do |f|
+            f.write(i.read)
+          end
+        end
+      end
+
+      def trans_zh_cn_str(input)
+        @trans_map_invert ||= load_trans_map.invert
+        out = []
+        input.each_char do |c|
+          out << (@trans_map_invert[c] || c)
+        end
+        out.join('')
+      end
+
+      def trans_zh_hk_str(input)
+        @trans_map ||= load_trans_map
+        out = []
+        input.each_char do |c|
+          out << (@trans_map[c] || c)
+        end
+        out.join('')
+      end
+    end
+  end
+end

data/lib/lhj/tools/version.rb

@@ -2,6 +2,6 @@
 
 module Lhj
   module Tools
-    VERSION = "0.1.1"
+    VERSION = "0.1.5"
   end
 end

data/lib/lhj/tools.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-
 require_relative "tools/version"
 
 module Lhj

data/lib/lhj/tree/directory_renderer.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Lhj
+  class Tree
+    # Render nodes as files paths explorer
+    class DirectoryRenderer
+      MARKERS = {
+        unicode: {
+          branch: '├──',
+          leaf: '└──',
+          pipe: '│'
+        },
+        ansi: {
+          branch: '|--',
+          leaf: '`--',
+          pipe: '|'
+        }
+      }.freeze
+
+      def initialize(nodes, options = {})
+        @nodes  = nodes
+        @indent = options.fetch(:indent, 4)
+        @pipe_mark  = MARKERS[:unicode][:pipe] + ' ' * [@indent - 1, 0].max
+        @space_mark = ' ' * @indent
+      end
+
+      def render
+        @nodes.reduce([]) do |acc, node|
+          render_node(acc, node, @pipe_mark, @space_mark)
+        end.join('')
+      end
+
+      private
+
+      def render_node(acc, node, pipe_mark, space_mark)
+        acc << node.prefix.gsub(/:pipe/, pipe_mark).gsub(/:space/, space_mark)
+        unless node.root?
+          acc << MARKERS[:unicode][node.leaf? ? :leaf : :branch]
+          acc << ' '
+        end
+        acc << node.name.to_s + "\n"
+      end
+    end
+  end
+end

data/lib/lhj/tree/hash_walker.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+require 'lhj/tree/node'
+
+module Lhj
+  class Tree
+    # Walk and collect nodes from hash data strcture.
+    #
+    # @api public
+    class HashWalker
+      attr_reader :nodes
+
+      attr_reader :files_count
+
+      attr_reader :dirs_count
+
+      def initialize(options = {})
+        @nodes       = []
+        @files_count = 0
+        @dirs_count  = 0
+        @level       = options.fetch(:level) { -1 }
+        @file_limit  = options.fetch(:file_limit) { - 1 }
+      end
+
+      def traverse(data)
+        walk(data, Pathname.new(''), '', 0, false)
+      end
+
+      def walk(data, parent_path, prefix, level, is_last)
+        node = is_last ? LeafNode : Node
+
+        case data
+        when Hash
+          return if @level != -1 && level + 1 > @level
+
+          data.each do |dir, item|
+            dir_node = node.new(dir.to_s, parent_path, prefix, level)
+            @nodes << dir_node
+            @dirs_count += 1 unless dir_node.root?
+
+            if level > 0
+              postfix = ':pipe'
+              postfix = ':space' if is_last
+            else
+              postfix = ''
+            end
+
+            walk(item, parent_path + dir.to_s,
+                 prefix + postfix, level + 1, false)
+          end
+        when Array
+          return if @file_limit != -1 && data.size > @file_limit
+
+          last_data_index = data.size - 1
+
+          data.each_with_index do |item, i|
+            last = (last_data_index == i)
+
+            walk(item, parent_path, prefix, level, last)
+          end
+        else
+          @nodes << node.new(data.to_s, parent_path, prefix, level)
+          @files_count += 1
+        end
+      end
+    end
+  end
+end

data/lib/lhj/tree/node.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+require 'pathname'
+
+module Lhj
+  class Tree
+    # A representation of tree node
+    #
+    # @api private
+    class Node
+      extend Forwardable
+
+      # The base name for the directory or file
+      attr_reader :name
+
+      # The parent directory path
+      attr_reader :parent
+
+      # The require path prefix
+      attr_reader :prefix
+
+      # The directory depth
+      attr_reader :level
+
+      # The file stat
+      attr_reader :stat
+
+      # The current path
+      attr_reader :path
+
+      def_delegators :@path, :directory?, :executable?, :file?,
+                     :symlink?, :socket?, :pipe?
+
+      def initialize(path, parent, prefix, level)
+        if path.is_a? String
+          # strip null bytes from the string to avoid throwing errors
+          path = path.delete("\0")
+        end
+
+        @path = Pathname.new(path)
+        @name   = @path.basename
+        @parent = Pathname.new(parent)
+        @prefix = prefix
+        @level  = level
+      end
+
+      def full_path
+        return parent if name.to_s.empty?
+
+        parent.join(name)
+      end
+
+      def root?
+        parent.to_s.empty?
+      end
+
+      def hidden?
+        name.to_s.start_with?('.')
+      end
+
+      def leaf?
+        false
+      end
+
+      def to_s
+        @name
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && other.state_attrs == state_attrs
+      end
+      alias eql? ==
+
+      protected
+
+      def state_attrs
+        [@name, @path, @parent, @prefix, @level]
+      end
+
+      ROOT = Node.new('', Pathname.new(''), '', 0).freeze
+    end # Node
+
+    class LeafNode < Node
+      def leaf?
+        true
+      end
+    end
+  end
+end

data/lib/lhj/tree/number_renderer.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Lhj
+  class Tree
+    # Render nodes as numbered list
+    class NumberRenderer
+      def initialize(nodes, options = {})
+        @indent = options.fetch(:indent, 4)
+        @nodes = nodes
+        @mark = ' ' * @indent
+      end
+
+      def render
+        @nodes.each_with_index.reduce([]) do |acc, (node, i)|
+          render_node(acc, node, i, @mark)
+        end.join
+      end
+
+      private
+
+      def render_node(acc, node, i, mark)
+        acc << node.prefix.gsub(/:pipe|:space/, mark)
+        unless node.root?
+          acc << "#{node.level}.#{i} "
+        end
+        acc << node.name.to_s + "\n"
+      end
+    end
+  end
+end

data/lib/lhj/tree/path_walker.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+require 'lhj/tree/node'
+
+module Lhj
+  class Tree
+    # Walk and collect nodes from directory.
+    #
+    # @api public
+    class PathWalker
+      attr_reader :nodes
+
+      attr_reader :files_count
+
+      attr_reader :dirs_count
+
+      # Create a PathWalker
+      #
+      # @api public
+      def initialize(options = {})
+        @files_count = 0
+        @dirs_count  = 0
+        @nodes       = []
+        @filters     = []
+        @level       = options.fetch(:level) { -1 }
+        @file_limit  = options.fetch(:file_limit) { - 1 }
+
+        unless options[:show_hidden]
+          add_filter(-> (p) { !p.basename.to_s.start_with?('.') })
+        end
+
+        if options[:only_dirs]
+          add_filter(-> (p) { p.directory? })
+        end
+      end
+
+      def add_filter(filter)
+        @filters << filter
+      end
+
+      # Traverse given path recursively
+      #
+      # @param [String] path
+      #   the path to traverse
+      #
+      # @api public
+      def traverse(path)
+        root_path  = Pathname.new(path)
+        empty_path = Pathname.new('')
+
+        unless root_path.directory?
+          raise ArgumentError, "#{root_path} is not a directory path"
+        end
+
+        @nodes << Node.new(root_path, empty_path, '', 0)
+
+        walk(root_path, root_path.children, '', 1)
+      end
+
+      private
+
+      # Filter entries
+      #
+      # @api private
+      def filter_entries(entries, filters)
+        return entries if filters.nil? || filters.empty?
+        filter = filters[0]
+        filter_entries(entries.select(&filter), filters[1..-1])
+      end
+
+      # Walk paths recursively
+      #
+      # @api private
+      def walk(parent_path, entries, prefix, level)
+        if entries.empty? || (@level != -1 && @level < level)
+          return
+        else
+          return if @file_limit != -1 && entries.size > @file_limit
+          processed_paths = filter_entries(entries, @filters).sort
+          last_path_index = processed_paths.size - 1
+
+          processed_paths.each_with_index do |path, i|
+            sub_path = path.relative_path_from(parent_path)
+
+            node = last_path_index == i ? LeafNode : Node
+
+            if path.directory?
+              next if @level != -1 && level + 1 > @level
+
+              @nodes << node.new(sub_path, parent_path, prefix, level)
+              @dirs_count += 1
+
+              postfix = ':pipe'
+              postfix = ':space' if i == last_path_index
+
+              walk(path, path.children, prefix + postfix, level + 1)
+            elsif path.file?
+              @nodes << node.new(path, parent_path, prefix, level)
+              @files_count += 1
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lhj/tree/tree.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'lhj/tree/node'
+require 'lhj/tree/directory_renderer'
+require 'lhj/tree/number_renderer'
+require 'lhj/tree/hash_walker'
+require 'lhj/tree/path_walker'
+
+module Lhj
+  class Tree
+    # @api public
+    def self.[](data)
+      new(data)
+    end
+
+    # The list of nodes in this tree.
+    attr_reader :nodes
+
+    # Create a Tree
+    #
+    # @param [String,Dir,Hash] data
+    #
+    # @api public
+    def initialize(data = nil, options = {}, &block)
+      @data   = data ? data.dup.freeze : nil
+      @walker = select_walker.new(options)
+      @nodes  = []
+
+      if @data
+        @walker.traverse(data)
+        @nodes = @walker.nodes
+      end
+
+      @nodes_stack = []
+
+      instance_eval(&block) if block_given?
+
+      freeze
+    end
+
+    # Add node to this tree.
+    #
+    # @param [Symbol,String] name
+    #   the name for the node
+    #
+    # @param [Node, LeafNode] type
+    #   the type of node to add
+    #
+    # @example
+    #   TTY::Tree.new do
+    #     node '...' do
+    #       node '...'
+    #     end
+    #   end
+    #
+    # @api public
+    def node(name, type = Node, &block)
+      parent = @nodes_stack.empty? ? Node::ROOT : @nodes_stack.last
+      level = [0, @nodes_stack.size - 1].max
+      prefix = ':pipe' * level
+      if parent.class == LeafNode
+        prefix = ':space' * level
+      end
+      node = type.new(name, parent.full_path, prefix, @nodes_stack.size)
+      @nodes << node
+
+      return unless block_given?
+
+      @nodes_stack << node
+      if block.arity.zero?
+        instance_eval(&block)
+      else
+        instance_eval(&(->(*_args) { block[node] }))
+      end
+      @nodes_stack.pop
+    end
+
+    # Add leaf node
+    #
+    # @api public
+    def leaf(name, &block)
+      node(name, LeafNode, &block)
+    end
+
+    # @api public
+    def render(options = {})
+      as = options.delete(:as) || :dir
+      renderer = select_renderer(as).new(nodes, options)
+      renderer.render
+    end
+
+    private
+
+    # @api private
+    def select_walker
+      if @data.is_a?(Hash) || @data.nil?
+        HashWalker
+      else
+        @data ||= Dir.pwd
+        PathWalker
+      end
+    end
+
+    def select_renderer(as)
+      case as
+      when :dir, :directory then DirectoryRenderer
+      when :num, :number then NumberRenderer
+      end
+    end
+  end
+end
+