dirwatch 0.0.8 → 0.0.9

data/vendor/bundle/ruby/2.5.0/gems/ast-2.4.0/lib/ast/processor.rb

@@ -0,0 +1,12 @@
+module AST
+  # This class includes {AST::Processor::Mixin}; however, it is
+  # deprecated, since the module defines all of the behaviors that
+  # the processor includes.  Any new libraries should use
+  # {AST::Processor::Mixin} instead of subclassing this.
+  #
+  # @deprecated Use {AST::Processor::Mixin} instead.
+  class Processor
+    require 'ast/processor/mixin'
+    include Mixin
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/ast-2.4.0/lib/ast/processor/mixin.rb

@@ -0,0 +1,288 @@
+module AST
+  class Processor
+    # The processor module is a module which helps transforming one
+    # AST into another.  In a nutshell, the {#process} method accepts
+    # a {Node} and dispatches it to a handler corresponding to its
+    # type, and returns a (possibly) updated variant of the node.
+    #
+    # The processor module has a set of associated design patterns.
+    # They are best explained with a concrete example. Let's define a
+    # simple arithmetic language and an AST format for it:
+    #
+    # Terminals (AST nodes which do not have other AST nodes inside):
+    #
+    #   * `(integer <int-literal>)`,
+    #
+    # Nonterminals (AST nodes with other nodes as children):
+    #
+    #   * `(add <node> <node>)`,
+    #   * `(multiply <node> <node>)`,
+    #   * `(divide <node> <node>)`,
+    #   * `(negate <node>)`,
+    #   * `(store <node> <string-literal>)`: stores value of `<node>`
+    #     into a variable named `<string-literal>`,
+    #   * `(load <string-literal>)`: loads value of a variable named
+    #     `<string-literal>`,
+    #   * `(each <node> ...): computes each of the `<node>`s and
+    #     prints the result.
+    #
+    # All AST nodes have the same Ruby class, and therefore they don't
+    # know how to traverse themselves. (A solution which dynamically
+    # checks the type of children is possible, but is slow and
+    # error-prone.) So, a class including the module which knows how
+    # to traverse the entire tree should be defined.  Such classes
+    # have a handler for each nonterminal node which recursively
+    # processes children nodes:
+    #
+    #     require 'ast'
+    #
+    #     class ArithmeticsProcessor
+    #       include AST::Processor::Mixin
+    #       # This method traverses any binary operators such as (add)
+    #       # or (multiply).
+    #       def process_binary_op(node)
+    #         # Children aren't decomposed automatically; it is
+    #         # suggested to use Ruby multiple assignment expansion,
+    #         # as it is very convenient here.
+    #         left_expr, right_expr = *node
+    #
+    #         # AST::Node#updated won't change node type if nil is
+    #         # passed as a first argument, which allows to reuse the
+    #         # same handler for multiple node types using `alias'
+    #         # (below).
+    #         node.updated(nil, [
+    #           process(left_expr),
+    #           process(right_expr)
+    #         ])
+    #       end
+    #       alias_method :on_add,      :process_binary_op
+    #       alias_method :on_multiply, :process_binary_op
+    #       alias_method :on_divide,   :process_binary_op
+    #
+    #       def on_negate(node)
+    #         # It is also possible to use #process_all for more
+    #         # compact code if every child is a Node.
+    #         node.updated(nil, process_all(node))
+    #       end
+    #
+    #       def on_store(node)
+    #         expr, variable_name = *node
+    #
+    #         # Note that variable_name is not a Node and thus isn't
+    #         # passed to #process.
+    #         node.updated(nil, [
+    #           process(expr),
+    #           variable_name
+    #         ])
+    #       end
+    #
+    #       # (load) is effectively a terminal node, and so it does
+    #       # not need an explicit handler, as the following is the
+    #       # default behavior.  Essentially, for any nodes that don't
+    #       # have a defined handler, the node remains unchanged.
+    #       def on_load(node)
+    #         nil
+    #       end
+    #
+    #       def on_each(node)
+    #         node.updated(nil, process_all(node))
+    #       end
+    #     end
+    #
+    # Let's test our ArithmeticsProcessor:
+    #
+    #     include AST::Sexp
+    #     expr = s(:add, s(:integer, 2), s(:integer, 2))
+    #
+    #     p ArithmeticsProcessor.new.process(expr) == expr # => true
+    #
+    # As expected, it does not change anything at all. This isn't
+    # actually very useful, so let's now define a Calculator, which
+    # will compute the expression values:
+    #
+    #     # This Processor folds nonterminal nodes and returns an
+    #     # (integer) terminal node.
+    #     class ArithmeticsCalculator < ArithmeticsProcessor
+    #       def compute_op(node)
+    #         # First, node children are processed and then unpacked
+    #         # to local variables.
+    #         nodes = process_all(node)
+    #
+    #         if nodes.all? { |node| node.type == :integer }
+    #           # If each of those nodes represents a literal, we can
+    #           # fold this node!
+    #           values = nodes.map { |node| node.children.first }
+    #           AST::Node.new(:integer, [
+    #             yield(values)
+    #           ])
+    #         else
+    #           # Otherwise, we can just leave the current node in the
+    #           # tree and only update it with processed children
+    #           # nodes, which can be partially folded.
+    #           node.updated(nil, nodes)
+    #         end
+    #       end
+    #
+    #       def on_add(node)
+    #         compute_op(node) { |left, right| left + right }
+    #       end
+    #
+    #       def on_multiply(node)
+    #         compute_op(node) { |left, right| left * right }
+    #       end
+    #     end
+    #
+    # Let's check:
+    #
+    #     p ArithmeticsCalculator.new.process(expr) # => (integer 4)
+    #
+    # Excellent, the calculator works! Now, a careful reader could
+    # notice that the ArithmeticsCalculator does not know how to
+    # divide numbers. What if we pass an expression with division to
+    # it?
+    #
+    #     expr_with_division = \
+    #       s(:add,
+    #         s(:integer, 1),
+    #         s(:divide,
+    #           s(:add, s(:integer, 8), s(:integer, 4)),
+    #           s(:integer, 3))) # 1 + (8 + 4) / 3
+    #
+    #     folded_expr_with_division = ArithmeticsCalculator.new.process(expr_with_division)
+    #     p folded_expr_with_division
+    #     # => (add
+    #     #      (integer 1)
+    #     #      (divide
+    #     #        (integer 12)
+    #     #        (integer 3)))
+    #
+    # As you can see, the expression was folded _partially_: the inner
+    # `(add)` node which could be computed was folded to
+    # `(integer 12)`, the `(divide)` node is left as-is because there
+    # is no computing handler for it, and the root `(add)` node was
+    # also left as it is because some of its children were not
+    # literals.
+    #
+    # Note that this partial folding is only possible because the
+    # _data_ format, i.e. the format in which the computed values of
+    # the nodes are represented, is the same as the AST itself.
+    #
+    # Let's extend our ArithmeticsCalculator class further.
+    #
+    #     class ArithmeticsCalculator
+    #       def on_divide(node)
+    #         compute_op(node) { |left, right| left / right }
+    #       end
+    #
+    #       def on_negate(node)
+    #         # Note how #compute_op works regardless of the operator
+    #         # arity.
+    #         compute_op(node) { |value| -value }
+    #       end
+    #     end
+    #
+    # Now, let's apply our renewed ArithmeticsCalculator to a partial
+    # result of previous evaluation:
+    #
+    #     p ArithmeticsCalculator.new.process(expr_with_division) # => (integer 5)
+    #
+    # Five! Excellent. This is also pretty much how CRuby 1.8 executed
+    # its programs.
+    #
+    # Now, let's do some automated bug searching. Division by zero is
+    # an error, right? So if we could detect that someone has divided
+    # by zero before the program is even run, that could save some
+    # debugging time.
+    #
+    #     class DivisionByZeroVerifier < ArithmeticsProcessor
+    #       class VerificationFailure < Exception; end
+    #
+    #       def on_divide(node)
+    #         # You need to process the children to handle nested divisions
+    #         # such as:
+    #         # (divide
+    #         #   (integer 1)
+    #         #   (divide (integer 1) (integer 0))
+    #         left, right = process_all(node)
+    #
+    #         if right.type == :integer &&
+    #            right.children.first == 0
+    #           raise VerificationFailure, "Ouch! This code divides by zero."
+    #         end
+    #       end
+    #
+    #       def divides_by_zero?(ast)
+    #         process(ast)
+    #         false
+    #       rescue VerificationFailure
+    #         true
+    #       end
+    #     end
+    #
+    #     nice_expr = \
+    #       s(:divide,
+    #         s(:add, s(:integer, 10), s(:integer, 2)),
+    #         s(:integer, 4))
+    #
+    #     p DivisionByZeroVerifier.new.divides_by_zero?(nice_expr)
+    #     # => false. Good.
+    #
+    #     bad_expr = \
+    #       s(:add, s(:integer, 10),
+    #         s(:divide, s(:integer, 1), s(:integer, 0)))
+    #
+    #     p DivisionByZeroVerifier.new.divides_by_zero?(bad_expr)
+    #     # => true. WHOOPS. DO NOT RUN THIS.
+    #
+    # Of course, this won't detect more complex cases... unless you
+    # use some partial evaluation before! The possibilites are
+    # endless. Have fun.
+    module Mixin
+      # Dispatches `node`. If a node has type `:foo`, then a handler
+      # named `on_foo` is invoked with one argument, the `node`; if
+      # there isn't such a handler, {#handler_missing} is invoked
+      # with the same argument.
+      #
+      # If the handler returns `nil`, `node` is returned; otherwise,
+      # the return value of the handler is passed along.
+      #
+      # @param  [AST::Node, nil] node
+      # @return [AST::Node, nil]
+      def process(node)
+        return if node.nil?
+
+        node = node.to_ast
+
+        # Invoke a specific handler
+        on_handler = :"on_#{node.type}"
+        if respond_to? on_handler
+          new_node = send on_handler, node
+        else
+          new_node = handler_missing(node)
+        end
+
+        node = new_node if new_node
+
+        node
+      end
+
+      # {#process}es each node from `nodes` and returns an array of
+      # results.
+      #
+      # @param  [Array<AST::Node>] nodes
+      # @return [Array<AST::Node>]
+      def process_all(nodes)
+        nodes.to_a.map do |node|
+          process node
+        end
+      end
+
+      # Default handler. Does nothing.
+      #
+      # @param  [AST::Node] node
+      # @return [AST::Node, nil]
+      def handler_missing(node)
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/ast-2.4.0/lib/ast/sexp.rb

@@ -0,0 +1,30 @@
+module AST
+  # This simple module is very useful in the cases where one needs
+  # to define deeply nested ASTs from Ruby code, for example, in
+  # tests. It should be used like this:
+  #
+  #     describe YourLanguage::AST do
+  #       include Sexp
+  #
+  #       it "should correctly parse expressions" do
+  #         YourLanguage.parse("1 + 2 * 3").should ==
+  #             s(:add,
+  #               s(:integer, 1),
+  #               s(:multiply,
+  #                 s(:integer, 2),
+  #                 s(:integer, 3)))
+  #       end
+  #     end
+  #
+  # This way the amount of boilerplate code is greatly reduced.
+  module Sexp
+    # Creates a {Node} with type `type` and children `children`.
+    # Note that the resulting node is of the type AST::Node and not a
+    # subclass.
+    # This would not pose a problem with comparisons, as {Node#==}
+    # ignores metadata.
+    def s(type, *children)
+      Node.new(type, children)
+    end
+  end
+end

data/vendor/bundle/ruby/2.5.0/gems/ast-2.4.0/test/helper.rb

@@ -0,0 +1,17 @@
+require 'bacon'
+require 'bacon/colored_output'
+
+require 'simplecov'
+require 'coveralls'
+
+SimpleCov.start do
+  self.formatter = SimpleCov::Formatter::MultiFormatter.new([
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ])
+
+  # Exclude the testsuite itself.
+  add_filter "/test/"
+end
+
+require 'ast'

data/vendor/bundle/ruby/2.5.0/gems/ast-2.4.0/test/test_ast.rb

@@ -0,0 +1,271 @@
+require 'helper'
+
+describe AST::Node do
+  extend AST::Sexp
+
+  class MetaNode < AST::Node
+    attr_reader :meta
+  end
+
+  before do
+    @node = AST::Node.new(:node, [ 0, 1 ])
+    @metanode = MetaNode.new(:node, [ 0, 1 ], :meta => 'value')
+  end
+
+  it 'should have accessors for type and children' do
+    @node.type.should.equal :node
+    @node.children.should.equal [0, 1]
+  end
+
+  it 'should set metadata' do
+    @metanode.meta.should.equal 'value'
+  end
+
+  it 'should be frozen' do
+    @node.frozen?.should.be.true
+    @node.children.frozen?.should.be.true
+  end
+
+  it 'should return self when duping' do
+    @node.dup.should.equal? @node
+  end
+
+  it 'should return self when cloning' do
+    @node.clone.should.equal? @node
+  end
+
+  it 'should return an updated node, but only if needed' do
+    @node.updated().should.be.identical_to @node
+    @node.updated(:node).should.be.identical_to @node
+    @node.updated(nil, [0, 1]).should.be.identical_to @node
+
+    updated = @node.updated(:other_node)
+    updated.should.not.be.identical_to @node
+    updated.type.should.equal :other_node
+    updated.children.should.equal @node.children
+
+    updated.frozen?.should.be.true
+
+    updated = @node.updated(nil, [1, 1])
+    updated.should.not.be.identical_to @node
+    updated.type.should.equal @node.type
+    updated.children.should.equal [1, 1]
+
+    updated = @metanode.updated(nil, nil, :meta => 'other_value')
+    updated.meta.should.equal 'other_value'
+  end
+
+  it 'should format to_sexp correctly' do
+    AST::Node.new(:a, [ :sym, [ 1, 2 ] ]).to_sexp.should.equal '(a :sym [1, 2])'
+    AST::Node.new(:a, [ :sym, @node ]).to_sexp.should.equal "(a :sym\n  (node 0 1))"
+    AST::Node.new(:a, [ :sym,
+      AST::Node.new(:b, [ @node, @node ])
+    ]).to_sexp.should.equal "(a :sym\n  (b\n    (node 0 1)\n    (node 0 1)))"
+  end
+
+  it 'should format to_s correctly' do
+    AST::Node.new(:a, [ :sym, [ 1, 2 ] ]).to_s.should.equal '(a :sym [1, 2])'
+    AST::Node.new(:a, [ :sym, @node ]).to_s.should.equal "(a :sym\n  (node 0 1))"
+    AST::Node.new(:a, [ :sym,
+      AST::Node.new(:b, [ @node, @node ])
+    ]).to_s.should.equal "(a :sym\n  (b\n    (node 0 1)\n    (node 0 1)))"
+  end
+
+  it 'should format inspect correctly' do
+    AST::Node.new(:a, [ :sym, [ 1, 2 ] ]).inspect.should.equal "s(:a, :sym, [1, 2])"
+    AST::Node.new(:a, [ :sym,
+      AST::Node.new(:b, [ @node, @node ])
+    ]).inspect.should.equal "s(:a, :sym,\n  s(:b,\n    s(:node, 0, 1),\n    s(:node, 0, 1)))"
+  end
+
+  it 'should recreate inspect output' do
+    simple_node = AST::Node.new(:a, [ :sym, [ 1, 2 ] ])
+    eval(simple_node.inspect).should.equal simple_node
+    complex_node =  s(:a ,  :sym,  s(:b, s(:node,  0,  1),  s(:node,  0,  1)))
+    eval(complex_node.inspect).should.equal complex_node
+  end
+
+  it 'should return self in to_ast' do
+    @node.to_ast.should.be.identical_to @node
+  end
+  
+  it 'should produce to_sexp_array correctly' do
+    AST::Node.new(:a, [ :sym, [ 1, 2 ] ]).to_sexp_array.should.equal [:a, :sym, [1, 2]]
+    AST::Node.new(:a, [ :sym,
+      AST::Node.new(:b, [ @node, @node ])
+    ]).to_sexp_array.should.equal [:a, :sym, [:b, [:node, 0, 1], [:node, 0, 1]]]
+  end
+
+  it 'should only use type and children to compute #hash' do
+    @node.hash.should.equal([@node.type, @node.children, @node.class].hash)
+  end
+
+  it 'should only use type and children in #eql? comparisons' do
+    # Not identical but equivalent
+    @node.eql?(AST::Node.new(:node, [0, 1])).should.be.true
+    # Not identical and not equivalent
+    @node.eql?(AST::Node.new(:other, [0, 1])).should.be.false
+    # Not identical and not equivalent because of differend class
+    @node.eql?(@metanode).should.be.false
+  end
+
+  it 'should only use type and children in #== comparisons' do
+    @node.should.equal @node
+    @node.should.equal @metanode
+    @node.should.not.equal :foo
+
+    mock_node = Object.new.tap do |obj|
+      def obj.to_ast
+        self
+      end
+
+      def obj.type
+        :node
+      end
+
+      def obj.children
+        [ 0, 1 ]
+      end
+    end
+    @node.should.equal mock_node
+  end
+
+  it 'should allow to decompose nodes with a, b = *node' do
+    node = s(:gasgn, :$foo, s(:integer, 1))
+
+    var_name, value = *node
+    var_name.should.equal :$foo
+    value.should.equal s(:integer, 1)
+  end
+
+  it 'should concatenate with arrays' do
+    node = s(:gasgn, :$foo)
+    (node + [s(:integer, 1)]).
+        should.equal s(:gasgn, :$foo, s(:integer, 1))
+  end
+
+  it 'should append elements' do
+    node = s(:array)
+    (node << s(:integer, 1) << s(:string, "foo")).
+        should.equal s(:array, s(:integer, 1), s(:string, "foo"))
+  end
+
+  begin
+    eval <<-CODE
+    it 'should not trigger a rubinius bug' do
+      bar = [ s(:bar, 1) ]
+      baz = s(:baz, 2)
+      s(:foo, *bar, baz).should.equal s(:foo, s(:bar, 1), s(:baz, 2))
+    end
+    CODE
+  rescue SyntaxError
+    # Running on 1.8, ignore.
+  end
+end
+
+describe AST::Processor do
+  extend AST::Sexp
+
+  def have_sexp(text)
+    text = text.lines.map { |line| line.sub /^ +\|(.+)/, '\1' }.join.rstrip
+    lambda { |ast| ast.to_sexp == text }
+  end
+
+  class MockProcessor < AST::Processor
+    attr_reader :counts
+
+    def initialize
+      @counts = Hash.new(0)
+    end
+
+    def on_root(node)
+      count_node(node)
+      node.updated(nil, process_all(node.children))
+    end
+    alias on_body on_root
+
+    def on_def(node)
+      count_node(node)
+      name, arglist, body = node.children
+      node.updated(:def, [ name, process(arglist), process(body) ])
+    end
+
+    def handler_missing(node)
+      count_node(node)
+    end
+
+    def count_node(node)
+      @counts[node.type] += 1; nil
+    end
+  end
+
+  before do
+    @ast = AST::Node.new(:root, [
+      AST::Node.new(:def, [ :func,
+        AST::Node.new(:arglist, [ :foo, :bar ]),
+        AST::Node.new(:body, [
+          AST::Node.new(:invoke, [ :puts, "Hello world" ])
+        ])
+      ]),
+      AST::Node.new(:invoke, [ :func ])
+    ])
+
+    @processor = MockProcessor.new
+  end
+
+  it 'should visit every node' do
+    @processor.process(@ast).should.equal @ast
+    @processor.counts.should.equal({
+      :root    => 1,
+      :def     => 1,
+      :arglist => 1,
+      :body    => 1,
+      :invoke  => 2,
+    })
+  end
+
+  it 'should be able to replace inner nodes' do
+    def @processor.on_arglist(node)
+      node.updated(:new_fancy_arglist)
+    end
+
+    @processor.process(@ast).should have_sexp(<<-SEXP)
+    |(root
+    |  (def :func
+    |    (new-fancy-arglist :foo :bar)
+    |    (body
+    |      (invoke :puts "Hello world")))
+    |  (invoke :func))
+    SEXP
+  end
+
+  it 'should build sexps' do
+    s(:add,
+      s(:integer, 1),
+      s(:multiply,
+        s(:integer, 2),
+        s(:integer, 3))).should have_sexp(<<-SEXP)
+    |(add
+    |  (integer 1)
+    |  (multiply
+    |    (integer 2)
+    |    (integer 3)))
+    SEXP
+  end
+
+  it 'should return nil if passed nil' do
+    @processor.process(nil).should == nil
+  end
+
+  it 'should refuse to process non-nodes' do
+    lambda { @processor.process([]) }.should.raise NoMethodError, %r|to_ast|
+  end
+
+  it 'should allow to visit nodes with process_all(node)' do
+    @processor.process_all s(:foo, s(:bar), s(:integer, 1))
+    @processor.counts.should.equal({
+      :bar =>     1,
+      :integer => 1,
+    })
+  end
+end