pattern for 'mydir' about node-watch HOT 13 CLOSED

watch('myDir/**/*.js',  function(filename) { 

});

function watchByPattern(pattern, options, callback) {

   // Parsing the pattern into two parts: 
   //   1. directory or filename.
   //   2. the wildcard used for filtering.  
   //
   //  For example:
   //
   //  Given the pattern "myDir/**/*.js",  will return 
   //  the directory 'myDir' and the wildcard "**/*.js".
   var segment = patternParser(pattern);


   // Filter by wildcard, using package "minimatch".
   var filterByWildCard = function(wildcard, callback) {
     return function(filename) {
       if (minimatch(filename, wildcard)) {
         callback(filename);
       }
     }
   }

   watch(
     segment.dir,
     options, 
     filterByWildCard(segment.wildcard, callback)
   );

}

var minimatch = require('minimatch');
var watch = require('node-watch');

function watchByPattern(pattern, callback) {
  var filterByWildCard = function(wildcard, fn) {
    return function(filename) {
      if (minimatch(filename, wildcard)) {
        fn(filename);
      }
    }
  }
  watch(
    './markup',
    filterByWildCard(pattern, callback)
  );
}

watchByPattern('**/*.scss', function(filename) {
  console.log(filename);
});

var minimatch = require('minimatch');
var watch = require('node-watch');

var watchByPattern = (function() {
  var patterns = [];
  var ready = true;
  return function(pattern, callback) {
    patterns.push({
      wildcard: pattern,
      callback: callback
    });
    if (ready) {
      ready = false;
      watch('./markup', function(filename) {
        patterns.forEach(function(pat) {
          if (minimatch(filename, pat.wildcard)) {
            pat.callback(filename);
          }
        });
      });
    }
  }
}());


watchByPattern('**/*.scss', function(filename) {
  console.log(filename);
});

watchByPattern('**/*.js', function(filename) {
  console.log(filename);
});

var minimatch = require('minimatch');
var watch = require('node-watch');

var watchByPattern = (function() {
  var parsePattern = function(input) {
    var current = './';
    var segments = input.split(/\*/);
    return {
      dir: (/^\*/.test(input) ? current : (segments[0] || current)),
      pat: ('*' + segments.slice(1).join('*'))
    }
  }
  var watchStack = {}
  return function(pattern, fn) {
    var input = parsePattern(pattern);
    var stack = { pat: input.pat, callback: fn };
    if (watchStack[input.dir]) {
      watchStack[input.dir].push(stack);
    } else {
      watchStack[input.dir] = [stack];
      watch(input.dir, function(filename) {
        watchStack[input.dir].forEach(function(stack) {
          if (minimatch(filename, stack.pat)) {
            stack.callback(filename);
          }
        });
      });
    };
  }
}());

watchByPattern('./markup/**/*.js', function(name) {
  //
});

watchByPattern('**/*.js', function(name) {
  //
});

var     minimatch = require('minimatch'),           // Service module for node-watch
        watch = require('node-watch');              // Watcher

// Watcher by node-watch
var watchByPattern = (function() {

    var watchStack = {};

    var parsePattern = function(input, filter) {
        var current = './',
            filterSegment = '',
            segments = input.split(/\*/),
            dir = '',
            pat = '',
            filterPattern = '';

            if (/^\*/.test(input)) {
                dir = current
            } else {
                dir = segments[0] || current;
            }

            pat = '*' + segments.slice(1).join('*');

            filterPattern = filter || false;

            if (filterPattern) {

                if (filterPattern instanceof Array) {

                    for (var i = 0; i < filterPattern.length; i++ ) {
                        filterSegment = filterPattern[i].split(/\*/);
                        filterPattern[i] = '*' + filterSegment.slice(1).join('*');
                    }
                } else {
                    filterSegment = filter.split(/\*/);
                    filterPattern = '*' + filterSegment.slice(1).join('*');
                }
            }

        return {
            dir: dir,
            pat: pat,
            filter: filterPattern
        }
    };

    var patternProcessing = function(pattern, filter, fn) {

        var input = parsePattern(pattern, filter),
            stack = { pat: input.pat, callback: fn, filter: input.filter };

        if (watchStack[input.dir]) {
            watchStack[input.dir].push(stack);
        } else {
            watchStack[input.dir] = [stack];
            watch(input.dir, function(filename) {
                watchStack[input.dir].forEach(function(stack) {
                    var useFilter = false;
                    if (minimatch(filename, stack.pat)) {

                        if (stack.filter) {
                            if (stack.filter instanceof Array) {
                                stack.filter.forEach(function(filterItem) {
                                    if (minimatch(filename, filterItem)) {
                                        useFilter = true;
                                    }
                                });

                                if (useFilter) {
                                    return;
                                } else {
                                    stack.callback(filename);
                                }
                            } else {
                                if (minimatch(filename, stack.filter)) {
                                    return;
                                } else {
                                    stack.callback(filename);   
                                }
                            }

                        } else {
                            stack.callback(filename);
                        }
                    }
                });
            });
        }
    };

    return function(pattern, filter, fn) {

        if (pattern instanceof Array) {
            pattern.forEach(function(patternItem) {
                patternProcessing(patternItem, filter, fn);
            });
        } else {
            patternProcessing(pattern, filter, fn);
        } 
    }
}());

module.exports = watchByPattern;

    watchByPattern('./markup/modules/**/*.js', './markup/modules/**/moduleData.js', function() {
        gulp.start('concat-plugins-libs-and-modules-lint-modules-js');
    });