dirwatch 0.0.1 → 0.0.2

data/vendor/bundle/ruby/2.3.0/gems/docile-1.1.5/lib/docile.rb

@@ -0,0 +1,84 @@
+require 'docile/version'
+require 'docile/execution'
+require 'docile/fallback_context_proxy'
+require 'docile/chaining_fallback_context_proxy'
+
+# Docile keeps your Ruby DSLs tame and well-behaved.
+module Docile
+  extend Execution
+
+  # Execute a block in the context of an object whose methods represent the
+  # commands in a DSL.
+  #
+  # @note Use with an *imperative* DSL (commands modify the context object)
+  #
+  # Use this method to execute an *imperative* DSL, which means that:
+  #
+  #   1. Each command mutates the state of the DSL context object
+  #   2. The return value of each command is ignored
+  #   3. The final return value is the original context object
+  #
+  # @example Use a String as a DSL
+  #   Docile.dsl_eval("Hello, world!") do
+  #     reverse!
+  #     upcase!
+  #   end
+  #   #=> "!DLROW ,OLLEH"
+  #
+  # @example Use an Array as a DSL
+  #   Docile.dsl_eval([]) do
+  #     push 1
+  #     push 2
+  #     pop
+  #     push 3
+  #   end
+  #   #=> [1, 3]
+  #
+  # @param dsl   [Object] context object whose methods make up the DSL
+  # @param args  [Array]  arguments to be passed to the block
+  # @param block [Proc]   the block of DSL commands to be executed against the
+  #                         `dsl` context object
+  # @return      [Object] the `dsl` context object after executing the block
+  def dsl_eval(dsl, *args, &block)
+    exec_in_proxy_context(dsl, FallbackContextProxy, *args, &block)
+    dsl
+  end
+  module_function :dsl_eval
+
+  # Execute a block in the context of an immutable object whose methods,
+  # and the methods of their return values, represent the commands in a DSL.
+  #
+  # @note Use with a *functional* DSL (commands return successor
+  #       context objects)
+  #
+  # Use this method to execute a *functional* DSL, which means that:
+  #
+  #   1. The original DSL context object is never mutated
+  #   2. Each command returns the next DSL context object
+  #   3. The final return value is the value returned by the last command
+  #
+  # @example Use a frozen String as a DSL
+  #   Docile.dsl_eval_immutable("I'm immutable!".freeze) do
+  #     reverse
+  #     upcase
+  #   end
+  #   #=> "!ELBATUMMI M'I"
+  #
+  # @example Use a Float as a DSL
+  #   Docile.dsl_eval_immutable(84.5) do
+  #     fdiv(2)
+  #     floor
+  #   end
+  #   #=> 42
+  #
+  # @param dsl   [Object] immutable context object whose methods make up the
+  #                       initial DSL
+  # @param args  [Array]  arguments to be passed to the block
+  # @param block [Proc]   the block of DSL commands to be executed against the
+  #                         `dsl` context object and successor return values
+  # @return      [Object] the return value of the final command in the block
+  def dsl_eval_immutable(dsl, *args, &block)
+    exec_in_proxy_context(dsl, ChainingFallbackContextProxy, *args, &block)
+  end
+  module_function :dsl_eval_immutable
+end

data/vendor/bundle/ruby/2.3.0/gems/docile-1.1.5/on_what.rb

@@ -0,0 +1,14 @@
+# NOTE: Very simple tests for what system we are on, extracted for sharing
+#   between Rakefile, gemspec, and spec_helper. Not for use in actual library.
+
+def on_travis?
+  ENV['CI'] == 'true'
+end
+
+def on_jruby?
+  (defined?(RUBY_ENGINE) && 'jruby' == RUBY_ENGINE)
+end
+
+def on_1_8?
+  RUBY_VERSION.start_with? '1.8'
+end

data/vendor/bundle/ruby/2.3.0/gems/docile-1.1.5/spec/docile_spec.rb

@@ -0,0 +1,339 @@
+require 'spec_helper'
+require 'singleton'
+
+describe Docile do
+
+  describe '.dsl_eval' do
+
+    context 'when DSL context object is an Array' do
+      let(:array) { [] }
+      let!(:result) { execute_dsl_against_array }
+
+      def execute_dsl_against_array
+        Docile.dsl_eval(array) do
+          push 1
+          push 2
+          pop
+          push 3
+        end
+      end
+
+      it 'executes the block against the DSL context object' do
+        expect(array).to eq([1, 3])
+      end
+
+      it 'returns the DSL object after executing block against it' do
+        expect(result).to eq(array)
+      end
+
+      it "doesn't proxy #__id__" do
+        Docile.dsl_eval(array) { expect(__id__).not_to eq(array.__id__) }
+      end
+
+      it "raises NoMethodError if the DSL object doesn't implement the method" do
+        expect { Docile.dsl_eval(array) { no_such_method } }.to raise_error(NoMethodError)
+      end
+    end
+
+    Pizza = Struct.new(:cheese, :pepperoni, :bacon, :sauce)
+
+    class PizzaBuilder
+      def cheese(v=true);    @cheese    = v; end
+      def pepperoni(v=true); @pepperoni = v; end
+      def bacon(v=true);     @bacon     = v; end
+      def sauce(v=nil);      @sauce     = v; end
+      def build
+        Pizza.new(!!@cheese, !!@pepperoni, !!@bacon, @sauce)
+      end
+    end
+
+    context 'when DSL context object is a Builder pattern' do
+      let(:builder) { PizzaBuilder.new }
+      let(:result) { execute_dsl_against_builder_and_call_build }
+
+      def execute_dsl_against_builder_and_call_build
+        @sauce = :extra
+        Docile.dsl_eval(builder) do
+          bacon
+          cheese
+          sauce @sauce
+        end.build
+      end
+
+      it 'returns correctly built object' do
+        expect(result).to eq(Pizza.new(true, false, true, :extra))
+      end
+    end
+
+    class InnerDSL
+      def initialize; @b = 'b'; end
+      attr_accessor :b
+    end
+
+    class OuterDSL
+      def initialize; @a = 'a'; end
+      attr_accessor :a
+
+      def inner(&block)
+        Docile.dsl_eval(InnerDSL.new, &block)
+      end
+
+      def inner_with_params(param, &block)
+        Docile.dsl_eval(InnerDSL.new, param, :foo, &block)
+      end
+    end
+
+    def outer(&block)
+      Docile.dsl_eval(OuterDSL.new, &block)
+    end
+
+    context 'when given parameters for the DSL block' do
+      def parameterized(*args, &block)
+        Docile.dsl_eval(OuterDSL.new, *args, &block)
+      end
+
+      it 'passes parameters to the block' do
+        parameterized(1,2,3) do |x,y,z|
+          expect(x).to eq(1)
+          expect(y).to eq(2)
+          expect(z).to eq(3)
+        end
+      end
+
+      it 'finds parameters before methods' do
+        parameterized(1) { |a| expect(a).to eq(1) }
+      end
+
+      it 'find outer dsl parameters in inner dsl scope' do
+        parameterized(1,2,3) do |a,b,c|
+          inner_with_params(c) do |d,e|
+            expect(a).to eq(1)
+            expect(b).to eq(2)
+            expect(c).to eq(3)
+            expect(d).to eq(c)
+            expect(e).to eq(:foo)
+          end
+        end
+      end
+    end
+
+    class DSLWithNoMethod
+      def initialize(b); @b = b; end
+      attr_accessor :b
+      def push_element
+        @b.push 1
+      end
+    end
+
+    context 'when DSL have NoMethod error inside' do
+      it 'raise error from nil' do
+        Docile.dsl_eval(DSLWithNoMethod.new(nil)) do
+          expect { push_element }.to raise_error(NoMethodError, /undefined method `push' (for|on) nil:NilClass/)
+        end
+      end
+    end
+
+    context 'when DSL blocks are nested' do
+
+      context 'method lookup' do
+        it 'finds method of outer dsl in outer dsl scope' do
+          outer { expect(a).to eq('a') }
+        end
+
+        it 'finds method of inner dsl in inner dsl scope' do
+          outer { inner { expect(b).to eq('b') } }
+        end
+
+        it 'finds method of outer dsl in inner dsl scope' do
+          outer { inner { expect(a).to eq('a') } }
+        end
+
+        it "finds method of block's context in outer dsl scope" do
+          def c; 'c'; end
+          outer { expect(c).to eq('c') }
+        end
+
+        it "finds method of block's context in inner dsl scope" do
+          def c; 'c'; end
+          outer { inner { expect(c).to eq('c') } }
+        end
+
+        it 'finds method of outer dsl in preference to block context' do
+          def a; 'not a'; end
+          outer { expect(a).to eq('a') }
+          outer { inner { expect(a).to eq('a') } }
+        end
+      end
+
+      context 'local variable lookup' do
+        it 'finds local variable from block context in outer dsl scope' do
+          foo = 'foo'
+          outer { expect(foo).to eq('foo') }
+        end
+
+        it 'finds local variable from block definition in inner dsl scope' do
+          bar = 'bar'
+          outer { inner { expect(bar).to eq('bar') } }
+        end
+      end
+
+      context 'instance variable lookup' do
+        it 'finds instance variable from block definition in outer dsl scope' do
+          @iv1 = 'iv1'; outer { expect(@iv1).to eq('iv1') }
+        end
+
+        it "proxies instance variable assignments in block in outer dsl scope back into block's context" do
+          @iv1 = 'foo'; outer { @iv1 = 'bar' }; expect(@iv1).to eq('bar')
+        end
+
+        it 'finds instance variable from block definition in inner dsl scope' do
+          @iv2 = 'iv2'; outer { inner { expect(@iv2).to eq('iv2') } }
+        end
+
+        it "proxies instance variable assignments in block in inner dsl scope back into block's context" do
+          @iv2 = 'foo'; outer { inner { @iv2 = 'bar' } }; expect(@iv2).to eq('bar')
+        end
+      end
+
+    end
+
+    context 'when DSL context object is a Dispatch pattern' do
+      class DispatchScope
+        def params
+          { :a => 1, :b => 2, :c => 3 }
+        end
+      end
+
+      class MessageDispatch
+        include Singleton
+
+        def initialize
+          @responders = {}
+        end
+
+        def add_responder path, &block
+          @responders[path] = block
+        end
+
+        def dispatch path, request
+          Docile.dsl_eval(DispatchScope.new, request, &@responders[path])
+        end
+      end
+
+      def respond(path, &block)
+        MessageDispatch.instance.add_responder(path, &block)
+      end
+
+      def send_request(path, request)
+        MessageDispatch.instance.dispatch(path, request)
+      end
+
+      it 'dispatches correctly' do
+        @first = @second = nil
+
+        respond '/path' do |request|
+          @first = request
+        end
+
+        respond '/new_bike' do |bike|
+          @second = "Got a new #{bike}"
+        end
+
+        def x(y) ; "Got a #{y}"; end
+        respond '/third' do |third|
+          expect(x(third)).to eq('Got a third thing')
+        end
+
+        fourth = nil
+        respond '/params' do |arg|
+          fourth = params[arg]
+        end
+
+        send_request '/path', 1
+        send_request '/new_bike', 'ten speed'
+        send_request '/third', 'third thing'
+        send_request '/params', :b
+
+        expect(@first).to eq(1)
+        expect(@second).to eq('Got a new ten speed')
+        expect(fourth).to eq(2)
+      end
+
+    end
+
+  end
+
+  describe '.dsl_eval_immutable' do
+
+    context 'when DSL context object is a frozen String' do
+      let(:original) { "I'm immutable!".freeze }
+      let!(:result) { execute_non_mutating_dsl_against_string }
+
+      def execute_non_mutating_dsl_against_string
+        Docile.dsl_eval_immutable(original) do
+          reverse
+          upcase
+        end
+      end
+
+      it "doesn't modify the original string" do
+        expect(original).to eq("I'm immutable!")
+      end
+
+      it 'chains the commands in the block against the DSL context object' do
+        expect(result).to eq("!ELBATUMMI M'I")
+      end
+    end
+
+    context 'when DSL context object is a number' do
+      let(:original) { 84.5 }
+      let!(:result) { execute_non_mutating_dsl_against_number }
+
+      def execute_non_mutating_dsl_against_number
+        Docile.dsl_eval_immutable(original) do
+          fdiv(2)
+          floor
+        end
+      end
+
+      it 'chains the commands in the block against the DSL context object' do
+        expect(result).to eq(42)
+      end
+    end
+  end
+
+end
+
+describe Docile::FallbackContextProxy do
+
+  describe '#instance_variables' do
+    subject { create_fcp_and_set_one_instance_variable.instance_variables }
+    let(:expected_type_of_names) { type_of_ivar_names_on_this_ruby }
+    let(:actual_type_of_names) { subject.first.class }
+    let(:excluded) { Docile::FallbackContextProxy::NON_PROXIED_INSTANCE_VARIABLES }
+
+    def create_fcp_and_set_one_instance_variable
+      fcp = Docile::FallbackContextProxy.new(nil, nil)
+      fcp.instance_variable_set(:@foo, 'foo')
+      fcp
+    end
+
+    def type_of_ivar_names_on_this_ruby
+      @a = 1
+      instance_variables.first.class
+    end
+
+    it 'returns proxied instance variables' do
+      expect(subject.map(&:to_sym)).to include(:@foo)
+    end
+
+    it "doesn't return non-proxied instance variables" do
+      expect(subject.map(&:to_sym)).not_to include(*excluded)
+    end
+
+    it 'preserves the type (String or Symbol) of names on this ruby version' do
+      expect(actual_type_of_names).to eq(expected_type_of_names)
+    end
+  end
+
+end

data/vendor/bundle/ruby/2.3.0/gems/docile-1.1.5/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+require File.expand_path('on_what', File.dirname(File.dirname(__FILE__)))
+
+begin
+  require 'simplecov'
+  require 'coveralls'
+
+  # On Ruby 1.9+ use SimpleCov and publish to Coveralls.io
+  if !on_1_8?
+    SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+      SimpleCov::Formatter::HTMLFormatter,
+      Coveralls::SimpleCov::Formatter
+    ]
+    SimpleCov.start do
+      add_filter '/spec/'    # exclude test code
+      add_filter '/vendor/'  # exclude gems which are vendored on Travis CI
+    end
+
+    # Remove Docile, which was required by SimpleCov, to require again later
+    Object.send(:remove_const, :Docile)
+    $LOADED_FEATURES.reject! { |f| f =~ /\/docile\// }
+  end
+rescue LoadError
+  warn 'warning: simplecov/coveralls gems not found; skipping coverage'
+end
+
+lib_dir = File.join(File.dirname(File.dirname(__FILE__)), 'lib')
+$LOAD_PATH.unshift lib_dir unless $LOAD_PATH.include? lib_dir
+
+# Require Docile again, now with coverage enabled on 1.9+
+require 'docile'