dirwatch 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c7d112f1441a02cbb26f3548db35987a2e5debdd71fc4a5c26ea293ec9840c64
-  data.tar.gz: 7a9a22c2724992200fa8d59712f819f126d678f9e13e6e2e39e251b64a738db4
+  metadata.gz: 7b8761a5a18956325ce6d88dcce7e9027a907a4a212c85f5fb5090d8faf29912
+  data.tar.gz: 272b58289488b7286dc7da495fc09ef6183c21ba214098e645af69563b8773f6
 SHA512:
-  metadata.gz: a8afb7c475889f628befd1c74e07979aae774905b3c98a67f84a03d93c5424f4438e0c7f0c6893c53f0332271c91dfccbe1b845fdaaa762f05f22dc8da864a3d
-  data.tar.gz: 0f74fb446251a354b0671cb992c4acc0edcf901afe97116bb544b91af81540b0ae0e5829a70b9537f88c97976abd7a65af25d5f236d7c7f53d12e74b3c040225
+  metadata.gz: b2a12dcc4fc31f08389f598c669f071227e5047c6d9a0eff850e095c628a492c064d3c75b01534a60d8b87de0aaed605daeaafa81c5006617803284f91f6f759
+  data.tar.gz: 4b49b996b380eeb9ab2c56cc2d731d840a184d3893b5f3fbd0483b89512e66c38c513419f1e3507dfd39d220e2ae997afce6e0624ac51179382057a6029f66aa

data/lib/dirwatch/templates/mac/latex.yml

@@ -5,4 +5,4 @@ latex:
   file_match: '*.tex'
   script:
     - pdflatex -interaction=nonstopmode -halt-on-error --shell-escape main.tex
-    - evince main.pdf
+    - open main.pdf

data/lib/dirwatch/version.rb

@@ -1,3 +1,3 @@
 module Dirwatch
-  VERSION = Gem::Version.new '0.0.8'
+  VERSION = Gem::Version.new '0.0.9'
 end

data/vendor/bundle/ruby/2.5.0/gems/ast-2.4.0/CHANGELOG.md

@@ -0,0 +1,9 @@
+Changelog
+=========
+
+v1.1.0 (2013-06-17)
+-------------------
+
+API changes:
+
+  * AST::Processor#process will return nil if passed nil, instead of raising NoMethodError.

data/vendor/bundle/ruby/2.5.0/gems/ast-2.4.0/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in furnace.gemspec
+gemspec

data/vendor/bundle/ruby/2.5.0/gems/ast-2.4.0/LICENSE.MIT

@@ -0,0 +1,20 @@
+Copyright (c) 2011-2013  Peter Zotov <whitequark@whitequark.org>
+
+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/vendor/bundle/ruby/2.5.0/gems/ast-2.4.0/README.YARD.md

@@ -0,0 +1,12 @@
+{AST} is a library for manipulating abstract syntax trees.
+
+It embraces immutability; each AST node is inherently frozen at
+creation, and updating a child node requires recreating that node
+and its every parent, recursively.
+
+This is a design choice. It does create some pressure on
+garbage collector, but completely eliminates all concurrency
+and aliasing problems.
+
+See also {AST::Node}, {AST::Processor::Mixin} and {AST::Sexp} for
+additional recommendations and design patterns.

data/vendor/bundle/ruby/2.5.0/gems/ast-2.4.0/README.md

@@ -0,0 +1,23 @@
+# AST
+
+[![Build Status](https://travis-ci.org/whitequark/ast.svg?branch=master)](https://travis-ci.org/whitequark/ast)
+[![Code Climate](https://codeclimate.com/github/whitequark/ast.svg)](https://codeclimate.com/github/whitequark/ast)
+[![Coverage Status](https://coveralls.io/repos/whitequark/ast/badge.svg?branch=master)](https://coveralls.io/r/whitequark/ast)
+
+AST is a small library for working with immutable abstract syntax trees.
+
+## Installation
+
+    $ gem install ast
+
+## Usage
+
+See the documentation at [GitHub](http://whitequark.github.com/ast/frames.html) or [rdoc.info](http://rdoc.info/gems/ast).
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/vendor/bundle/ruby/2.5.0/gems/ast-2.4.0/Rakefile

@@ -0,0 +1,19 @@
+require 'bundler/gem_tasks'
+require 'bundler/setup'
+
+task :default => :test
+
+desc "Run test suite"
+task :test do
+  sh "bacon -Itest -a"
+end
+
+PAGES_REPO = 'git@github.com:whitequark/ast'
+
+desc "Build and deploy documentation to GitHub pages"
+task :pages do
+  system "git clone #{PAGES_REPO} gh-temp/ -b gh-pages; rm gh-temp/* -rf; touch gh-temp/.nojekyll" or abort
+  system "yardoc -o gh-temp/;" or abort
+  system "cd gh-temp/; git add -A; git commit -m 'Updated pages.'; git push -f origin gh-pages" or abort
+  FileUtils.rm_rf 'gh-temp'
+end

data/vendor/bundle/ruby/2.5.0/gems/ast-2.4.0/ast.gemspec

@@ -0,0 +1,29 @@
+Gem::Specification.new do |s|
+  s.name        = 'ast'
+  s.version     = '2.4.0'
+  s.license     = 'MIT'
+  s.authors     = ["whitequark"]
+  s.email       = ["whitequark@whitequark.org"]
+  s.homepage    = "https://whitequark.github.io/ast/"
+  s.summary     = %q{A library for working with Abstract Syntax Trees.}
+  s.description = s.summary
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'rake',                '~> 10.0'
+
+  s.add_development_dependency 'bacon',               '~> 1.2'
+  s.add_development_dependency 'bacon-colored_output'
+  s.add_development_dependency 'simplecov'
+
+  s.add_development_dependency 'coveralls'
+  s.add_development_dependency 'json_pure' # for coveralls on 1.9.2
+  s.add_development_dependency 'mime-types', '~> 1.25' # for coveralls on 1.8.7
+  s.add_development_dependency 'rest-client', '~> 1.6.7' # 1.8.7
+
+  s.add_development_dependency 'yard'
+  s.add_development_dependency 'kramdown'
+end

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

@@ -0,0 +1,17 @@
+# {AST} is a library for manipulating abstract syntax trees.
+#
+# It embraces immutability; each AST node is inherently frozen at
+# creation, and updating a child node requires recreating that node
+# and its every parent, recursively.
+# This is a design choice. It does create some pressure on
+# garbage collector, but completely eliminates all concurrency
+# and aliasing problems.
+#
+# See also {AST::Node}, {AST::Processor::Mixin} and {AST::Sexp} for
+# additional recommendations and design patterns.
+#
+module AST
+  require 'ast/node'
+  require 'ast/processor'
+  require 'ast/sexp'
+end

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

@@ -0,0 +1,258 @@
+# frozen_string_literal: true
+
+module AST
+  # Node is an immutable class, instances of which represent abstract
+  # syntax tree nodes. It combines semantic information (i.e. anything
+  # that affects the algorithmic properties of a program) with
+  # meta-information (line numbers or compiler intermediates).
+  #
+  # Notes on inheritance
+  # ====================
+  #
+  # The distinction between semantics and metadata is important. Complete
+  # semantic information should be contained within just the {#type} and
+  # {#children} of a Node instance; in other words, if an AST was to be
+  # stripped of all meta-information, it should remain a valid AST which
+  # could be successfully processed to yield a result with the same
+  # algorithmic properties.
+  #
+  # Thus, Node should never be inherited in order to define methods which
+  # affect or return semantic information, such as getters for `class_name`,
+  # `superclass` and `body` in the case of a hypothetical `ClassNode`. The
+  # correct solution is to use a generic Node with a {#type} of `:class`
+  # and three children. See also {Processor} for tips on working with such
+  # ASTs.
+  #
+  # On the other hand, Node can and should be inherited to define
+  # application-specific metadata (see also {#initialize}) or customize the
+  # printing format. It is expected that an application would have one or two
+  # such classes and use them across the entire codebase.
+  #
+  # The rationale for this pattern is extensibility and maintainability.
+  # Unlike static ones, dynamic languages do not require the presence of a
+  # predefined, rigid structure, nor does it improve dispatch efficiency,
+  # and while such a structure can certainly be defined, it does not add
+  # any value but incurs a maintaining cost.
+  # For example, extending the AST even with a transformation-local
+  # temporary node type requires making globally visible changes to
+  # the codebase.
+  #
+  class Node
+    # Returns the type of this node.
+    # @return [Symbol]
+    attr_reader :type
+
+    # Returns the children of this node.
+    # The returned value is frozen.
+    # The to_a alias is useful for decomposing nodes concisely.
+    # For example:
+    #
+    #     node = s(:gasgn, :$foo, s(:integer, 1))
+    #     var_name, value = *node
+    #     p var_name # => :$foo
+    #     p value    # => (integer 1)
+    #
+    # @return [Array]
+    attr_reader :children
+    alias to_a children
+
+    # Returns the precomputed hash value for this node
+    # @return [Fixnum]
+    attr_reader :hash
+
+    # Constructs a new instance of Node.
+    #
+    # The arguments `type` and `children` are converted with `to_sym` and
+    # `to_a` respectively. Additionally, the result of converting `children`
+    # is frozen. While mutating the arguments is generally considered harmful,
+    # the most common case is to pass an array literal to the constructor. If
+    # your code does not expect the argument to be frozen, use `#dup`.
+    #
+    # The `properties` hash is passed to {#assign_properties}.
+    def initialize(type, children=[], properties={})
+      @type, @children = type.to_sym, children.to_a.freeze
+
+      assign_properties(properties)
+
+      @hash = [@type, @children, self.class].hash
+
+      freeze
+    end
+
+    # Test if other object is equal to
+    # @param [Object] other
+    # @return [Boolean]
+    def eql?(other)
+      self.class.eql?(other.class)   &&
+      @type.eql?(other.type)         &&
+      @children.eql?(other.children)
+    end
+
+    # By default, each entry in the `properties` hash is assigned to
+    # an instance variable in this instance of Node. A subclass should define
+    # attribute readers for such variables. The values passed in the hash
+    # are not frozen or whitelisted; such behavior can also be implemented
+    # by subclassing Node and overriding this method.
+    #
+    # @return [nil]
+    def assign_properties(properties)
+      properties.each do |name, value|
+        instance_variable_set :"@#{name}", value
+      end
+
+      nil
+    end
+    protected :assign_properties
+
+    alias   :original_dup :dup
+    private :original_dup
+
+    # Nodes are already frozen, so there is no harm in returning the
+    # current node as opposed to initializing from scratch and freezing
+    # another one.
+    #
+    # @return self
+    def dup
+      self
+    end
+    alias :clone :dup
+
+    # Returns a new instance of Node where non-nil arguments replace the
+    # corresponding fields of `self`.
+    #
+    # For example, `Node.new(:foo, [ 1, 2 ]).updated(:bar)` would yield
+    # `(bar 1 2)`, and `Node.new(:foo, [ 1, 2 ]).updated(nil, [])` would
+    # yield `(foo)`.
+    #
+    # If the resulting node would be identical to `self`, does nothing.
+    #
+    # @param  [Symbol, nil] type
+    # @param  [Array, nil]  children
+    # @param  [Hash, nil]   properties
+    # @return [AST::Node]
+    def updated(type=nil, children=nil, properties=nil)
+      new_type       = type       || @type
+      new_children   = children   || @children
+      new_properties = properties || {}
+
+      if @type == new_type &&
+          @children == new_children &&
+          properties.nil?
+        self
+      else
+        original_dup.send :initialize, new_type, new_children, new_properties
+      end
+    end
+
+    # Compares `self` to `other`, possibly converting with `to_ast`. Only
+    # `type` and `children` are compared; metadata is deliberately ignored.
+    #
+    # @return [Boolean]
+    def ==(other)
+      if equal?(other)
+        true
+      elsif other.respond_to? :to_ast
+        other = other.to_ast
+        other.type == self.type &&
+          other.children == self.children
+      else
+        false
+      end
+    end
+
+    # Concatenates `array` with `children` and returns the resulting node.
+    #
+    # @return [AST::Node]
+    def concat(array)
+      updated(nil, @children + array.to_a)
+    end
+
+    alias + concat
+
+    # Appends `element` to `children` and returns the resulting node.
+    #
+    # @return [AST::Node]
+    def append(element)
+      updated(nil, @children + [element])
+    end
+
+    alias << append
+
+    # Converts `self` to a pretty-printed s-expression.
+    #
+    # @param  [Integer] indent Base indentation level.
+    # @return [String]
+    def to_sexp(indent=0)
+      indented = "  " * indent
+      sexp = "#{indented}(#{fancy_type}"
+
+      children.each do |child|
+        if child.is_a?(Node)
+          sexp += "\n#{child.to_sexp(indent + 1)}"
+        else
+          sexp += " #{child.inspect}"
+        end
+      end
+
+      sexp += ")"
+
+      sexp
+    end
+
+    alias to_s to_sexp
+
+    # Converts `self` to a s-expression ruby string.
+    # The code return will recreate the node, using the sexp module s()
+    #
+    # @param  [Integer] indent Base indentation level.
+    # @return [String]
+    def inspect(indent=0)
+      indented = "  " * indent
+      sexp = "#{indented}s(:#{@type}"
+
+      children.each do |child|
+        if child.is_a?(Node)
+          sexp += ",\n#{child.inspect(indent + 1)}"
+        else
+          sexp += ", #{child.inspect}"
+        end
+      end
+
+      sexp += ")"
+
+      sexp
+    end
+
+    # @return [AST::Node] self
+    def to_ast
+      self
+    end
+    
+    # Converts `self` to an Array where the first element is the type as a Symbol,
+    # and subsequent elements are the same representation of its children. 
+    #
+    # @return [Array<Symbol, [...Array]>]
+    def to_sexp_array
+      children_sexp_arrs = children.map do |child|
+        if child.is_a?(Node)
+          child.to_sexp_array
+        else
+          child
+        end
+      end
+
+      [type, *children_sexp_arrs]
+    end
+
+    protected
+
+    # Returns `@type` with all underscores replaced by dashes. This allows
+    # to write symbol literals without quotes in Ruby sources and yet have
+    # nicely looking s-expressions.
+    #
+    # @return [String]
+    def fancy_type
+      @type.to_s.gsub('_', '-')
+    end
+  end
+end