jdc 0.2.1.pre → 0.2.1

data/lib/jdc/spacing.rb

@@ -1,89 +0,0 @@
-module JDC 
-  module Spacing
-    @@indentation = 0
-
-    def indented
-      @@indentation += 1
-      yield
-    ensure
-      @@indentation -= 1
-    end
-
-    def line(msg = "")
-      return puts "" if msg.empty?
-
-      start_line(msg)
-      puts ""
-    end
-
-    def start_line(msg)
-      print "  " * @@indentation unless quiet?
-      print msg
-    end
-
-    def lines(blob)
-      blob.each_line do |line|
-        start_line(line)
-      end
-
-      line
-    end
-
-    def quiet?
-      false
-    end
-
-    def spaced(vals)
-      num = 0
-      vals.each do |val|
-        line unless quiet? || num == 0
-        yield val
-        num += 1
-      end
-    end
-
-    def tabular(*rows)
-      spacings = []
-      rows.each do |row|
-        next unless row
-
-        row.each.with_index do |col, i|
-          next unless col
-
-          width = text_width(col)
-
-          if !spacings[i] || width > spacings[i]
-            spacings[i] = width
-          end
-        end
-      end
-
-      columns = spacings.size
-      rows.each do |row|
-        next unless row
-
-        row.each.with_index do |col, i|
-          next unless col
-
-          start_line justify(col, spacings[i])
-          print "   " unless i + 1 == columns
-        end
-
-        line
-      end
-    end
-
-    def trim_escapes(str)
-      str.gsub(/\e\[\d+m/, "")
-    end
-
-    def text_width(str)
-      trim_escapes(str).size
-    end
-
-    def justify(str, width)
-      trimmed = trim_escapes(str)
-      str.ljust(width + (str.size - trimmed.size))
-    end
-  end
-end

data/lib/jdc/spec_helper.rb

@@ -1 +0,0 @@
-require File.expand_path("../../../spec/spec_helper", __FILE__)

data/lib/jdc/test_support.rb

@@ -1,6 +0,0 @@
-module JDC::TestSupport
-end
-
-Dir[File.expand_path('../../../spec/support/**/*.rb', __FILE__)].each do |file|
-  require file
-end

data/lib/jdc/version.rb

@@ -1,3 +0,0 @@
-module JDC 
-  VERSION = "0.2.1".freeze
-end

data/lib/manifests/errors.rb

@@ -1,35 +0,0 @@
-require "jdc/errors"
-
-module JDCManifests
-  class InvalidManifest < JDC::UserFriendlyError
-    attr_reader :file
-
-    def initialize(file)
-      @file = file
-    end
-
-    def to_s
-      "Manifest file '#{@file}' is malformed."
-    end
-  end
-
-  class CircularDependency < JDC::UserFriendlyError
-    def initialize(app)
-      @app = app
-    end
-
-    def to_s
-      "Circular dependency in application '#@app'"
-    end
-  end
-
-  class UnknownSymbol < JDC::UserFriendlyError
-    def initialize(sym)
-      @sym = sym
-    end
-
-    def to_s
-      "Undefined symbol in manifest: '#@sym'"
-    end
-  end
-end

data/lib/manifests/loader/builder.rb

@@ -1,39 +0,0 @@
-require "manifests/errors"
-
-module JDCManifests
-  module Builder
-    # parse a manifest and merge with its inherited manifests
-    def build(file)
-      manifest = YAML.load_file file
-      raise JDCManifests::InvalidManifest.new(file) unless manifest
-
-      Array(manifest["inherit"]).each do |path|
-        manifest = merge_parent(path, manifest)
-      end
-
-      manifest.delete("inherit")
-
-      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/loader/normalizer.rb

@@ -1,145 +0,0 @@
-module JDCManifests
-  module Normalizer
-    MANIFEST_META = ["applications", "properties"]
-
-    def normalize!(manifest)
-      toplevel = toplevel_attributes(manifest)
-
-      apps = manifest["applications"]
-      apps ||= [{}]
-
-      default_paths_to_keys!(apps)
-
-      apps = convert_to_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_to_array(apps)
-      return apps if apps.is_a?(Array)
-
-      ordered_by_deps(apps)
-    end
-
-    # sort applications in dependency order
-    # e.g. if A depends on B, B will be listed before A
-    def ordered_by_deps(apps, processed = Set[])
-      ordered = []
-      apps.each do |tag, info|
-        next if processed.include?(tag)
-
-        if deps = Array(info["depends-on"])
-          dep_apps = {}
-          deps.each do |dep|
-            dep_apps[dep] = apps[dep]
-          end
-
-          processed.add(tag)
-
-          ordered += ordered_by_deps(dep_apps, processed)
-          ordered << info
-        else
-          ordered << info
-          processed.add(tag)
-        end
-      end
-
-      ordered.each { |app| app.delete("depends-on") }
-
-      ordered
-    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 do |app|
-        normalize_app!(app)
-      end
-    end
-
-    def merge_toplevel!(toplevel, manifest, apps)
-      return if toplevel.empty?
-
-      apps.collect! do |a|
-        toplevel.merge(a)
-      end
-
-      toplevel.each do |k, _|
-        manifest.delete k
-      end
-    end
-
-    def normalize_app!(app)
-      if app.key?("mem")
-        app["memory"] = app.delete("mem")
-      end
-
-      if app.key?("url") && app["url"].nil?
-        app["url"] = "none"
-      end
-
-      if app.key?("subdomain")
-        if app.key?("host")
-          app.delete("subdomain")
-        else
-          app["host"] = app.delete("subdomain")
-        end
-      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) }
-      when nil
-        nil
-      else
-        val.to_s
-      end
-    end
-  end
-end

data/lib/manifests/loader/resolver.rb

@@ -1,79 +0,0 @@
-module JDCManifests
-  module Resolver
-    def resolve(manifest, resolver)
-      new = {}
-
-      new[:applications] = manifest[:applications].collect do |app|
-        resolve_lexically(resolver, app, [manifest])
-      end
-
-      resolve_lexically(resolver, new, [new])
-    end
-
-    private
-
-    # resolve symbols, with hashes introducing new lexical symbols
-    def resolve_lexically(resolver, val, ctx)
-      case val
-      when Hash
-        new = {}
-
-        val.each do |k, v|
-          new[k] = resolve_lexically(resolver, v, [val] + ctx)
-        end
-
-        new
-      when Array
-        val.collect do |v|
-          resolve_lexically(resolver, v, ctx)
-        end
-      when String
-        val.gsub(/\$\{([^\}]+)\}/) do
-          resolve_symbol(resolver, $1, ctx)
-        end
-      else
-        val
-      end
-    end
-
-    # resolve a symbol to its value, and then resolve that value
-    def resolve_symbol(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/loader.rb

@@ -1,31 +0,0 @@
-require "manifests/loader/builder"
-require "manifests/loader/normalizer"
-require "manifests/loader/resolver"
-
-module JDCManifests
-  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
-    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