ymlex 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 !binary "U0hBMQ==":
-  metadata.gz: d58cf8e6242857ce7733c5c3fb8c7e6943e36fff
-  data.tar.gz: 788e86d712d1aa6224a58430edd155241f9a6903
+  metadata.gz: 08193ba23283d08722054a4aeb4e727b366c33e1
+  data.tar.gz: 36a6458002ac1726f5b8110a1c6f2565530c0ba2
 !binary "U0hBNTEy":
-  metadata.gz: a8998586d0251f20a9f1dc5410b1fecc70934533b406ec1a88a0cfa4abede86f54a40fe3fa2bc0e6c01a8ccbe631f8afc972e69d9d6fe121c1ce04ab33d84294
-  data.tar.gz: e92d59c7b104c9406fec09c89b23e9ab135bfb8264cbe0aed1e2852099e909109fefba1ce1bb064520fca0fe9c5874711ffd8b47cbe98fefcaebaf19da47c8e7
+  metadata.gz: 27558b9ac2e0139539676232418c3654103249c1d186c84d089472bef087115e655016e82f40e409b757d90429d1a6bf5cc855021925c9c408ee3b3bc36a365a
+  data.tar.gz: 6dc301b9d99f40b8ba104d3ffb2c854baf3684e095c2299ff6d12cf21431bdf3c5ab038167ebe3ab585460c799889f02cde8d96b322e353c50263e5ddea30bd5

data/bin/ymlex

@@ -0,0 +1,206 @@
+#!/usr/bin/env ruby
+
+home = File.join(File.dirname(__FILE__),'..')
+$LOAD_PATH.unshift(File.join(home,'lib'))
+
+require 'ymlex'
+
+def find_last
+  pwd = Dir.pwd
+  last = nil
+  dir = nil
+  until last or pwd == ""
+    file = "#{pwd}/.ymlex.last"
+    if File.exist? file
+      File.open file, "r" do |f|
+        last = f.read.chomp
+        dir = pwd
+      end
+    end
+    pwd = pwd.sub(/\/(\w)*$/,"")
+  end
+  [last, dir]
+end
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: ymlex [options]"
+  opts.on("-t", "--template [directory]", "Path to template, default is './'") do |template_dir|
+    options[:template] = template_dir
+    Ymlex.initTptDir template_dir
+  end
+  opts.on("-p", "--product [directoy]", "Translate a directiory of ymlex files") do |product_dir|
+    options[:product] = product_dir
+  end
+  opts.on("-j", "--[no-]show-json", "Show the instance in json") do
+    options[:showjson] = true
+  end
+  opts.on("-y", "--[no-]show-yml", "Show the instance in yaml") do
+    options[:showyml] = true
+  end
+  opts.on("-c", "--ci [product]", "check in") do |product|
+    product, options[:pwd] = find_last if !product
+    options[:ci] = product
+  end
+  opts.on("-n", "--new [modu]", "check in") do |modu|
+    options[:new] = modu
+  end
+  opts.on("-a", "--auto [product]", "Trans product automatically") do |product|
+    product, options[:pwd] = find_last if !product
+    options[:auto] = product
+  end
+  opts.on("-o", "--output [directory]", "Set output directory") do |output_dir|
+    options[:output] = output_dir
+  end
+  opts.on("-l", "--log [log_name]", "Trans log monitor") do |log_name|
+    options[:log] = log_name
+  end
+  opts.on("-h", "--help", "Show this help") do
+    puts opts
+    exit
+  end
+end.parse!
+options[:output] = options[:auto] || "./output" if !options[:output]
+
+case
+when options[:new]
+  modu = options[:new]
+  file = <<HD_NEW
+name: #{modu}
+# node:
+# - BAIDU_ECOM_SDC_SOMENODE
+# bns:
+# - somebns
+contacts:
+  rd: "" 
+  op: ""
+  qa: ""
+basepath: /home/work/#{modu}
+_inherit: c_base.tpt
+request:
+  listen:
+    port: 8080
+proc:
+  main:
+    path: ${basepath}/bin/#{modu}
+log:
+  accessLog:
+    path: ${basepath}/log/#{modu}.log
+    flow:
+      formula: ${self}_cps >= 1000
+  errorLog:
+    path: ${basepath}/log/#{modu}.log.wf
+    fatal:
+      match_str: FATAL
+      formula: ${self}_cnt > 1
+# aggr:
+#   flow_sum:
+#     items: #{modu}_log_accessLog_flow_cps
+#     types: sum
+HD_NEW
+  File.open "#{modu}.yex", "w" do |f|
+    f.write file
+  end
+  exit
+when options[:ci]
+  git_product = options[:ci]
+  svn_product = git_product.upcase
+  local_path = options[:pwd] || options[:output]
+  git_path = "#{local_path}/git/#{git_product}"
+  svn_path = "#{local_path}/svn/#{svn_product}"
+  system <<HD_SHELL_CI
+set -eu
+echo "svn check in ..."
+cd #{svn_path} && svn ci -m 'auto check in'
+echo "git commit and push ..."
+cd #{git_path} && git add . && git commit -am 'auto commit' && git push
+HD_SHELL_CI
+  exit
+when options[:log]
+  filename = options[:log]
+  log_js = {}
+  File.open(filename,"r") do |f|
+    log_js = JSON.parse f.read
+  end
+  log_yml = {}
+  log_yml["path"] = log_js["log_filepath"]
+  log_js["item"].each do |item|
+    name = item["item_name_prefix"]
+    item.delete "item_name_prefix"
+    log_yml[name] = item
+  end
+  puts log_yml.to_yaml
+  exit
+when options[:auto]
+  git_product = options[:auto]
+  svn_product = git_product.upcase
+  git_remote = "http://gitlab.baidu.com/sdc-monitor/#{git_product}.git"
+  template_remote = "http://gitlab.baidu.com/sdc-monitor/template.git"
+  svn_remote = "http://svn.noah.baidu.com/svn/conf/online/#{svn_product}"
+  local_path = options[:pwd] || options[:output]
+  git_path = "#{local_path}/git/#{git_product}"
+  template_path = "#{local_path}/git/template"
+  svn_path = "#{local_path}/svn/#{svn_product}"
+  system <<HD_SHELL
+set -eu
+mkdir -p #{local_path}/git #{local_path}/svn
+echo #{git_product} > #{local_path}/.ymlex.last
+if [[ -d #{git_path} ]]; then
+  echo "#{git_path} exist. git pull ..."
+  cd #{git_path}
+  git pull
+  cd -
+else
+  echo "#{git_path} not exist. git clone ..."
+  cd #{local_path}/git
+  git clone #{git_remote} 
+  cd -
+fi
+if [[ -d #{template_path} ]]; then
+  echo "#{template_path} exist. git pull ..."
+  cd #{template_path}
+  git pull
+  cd -
+else
+  echo "#{template_path} not exist. git clone ..."
+  cd #{local_path}/git
+  git clone #{template_remote} 
+  cd -
+fi
+if [[ -d #{svn_path} ]]; then
+  echo "#{svn_path} exist. svn up ..."
+  cd #{svn_path}
+  svn up
+  cd -
+else
+  echo "#{svn_path} not exist. svn co ..."
+  cd #{local_path}/svn
+  svn co #{svn_remote} 
+  cd -
+fi
+echo "process ymlex ..."
+ymlex -p #{git_path} -t #{template_path} -o #{svn_path}
+cd #{svn_path}
+echo "show svn diff"
+svn st | grep '?'  | awk '{print $2}' | xargs svn add || true
+svn st | grep '!'  | awk '{print $2}' | xargs svn delete || true
+svn diff
+HD_SHELL
+  puts <<HD_SHELL
+==================================================================
+output is in #{svn_path}, you may check in after comfirm the diff:
+cd #{svn_path}
+svn ci 
+HD_SHELL
+  exit
+when options[:product]
+  ArgusYml.process_dir options[:product], options[:output]
+else
+  until ARGV.empty?
+    input = ARGV.shift
+    ags = ArgusYml.new input
+    puts ags.info_yml.to_yaml if options[:showyml]
+    puts JSON.pretty_generate ags.instance if options[:showjson]
+    ags.dump_json options[:output] if options[:output]
+  end
+end

data/lib/ymlex/argusyml.rb

@@ -0,0 +1,380 @@
+#!/usr/bin/env ruby
+class Alert
+  # level definition
+  # nil: no alert
+  # info: mail
+  # warning: summury and sms
+  # error: sms
+  # fatal: sms to boss 
+  attr :contacts, :default_level
+  def initialize contacts, level={}
+    @contacts = contacts
+    @default_level = { "oncall" => "g_ecomop_maop_oncall", 
+                       "manager" => "g_ecomop_maop_manager",
+                       "rd" => "err", 
+                       "op" => "warn", 
+                       "qa" => nil }.merge(level)
+  end
+
+  def get_alert lvl={}
+    level = @default_level.merge(lvl)
+    oncall = level["oncall"]
+    manager = level["manager"]
+
+    mail = ""
+    sms = ""
+    level.each do |role, lvl|
+      if ["op","rd","qa"].include? role
+        mail = "#{@contacts[role]};#{mail}" if lvl != nil
+        if lvl =~ /err/ or lvl =~ /fatal/ or (lvl =~ /warn/ and role != "op")
+          sms = "#{@contacts[role]};#{sms}" 
+        end
+      end
+    end
+    lvl = level["op"]
+    sms = "#{oncall};#{sms}" if lvl =~ /warn/ or lvl =~ /err/ or lvl =~ /fatal/
+    sms = "#{manager};#{sms}" if lvl =~ /fatal/
+
+    remind_time = (lvl =~ /fatal/)? "300" : "7200"
+    alt = {
+      "max_alert_times" => level["max_alert_times"] || "2",
+      "alert_threshold_percent" => level["alert_threshold_percent"] || "0",
+      "sms_threshold_percent" => level["sms_threshold_percent"] || "0",
+      "remind_interval_second" => level["remind_interval_second"] || remind_time,
+      "mail" => mail,
+      "sms" => sms,
+    }
+    if lvl =~ /warn/
+      alt["level1_upgrade_interval"] = "10800"
+      alt["level1_upgrade_sms"] = @contacts["op"]
+      if manager != ""
+        alt["level2_upgrade_interval"] = "36000"
+        alt["level2_upgrade_sms"] = manager
+      end
+    end
+    if lvl =~ /err/ and manager != ""
+      alt["level1_upgrade_interval"] = "10800"
+      alt["level1_upgrade_sms"] = manager
+    end
+    alt
+  end
+
+  def get_mail lvl=nil
+    alert_info = get_alert lvl
+    alert_info["mail"]
+  end
+
+  def get_sms lvl=nil
+    alert_info = get_alert lvl
+    alert_info["sms"]
+  end
+
+end
+
+class ArgusYml
+
+  def self.process_dir dir_path, dest_path, product = nil
+    filelist = `find #{dir_path} -type f -name '*yex'`.split(' ')
+    product = File.basename dir_path if !product
+    filelist.each do |ymx|
+      puts "process #{ymx}"
+      ags = ArgusYml.new ymx, product
+      ags.dump_json dest_path
+    end
+  end
+
+  attr_reader :info_yml, :instance, :logs, :name, :bns, :alert, :node
+
+  def initialize filename_or_hash, product = nil
+    if filename_or_hash.kind_of? String
+      yml = Ymlex.load_file filename_or_hash
+    else
+      yml = filename_or_hash
+    end
+    @info_yml = value_to_str yml
+    @name = @info_yml["name"]
+    @bns = @info_yml["bns"] || []
+    node_list = @info_yml["node"] || []
+    node_str = ""
+    node_list.each {|v| node_str += v + ","}
+    @node = node_str.sub /,$/, ""
+    @product = product || @info_yml["product"] || @bns.first.sub(/^.*?\./,"").sub(/\..*$/,"") || "Undefined_Product"
+    @logs = {}
+    @alert = Alert.new @info_yml["contacts"], @info_yml["alert"]
+    @service_aggr = []
+    @service_rule = []
+    @service_alert = [default_alert]
+    reset_instance
+    trans_ytoj
+  end
+
+  def reset_instance
+    @instance = empty
+  end
+
+  def value_to_str input
+    case 
+    when input.kind_of?(Hash)
+      input.each do |k,v|
+        input[k] = value_to_str v
+      end
+    when input.kind_of?(Array)
+      input.each_index do |i|
+        input[i] = value_to_str input[i]
+      end
+    when input.kind_of?(Fixnum) || input.kind_of?(Float)
+      input = input.to_s
+    end
+    input
+  end
+
+  def dump_json dir_path, append_mode = true
+    
+    dir = "#{dir_path}/cluster/cluster.#{@name}.#{@product}.all"
+    `mkdir -p #{dir}`
+
+    # instance
+    filename = "#{dir}/instance"
+    if append_mode 
+      old_instance = nil
+      begin
+        File.open(filename,"r") do |f|
+          old_instance = JSON.parse f.read
+        end
+        old_instance = empty if !old_instance
+      rescue
+        old_instance = empty
+      end
+      new_instance = {}
+      ["raw","request","rule","alert"].each do |type| 
+        new_instance[type] = old_instance[type]
+        next unless @instance[type]
+        @instance[type].each do |new_item|
+          idx = old_instance[type].find_index do |old_item| 
+            old_item["name"] == new_item["name"]
+          end
+          if idx
+            new_instance[type][idx] = new_item
+          else
+            new_instance[type] << new_item
+          end
+        end
+      end 
+    else
+      new_instance = @instance
+    end
+    File.open(filename,"w") do |f|
+      f.puts JSON.pretty_generate new_instance
+    end
+
+    # log
+    @logs.each do |log_key, log_value|
+      log_name = "#{dir}/#{log_key}.conf"
+      File.open(log_name, "w") do |f|
+        f.puts JSON.pretty_generate log_value
+      end
+    end
+
+    # cluster
+    aggr_name = "#{dir}/cluster"
+    File.open(aggr_name, "w") do |f|
+      cluster = { "aggr" => @service_aggr,
+                  "rule" => @service_rule,
+                  "alert" => @service_alert,
+                }
+      cluster["namespace_list"] = @bns if @bns != []
+      cluster["service_node"] = @node if @node != ""
+      f.puts JSON.pretty_generate cluster
+    end
+  end 
+
+  def trans_ytoj
+    @info_yml.each do |key, value| 
+      case key
+      when "proc"
+        trans_proc value
+      when "request"
+        trans_request value
+      when "exec"
+        trans_exec value
+      when "other"
+        trans_other value
+      when "log"
+        trans_log value
+      when "aggr"
+        trans_aggr value
+      end
+    end
+  end
+
+  def trans_aggr list
+    list.each do | rule_name, value | 
+      @service_aggr << { "items" => value["items"],
+                         "types" => value["types"] || "sum",
+                       }
+      if value["formula"]
+        rule_name = "#{@name}_aggr_#{rule_name}"
+        alert_name = "default_alert"
+        if value["alert"]
+          alt = @alert.get_alert value["alert"]
+          alt["name"] = rule_name
+          @service_alert << alt
+          alert_name = rule_name
+        end
+        @service_rule << { "name" => rule_name,
+                           "formula" => value["formula"],
+                           "filter" => value["filter"] || "1/1",
+                           "alert" => alert_name }
+      end
+    end
+  end
+
+  def trans_exec list
+    list.each do | raw_key, raw_value |
+      dft_exec_raw = { "cycle" => "60",
+                       "method" => "exec",
+                     }
+      raw_value["name"] = "#{@name}_exec_#{raw_key}"
+      @instance["raw"] << dft_exec_raw.merge(raw_value)
+    end
+  end
+
+  def trans_other list
+    list.each do | rule_key, rule_value |
+      rule_name = "#{@name}_other_#{rule_key}"
+      alert_name = "default_alert"
+      if rule_value["alert"]
+        alt = @alert.get_alert rule_value["alert"]
+        alt["name"] = rule_name
+        @instance["alert"] << alt
+        alert_name = rule_name
+      end
+      @instance["rule"] << { "name" => rule_name,
+                             "formula" => rule_value["formula"],
+                             "filter" => rule_value["filter"] || "1/1",
+                             "alert" => alert_name }
+    end
+  end
+
+  def trans_log list
+    list.each do |log_key, log_value|
+      raw_name = "#{@name}_log_#{log_key}"
+      log_raw = { "name" => raw_name,
+                  "cycle" => log_value["cycle"] || "60",
+                  "method" => "noah",
+                  "target" => "logmon",
+                  "params" => "${ATTACHMENT_DIR}/#{raw_name}.conf",
+                }
+      @instance["raw"] << log_raw
+
+      log_conf = { "log_filepath" => log_value["path"],
+                   "limit_rate" => "5",
+                   "item" => []
+                 }
+      log_value.each do |raw_key, raw_value|
+        next if raw_key == "path"
+        item_name_prefix = "#{raw_name}_#{raw_key}" 
+        item = { "item_name_prefix" => item_name_prefix,
+                 "cycle" => raw_value["cycle"] || "60",
+                 "match_str" => raw_value["match_str"],
+                 "filter_str" => raw_value["filter_str"] || "",
+               }
+        log_conf["item"] << item
+        next unless raw_value["formula"]
+        alert_name = "default_alert"
+        if raw_value["alert"]
+          alt = @alert.get_alert raw_value["alert"]
+          alt["name"] = item_name_prefix
+          @instance["alert"] << alt
+          alert_name = item_name_prefix
+        end
+        @instance["rule"] << { "name" => item_name_prefix, 
+                               "formula" => raw_value["formula"],
+                               "filter" => raw_value["filter"] || "1/1",
+                               "alert" => alert_name,
+                             }
+      end
+      @logs[raw_name] = log_conf
+    end
+  end
+
+  def trans_proc list
+    list.each do |raw_key, raw_value|
+      raw_name = "#{@name}_proc_#{raw_key}"
+      @instance["raw"] << { "name" => raw_name,
+                            "cycle" => raw_value["cycle"]||"60",
+                            "method" => "noah",
+                            "target" => "procmon",
+                            "params" => raw_value["path"] }
+      raw_value.each do |rule_key, rule_value|
+        next if (rule_key == "path" || !rule_value["formula"])
+        rule_name = "#{raw_name}_#{rule_key}"
+        alert_name = "default_alert"
+        if rule_value["alert"]
+          alt = @alert.get_alert rule_value["alert"]
+          alt["name"] = rule_name
+          @instance["alert"] << alt
+          alert_name = rule_name
+        end
+        @instance["rule"] << { "name" => rule_name,
+                               "formula" => rule_value["formula"],
+                               "filter" => rule_value["filter"]||"3/3",
+                               "alert" => alert_name }
+      end
+    end
+  end
+
+  def trans_request list
+    list.each do |raw_key, raw_value|
+      raw_name = "#{@name}_request_#{raw_key}"
+      dft_raw = { "name" => raw_name,
+                  "cycle" => "60",
+                  "port" => "8080",
+                  "protocol" => "tcp",
+                  "mon_idc" => "local",
+                  "req_type" => "port",
+                }
+      @instance["request"] << dft_raw.merge(raw_value)
+      alert_name = "default_alert"
+      if raw_value["alert"]
+        alt = @alert.get_alert raw_value["alert"]
+        alt["name"] = raw_name
+        @instance["alert"] << alt
+        alert_name = raw_name
+      end
+      @instance["rule"] << { "name" => raw_name,
+                             "formula" => "#{raw_name} != 'ok'",
+                             "filter" => raw_value["filter"]||"3/3",
+                             "alert" => alert_name }
+    end
+  end
+
+  private
+
+  def noah_error
+    {
+      "name" => "noah_error",
+      "formula" => "noah_error != '' && not_contain(noah_error,'logmon open log failed') && time_between('080000-220000')",
+      "filter" => "100/100",
+      "alert" => "noah_error_alert",
+    } 
+  end
+
+  def default_alert
+    alt = @alert.get_alert
+    alt["name"] = "default_alert"
+    alt
+  end
+
+  def noah_error_alert
+    alt = @alert.get_alert({"rd" => nil, "qa" => nil, "op" => "warn" })
+    alt["name"] = "noah_error_alert"
+    alt
+  end
+
+  def empty
+    {"raw"=>[], "request"=>[], "rule"=>[noah_error], "alert"=>[default_alert,noah_error_alert]}
+  end
+
+end
+

data/lib/ymlex/ymlex.rb

@@ -3,6 +3,8 @@
 class Ymlex
 
   @log = Logger.new STDOUT
+  @log.level = Logger::WARN
+  @name = nil
 
   def self.initLogger logger
     @log = logger
@@ -21,13 +23,23 @@ class Ymlex
   end
 
   def self.load_file file
-    @log.debug "start load file: #{file}"
+    loadFile file
+  end
+
+  def self.loadFile file
     input = YAML.load_file file
-    @tptDir ||= File.dirname file
+    @name = input["name"] || nil
+    @pwd = File.dirname file
+    @tptDir ||= @pwd
     input = parse input
-    @log.debug "after parse, #{file} is #{input}"
     input = verblize input
-    @log.debug "after verblize, #{file} is #{input}"
+    input
+  end
+
+  def self.loadTpt file
+    input = YAML.load_file file
+    @tptDir ||= File.dirname file
+    input = parse input
     input
   end
 
@@ -38,36 +50,46 @@ class Ymlex
       end
     end
     if input.key? "_inherit"
-      father = load_file File.join(@tptDir,input["_inherit"])
+      if File.exist? File.join(@pwd,input["_inherit"])
+        father = loadTpt File.join(@pwd,input["_inherit"])
+      elsif File.exist? File.join(@tptDir,input["_inherit"])
+        father = loadTpt File.join(@tptDir,input["_inherit"])
+      end
       input.delete "_inherit"
       input = merge father, input
     end
     input
   end
 
-  def self.verblize input, ref = nil
+  def self.verblize input, ref = nil, selfRule = nil
     ref ||= input
-    case 
+    case
     when input.class == Hash
       input.each do |key,value|
-        input[key] = verblize value, ref
+        nextRule = selfRule ? "#{selfRule}_#{key}" : key
+        input[key] = verblize value, ref, nextRule
       end
     when input.class == Array
       input.each_index do |i|
-        input[i] = verblize input[i], ref
+        input[i] = verblize input[i], ref, selfRule
       end
     when input.class == String
-      input = verbString input, ref
+      input = verbString input, ref, selfRule
     end
     input
   end
 
-  def self.verbString input, ref
+  def self.verbString input, ref, selfRule
+    selfRule = selfRule.sub(/^/, "#{@name}_") if @name
+    selfRule = selfRule.sub(/_[a-zA-Z0-9]*$/, '')
+    selfRule = selfRule.sub(/_[a-zA-Z0-9]*$/, '') if selfRule =~ /_proc_/
+    input = input.gsub(/[\$@]{self}/, selfRule)
+
     reg = /\${(.*?)}/.match(input)
     while reg
-      toRep = reg[1] if reg
+      toRep = reg[1]
       toEval = toRep.gsub(/[\.]/,"\"][\"").sub(/^/,"ref[\"").sub(/$/,"\"]")
-      begin 
+      begin
         resultEval = eval toEval
       rescue
         @log.error "fail to verbString #{input}"
@@ -76,6 +98,16 @@ class Ymlex
       input = input.sub(/\${(.*?)}/,resultEval)
       reg = /\${(.*?)}/.match(input)
     end
+
+    reg = /@{(.*?)}/.match(input)
+    while reg
+      toRep = reg[1]
+      keyStr = toRep.gsub(/\./, '_')
+      keyStr = keyStr.sub(/^/, "#{@name}_") if @name
+      input = input.sub(/@{(.*?)}/, keyStr)
+      reg = /\${(.*?)}/.match(input)
+    end
+
     input
   end
 
@@ -86,13 +118,15 @@ class Ymlex
           father[key] = merge value, child[key]
         elsif value.class == Array && child[key].class == Array
           father[key] = (value + child[key]).uniq
+        elsif child[key] == "disable"
+          father.delete key
         else
           father[key] = child[key]
         end
       end
     end
     child.each do |key,value|
-      father[key] ||= value
+      father[key] ||= value if value != "disable"
     end
     father
   end

data/lib/ymlex.rb

@@ -1,5 +1,8 @@
 #!/usr/bin/env ruby
 require 'yaml'
 require 'logger'
+require 'json'
+require 'optparse'
 
 require 'ymlex/ymlex'
+require 'ymlex/argusyml'

metadata

@@ -1,23 +1,26 @@
 --- !ruby/object:Gem::Specification
 name: ymlex
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
-- Cruel Wen
+- Wen Li
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-14 00:00:00.000000000 Z
+date: 2014-08-01 00:00:00.000000000 Z
 dependencies: []
 description: ! 'extend ymal: support inherit and valueize'
-email: 
-executables: []
+email: wenli@baidu.com
+executables:
+- ymlex
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/ymlex.rb
 - lib/ymlex/ymlex.rb
+- lib/ymlex/argusyml.rb
+- bin/ymlex
 homepage: https://github.com/cruelwen/ymlex
 licenses:
 - MIT