orchparty 0.1.0

data/exe/orchparty

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+require "thor"
+require "orchparty"
+
+class OrchPartyCommand < Thor
+  desc "generate INPUT_FILE OUTPUT_FILE APPLICATION_NAME", "generates a configuration file for an application"
+  method_option :generator, :aliases => "-g", default: "docker_compose_v1", :desc => "Which generator to take"
+  method_option :aliases => "g"
+  def generate(input_file, output_file, application_name)
+    generator = options[:generator] || "docker_compose_v1"
+    File.write(output_file, Orchparty.send(generator.to_sym, input_file, application_name))
+  end
+end
+
+OrchPartyCommand.start

data/lib/deep_merge.rb

@@ -0,0 +1,106 @@
+module Hashie
+  module Extensions
+    module DeepMergeConcat
+
+      def transform_values
+        result = self.class.new
+        each do |key, value|
+          result[key] = yield(value)
+        end
+        result
+      end
+
+      def transform_values!
+        each do |key, value|
+          self[key] = yield(value)
+        end
+      end
+
+      def transform_keys
+        result = self.class.new
+        each_key do |key|
+          result[yield(key)] = self[key]
+        end
+        result
+      end
+
+      def transform_keys!
+        keys.each do |key|
+          self[yield(key)] = delete(key)
+        end
+        self
+      end
+
+      # Returns a new hash with +self+ and +other_hash+ merged recursively.
+      def deep_merge_concat(other_hash, &block)
+        copy = dup
+        copy.extend(Hashie::Extensions::DeepMergeConcat) unless copy.respond_to?(:deep_merge_concat!)
+        copy.deep_merge_concat!(other_hash, &block)
+      end
+
+      # Returns a new hash with +self+ and +other_hash+ merged recursively.
+      # Modifies the receiver in place.
+      def deep_merge_concat!(other_hash, &block)
+        return self unless other_hash.is_a?(::Hash)
+        _recursive_merge_concat(self, other_hash, &block)
+        self
+      end
+
+      def deep_transform_values(&block)
+        _deep_transform_values_in_object(self, &block)
+      end
+
+      def deep_transform_values!(&block)
+        _deep_transform_values_in_object!(self, &block)
+      end
+
+      private
+
+      def _deep_transform_values_in_object(object, &block)
+        case object
+        when Hash
+          object.each_with_object({}) do |arg, result|
+            key = arg.first
+            value = arg.last
+            result[key] = _deep_transform_values_in_object(value, &block)
+          end
+        when Array
+          object.map {|e| _deep_transform_values_in_object(e, &block) }
+        else
+          yield(object)
+        end
+      end
+
+      def _deep_transform_values_in_object!(object, &block)
+        case object
+        when Hash
+          object.each do |key, value|
+            object[key] = _deep_transform_values_in_object!(value, &block)
+          end
+        when Array
+          object.map! {|e| _deep_transform_values_in_object!(e, &block) }
+        else
+          yield(object)
+        end
+      end
+
+
+      def _recursive_merge_concat(hash, other_hash, &block)
+        other_hash.each do |k, v|
+          hash[k] = if hash.key?(k) && hash[k].is_a?(::Hash) && v.is_a?(::Hash)
+                      _recursive_merge(hash[k], v, &block)
+                    elsif hash.key?(k) && hash[k].is_a?(::Array) && v.is_a?(::Array)
+                      hash[k].concat(v)
+                    else
+                      if hash.key?(k) && block_given?
+                        block.call(k, hash[k], v)
+                      else
+                        v.respond_to?(:deep_dup) ? v.deep_dup : v
+                      end
+                    end
+        end
+        hash
+      end
+    end
+  end
+end

data/lib/hash.rb

@@ -0,0 +1,28 @@
+class HashUtils
+  def self.transform_hash(original, options={}, &block)
+    original.inject({}){|result, (key,value)|
+      value = if (options[:deep] && Hash === value)
+                transform_hash(value, options, &block)
+              else
+                if Array === value
+                  value.map{|v|
+                    if Hash === v
+                      transform_hash(v, options, &block)
+                    else
+                      v
+                    end}
+                else
+                  value
+                end
+              end
+      block.call(result,key,value)
+      result
+    }
+  end
+  # Convert keys to strings, recursively
+  def self.deep_stringify_keys(hash)
+    transform_hash(hash, :deep => true) {|hash, key, value|
+      hash[key.to_s] = value
+    }
+  end
+end

data/lib/orchparty/ast/application.rb

@@ -0,0 +1,7 @@
+module Orchparty
+  class AST
+    class Application < Node
+
+    end
+  end
+end

data/lib/orchparty/ast/mixin.rb

@@ -0,0 +1,6 @@
+module Orchparty
+  class AST
+    class Mixin < Node
+    end
+  end
+end

data/lib/orchparty/ast/root.rb

@@ -0,0 +1,6 @@
+module Orchparty
+  class AST
+    class Root < Node
+    end
+  end
+end

data/lib/orchparty/ast/service.rb

@@ -0,0 +1,6 @@
+module Orchparty
+  class AST
+    class Service < Node
+    end
+  end
+end

data/lib/orchparty/ast.rb

@@ -0,0 +1,16 @@
+require 'hashie'
+
+module Orchparty
+  class AST
+    class Node < ::Hashie::Mash
+      include Hashie::Extensions::DeepMerge
+      include Hashie::Extensions::DeepMergeConcat
+      include Hashie::Extensions::MethodAccess
+      include Hashie::Extensions::Mash::KeepOriginalKeys
+    end
+  end
+end
+require 'orchparty/ast/application'
+require 'orchparty/ast/mixin'
+require 'orchparty/ast/root'
+require 'orchparty/ast/service'

data/lib/orchparty/context.rb

@@ -0,0 +1,12 @@
+module Orchparty
+    class Context < ::Hashie::Mash
+      include Hashie::Extensions::DeepMerge
+      include Hashie::Extensions::DeepMergeConcat
+      include Hashie::Extensions::MethodAccess
+      include Hashie::Extensions::Mash::KeepOriginalKeys
+
+      def context
+        self
+      end
+    end
+end

data/lib/orchparty/dsl_parser.rb

@@ -0,0 +1,186 @@
+require 'pathname'
+require 'docile'
+module Orchparty
+  class DSLParser
+    attr_reader :filename
+
+    def initialize(filename)
+      @filename = filename
+    end
+
+    def parse
+      file_content = File.read(filename)
+      builder = RootBuilder.new
+      builder.instance_eval(file_content, filename)
+      builder.build
+    end
+  end
+
+  class RootBuilder
+
+    def initialize
+      @root = AST::Root.new(applications: {}, mixins: {})
+    end
+
+    def import(rel_file)
+      old_file_path = Pathname.new(caller[0][/[^:]+/]).parent
+      rel_file_path = Pathname.new rel_file
+      new_file_path = old_file_path + rel_file_path
+      file_content = File.read(new_file_path)
+      instance_eval(file_content, new_file_path.expand_path.to_s)
+    end
+
+    def application(name, &block)
+      @root.applications[name] = Docile.dsl_eval(ApplicationBuilder.new(name), &block).build
+      self
+    end
+
+    def mixin(name, &block)
+      @root.mixins[name] = Docile.dsl_eval(MixinBuilder.new(name), &block).build
+      self
+    end
+
+    def build
+      @root
+    end
+  end
+
+  class MixinBuilder
+
+    def initialize(name)
+      @mixin = AST::Mixin.new(name: name, services: {})
+    end
+
+    def service(name, &block)
+      builder  = ServiceBuilder.new(name)
+      builder.instance_eval(&block)
+      @mixin.services[name] = builder._build
+      self
+    end
+
+    def build
+      @mixin
+    end
+  end
+
+  class ApplicationBuilder
+
+    def initialize(name)
+      @application = AST::Application.new(name: name, services: {}, mix: [], mixins: {})
+    end
+
+    def mix(name)
+      @application.mix << name
+    end
+
+    def mixin(name, &block)
+      builder  = CommonBuilder.new
+      builder.instance_eval(&block)
+      @application.mixins[name] = builder._build
+      self
+    end
+
+    def all(&block)
+      builder  = AllBuilder.new
+      builder.instance_eval(&block)
+      @application.all = builder._build
+      self
+    end
+
+    def variables(&block)
+      builder  = HashBuilder.new
+      builder.instance_eval(&block)
+      @application._variables = builder._build
+      self
+    end
+
+    def service(name, &block)
+      builder  = ServiceBuilder.new(name)
+      builder.instance_eval(&block)
+      @application.services[name] = builder._build
+      self
+    end
+
+    def build
+      @application
+    end
+  end
+
+  class HashBuilder
+
+    def initialize
+    end
+
+    def method_missing(_, *values, &block)
+      if block_given?
+        builder = HashBuilder.new
+        builder.instance_eval(&block)
+        value = builder._build
+        if values.count == 1
+          @hash ||= {}
+          @hash[values.first.to_sym] = value
+        else
+          @hash ||= []
+          @hash << value
+        end
+      else
+        value = values.first
+        if value.is_a? Hash
+          @hash ||= {}
+          key, value = value.first
+          @hash[key.to_sym] = value
+        else
+          @hash ||= []
+          @hash << value
+        end
+      end
+      self
+    end
+
+    def _build
+      @hash || {}
+    end
+  end
+
+  class CommonBuilder
+
+    def initialize
+      @service = AST::Service.new(_mix: [])
+    end
+
+    def mix(name)
+      @service._mix << name
+    end
+
+    def method_missing(name, *values, &block)
+      if block_given?
+        builder = HashBuilder.new
+        builder.instance_eval(&block)
+        @service[name] = builder._build
+      else
+        @service[name] = values.first
+      end
+    end
+
+    def _build
+      @service
+    end
+
+    def variables(&block)
+      builder  = HashBuilder.new
+      builder.instance_eval(&block)
+      @service._variables = builder._build
+      self
+    end
+  end
+
+  class AllBuilder < CommonBuilder
+  end
+
+  class ServiceBuilder < CommonBuilder
+
+    def initialize(name)
+      @service = AST::Service.new(name: name, _mix: [])
+    end
+  end
+end

data/lib/orchparty/generators/docker_compose_v1.rb

@@ -0,0 +1,20 @@
+require 'psych'
+module Orchparty
+  module Generators
+    class DockerComposeV1
+      attr_reader :ast
+      def initialize(ast)
+        @ast = ast
+      end
+
+      def output(application_name)
+        Psych.dump(ast.applications[application_name].services.map do |name, service|
+          service = service.to_h
+          service.delete(:mix)
+          [service.delete(:name), HashUtils.deep_stringify_keys(service.to_h)]
+        end.to_h)
+      end
+
+    end
+  end
+end

data/lib/orchparty/generators/docker_compose_v2.rb

@@ -0,0 +1,23 @@
+require 'yaml'
+module Orchparty
+  module Generators
+    class DockerComposeV2
+      attr_reader :ast
+      def initialize(ast)
+        @ast = ast
+      end
+
+      def output(application_name)
+        {"version" => "2", 
+         "services" =>
+        ast.applications[application_name].services.map do |name,service|
+           service = service.to_h
+           service.delete(:mix)
+           [service.delete(:name), HashUtils.deep_stringify_keys(service.to_h)]
+         end.to_h
+        }.to_yaml
+      end
+
+    end
+  end
+end

data/lib/orchparty/generators.rb

@@ -0,0 +1,7 @@
+require 'orchparty/generators/docker_compose_v1'
+require 'orchparty/generators/docker_compose_v2'
+
+module Orchparty
+  module Generators
+  end
+end

data/lib/orchparty/transformations/all.rb

@@ -0,0 +1,19 @@
+
+module Orchparty
+  module Transformations
+    class All
+      def transform(ast)
+        ast.applications.each do |_, application|
+          application.services.transform_values! do |service|
+            if application.all.is_a?(Hash)
+              AST::Service.new(application.all.deep_merge(service)) 
+            else
+              service
+            end
+          end
+        end
+        ast
+      end
+    end
+  end
+end

data/lib/orchparty/transformations/mixin.rb

@@ -0,0 +1,35 @@
+require 'byebug'
+
+module Orchparty
+  module Transformations
+    class Mixin
+      def transform(ast)
+        ast.applications.transform_values! do |application|
+          current = AST::Application.new
+          application.mix.each do |mixin_name|
+            mixin = application.mixins[mixin_name] || ast.mixins[mixin_name]
+            current = current.deep_merge_concat(mixin)
+          end
+          transform_application(current.deep_merge_concat(application), ast)
+        end
+        ast
+      end
+
+      def transform_application(application, ast)
+        application.services = application.services.transform_values! do |service|
+          current = AST::Service.new
+          service.delete(:_mix).each do |mixin|
+            if mixin.include? "."
+              mixin_name, mixin_service_name = mixin.split(".")
+              current = current.deep_merge_concat(ast.mixins[mixin_name].services[mixin_service_name])
+            else
+              current = current.deep_merge_concat(application.mixins[mixin])
+            end
+          end
+          current.deep_merge_concat(service)
+        end
+        application
+      end
+    end
+  end
+end

data/lib/orchparty/transformations/remove_internal.rb

@@ -0,0 +1,16 @@
+
+module Orchparty
+  module Transformations
+    class RemoveInternal
+      def transform(ast)
+        ast.applications.each do |_, application|
+          application.delete_if {|k, _| k.to_s.start_with?("_")}
+          application.services = application.services.each do |_, service|
+            service.delete_if {|k, _| k.to_s.start_with?("_")}
+          end
+        end
+        ast
+      end
+    end
+  end
+end

data/lib/orchparty/transformations/variable.rb

@@ -0,0 +1,38 @@
+
+module Orchparty
+  module Transformations
+    class Variable
+      def transform(ast)
+        ast.applications.each do |_, application|
+          application.services = application.services.each do |_, service|
+            service.deep_transform_values! do |v|
+              if v.respond_to?(:call)
+                eval_value(build_context(application: application, service: service), v) 
+              elsif v.is_a? Array
+                v.map do |v|
+                  if v.respond_to?(:call)
+                    eval_value(build_context(application: application, service: service), v) 
+                  else
+                    v
+                  end
+                end
+              else
+                v
+              end
+            end
+          end
+        end
+        ast
+      end
+
+      def eval_value(context, value)
+        context.instance_exec(&value)
+      end
+
+      def build_context(application:, service:)
+        variables = application._variables.merge(service._variables)
+        Context.new(variables.merge({application: application.merge(application._variables), service: service.merge(service._variables)}))
+      end
+    end
+  end
+end

data/lib/orchparty/transformations.rb

@@ -0,0 +1,16 @@
+require 'ostruct'
+require 'orchparty/transformations/all'
+require 'orchparty/transformations/variable'
+require 'orchparty/transformations/mixin'
+require 'orchparty/transformations/remove_internal'
+
+module Orchparty
+  module Transformations
+    def self.transform(ast)
+      ast = Mixin.new.transform(ast)
+      ast = All.new.transform(ast)
+      ast = Variable.new.transform(ast)
+      ast = RemoveInternal.new.transform(ast)
+    end
+  end
+end

data/lib/orchparty/version.rb

@@ -0,0 +1,3 @@
+module Orchparty
+  VERSION = "0.1.0"
+end

data/lib/orchparty.rb

@@ -0,0 +1,24 @@
+require "deep_merge"
+require "orchparty/version"
+require "orchparty/ast"
+require "orchparty/context"
+require "orchparty/transformations"
+require "orchparty/generators"
+require "orchparty/dsl_parser"
+require "hash"
+
+module Orchparty
+
+
+  def self.ast(input_file)
+    Transformations.transform(Orchparty::DSLParser.new(input_file).parse)
+  end
+
+  def self.docker_compose_v1(input_file, application_name)
+    Orchparty::Generators::DockerComposeV1.new(ast(input_file)).output(application_name)
+  end
+
+  def self.docker_compose_v2(input_file, application_name)
+    Orchparty::Generators::DockerComposeV2.new(ast(input_file)).output(application_name)
+  end
+end

data/orchparty.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'orchparty/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "orchparty"
+  spec.version       = Orchparty::VERSION
+  spec.authors       = ["Jannis Huebl"]
+  spec.email         = ["jannis.huebl@gmail.com"]
+
+  spec.summary       = %q{Write your orchestration configuration with a Ruby DSL that allows you to have mixins, imports and variables.}
+  spec.description   = <<-EOF
+    With this gem you can write docker-compose like orchestration configuration with a Ruby DSL, that supports mixins, imports and variables.!
+    Out of this you can generate docker-compose.yml v1 or v2. 
+  EOF
+  spec.homepage      = "https://orch.party"
+  spec.license       = "LGPL-3.0"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "hashie", "~> 3.5.6"
+  spec.add_dependency "docile", "~> 1.1.5"
+  spec.add_dependency "thor", "~> 0.19.4"
+  spec.add_dependency 'psych', '~> 2.2', '>= 2.2.4'
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+end