dployr 0.0.1

data/lib/dployr/config/instance.rb

@@ -0,0 +1,99 @@
+require 'dployr/utils'
+
+module Dployr
+  module Config
+    class Instance
+
+      include Dployr::Utils
+
+      attr_reader :attributes, :providers, :authentication, :scripts, :parents
+      attr_accessor :name
+
+      def initialize
+        @name = 'unnamed'
+        @attributes = {}
+        @authentication = {}
+        @scripts = []
+        @providers = {}
+        @parents = []
+        yield self if block_given?
+      end
+
+      def configure(config)
+        if config.is_a? Hash
+          set_attributes get_by_key config, :attributes if has config, :attributes
+          set_providers get_by_key config, :providers if has config, :providers
+          set_auth get_by_key config, :authentication if has config, :authentication
+          set_scripts get_by_key config, :scripts if has config, :scripts
+          set_parents get_by_key config, :extends if has config, :extends
+        end
+      end
+
+      def get_values
+        deep_copy({
+          attributes: @attributes,
+          authentication: @authentication,
+          scripts: @scripts,
+          providers: @providers,
+          parents: @parents
+        })
+      end
+
+      def set_attribute(key, value)
+        @attributes[key] = value
+      end
+
+      def get_attribute(key)
+        @attributes[key]
+      end
+
+      def remove_attribute(key)
+        @attributes.remove key
+      end
+
+      def add_script(script)
+        @scripts << script if script.is_a? Hash
+      end
+
+      def add_auth(key, value)
+        @authentication[key] = value if key
+      end
+
+      def add_provider(name, provider)
+        @providers[name] = provider if provider.is_a? Hash
+      end
+
+      def get_provider(index)
+        @providers[index]
+      end
+
+      def remove_provider(provider)
+        @providers.delete provider
+      end
+
+      private
+
+      def set_auth(auth)
+        @authentication = auth if auth.is_a? Hash
+      end
+
+      def set_providers(providers)
+        @providers = providers if providers.is_a? Hash
+      end
+
+      def set_scripts(scripts)
+        @scripts = scripts if scripts.is_a? Array
+      end
+
+      def set_attributes(attrs)
+        @attributes = attrs if attrs.is_a? Hash
+      end
+
+      def set_parents(parents)
+        parents = [ parents ] if parents.is_a? String
+        @parents.concat parents if parents.is_a? Array
+      end
+
+    end
+  end
+end

data/lib/dployr/configuration.rb

@@ -0,0 +1,163 @@
+require 'dployr/utils'
+
+module Dployr
+  class Configuration
+
+    include Dployr::Utils
+
+    attr_reader :default, :instances
+
+    def initialize
+      @default = nil
+      @config = nil
+      @instances = []
+      @merged = false
+      yield self if block_given?
+    end
+
+    def exists?
+      (!@default.nil? or @instances.length >= 1)
+    end
+
+    def set_default(config)
+      @default = create_instance('default', config) if config.is_a? Hash
+    end
+
+    def add_instance(name, config)
+      @instances << create_instance(name, config) if config.is_a? Hash
+      @instances.last
+    end
+
+    def get_instance(name)
+      @instances.each { |i| return i if i.name.to_s == name.to_s }
+      nil
+    end
+
+    def get_config(name, attributes = {})
+      instance = get_instance name
+      raise ArgumentError.new "Instance '#{name.to_s}' do not exists" if instance.nil?
+      replace_variables merge_config(instance), replace_variables(attributes)
+    end
+
+    def get_config_all(attributes = {})
+      config = []
+      @instances.each do |i|
+        config << get_config(i.name, attributes)
+      end
+      puts config
+      config
+    end
+
+    def get_provider(name, provider, attributes = {})
+      config = get_config name, attributes
+      if config.is_a? Hash
+        config = config[get_real_key(config, :providers)]
+        if config.is_a? Hash
+          return config[get_real_key(config, provider)]
+        end
+      end
+    end
+
+    def get_region(name, provider, region, attributes = {})
+      provider = get_provider name, provider, attributes
+      if provider.is_a? Hash
+        regions = get_by_key provider, :regions
+        return get_by_key regions, region
+      end
+    end
+
+    def each(type = :providers)
+      config = get_config_all
+      config.each { |i| yield i if block_given? }
+    end
+
+    private
+
+    def create_instance(name = 'unnamed', config)
+      Dployr::Config::Instance.new do |i|
+        i.name = name
+        i.configure config
+      end if config.is_a? Hash
+    end
+
+    def replace_variables(config, attributes = {})
+      if config.is_a? Hash
+        attrs = get_all_attributes config
+        attrs.merge! attributes if attributes.is_a? Hash
+        traverse_map config do |str, key|
+          replace_env_vars template(str, attrs)
+        end
+      end
+      config
+    end
+
+    def get_all_attributes(config)
+      attrs = {}
+      config.each do |key, value|
+        if key.to_sym == :attributes
+          attrs.merge! value if value.is_a? Hash
+        elsif value.is_a? Hash
+          attrs.merge! get_all_attributes value
+        end
+      end if config.is_a? Hash
+      attrs
+    end
+
+    def merge_config(instance)
+      merge_providers merge_parents merge_defaults instance.get_values
+    end
+
+    def merge_defaults(config)
+      config = deep_merge @default.get_values, config if @default
+      config
+    end
+
+    def merge_providers(config)
+      key = get_real_key config, :providers
+      if config[key].is_a? Hash
+        config[key].each do |name, provider|
+          provider = replace_keywords 'provider', name, inherit_config(provider, config)
+          regions = get_by_key provider, get_real_key(provider, :regions)
+          regions.each do |name, region|
+            regions[name] = replace_keywords 'region', name, inherit_config(region, provider)
+          end if regions
+        end
+      end
+      config
+    end
+
+    def replace_keywords(keyword, value, hash)
+      traverse_map hash do |str|
+        str.gsub "${#{keyword.to_s}}", value.to_s
+      end if hash.is_a? Hash
+    end
+
+    def inherit_config(child, parent)
+      keys = [ :attributes, :scripts, :authentication ]
+      keys.each do |type|
+        current = deep_copy get_by_key(parent, type)
+        source = get_by_key child, type
+        if type == :scripts
+          current = [] unless current.is_a? Array
+          current.concat source if source.is_a? Array
+          current = current.compact.uniq
+        else
+          current = {} unless current.is_a? Hash
+          current = deep_merge current, source
+        end
+        child[type] = current if current.length
+      end
+      child
+    end
+
+    def merge_parents(child)
+      parents = get_by_key child, :parents
+      parents = [ parents ] if parents.is_a? String
+      parents.each do |parent|
+        parent = get_instance parent
+        child = deep_merge parent.get_values, child unless parent.nil?
+      end if parents.is_a? Array
+      child
+    end
+  end
+end

data/lib/dployr/init.rb

@@ -0,0 +1,72 @@
+require 'dployr/configuration'
+require 'dployr/config/file_utils'
+
+module Dployr
+
+  module_function
+
+  def configure(attributes = {})
+    dployr = Init::instance
+    yield dployr if block_given?
+  end
+
+  def config
+    dployr = Init::instance
+    dployr.config if dployr
+  end
+
+  def load(file_path)
+    if Dployr::Config::FileUtils.yaml_file? file_path
+      Dployr::Config::FileUtils.read_yaml file_path
+    else
+      load file_path
+    end
+  end
+
+  class Init
+
+    include Dployr::Config::FileUtils
+
+    attr_reader :file_path, :config
+
+    @@instance = nil
+
+    def initialize(attributes = {})
+      @@instance = self
+      @attributes = attributes
+      @config = Dployr::Configuration.new
+      @file_path = discover
+      load_file @file_path
+    end
+
+    def self.instance
+      @@instance
+    end
+
+    private
+
+    def load_file(file_path)
+      if file_path.is_a? String
+        if yaml_file? file_path
+          load_yaml file_path
+        else
+          load file_path
+        end
+      end
+    end
+
+    def load_yaml(file_path)
+      config = read_yaml file_path
+      if config.is_a? Hash
+        config.each do |name, config|
+          if name == 'default'
+            @config.set_default config
+          else
+            @config.add_instance name, config
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/dployr/logger.rb

@@ -0,0 +1,11 @@
+module Dployr
+  module Logger
+
+    module_function
+
+    def log(*msg)
+      msg.each { |msg| puts msg }
+    end
+
+  end
+end

data/lib/dployr/utils.rb

@@ -0,0 +1,127 @@
+module Dployr
+  module Utils
+
+    MERGE_OPTIONS = { merge_hash_arrays: false, knockout_prefix: false }
+
+    module_function
+
+    def has(hash, key)
+      (hash.is_a? Hash and
+        (hash.key? key or hash.key? key.to_sym or hash.key? key.to_s))
+    end
+
+    def get_by_key(hash, key)
+      if hash.is_a? Hash
+        hash[key] or hash[key.to_sym] or hash[key.to_s]
+      end
+    end
+
+    def get_real_key(hash, key)
+      if hash.is_a? Hash
+        if hash.key? key
+          key
+        elsif hash.key? key.to_sym
+          key.to_sym
+        elsif hash.key? key.to_s
+          key.to_s
+        end
+      end
+    end
+
+    def merge(target, *origins)
+      origins.each { |h| target = target.merge h }
+      target
+    end
+
+    def deep_merge(target = {}, *origins)
+      origins.each do |h|
+        target.deep_merge! h, MERGE_OPTIONS if h.is_a? Hash
+      end
+      target
+    end
+
+    def deep_copy(o)
+      Marshal.load Marshal.dump o
+    end
+
+    def parse_matrix(str)
+      hash = {}
+      str.split(';').each do |val|
+        val = val.split '='
+        hash[val.first.strip] = val.last.strip
+      end if str.is_a? String
+      hash
+    end
+
+    def parse_flags(str)
+      hash = {}
+      str.gsub(/\s+/, ' ').strip.split(' ').each_slice(2) do |val|
+        key = val.first
+        if val.first.is_a? String
+          key = key.gsub(/^\-+/, '').strip
+          hash[key] = (val.last or '').strip
+        end
+      end if str.is_a? String
+      hash
+    end
+
+    def replace_vars(str)
+      str.gsub(/\%\{(\w+)\}/) { yield $1 }
+    end
+
+    def template(str, data)
+      raise ArgumentError.new 'Data must be a hash' unless data.is_a? Hash
+      replace_vars str do |match|
+        key = get_real_key data, match
+        if key
+          data[key]
+        else
+          raise ArgumentError.new "Missing template variable: #{match}"
+        end
+      end
+    end
+
+    def replace_env_vars(str)
+      str.gsub(/\$\{(\w+)\}/) do
+        if ENV.key? $1
+          ENV[$1]
+        else
+          ''
+        end
+      end
+    end
+
+    def replace_placeholders(str, data)
+      str % data if data.is_a? Hash or data.is_a? Array
+    end
+
+    def traverse_map(hash, &block)
+      traverse_mapper hash, nil, &block
+    end
+
+    def traverse_mapper(hash, key, &block)
+      case hash
+      when String
+        hash = yield hash, key
+      when Array
+        hash.map! { |item| traverse_mapper item, nil, &block }
+      when Hash
+        buf = {}
+        hash.each do |k, v|
+          if k.is_a? String
+            new_key = yield k, k
+            if new_key != k
+              hash.delete k
+              buf[new_key] = traverse_mapper v, new_key, &block
+              next
+            end
+          end
+          hash[k] = traverse_mapper v, k, &block
+        end
+        hash.merge! buf
+      end
+      hash
+    end
+
+  end
+end

data/lib/dployr/version.rb

@@ -0,0 +1,3 @@
+module Dployr
+  VERSION = '0.0.1'
+end

data/lib/dployr.rb

@@ -0,0 +1,8 @@
+require 'yaml'
+require 'deep_merge'
+require 'dployr/version'
+require 'dployr/init'
+require 'dployr/configuration'
+require 'dployr/config/create'
+require 'dployr/config/file_utils'
+require 'dployr/config/instance'

data/spec/config_file_utils_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+describe Dployr::Config::FileUtils do
+
+  describe :read_yaml do
+    it "should expose the read method" do
+      Dployr::Config::FileUtils.respond_to?(:read_yaml).should be_true
+    end
+
+    it "should have a valid number of items" do
+      Dployr::Config::FileUtils.read_yaml(File.dirname(__FILE__) + '/fixtures/Dployrfile.yml').should have(2).item
+    end
+  end
+
+  describe :discover do
+    let(:pwd) { Dir.pwd }
+    let(:filename) { Dployr::Config::FileUtils::FILENAME }
+    let(:tmpdir) { File.join File.dirname(__FILE__), 'fixtures', '.tmp' }
+    let(:fixtures) { File.join File.dirname(__FILE__), 'fixtures' }
+
+    describe "current directory" do
+      context "when cannot discover" do
+        it { Dployr::Config::FileUtils.discover.should eql nil }
+      end
+
+      context "when discover" do
+        let(:expected) { File.join fixtures, filename }
+
+        before do
+          Dir.chdir fixtures
+        end
+
+        it { Dployr::Config::FileUtils.discover.should_not be_empty }
+
+        it { Dployr::Config::FileUtils.discover.should eql expected }
+
+        after do
+          Dir.chdir pwd
+        end
+      end
+    end
+
+    describe "higher directories" do
+      context "when discover" do
+        let(:expected) { File.join fixtures, filename }
+
+        before do
+          FileUtils.mkdir_p File.join tmpdir, 'sample'
+          Dir.chdir File.join tmpdir, 'sample'
+        end
+
+        after do
+          Dir.chdir pwd
+          FileUtils.rm_rf tmpdir
+        end
+
+        it { Dployr::Config::FileUtils.discover.should eql expected }
+      end
+    end
+  end
+end

data/spec/config_instance_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Dployr::Config::Instance do
+  describe "Instance" do
+    describe "instance configuration" do
+      let(:instance) {
+        Dployr::Config::Instance.new
+      }
+
+      describe "setting attributes" do
+        context "when created" do
+          subject { instance.attributes }
+          it { should be_a Hash }
+          it { should have(0).items }
+        end
+
+        context "when add attributes" do
+          before do
+            instance.set_attribute :key, "value"
+          end
+
+          subject { instance.attributes }
+          it { should have_key(:key) }
+        end
+      end
+
+      describe "setting providers" do
+        context "when created" do
+          subject { instance.providers }
+          it { should be_a Hash }
+          it { should have(0).items }
+        end
+
+        describe "setting providers" do
+          let(:provider) do
+            {
+              attributes: {
+                instance_type: "m1.small"
+              },
+              scripts: [],
+              regions: {}
+            }
+          end
+
+          context "when add a provider" do
+            before do
+              instance.add_provider :aws, provider
+            end
+
+            subject { instance.get_provider :aws }
+            it { should be_a Hash }
+            it { should have_key(:attributes) }
+            it { should have_key(:scripts) }
+            it { should have_key(:regions) }
+          end
+        end
+      end
+    end
+  end
+end