jekyll-tally-tags 0.1.0

data/lib/jekyll-tally-tags/counter.rb

@@ -0,0 +1,260 @@
+module Jekyll
+  module TallyTags
+    class Counter
+
+      # 两处赋值
+      # @param [Document] doc
+      # @param [String] key
+      # @param [Object] value
+      def self.set_doc_data(doc, key, value)
+        doc.data[key]       = value
+        doc.data[DATA][key] = value
+      end
+
+      # 两处添加
+      # @param [Document] doc
+      # @param [String] key
+      # @param [Object] value
+      def self.add_doc_data(doc, key, value)
+        doc.data[key]       = [] if !doc.data[key]
+        doc.data[DATA][key] = [] if !doc.data[DATA][key]
+        doc.data[key] << value
+        doc.data[DATA][key] << value
+      end
+
+      # @param [Float] number
+      # @param [String] format
+      def self.to_f_s(number, format)
+        if number - number.round != 0
+          format % number.round(2).to_s
+        else
+          format % number.round.to_s
+        end
+      end
+
+      # @param [Array, Object]
+      # @return [Array]
+      def self.to_array(single_or_array, default)
+        if !single_or_array
+          return default
+        end
+        if single_or_array.is_a?(Array)
+          single_or_array
+        else
+          [single_or_array]
+        end
+      end
+
+      # @param [Array<Array<String>>] merge_list
+      # @param [Array<Document>] docs
+      # @param [String] find
+      # @param [String] to
+      def self.combine_merge_list(merge_list, docs, find, to)
+        merge_list.each do |merges|
+          docs.each do |doc|
+            (0..doc.data[find].size - 1).each do |index|
+              if merges.include?(doc.data[find][index])
+                self.add_doc_data(doc, to, merges) unless doc.data[to].include?(merges)
+              end
+            end
+          end
+        end
+      end
+
+      # @param [Array<String>] items 原始数据
+      # @param [Integer, Array<Integer>] deep_key 合并类型
+      # @return [Array<Array<String>>]
+      def self.merge_all(items, deep_key)
+        hash    = {}
+        is_deep = false
+        if items.size > 2
+          deep_key = ALL if !deep_key
+          # all 情况
+          if deep_key.is_a?(String)
+            if deep_key == ALL
+              is_deep = true
+              (2..items.size).each do |deep|
+                hash[deep] = self.merge(items, nil, nil, deep, 0, 0, 0)
+              end
+            end
+          end
+
+          # 单个
+          if deep_key.is_a?(Integer)
+            if deep_key != 0 && deep_key >= 2
+              is_deep        = true
+              hash[deep_key] = self.merge(items, nil, nil, deep_key, 0, 0, 0)
+            end
+          end
+
+          # 数组
+          if deep_key.is_a?(Array)
+            deep_key.each do |deep|
+              if deep != 0 && deep >= 2
+                is_deep    = true
+                hash[deep] = self.merge(items, nil, nil, deep, 0, 0, 0)
+              end
+            end
+          end
+
+          if !is_deep
+            Jekyll.logger.warn(COUNTER, "#{deep_key}类型未知")
+          end
+
+          all = []
+          hash.values.each do |values|
+            all += values
+          end
+          all
+        else
+          [items]
+        end
+      end
+
+      # @param [Array<String>] items 原始数据
+      # @param [Array<Array<String>>] deep_items 对应深度数据的保存数组
+      # @param [Array<String>] into_items 遍历时 当前深度 的 保存数组 会 添加到 对应深度数据的保存数组
+      # @param [Integer] deep 总深度
+      # @param [Integer] cur_deep 当前深度
+      # @param [Integer] s 起始下标
+      # @param [Integer] e 结束下标
+      # @return [Array<Array<String>>]
+      def self.merge(items, deep_items, into_items, deep, cur_deep, s, e)
+        if !deep_items
+          deep_items = []
+          into_items = []
+          cur_deep   = 0
+          s          = 0
+          e          = items.size - deep
+        end
+        (s..e).each do |i|
+          temp = Array.new(into_items) << items[i]
+          if cur_deep == deep - 1
+            deep_items << temp
+          else
+            deep_items += self.merge(items, [], temp, deep, cur_deep + 1, i + 1, e + 1)
+          end
+        end
+        deep_items
+      end
+
+      # @param [Integer] a
+      # @param [Integer] b
+      def self.sum(a, b)
+        a.to_f + b.to_f
+      end
+
+      # @param [Integer] a
+      # @param [Integer] b
+      def self.div(a, b)
+        a.to_f / b.to_f
+      end
+
+      # @param [Integer] a
+      # @param [Integer] b
+      def self.mul(a, b)
+        a.to_f * b.to_f
+      end
+
+      # @param [Integer] a
+      # @param [Integer] b
+      def self.sub(a, b)
+        a.to_f - b.to_f
+      end
+
+      # @example
+      #   ":sub_2和:2:3" => [":sub_2", "和", ":2", ":3"]
+      # @param [String]
+      # @return [Array<String>]
+      def self.partition_all(formatter)
+        result = []
+        temps  = formatter.partition(/:\w+/)
+        (0..temps.size - 1).each do |index|
+          temp = temps[index]
+          if index == temps.size - 1
+            if !temp.empty?
+              result += self.partition_all(temp)
+            end
+          else
+            if temp && !temp.empty?
+              result << temp
+            end
+          end
+        end
+        result
+      end
+
+      # @param [Array<String>] values
+      # @param [Array<String>] formatters
+      def self.formatValues(values, formatters)
+        results = []
+        formatters.each do |formatter|
+          # 如果是数字的话
+          if formatter.is_a?(Integer)
+            results << values[formatter]
+            next
+          end
+
+          # @type [Hash<Integer => Integer>]
+          params = {} #下标 数组
+          # @type [Hash<Integer => String>]
+          methods = {} #方法 数组
+
+          splits     = self.partition_all(formatter)
+          split_hash = {}
+          splits.each_index do |index|
+            split = splits[index]
+            # 保存到 `hash` 内
+            split_hash[index] = split
+            if split.match?(/^:[a-zA-Z0-9_]+/)
+              # 判断是不是满足初始条件
+              if split.match?(/^:[0-9]+/)
+                value_index   = split.match(/[0-9]+/)[0].to_i
+                params[index] = values[value_index]
+              else
+                methods[index] = split
+              end
+            end
+          end
+
+          result = ""
+          if methods.empty?
+            splits.each_index do |index|
+              if params.has_key?(index)
+                result += params[index]
+              else
+                result += splits[index]
+              end
+            end
+          else
+            methods.keys.sort.reverse_each do |index|
+              param_count  = methods[index].match(/[0-9]/)[0].to_i
+              method_match = methods[index].match(/[a-zA-Z]+/).to_s
+              method       = self.method(method_match)
+              args         = []
+              (1..param_count).each do |i|
+                if params.include?(index + i)
+                  args[i - 1] = params.delete(index + i) # 在对应位置上删掉该参数
+                end
+                if methods.include?(index + i)
+                  args[i - 1] = methods.delete(index + i) # 在对应位置上删掉该参数
+                end
+                split_hash.delete(index + i)
+              end
+              methods[index] = method.call(*args)
+            end
+            split_hash.keys.sort.each do |index|
+              if methods.has_key?(index)
+                result += methods[index].to_s
+              else
+                result += split_hash[index]
+              end
+            end
+          end
+          results << result
+        end
+        results
+      end
+    end
+  end
+end

data/lib/jekyll-tally-tags/hooks_doc.rb

@@ -0,0 +1,134 @@
+module Jekyll
+  module TallyTags
+
+    Jekyll::Hooks.register :site, :after_init do |_|
+      # 修改正则让 `2021-01-01.md` 就算无后缀也可读
+      old = Jekyll::Document::DATE_FILENAME_MATCHER
+      new = NO_NAME
+      if old != new
+        Jekyll::Document::DATE_FILENAME_MATCHER = new
+      end
+    end
+
+    Jekyll::Hooks.register :site, :post_read do |site|
+
+      # 首先获取所有在 `tally` 内 `list` 的值
+      tally_configs = site.config.fetch(TALLY, {})
+      next unless tally_configs && !tally_configs.empty?
+      # 然后获取默认配置 没有也是可以的
+      # @type [Hash<String => Array<Integer, String>>]
+      default_template = tally_configs[DEFAULT]
+
+      if default_template
+        # 初始化默认的模板
+        default_template.each_key do |key|
+          default_template[key] = Counter.to_array(default_template[key], nil)
+        end
+      end
+
+      # 先判断有没有对应的配置
+      # @type [Hash<String => Array<Integer, String>>]
+      templates = tally_configs[TEMPLATES]
+      # 必须有模板才可以解析
+      next unless templates && !templates.empty?
+
+      # @type [Array<Document>]
+      docs = site.posts.docs # 文章里的文档 (也就是 `yaml`)
+      id   = 0 # id
+
+      no_scan_docs = [] # 无法扫描的文档
+      scanned_docs = [] # 创建新的文档
+
+      # 先遍历模板
+      templates.each_key do |template_key|
+        template = templates[template_key]
+        template.each_key do |key|
+          # 依据默认模板生成新的模板
+          template[key] = Counter.to_array(template[key], default_template[key])
+        end
+      end
+
+      # 后便利文档
+      docs.each do |doc|
+        # 判断这个文档里面有没有对应的 `template`
+        doc_has_template = doc.data.keys & templates.keys
+        if !doc_has_template || doc_has_template.empty?
+          no_scan_docs << doc
+          next
+        end
+
+        doc_has_template.each do |template_key|
+          csv_list = doc[template_key]
+          template = templates[template_key]
+          # 下一步 如果 有值 且 不为空
+          next unless csv_list && !csv_list.empty?
+
+          # 如果不是数组的话
+          if !csv_list.is_a?(Array)
+            Jekyll.logger.warn(template_key, "#{doc.path}里的数据不为数组, 将不解析该字段")
+            next
+          end
+
+          keys = []
+          csv_list.each_index do |csv_index|
+            csv = csv_list[csv_index]
+            # 正则处理 把",,,"这样的 分割成" ,  ,  , "
+            csv.gsub!(/[，|,|\s]+?/, " , ")
+            # lstrip rstrip 去掉前后空格
+            # @type [Array<String>]
+            values = csv.split(',').each(&:lstrip!).each(&:rstrip!)
+            # 判断有没有 `keys` 如果没有 第一行就作为 `keys` 因为第一行作为 `keys` 就是像极了 `csv`
+            if (!template[KEYS] || template[KEYS].empty?) && csv_index == 0
+              keys = values
+              next
+            end
+            # 初始化数据
+            datum = { ID => id, PERMALINK => "/#{ID}/#{id}" }
+            # 对当前 `template` 所有 `key` 遍历
+            template.each_key do |key|
+              datum[key] = Counter.formatValues(values, template[key])
+            end
+
+            # 对 `values` 所有 内容 遍历
+            values.each_index do |index|
+              datum[keys[index]] = values[index]
+            end
+
+            # 可能会死循环 `Document.new` 还会发消息
+            # TODO: 后续 采用 `Document` 子类
+            new_doc = Document.new(doc.path, site: site, collection: site.posts)
+            new_doc.data.replace(doc.data)
+            new_doc.data[DATA] = {}
+            # 重新赋值
+            datum.each_key do |key|
+              Counter.set_doc_data(new_doc, key, datum[key])
+            end
+            scanned_docs << new_doc
+            id += 1
+          end
+        end
+      end
+      # @type [Array<Document>]
+      all_docs = no_scan_docs + scanned_docs
+      # 判断是不是需要 开启组合模式
+      combine_configs = tally_configs[COMBINE]
+      if combine_configs && combine_configs.is_a?(Array)
+        combine_configs.each do |config|
+          find_key      = config[FIND]
+          combine_key   = config[TO]
+          deep_key      = config[DEEP]
+          all_find_keys = []
+          all_docs.each do |doc|
+            doc.data[combine_key] = []
+            # 找到所有 `key`
+            all_find_keys += doc.data[find_key]
+          end
+          merges = Counter.merge_all(all_find_keys.uniq!, deep_key)
+          Counter.combine_merge_list(merges, all_docs, find_key, combine_key)
+        end
+      end
+
+      site.posts.docs = all_docs
+    end
+  end
+end

data/lib/jekyll-tally-tags/hooks_logs.rb

@@ -0,0 +1,57 @@
+module Jekyll
+  DEBUG = false
+  Jekyll::Hooks.register :site, :after_init do |data|
+    puts 'site   after_init 在网站初始化时，但是在设置和渲染之前，适合用来修改网站的配置项' if DEBUG
+  end
+  Jekyll::Hooks.register :site, :after_reset do |data|
+    puts 'site   after_reset 网站重置之后' if DEBUG
+  end
+  Jekyll::Hooks.register :site, :post_read do |site|
+    puts 'site   post_read 在网站数据从磁盘中读取并加载之后' if DEBUG
+  end
+  Jekyll::Hooks.register :site, :pre_render do |data|
+    puts 'site   pre_render 在渲染整个网站之前' if DEBUG
+  end
+  Jekyll::Hooks.register :site, :post_render do |data|
+    puts 'site   post_render 在渲染整个网站之后，但是在写入任何文件之前' if DEBUG
+  end
+  Jekyll::Hooks.register :site, :post_write do |data|
+    puts 'site   post_write 在将整个网站写入磁盘之后' if DEBUG
+  end
+  Jekyll::Hooks.register :pages, :post_init do |data|
+    puts 'pages   post_init 每次页面被初始化的时候' if DEBUG
+  end
+  Jekyll::Hooks.register :pages, :pre_render do |data|
+    puts 'pages   pre_render 在渲染页面之前' if DEBUG
+  end
+  Jekyll::Hooks.register :pages, :post_render do |data|
+    puts 'pages   post_render 在页面渲染之后，但是在页面写入磁盘之前' if DEBUG
+  end
+  Jekyll::Hooks.register :pages, :post_write do |data|
+    puts 'pages   post_write 在页面写入磁盘之后' if DEBUG
+  end
+  Jekyll::Hooks.register :posts, :post_init do |data|
+    puts 'posts   post_init 每次博客被初始化的时候' if DEBUG
+  end
+  Jekyll::Hooks.register :posts, :pre_render do |data|
+    puts 'posts   pre_render 在博客被渲染之前' if DEBUG
+  end
+  Jekyll::Hooks.register :posts, :post_render do |data|
+    puts 'posts   post_render 在博客渲染之后，但是在被写入磁盘之前' if DEBUG
+  end
+  Jekyll::Hooks.register :posts, :post_write do |data|
+    puts 'posts   post_write 在博客被写入磁盘之后' if DEBUG
+  end
+  Jekyll::Hooks.register :documents, :post_init do |data|
+    puts 'documents   post_init 每次文档被初始化的时候' if DEBUG
+  end
+  Jekyll::Hooks.register :documents, :pre_render do |data|
+    puts 'documents   pre_render 在渲染文档之前' if DEBUG
+  end
+  Jekyll::Hooks.register :documents, :post_render do |data|
+    puts 'documents   post_render 在渲染文档之后，但是在被写入磁盘之前' if DEBUG
+  end
+  Jekyll::Hooks.register :documents, :post_write do |data|
+    puts 'documents   post_write 在文档被写入磁盘之后' if DEBUG
+  end
+end