fluid_cli 0.1.2

data/vendor/deps/observer/README.md

@@ -0,0 +1,139 @@
+# Observer
+
+The Observer pattern (also known as publish/subscribe) provides a simple
+mechanism for one object to inform a set of interested third-party objects
+when its state changes.
+
+## Mechanism
+
+The notifying class mixes in the +Observable+
+module, which provides the methods for managing the associated observer
+objects.
+
+The observable object must:
+
+* assert that it has +#changed+
+* call +#notify_observers+
+
+An observer subscribes to updates using Observable#add_observer, which also
+specifies the method called via #notify_observers. The default method for
+notify_observers is #update.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'observer'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install observer
+
+## Usage
+
+The following example demonstrates this nicely.  A +Ticker+, when run,
+continually receives the stock +Price+ for its <tt>@symbol</tt>.  A +Warner+
+is a general observer of the price, and two warners are demonstrated, a
++WarnLow+ and a +WarnHigh+, which print a warning if the price is below or
+above their set limits, respectively.
+
+The +update+ callback allows the warners to run without being explicitly
+called.  The system is set up with the +Ticker+ and several observers, and the
+observers do their duty without the top-level code having to interfere.
+
+Note that the contract between publisher and subscriber (observable and
+observer) is not declared or enforced.  The +Ticker+ publishes a time and a
+price, and the warners receive that.  But if you don't ensure that your
+contracts are correct, nothing else can warn you.
+
+```ruby
+require "observer"
+
+class Ticker          ### Periodically fetch a stock price.
+
+  include Observable
+
+  def initialize(symbol)
+    @symbol = symbol
+  end
+
+  def run
+    last_price = nil
+    loop do
+      price = Price.fetch(@symbol)
+      print "Current price: #{price}\n"
+      if price != last_price
+        changed                 # notify observers
+        last_price = price
+        notify_observers(Time.now, price)
+      end
+      sleep 1
+    end
+  end
+end
+
+class Price           ### A mock class to fetch a stock price (60 - 140).
+  def self.fetch(symbol)
+    60 + rand(80)
+  end
+end
+
+class Warner          ### An abstract observer of Ticker objects.
+  def initialize(ticker, limit)
+    @limit = limit
+    ticker.add_observer(self)
+  end
+end
+
+class WarnLow < Warner
+  def update(time, price)       # callback for observer
+    if price < @limit
+      print "--- #{time.to_s}: Price below #@limit: #{price}\n"
+    end
+  end
+end
+
+class WarnHigh < Warner
+  def update(time, price)       # callback for observer
+    if price > @limit
+      print "+++ #{time.to_s}: Price above #@limit: #{price}\n"
+    end
+  end
+end
+
+ticker = Ticker.new("MSFT")
+WarnLow.new(ticker, 80)
+WarnHigh.new(ticker, 120)
+ticker.run
+```
+
+Produces:
+
+```
+Current price: 83
+Current price: 75
+--- Sun Jun 09 00:10:25 CDT 2002: Price below 80: 75
+Current price: 90
+Current price: 134
++++ Sun Jun 09 00:10:25 CDT 2002: Price above 120: 134
+Current price: 134
+Current price: 112
+Current price: 79
+--- Sun Jun 09 00:10:25 CDT 2002: Price below 80: 79
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ruby/observer.

data/vendor/deps/observer/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/test_*.rb"]
+end
+
+task :default => :test

data/vendor/deps/observer/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "observer"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/vendor/deps/observer/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/vendor/deps/observer/lib/observer.rb

@@ -0,0 +1,229 @@
+# frozen_string_literal: true
+#
+# Implementation of the _Observer_ object-oriented design pattern.  The
+# following documentation is copied, with modifications, from "Programming
+# Ruby", by Hunt and Thomas; http://www.ruby-doc.org/docs/ProgrammingRuby/html/lib_patterns.html.
+#
+# See Observable for more info.
+
+# The Observer pattern (also known as publish/subscribe) provides a simple
+# mechanism for one object to inform a set of interested third-party objects
+# when its state changes.
+#
+# == Mechanism
+#
+# The notifying class mixes in the +Observable+
+# module, which provides the methods for managing the associated observer
+# objects.
+#
+# The observable object must:
+# * assert that it has +#changed+
+# * call +#notify_observers+
+#
+# An observer subscribes to updates using Observable#add_observer, which also
+# specifies the method called via #notify_observers. The default method for
+# #notify_observers is #update.
+#
+# === Example
+#
+# The following example demonstrates this nicely.  A +Ticker+, when run,
+# continually receives the stock +Price+ for its <tt>@symbol</tt>.  A +Warner+
+# is a general observer of the price, and two warners are demonstrated, a
+# +WarnLow+ and a +WarnHigh+, which print a warning if the price is below or
+# above their set limits, respectively.
+#
+# The +update+ callback allows the warners to run without being explicitly
+# called.  The system is set up with the +Ticker+ and several observers, and the
+# observers do their duty without the top-level code having to interfere.
+#
+# Note that the contract between publisher and subscriber (observable and
+# observer) is not declared or enforced.  The +Ticker+ publishes a time and a
+# price, and the warners receive that.  But if you don't ensure that your
+# contracts are correct, nothing else can warn you.
+#
+#   require "observer"
+#
+#   class Ticker          ### Periodically fetch a stock price.
+#     include Observable
+#
+#     def initialize(symbol)
+#       @symbol = symbol
+#     end
+#
+#     def run
+#       last_price = nil
+#       loop do
+#         price = Price.fetch(@symbol)
+#         print "Current price: #{price}\n"
+#         if price != last_price
+#           changed                 # notify observers
+#           last_price = price
+#           notify_observers(Time.now, price)
+#         end
+#         sleep 1
+#       end
+#     end
+#   end
+#
+#   class Price           ### A mock class to fetch a stock price (60 - 140).
+#     def self.fetch(symbol)
+#       60 + rand(80)
+#     end
+#   end
+#
+#   class Warner          ### An abstract observer of Ticker objects.
+#     def initialize(ticker, limit)
+#       @limit = limit
+#       ticker.add_observer(self)
+#     end
+#   end
+#
+#   class WarnLow < Warner
+#     def update(time, price)       # callback for observer
+#       if price < @limit
+#         print "--- #{time.to_s}: Price below #@limit: #{price}\n"
+#       end
+#     end
+#   end
+#
+#   class WarnHigh < Warner
+#     def update(time, price)       # callback for observer
+#       if price > @limit
+#         print "+++ #{time.to_s}: Price above #@limit: #{price}\n"
+#       end
+#     end
+#   end
+#
+#   ticker = Ticker.new("MSFT")
+#   WarnLow.new(ticker, 80)
+#   WarnHigh.new(ticker, 120)
+#   ticker.run
+#
+# Produces:
+#
+#   Current price: 83
+#   Current price: 75
+#   --- Sun Jun 09 00:10:25 CDT 2002: Price below 80: 75
+#   Current price: 90
+#   Current price: 134
+#   +++ Sun Jun 09 00:10:25 CDT 2002: Price above 120: 134
+#   Current price: 134
+#   Current price: 112
+#   Current price: 79
+#   --- Sun Jun 09 00:10:25 CDT 2002: Price below 80: 79
+#
+# === Usage with procs
+#
+# The +#notify_observers+ method can also be used with +proc+s by using
+# the +:call+ as +func+ parameter.
+#
+# The following example illustrates the use of a lambda:
+#
+#   require 'observer'
+#
+#   class Ticker
+#     include Observable
+#
+#     def run
+#       # logic to retrieve the price (here 77.0)
+#       changed
+#       notify_observers(77.0)
+#     end
+#   end
+#
+#   ticker = Ticker.new
+#   warner = ->(price) { puts "New price received: #{price}" }
+#   ticker.add_observer(warner, :call)
+#   ticker.run
+module Observable
+  VERSION = "0.1.2"
+
+  #
+  # Add +observer+ as an observer on this object. So that it will receive
+  # notifications.
+  #
+  # +observer+:: the object that will be notified of changes.
+  # +func+:: Symbol naming the method that will be called when this Observable
+  #          has changes.
+  #
+  #          This method must return true for +observer.respond_to?+ and will
+  #          receive <tt>*arg</tt> when #notify_observers is called, where
+  #          <tt>*arg</tt> is the value passed to #notify_observers by this
+  #          Observable
+  def add_observer(observer, func=:update)
+    @observer_peers = {} unless defined? @observer_peers
+    unless observer.respond_to? func
+      raise NoMethodError, "observer does not respond to `#{func}'"
+    end
+    @observer_peers[observer] = func
+  end
+
+  #
+  # Remove +observer+ as an observer on this object so that it will no longer
+  # receive notifications.
+  #
+  # +observer+:: An observer of this Observable
+  def delete_observer(observer)
+    @observer_peers.delete observer if defined? @observer_peers
+  end
+
+  #
+  # Remove all observers associated with this object.
+  #
+  def delete_observers
+    @observer_peers.clear if defined? @observer_peers
+  end
+
+  #
+  # Return the number of observers associated with this object.
+  #
+  def count_observers
+    if defined? @observer_peers
+      @observer_peers.size
+    else
+      0
+    end
+  end
+
+  #
+  # Set the changed state of this object.  Notifications will be sent only if
+  # the changed +state+ is +true+.
+  #
+  # +state+:: Boolean indicating the changed state of this Observable.
+  #
+  def changed(state=true)
+    @observer_state = state
+  end
+
+  #
+  # Returns true if this object's state has been changed since the last
+  # #notify_observers call.
+  #
+  def changed?
+    if defined? @observer_state and @observer_state
+      true
+    else
+      false
+    end
+  end
+
+  #
+  # Notify observers of a change in state *if* this object's changed state is
+  # +true+.
+  #
+  # This will invoke the method named in #add_observer, passing <tt>*arg</tt>.
+  # The changed state is then set to +false+.
+  #
+  # <tt>*arg</tt>:: Any arguments to pass to the observers.
+  def notify_observers(*arg)
+    if defined? @observer_state and @observer_state
+      if defined? @observer_peers
+        @observer_peers.each do |k, v|
+          k.__send__(v, *arg)
+        end
+      end
+      @observer_state = false
+    end
+  end
+
+end

data/vendor/deps/observer/observer.gemspec

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+name = File.basename(__FILE__, ".gemspec")
+version = ["lib", Array.new(name.count("-")+1, ".").join("/")].find do |dir|
+  break File.foreach(File.join(__dir__, dir, "#{name.tr('-', '/')}.rb")) do |line|
+    /^\s*VERSION\s*=\s*"(.*)"/ =~ line and break $1
+  end rescue nil
+end
+
+Gem::Specification.new do |spec|
+  spec.name          = name
+  spec.version       = version
+  spec.authors       = ["Yukihiro Matsumoto"]
+  spec.email         = ["matz@ruby-lang.org"]
+
+  spec.summary       = %q{Implementation of the Observer object-oriented design pattern.}
+  spec.description   = spec.summary
+  spec.homepage      = "https://github.com/ruby/observer"
+  spec.licenses      = ["Ruby", "BSD-2-Clause"]
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z 2>#{IO::NULL}`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+end

data/vendor/deps/observer/test/test_observer.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+require 'test/unit'
+require 'observer'
+
+class TestObserver < Test::Unit::TestCase
+  class TestObservable
+    include Observable
+
+    def notify(*args)
+      changed
+      notify_observers(*args)
+    end
+  end
+
+  class TestWatcher
+    def initialize(observable)
+      @notifications = []
+      observable.add_observer(self)
+    end
+
+    attr_reader :notifications
+
+    def update(*args)
+      @notifications << args
+    end
+  end
+
+  def test_observers
+    observable = TestObservable.new
+
+    assert_equal(0, observable.count_observers)
+
+    watcher1 = TestWatcher.new(observable)
+
+    assert_equal(1, observable.count_observers)
+
+    observable.notify("test", 123)
+
+    watcher2 = TestWatcher.new(observable)
+
+    assert_equal(2, observable.count_observers)
+
+    observable.notify(42)
+
+    assert_equal([["test", 123], [42]], watcher1.notifications)
+    assert_equal([[42]], watcher2.notifications)
+
+    observable.delete_observer(watcher1)
+
+    assert_equal(1, observable.count_observers)
+
+    observable.notify(:cats)
+
+    assert_equal([["test", 123], [42]], watcher1.notifications)
+    assert_equal([[42], [:cats]], watcher2.notifications)
+
+    observable.delete_observers
+
+    assert_equal(0, observable.count_observers)
+
+    observable.notify("nope")
+
+    assert_equal([["test", 123], [42]], watcher1.notifications)
+    assert_equal([[42], [:cats]], watcher2.notifications)
+  end
+end

data/vendor/deps/webrick/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/vendor/deps/webrick/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/vendor/deps/webrick/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (C) 1993-2013 Yukihiro Matsumoto. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. Redistributions in binary form must reproduce the above copyright
+notice, this list of conditions and the following disclaimer in the
+documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGE.

data/vendor/deps/webrick/README.md

@@ -0,0 +1,61 @@
+# Webrick
+
+WEBrick is an HTTP server toolkit that can be configured as an HTTPS server, a proxy server, and a virtual-host server.
+
+WEBrick features complete logging of both server operations and HTTP access.
+
+WEBrick supports both basic and digest authentication in addition to algorithms not in RFC 2617.
+
+A WEBrick server can be composed of multiple WEBrick servers or servlets to provide differing behavior on a per-host or per-path basis. WEBrick includes servlets for handling CGI scripts, ERB pages, Ruby blocks and directory listings.
+
+WEBrick also includes tools for daemonizing a process and starting a process at a higher privilege level and dropping permissions.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'webrick'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install webrick
+
+## Usage
+
+To create a new WEBrick::HTTPServer that will listen to connections on port 8000 and serve documents from the current user's public_html folder:
+
+```ruby
+require 'webrick'
+
+root = File.expand_path '~/public_html'
+server = WEBrick::HTTPServer.new :Port => 8000, :DocumentRoot => root
+```
+
+To run the server you will need to provide a suitable shutdown hook as
+starting the server blocks the current thread:
+
+```ruby
+trap 'INT' do server.shutdown end
+
+server.start
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and Patch are welcome on https://bugs.ruby-lang.org/.
+
+## License
+
+The gem is available as open source under the terms of the [2-Clause BSD License](https://opensource.org/licenses/BSD-2-Clause).

data/vendor/deps/webrick/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test" << "test/lib"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/test_*.rb']
+end
+
+task :default => :test