levels 0.1.0

data/lib/levels/input/system.rb

@@ -0,0 +1,63 @@
+module Levels
+  module Input
+    # This input creates an env level from the system environment
+    # (ENV in ruby). It does so by using an existing level as a
+    # template for the group names and values. For each value, it
+    # attempts to typecast a String value into the same type found in
+    # the template.
+    #
+    # Examples
+    #
+    #     # Given a template level with a single group:
+    #     settings: {
+    #       hostname: "example.com",
+    #       workers: 5,
+    #       queues: ["low", "high", "other"]
+    #     }
+    #
+    #     # These environment variables will set new values.
+    #     SETTINGS_HOSTNAME=foo.com
+    #     SETTINGS_WORKERS=1
+    #     SETTINGS_QUEUES=high:low:other
+    #
+    class System
+
+      # Initialize a new system reader.
+      #
+      # template - Enumerator that defines the possible keys.
+      # prefix   - String prefix for the keys (default: no
+      #            prefix).
+      #
+      def initialize(template, key_formatter = nil, env_hash = ENV)
+        @template = template
+        @env_hash = env_hash
+        @key_formatter = key_formatter || Levels::System::KeyFormatter.new
+        @key_parser = Levels::System::KeyParser.new(@key_formatter)
+      end
+
+      def read(level)
+        @template.each do |group_name, group|
+          env_data = {}
+          group_data = {}
+          group.each do |key, value|
+            group_data[key.to_sym] = value
+          end
+          @env_hash.each do |key, value|
+            match_key = @key_formatter.create(group_name, "(.+)")
+            matcher = Regexp.new("^#{match_key}$")
+            if key =~ matcher
+              attr_name = $1.downcase.to_sym
+              if group_data.key?(attr_name)
+                cast_value = @key_parser.parse(@env_hash, key, group_data[attr_name])
+                env_data[attr_name] = cast_value
+              end
+            end
+          end
+          if env_data.any?
+            level.set_group(group_name, env_data)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/levels/input/yaml.rb

@@ -0,0 +1,17 @@
+module Levels
+  module Input
+    class YAML
+
+      def initialize(yaml_string)
+        @yaml = ::YAML.load(yaml_string)
+      end
+
+      def read(level)
+        @yaml.each do |group_name, group|
+          level.set_group(group_name, group)
+        end
+      end
+    end
+  end
+end
+

data/lib/levels/key.rb

@@ -0,0 +1,28 @@
+module Levels
+  class Key
+
+    def initialize(key)
+      @key = key
+    end
+
+    def to_sym
+      @key.to_sym
+    end
+
+    def eql?(other)
+      other.class == self.class && to_sym == other.to_sym
+    end
+
+    alias == eql?
+
+    def hash
+      self.class.hash ^ to_sym.hash
+    end
+
+    def inspect
+      "<Levels::Key #{to_sym.inspect}>"
+    end
+
+    alias to_s inspect
+  end
+end

data/lib/levels/key_values.rb

@@ -0,0 +1,54 @@
+module Levels
+  class KeyValues
+
+    def Key(key)
+      case key
+      when Levels::Key then key
+      else Levels::Key.new(key)
+      end
+    end
+
+    include Enumerable
+
+    def initialize(data = nil)
+      @hash = {}
+      data.each { |k, v| self[k] = v } if data
+    end
+
+    def [](key)
+      @hash[Key(key)]
+    end
+
+    def pair(key)
+      return Key(key), self[key]
+    end
+
+    def []=(key, value)
+      @hash[Key(key)] = value
+    end
+
+    def key?(key)
+      @hash.key?(Key(key))
+    end
+
+    def each(&block)
+      @hash.each(&block)
+    end
+
+    def eql?(other)
+      self.class == other.class && @hash.eql?(other.instance_variable_get(:@hash))
+    end
+
+    alias == eql?
+
+    def hash
+      self.class.hash ^ @hash.hash
+    end
+
+    def inspect
+      "<Levels::KeyValues>"
+    end
+
+    alias to_s inspect
+  end
+end

data/lib/levels/lazy_evaluator.rb

@@ -0,0 +1,54 @@
+module Levels
+  # Whenever a value is read, it's interpreted by the LazyEvaluator. This class
+  # implements all of the interpolation rules.
+  class LazyEvaluator
+
+    # Internal: Initialize a new LazyEvaluator.
+    #
+    # level         - Levels::Level or equivalent, used to find referenced
+    #                 groups and keys.
+    # key_formatter - Levels::System::KeyFormatter.
+    #
+    def initialize(level, key_formatter = nil)
+      @level = level
+      @key_formatter = key_formatter || Levels::System::KeyFormatter.new
+    end
+
+    # Internal: Interpret the value.
+    def call(value)
+      loop do
+        case value
+        #when /\$\{[A-Z_]+\}/
+        when Proc
+          dsl = DSL.new(@level)
+          value = dsl.instance_exec(&value)
+        when Array
+          return value.map { |v| call(v) }
+        else
+          return value
+        end
+      end
+    end
+
+    # This is the class that evaluations Proc values. When you define a value
+    # as a Proc, it's evaluation in the context of an instance of this class.
+    class DSL
+      include Levels::MethodMissing
+      include Levels::Runtime
+
+      def initialize(level)
+        @level = level
+      end
+
+      # Public: Determine if a group exists.
+      def defined?(group_key)
+        @level.defined?(group_key)
+      end
+
+      # Public: Retrieve a group.
+      def [](group_key)
+        @level[group_key]
+      end
+    end
+  end
+end

data/lib/levels/level.rb

@@ -0,0 +1,80 @@
+module Levels
+  # A Level is a named set of groups. A Configuration is made up of multiple
+  # levels with clear semantics on how those levels are merged. You generally won't
+  # instantiate a Level directly, but instead load one from an external source.
+  #
+  # Examples
+  #
+  #     level = Levels::Level.new("My Level")
+  #
+  #     level.set_group(:group1, a: 1, b: 2)
+  #     level.set_group(:group2, c: 3, d: 4)
+  #
+  #     level.group1 # => { a: 1, b: 2 }
+  #     level.group2 # => { c: 3, d: 4 }
+  #
+  class Level
+    include Levels::MethodMissing
+
+    # Internal: Initialize a new level.
+    #
+    # name - String name of the level.
+    #
+    def initialize(name)
+      @name = name
+      @groups = Levels::KeyValues.new
+    end
+
+    # Public: Get a group by name.
+    #
+    # group_name - Symbol name of the group.
+    #
+    # Returns a Levels::Group.
+    # Raises Levels::UnknownGroup if the group is not defined.
+    def [](group_name)
+      @groups[group_name] or raise UnknownGroup, "#{group_name.inspect} group is not defined"
+    end
+
+    # Public: Determine if a group has been defined.
+    #
+    # Returns a Boolean.
+    def defined?(group_name)
+      @groups.key?(group_name)
+    end
+
+    # Internal: Define a group.
+    #
+    # group_name - Symbol name of the group.
+    # hash       - Hash of values.
+    #
+    # Returns nothing.
+    def set_group(group_name, hash)
+      if @groups.key?(group_name)
+        raise DuplicateGroup, "#{group_name} has already been defined"
+      end
+      @groups[group_name] = Group.new(hash)
+    end
+
+    def to_s
+      "<Levels::Level #{@name.inspect}>"
+    end
+
+    # Returns an Enumerator which yields [group_name, Group#to_enum].
+    def to_enum
+      Enumerator.new do |y|
+        @groups.each do |name, group|
+          y << [name.to_sym, group.to_enum]
+        end
+      end
+    end
+
+    def _level_name
+      @name
+    end
+
+    def eql_hash?(hash)
+      key_values = Levels::KeyValues.new(hash)
+      @groups.all? { |name, group| group.eql_hash?(key_values[name]) }
+    end
+  end
+end

data/lib/levels/method_missing.rb

@@ -0,0 +1,14 @@
+module Levels
+  # Enables dot syntax for levels and groups.
+  module MethodMissing
+
+    def method_missing(message, *args, &block)
+      raise ArgumentError, "arguments are not allowed: #{message}(#{args.inspect})" if args.any?
+      if message =~ /^(.*)\?$/
+        self.defined?($1.to_sym)
+      else
+        self[message]
+      end
+    end
+  end
+end

data/lib/levels/output/json.rb

@@ -0,0 +1,33 @@
+module Levels
+  module Output
+    class JSON
+
+      SPACE = " ".freeze
+      JSON_OPTS = {
+        indent: SPACE * 2,
+        space: SPACE * 1,
+        space_before: SPACE * 0,
+        object_nl: "\n",
+        array_nl: "\n",
+        allow_nan: false,
+        max_nesting: 10
+      }
+
+      def initialize(json_opts = nil)
+        @json_opts = json_opts || JSON_OPTS
+      end
+
+      def generate(enumerator)
+        hash = {}
+        enumerator.each do |group_name, group|
+          hash[group_name] = {}
+          group.each do |key, value|
+            hash[group_name][key] = value
+          end
+        end
+        ::JSON.generate(hash, @json_opts)
+      end
+
+    end
+  end
+end

data/lib/levels/output/system.rb

@@ -0,0 +1,29 @@
+module Levels
+  module Output
+    class System
+
+      def initialize(key_formatter = nil)
+        @key_formatter = key_formatter || Levels::System::KeyFormatter.new
+        @key_generator = Levels::System::KeyGenerator.new(key_formatter)
+      end
+
+      def generate(enumerator)
+        flat_enum = Enumerator.new do |y|
+          enumerator.each do |group_name, group|
+            group.each do |key, value|
+              y << [group_name, key, value]
+            end
+          end
+        end
+        vars = @key_generator.generate(flat_enum)
+        vars.map { |k, v| "export #{k}=#{quote v}" }.join("\n")
+      end
+
+    protected
+
+      def quote(value)
+        %("#{value}")
+      end
+    end
+  end
+end

data/lib/levels/output/yaml.rb

@@ -0,0 +1,19 @@
+module Levels
+  module Output
+    class YAML
+
+      def generate(enumerator)
+        hash = {}
+        enumerator.each do |group_name, group|
+          hash[group_name.to_s] = {}
+          group.each do |key, value|
+            hash[group_name.to_s][key.to_s] = value
+          end
+        end
+        ::YAML.dump(hash)
+      end
+
+    end
+  end
+end
+

data/lib/levels/runtime.rb

@@ -0,0 +1,30 @@
+module Levels
+  # Public: Methods in this module are available within any Ruby input.
+  # You may extend it with any additonal methods you require.
+  module Runtime
+
+    FileNotFoundError = Class.new(RuntimeError)
+
+    # Public: Read the value from a file on disk. The file
+    # will not be read until the key is accessed.
+    #
+    # file_path - String path to the file. The path may be absolute,
+    #             or relative to the Ruby file calling this function.
+    #
+    # Returns a Proc that reads the file when called.
+    # That proc raises Levels::Ruby::FileNotFoundError if the file does
+    #   not exist.
+    def file(file_path)
+      return nil if file_path.nil?
+      caller_path = Pathname.new(caller[0]).dirname
+      -> do
+        path = caller_path + file_path
+        if path.exist?
+          path.read
+        else
+          raise FileNotFoundError, path.to_s
+        end
+      end
+    end
+  end
+end

data/lib/levels/setup.rb

@@ -0,0 +1,132 @@
+module Levels
+  class Setup
+
+    # Internal: Initialize a new Levels::Setup.
+    def initialize
+      @inputs = []
+    end
+
+    # Public: Add a level of configuration.
+    #
+    # name   - String name of the level.
+    # source - Anything that can be identified as an input source. File
+    #          path, code or any object that responds to #read is a valid
+    #          source.
+    #
+    # Returns nothing.
+    def add(name, source)
+      level = -> { Levels::Level.new(name) }
+      input = Input.new(source)
+      @inputs << [level, input]
+    end
+
+    # Public: Add the system environment as a level of configuration.
+    #
+    # prefix   - String the prefix for environment variables (default
+    #            none).
+    # name     - String the name of the level (default: "System
+    #            Environment").
+    # env_hash - Hash of environment variables (default: ENV).
+    #
+    # Returns nothing.
+    def add_system(prefix = nil, name = nil, env_hash = ENV)
+      key_formatter = Levels::System::KeyFormatter.new(prefix)
+      level = -> { Levels::Level.new(name || "System Environment") }
+      input = -> template { Levels::Input::System.new(template, key_formatter, env_hash) }
+      @inputs << [level, input]
+    end
+
+    # Public: Add an already initialized Level.
+    #
+    # level - Levels::Level.
+    #
+    # Returns nothing.
+    def add_level(level)
+      @inputs << [-> { level }, NullInput.new]
+    end
+
+    # Public: Parse all inputs sources and get a Configuration.
+    #
+    # Returns a Levels::Configuration.
+    def merge
+      levels = []
+      @inputs.each do |level_proc, input|
+        level = level_proc.call
+        case input
+        when Proc
+          template = Levels::Configuration.new(levels)
+          input = input.call(template.to_enum)
+          input.read(level)
+        else
+          input.read(level)
+        end
+        levels << level
+      end
+      Levels::Configuration.new(levels)
+    end
+
+    class NullInput
+
+      def read(level)
+        # noop
+      end
+    end
+
+    # This class transforms any supported object into Level data. The object
+    # can be any of:
+    #
+    #   * A file path to Ruby, JSON or YAML
+    #   * Ruby, JSON or YAML code
+    #   * An object that responds to `#read(level)`.
+    #
+    class Input
+
+      def initialize(source)
+        @source = source
+      end
+
+      # Read the input into a Level.
+      # Raises an ArgumentError if the source cannot be used as an input.
+      def read(level)
+        input.read(level)
+      end
+
+      # Returns a Levels::Input.
+      # Raises an ArgumentError if the format couldn't be determined.
+      def input
+        format, source, *args = identify
+        case format
+        when :custom then source
+        when :ruby   then Levels::Input::Ruby.new(source, *args)
+        when :json   then Levels::Input::JSON.new(source)
+        when :yaml   then Levels::Input::YAML.new(source)
+        else raise ArgumentError, "Could not identify the format: #{format.inspect}"
+        end
+      end
+
+      # Determine the format of the source and read it from disk if
+      # it's a file.
+      def identify
+        if @source.respond_to?(:read)
+          return :custom, @source
+        end
+        pn = Pathname.new(@source)
+        if pn.exist?
+          case pn.extname
+          when ".rb"           then [:ruby, pn.read, pn.to_s, 1]
+          when ".json"         then [:json, pn.read]
+          when ".yaml", ".yml" then [:yaml, pn.read]
+          else raise ArgumentError, "Could not identify the file type: #{pn.extname}"
+          end
+        else
+          case @source
+          when /\A\w*{/     then [:json, @source]
+          when /\A---$/     then [:yaml, @source]
+          when /\A\w*group/ then [:ruby, @source, "Code from String", 1]
+          else raise ArgumentError, "Could not identify the source: #{@source.inspect}"
+          end
+        end
+      end
+    end
+  end
+end