percolate 0.9.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2b8382f1bf97ccb41b8ef91a2072f5693d7c5b94ef9c5dee541b788b622683d3
+  data.tar.gz: 13845c16938b31f54a1e9e3e28b01bed59f7817342743e4b00a7594c2dd85a32
+SHA512:
+  metadata.gz: 2284c4ca4102771ec8664ebfa0c980bf416df8425274418fb1d1af8ffe34293d50de1640da86def3ce954037118bad5038018c4916042faf77b4bba3b8bc4275
+  data.tar.gz: 807c807e84365ffdb38f53fe1dd4569e2f03a1a4017be2312e760bb6eb24ba6e6a1d763ba3333aab758574ff75a4fd89969e3485259dfeff0fdd3d32509bee9d

data/lib/percolate.rb

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2014 Roy Liu
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+require "percolate/percolator"
+require "percolate/version"

data/lib/percolate/adapter/base_adapter.rb

@@ -0,0 +1,89 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2014 Roy Liu
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+require "active_support/inflector"
+
+module Percolate
+  module Adapter
+    # A base class to build off of.
+    class BaseAdapter
+      # The constructor.
+      #
+      # @param data_source [Object] the data source.
+      def initialize(data_source = nil)
+        @data_source = data_source
+      end
+
+      # Loads entities in an adapter-specific way.
+      #
+      # @return [Hash] the loaded entities.
+      def load_entities
+        {}
+      end
+
+      # Loads a facet.
+      #
+      # @param context [String] the lookup context.
+      # @param facet_name [Symbol] the facet name.
+      #
+      # @return [Object] the loaded facet.
+      def load_facet(context, facet_name)
+        create_facet(facet_name)
+      end
+
+      # Creates a facet from the given name.
+      #
+      # @param facet_name [Symbol] the facet name.
+      #
+      # @return [Object] the facet.
+      def create_facet(facet_name)
+        const_str = ActiveSupport::Inflector.camelize(facet_name) + "Facet"
+
+        begin
+          require "percolate/facet/#{facet_name}_facet"
+        rescue LoadError
+          # Do nothing. Give the benefit of the doubt if the file doesn't exist.
+        end if !Facet.const_defined?(const_str)
+
+        Facet.const_get(const_str).new
+      end
+
+      # Configures a facet according to the given attribute hash.
+      #
+      # @param facet [Object] the facet.
+      # @param attr_hash [Hash] the attribute hash.
+      #
+      # @return [Object] the facet.
+      def configure_facet(facet, attr_hash)
+        attr_hash.each_pair do |attr, value|
+          facet.send((attr + "=").to_sym, value)
+        end
+
+        facet
+      end
+
+      # If the given method isn't found, check for a setter of the same name.
+      def method_missing(sym, *args, &block)
+        if sym[-1] != "="
+          sym_set = (sym.to_s + "=").to_sym
+          return send(sym_set, *args, &block) if respond_to?(sym_set)
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/percolate/adapter/chef_data_bag_adapter.rb

@@ -0,0 +1,84 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2014 Roy Liu
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+require "active_support/inflector"
+
+require "percolate/adapter/base_adapter"
+require "percolate/util"
+
+module Percolate
+  module Adapter
+    # An adapter for loading from Chef data bags.
+    class ChefDataBagAdapter < BaseAdapter
+      attr_writer :entities_data_bag
+
+      def initialize(data_source)
+        super
+
+        @entities_data_bag = "entities"
+      end
+
+      def load_entities
+        begin
+          @data_source.data_bag(@entities_data_bag).reduce({}) do |current, item_name|
+            Percolate::Util.merge_attributes(
+                current,
+                @data_source.data_bag_item(@entities_data_bag, item_name).raw_data["entities"] || {}
+            )
+          end
+        rescue Net::HTTPServerException => e
+          # Reraise the exception if the status code isn't 404 Not Found.
+          if e.response.code != "404"
+            raise
+          end
+
+          nil
+        end
+      end
+
+      def load_facet(context, name)
+        name = name.to_s
+
+        facets = begin
+          @data_source.data_bag(context).map do |item_name|
+            facets_hash = @data_source.data_bag_item(context, item_name).raw_data["facets"]
+
+            facet_hash = facets_hash[name] || {}
+            facet_type = facet_hash.fetch("type", name)
+            facet_attrs = facet_hash.fetch("attrs", {})
+
+            configure_facet(create_facet(facet_type), facet_attrs)
+          end
+        rescue Net::HTTPServerException => e
+          # Reraise the exception if the status code isn't 404 Not Found.
+          if e.response.code != "404"
+            raise
+          end
+
+          []
+        end
+
+        if facets.size > 0
+          facets[1...facets.size].reduce(facets[0]) do |current, other|
+            current.merge(other)
+          end
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/percolate/adapter/fixture_adapter.rb

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2014 Roy Liu
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+require "percolate/adapter/base_adapter"
+
+module Percolate
+  module Adapter
+    # An adapter for exposing a fixed attribute `Hash`.
+    class FixtureAdapter < BaseAdapter
+      def initialize(data_source)
+        super
+      end
+
+      def load_entities
+        @data_source["entities"]
+      end
+
+      def load_facet(context, name)
+        name = name.to_s
+
+        facets_hash = @data_source["contexts"][context]["facets"]
+
+        if facets_hash.include?(name)
+          facet_hash = facets_hash[name]
+          facet_type = facet_hash.fetch("type", name)
+          facet_attrs = facet_hash.fetch("attrs", {})
+
+          configure_facet(create_facet(facet_type), facet_attrs)
+        else
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/percolate/facet/base_facet.rb

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2014 Roy Liu
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+module Percolate
+  module Facet
+    # A base class to build off of.
+    class BaseFacet
+      # Finds entity information from the given input.
+      #
+      # @param args [Array] the argument splat.
+      #
+      # @return [String] the entity name.
+      def find(*args)
+        nil
+      end
+
+      # Merges the given facet with this one.
+      #
+      # @param other [BaseFacet] the other facet.
+      #
+      # @return [BaseFacet] this facet.
+      def merge(other)
+        BaseFacet.new
+      end
+    end
+  end
+end

data/lib/percolate/facet/fixture_facet.rb

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2014 Roy Liu
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+require "percolate/facet/base_facet"
+
+module Percolate
+  module Facet
+    # A facet for looking up entities based on a fixed attribute `Hash`.
+    class FixtureFacet < BaseFacet
+      attr_accessor :fixtures
+
+      def initialize
+        @fixtures = {}
+      end
+
+      # Gets the fixtures.
+      #
+      # @return [Hash] the fixtures.
+      def fixtures
+        @fixtures
+      end
+
+      def find(key)
+        @fixtures[key]
+      end
+
+      def merge(other)
+        raise ArgumentError, "Please provide another #{self.class}" if !other.is_a?(FixtureFacet)
+
+        merged = FixtureFacet.new
+        merged.fixtures = @fixtures.merge(other.fixtures)
+
+        merged
+      end
+    end
+  end
+end

data/lib/percolate/facet/hostname_facet.rb

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2014 Roy Liu
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+require "percolate/facet/base_facet"
+
+module Percolate
+  module Facet
+    # A facet for looking up entities based on hostname.
+    class HostnameFacet < BaseFacet
+      attr_accessor :hostnames, :domains, :organizations
+
+      def initialize
+        @hostnames = {}
+        @domains = {}
+        @organizations = {}
+      end
+
+      def find(hostname)
+        return @hostnames[hostname] if @hostnames.include?(hostname)
+
+        comps = hostname.split(".", -1)
+        domain = comps[1...3].join(".")
+
+        return @domains[domain] if @domains.include?(domain)
+
+        organization = comps[1]
+
+        @organizations.fetch(organization, organization)
+      end
+
+      def merge(other)
+        raise ArgumentError, "Please provide another #{self.class}" if !other.is_a?(HostnameFacet)
+
+        merged = HostnameFacet.new
+        merged.hostnames = @hostnames.merge(other.hostnames)
+        merged.domains = @domains.merge(other.domains)
+        merged.organizations = @organizations.merge(other.organizations)
+
+        merged
+      end
+    end
+  end
+end

data/lib/percolate/facet/tag_facet.rb

@@ -0,0 +1,213 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2014 Roy Liu
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+require "set"
+
+if Gem::Version.new(RUBY_VERSION.dup) < Gem::Version.new("2.0.0")
+  require "backports/2.0.0/array"
+end
+
+require "percolate/facet/base_facet"
+
+module Percolate
+  module Facet
+    # A facet for looking up entities based on collections of tags.
+    class TagFacet < BaseFacet
+      attr_reader :poset_root
+
+      def initialize(poset_root = nil)
+        @poset_root = poset_root
+      end
+
+      # Sets the tag lookup rules.
+      #
+      # @param rules_hash [Hash] the lookup rules.
+      def rules=(rules_hash)
+        @poset_root = TagPoset.new
+
+        rules_hash.each do |rule_hash|
+          @poset_root.insert(rule_hash["tags"], rule_hash["value"])
+        end
+
+        rules_hash
+      end
+
+      def find(tags)
+        @poset_root.matches(tags).sort
+      end
+
+      def merge(other)
+        raise ArgumentError, "Please provide another #{self.class}" if !other.is_a?(TagFacet)
+
+        TagFacet.new(@poset_root.merge(other.poset_root))
+      end
+
+      # A data structure representing the partial order induced on collections of tags.
+      class TagPoset
+        attr_reader :tags, :value, :supersets
+
+        # The constructor.
+        #
+        # @param tags [Array] the tags.
+        # @param value [Object] the associated value.
+        # @param supersets [Array] the {TagPoset}s that contain tag supersets.
+        def initialize(tags = [], value = nil, supersets = [])
+          @tags = tags
+          @value = value
+          @supersets = supersets
+        end
+
+        # Inserts the given collection of tags and its associated value into the partial order.
+        #
+        # @param tags [Array] the tags.
+        # @param value [Object] the associated value.
+        # @param visited [Set] the visited {TagPoset}s so far, memoized by their tags.
+        def insert(tags, value, visited = Set.new)
+          tags = tags.sort
+
+          # We got an exact match. Override the value and return.
+          if @tags == tags
+            @value = value
+
+            return value
+          end
+
+          n_supersets = 0
+          subset_indices = []
+
+          @supersets.each_with_index do |superset, i|
+            if superset.tags - tags == []
+              superset.insert(tags, value, visited) if !visited.add?(superset.tags).nil?
+              n_supersets = n_supersets + 1
+            elsif tags - superset.tags == []
+              subset_indices.push(i)
+            end
+          end
+
+          # We visited a superset; there's no more work to be done in this frame.
+          if n_supersets > 0
+            return value
+          end
+
+          if !subset_indices.empty?
+            # The tags are a subset of at least one superset; insert them in between this poset and the superset(s).
+            tp = TagPoset.new(tags, value, subset_indices.map { |i| @supersets[i] })
+
+            subset_indices.each { |i| @supersets[i] = nil }
+            @supersets = @supersets.select { |item| !item.nil? }.to_a
+
+          else
+            # The tags are not a subset of any superset; insert them separately.
+            tp = TagPoset.new(tags, value, transitives(tags))
+          end
+
+          # Insert the new poset with binary search for stability.
+          insertion_index = (0...@supersets.size).bsearch { |i| (@supersets[i].tags <=> tags) >= 0 } || @supersets.size
+          @supersets.insert(insertion_index, tp)
+
+          value
+        end
+
+        # Finds transitive supersets that contain the given collection of tags.
+        #
+        # @param remainder [Array] the remaining tags to look for.
+        # @param visited [Set] the visited {TagPoset}s so far, memoized by their tags.
+        #
+        # @return [Array] the transitive supersets.
+        def transitives(remainder, visited = Set.new)
+          transitives = []
+
+          @supersets.each do |superset|
+            r_remainder = remainder - superset.tags
+
+            if r_remainder != []
+              r_transitives = superset.transitives(r_remainder, visited)
+
+              r_transitives = r_transitives.select do |r_superset|
+                transitives.select do |superset|
+                  superset.tags - r_superset.tags == []
+                end.empty?
+              end.to_a
+
+              transitives = transitives.select do |superset|
+                r_transitives.select do |r_superset|
+                  r_superset.tags - superset.tags == []
+                end.empty?
+              end.to_a
+
+              transitives.concat(r_transitives)
+            else
+              transitives.push(superset)
+            end if !visited.add?(superset.tags).nil?
+          end
+
+          transitives
+        end
+
+        # Calculates the best matches for the given collection of tags.
+        #
+        # @param tags [Array] the tags.
+        # @param visited [Set] the visited {TagPoset}s so far, memoized by their tags.
+        #
+        # @return [Array] the values associated with best matches.
+        def matches(tags, visited = Set.new)
+          tags = tags.sort
+
+          matches = []
+          n_supersets = 0
+
+          @supersets.each do |superset|
+            if superset.tags - tags == []
+              matches.concat(superset.matches(tags, visited)) if !visited.add?(superset.tags).nil?
+              n_supersets = n_supersets + 1
+            end
+          end
+
+          # We didn't visit a superset; push on the associated value as a best match.
+          if n_supersets == 0 && !@value.nil?
+            matches.push(@value)
+          end
+
+          matches
+        end
+
+        # Merges the given {TagPoset} with this one.
+        #
+        # @param other [TagPoset] the other {TagPoset}.
+        #
+        # @return [TagPoset] the merged result.
+        def merge(other)
+          TagPoset.new.merge!(self).merge!(other)
+        end
+
+        # Mutatively merges the given {TagPoset} with this one.
+        #
+        # @param other [TagPoset] the other {TagPoset}.
+        #
+        # @return [TagPoset] `self`.
+        def merge!(other, visited = Set.new)
+          insert(other.tags, other.value)
+
+          other.supersets.each do |superset|
+            merge!(superset, visited) if !visited.add?(superset.tags).nil?
+          end
+
+          self
+        end
+      end
+    end
+  end
+end

data/lib/percolate/percolator.rb

@@ -0,0 +1,124 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2014 Roy Liu
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+require "active_support/inflector"
+
+module Percolate
+  # Creates a {Percolator} from the given adapter name and data source.
+  #
+  # @param adapter_name [Symbol] the adapter name.
+  # @param data_source [Object] the data source.
+  # @param block [Proc] the configuration block.
+  #
+  # @return [Percolator] the {Percolator}.
+  def self.create(adapter_name, data_source = nil, &block)
+    const_str = ActiveSupport::Inflector.camelize(adapter_name) + "Adapter"
+
+    begin
+      require "percolate/adapter/#{adapter_name}_adapter"
+    rescue LoadError
+      # Do nothing. Give the benefit of the doubt if the file doesn't exist.
+    end if !Adapter.const_defined?(const_str)
+
+    adapter = Adapter.const_get(const_str).new(data_source)
+    percolator = Percolator.new(adapter)
+    percolator.load(&block)
+    percolator
+  end
+
+  # The class that percolates information from entities through facets to the user.
+  class Percolator
+    attr_reader :adapter, :entities
+
+    # The constructor.
+    #
+    # @param adapter [Object] the adapter to a data source.
+    def initialize(adapter)
+      @adapter = adapter
+      @facet_cache = {}
+    end
+
+    # Configures and loads the underlying adapter's entities.
+    #
+    # @param block [Proc] the configuration block.
+    def load(&block)
+      @adapter.instance_eval(&block) if !block.nil?
+      @entities = @adapter.load_entities
+
+      nil
+    end
+
+    # Finds an entity or entities.
+    #
+    # @param context [String] the lookup context.
+    # @param facet_name [Symbol] the facet name.
+    # @param args [Array] the argument splat passed to the facet.
+    #
+    # @return [Object] the retrieved entity or entities.
+    def find(context, facet_name, *args)
+      facet = find_facet(context, facet_name)
+
+      if !facet
+        return nil
+      end
+
+      case result = facet.find(*args)
+      when Array
+        result.map { |item| @entities[item] }
+      when String
+        @entities[result]
+      when NilClass
+        nil
+      else
+        raise "Bad facet return type #{result.class.name.dump}"
+      end
+    end
+
+    # Finds a facet.
+    #
+    # @param context [String] the lookup context.
+    # @param facet_name [Symbol] the facet name.
+    #
+    # @return [Object] the facet.
+    def find_facet(context, facet_name)
+      cache_key = [context, facet_name]
+
+      if @facet_cache.include?(cache_key)
+        facet = @facet_cache[cache_key]
+      else
+        begin
+          require "percolate/facet/#{facet_name}_facet"
+        rescue LoadError
+          # Do nothing. Give the benefit of the doubt if the file doesn't exist.
+        end
+
+        if facet = @adapter.load_facet(context, facet_name)
+          @facet_cache[cache_key] = facet
+        end
+      end
+
+      facet
+    end
+  end
+
+  # The namespace for adapters.
+  module Adapter
+  end
+
+  # The namespace for facets.
+  module Facet
+  end
+end

data/lib/percolate/util.rb

@@ -0,0 +1,48 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2014 Roy Liu
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+require "active_support/inflector"
+
+module Percolate
+  # Contains utility methods.
+  module Util
+    # Merges the given attributes, which can take the form of nested `Hash`es, `Array`s, and `String`s. If there is a
+    # conflict, the right hand side wins.
+    def self.merge_attributes(lhs, rhs)
+      if lhs.is_a?(Hash) && rhs.is_a?(Hash)
+        res = {}
+
+        lhs.each_pair do |key, value|
+          if rhs.include?(key)
+            res[key] = merge_attributes(lhs[key], rhs[key])
+          else
+            res[key] = value
+          end
+        end
+
+        rhs.each_pair do |key, value|
+          res[key] = value if !res.include?(key)
+        end
+      elsif lhs.is_a?(Array) && rhs.is_a?(Array)
+        res = lhs + rhs
+      else
+        res = rhs
+      end
+
+      res
+    end
+  end
+end

data/lib/percolate/version.rb

@@ -0,0 +1,34 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2014 Roy Liu
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+module Percolate
+  # A module containing the gem version information.
+  module Version
+    # The major version.
+    MAJOR = 0
+
+    # The minor version.
+    MINOR = 9
+
+    # The patch version.
+    PATCH = 4
+
+    # Gets the String representation of the gem version.
+    def self.to_s
+      "#{MAJOR}.#{MINOR}.#{PATCH}"
+    end
+  end
+end

data/spec/percolate_spec.rb

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2014 Roy Liu
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+require "percolate/adapter/base_adapter"
+
+require "spec_helper"
+
+describe Percolate do
+  it "finds adapters by the naming convention" do
+    percolator = Percolate.create(:base)
+
+    expect(percolator).to be_an_instance_of Percolate::Percolator
+    expect(percolator.adapter).to be_an_instance_of Percolate::Adapter::BaseAdapter
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+#
+# Copyright 2014 Roy Liu
+#
+# Licensed under the Apache License, Version 2.0 (the "License"); you may not
+# use this file except in compliance with the License. You may obtain a copy of
+# the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations under
+# the License.
+
+require "chefspec"
+require "chefspec/librarian"
+
+require "percolate"

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: percolate
+version: !ruby/object:Gem::Version
+  version: 0.9.4
+platform: ruby
+authors:
+- Roy Liu
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-03-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.2
+description: Percolate is a library for organizing and distributing configuration
+  settings. It contains adapters for frameworks like Chef, with which the user can
+  take full advantage of a declarative syntax for Chef data bags and avoid the antipattern
+  of representing initialization state with node attributes.
+email:
+- carsomyr@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/percolate.rb
+- lib/percolate/adapter/base_adapter.rb
+- lib/percolate/adapter/chef_data_bag_adapter.rb
+- lib/percolate/adapter/fixture_adapter.rb
+- lib/percolate/facet/base_facet.rb
+- lib/percolate/facet/fixture_facet.rb
+- lib/percolate/facet/hostname_facet.rb
+- lib/percolate/facet/tag_facet.rb
+- lib/percolate/percolator.rb
+- lib/percolate/util.rb
+- lib/percolate/version.rb
+- spec/percolate_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/carsomyr/percolate
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.3
+signing_key: 
+specification_version: 4
+summary: Percolate is a library for organizing and distributing configuration settings
+test_files:
+- spec/spec_helper.rb
+- spec/percolate_spec.rb