context-filters 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5fefdc786067150db5a30a0f0d3951a8400dfaea
+  data.tar.gz: ceee00abeae9a01b2190f7dca8c903cd1e4125ed
+SHA512:
+  metadata.gz: b54f7a9eb75421d1eccc8ba97b80e823dba1a1748cd1b5c66046f7e133f3f914a029376e84521f6b5b39cded1d9e228c39a8c56e79dbfdb4c29231168408bcec
+  data.tar.gz: dcfd179c6eb7d3965cf28b687fd515ae4003a88d2690b894f38d1a75b5e0712a330ef983e656cbb361a4ce8e536e21293faafbf9a4be0e18a581b2352bf372ac

data/lib/context-filters.rb

@@ -0,0 +1,8 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require "context-filters/version"
+require "context-filters/context"

data/lib/context-filters/context.rb

@@ -0,0 +1,23 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require "context-filters/global_context"
+require "context-filters/local_context"
+
+# manipulate set of context and filters for it,
+# allow evaluating filters in given context
+class ContextFilters::Context < CommandDesigner::GlobalContext
+
+  include ContextFilters::LocalContext
+
+  # run the given method on global and local filters
+  def evaluate_filters(method)
+    super(method) do
+      evaluate_local_filters(method)
+    end
+  end
+
+end

data/lib/context-filters/filters.rb

@@ -0,0 +1,68 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require "context-filters/version"
+
+# Store and apply filters using blocks
+#
+# @example
+#
+#   class FiltersTestSubject
+#     attr_reader :value
+#     def initialize(value)
+#       @value = value
+#     end
+#     def change(&block)
+#       @value = block.call(@value)
+#     end
+#   end
+#   filters = ContextFilters::Filters.new
+#   filters.store(:addition) {|value| value + 1 }
+#   filters.store(:subtraction) {|value| value - 1 }
+#   filters.filters # => [:addition, :subtraction]
+#   object = FiltersTestSubject.new(3)
+#   object.value => 3
+#   filters.apply(object.method(:change), :addition)
+#   object.value => 4
+#   filters.apply(object.method(:change), :subtraction)
+#   object.value => 3
+
+class ContextFilters::Filters
+
+  # initialize the filters storage
+  def initialize
+    @filters = {}
+  end
+
+  # stores the block for given options, if the options have a block
+  # already the new one is added to the list
+  # @param options [Object] options for filtering blocks
+  # @param block   [Proc]   block of code to add to the list of blocks
+  #                         for this options
+  def store(options = nil, &block)
+    @filters[options] ||= []
+    @filters[options] << block
+  end
+
+  # applies matching filters to the given method
+  # @param method  [Method] an object method that takes a transformation
+  #                         block as param
+  # @param options [Object] a filter for selecting matching blocks
+  def apply(method, options = {})
+    @filters.fetch(options, []).each{|block| method.call(&block) }
+  end
+
+  # Array of already defined filters
+  def filters
+    @filters.keys
+  end
+
+  # @return [Boolean] true if there are any rules stored, false otherwise
+  def empty?
+    @filters.empty?
+  end
+
+end

data/lib/context-filters/global_context.rb

@@ -0,0 +1,77 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require "context-filters/priority_filters"
+
+# builds list of filters and provides dsl for building nested context
+# and allows evaluating filters on methods in the current context
+class ContextFilters::GlobalContext
+
+  # @return [Array] the context stack
+  attr_reader :context
+
+  # @return [PriorityFilters] shared list of filters
+  attr_reader :priority_filters
+
+  # initialize new GlobalContext, works in two modes:
+  # 1. start totally new context, takes one param - array of priorities,
+  #    +nil+ to use one anonymous priority
+  # 2. build sub context, params: global_filters_list, parents_context,
+  #    value to add to context
+  #
+  # @param priority_filters [Array,PriorityFilters] when PriorityFilters - uses it for priority_filters
+  #                                                 otherwise - initializes new priority_filters with it
+  # @param context [Array]  parents context, duplicates to initialize own context
+  # @param options [Object] new context, ads it to current context
+  #
+  def initialize(priority_filters = nil, context = [], options = nil)
+    if ContextFilters::PriorityFilters === priority_filters
+    then @priority_filters = priority_filters
+    else @priority_filters = ContextFilters::PriorityFilters.new(priority_filters)
+    end
+    @context = context.dup + [options]
+  end
+
+  # defines new filter for given +priority+ and +options+
+  #
+  # @param priority [nil, Object] has to correspond to one of the initialized priorities
+  # @param options  [Object]      the options to use for new filter
+  # @param block    [Proc]        the transformation to use when the options match
+  #
+  def filter(priority, options = nil, &block)
+    @priority_filters.store(priority, options, &block)
+  end
+
+  # starts new context
+  # @param options [Object] options to start new context
+  # @param block   [Proc]   code block that will enable filtering for the given +options+
+  # @yield         [GlobalContext] the new context
+  def in_context(options, &block)
+    self.class.new(@priority_filters, @context, options).tap(&block)
+  end
+
+  # evaluates all matching filters for given context, allows to do extra
+  # work for +priority.nil?+ or on the end of the priorities,
+  # @param method [Proc] the method to evaluate with filters matching current context
+  # @yield on first +priority.nil?+ or on the end when none
+  def evaluate_filters(method)
+    local_called = false
+
+    @priority_filters.each do |priority, filters|
+
+      @context.each { |options| filters.apply(method, options) }
+
+      if priority.nil? && block_given? && !local_called
+        yield
+        local_called = true
+      end
+
+    end
+
+    yield if block_given? && !local_called
+  end
+
+end

data/lib/context-filters/local_context.rb

@@ -0,0 +1,39 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require "context-filters/version"
+
+# allow defining local filters and evaluating code in context of thems
+module ContextFilters::LocalContext
+
+  # @return [Array<Proc>] list of blocks to evaluate
+  def local_filters
+    @local_filters ||= []
+  end
+
+  # temporarly adds +filter_block+ to the list of filters to run and
+  # yields given block of code
+  #
+  # @param filter_block [Proc] a block of code to add to the list
+  # @yield a block in which +local_filters+ temporarly includes
+  #         +filter_block+
+  def local_filter(filter_block, &block)
+    local_filters.push(filter_block)
+    block.call
+  ensure
+    local_filters.pop
+    nil
+  end
+
+  # iterates over +local_filters+ and applies them to the given +method+
+  #
+  # @param method [Proc] a method to call with each filter stored in
+  #                      +local_filters+
+  def evaluate_local_filters(method)
+    local_filters.each { |block| method.call(&block) }
+  end
+
+end

data/lib/context-filters/priority_filters.rb

@@ -0,0 +1,52 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require "context-filters/filters"
+
+# list of +filters+ sorted by +priorities+
+class ContextFilters::PriorityFilters
+
+  attr_reader :priorities
+
+  # initializes priorities and coresponding list of filters
+  # @param priorities [Array|Object] a list of priorities to order filters
+  def initialize(priorities = nil)
+    @priorities = [priorities].flatten.freeze
+    @filters_array = @priorities.product([ContextFilters::Filters.new])
+  end
+
+  # adds a priority filter
+  #
+  # @param priority [Object]   anything that was part of +priorities+ array
+  # @param options  [Object]   forwarded to Filters.store
+  # @param block    [Proc]     forwarded to Filters.store
+  # @raise          [KeyError] when priority not matching priorities is used
+  def store(priority, options = nil, &block)
+    found = @filters_array.assoc(priority)
+    raise KeyError if found.nil?
+    found.last.store(options, &block)
+  end
+
+  # list of +filters+ sorted by +priorities+
+  def to_a
+    @filters_array
+  end
+
+  # iterate over +filters+ ordered by +priority+
+  # @yield [priority,filters] the next filters from sorted array
+  # @yieldparam priority [Object]  the priority
+  # @yieldparam filters  [Filters] the filters for priority
+  def each(&block)
+    to_a.each(&block) unless empty?
+  end
+
+  # check if all of the filters are empty
+  # return [Bolean] true if all filters are empty
+  def empty?
+    @filters_array.map(&:last).all?(&:empty?)
+  end
+
+end

data/lib/context-filters/version.rb

@@ -0,0 +1,5 @@
+# Build command text based on multiple filters
+class ContextFilters
+  # version of the context-filters gem
+  VERSION = "0.0.1"
+end

data/test/context-filters/context_test.rb

@@ -0,0 +1,62 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require "test_helper"
+require "context-filters/context"
+require "context-filters/filter_test_subject"
+
+describe ContextFilters::Context do
+
+  subject do
+    ContextFilters::Context.new
+  end
+
+  let(:filter_test_subject) do
+    FilterTestSubject.new(3)
+  end
+
+  let(:change_method) do
+    filter_test_subject.method(:change)
+  end
+
+  describe "#evaluate_filters" do
+
+    it "does not apply filters when no filters" do
+      subject.priority_filters.expects(:apply).never
+      subject.evaluate_filters(Proc.new{})
+    end
+
+    it "does apply global filters" do
+      method = Proc.new{}
+      subject.context << :a
+      subject.filter(nil, :b) { true }
+      subject.priority_filters.to_a[0][1].expects(:apply).once.with(method, nil)
+      subject.priority_filters.to_a[0][1].expects(:apply).once.with(method, :a)
+      subject.evaluate_filters(method)
+    end
+
+    it "does apply local filters" do
+      subject.stubs(:local_filters).returns([Proc.new{|value| value+4}])
+      subject.evaluate_filters(change_method)
+      filter_test_subject.value.must_equal(7)
+    end
+
+    it "does apple global and local filters" do
+      filter_test_subject.value.must_equal(3)
+      addition       = Proc.new { |value| value+1 }
+      multiplication = Proc.new { |value| value*3 }
+
+      subject.filter(nil,&multiplication)
+      subject.local_filter(addition) do
+        subject.evaluate_filters(change_method)
+      end
+
+      filter_test_subject.value.must_equal(10)
+    end
+
+  end #evaluate_command
+
+end

data/test/context-filters/filter_test_subject.rb

@@ -0,0 +1,15 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+class FilterTestSubject
+  attr_accessor :value
+  def initialize(value)
+    @value = value
+  end
+  def change(&block)
+    @value = block.call(@value)
+  end
+end

data/test/context-filters/filters_test.rb

@@ -0,0 +1,97 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require "test_helper"
+require "context-filters/filters"
+require "context-filters/filter_test_subject"
+
+describe ContextFilters::Filters do
+
+  subject do
+    ContextFilters::Filters.new
+  end
+
+  describe "#store" do
+
+    it "adds empty filter" do
+      subject.store() { true }
+      subject.filters.size.must_equal 1
+      subject.filters.first.must_equal(nil)
+    end
+
+    it "adds options filter" do
+      subject.store(x: 2) { true }
+      subject.filters.size.must_equal 1
+      subject.filters.first.must_equal({x:2})
+    end
+
+    it "adds hash filter" do
+      subject.store({x: 3}) { true }
+      subject.filters.size.must_equal 1
+      subject.filters.first.must_equal({x:3})
+    end
+
+    it "adds nil filter" do
+      subject.store(nil) { true }
+      subject.filters.size.must_equal 1
+      subject.filters.first.must_equal(nil)
+    end
+
+    it "adds filter block" do
+      subject.store() { 4 }
+      filters = subject.instance_variable_get(:@filters)
+      filters.size.must_equal 1
+      filters[nil].size.must_equal 1
+      filters[nil].first.call.must_equal(4)
+    end
+
+  end #store
+
+  describe "#apply" do
+
+    let(:apply_test_subject) do
+      FilterTestSubject.new("test me")
+    end
+
+    it "does not apply filter" do
+      subject.store({x: 1}) { |value| "better #{value}" }
+
+      subject.apply(apply_test_subject.method(:change), {x: 2})
+
+      apply_test_subject.value.must_equal("test me")
+    end
+
+    it "applies single filter" do
+      subject.store({x: 1}) { |value| "better #{value}" }
+
+      subject.apply(apply_test_subject.method(:change), {x: 1})
+
+      apply_test_subject.value.must_equal("better test me")
+    end
+
+    it "applies repeating filters" do
+      subject.store({x: 1}) { |value| "better #{value}" }
+      subject.store({x: 1}) { |value| "#{value} please" }
+      subject.store({x: 1}) { |value| "#{value}!" }
+
+      subject.apply(apply_test_subject.method(:change), {x: 1})
+
+      apply_test_subject.value.must_equal("better test me please!")
+    end
+
+    it "applies different filters" do
+      subject.store({x: 1}) { |value| "dont #{value}" }
+      subject.store({x: 2}) { |value| "#{value} now" }
+
+      subject.apply(apply_test_subject.method(:change), {x: 1})
+      subject.apply(apply_test_subject.method(:change), {x: 2})
+
+      apply_test_subject.value.must_equal("dont test me now")
+    end
+
+  end #apply
+
+end

data/test/context-filters/global_context_test.rb

@@ -0,0 +1,73 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require "test_helper"
+require "context-filters/global_context"
+
+describe ContextFilters::GlobalContext do
+
+  subject do
+    ContextFilters::GlobalContext.new
+  end
+
+  describe "#initialize" do
+
+    it "sets up initial variables" do
+      subject.priority_filters.must_be_kind_of ContextFilters::PriorityFilters
+      subject.priority_filters.must_be_empty
+      subject.context.must_equal([nil])
+    end
+
+  end #initialize
+
+  it "stores filters" do
+    subject.priority_filters.expects(:store).with(nil, :a).once
+    subject.filter(nil, :a) do true end
+  end
+
+  describe "#evaluate_filters" do
+
+    it "does not apply filters when no filters" do
+      subject.priority_filters.expects(:apply).never
+      subject.evaluate_filters(Proc.new{})
+    end
+
+    it "does apply filters" do
+      method = Proc.new{}
+      subject.context << :a
+      subject.filter(nil, :b) { true }
+      subject.priority_filters.to_a[0][1].expects(:apply).once.with(method, nil)
+      subject.priority_filters.to_a[0][1].expects(:apply).once.with(method, :a)
+      subject.evaluate_filters(method)
+    end
+
+  end #evaluate_command
+
+  describe "#group" do
+
+    it "nests" do
+      subject.in_context(:a) do |test_a|
+
+        test_a.must_be_kind_of ContextFilters::GlobalContext
+        test_a.priority_filters.object_id.must_equal(subject.priority_filters.object_id)
+        test_a.context.object_id.wont_equal(subject.context.object_id)
+        test_a.context.must_equal([nil, :a])
+
+        test_a.in_context(:b) do |test_b|
+          test_b.must_be_kind_of ContextFilters::GlobalContext
+          test_b.priority_filters.object_id.must_equal(test_a.priority_filters.object_id)
+          test_b.context.object_id.wont_equal(test_a.context.object_id)
+          test_b.context.must_equal([nil, :a, :b])
+        end
+
+        test_a.context.must_equal([nil, :a])
+      end
+      subject.context.must_equal([nil])
+    end
+
+  end #group
+
+end

data/test/context-filters/local_context_test.rb

@@ -0,0 +1,43 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require "test_helper"
+require "context-filters/local_context"
+require "context-filters/filter_test_subject"
+
+describe ContextFilters::LocalContext do
+
+  subject do
+    Object.new.tap { |o| o.extend(ContextFilters::LocalContext) }
+  end
+
+  let(:filter_test_subject) do
+    FilterTestSubject.new(3)
+  end
+
+  let(:change_method) do
+    filter_test_subject.method(:change)
+  end
+
+  it "has default value for #local_filters" do
+    subject.local_filters.must_equal([])
+  end
+
+  it "adds local filters" do
+    subject.local_filter(change_method) do
+      subject.local_filters.must_equal([change_method])
+    end
+    subject.local_filters.must_equal([])
+  end
+
+  it "runs change" do
+    method = Proc.new { |value| value+4 }
+    subject.stubs(:local_filters).returns([method])
+    subject.evaluate_local_filters(change_method)
+    filter_test_subject.value.must_equal(7)
+  end
+
+end

data/test/context-filters/priority_filters_test.rb

@@ -0,0 +1,65 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require "test_helper"
+require "context-filters/priority_filters"
+
+describe ContextFilters::PriorityFilters do
+
+  subject do
+    ContextFilters::PriorityFilters.allocate
+  end
+
+  describe "#initialize" do
+
+    it "initializes with no args" do
+      subject.send(:initialize)
+      subject.priorities.must_equal([nil])
+    end
+
+    it "initializes with objects" do
+      subject.send(:initialize, :a)
+      subject.priorities.must_equal([:a])
+    end
+
+    it "initializes with array" do
+      subject.send(:initialize, [:a, nil, :b])
+      subject.priorities.must_equal([:a, nil, :b])
+    end
+
+    it "initializes to_a" do
+      subject.send(:initialize, [:a, :b])
+      subject.to_a.size.must_equal(2)
+      subject.to_a.map(&:first).must_equal([:a, :b])
+      subject.to_a[0][1].must_be_kind_of ContextFilters::Filters
+      subject.to_a[1][1].must_be_kind_of ContextFilters::Filters
+    end
+
+  end #initialize
+
+  describe "#store" do
+
+    it "stores filters" do
+      subject.send(:initialize, :a)
+      subject.store(:a, :options) {true}
+      subject.to_a[0][1].filters.must_equal([:options])
+    end
+
+    it "throws exception on wrong priority" do
+      subject.send(:initialize, :a)
+      lambda {
+        subject.store(:b, :options) {true}
+      }.must_raise(KeyError)
+    end
+
+  end
+
+  it "returns list in to_a" do
+    subject.send(:initialize, [2, 1])
+    subject.to_a.must_be_kind_of Array
+  end
+
+end

data/test/test_helper.rb

@@ -0,0 +1,33 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require "rubygems"
+
+if
+  RUBY_VERSION == "2.0.0" && # check Gemfile
+  $0 != "-e" # do not do that in guard
+then
+  require "coveralls"
+  require "simplecov"
+
+  SimpleCov.start do
+    formatter SimpleCov::Formatter::MultiFormatter[
+      SimpleCov::Formatter::HTMLFormatter,
+      Coveralls::SimpleCov::Formatter,
+    ]
+    command_name "Unit Tests"
+    add_filter "/test/"
+  end
+
+  Coveralls.noisy = true unless ENV["CI"]
+end
+
+# Autoload all lib/**/*.rb files so simplecov does not misses anything
+Dir[File.expand_path("../../lib/**/*.rb", __FILE__)].each{|f| require f }
+
+require "minitest/autorun" unless $0=="-e" # skip in guard
+require "minitest/unit"
+require "mocha/setup"

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: context-filters
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Michal Papis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: guard-yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '5.4'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.3'
+description: 
+email:
+- mpapis@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/context-filters.rb
+- lib/context-filters/context.rb
+- lib/context-filters/filters.rb
+- lib/context-filters/global_context.rb
+- lib/context-filters/local_context.rb
+- lib/context-filters/priority_filters.rb
+- lib/context-filters/version.rb
+- test/context-filters/context_test.rb
+- test/context-filters/filter_test_subject.rb
+- test/context-filters/filters_test.rb
+- test/context-filters/global_context_test.rb
+- test/context-filters/local_context_test.rb
+- test/context-filters/priority_filters_test.rb
+- test/test_helper.rb
+homepage: https://github.com/remote-exec/context-filters
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Generic support for filters applied in context
+test_files:
+- test/test_helper.rb
+- test/context-filters/filter_test_subject.rb
+- test/context-filters/context_test.rb
+- test/context-filters/filters_test.rb
+- test/context-filters/global_context_test.rb
+- test/context-filters/local_context_test.rb
+- test/context-filters/priority_filters_test.rb
+has_rdoc: