flipper 0.10.2 → 0.11.0.beta1

data/lib/flipper.rb

@@ -64,12 +64,9 @@ module Flipper
   #
   #   Flipper.group(:admins)
   #
-  # Returns the Flipper::Group if group registered.
-  # Raises Flipper::GroupNotRegistered if group is not registered.
+  # Returns Flipper::Group.
   def self.group(name)
-    groups_registry.get(name)
-  rescue Registry::KeyNotFound => e
-    raise GroupNotRegistered, "Group #{e.key.inspect} has not been registered"
+    groups_registry.get(name) || Types::Group.new(name)
   end
 
   # Internal: Registry of all groups_registry.

data/lib/flipper/adapter.rb

@@ -11,5 +11,15 @@ module Flipper
       end
       result
     end
+
+    def default_config
+      {
+        boolean: nil,
+        groups: Set.new,
+        actors: Set.new,
+        percentage_of_actors: nil,
+        percentage_of_time: nil,
+      }
+    end
   end
 end

data/lib/flipper/adapters/http.rb

@@ -0,0 +1,147 @@
+require 'net/http'
+require 'json'
+require 'set'
+require 'flipper'
+require 'flipper/adapters/http/error'
+require 'flipper/adapters/http/client'
+
+module Flipper
+  module Adapters
+    class Http
+      include Flipper::Adapter
+
+      attr_reader :name
+
+      def initialize(options = {})
+        @client = Client.new(uri: options.fetch(:uri),
+                             headers: options[:headers],
+                             basic_auth_username: options[:basic_auth_username],
+                             basic_auth_password: options[:basic_auth_password],
+                             read_timeout: options[:read_timeout],
+                             open_timeout: options[:open_timeout])
+        @name = :http
+      end
+
+      def get(feature)
+        response = @client.get("/features/#{feature.key}")
+        if response.is_a?(Net::HTTPOK)
+          parsed_response = JSON.parse(response.body)
+          result_for_feature(feature, parsed_response.fetch('gates'))
+        elsif response.is_a?(Net::HTTPNotFound)
+          default_config
+        else
+          raise Error, response
+        end
+      end
+
+      def add(feature)
+        body = JSON.generate(name: feature.key)
+        response = @client.post('/features', body)
+        response.is_a?(Net::HTTPOK)
+      end
+
+      def get_multi(features)
+        csv_keys = features.map(&:key).join(',')
+        response = @client.get("/features?keys=#{csv_keys}")
+        raise Error, response unless response.is_a?(Net::HTTPOK)
+
+        parsed_response = JSON.parse(response.body)
+        parsed_features = parsed_response.fetch('features')
+        gates_by_key = parsed_features.each_with_object({}) do |parsed_feature, hash|
+          hash[parsed_feature['key']] = parsed_feature['gates']
+          hash
+        end
+
+        result = {}
+        features.each do |feature|
+          result[feature.key] = result_for_feature(feature, gates_by_key[feature.key])
+        end
+        result
+      end
+
+      def features
+        response = @client.get('/features')
+        raise Error, response unless response.is_a?(Net::HTTPOK)
+
+        parsed_response = JSON.parse(response.body)
+        parsed_response['features'].map { |feature| feature['key'] }.to_set
+      end
+
+      def remove(feature)
+        response = @client.delete("/features/#{feature.key}")
+        response.is_a?(Net::HTTPNoContent)
+      end
+
+      def enable(feature, gate, thing)
+        body = request_body_for_gate(gate, thing.value.to_s)
+        query_string = gate.key == :groups ? "?allow_unregistered_groups=true" : ""
+        response = @client.post("/features/#{feature.key}/#{gate.key}#{query_string}", body)
+        response.is_a?(Net::HTTPOK)
+      end
+
+      def disable(feature, gate, thing)
+        body = request_body_for_gate(gate, thing.value.to_s)
+        query_string = gate.key == :groups ? "?allow_unregistered_groups=true" : ""
+        response =
+          case gate.key
+          when :percentage_of_actors, :percentage_of_time
+            @client.post("/features/#{feature.key}/#{gate.key}#{query_string}", body)
+          else
+            @client.delete("/features/#{feature.key}/#{gate.key}#{query_string}", body)
+          end
+        response.is_a?(Net::HTTPOK)
+      end
+
+      def clear(feature)
+        response = @client.delete("/features/#{feature.key}/clear")
+        response.is_a?(Net::HTTPNoContent)
+      end
+
+      private
+
+      def request_body_for_gate(gate, value)
+        data = case gate.key
+               when :boolean
+                 {}
+               when :groups
+                 { name: value }
+               when :actors
+                 { flipper_id: value }
+               when :percentage_of_actors, :percentage_of_time
+                 { percentage: value }
+               else
+                 raise "#{gate.key} is not a valid flipper gate key"
+               end
+        JSON.generate(data)
+      end
+
+      def result_for_feature(feature, api_gates)
+        api_gates ||= []
+        result = default_config
+
+        feature.gates.each do |gate|
+          api_gate = api_gates.detect { |ag| ag['key'] == gate.key.to_s }
+          result[gate.key] = value_for_gate(gate, api_gate) if api_gate
+        end
+
+        result
+      end
+
+      def value_for_gate(gate, api_gate)
+        value = api_gate['value']
+        case gate.data_type
+        when :boolean, :integer
+          value ? value.to_s : value
+        when :set
+          value ? value.to_set : Set.new
+        else
+          unsupported_data_type(gate.data_type)
+        end
+      end
+
+      def unsupported_data_type(data_type)
+        raise "#{data_type} is not supported by this adapter"
+      end
+    end
+  end
+end

data/lib/flipper/adapters/http/client.rb

@@ -0,0 +1,83 @@
+require 'uri'
+require 'openssl'
+require 'flipper/version'
+
+module Flipper
+  module Adapters
+    class Http
+      class Client
+        DEFAULT_HEADERS = {
+          'Content-Type' => 'application/json',
+          'Accept' => 'application/json',
+          'User-Agent' => "Flipper HTTP Adapter v#{VERSION}",
+        }.freeze
+
+        HTTPS_SCHEME = "https".freeze
+
+        def initialize(options = {})
+          @uri = URI(options.fetch(:uri))
+          @headers = DEFAULT_HEADERS.merge(options[:headers] || {})
+          @basic_auth_username = options[:basic_auth_username]
+          @basic_auth_password = options[:basic_auth_password]
+          @read_timeout = options[:read_timeout]
+          @open_timeout = options[:open_timeout]
+        end
+
+        def get(path)
+          perform Net::HTTP::Get, path, @headers
+        end
+
+        def post(path, body = nil)
+          perform Net::HTTP::Post, path, @headers, body: body
+        end
+
+        def delete(path, body = nil)
+          perform Net::HTTP::Delete, path, @headers, body: body
+        end
+
+        private
+
+        def perform(http_method, path, headers = {}, options = {})
+          uri = uri_for_path(path)
+          http = build_http(uri)
+          request = build_request(http_method, uri, headers, options)
+          http.request(request)
+        end
+
+        def uri_for_path(path)
+          uri = @uri.dup
+          path_uri = URI(path)
+          uri.path += path_uri.path
+          uri.query = "#{uri.query}&#{path_uri.query}" if path_uri.query
+          uri
+        end
+
+        def build_http(uri)
+          http = Net::HTTP.new(uri.host, uri.port)
+          http.read_timeout = @read_timeout if @read_timeout
+          http.open_timeout = @open_timeout if @open_timeout
+
+          if uri.scheme == HTTPS_SCHEME
+            http.use_ssl = true
+            http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          end
+
+          http
+        end
+
+        def build_request(http_method, uri, headers, options)
+          body = options[:body]
+          request = http_method.new(uri.request_uri)
+          request.initialize_http_header(headers) if headers
+          request.body = body if body
+
+          if @basic_auth_username && @basic_auth_password
+            request.basic_auth(@basic_auth_username, @basic_auth_password)
+          end
+
+          request
+        end
+      end
+    end
+  end
+end

data/lib/flipper/adapters/http/error.rb

@@ -0,0 +1,14 @@
+module Flipper
+  module Adapters
+    class Http
+      class Error < StandardError
+        attr_reader :response
+
+        def initialize(response)
+          @response = response
+          super("Failed with status: #{response.code}")
+        end
+      end
+    end
+  end
+end

data/lib/flipper/adapters/instrumented.rb

@@ -34,93 +34,93 @@ module Flipper
       # Public
       def features
         payload = {
-          :operation => :features,
-          :adapter_name => @adapter.name,
+          operation: :features,
+          adapter_name: @adapter.name,
         }
 
-        @instrumenter.instrument(InstrumentationName, payload) { |payload|
+        @instrumenter.instrument(InstrumentationName, payload) do |payload|
           payload[:result] = @adapter.features
-        }
+        end
       end
 
       # Public
       def add(feature)
         payload = {
-          :operation => :add,
-          :adapter_name => @adapter.name,
-          :feature_name => feature.name,
+          operation: :add,
+          adapter_name: @adapter.name,
+          feature_name: feature.name,
         }
 
-        @instrumenter.instrument(InstrumentationName, payload) { |payload|
+        @instrumenter.instrument(InstrumentationName, payload) do |payload|
           payload[:result] = @adapter.add(feature)
-        }
+        end
       end
 
       # Public
       def remove(feature)
         payload = {
-          :operation => :remove,
-          :adapter_name => @adapter.name,
-          :feature_name => feature.name,
+          operation: :remove,
+          adapter_name: @adapter.name,
+          feature_name: feature.name,
         }
 
-        @instrumenter.instrument(InstrumentationName, payload) { |payload|
+        @instrumenter.instrument(InstrumentationName, payload) do |payload|
           payload[:result] = @adapter.remove(feature)
-        }
+        end
       end
 
       # Public
       def clear(feature)
         payload = {
-          :operation => :clear,
-          :adapter_name => @adapter.name,
-          :feature_name => feature.name,
+          operation: :clear,
+          adapter_name: @adapter.name,
+          feature_name: feature.name,
         }
 
-        @instrumenter.instrument(InstrumentationName, payload) { |payload|
+        @instrumenter.instrument(InstrumentationName, payload) do |payload|
           payload[:result] = @adapter.clear(feature)
-        }
+        end
       end
 
       # Public
       def get(feature)
         payload = {
-          :operation => :get,
-          :adapter_name => @adapter.name,
-          :feature_name => feature.name,
+          operation: :get,
+          adapter_name: @adapter.name,
+          feature_name: feature.name,
         }
 
-        @instrumenter.instrument(InstrumentationName, payload) { |payload|
+        @instrumenter.instrument(InstrumentationName, payload) do |payload|
           payload[:result] = @adapter.get(feature)
-        }
+        end
       end
 
       # Public
       def enable(feature, gate, thing)
         payload = {
-          :operation => :enable,
-          :adapter_name => @adapter.name,
-          :feature_name => feature.name,
-          :gate_name => gate.name,
+          operation: :enable,
+          adapter_name: @adapter.name,
+          feature_name: feature.name,
+          gate_name: gate.name,
         }
 
-        @instrumenter.instrument(InstrumentationName, payload) { |payload|
+        @instrumenter.instrument(InstrumentationName, payload) do |payload|
           payload[:result] = @adapter.enable(feature, gate, thing)
-        }
+        end
       end
 
       # Public
       def disable(feature, gate, thing)
         payload = {
-          :operation => :disable,
-          :adapter_name => @adapter.name,
-          :feature_name => feature.name,
-          :gate_name => gate.name,
+          operation: :disable,
+          adapter_name: @adapter.name,
+          feature_name: feature.name,
+          gate_name: gate.name,
         }
 
-        @instrumenter.instrument(InstrumentationName, payload) { |payload|
+        @instrumenter.instrument(InstrumentationName, payload) do |payload|
           payload[:result] = @adapter.disable(feature, gate, thing)
-        }
+        end
       end
     end
   end

data/lib/flipper/adapters/memoizable.rb

@@ -120,15 +120,11 @@ module Flipper
       private
 
       def expire_feature(feature)
-        if memoizing?
-          cache.delete(feature.key)
-        end
+        cache.delete(feature.key) if memoizing?
       end
 
       def expire_features_set
-        if memoizing?
-          cache.delete(FeaturesKey)
-        end
+        cache.delete(FeaturesKey) if memoizing?
       end
     end
   end

data/lib/flipper/adapters/memory.rb

@@ -50,14 +50,15 @@ module Flipper
         result = {}
 
         feature.gates.each do |gate|
-          result[gate.key] = case gate.data_type
-          when :boolean, :integer
-            read key(feature, gate)
-          when :set
-            set_members key(feature, gate)
-          else
-            raise "#{gate} is not supported by this adapter yet"
-          end
+          result[gate.key] =
+            case gate.data_type
+            when :boolean, :integer
+              read key(feature, gate)
+            when :set
+              set_members key(feature, gate)
+            else
+              raise "#{gate} is not supported by this adapter yet"
+            end
         end
 
         result
@@ -96,7 +97,7 @@ module Flipper
       # Public
       def inspect
         attributes = [
-          "name=:memory",
+          'name=:memory',
           "source=#{@source.inspect}",
         ]
         "#<#{self.class.name}:#{object_id} #{attributes.join(', ')}>"