levels 0.1.0

data/lib/levels/system/constants.rb

@@ -0,0 +1,8 @@
+module Levels
+  module System
+
+    TYPE_SUFFIX = "TYPE"
+    ARRAY_DELIMITER_SUFFIX = "DELIMITER"
+
+  end
+end

data/lib/levels/system/key_formatter.rb

@@ -0,0 +1,15 @@
+module Levels
+  module System
+    class KeyFormatter
+
+      def initialize(prefix = nil, joiner = nil)
+        @prefix = prefix || ""
+        @joiner = joiner || "_"
+      end
+
+      def create(*parts)
+        (@prefix + parts.join(@joiner)).upcase
+      end
+    end
+  end
+end

data/lib/levels/system/key_generator.rb

@@ -0,0 +1,50 @@
+module Levels
+  module System
+    class KeyGenerator
+
+      def initialize(key_formatter = nil)
+        @key_formatter = key_formatter || KeyFormatter.new
+      end
+
+      def generate(enumerator)
+        env = {}
+        enumerator.each do |group, key, value|
+          add_keys(env, group, key, value)
+        end
+        env
+      end
+
+    protected
+
+      def k(*parts)
+        @key_formatter.create(*parts)
+      end
+
+      def add_keys(env, group, key, value)
+        case value
+        when Array
+          env[k(group, key)] = value.join(":")
+          env[k(group, key, TYPE_SUFFIX)] = "array"
+          env[k(group, key, ARRAY_DELIMITER_SUFFIX)] = ":"
+          env[k(group, key, TYPE_SUFFIX, TYPE_SUFFIX)] = type_for(value.first)
+        else
+          env[k(group, key)] = value.to_s
+          env[k(group, key, TYPE_SUFFIX)] = type_for(value)
+        end
+      end
+
+      def type_for(value)
+        case value
+        when String, NilClass then "string"
+        when Integer          then "integer"
+        when Float            then "float"
+        when TrueClass, FalseClass then "boolean"
+        when Array            then "array"
+        else
+          raise ArgumentError, "Could not export #{value.class}"
+        end
+      end
+
+    end
+  end
+end

data/lib/levels/system/key_parser.rb

@@ -0,0 +1,67 @@
+module Levels
+  module System
+    class KeyParser
+
+      def initialize(key_formatter = nil)
+        @key_formatter = key_formatter || KeyFormatter.new
+      end
+
+      def parse(env_hash, key, template_value)
+        value = env_hash[key]
+        typecast_info = env_hash[k(key, TYPE_SUFFIX)]
+        parse_any(env_hash, key, value, typecast_info, template_value)
+      end
+
+    protected
+
+      def k(*parts)
+        @key_formatter.create(*parts)
+      end
+
+      def parse_any(env_hash, key, value, typecast_info, template_value)
+        case
+        when value.empty?         then nil
+        when !typecast_info.nil?  then parse_from_typecast(env_hash, key, value, typecast_info)
+        when !template_value.nil? then parse_from_template(env_hash, key, value, template_value)
+        else value.to_s
+        end
+      end
+
+      def parse_from_typecast(env_hash, key, value, typecast_info)
+        case typecast_info
+        when "string", nil then value.to_s
+        when "integer"     then value.to_i
+        when "float"       then value.to_f
+        when "boolean"     then boolean(value)
+        when "array"       then array(env_hash, key, value, nil)
+        else raise ArgumentError, "Unknown typecast to #{typecast_info.inspect}"
+        end
+      end
+
+      def parse_from_template(env_hash, key, value, template_value)
+        case template_value
+        when String     then value.to_s
+        when Integer    then value.to_i
+        when Float      then value.to_f
+        when TrueClass  then boolean(value.to_s)
+        when FalseClass then boolean(value.to_s)
+        when Array      then array(env_hash, key, value, template_value.first)
+        else raise ArgumentError, "Unknown template value of type #{template_value.class}"
+        end
+      end
+
+      def array(env_hash, key, value, template_value)
+        value_typecast_info = env_hash[k(key, TYPE_SUFFIX, TYPE_SUFFIX)]
+        delimiter = env_hash[k(key, ARRAY_DELIMITER_SUFFIX)] || ":"
+        value.split(delimiter).map do |v|
+          parse_any(env_hash, key, v, value_typecast_info, template_value)
+        end
+      end
+
+      def boolean(value)
+        value.match(/^(true|1)$/i) != nil
+      end
+
+    end
+  end
+end

data/lib/levels/version.rb

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

data/test/acceptance/audit_test.rb

@@ -0,0 +1,105 @@
+require 'helper'
+
+describe "acceptance: the audit observers" do
+
+  # This test requires a lot of collaborators, but hopefully shows how the
+  # auditor works as a whole.
+
+  let(:event_handler_class) {
+    Class.new do
+
+      def initialize
+        @current_key = nil
+        @captured = Hash.new { |h, k| h[k] = [] }
+      end
+
+      attr_reader :captured
+
+      def on_values(values)
+        @current_key = values.value_key
+        values.each do |value|
+          @captured[@current_key] << value.raw
+          value.notify(self)
+        end
+        @current_key = nil
+      end
+
+      def on_nested_values(values)
+        values.each do |value|
+          @captured[@current_key] << [values.value_key, value.raw]
+        end
+      end
+    end
+  }
+
+  # The levels that will be merged.
+  let(:levels) { [] }
+
+  # The merged view of the levels.
+  let(:configuration) { Levels::Configuration.new(levels) }
+
+  # Computed values are evaluated against the merged levels.
+  let(:lazy_evaluator) { Levels::LazyEvaluator.new(configuration) }
+
+  # The root observer performing the audit.
+  let(:root_observer) { Levels::Audit.start(lazy_evaluator) }
+
+  before do
+    level1 = Levels::Level.new("one")
+    level1.set_group(:group1, a: 1)
+    level1.set_group(:group2, x: -> { "a = #{group1.a}, b = #{group2.b}" })
+
+    level2 = Levels::Level.new("two")
+    level2.set_group(:group1, a: 2)
+    level2.set_group(:group2, b: 3)
+
+    levels << level1
+    levels << level2
+
+    # The auditor must be assigned to the configuration, else nested values get
+    # confused since the value is ultimately accessed via the LazyEvaluator's
+    # levels reference. The point is, we're doing something weird here by using
+    # the auditor directly.
+    configuration.instance_variable_set(:@root_observer, root_observer)
+  end
+
+  # A custom event handler to collect the values that are observed.
+  let(:event_handler) { event_handler_class.new }
+
+  # Get the full audit trail for a group.value read.
+  def observe_values(group_key, value_key)
+    group_observer = root_observer.observe_group(event_handler)
+    group_observer.observe_values(levels, group_key, value_key)
+  end
+
+  it "handles simple values" do
+    values = observe_values(:group1, :a)
+
+    event_handler.captured.must_equal a: [1, 2]
+
+    values.final_value.must_equal 2
+  end
+
+  it "handles complex nested values" do
+    values = observe_values(:group2, :x)
+
+    event_handler.captured.must_equal x: [
+      "a = 2, b = 3",
+      [:a, 1],
+      [:a, 2],
+      [:b, 3]
+    ]
+
+    values.final_value.must_equal "a = 2, b = 3"
+  end
+
+  it "returns empty values for a non-existent key" do
+    values = observe_values(:no_group, :foo)
+    event_handler.captured.must_equal({})
+    values.must_be :empty?
+
+    values = observe_values(:group1, :no_key)
+    event_handler.captured.must_equal({})
+    values.must_be :empty?
+  end
+end

data/test/acceptance/event_handler_test.rb

@@ -0,0 +1,43 @@
+require 'helper'
+
+describe "acceptance: the cli event handler" do
+
+  def read_ruby(level_name, ruby_string)
+    level = Levels::Level.new(level_name)
+    input = Levels::Input::Ruby.new(ruby_string)
+    input.read(level)
+    level
+  end
+
+  it "handles lazy evaluation" do
+
+    level1 = read_ruby("One", <<-RUBY)
+group :names
+  set full_name: -> { [names.first_name, names.last_name].join(" ") }
+  set first_name: "John"
+  set last_name: "Doe"
+    RUBY
+
+    level2 = read_ruby("Two", <<-RUBY)
+group :names
+  set last_name: "Smith"
+    RUBY
+
+    stream = StringIO.new
+
+    configuration = Levels::Configuration.new([level1, level2])
+    configuration.event_handler = Levels::CliEventHandler.new(stream)
+
+    configuration.names.full_name
+
+    stream.string.must_equal <<-STR
+> names.full_name
+  > names.first_name
+   + "John" from One
+  > names.last_name
+   - "Doe" from One
+   + "Smith" from Two
+ + "John Smith" from One
+    STR
+  end
+end

data/test/acceptance/read_json_test.rb

@@ -0,0 +1,35 @@
+require 'helper'
+
+describe "acceptance: read json" do
+
+  def read_json(level_name, json_string)
+    level = Levels::Level.new(level_name)
+    input = Levels::Input::JSON.new(json_string)
+    input.read(level)
+    level
+  end
+
+  let(:json) {
+    <<-JSON
+{
+  "types": {
+    "string": "hello",
+    "integer": 123,
+    "float": 1.5,
+    "boolean_true": true,
+    "boolean_false": false,
+    "array_of_string": ["a", "b", "c"],
+    "array_of_integer": [1, 2, 3],
+    "null": null
+  },
+  "group2": {
+    "message": "hello world"
+  }
+}
+    JSON
+  }
+
+  subject { read_json("test", json) }
+
+  assert_sample_data_set
+end

data/test/acceptance/read_ruby_test.rb

@@ -0,0 +1,117 @@
+require 'helper'
+require 'tempfile'
+
+describe "acceptance: read ruby" do
+
+  def read_ruby(level_name, ruby_string)
+    level = Levels::Level.new(level_name)
+    input = Levels::Input::Ruby.new(ruby_string)
+    input.read(level)
+    level
+  end
+
+  describe "types" do
+
+    let(:ruby) {
+      <<-RUBY
+group "types"
+  set string: "hello"
+  set integer: 123
+  set float: 1.5
+  set boolean_true: true
+  set boolean_false: false
+  set array_of_string: ["a", "b", "c"]
+  set array_of_integer: [1, 2, 3]
+  set null: nil
+
+group "group2"
+  set message: "hello world"
+      RUBY
+    }
+
+    subject { read_ruby("test", ruby) }
+
+    assert_sample_data_set
+  end
+
+  describe "computed values" do
+
+    let(:level1_ruby) {
+      <<-RUBY
+group :names
+  set full_name: -> { [names.first_name, names.last_name].join(" ") }
+  set first_name: "John"
+  set last_name: "Doe"
+      RUBY
+    }
+
+    let(:level2_ruby) {
+      <<-RUBY
+group "names"
+  set last_name: "Smith"
+      RUBY
+    }
+
+    let(:level1) { read_ruby("ruby level 1", level1_ruby) }
+    let(:level2) { read_ruby("ruby level 2", level2_ruby) }
+
+    subject { Levels::Configuration.new([level1, level2]) }
+
+    it "resolves the computed value" do
+      subject.names.full_name.must_equal "John Smith"
+    end
+  end
+
+  describe "reading a file" do
+
+    let(:ruby_file) { f("file.rb") }
+
+    def read_ruby_with_file_path_path(path)
+      input = Levels::Input::Ruby.new(<<-RUBY, ruby_file.to_s)
+group "group1"
+  set message: file("#{path}")
+  set lazy_message: -> { file("#{path}") }
+      RUBY
+      level = Levels::Level.new("test")
+      input.read(level)
+      Levels::Configuration.new([level])
+    end
+
+    it "reads a file in the same directory" do
+      level = read_ruby_with_file_path_path("f1")
+      w("f1", "hello world")
+      level.group1.message.must_equal "hello world"
+    end
+
+    it "reads a file at a relative path" do
+      level = read_ruby_with_file_path_path("d/f1")
+      (ruby_file.dirname + "d").mkdir
+      w("d/f1", "hello world")
+      level.group1.message.must_equal "hello world"
+    end
+
+    it "reads a file at an absolute path" do
+      f = Tempfile.new("f")
+      begin
+        level = read_ruby_with_file_path_path(f.path)
+        f.write "hello world"
+        f.close
+        level.group1.message.must_equal "hello world"
+      ensure
+        f.close!
+      end
+    end
+
+    it "fails if the file does not exist" do
+      level = read_ruby_with_file_path_path("f1")
+      level.group1.defined?(:message).must_equal true
+      -> { level.group1.message }.must_raise Levels::Runtime::FileNotFoundError
+    end
+
+    it "lazily reads a file" do
+      level = read_ruby_with_file_path_path("f1")
+      w("f1", "hello world")
+      level.group1.lazy_message.must_equal "hello world"
+    end
+  end
+end