manifests-vmc-plugin 0.4.13 → 0.4.14

data/lib/manifests-vmc-plugin/loader/builder.rb

@@ -0,0 +1,34 @@
+module VMCManifests
+  module Builder
+    # parse a manifest and merge with its inherited manifests
+    def build(file)
+      manifest = YAML.load_file file
+
+      Array(manifest["inherit"]).each do |path|
+        manifest = merge_parent(path, manifest)
+      end
+
+      manifest
+    end
+
+    private
+
+    # merge the manifest at `parent_path' into the `child'
+    def merge_parent(parent_path, child)
+      merge_manifest(build(from_manifest(parent_path)), child)
+    end
+
+    # deep hash merge
+    def merge_manifest(parent, child)
+      merge = proc do |_, old, new|
+        if new.is_a?(Hash) && old.is_a?(Hash)
+          old.merge(new, &merge)
+        else
+          new
+        end
+      end
+
+      parent.merge(child, &merge)
+    end
+  end
+end

data/lib/manifests-vmc-plugin/loader/normalizer.rb

@@ -0,0 +1,112 @@
+module VMCManifests
+  module Normalizer
+    MANIFEST_META = ["applications", "properties"]
+
+    def normalize!(manifest)
+      toplevel = toplevel_attributes(manifest)
+
+      apps = manifest["applications"]
+      apps ||= [{}]
+
+      default_paths_to_keys!(apps)
+
+      apps = convert_from_array(apps) 
+
+      merge_toplevel!(toplevel, manifest, apps)
+      normalize_apps!(apps)
+
+      manifest["applications"] = apps
+
+      normalize_paths!(apps)
+
+      keyval = normalize_key_val(manifest)
+      manifest.clear.merge!(keyval)
+
+      nil
+    end
+
+    private
+
+    def normalize_paths!(apps)
+      apps.each do |_, app|
+        app["path"] = from_manifest(app["path"])
+      end
+    end
+
+    def convert_from_array(apps)
+      return apps unless apps.is_a?(Array)
+
+      apps_hash = {}
+      apps.each.with_index do |a, i|
+        apps_hash[i.to_s] = a
+      end
+
+      apps_hash
+    end
+
+    def default_paths_to_keys!(apps)
+      return if apps.is_a?(Array)
+
+      apps.each do |tag, app|
+        app["path"] ||= tag
+      end
+    end
+
+    def normalize_apps!(apps)
+      apps.each_value do |app|
+        normalize_app!(app)
+      end
+    end
+
+    def merge_toplevel!(toplevel, manifest, apps)
+      return if toplevel.empty?
+
+      apps.each do |t, a|
+        apps[t] = toplevel.merge(a)
+      end
+
+      toplevel.each do |k, _|
+        manifest.delete k
+      end
+    end
+
+    def normalize_app!(app)
+      if app["framework"].is_a?(Hash)
+        app["framework"] = app["framework"]["name"]
+      end
+
+      if app.key?("mem")
+        app["memory"] = app.delete("mem")
+      end
+    end
+
+    def toplevel_attributes(manifest)
+      top =
+        manifest.reject { |k, _|
+          MANIFEST_META.include? k
+        }
+
+      # implicit toplevel path of .
+      top["path"] ||= "."
+
+      top
+    end
+
+    def normalize_key_val(val)
+      case val
+      when Hash
+        stringified = {}
+
+        val.each do |k, v|
+          stringified[k.to_sym] = normalize_key_val(v)
+        end
+
+        stringified
+      when Array
+        val.collect { |x| normalize_key_val(x) }
+      else
+        val.to_s
+      end
+    end
+  end
+end

data/lib/manifests-vmc-plugin/loader/resolver.rb

@@ -0,0 +1,75 @@
+module VMCManifests
+  module Resolver
+    def resolve!(manifest, resolver)
+      manifest[:applications].each_value do |v|
+        resolve_lexically(resolver, v, [manifest])
+      end
+
+      resolve_lexically(resolver, manifest, [manifest])
+
+      nil
+    end
+
+    private
+
+    # resolve symbols, with hashes introducing new lexical symbols
+    def resolve_lexically(resolver, val, ctx)
+      case val
+      when Hash
+        val.each_value do |v|
+          resolve_lexically(resolver, v, [val] + ctx)
+        end
+      when Array
+        val.each do |v|
+          resolve_lexically(resolver, v, ctx)
+        end
+      when String
+        val.gsub!(/\$\{([^\}]+)\}/) do
+          resolve(resolver, $1, ctx)
+        end
+      end
+
+      nil
+    end
+
+    # resolve a symbol to its value, and then resolve that value
+    def resolve(resolver, sym, ctx)
+      if found = find_symbol(sym.to_sym, ctx)
+        resolve_lexically(resolver, found, ctx)
+        found
+      elsif dynamic = resolver.resolve_symbol(sym)
+        dynamic
+      else
+        fail("Unknown symbol in manifest: #{sym}")
+      end
+    end
+
+    # search for a symbol introduced in the lexical context
+    def find_symbol(sym, ctx)
+      ctx.each do |h|
+        if val = resolve_in(h, sym)
+          return val
+        end
+      end
+
+      nil
+    end
+
+    # find a value, searching in explicit properties first
+    def resolve_in(hash, *where)
+      find_in_hash(hash, [:properties] + where) ||
+        find_in_hash(hash, where)
+    end
+
+    # helper for following a path of values in a hash
+    def find_in_hash(hash, where)
+      what = hash
+      where.each do |x|
+        return nil unless what.is_a?(Hash)
+        what = what[x]
+      end
+
+      what
+    end
+  end
+end

data/lib/manifests-vmc-plugin/loader.rb

@@ -0,0 +1,32 @@
+require "manifests-vmc-plugin/loader/builder"
+require "manifests-vmc-plugin/loader/normalizer"
+require "manifests-vmc-plugin/loader/resolver"
+
+module VMCManifests
+  class Loader
+    include Builder
+    include Normalizer
+    include Resolver
+
+    def initialize(file, resolver)
+      @file = file
+      @resolver = resolver
+    end
+
+    def manifest
+      info = build(@file)
+      normalize! info
+      resolve! info, @resolver
+      info
+    end
+
+    private
+
+    # expand a path relative to the manifest file's directory
+    def from_manifest(path)
+      return path unless @file
+
+      File.expand_path(path, File.dirname(@file))
+    end
+  end
+end

data/lib/manifests-vmc-plugin/plugin.rb

@@ -4,29 +4,13 @@ require "vmc/plugin"
 require "manifests-vmc-plugin"
 
 
-class Manifests < VMC::CLI
+class Manifests < VMC::App::Base
   include VMCManifests
 
-  @@showed_manifest_usage = false
-
   option :manifest, :aliases => "-m", :value => :file,
     :desc => "Path to manifest file to use"
 
 
-  def no_apps
-    fail "No applications or manifest to operate on."
-  end
-
-  def show_manifest_usage
-    return if @@showed_manifest_usage
-
-    path = Pathname.new(manifest_file).relative_path_from(Pathname.pwd)
-    line "Using manifest file #{c(path, :name)}"
-    line
-
-    @@showed_manifest_usage = true
-  end
-
   # basic commands that, when given no name, act on the
   # app(s) described by the manifest, in dependency-order
   [ :start, :restart, :instances, :logs, :env,
@@ -104,17 +88,21 @@ class Manifests < VMC::CLI
     :desc => "Reset to values in the manifest"
 
   around(:push) do |push, input|
-    single =
+    particular =
       if input.given?(:name)
         path = File.expand_path(input[:name])
         find_by = File.exists?(path) ? path : input[:name]
 
-        app_info(find_by, input.without(:name))
+        find_apps(find_by)
+      else
+        []
       end
 
-    single ||= app_info(Dir.pwd, input)
+    if particular.empty?
+      particular = find_apps(Dir.pwd)
+    end
 
-    apps = single ? [single] : all_apps(input)
+    apps = particular.empty? ? all_apps : particular
 
     if apps.empty?
       with_filters(
@@ -127,7 +115,7 @@ class Manifests < VMC::CLI
     else
       show_manifest_usage
 
-      apps.each do |app|
+      spaced(apps) do |app|
         with_filters(
             :push => {
               :create_app => proc { |a|
@@ -141,7 +129,7 @@ class Manifests < VMC::CLI
             }) do
           # only set inputs if creating app or updating with --reset
           if input[:reset] || !client.app_by_name(app[:name])
-            app_input = input.merge_given(app)
+            app_input = input.rebase_given(app)
           else
             app_input = input.merge(:path => from_manifest(app[:path]))
           end

data/lib/manifests-vmc-plugin/version.rb

@@ -1,3 +1,3 @@
 module VMCManifests
-  VERSION = "0.4.13"
+  VERSION = "0.4.14"
 end

data/lib/manifests-vmc-plugin.rb

@@ -1,9 +1,14 @@
 require "yaml"
 require "set"
 
+require "manifests-vmc-plugin/loader"
+
+
 module VMCManifests
   MANIFEST_FILE = "manifest.yml"
 
+  @@showed_manifest_usage = false
+
   def manifest
     return @manifest if @manifest
 
@@ -13,7 +18,7 @@ module VMCManifests
   end
 
   def save_manifest(save_to = manifest_file)
-    raise "No manifest to save!" unless @manifest
+    fail "No manifest to save!" unless @manifest
 
     File.open(save_to, "w") do |io|
       YAML.dump(@manifest, io)
@@ -44,250 +49,67 @@ module VMCManifests
     @manifest_file = File.expand_path(path)
   end
 
-  # convert any deprecated structuring to the modern format
-  def simplify_info(info)
-    if info["framework"].is_a?(Hash)
-      info["framework"] = info["framework"]["name"]
-    end
-  end
-
   # load and resolve a given manifest file
   def load_manifest(file)
-    manifest = build_manifest(file)
-    resolve_manifest(manifest)
-
-    # single-app manifest
-    simplify_info(manifest)
-
-    if apps = manifest["applications"]
-      apps.each do |path, info|
-        simplify_info(info)
-      end
-    end
-
-    manifest
-  end
-
-  # parse a manifest and merge with its inherited manifests
-  def build_manifest(file)
-    manifest = YAML.load_file file
-
-    Array(manifest["inherit"]).each do |p|
-      manifest = merge_parent(manifest, p)
-    end
-
-    manifest
-  end
-
-  # merge the manifest at `path' into the `child'
-  def merge_parent(child, path)
-    merge_manifest(child, build_manifest(from_manifest(path)))
-  end
-
-  # deep hash merge
-  def merge_manifest(child, parent)
-    merge = proc do |_, old, new|
-      if new.is_a?(Hash) and old.is_a?(Hash)
-        old.merge(new, &merge)
-      else
-        new
-      end
-    end
-
-    parent.merge(child, &merge)
-  end
-
-  # resolve symbols in a manifest
-  def resolve_manifest(manifest)
-    if apps = manifest["applications"]
-      apps.each_value do |v|
-        resolve_lexically(v, [manifest])
-      end
-    end
-
-    resolve_lexically(manifest, [manifest])
-
-    nil
+    Loader.new(file, self).manifest
   end
 
-  # resolve symbols, with hashes introducing new lexical symbols
-  def resolve_lexically(val, ctx)
-    case val
-    when Hash
-      val.each_value do |v|
-        resolve_lexically(v, [val] + ctx)
-      end
-    when Array
-      val.each do |v|
-        resolve_lexically(v, ctx)
-      end
-    when String
-      val.gsub!(/\$\{([^\}]+)\}/) do
-        resolve_symbol($1, ctx)
-      end
-    end
-
-    nil
-  end
-
-  # resolve a symbol to its value, and then resolve that value
-  def resolve_symbol(sym, ctx)
+  # dynamic symbol resolution
+  def resolve_symbol(sym)
     case sym
     when "target-url"
-      target_url(ctx)
+      client_target
 
     when "target-base"
-      target_base(ctx)
+      client_target.sub(/^[^\.]+\./, "")
 
     when "random-word"
-      "%04x" % [rand(0x0100000)]
+      sprintf("%04x", rand(0x0100000))
 
     when /^ask (.+)/
       ask($1)
-
-    else
-      found = find_symbol(sym, ctx)
-
-      if found
-        resolve_lexically(found, ctx)
-        found
-      else
-        raise("Unknown symbol in manifest: #{sym}")
-      end
-    end
-  end
-
-  # get the target url from either the manifest or the current client
-  def target_url(ctx = [])
-    find_symbol("target", ctx) || client_target
-  end
-
-  def target_base(ctx = [])
-    target_url(ctx).sub(/^[^\.]+\./, "")
-  end
-
-  # search for a symbol introduced in the lexical context
-  def find_symbol(sym, ctx)
-    ctx.each do |h|
-      if val = resolve_in(h, sym)
-        return val
-      end
-    end
-
-    nil
-  end
-
-  # find a value, searching in explicit properties first
-  def resolve_in(hash, *where)
-    find_in_hash(hash, ["properties"] + where) ||
-      find_in_hash(hash, where)
-  end
-
-  # helper for following a path of values in a hash
-  def find_in_hash(hash, where)
-    what = hash
-    where.each do |x|
-      return nil unless what.is_a?(Hash)
-      what = what[x]
-    end
-
-    what
-  end
-
-  MANIFEST_META = ["applications", "properties"]
-
-  def toplevel_attributes
-    if m = manifest
-      m.reject do |k, _|
-        MANIFEST_META.include? k
-      end
     end
   end
 
-  def app_by_name(name, input = nil)
-    return unless manifest
-
-    if apps = manifest["applications"]
-      manifest["applications"].find do |path, info|
-        info["name"] == name
-      end
-    elsif name == manifest["name"]
-      [".", toplevel_attributes]
-    end
+  # find an app by its unique tag
+  def app_by_tag(tag)
+    manifest[:applications][tag]
   end
 
-  def app_by_path(find_path)
-    return unless manifest
-
-    if apps = manifest["applications"]
-      full_path = from_manifest(find_path)
-
-      manifest["applications"].find do |path, info|
-        from_manifest(path) == full_path
-      end
-    elsif find_path == "."
-      [".", toplevel_attributes]
+  # find apps by an identifier, which may be either a tag, a name, or a path
+  def find_apps(identifier)
+    if app = app_by_tag(identifier)
+      return [app]
     end
-  end
-
-  def app_info(path_or_name, input = nil)
-    path, info = app_by_name(path_or_name) || app_by_path(path_or_name)
-    return unless info
 
-    data = { :path => path }
-
-    toplevel_attributes.merge(info).each do |k, v|
-      name = k.to_sym
-
-      if name == :mem
-        name = :memory
-      end
+    apps = apps_by(:name, identifier)
 
-      data[name] = input && input.given(name) || v
+    if apps.empty?
+      apps = apps_by(:path, from_manifest(identifier))
     end
 
-    data[:path] = from_manifest(data[:path])
-
-    data
+    apps
   end
 
   # call a block for each app in a manifest (in dependency order), setting
   # inputs for each app
-  def each_app(input = nil, &blk)
-    if manifest and all_apps = manifest["applications"]
-      use_inputs = all_apps.size == 1
-
-      ordered_by_deps(all_apps).each do |path|
-        yield app_info(path, use_inputs && input)
-      end
-
-      true
-
-    # manually created or legacy single-app manifest
-    elsif toplevel_attributes
-      yield app_info(".", input)
-
-      true
+  def each_app(&blk)
+    return unless manifest
 
-    else
-      false
-    end
+    ordered_by_deps(manifest[:applications]).each(&blk)
   end
 
-  def all_apps(input = nil)
+  # return all the apps described by the manifest, in dependency order
+  def all_apps
     apps = []
 
-    each_app(input) do |app|
+    each_app do |app|
       apps << app
     end
 
     apps
   end
 
-  def no_apps
-    fail "No applications or manifest to operate on."
-  end
-
   # like each_app, but only acts on apps specified as paths instead of names
   #
   # returns the names that were not paths
@@ -307,10 +129,12 @@ module VMCManifests
     in_manifest = []
 
     if names_or_paths.empty?
-      if app = app_info(Dir.pwd, input)
-        in_manifest << app
+      specific = find_apps(Dir.pwd)
+
+      if !specific.empty?
+        in_manifest += apps
       else
-        each_app(input, &blk)
+        each_app(&blk)
         return []
       end
     end
@@ -320,8 +144,10 @@ module VMCManifests
       if x.is_a?(String)
         path = File.expand_path(x)
 
-        if app = app_info(File.exists?(path) ? path : x, input)
-          in_manifest << app
+        apps = find_apps(File.exists?(path) ? path : x)
+
+        if !apps.empty?
+          in_manifest += apps
         elsif app = client.app_by_name(x)
           external << app
         else
@@ -339,9 +165,33 @@ module VMCManifests
     external
   end
 
-
   private
 
+  def show_manifest_usage
+    return if @@showed_manifest_usage
+
+    path = Pathname.new(manifest_file).relative_path_from(Pathname.pwd)
+    line "Using manifest file #{c(path, :name)}"
+    line
+
+    @@showed_manifest_usage = true
+  end
+
+  def no_apps
+    fail "No applications or manifest to operate on."
+  end
+
+  def apps_by(attr, val)
+    found = []
+    manifest[:applications].each do |tag, info|
+      if info[attr] == val
+        found << info
+      end
+    end
+
+    found
+  end
+
   # expand a path relative to the manifest file's directory
   def from_manifest(path)
     File.expand_path(path, File.dirname(manifest_file))
@@ -349,35 +199,26 @@ module VMCManifests
 
   # sort applications in dependency order
   # e.g. if A depends on B, B will be listed before A
-  def ordered_by_deps(apps, abspaths = nil, processed = Set[])
-    unless abspaths
-      abspaths = {}
-      apps.each do |p, i|
-        abspaths[from_manifest(p)] = i
-      end
-    end
-
+  def ordered_by_deps(apps, processed = Set[])
     ordered = []
-    apps.each do |path, info|
-      epath = from_manifest(path)
+    apps.each do |tag, info|
+      next if processed.include?(tag)
 
-      if deps = info["depends-on"]
+      if deps = Array(info[:"depends-on"])
         dep_apps = {}
         deps.each do |dep|
-          edep = from_manifest(dep)
-
-          raise "Circular dependency detected." if processed.include? edep
-
-          dep_apps[dep] = abspaths[edep]
+          dep = dep.to_sym
+          fail "Circular dependency detected." if processed.include? dep
+          dep_apps[dep] = apps[dep]
         end
 
-        processed.add(epath)
+        processed.add(tag)
 
-        ordered += ordered_by_deps(dep_apps, abspaths, processed)
-        ordered << path
-      elsif not processed.include? epath
-        ordered << path
-        processed.add(epath)
+        ordered += ordered_by_deps(dep_apps, processed)
+        ordered << info
+      else
+        ordered << info
+        processed.add(tag)
       end
     end
 
@@ -431,7 +272,7 @@ module VMCManifests
       with_progress("Saving to #{c("manifest.yml", :name)}") do
         File.open("manifest.yml", "w") do |io|
           YAML.dump(
-            { "applications" => { "." => meta } },
+            { "applications" => [meta] },
             io)
         end
       end
@@ -470,19 +311,19 @@ module VMCManifests
         to_bind << instance
       else
         service = services.find { |s|
-          s.label == (svc["label"] || svc["type"] || svc["vendor"]) &&
-            (!svc["version"] || s.version == svc["version"]) &&
-            (s.provider == (svc["provider"] || "core"))
+          s.label == (svc[:label] || svc[:type] || svc[:vendor]) &&
+            (!svc[:version] || s.version == svc[:version]) &&
+            (s.provider == (svc[:provider] || "core"))
         }
 
         fail "Unknown service: #{svc.inspect}." unless service
 
         if v2?
           plan = service.service_plans.find { |p|
-            p.name == (svc["plan"] || "D100")
+            p.name == (svc[:plan] || "D100")
           }
 
-          fail "Unknown service plan: #{svc["plan"]}." unless plan
+          fail "Unknown service plan: #{svc[:plan]}." unless plan
         end
 
         invoke :create_service,
@@ -500,32 +341,4 @@ module VMCManifests
         :instance => i
     end
   end
-
-  def megabytes(str)
-    if str =~ /T$/i
-      str.to_i * 1024 * 1024
-    elsif str =~ /G$/i
-      str.to_i * 1024
-    elsif str =~ /M$/i
-      str.to_i
-    elsif str =~ /K$/i
-      str.to_i / 1024
-    else # assume megabytes
-      str.to_i
-    end
-  end
-
-  def human_size(num, precision = 1)
-    sizes = ["G", "M", "K"]
-    sizes.each.with_index do |suf, i|
-      pow = sizes.size - i
-      unit = 1024 ** pow
-      if num >= unit
-        return format("%.#{precision}f%s", num / unit, suf)
-      end
-    end
-
-    format("%.#{precision}fB", num)
-  end
-
 end

data/spec/normalizer_spec.rb

@@ -0,0 +1,125 @@
+require "spec_helper"
+
+require "manifests-vmc-plugin/loader"
+
+
+describe VMCManifests::Normalizer do
+  let(:manifest) { {} }
+  let(:loader) { VMCManifests::Loader.new(nil, nil) }
+
+  describe '#normalize!' do
+    subject do
+      loader.normalize!(manifest)
+      manifest
+    end
+
+    context 'with a manifest where the applications have no path set' do
+      let(:manifest) { { "applications" => { "." => { "name" => "foo" } } } }
+
+      it "sets the path to their tag, assuming it's a path" do
+        expect(subject).to eq(
+          :applications => { :"." => { :name => "foo", :path => "." } })
+      end
+    end
+
+    context 'with a manifest with toplevel attributes' do
+      context 'and properties' do
+        let(:manifest) {
+          { "name" => "foo", "properties" => { "fizz" => "buzz" } }
+        }
+
+        it 'keeps the properties at the toplevel' do
+          expect(subject).to eq(
+            :applications => { :"0" => { :name => "foo", :path => "." } },
+            :properties => { :fizz => "buzz" })
+        end
+      end
+
+      context 'and no applications' do
+        context 'and no path' do
+          let(:manifest) { { "name" => "foo" } }
+
+          it 'adds it as an application with path .' do
+            expect(subject).to eq(
+              :applications => { :"0" => { :name => "foo", :path => "." } })
+          end
+        end
+
+        context 'and a path' do
+          let(:manifest) { { "name" => "foo", "path" => "./foo" } }
+
+          it 'adds it as an application with the proper tag and path' do
+            expect(subject).to eq(
+              :applications => {
+                :"0" => { :name => "foo", :path => "./foo" }
+              })
+          end
+        end
+      end
+
+      context 'and applications' do
+        let(:manifest) {
+          { "runtime" => "ruby19",
+            "applications" => {
+              "./foo" => { "name" => "foo" },
+              "./bar" => { "name" => "bar" },
+              "./baz" => { "name" => "baz", "runtime" => "ruby18" }
+            }
+          }
+        }
+
+        it "merges the toplevel attributes into the applications" do
+          expect(subject).to eq(
+            :applications => {
+              :"./foo" =>
+                { :name => "foo", :path => "./foo", :runtime => "ruby19" },
+
+              :"./bar" =>
+                { :name => "bar", :path => "./bar", :runtime => "ruby19" },
+
+              :"./baz" =>
+                { :name => "baz", :path => "./baz", :runtime => "ruby18" }
+            })
+        end
+      end
+    end
+
+    context 'with a manifest where applications is an array' do
+      let(:manifest) { { "applications" => [{ "name" => "foo" }] } }
+
+      it 'converts the array to a hash, with the path as .' do
+        expect(subject).to eq(
+          :applications => { :"0" => { :name => "foo", :path => "." } })
+      end
+    end
+  end
+
+  describe '#normalize_app!' do
+    subject do
+      loader.send(:normalize_app!, manifest)
+      manifest
+    end
+
+    context 'with framework as a hash' do
+      let(:manifest) {
+        { "name" => "foo",
+          "framework" => { "name" => "ruby19", "mem" => "64M" }
+        }
+      }
+
+      it 'sets the framework to just the name' do
+        expect(subject).to eq(
+          "name" => "foo",
+          "framework" => "ruby19")
+      end
+    end
+
+    context 'with mem instead of memory' do
+      let(:manifest) { { "name" => "foo", "mem" => "128M" } }
+
+      it 'renames mem to memory' do
+        expect(subject).to eq("name" => "foo", "memory" => "128M")
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require "cfoundry"
+require "vmc"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: manifests-vmc-plugin
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 19
   prerelease: 
   segments: 
   - 0
   - 4
-  - 13
-  version: 0.4.13
+  - 14
+  version: 0.4.14
 platform: ruby
 authors: 
 - Alex Suraci
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-11-20 00:00:00 -08:00
+date: 2012-11-30 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -34,6 +34,51 @@ dependencies:
         version: 0.4.0
   type: :runtime
   version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: vmc
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 15
+        segments: 
+        - 0
+        - 4
+        - 0
+        version: 0.4.0
+  type: :development
+  version_requirements: *id004
 description: 
 email: 
 - asuraci@vmware.com
@@ -48,7 +93,13 @@ files:
 - lib/manifests-vmc-plugin/version.rb
 - lib/manifests-vmc-plugin/errors.rb
 - lib/manifests-vmc-plugin/plugin.rb
+- lib/manifests-vmc-plugin/loader.rb
+- lib/manifests-vmc-plugin/loader/normalizer.rb
+- lib/manifests-vmc-plugin/loader/resolver.rb
+- lib/manifests-vmc-plugin/loader/builder.rb
 - lib/manifests-vmc-plugin.rb
+- spec/spec_helper.rb
+- spec/normalizer_spec.rb
 has_rdoc: true
 homepage: http://cloudfoundry.com/
 licenses: []
@@ -83,5 +134,6 @@ rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Cloud Foundry automation via manifest documents.
-test_files: []
-
+test_files: 
+- spec/spec_helper.rb
+- spec/normalizer_spec.rb