unobtainium 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c5ce28fc39781ca3d3ad6b7116e93f3b194e44d2
-  data.tar.gz: 58b285e599f453331bfe7c7382158fa09d591f1e
+  metadata.gz: 62f55e229f2458af4e265380afd8e407135e2f6e
+  data.tar.gz: 84c5321fff693ec7eedddc59f74bbe829303f383
 SHA512:
-  metadata.gz: 8e8d24aae8e1143ca3ec5a7d6043968f6c0bc6f1ced20bd35f868bf2c5ca74cc669caada417a58d23509987bdeca92e18abcc92abaa78b37d02cd936c549569f
-  data.tar.gz: 4ee5af3d346f55488f65f33929a37cc18a39c6ba42337db2ad25c94fc695d133f72975566d3c9804c5f584dd3d3a5460ce661782db5f3b7a5f72d54925dcabd5
+  metadata.gz: 070ff928ed2373b5f26bcb9d4c596d6d7ced6443d0028feeaba897a1cb66accec60b8612204245ef9c76dc00213bab8c0c9ea0562483d286d7d3524926536781
+  data.tar.gz: 2c8b4a547d1cc410d60f0d0d86c214720097f1da2ea7a4d1717d7b1645615be12add8ccfac7eac53f1e091e4c8ef32ef28b8672f1366d7db87ebffad32acf4a5

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    unobtainium (0.1.0)
+    unobtainium (0.2.0)
 
 GEM
   remote: https://rubygems.org/

data/cuke/Gemfile.lock

@@ -0,0 +1,59 @@
+GIT
+  remote: git@github.com:jfinkhaeuser/unobtainium.git
+  revision: 16b26ed3c3f60bd114ab774a717d3050feb94e03
+  branch: master
+  specs:
+    unobtainium (0.2.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    appium_lib (8.0.2)
+      awesome_print (~> 1.6)
+      json (~> 1.8)
+      nokogiri (~> 1.6.6)
+      selenium-webdriver (~> 2.49)
+      tomlrb (~> 1.1)
+    awesome_print (1.6.1)
+    builder (3.2.2)
+    childprocess (0.5.9)
+      ffi (~> 1.0, >= 1.0.11)
+    cucumber (2.3.3)
+      builder (>= 2.1.2)
+      cucumber-core (~> 1.4.0)
+      cucumber-wire (~> 0.0.1)
+      diff-lcs (>= 1.1.3)
+      gherkin (~> 3.2.0)
+      multi_json (>= 1.7.5, < 2.0)
+      multi_test (>= 0.1.2)
+    cucumber-core (1.4.0)
+      gherkin (~> 3.2.0)
+    cucumber-wire (0.0.1)
+    diff-lcs (1.2.5)
+    ffi (1.9.10)
+    gherkin (3.2.0)
+    json (1.8.3)
+    mini_portile2 (2.0.0)
+    multi_json (1.11.2)
+    multi_test (0.1.2)
+    nokogiri (1.6.7.2)
+      mini_portile2 (~> 2.0.0.rc2)
+    rubyzip (1.2.0)
+    selenium-webdriver (2.53.0)
+      childprocess (~> 0.5)
+      rubyzip (~> 1.0)
+      websocket (~> 1.0)
+    tomlrb (1.2.1)
+    websocket (1.2.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  appium_lib
+  cucumber
+  selenium-webdriver
+  unobtainium!
+
+BUNDLED WITH
+   1.11.2

data/cuke/config/config.yml

@@ -4,3 +4,4 @@ drivers:
   android:
     browser: chrome
 driver: firefox
+at_end: quit

data/lib/unobtainium/config.rb

@@ -59,14 +59,23 @@ module Unobtainium
       # Wrap all read functions into something that checks for environment
       # variables first.
       define_method(method) do |*args, &block|
+        # If there are no arguments, there's nothing to do with paths. Just
+        # delegate to the hash.
+        if args.empty?
+          return super(*args, &block)
+        end
+
         # We'll make it rather simple: since the first argument is a key, we
         # will just transform it to the matching environment variable name,
         # and see if that environment variable is set.
-        env_name = args[0].upcase.gsub(split_pattern, '_')
-        contents = ENV[env_name]
+        env_name = args[0].to_s.upcase.gsub(split_pattern, '_')
+        contents = nil
+        if env_name != '_'
+          contents = ENV[env_name]
+        end
 
         # No environment variable set? Fine, just do the usual thing.
-        if contents.nil?
+        if contents.nil? or contents.empty?
           return super(*args, &block)
         end
 
@@ -94,28 +103,23 @@ module Unobtainium
       ##
       # Loads a configuration file with the given file name. The format is
       # detected based on one of the extensions in FILE_TO_PARSER.
-      def load_config(path)
+      def load_config(path, resolve_extensions = true)
         # Load base and local configuration files
         base, config = load_base_config(path)
         _, local_config = load_local_config(base)
-        if local_config.nil?
-          return Config.new(config)
-        end
 
-        # Merge
-        merger = proc do |_, v1, v2|
-          # rubocop:disable Style/GuardClause
-          if v1.is_a? Hash and v2.is_a? Hash
-            next v1.merge(v2, &merger)
-          elsif v1.is_a? Array and v2.is_a? Array
-            next v1 + v2
-          end
-          next v2
-          # rubocop:enable Style/GuardClause
+        # Merge local configuration
+        config.recursive_merge!(local_config)
+
+        # Create config from the result
+        cfg = Config.new(config)
+
+        # Now resolve config hashes that extend other hashes.
+        if resolve_extensions
+          cfg.resolve_extensions!
         end
-        config.merge!(local_config, &merger)
 
-        return Config.new(config)
+        return cfg
       end
 
       private
@@ -137,7 +141,7 @@ module Unobtainium
         # Parse the contents.
         config = FILE_TO_PARSER[base.extname].parse(contents)
 
-        return base, hashify(config)
+        return base, PathedHash.new(hashify(config))
       end
 
       def load_local_config(base)
@@ -156,7 +160,7 @@ module Unobtainium
 
         local_config = FILE_TO_PARSER[base.extname].parse(contents)
 
-        return local, hashify(local_config)
+        return local, PathedHash.new(hashify(local_config))
       end
 
       def hashify(data)
@@ -169,5 +173,111 @@ module Unobtainium
         return data
       end
     end # class << self
+
+    ##
+    # Resolve extensions in configuration hashes. If your hash contains e.g.:
+    #
+    #   foo:
+    #     bar:
+    #       some: value
+    #     baz:
+    #       extends: bar
+    #
+    # Then 'foo.baz.some' will equal 'value' after resolving extensions. Note
+    # that :load_config calls this function, so normally you don't need to call
+    # it yourself. You can switch this behaviour off in :load_config.
+    #
+    # Note that this process has some intended side-effects:
+    # 1) If a hash can't be extended because the base cannot be found, an error
+    #    is raised.
+    # 2) If a hash got successfully extended, the :extends keyword itself is
+    #    removed from the hash.
+    # 3) In a successfully extended hash, an :base keyword, which contains
+    #    the name of the base. In case of multiple recursive extensions, the
+    #    final base is stored here.
+    #
+    # Also note that all of this means that :extends and :base are reserved
+    # keywords that cannot be used in configuration files other than for this
+    # purpose!
+    def resolve_extensions!
+      recursive_merge("", "")
+    end
+
+    def resolve_extensions
+      dup.resolve_extensions!
+    end
+
+    private
+
+    def recursive_merge(parent, key)
+      loop do
+        full_key = "#{parent}#{separator}#{key}"
+
+        # Recurse down to the remaining root of the hierarchy
+        base = full_key
+        derived = nil
+        loop do
+          new_base, new_derived = resolve_extension(parent, base)
+
+          if new_derived.nil?
+            break
+          end
+
+          base = new_base
+          derived = new_derived
+        end
+
+        # If recursion found nothing to merge, we're done!
+        if derived.nil?
+          break
+        end
+
+        # Otherwise, merge what needs merging and continue
+        merge_extension(base, derived)
+      end
+    end
+
+    def resolve_extension(grandparent, parent)
+      fetch(parent, {}).each do |key, value|
+        # Recurse into hash values
+        if value.is_a? Hash
+          recursive_merge(parent, key)
+        end
+
+        # No hash, ignore any keys other than the special "extends" key
+        if key != "extends"
+          next
+        end
+
+        # If the key is "extends", return a normalized version of its value.
+        full_value = value.dup
+        if not full_value.start_with?(separator)
+          full_value = "#{grandparent}#{separator}#{value}"
+        end
+
+        if full_value == parent
+          next
+        end
+        return full_value, parent
+      end
+
+      return nil, nil
+    end
+
+    def merge_extension(base, derived)
+      # Remove old 'extends' key, but remember the value
+      extends = self[derived]["extends"]
+      self[derived].delete("extends")
+
+      # Recursively merge base into derived without overwriting
+      self[derived].extend(::Unobtainium::RecursiveMerge)
+      self[derived].recursive_merge!(self[base], false)
+
+      # Then set the "base" keyword, but only if it's not yet set.
+      if not self[derived]["base"].nil?
+        return
+      end
+      self[derived]["base"] = extends
+    end
   end # class Config
 end # module Unobtainium

data/lib/unobtainium/drivers/selenium.rb

@@ -19,6 +19,7 @@ module Unobtainium
         safari: [],
         chrome: [],
         chromium: [],
+        remote: [],
       }.freeze
 
       class << self
@@ -39,10 +40,26 @@ module Unobtainium
                 err.backtrace
         end
 
+        ##
+        # Selenium really wants symbol keys for the options
+        def sanitize_options(label, options)
+          new_opts = {}
+
+          if not options.nil?
+            options.each do |key, value|
+              new_opts[key.to_sym] = value
+            end
+          end
+
+          options = new_opts
+
+          return label, options
+        end
+
         ##
         # Create and return a driver instance
-        def create(label, _)
-          driver = ::Selenium::WebDriver.for(normalize_label(label))
+        def create(label, options)
+          driver = ::Selenium::WebDriver.for(normalize_label(label), options)
           return driver
         end
 

data/lib/unobtainium/pathed_hash.rb

@@ -7,6 +7,8 @@
 # All rights reserved.
 #
 
+require 'unobtainium/recursive_merge'
+
 module Unobtainium
 
   ##
@@ -14,10 +16,16 @@ module Unobtainium
   # regular access, i.e. instead of h["first"]["second"] you can write
   # h["first.second"]
   class PathedHash
+    include RecursiveMerge
+
     ##
     # Initializer
     def initialize(init = {})
-      @data = init
+      if init.nil?
+        @data = {}
+      else
+        @data = init.dup
+      end
       @separator = '.'
     end
 
@@ -40,13 +48,39 @@ module Unobtainium
     (READ_METHODS + WRITE_METHODS).each do |method|
       # Wrap all accessor functions to deal with paths
       define_method(method) do |*args, &block|
+        # If there are no arguments, there's nothing to do with paths. Just
+        # delegate to the hash.
+        if args.empty?
+          return @data.send(method, *args, &block)
+        end
+
         # With any of the dispatch methods, we know that the first argument has
         # to be a key. We'll try to split it by the path separator.
         components = args[0].to_s.split(split_pattern)
+        loop do
+          if components.empty? or not components[0].empty?
+            break
+          end
+          components.shift
+        end
+
+        # If there are no components, return self/the root
+        if components.empty?
+          return self
+        end
 
         # This PathedHash is already the leaf-most Hash
         if components.length == 1
-          return @data.send(method, *args, &block)
+          # Weird edge case: if we didn't have to shift anything, then it's
+          # possible we inadvertently changed a symbol key into a string key,
+          # which could mean looking fails.
+          # We can detect that by comparing copy[0] to a symbolized version of
+          # components[0].
+          copy = args.dup
+          if copy[0] != components[0].to_sym
+            copy[0] = components[0]
+          end
+          return @data.send(method, *copy, &block)
         end
 
         # Deal with other paths. The frustrating part here is that for nested
@@ -57,13 +91,6 @@ module Unobtainium
         leaf = recursive_fetch(components, @data,
                                create: WRITE_METHODS.include?(method))
 
-        # If the leaf is nil, we can't send it any method without raising
-        # an error. We'll instead send the method to an empty hash, to mimic
-        # the correct behaviour.
-        if leaf.nil?
-          return {}.send(method, *args, &block)
-        end
-
         # If we have a leaf, we want to send the requested method to that
         # leaf.
         copy = args.dup
@@ -76,6 +103,16 @@ module Unobtainium
       @data.to_s
     end
 
+    def dup
+      PathedHash.new(@data.dup)
+    end
+
+    def merge!(*args, &block)
+      # FIXME: we may need other methods like this. This is used by
+      #        RecursiveMerge, so we know it's required.
+      PathedHash.new(super)
+    end
+
     ##
     # Map any missing method to the driver implementation
     def respond_to?(meth)

data/lib/unobtainium/recursive_merge.rb

@@ -0,0 +1,40 @@
+# coding: utf-8
+#
+# unobtainium
+# https://github.com/jfinkhaeuser/unobtainium
+#
+# Copyright (c) 2016 Jens Finkhaeuser and other unobtainium contributors.
+# All rights reserved.
+#
+
+module Unobtainium
+  ##
+  # Provides recursive merge functions for hashes. Used in PathedHash.
+  module RecursiveMerge
+    def recursive_merge!(other, overwrite = true)
+      if other.nil?
+        return self
+      end
+
+      merger = proc do |_, v1, v2|
+        # rubocop:disable Style/GuardClause
+        if v1.is_a? Hash and v2.is_a? Hash
+          next v1.merge(v2, &merger)
+        elsif v1.is_a? Array and v2.is_a? Array
+          next v1 + v2
+        end
+        if overwrite
+          next v2
+        else
+          next v1
+        end
+        # rubocop:enable Style/GuardClause
+      end
+      merge!(other, &merger)
+    end
+
+    def recursive_merge(other, overwrite = true)
+      dup.recursive_merge!(other, overwrite)
+    end
+  end # module RecursiveMerge
+end # module Unobtainium

data/lib/unobtainium/version.rb

@@ -7,5 +7,5 @@
 # All rights reserved.
 #
 module Unobtainium
-  VERSION = "0.1.1".freeze
+  VERSION = "0.2.0".freeze
 end

data/lib/unobtainium/world.rb

@@ -53,6 +53,12 @@ module Unobtainium
         options = config["drivers.#{label}"]
       end
 
+      # The merged/extended options might define a "base"; that's the label
+      # we need to use.
+      if not options.nil? and not options["base"].nil?
+        label = options["base"]
+      end
+
       # The driver may modify the options; if so, we should let it do that
       # here. That way our key (below) is based on the expanded options.
       label, options = ::Unobtainium::Driver.sanitize_options(label, options)
@@ -64,19 +70,21 @@ module Unobtainium
       key = Digest::SHA1.hexdigest(key.to_s)
       key = "driver-#{key}"
 
-      # Only create a driver with this exact configuration once
-      dtor = ::Unobtainium::World.method(:driver_destructor)
-      return ::Unobtainium::Runtime.instance.store_with_if(key, dtor) do
-        ::Unobtainium::Driver.create(label, options)
-      end
-    end
-
-    class << self
-      def driver_destructor(the_driver = nil)
+      # Only create a driver with this exact configuration once. Unfortunately
+      # We'll have to bind the destructor to whatever configuration exists at
+      # this point in time, so we have to create a proc here - whether the Driver
+      # gets created or not.
+      at_end = config.fetch("at_end", "quit")
+      dtor = proc do |the_driver|
         if the_driver.nil?
           return
         end
-        the_driver.close
+
+        meth = at_end.to_sym
+        the_driver.send(meth)
+      end
+      return ::Unobtainium::Runtime.instance.store_with_if(key, dtor) do
+        ::Unobtainium::Driver.create(label, options)
       end
     end
   end # module World

data/spec/config_spec.rb

@@ -79,4 +79,30 @@ describe ::Unobtainium::Config do
     cfg = ::Unobtainium::Config.load_config(config)
     expect(cfg).to be_empty
   end
+
+  it "extends configuration hashes" do
+    config = File.join(@data_path, 'driverconfig.yml')
+    cfg = ::Unobtainium::Config.load_config(config)
+
+    # First, test for non-extended values
+    expect(cfg["drivers.mock.mockoption"]).to eql 42
+    expect(cfg["drivers.branch1.branch1option"]).to eql "foo"
+    expect(cfg["drivers.branch2.branch2option"]).to eql "bar"
+    expect(cfg["drivers.leaf.leafoption"]).to eql "baz"
+
+    # Now test extended values
+    expect(cfg["drivers.branch1.mockoption"]).to eql 42
+    expect(cfg["drivers.branch2.mockoption"]).to eql 42
+    expect(cfg["drivers.leaf.mockoption"]).to eql 42
+
+    expect(cfg["drivers.branch2.branch1option"]).to eql "foo"
+    expect(cfg["drivers.leaf.branch1option"]).to eql "override" # not "foo" !
+
+    expect(cfg["drivers.leaf.branch2option"]).to eql "bar"
+
+    # Also test that all levels go back to base == mock
+    expect(cfg["drivers.branch1.base"]).to eql 'mock'
+    expect(cfg["drivers.branch2.base"]).to eql 'mock'
+    expect(cfg["drivers.leaf.base"]).to eql 'mock'
+  end
 end

data/spec/data/driverconfig.yml

@@ -0,0 +1,23 @@
+# the hierarchy is mock -> branch1 -> branch2 -> leaf
+#
+# We test
+# a) having a base before its derived by ordering mock before branch1
+# b) having a base after its derived by ordering branch2 after leaf
+# c) overrides by having leaf override the option from branch1
+#
+# so the order in this file has to be mock -> branch2 -> branch1 -> leaf
+---
+drivers:
+  mock:
+    mockoption: 42
+  branch2:
+    extends: branch1
+    branch2option: bar
+  branch1:
+    extends: mock
+    branch1option: foo
+  leaf:
+    extends: branch2
+    leafoption: baz
+    branch1option: override
+driver: leaf

data/spec/pathed_hash_spec.rb

@@ -13,6 +13,11 @@ describe ::Unobtainium::PathedHash do
       expect(ph.empty?).to eql false
       expect(ph[:foo]).to eql 42
     end
+
+    it "can be constructed with a nil value" do
+      ph = ::Unobtainium::PathedHash.new(nil)
+      expect(ph.empty?).to eql true
+    end
   end
 
   describe "Hash-like" do
@@ -49,6 +54,20 @@ describe ::Unobtainium::PathedHash do
     expect(ph["bar.nope"]).to eql nil
   end
 
+  it "treats a single separator as the root" do
+    sample = { "foo" => 42 }
+    ph = ::Unobtainium::PathedHash.new(sample)
+
+    expect(ph[ph.separator]["foo"]).to eql 42
+  end
+
+  it "treats an empty path as the root" do
+    sample = { "foo" => 42 }
+    ph = ::Unobtainium::PathedHash.new(sample)
+
+    expect(ph[""]["foo"]).to eql 42
+  end
+
   it "can recursively write entries via a path" do
     ph = ::Unobtainium::PathedHash.new
     ph["foo.bar"] = 42
@@ -60,4 +79,58 @@ describe ::Unobtainium::PathedHash do
     ph = ::Unobtainium::PathedHash.new(h)
     expect(ph.to_s).to eql h.to_s
   end
+
+  it "understands absolute paths (starting with separator)" do
+    sample = {
+      "foo" => 42,
+      "bar" => {
+        "baz" => "quux",
+        "blah" => [1, 2],
+      }
+    }
+    ph = ::Unobtainium::PathedHash.new(sample)
+
+    expect(ph["bar.baz"]).to eql "quux"
+    expect(ph[".bar.baz"]).to eql "quux"
+  end
+
+  it "recursively merges with overwriting" do
+    sample1 = {
+      "foo" => {
+        "bar" => 42,
+        "baz" => "quux",
+      }
+    }
+    sample2 = {
+      "foo" => {
+        "baz" => "override"
+      }
+    }
+
+    ph1 = ::Unobtainium::PathedHash.new(sample1)
+    ph2 = ph1.recursive_merge(sample2)
+
+    expect(ph2["foo.bar"]).to eql 42
+    expect(ph2["foo.baz"]).to eql "override"
+  end
+
+  it "recursively merges without overwriting" do
+    sample1 = {
+      "foo" => {
+        "bar" => 42,
+        "baz" => "quux",
+      }
+    }
+    sample2 = {
+      "foo" => {
+        "baz" => "override"
+      }
+    }
+
+    ph1 = ::Unobtainium::PathedHash.new(sample1)
+    ph2 = ph1.recursive_merge(sample2, false)
+
+    expect(ph2["foo.bar"]).to eql 42
+    expect(ph2["foo.baz"]).to eql "quux"
+  end
 end

data/spec/world_spec.rb

@@ -9,7 +9,7 @@ end # class Tester
 describe ::Unobtainium::World do
   before :each do
     # Set configuration
-    path = File.join(File.dirname(__FILE__), 'data', 'world.yml')
+    path = File.join(File.dirname(__FILE__), 'data', 'driverconfig.yml')
     ::Unobtainium::World.config_file = path
 
     # Load MockDriver
@@ -20,7 +20,7 @@ describe ::Unobtainium::World do
   end
 
   it "loads the global config" do
-    expect(@tester.config["drivers.mock.option"]).to eql "value"
+    expect(@tester.config["drivers.mock.mockoption"]).to eql 42
   end
 
   it "creates a mock driver parameters" do
@@ -28,6 +28,10 @@ describe ::Unobtainium::World do
   end
 
   it "passed the config file options to the driver" do
-    expect(@tester.driver.passed_options["option"]).to eql "value"
+    expect(@tester.driver.passed_options["mockoption"]).to eql 42
+  end
+
+  it "extends driver options" do
+    expect(@tester.driver.passed_options["base"]).to eql "mock"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: unobtainium
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Jens Finkhaeuser
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-12 00:00:00.000000000 Z
+date: 2016-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -101,6 +101,7 @@ files:
 - Rakefile
 - cuke/.gitignore
 - cuke/Gemfile
+- cuke/Gemfile.lock
 - cuke/README.md
 - cuke/config/config.yml
 - cuke/features/step_definitions/steps.rb
@@ -112,6 +113,7 @@ files:
 - lib/unobtainium/drivers/appium.rb
 - lib/unobtainium/drivers/selenium.rb
 - lib/unobtainium/pathed_hash.rb
+- lib/unobtainium/recursive_merge.rb
 - lib/unobtainium/runtime.rb
 - lib/unobtainium/version.rb
 - lib/unobtainium/world.rb
@@ -119,6 +121,7 @@ files:
 - spec/data/array.yaml
 - spec/data/arraymerge-local.yaml
 - spec/data/arraymerge.yaml
+- spec/data/driverconfig.yml
 - spec/data/empty.yml
 - spec/data/hash.yml
 - spec/data/hashmerge-local.yml
@@ -164,6 +167,7 @@ test_files:
 - spec/data/array.yaml
 - spec/data/arraymerge-local.yaml
 - spec/data/arraymerge.yaml
+- spec/data/driverconfig.yml
 - spec/data/empty.yml
 - spec/data/hash.yml
 - spec/data/hashmerge-local.yml