fake_florence 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6d2c5123d928582a6c986f0243198c4c4efecdf0
+  data.tar.gz: ec1eb451cc86867f18fc23cb37bc226a570d661d
+SHA512:
+  metadata.gz: ca69fa7eb6684c6f72401f27ef2c888c44a1c9560fca534bfcc9b62b747ccba271e6af3726587e0b6c4e6ccb6a216114f3e0a01aed49614a8dc27c2699b5351f
+  data.tar.gz: c02fdd8aaebffec882f0a9a368825376355140f3bb4cb8199ecf1ee36978a62d59d7ae772eb952107b1b9f54f98f02b58a37e40d258b42f88e54eb0371c51343

data/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 JP Hastings-Spital
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,51 @@
+# Fake Florence
+
+A command line application, bundled as a gem, which provides a stub interface for [Determinator](https://github.com/deliveroo/determinator) to read from.
+
+## Installation
+
+Install this gem with:
+
+```bash
+$ gem install fake_florence
+```
+
+## Usage
+
+Basic usage of the `flo` command line gem looks like this:
+
+```bash
+$ flo start
+Flo now is running at https://flo.dev
+Use other commands to create or edit Feature flags and Experiments.
+See `flo help` for more information
+
+$ flo create my_experiment
+my_experiment created and opened for editing
+```
+
+The default config expects that you have [puma-dev](https://github.com/puma/puma-dev) running, and https://flo.dev pointing to port 35600. You can do this with the command:
+
+```bash
+$ echo 35600 > ~/.puma-dev/flo
+```
+
+Once the Fake Florence server is running, point your instance of determinator at Flo and run `flo announce` to announce all the fake features you currently have specified.
+
+## Planned features
+
+- Better logging
+- Logging of requests for features received by the server
+- Tests
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/deliveroo/fake_florence. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the FakeFlorence project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/fake_florence/blob/master/CODE_OF_CONDUCT.md).

data/exe/flo

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+$LOAD_PATH.push(File.join(__dir__, '../lib'))
+require 'fake_florence'
+
+Process.setproctitle('flo')
+FakeFlorence::Cli.start

data/lib/fake_florence/announcers/routemaster.rb

@@ -0,0 +1,51 @@
+require 'faraday'
+
+module FakeFlorence
+  module Announcers
+    class Routemaster
+      attr_reader :name
+
+      def initialize(url, name: nil)
+        @name = name
+        @http = Faraday.new(url: url) do |f|
+          f.use Faraday::Response::RaiseError
+          f.request :json
+          f.adapter Faraday.default_adapter
+        end
+      end
+
+      def announce(hash)
+        t = Time.now.to_i
+
+        events = []
+        hash.each_pair do |type, features|
+          features.each do |feature|
+            events.push(
+              topic: 'feature',
+              type: type,
+              url: Config.url_for(feature),
+              t: t
+            )
+          end
+        end
+
+        res = @http.post do |req|
+          req.body = events.to_json
+        end
+
+        count = events.size
+        counter = "#{count} feature#{count == 1 ? '' : 's'}"
+        Config.log.info "#{counter} announced to '#{@name}'."
+        true
+
+      rescue Faraday::ConnectionFailed => e
+        Config.log.error e.message
+        false
+
+      rescue Faraday::Error::ClientError => e
+        Config.log.warn "Could not announce to #{@name}: HTTP #{e.response[:status]}"
+        false
+      end
+    end
+  end
+end

data/lib/fake_florence/announcers.rb

@@ -0,0 +1,15 @@
+module FakeFlorence
+  module Announcers
+    def self.load(config_array)
+      config_array.map do |config|
+        case config['type']
+        when 'routemaster'
+          require 'fake_florence/announcers/routemaster'
+          Routemaster.new(config['url'], name: config['name'])
+        else
+          raise "Unsupported announcer: #{config}"
+        end
+      end
+    end
+  end
+end

data/lib/fake_florence/cli.rb

@@ -0,0 +1,174 @@
+require 'thor'
+
+module FakeFlorence
+  class Cli < Thor
+    include Thor::Actions
+
+    def self.source_root
+      File.join(__dir__, '../../templates')
+    end
+
+    def help
+      puts <<~MSG
+      Fake Florence v#{VERSION} (#{status_text})
+
+      This is a command line application which will help you with development of Florence & Determinator based experiments and feature flags.
+      Find out more about specific commands with `#{set_color 'flo help [COMMAND]', :blue}`, but you're probably looking for:
+
+        #{set_color '$ flo start', :blue}
+        #{set_color '$ flo create my_experiment', :blue}
+
+      MSG
+      super
+    end
+
+    desc 'start', 'Starts the Florence server'
+    long_desc <<~MSG
+    Begins a Fake Florence webserver bound to the address and port given in the config file.
+    Typical usage is to run `flo start` then use `flo create` and `flo edit` to configure your features.
+    MSG
+
+    method_option(:daemonize,
+      aliases: '-d',
+      type: :boolean,
+      default: true,
+      desc: 'Run in the background'
+    )
+
+    def start
+      if daemon.running?
+        abort 'Flo is already running.'
+      else
+        puts <<~MSG
+        Flo is now #{set_color 'running', :green} at #{set_color Config.base_url, :white}
+        Use other commands to create or edit Feature flags and Experiments.
+        See `#{set_color 'flo help', :blue}` for more information
+        MSG
+
+        daemon.start(daemonize: options[:daemonize])
+      end
+    end
+
+    desc 'stop', 'Stops the Florence server'
+    long_desc <<~MSG
+    Stops any daemon or foregrounded copy of Fake Florence running on this machine.
+    This uses the PID file in the config directory for reference, so its location has been changed versions of Fake Florence may still be running.
+    MSG
+
+    def stop
+      if daemon.running?
+        daemon.stop
+        puts "Flo is now #{set_color 'stopped', :red}."
+      else
+        abort 'Flo was not running.'
+      end
+    end
+
+    desc 'status', 'The status of the Florence server'
+    long_desc <<~MSG
+    Declares whether Fake Florence is running or not.
+    MSG
+
+    def status
+      puts "Flo is #{status_text}"
+    end
+
+    desc 'edit [NAME]', 'Opens Feature Flags and Experiments for editing'
+    long_desc <<~MSG
+    Uses the editor defined in the '$EDITOR' environment variable to edit a given feature, by name.
+    If no name is given, the editor will be passed the folder name.
+    MSG
+
+    def edit(id = nil)
+      path = id.nil? ? cache.root : cache.id_to_file(id)
+
+      unless path.exist?
+        puts "This feature doesn't exist. In future, `#{set_color "flo create #{id}", :blue}` will provide a template to start from."
+      end
+
+      open_editor(path)
+      puts "#{set_color(id || 'The features folder', :white)} has been opened for editing"
+    end
+
+    desc 'create NAME', 'Creates a new feature for editing'
+    long_desc <<~MSG
+    Creates a new feature with the given name, with default configuration and opens it for editing.
+    MSG
+
+    def create(id)
+      path = cache.id_to_file(id)
+      copy_file('feature.yaml', path)
+      open_editor(path)
+      puts "#{set_color id, :white} created and opened for editing"
+    end
+
+    desc 'clone URL', 'Clones the features on the given server locally'
+    long_desc <<~MSG
+    Copies all the feature flags and experiments from a given remote server to the local instance of Fake Florence.
+    This is particularly useful for making your local instance of Fake Florence look like production.
+    MSG
+
+    def clone(url)
+      r = Retriever.new(url)
+
+      r.each_feature do |feature|
+        create_file(cache.id_to_file(feature.id)) do
+          feature.saveable
+        end
+      end
+    rescue Retriever::HTTPFailure => e
+      abort "HTTP error: #{e.message}"
+    rescue Retriever::NotFlorenceServerError
+      abort "The given URL doesn't quack like a Florence server"
+    end
+
+    desc 'announce', 'Announces all local features'
+
+    def announce
+      abort "Florence is #{status_text}, please `#{set_colour 'flo start', :blue}` before announcing." unless daemon.running?
+      Config.log.level = Logger::WARN
+      res = cache.announce_all_now
+      announcers = res[:announcers].map do |name|
+        set_color name, :white
+      end
+
+      if announcers.any?
+        puts "Announced #{set_color res[:features], :white} features to #{announcers.join(', ')}."
+      else
+        puts 'Did not announce any features.'
+      end
+    end
+
+    desc 'config', 'Opens the config file for editing'
+
+    def config
+      open_editor(Config.store_file)
+    end
+
+    desc 'logs', 'Tails the logfile'
+
+    def logs
+      exec("tail -f \"#{Config.logfile}\"")
+    end
+
+    private
+
+    def open_editor(path)
+      abort "Unsure how to edit #{path.to_s}\nEDITOR variable is empty" unless ENV['EDITOR']
+      system("$EDITOR \"#{path.to_s}\"")
+      abort "Flo failed to open #{path.to_s} for editing" unless $CHILD_STATUS.exitstatus == 0
+    end
+
+    def cache
+      @cache ||= FeatureCache.new(Config.home_dir)
+    end
+
+    def daemon
+      @daemon ||= FakeFlorence::Daemon.new
+    end
+
+    def status_text
+      daemon.running? ? set_color('running', :green) : set_color('stopped', :red)
+    end
+  end
+end

data/lib/fake_florence/config.rb

@@ -0,0 +1,78 @@
+require 'logger'
+require 'pathname'
+require 'uri'
+require 'yaml'
+
+module FakeFlorence
+  module Config
+    class << self
+      DEFAULT_CONFIG = Pathname.new(__dir__).join('../../templates/config.yaml').freeze
+      SEVERITY = {
+        'DEBUG' => '🤖',
+        'INFO'  => 'ℹ️',
+        'WARN'  => '⚠️',
+        'ERROR' => '😡',
+        'FATAL' => '🤢',
+      }.freeze
+
+      attr_accessor :log
+
+      def url_for(feature)
+        URI.join(
+          read_config(:base_url),
+          File.join(
+            mount_path,
+            feature.id
+          )
+        )
+      end
+
+      def store_file
+        home_dir.join('config.yaml')
+      end
+
+      def home_dir
+        Pathname.new('~/.flo').expand_path.tap do |home|
+          home.mkpath
+        end
+      end
+
+      def log
+        @log ||= Logger.new($stdout).tap do |logger|
+          logger.formatter = -> (sev, time, name, msg) do
+            "#{time.utc.strftime('%Y-%m-%d %H:%M:%SZ')} #{SEVERITY[sev]}: #{msg}\n"
+          end
+        end
+      end
+
+      def pidfile
+        home_dir.join('flo.pid')
+      end
+
+      def logfile
+        home_dir.join('flo.log')
+      end
+
+      def method_missing(m)
+        read_config(m)
+      end
+
+      private
+
+      def read_config(key)
+        @config_data ||= begin
+          if store_file.exist?
+            YAML.load_file(store_file)
+          else
+            YAML.load_file(DEFAULT_CONFIG).tap do |data|
+              File.open(store_file, 'w') do |f|
+                YAML.dump(data, f)
+              end
+            end
+          end
+        end
+        @config_data[key.to_s]
+      end
+    end
+  end
+end

data/lib/fake_florence/daemon.rb

@@ -0,0 +1,66 @@
+module FakeFlorence
+  class Daemon
+    def initialize
+      @cache = FeatureCache.new(Config.home_dir)
+      @announcers = Announcers.load(Config.announce)
+    end
+
+    def run
+      start_listeners
+      Server.set :feature_cache, @cache
+      Config.log.info "Florence is listening at #{Config.base_url}"
+
+      prepare_for_run
+      Server.run!
+    end
+
+    def start(daemonize:)
+      raise 'Already running' if running?
+
+      if daemonize
+        $stdout = Config.logfile.open('a')
+        $stdout.sync = true
+        Process.daemon(true)
+      end
+
+      run
+    end
+
+    def stop
+      raise 'Not running' unless running?
+
+      Process.kill('TERM', pid)
+    end
+
+    def running?
+      return false if pid.nil?
+      Process.getpgid(pid)
+      true
+    rescue Errno::ESRCH
+      Config.pidfile.delete
+      false
+    end
+
+    def pid
+      Config.pidfile.read.to_i
+    rescue Errno::ENOENT
+      nil
+    end
+
+    private
+
+    def start_listeners
+      @announcers.each do |announcer|
+        @cache.register_listener(&announcer.method(:announce))
+      end
+    end
+
+    def prepare_for_run
+      Config.pidfile.write(Process.pid)
+      at_exit do
+        Config.pidfile.delete if Config.pidfile.exist?
+        Config.log.info 'Shutting down'
+      end
+    end
+  end
+end

data/lib/fake_florence/feature.rb

@@ -0,0 +1,30 @@
+require 'yaml'
+require 'json'
+require 'ostruct'
+
+module FakeFlorence
+  class Feature < OpenStruct
+    def self.read(id, pathname)
+      new(YAML.load_file(pathname)).tap do |feature|
+        feature[:id] = id
+      end
+    end
+
+    def initialize(keys = {})
+      super(FeatureSchema.call(keys).to_h)
+    end
+
+    def to_h
+      each_pair.reduce({}) do |h, (k, v)|
+        h[k.to_s] = v
+        h
+      end
+    end
+
+    def saveable
+      to_h.tap do |h|
+        h.delete('id')
+      end.to_yaml
+    end
+  end
+end

data/lib/fake_florence/feature_cache.rb

@@ -0,0 +1,75 @@
+require 'listen'
+
+module FakeFlorence
+  class FeatureCache
+    attr_reader :root
+
+    def initialize(path)
+      @root = path.join('features')
+      @root.mkpath
+      @callbacks = []
+    end
+
+    def features
+      Dir.glob(@root.join('*.yaml')).map(&method(:file_to_feature))
+    end
+
+    def feature(id)
+      Feature.read(id, id_to_file(id))
+    end
+
+    def register_listener(&block)
+      @callbacks.push(block)
+      listen_for_changes unless @listener
+    end
+
+    def id_to_file(id)
+      @root.join("#{id}.yaml")
+    end
+
+    def announce_all_now
+      names = []
+
+      Announcers.load(Config.announce).each do |announcer|
+        names.push(announcer.name) if announcer.announce(noop: features)
+      end
+
+      { features: features.size, announcers: names }
+    end
+
+    private
+
+    def listen_for_changes
+      @listener = Listen.to(@root.to_s, only: /.yaml$/) do |updated, created, deleted|
+        features_map = {
+          create: created.map(&method(:file_to_feature)),
+          update: updated.map(&method(:file_to_feature)),
+          delete: deleted.map(&method(:file_to_stub_feature)),
+        }
+
+        features_map.each_pair do |type, fs|
+          next if fs.empty?
+          Config.log.debug "Features #{type}d: #{fs.map(&:id).join(', ')}"
+        end
+
+        @callbacks.each do |callback|
+          callback.call(features_map)
+        end
+      end
+
+      @listener.start
+    end
+
+    def file_to_feature(file)
+      Feature.read(file_to_id(file), file)
+    end
+
+    def file_to_stub_feature(file)
+      Feature.new('id' => file_to_id(file))
+    end
+
+    def file_to_id(file)
+      File.basename(file, '.yaml')
+    end
+  end
+end

data/lib/fake_florence/feature_schema.rb

@@ -0,0 +1,28 @@
+require 'dry-validation'
+
+module FakeFlorence
+  FeatureSchema = Dry::Validation.Schema do
+    configure { config.input_processor = :sanitizer }
+
+    required('id').maybe(:str?)
+
+    required('name').filled(:str?)
+    required('identifier').filled(:str?)
+    required('bucket_type').filled(:str?)
+    required('active').filled(:bool?)
+    required('target_groups').each do
+      schema do
+        required('rollout') { int? & gteq?(0) & lteq?(65536) }
+        # TODO: any key => :str?
+        required('constraints').filled(:hash?)
+      end
+    end
+
+    # TODO: any key => :int?
+    required('variants').filled(:hash?)
+    required('winning_variant').filled(:str?)
+
+    # TODO: any key => :str?, :bool?
+    required('overrides', Dry::Types::Hash).filled
+  end
+end

data/lib/fake_florence/retriever.rb

@@ -0,0 +1,47 @@
+require 'faraday'
+require 'pp'
+require 'faraday_middleware'
+
+module FakeFlorence
+  class Retriever
+
+    class NotFlorenceServerError < RuntimeError; end
+    class HTTPFailure < RuntimeError; end
+
+    def initialize(root_url)
+      @root = root_url
+
+      @http = Faraday.new do |f|
+        f.response :json, content_type: /\bjson$/
+        f.use Faraday::Response::RaiseError
+        f.adapter Faraday.default_adapter
+      end
+    end
+
+    def each_feature
+      urls = [@root]
+
+      while url = urls.shift
+        response = @http.get(url)
+        links = response.body['_links']
+        raise NotFlorenceServerError if links.nil?
+
+        urls << links['next']['href'] if links['next']
+
+        (links['features'] ||[]).each do |listing|
+          yield get_feature(listing['href'])
+        end
+      end
+    rescue Faraday::Error::ClientError => e
+      Config.log.debug e.message
+      raise HTTPFailure
+    end
+
+    private
+
+    def get_feature(url)
+      response = @http.get(url)
+      Feature.new(response.body)
+    end
+  end
+end

data/lib/fake_florence/server.rb

@@ -0,0 +1,66 @@
+require 'sinatra/base'
+
+module FakeFlorence
+  class Server < Sinatra::Base
+    set :bind, Config.bind
+    set :port, Config.port
+    set :quiet, false
+    set :show_exceptions, false
+    set :server, :puma
+    set :server_settings, { Silent: true }
+    set :environment, :production
+
+    use Rack::CommonLogger, Config.log
+
+    helpers do
+      def feature
+        settings.feature_cache.feature(params[:id])
+      rescue Errno::ENOENT
+        halt 404
+      end
+
+      def url_for(*path_bits)
+        File.join(Config.base_url, *path_bits)
+      end
+
+      def jsonhal_for(*path_bits, extra_links: {})
+        {
+          _links: {
+            curies: [],
+            self: { href: url_for(*path_bits) }
+          }.merge(extra_links)
+        }.tap { |doc|
+          doc.merge!(yield) if block_given?
+        }.to_json
+      end
+    end
+
+    before do
+      content_type :json
+    end
+
+    get '/' do
+      jsonhal_for('/', extra_links: {
+        features: { href: url_for(Config.mount_path) },
+        feature: {
+          href: url_for(File.join(Config.mount_path, '{id}')),
+          templated: true
+        }
+      })
+    end
+
+    get Config.mount_path do
+      jsonhal_for(Config.mount_path, extra_links: {
+        features: settings.feature_cache.features.map { |feature|
+          { href: url_for(Config.mount_path, feature.id) }
+        }
+      })
+    end
+
+    get File.join(Config.mount_path, ':id') do
+      jsonhal_for(Config.mount_path, feature.id) do
+        feature.to_h
+      end
+    end
+  end
+end

data/lib/fake_florence/version.rb

@@ -0,0 +1,3 @@
+module FakeFlorence
+  VERSION = '1.0.0'
+end

data/lib/fake_florence.rb

@@ -0,0 +1,14 @@
+require 'fake_florence/announcers'
+require 'fake_florence/cli'
+require 'fake_florence/config'
+require 'fake_florence/daemon'
+require 'fake_florence/feature'
+require 'fake_florence/feature_cache'
+require 'fake_florence/feature_schema'
+require 'fake_florence/retriever'
+require 'fake_florence/server'
+require 'fake_florence/version'
+
+module FakeFlorence
+  
+end

data/templates/config.yaml

@@ -0,0 +1,18 @@
+## Server settings
+
+# The address the server is going to listen on. Probably best to stick local.
+bind: 127.0.0.1
+# The port that Fake Florence will run on.
+port: 35600
+# This will be the URL Fake Florence uses in its responses. Using puma-dev is
+# recommended (https://github.com/puma/puma-dev)
+base_url: https://flo.dev
+# The path at which feature information will be mouted. It's highly unlikely you
+# need to change this.
+mount_path: /features
+# These are the services that will be pinged whenever a feature is added, edited
+# or removed. This can be an empty array if you like.
+announce:
+  - type: routemaster
+    name: Determinator Example
+    url: https://determinator-example.dev/events

data/templates/feature.yaml

@@ -0,0 +1,58 @@
+## A Florence template file
+
+# A human readable description of the Feature flag or experiment
+name: A descriptive name
+# The identifier is the salt that determines the seed
+# for the random distribution. Two experiments with the
+# same identifier would have the same actors in the same
+# variants.
+identifier: anything
+# Which of an actor's identifying properties will be used
+# to bucket them into rollouts and variants. 'id' and 'guid'
+# are self-evident, 'fallback' uses the actor's id, if
+# available, or uses the actor's guid if not.
+bucket_type: id
+# Inactive features are always off
+active: true
+# Each target group specifies a rollout fraction and a number
+# of constraints that limit the actors to which this rollout
+# will apply.
+target_groups:
+  # The rollout fraction is out of 65536
+- rollout: 65536
+  # Every constraint must be matched by the actor for the
+  # given rollout to apply. This can be an empty hash to mean
+  # 'every actor'.
+  constraints:
+    # Here, the actor's 'platform' must be 'ios'
+    platform: ios
+    # Here, the actor's 'country' must be either 'uk' or 'de'
+    country: [uk, de]
+
+## Experiment only options
+
+# Listing variants declares this an experiment
+# Each key of this hash is the string which will
+# be given if the actor is in that variant.
+# Each value is the weighting of that variant,
+# eg. if all are '1' then the actors have an equal
+# chance of being in each variant.
+variants:
+  # The first is always considered the control.
+  anchovy: 1
+  mackerel: 1
+# A non-null value declares the winner of the experiment
+# and the result that all actors within any target group's
+# rollout will see.
+winning_variant: anchovy
+
+# Overrides force specific actors to have a given outcome,
+# instead of the determinated one. Because actors must be
+# specified by identifier this should be kept to a select
+# few for testing and evaluation. Target Groups should be
+# used instead product cases.
+overrides:
+  # The key is the actor identifier (ie. the ID or anonymous
+  # ID as specified by the buckt type).
+  # The key is the desired outcome for this actor.
+  123: false

metadata

@@ -0,0 +1,190 @@
+--- !ruby/object:Gem::Specification
+name: fake_florence
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- JP Hastings-Spital
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-09-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dry-validation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: listen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.20'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.20'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: A local Florence server for use with Determinator locally
+email:
+- jp@deliveroo.co.uk
+executables:
+- flo
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.md
+- README.md
+- exe/flo
+- lib/fake_florence.rb
+- lib/fake_florence/announcers.rb
+- lib/fake_florence/announcers/routemaster.rb
+- lib/fake_florence/cli.rb
+- lib/fake_florence/config.rb
+- lib/fake_florence/daemon.rb
+- lib/fake_florence/feature.rb
+- lib/fake_florence/feature_cache.rb
+- lib/fake_florence/feature_schema.rb
+- lib/fake_florence/retriever.rb
+- lib/fake_florence/server.rb
+- lib/fake_florence/version.rb
+- templates/config.yaml
+- templates/feature.yaml
+homepage: https://github.com/deliveroo/fake_florence
+licenses:
+- MIT
+metadata: {}
+post_install_message: 'Fake Florence has been installed. Run `flo help` for more information.
+
+'
+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.5.1
+signing_key: 
+specification_version: 4
+summary: A local Florence server for use with Determinator locally
+test_files: []