kumogata-template 0.0.35 → 0.0.36

data/lib/kumogata/template/helper.rb

@@ -4,12 +4,6 @@
 require 'date'
 require 'kumogata/template/const'
 
-def _resource_name(name, append = nil)
-  name = name.to_s
-  name += " #{append}" unless append.nil?
-  name.split.map(&:capitalize).join(' ').gsub(/[-_#,.]/, '').delete(' ')
-end
-
 def _array(args)
   if args.is_a? String
     [ args ]
@@ -39,12 +33,58 @@ def _description(name)
     chomp.slice(0, 1024)
 end
 
-def _empty?(value)
-  return true if value.nil?
-  return false if value.is_a? Integer
-  return false if value.is_a? TrueClass or value.is_a? FalseClass
+def _pair_name_value(args, name)
+  _pair_value(args, name, "name")
+end
+
+def _pair_value(args, name, key_prefix = "key")
+  return "" unless args.key? name.to_sym
+
+  pair = args[name.to_sym]
+
+  if pair.is_a? Hash
+    pair.map.collect do |key, value|
+      case value
+      when /^_ref_(.*)$/
+        value = _ref_pseudo($1)
+      when /^_import_(.*)$/
+        value = _import($1)
+      end
+
+      p = { "#{key_prefix.capitalize}": key.to_s }
+      p['Value'] = value
+      p
+    end
+  else
+    pair.collect do |p|
+      p.map.collect do |_, value|
+        _{
+          Value value
+        }
+      end
+    end
+  end
+end
+
+def _name(name, args, prefix = "-")
+  return _import(args["import_#{name}".to_sym]) if args.key? "import_#{name}".to_sym
+  ref_name = _ref_string(name, args)
+  if ref_name.empty?
+    ref_name_default = _ref_string("name", args)
+    _join([
+           _ref(_resource_name("service")),
+           (ref_name_default.is_a? String) ? ref_name_default.gsub(' ', prefix) : ref_name_default,
+          ],
+          prefix)
+  else
+    (ref_name.is_a? String) ? ref_name.gsub(' ', prefix) : ref_name
+  end
+end
 
-  value.empty?
+def _resource_name(name, append = nil)
+  resource = name.to_s.clone
+  resource += " #{append}" unless append.nil?
+  resource.gsub(/[^0-9A-Za-z]/, ' ').split(' ').map(&:capitalize).join()
 end
 
 def _valid_values(value, values, default = nil)
@@ -59,29 +99,15 @@ def _valid_numbers(value, min = 0, max = 0, default = nil)
   (min <= number and number <= max) ? number : default
 end
 
-def _real_name(name, args)
-  key = _ref_key?(name, args) ? name : "name"
-  real_name = _ref_string(key, args)
-  real_name = real_name.gsub(" ", "-") if real_name.is_a? String
-  real_name =~ /^false/i ? false : real_name
-end
-
-def _ref_key?(name, args, ref_name = '')
+def _ref_key?(name, args, ref_name = '', check_name = true)
   return true if args.key? "import_#{name}".to_sym
   return true if args.key? "ref_#{name}".to_sym
-  return true unless args[name.to_sym].to_s.empty?
+  return true if check_name and args.key? name.to_sym
   false
 end
 
-def _ref_number(name, args, ref_name = '')
-  return _import(args["import_#{name}".to_sym]) if args.key? "import_#{name}".to_sym
-  return args[name.to_sym].to_i || 0 unless args.key? "ref_#{name}".to_sym
-
-  _ref(_resource_name(args["ref_#{name}".to_sym].to_s, ref_name))
-end
-
-def _ref_string(name, args, ref_name = '')
-  return _import(args["import_#{name}".to_sym]) if args.key? "import_#{name}".to_sym
+def _ref_string(name, args, ref_name = '', append_import_name = '')
+  return _import(args["import_#{name}".to_sym], ref_name, append_import_name) if args.key? "import_#{name}".to_sym
   return args[name.to_sym].to_s || '' unless args.key? "ref_#{name}".to_sym
 
   _ref(_resource_name(args["ref_#{name}".to_sym].to_s, ref_name))
@@ -92,23 +118,35 @@ def _ref_string_default(name, args, ref_name = '', default = '')
   ref_string.empty? ? default : ref_string
 end
 
-def _ref_array(name, args, ref_name = '')
-  return args["import_#{name}".to_sym].collect{|v| _import(v) } if args.key? "import_#{name}".to_sym
-  return _array(args[name.to_sym]) || [] unless args.key? "ref_#{name}".to_sym
-
-  array = []
-  if args["ref_#{name}".to_sym].is_a? String
-    array << _ref_string(name, args, ref_name)
+def _ref_array(name, args, ref_name = '', attr_name = '', append_import_name = '')
+  if args["import_#{name}".to_sym].is_a? String
+      [ _import(name, ref_name, append_import_name) ]
+  elsif args["ref_#{name}".to_sym].is_a? String
+    if attr_name.empty?
+      [ _ref_string(name, args, ref_name) ]
+    else
+      [ _attr_string(name, attr_name, ref_name) ]
+    end
   else
-    args["ref_#{name}".to_sym].collect{|v|
-      array << _ref(_resource_name(v, ref_name))
-    }
+    array = []
+    array += args["import_#{name}".to_sym].collect do |v|
+      _import(v, ref_name, append_import_name)
+    end if args.key? "import_#{name}".to_sym
+    array += args["ref_#{name}".to_sym].collect do |v|
+      if attr_name.empty?
+        _ref(_resource_name(v, ref_name))
+      else
+        _attr_string(v, attr_name, ref_name)
+      end
+    end if args.key? "ref_#{name}".to_sym
+    array.empty? ? _array(args[name.to_sym] || []) : array
   end
-  array
 end
 
-def _ref_attr_string(name, attr, args, ref_name = '')
-  if args.key? "ref_#{name}".to_sym
+def _ref_attr_string(name, attr, args, ref_name = '', append_import_name = '')
+  if args.key? "import_#{name}".to_sym
+    _import(args["import_#{name}".to_sym], ref_name, append_import_name)
+  elsif args.key? "ref_#{name}".to_sym
     _attr_string(args["ref_#{name}".to_sym], attr, ref_name)
   elsif args.key? name.to_sym
     args[name.to_sym]
@@ -117,52 +155,35 @@ def _ref_attr_string(name, attr, args, ref_name = '')
   end
 end
 
-def _ref_name(name, args, ref_name = '')
-  return _ref(_resource_name(args["ref_raw_#{name}".to_sym], ref_name)) if args.key? "ref_raw_#{name}".to_sym
-  return args["raw_#{name}".to_sym] if args.key? "raw_#{name}".to_sym
-  return _import(args["import_#{name}".to_sym]) if args.key? "import_#{name}".to_sym
-
-  name = _ref_string(name, args, ref_name)
-  if name.empty?
-    _join([ _ref(_resource_name("service")), _ref(_resource_name("name")) ], "-")
-  elsif name.is_a? Hash
-    _join([ _ref(_resource_name("service")), name ], "-")
-  else
-    name.gsub(" ", "-")
-  end
-end
-
-def _ref_name_default(name, args, ref_name = '')
-  return args["raw_#{name}".to_sym] if args.key? "raw_#{name}".to_sym
-  name = _ref_string(name, args, ref_name)
-  name.empty? ? args[:name] : name.gsub(" ", "-")
-end
-
-def _ref_resource_name(args, ref_name = '')
-  _ref(_resource_name(args[:name], ref_name))
-end
-
 def _ref_arn(service, name)
   _join([ "arn:aws:#{service}:::", _ref(_resource_name(name)) ], ",")
 end
 
 def _ref_pseudo(type)
-  pseudo =
-    case type
-    when "account"
-      "AccountId"
-    when "notification arns"
-      "NotificationARNs"
-    when "no value"
-      "NoValue"
-    when "region"
-      "Region"
-    when "stack id"
-      "StackId"
-    when "stack name"
-      "StackName"
-    end
-  _ref("AWS::#{pseudo}")
+  _ref("AWS::#{_pseudo(type)}")
+end
+
+def _var_pseudo(type)
+  "${AWS::#{_pseudo(type)}}"
+end
+
+def _pseudo(type)
+  case type
+  when "account id", "account_id"
+    "AccountId"
+  when "notification arns", "notification_arns"
+    "NotificationARNs"
+  when "no value", "no_value"
+    "NoValue"
+  when "region"
+    "Region"
+  when "stack id", "stack_id"
+    "StackId"
+  when "stack name", "stack_name"
+    "StackName"
+  else
+    type
+  end
 end
 
 def _ref(name)
@@ -207,7 +228,11 @@ def _base64(data)
 end
 
 def _base64_shell(data, shell = "/bin/bash")
-  _base64("#!#{shell}\n#{data}\n")
+  if data.is_a? Array
+    _base64(_join(data.insert(0, "#!#{shell}"), "\n"))
+  else
+    _base64(_join([ "#!#{shell}", data ], "\n"))
+  end
 end
 
 def _find_in_map(name, top_level, secondary_level)
@@ -219,65 +244,105 @@ def _select(index, list)
 end
 
 def _split(name, delimiter = ",")
-  _{
-    Fn__Split [ delimiter, name ]
-  }
+  _{ Fn__Split [ delimiter, name ] }
+end
+
+def _sub(name, mappings = [])
+  if mappings.empty?
+    _{ Fn__Sub name }
+  else
+    array = [ name ]
+    mappings.each do |mapping|
+      mapping.each_pair do |key, value|
+        _sub = {}
+        _sub.store(_resource_name(key), _ref_string('', { ref_: value }))
+        array << _sub
+      end
+    end
+    _{ Fn__Sub array }
+  end
 end
 
-def _sub(name)
-  _{ Fn__Sub name }
+def _sub_service(service)
+  _sub("#{service}.#{_var_pseudo('region')}.#{DOMAIN}")
 end
 
 def _export_string(args, prefix)
-  if args.key? :export and args[:export] == true
-    "#{args[:name]}-#{prefix.gsub(' ', '-')}"
-  else
-    ""
-  end
+  return '' unless args.key? :export
+  return '' unless args[:export] == true
+
+  export = args[:name]
+  export += "-#{args[:resource]}" if args.key? :resource
+  export += "-#{prefix}" unless prefix.empty?
+  export.gsub(/(\s|_)/, '-')
 end
 
 def _export(args)
   export = args[:export] || ''
   return '' if export.empty?
 
-  _{
-    Name _sub("${AWS::StackName}-#{export.gsub(" ", "-")}")
-  }
+  export = "#{export}-#{args[:resource]}" if args.key? :resource
+
+  _{ Name _sub("${AWS::StackName}-#{export.gsub(/(\s|_)/, '-')}") }
+end
+
+def _depends(keys, args)
+  return '' if keys.empty?
+
+  depends =
+     if args.key? :depends
+       args[:depends].collect{|v| _resource_name(v) }
+     else
+       []
+     end
+
+  keys.each do |v|
+    if v.is_a? String
+      depends << _resource_name(args[v.to_sym]) if args.key? v.to_sym
+    else
+      v.each_pair do |kk, vv|
+        depends << _resource_name(args[kk.to_sym], vv) if args.key? kk.to_sym
+      end
+    end
+  end
+
+  depends
 end
 
 def _join(args, delimiter = ",")
   _{ Fn__Join delimiter, args }
 end
 
-def _import(name)
-  _{
-    Fn__ImportValue _sub(name)
-  }
+def _import(name, ref_name = '', append_import_name = '')
+  import = name
+  import += "-#{ref_name}" unless ref_name.empty?
+  import += "-#{append_import_name}" unless append_import_name.empty?
+  _{ Fn__ImportValue _sub(import.gsub(/(\s|_)/, '-')) }
 end
 
 def _region
-  _ref("AWS::Region")
+  _ref_pseudo("region")
+end
+
+def _account_id
+  _ref_pseudo("account id")
 end
 
 def _tag(args)
   key = args[:key].to_s || ''
   value = args[:value] || ''
-  if key =~ /^ref_.*/
-    key.gsub!(/^ref_/, '')
-    value = _ref(_resource_name(value))
-  end
-
+  is_ref = (key =~ /^ref_.*/) ? true : false
   _{
-    Key _resource_name(key)
-    Value value
+    Key _resource_name(key.gsub(/^ref_/, ''))
+    Value is_ref ? _ref(_resource_name(value)) : value
   }
 end
 
-def _tags(args)
+def _tags(args, tag_name = "tag_name")
   tags = [
           _{
             Key "Name"
-            Value _tag_name(args)
+            Value _name(tag_name, args)
           },
           _{
             Key "Service"
@@ -288,33 +353,27 @@ def _tags(args)
             Value _ref(_resource_name("version"))
           },
          ]
-  args[:tags_append].collect{|k, v| tags << _tag(key: k, value: v) } if args.key? :tags_append
+  args[:tags_append].collect{|k, v| tags << _tag(key: k, value: v.gsub(" ", "-")) } if args.key? :tags_append
   tags
 end
 
-def _tag_name(args)
-  return _ref(_resource_name(args["ref_raw_tag_name".to_sym])) if args.key? "ref_raw_tag_name".to_sym
-  return args["raw_tag_name".to_sym] if args.key? "raw_tag_name".to_sym
-
-  tag_name = _ref_string("tag_name", args)
-  return tag_name unless tag_name.empty?
+def _tags_string(args, tag_name = "tag_name")
+  tags = {}
+  _tags(args, tag_name).collect{|v| tags[v['Key']] = v['Value'] }
+  tags
+end
 
-  tag_name = _ref_string("name", args)
-  tag_name = tag_name.gsub(" ", "-") if tag_name.is_a? String
-  _join([ _ref(_resource_name(args[:tag_service] || "service")), tag_name ], "-")
+def _var(value)
+  "${#{value}}"
 end
 
-def _availability_zone(args, use_subnet = true)
-  zone = args.dup
+def _availability_zone(args, use_subnet = true, prefix = "zone name")
+  zone = args.clone
   zone.delete(:ref_subnet) if use_subnet == false
   if zone.key? :ref_subnet
     _ref_attr_string("subnet", "AvailabilityZone", zone, "subnet")
-  elsif  zone.key? :ref_az
-    _ref_string("az", zone)
-  elsif zone.key? :az
-    zone[:az]
   else
-    ''
+    _ref_string("az", zone, prefix)
   end
 end
 
@@ -337,7 +396,7 @@ def _availability_zones(args, use_subnet = true)
   end
 end
 
-def _timestamp_utc(time = Time.now, type = nil)
+def _timestamp_utc(time = Time.now, type = '')
   format =
     case type
     when "cron"
@@ -348,7 +407,7 @@ def _timestamp_utc(time = Time.now, type = nil)
   time.utc.strftime(format)
 end
 
-def _timestamp_utc_from_string(time, type= nil)
+def _timestamp_utc_from_string(time, type = '')
   _timestamp_utc(Time.strptime(time, "%Y-%m-%d %H:%M"), type)
 end