flipper 0.24.1 → 1.3.0

data/lib/flipper/adapters/pstore.rb

@@ -1,3 +1,4 @@
+require 'json'
 require 'pstore'
 require 'set'
 require 'flipper'
@@ -9,19 +10,14 @@ module Flipper
     class PStore
       include ::Flipper::Adapter
 
-      FeaturesKey = :flipper_features
-
-      # Public: The name of the adapter.
-      attr_reader :name
-
       # Public: The path to where the file is stored.
       attr_reader :path
 
       # Public
       def initialize(path = 'flipper.pstore', thread_safe = true)
-        @name = :pstore
         @path = path
         @store = ::PStore.new(path, thread_safe)
+        @features_key = :flipper_features
       end
 
       # Public: The set of known features.
@@ -34,7 +30,7 @@ module Flipper
       # Public: Adds a feature to the set of known features.
       def add(feature)
         @store.transaction do
-          set_add FeaturesKey, feature.key
+          set_add @features_key, feature.key
         end
         true
       end
@@ -43,7 +39,7 @@ module Flipper
       # all the values for the feature.
       def remove(feature)
         @store.transaction do
-          set_delete FeaturesKey, feature.key
+          set_delete @features_key, feature.key
           clear_gates(feature)
         end
         true
@@ -88,6 +84,8 @@ module Flipper
             write key(feature, gate), thing.value.to_s
           when :set
             set_add key(feature, gate), thing.value.to_s
+          when :json
+            write key(feature, gate), Typecast.to_json(thing.value)
           else
             raise "#{gate} is not supported by this adapter yet"
           end
@@ -109,6 +107,10 @@ module Flipper
           @store.transaction do
             set_delete key(feature, gate), thing.value.to_s
           end
+        when :json
+          @store.transaction do
+            delete key(feature, gate)
+          end
         else
           raise "#{gate} is not supported by this adapter yet"
         end
@@ -135,7 +137,7 @@ module Flipper
       end
 
       def read_feature_keys
-        set_members FeaturesKey
+        set_members @features_key
       end
 
       def read_many_features(features)
@@ -150,12 +152,16 @@ module Flipper
         result = {}
 
         feature.gates.each do |gate|
+          key = key(feature, gate)
           result[gate.key] =
             case gate.data_type
             when :boolean, :integer
-              read key(feature, gate)
+              read key
             when :set
-              set_members key(feature, gate)
+              set_members key
+            when :json
+              value = read(key)
+              Typecast.from_json(value)
             else
               raise "#{gate} is not supported by this adapter yet"
             end

data/lib/flipper/adapters/read_only.rb

@@ -3,8 +3,8 @@ require 'flipper'
 module Flipper
   module Adapters
     # Public: Adapter that wraps another adapter and raises for any writes.
-    class ReadOnly
-      include ::Flipper::Adapter
+    class ReadOnly < Wrapper
+      WRITE_METHODS = %i[add remove clear enable disable]
 
       class WriteAttempted < Error
         def initialize(message = nil)
@@ -12,49 +12,16 @@ module Flipper
         end
       end
 
-      # Internal: The name of the adapter.
-      attr_reader :name
-
-      # Public
-      def initialize(adapter)
-        @adapter = adapter
-        @name = :read_only
-      end
-
-      def features
-        @adapter.features
-      end
-
-      def get(feature)
-        @adapter.get(feature)
-      end
-
-      def get_multi(features)
-        @adapter.get_multi(features)
+      def read_only?
+        true
       end
 
-      def get_all
-        @adapter.get_all
-      end
+      private
 
-      def add(_feature)
-        raise WriteAttempted
-      end
-
-      def remove(_feature)
-        raise WriteAttempted
-      end
-
-      def clear(_feature)
-        raise WriteAttempted
-      end
-
-      def enable(_feature, _gate, _thing)
-        raise WriteAttempted
-      end
+      def wrap(method, *args, **kwargs)
+        raise WriteAttempted if WRITE_METHODS.include?(method)
 
-      def disable(_feature, _gate, _thing)
-        raise WriteAttempted
+        yield
       end
     end
   end

data/lib/flipper/adapters/strict.rb

@@ -0,0 +1,45 @@
+module Flipper
+  module Adapters
+    # An adapter that ensures a feature exists before checking it.
+    class Strict < Wrapper
+      attr_reader :handler
+
+      class NotFound < ::Flipper::Error
+        def initialize(name)
+          super "Could not find feature #{name.inspect}. Call `Flipper.add(#{name.inspect})` to create it."
+        end
+      end
+
+      def initialize(adapter, handler = nil, &block)
+        super(adapter)
+        @handler = block || handler
+      end
+
+      def get(feature)
+        assert_feature_exists(feature)
+        super
+      end
+
+      def get_multi(features)
+        features.each { |feature| assert_feature_exists(feature) }
+        super
+      end
+
+      private
+
+      def assert_feature_exists(feature)
+        return if @adapter.features.include?(feature.key)
+
+        case handler
+        when Proc then handler.call(feature)
+        when :warn then warn NotFound.new(feature.key).message
+        when :noop, false, nil
+         # noop
+        else # truthy or :raise
+         raise NotFound.new(feature.key)
+        end
+      end
+
+    end
+  end
+end

data/lib/flipper/adapters/sync/feature_synchronizer.rb

@@ -9,6 +9,7 @@ module Flipper
       class FeatureSynchronizer
         extend Forwardable
 
+        def_delegator :@local_gate_values, :expression, :local_expression
         def_delegator :@local_gate_values, :boolean, :local_boolean
         def_delegator :@local_gate_values, :actors, :local_actors
         def_delegator :@local_gate_values, :groups, :local_groups
@@ -17,6 +18,7 @@ module Flipper
         def_delegator :@local_gate_values, :percentage_of_time,
                       :local_percentage_of_time
 
+        def_delegator :@remote_gate_values, :expression, :remote_expression
         def_delegator :@remote_gate_values, :boolean, :remote_boolean
         def_delegator :@remote_gate_values, :actors, :remote_actors
         def_delegator :@remote_gate_values, :groups, :remote_groups
@@ -40,8 +42,9 @@ module Flipper
             @feature.enable
           else
             @feature.disable if local_boolean_enabled?
-            sync_actors
             sync_groups
+            sync_actors
+            sync_expression
             sync_percentage_of_actors
             sync_percentage_of_time
           end
@@ -49,6 +52,12 @@ module Flipper
 
         private
 
+        def sync_expression
+          return if local_expression == remote_expression
+
+          @feature.enable_expression remote_expression
+        end
+
         def sync_actors
           remote_actors_added = remote_actors - local_actors
           remote_actors_added.each do |flipper_id|

data/lib/flipper/adapters/sync.rb

@@ -8,9 +8,6 @@ module Flipper
     class Sync
       include ::Flipper::Adapter
 
-      # Public: The name of the adapter.
-      attr_reader :name
-
       # Public: The synchronizer that will keep the local and remote in sync.
       attr_reader :synchronizer
 
@@ -22,7 +19,6 @@ module Flipper
       # interval - The Float or Integer number of seconds between syncs from
       # remote to local. Default value is set in IntervalSynchronizer.
       def initialize(local, remote, options = {})
-        @name = :sync
         @local = local
         @remote = remote
         @synchronizer = options.fetch(:synchronizer) do

data/lib/flipper/adapters/wrapper.rb

@@ -0,0 +1,54 @@
+module Flipper
+  module Adapters
+    # A base class for any adapter that wraps another adapter. By default, all methods
+    # delegate to the wrapped adapter. Implement `#wrap` to customize the behavior of
+    # all delegated methods, or override individual methods as needed.
+    class Wrapper
+      include Flipper::Adapter
+
+      METHODS = [
+        :import,
+        :export,
+        :features,
+        :add,
+        :remove,
+        :clear,
+        :get,
+        :get_multi,
+        :get_all,
+        :enable,
+        :disable,
+      ].freeze
+
+      attr_reader :adapter
+
+      def initialize(adapter)
+        @adapter = adapter
+      end
+
+      METHODS.each do |method|
+        if RUBY_VERSION >= '3.0'
+          define_method(method) do |*args, **kwargs|
+            wrap(method, *args, **kwargs) { @adapter.public_send(method, *args, **kwargs) }
+          end
+        else
+          define_method(method) do |*args|
+            wrap(method, *args) { @adapter.public_send(method, *args) }
+          end
+        end
+      end
+
+      # Override this method to customize the behavior of all delegated methods, and just yield to
+      # the block to call the wrapped adapter.
+      if RUBY_VERSION >= '3.0'
+        def wrap(method, *args, **kwargs, &block)
+          block.call
+        end
+      else
+        def wrap(method, *args, &block)
+          block.call
+        end
+      end
+    end
+  end
+end

data/lib/flipper/cli.rb

@@ -0,0 +1,263 @@
+require 'optparse'
+
+module Flipper
+  class CLI < OptionParser
+    def self.run(argv = ARGV)
+      new.run(argv)
+    end
+
+    # Path to the local Rails application's environment configuration.
+    DEFAULT_REQUIRE = "./config/environment"
+
+    attr_accessor :shell
+
+    def initialize(stdout: $stdout, stderr: $stderr, shell: Bundler::Thor::Base.shell.new)
+      super
+
+      # Program is always flipper, no matter how it's invoked
+      @program_name = 'flipper'
+      @require = ENV.fetch("FLIPPER_REQUIRE", DEFAULT_REQUIRE)
+      @commands = {}
+
+      # Extend whatever shell to support output redirection
+      @shell = shell.extend(ShellOutput)
+      shell.redirect(stdout: stdout, stderr: stderr)
+
+      %w[enable disable].each do |action|
+        command action do |c|
+          c.banner = "Usage: #{c.program_name} [options] <feature>"
+          c.description = "#{action.to_s.capitalize} a feature"
+
+          values = []
+
+          c.on('-a id', '--actor=id', "#{action} for an actor") do |id|
+            values << Actor.new(id)
+          end
+          c.on('-g name', '--group=name', "#{action} for a group") do |name|
+            values << Types::Group.new(name)
+          end
+          c.on('-p NUM', '--percentage-of-actors=NUM', Numeric, "#{action} for a percentage of actors") do |num|
+            values << Types::PercentageOfActors.new(num)
+          end
+          c.on('-t NUM', '--percentage-of-time=NUM', Numeric, "#{action} for a percentage of time") do |num|
+            values << Types::PercentageOfTime.new(num)
+          end
+          c.on('-x expressions', '--expression=NUM', "#{action} for the given expression") do |expression|
+            begin
+              values << Flipper::Expression.build(JSON.parse(expression))
+            rescue JSON::ParserError => e
+              ui.error "JSON parse error #{e.message}"
+              ui.trace(e)
+              exit 1
+            rescue ArgumentError => e
+              ui.error "Invalid expression: #{e.message}"
+              ui.trace(e)
+              exit 1
+            end
+          end
+
+          c.action do |feature|
+            f = Flipper.feature(feature)
+
+            if values.empty?
+              f.send(action)
+            else
+              values.each { |value| f.send(action, value) }
+            end
+
+            ui.info feature_details(f)
+          end
+        end
+      end
+
+      command 'list' do |c|
+        c.description = "List defined features"
+        c.action do
+          ui.info feature_summary(Flipper.features)
+        end
+      end
+
+      command 'show' do |c|
+        c.description = "Show a defined feature"
+        c.action do |feature|
+          ui.info feature_details(Flipper.feature(feature))
+        end
+      end
+
+      command 'help' do |c|
+        c.load_environment = false
+        c.action do |command = nil|
+          ui.info command ? @commands[command].help : help
+        end
+      end
+
+      on_tail('-r path', "The path to load your application. Default: #{@require}") do |path|
+        @require = path
+      end
+
+      # Options available on all commands
+      on_tail('-h', '--help', 'Print help message') do
+        ui.info help
+        exit
+      end
+
+      # Set help documentation
+      self.banner = "Usage: #{program_name} [options] <command>"
+      separator ""
+      separator "Commands:"
+
+      pad = @commands.keys.map(&:length).max + 2
+      @commands.each do |name, command|
+        separator "  #{name.to_s.ljust(pad, " ")} #{command.description}" if command.description
+      end
+
+      separator ""
+      separator "Options:"
+    end
+
+    def run(argv)
+      command, *args = order(argv)
+
+      if @commands[command]
+        load_environment! if @commands[command].load_environment
+        @commands[command].run(args)
+      else
+        ui.info help
+
+        if command
+          ui.error "Unknown command: #{command}"
+          exit 1
+        end
+      end
+    rescue OptionParser::InvalidOption => e
+      ui.error e.message
+      exit 1
+    end
+
+    # Helper method to define a new command
+    def command(name, &block)
+      @commands[name] = Command.new(program_name: "#{program_name} #{name}")
+      block.call(@commands[name])
+    end
+
+    def load_environment!
+      ENV["FLIPPER_CLOUD_LOGGING_ENABLED"] ||= "false"
+      require File.expand_path(@require)
+      # Ensure all of flipper gets loaded if it hasn't already.
+      require 'flipper'
+    rescue LoadError => e
+      ui.error e.message
+      exit 1
+    end
+
+    def feature_summary(features)
+      features = Array(features)
+      padding = features.map { |f| f.key.to_s.length }.max
+
+      features.map do |feature|
+        summary = case feature.state
+        when :on
+          colorize("⏺ enabled", [:GREEN])
+        when :off
+          "⦸ disabled"
+        else
+            "#{colorize("◯ enabled", [:YELLOW])} for " + feature.enabled_gates.map do |gate|
+            case gate.name
+            when :actor
+              pluralize feature.actors_value.size, 'actor', 'actors'
+            when :group
+              pluralize feature.groups_value.size, 'group', 'groups'
+            when :percentage_of_actors
+              "#{feature.percentage_of_actors_value}% of actors"
+            when :percentage_of_time
+              "#{feature.percentage_of_time_value}% of time"
+            when :expression
+              "an expression"
+            end
+          end.join(', ')
+        end
+
+        colorize("%-#{padding}s" % feature.key, [:BOLD, :WHITE]) + " is #{summary}"
+      end.join("\n")
+    end
+
+    def feature_details(feature)
+      summary = case feature.state
+      when :on
+        colorize("⏺ enabled", [:GREEN])
+      when :off
+        "⦸ disabled"
+      else
+        lines = feature.enabled_gates.map do |gate|
+          case gate.name
+          when :actor
+            [ pluralize(feature.actors_value.size, 'actor', 'actors') ] +
+            feature.actors_value.map { |actor| "- #{actor}" }
+          when :group
+            [ pluralize(feature.groups_value.size, 'group', 'groups') ] +
+            feature.groups_value.map { |group| "  - #{group}" }
+          when :percentage_of_actors
+            "#{feature.percentage_of_actors_value}% of actors"
+          when :percentage_of_time
+            "#{feature.percentage_of_time_value}% of time"
+          when :expression
+            json = indent(JSON.pretty_generate(feature.expression_value), 2)
+            "the expression: \n#{colorize(json, [:MAGENTA])}"
+          end
+        end
+
+        "#{colorize("◯ conditionally enabled", [:YELLOW])} for:\n" +
+        indent(lines.flatten.join("\n"), 2)
+      end
+
+      "#{colorize(feature.key, [:BOLD, :WHITE])} is #{summary}"
+    end
+
+    def pluralize(count, singular, plural)
+      "#{count} #{count == 1 ? singular : plural}"
+    end
+
+    def colorize(text, colors)
+      ui.add_color(text, *colors)
+    end
+
+    def ui
+      @ui ||= Bundler::UI::Shell.new.tap do |ui|
+        ui.shell = shell
+      end
+    end
+
+    def indent(text, spaces)
+      text.gsub(/^/, " " * spaces)
+    end
+
+    # Redirect the shell's output to the given stdout and stderr streams
+    module ShellOutput
+      attr_reader :stdout, :stderr
+
+      def redirect(stdout: $stdout, stderr: $stderr)
+        @stdout, @stderr = stdout, stderr
+      end
+    end
+
+    class Command < OptionParser
+      attr_accessor :description, :load_environment
+
+      def initialize(program_name: nil)
+        super()
+        @program_name = program_name
+        @load_environment = true
+        @action = lambda { }
+      end
+
+      def run(argv)
+        # Parse argv and call action with arguments
+        @action.call(*permute(argv))
+      end
+
+      def action(&block)
+        @action = block
+      end
+    end
+  end
+end