context-filters 0.10.0 → 0.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9f1809572fcd86c5f8ee99f43c956fa4ebbba43b
-  data.tar.gz: a4c0c942c34bcabfb2193b2d8f59cb2fa2bcf23e
+  metadata.gz: 83448fa38442792fe4a30024c26e0e992cd67edc
+  data.tar.gz: 37f4cbb3444f2f9365d922c86fc6ecd87cf2504a
 SHA512:
-  metadata.gz: 5b0f70e4be2fbf8c869f8be48a9ac20d9051b7c757d1cdad9f822e5242ab7ef432be7ef117a073bd2cae76a7ee2337f55c7ba157affe239e3f46420b63e09fe9
-  data.tar.gz: 1274b880b437e254e86c98027a30efa26175ae57758d135b786a0b5383d3d434cdc70b500c23a76c36eed0abbad5ef17b87423396d6c10cf55a94f98a08ea5a9
+  metadata.gz: 1b3a3cc9145e049c9ac4908230a7101c66cfbe0ce9ad5cfef6624c87606ab0cb2907854d9b3f06ad26d70814755dd52f6e58ab09f14eeb48b1504c249b5a86f4
+  data.tar.gz: 77ae68c8e7f0fba6778b2674fabbe7b09acb108a4e7bc103465cc6d36e3b9c44fe82c007c2b6f6418e4478ca01016d8ade5ef397ef53aa056e7b7f2386dd44ae

data/lib/context-filters/context.rb

@@ -4,14 +4,20 @@ 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"
+require "context-filters/context/global"
+require "context-filters/context/local"
 
 # manipulate set of context and filters for it,
 # allow evaluating filters in given context
-class ContextFilters::Context < ContextFilters::GlobalContext
+class ContextFilters::Context
 
-  include ContextFilters::LocalContext
+  include ContextFilters::Context::Global
+  include ContextFilters::Context::Local
+
+  # sets up the priorities order for global context filters
+  def initialize(priority_filters = nil)
+    initialize_priority_filters(priority_filters)
+  end
 
   # run the given method on global and local filters
   # @param method [Proc] the method to evaluate for filters matching context

data/lib/context-filters/context/global.rb

@@ -0,0 +1,43 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require "context-filters/context/global_context"
+require "context-filters/context/global_filters"
+
+class ContextFilters::Context
+
+  # builds list of filters and provides dsl for building nested context
+  # and allows evaluating filters on methods in the current context
+  module Global
+
+    include GlobalContext
+    include GlobalFilters
+
+    # evaluates all matching filters for given context_stack, 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(target, method)
+      local_called = false
+
+      priority_filters.each do |priority, filters|
+
+        context_stack.each { |options| filters.apply(target, method, options) }
+
+        if priority.nil? && block_given? && !local_called
+          yield
+          local_called = true
+        end
+
+      end
+
+      yield if block_given? && !local_called
+    end
+
+  end
+
+end

data/lib/context-filters/context/global_context.rb

@@ -0,0 +1,34 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require "context-filters/version"
+
+class ContextFilters::Context
+
+  # temporarily stack context and yield code
+  module GlobalContext
+
+    # @return [Array] the context stack
+    # @api private
+    def context_stack
+      @context_stack ||= [nil]
+    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 a block in which +context_stack+ temporarily includes +filter_block+
+    # @yieldparam    [self]   use it optionally to give a new name to the
+    #                         code evaluated in new context
+    def context(options, &block)
+      context_stack.push(options)
+      yield(self)
+    ensure
+      context_stack.pop
+    end
+  end
+
+end

data/lib/context-filters/context/global_filters.rb

@@ -0,0 +1,39 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require "context-filters/filters/priority_filters"
+
+class ContextFilters::Context
+
+  # simple access to global priority filters
+  module GlobalFilters
+
+    # @return [PriorityFilters] shared list of filters
+    # @api private
+    def priority_filters
+      @priority_filters ||= initialize_priority_filters(nil)
+    end
+
+    # sets up the priorities order for filters
+    # @param priority_filters [Array] initialization param for PriorityFilters
+    # @api private
+    def initialize_priority_filters(priority_filters)
+      @priority_filters = ContextFilters::Filters::PriorityFilters.new(priority_filters)
+    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
+
+  end
+
+end

data/lib/context-filters/context/local.rb

@@ -0,0 +1,43 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require "context-filters/version"
+
+class ContextFilters::Context
+
+  # allow defining local filters and evaluating code in context of thems
+  module Local
+
+    # @return [Array<Proc>] list of blocks to evaluate
+    # @api private
+    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+ temporarily includes +filter_block+
+    def local_filter(filter_block, &block)
+      local_filters.push(filter_block)
+      block.call
+    ensure
+      local_filters.pop
+    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+
+    # @api private
+    def evaluate_local_filters(target, method)
+      local_filters.each { |block| target.send(method, &block) }
+    end
+
+  end
+
+end

data/lib/context-filters/filters/filters.rb

@@ -0,0 +1,72 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require "context-filters/filters/store"
+
+# filtering related classes and modules
+module ContextFilters::Filters
+
+  # 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 Filters
+
+    include Store
+
+    # applies matching filters to the given target method, also uses
+    # filters matching extra +:target => target+ when options is a Hash
+    # @param target  [Object] an object to run the method on
+    # @param method  [symbol] method name that takes a transformation
+    #                         block as param
+    # @param options [Object] a filter for selecting matching blocks
+    def apply(target, method, options = nil)
+      select_filters(target, options).each{|block| target.send(method, &block) }
+    end
+
+    # Select matching filters and filters including targets when
+    # options is a +Hash+
+    # @param target  [Object] an object to run the method on
+    # @param options [Object] a filter for selecting matching blocks
+    def select_filters(target, options)
+      found = filters_store.fetch(options, [])
+      if
+        Hash === options || options.nil?
+      then
+        options ||={}
+        options.merge!(:target => target)
+        found +=
+        # can not @filters.fetch(options, []) to allow filters provide custom ==()
+        filters_store.select do |filter_options, filters|
+          options == filter_options
+        end.map(&:last).flatten
+      end
+      found
+    end
+
+  end
+
+end

data/lib/context-filters/filters/priority_filters.rb

@@ -0,0 +1,57 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require "context-filters/filters/filters"
+
+module ContextFilters::Filters
+
+  # list of +filters+ sorted by +priorities+
+  class PriorityFilters
+
+    # @return [Array] list of priorities this object was initialized with
+    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([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
+
+end

data/lib/context-filters/filters/store.rb

@@ -0,0 +1,43 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require "context-filters/version"
+
+# filtering related classes and modules
+module ContextFilters::Filters
+
+  # Store filters
+  module Store
+
+    # @return [Hash] the filters storage
+    # @api private
+    def filters_store
+      @filters_store ||= {}
+    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_store[options] ||= []
+      filters_store[options] << block
+    end
+
+    # Array of already defined filters
+    def filters
+      filters_store.keys
+    end
+
+    # @return [Boolean] true if there are any rules stored, false otherwise
+    def empty?
+      filters_store.empty?
+    end
+
+  end
+
+end

data/lib/context-filters/version.rb

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

data/test/context-filters/context/global_context_test.rb

@@ -0,0 +1,36 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require "test_helper"
+require "context-filters/context/global_context"
+
+describe ContextFilters::Context::GlobalContext do
+
+  subject do
+    Object.new.tap { |o| o.extend(ContextFilters::Context::GlobalContext) }
+  end
+
+  it "sets up initial variables" do
+    subject.context_stack.must_equal([nil])
+  end
+
+  it "nests context" do
+    subject.context(:a) do |test_a|
+
+      test_a.object_id.must_equal(subject.object_id)
+      test_a.context_stack.must_equal([nil, :a])
+
+      test_a.context(:b) do |test_b|
+        test_b.object_id.must_equal(test_a.object_id)
+        test_b.context_stack.must_equal([nil, :a, :b])
+      end
+
+      test_a.context_stack.must_equal([nil, :a])
+    end
+    subject.context_stack.must_equal([nil])
+  end
+
+end

data/test/context-filters/context/global_filters_test.rb

@@ -0,0 +1,32 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require "test_helper"
+require "context-filters/context/global_filters"
+
+describe ContextFilters::Context::GlobalFilters do
+
+  subject do
+    Object.new.tap { |o| o.extend(ContextFilters::Context::GlobalFilters) }
+  end
+
+  it "sets up empty initial variables" do
+    subject.priority_filters.must_be_kind_of ContextFilters::Filters::PriorityFilters
+    subject.priority_filters.must_be_empty
+  end
+
+  it "initializes new PriorityFilters" do
+    example = [:a, :b, :c]
+    subject.initialize_priority_filters(example)
+    subject.priority_filters.priorities.must_equal(example)
+  end
+
+  it "stores filters" do
+    subject.priority_filters.expects(:store).with(nil, :a).once
+    subject.filter(nil, :a) do true end
+  end
+
+end

data/test/context-filters/context/global_test.rb

@@ -0,0 +1,54 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require "test_helper"
+require "context-filters/context/global"
+require "context-filters/filter_test_subject"
+
+describe ContextFilters::Context::Global do
+
+  subject do
+    Object.new.tap { |o| o.extend(ContextFilters::Context::Global) }
+  end
+
+  let(:filter_test_subject) do
+    FilterTestSubject.new(3)
+  end
+
+  it "does not apply filters when no filters" do
+    subject.priority_filters.expects(:apply).never
+    subject.evaluate_filters(filter_test_subject, :change)
+  end
+
+  it "does apply filters" do
+    method = Proc.new{}
+    subject.context_stack << :a
+    subject.filter(nil, :b) { true }
+    subject.priority_filters.to_a[0][1].expects(:apply).once.with(filter_test_subject, :change, nil)
+    subject.priority_filters.to_a[0][1].expects(:apply).once.with(filter_test_subject, :change, :a)
+    subject.evaluate_filters(filter_test_subject, :change)
+  end
+
+  it "does apply targeted filters in top context" do
+    addition       = Proc.new { |value| value+1 }
+    multiplication = Proc.new { |value| value*3 }
+    subject.filter(nil, {:target => filter_test_subject}, &addition)
+    subject.filter(nil, {:target => nil}, &multiplication)
+    subject.evaluate_filters(filter_test_subject, :change)
+    filter_test_subject.value.must_equal(4)
+  end
+
+  it "does apply targeted filters in sub context" do
+    addition       = Proc.new { |value| value+1 }
+    multiplication = Proc.new { |value| value*3 }
+    subject.context_stack << { :a => 1 }
+    subject.filter(nil, {:a => 1, :target => filter_test_subject}, &addition)
+    subject.filter(nil, {:a => 1, :target => nil}, &multiplication)
+    subject.evaluate_filters(filter_test_subject, :change)
+    filter_test_subject.value.must_equal(4)
+  end
+
+end

data/test/context-filters/{local_context_test.rb → context/local_test.rb}

@@ -5,13 +5,13 @@ See the file LICENSE for copying permission.
 =end
 
 require "test_helper"
-require "context-filters/local_context"
+require "context-filters/context/local"
 require "context-filters/filter_test_subject"
 
-describe ContextFilters::LocalContext do
+describe ContextFilters::Context::Local do
 
   subject do
-    Object.new.tap { |o| o.extend(ContextFilters::LocalContext) }
+    Object.new.tap { |o| o.extend(ContextFilters::Context::Local) }
   end
 
   let(:filter_test_subject) do

data/test/context-filters/context_test.rb

@@ -10,16 +10,35 @@ require "context-filters/filter_test_subject"
 
 describe ContextFilters::Context do
 
-  subject do
-    ContextFilters::Context.new
-  end
+  describe "#initialize" do
 
-  let(:filter_test_subject) do
-    FilterTestSubject.new(3)
-  end
+    subject do
+      ContextFilters::Context.allocate
+    end
+
+    it "initializes empty priority_filters" do
+      subject.send(:initialize)
+      subject.priority_filters.priorities.must_equal([nil])
+    end
+
+    it "initializes priority_filters with values" do
+      example = [:a, :b, :c]
+      subject.send(:initialize, example)
+      subject.priority_filters.priorities.must_equal(example)
+    end
+
+  end #initialize
 
   describe "#evaluate_filters" do
 
+    subject do
+      ContextFilters::Context.new
+    end
+
+    let(:filter_test_subject) do
+      FilterTestSubject.new(3)
+    end
+
     it "does not apply filters when no filters" do
       subject.priority_filters.expects(:apply).never
       subject.evaluate_filters(filter_test_subject, :change)

data/test/context-filters/{filters_test.rb → filters/filters_test.rb}

@@ -5,51 +5,15 @@ See the file LICENSE for copying permission.
 =end
 
 require "test_helper"
-require "context-filters/filters"
+require "context-filters/filters/filters"
 require "context-filters/filter_test_subject"
 
-describe ContextFilters::Filters do
+describe ContextFilters::Filters::Filters do
 
   subject do
-    ContextFilters::Filters.new
+    ContextFilters::Filters::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

data/test/context-filters/{priority_filters_test.rb → filters/priority_filters_test.rb}

@@ -5,12 +5,12 @@ See the file LICENSE for copying permission.
 =end
 
 require "test_helper"
-require "context-filters/priority_filters"
+require "context-filters/filters/priority_filters"
 
-describe ContextFilters::PriorityFilters do
+describe ContextFilters::Filters::PriorityFilters do
 
   subject do
-    ContextFilters::PriorityFilters.allocate
+    ContextFilters::Filters::PriorityFilters.allocate
   end
 
   describe "#initialize" do
@@ -34,8 +34,8 @@ describe ContextFilters::PriorityFilters 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
+      subject.to_a[0][1].must_be_kind_of ContextFilters::Filters::Filters
+      subject.to_a[1][1].must_be_kind_of ContextFilters::Filters::Filters
     end
 
   end #initialize

data/test/context-filters/filters/store_test.rb

@@ -0,0 +1,57 @@
+=begin
+Copyright 2014 Michal Papis <mpapis@gmail.com>
+
+See the file LICENSE for copying permission.
+=end
+
+require "test_helper"
+require "context-filters/filters/store"
+
+describe ContextFilters::Filters::Store do
+
+  subject do
+    Object.new.tap { |o| o.extend(ContextFilters::Filters::Store) }
+  end
+
+  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 }
+    subject.filters_store.size.must_equal 1
+    subject.filters_store[nil].size.must_equal 1
+    subject.filters_store[nil].first.call.must_equal(4)
+  end
+
+  it "is empty?" do
+    subject.filters_store.size.must_equal 0
+    subject.empty?.must_equal true
+  end
+
+  it "is not empty?" do
+    subject.store() { 4 }
+    subject.empty?.must_equal false
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: context-filters
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Michal Papis
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-10-17 00:00:00.000000000 Z
+date: 2014-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: guard
@@ -103,17 +103,23 @@ 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/context/global.rb
+- lib/context-filters/context/global_context.rb
+- lib/context-filters/context/global_filters.rb
+- lib/context-filters/context/local.rb
+- lib/context-filters/filters/filters.rb
+- lib/context-filters/filters/priority_filters.rb
+- lib/context-filters/filters/store.rb
 - lib/context-filters/version.rb
+- test/context-filters/context/global_context_test.rb
+- test/context-filters/context/global_filters_test.rb
+- test/context-filters/context/global_test.rb
+- test/context-filters/context/local_test.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/context-filters/filters/filters_test.rb
+- test/context-filters/filters/priority_filters_test.rb
+- test/context-filters/filters/store_test.rb
 - test/test_helper.rb
 homepage: https://github.com/remote-exec/context-filters
 licenses:
@@ -141,10 +147,13 @@ specification_version: 4
 summary: Generic support for filters applied in context
 test_files:
 - test/test_helper.rb
-- test/context-filters/priority_filters_test.rb
-- test/context-filters/local_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/context/local_test.rb
+- test/context-filters/context/global_test.rb
+- test/context-filters/context/global_context_test.rb
+- test/context-filters/context/global_filters_test.rb
 - test/context-filters/context_test.rb
+- test/context-filters/filters/priority_filters_test.rb
+- test/context-filters/filters/filters_test.rb
+- test/context-filters/filters/store_test.rb
 has_rdoc: 

data/lib/context-filters/filters.rb

@@ -1,90 +0,0 @@
-=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 target method, also uses
-  # filters matching extra +:target => target+ when options is a Hash
-  # @param target  [Object] an object to run the method on
-  # @param method  [symbol] method name that takes a transformation
-  #                         block as param
-  # @param options [Object] a filter for selecting matching blocks
-  def apply(target, method, options = nil)
-    select_filters(target, options).each{|block| target.send(method, &block) }
-  end
-
-  # Select matching filters and filters including targets when
-  # options is a +Hash+
-  # @param target  [Object] an object to run the method on
-  # @param options [Object] a filter for selecting matching blocks
-  def select_filters(target, options)
-    found = @filters.fetch(options, [])
-    if
-      Hash === options || options.nil?
-    then
-      options ||={}
-      options.merge!(:target => target)
-      found +=
-      # can not @filters.fetch(options, []) to allow filters provide custom ==()
-      @filters.select do |filter_options, filters|
-        options == filter_options
-      end.map(&:last).flatten
-    end
-    found
-  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

@@ -1,80 +0,0 @@
-=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
-  # @api private
-  attr_reader :context_stack
-
-  # @return [PriorityFilters] shared list of filters
-  # @api private
-  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_stack    [Array]  parents context_stack, duplicates to initialize own context_stack
-  # @param options          [Object] new context, ads it to context_stack
-  #
-  def initialize(priority_filters = nil, context_stack = [], options = nil)
-    if ContextFilters::PriorityFilters === priority_filters
-    then @priority_filters = priority_filters
-    else @priority_filters = ContextFilters::PriorityFilters.new(priority_filters)
-    end
-    @context_stack = context_stack.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 context(options, &block)
-    self.class.new(@priority_filters, @context_stack, options).tap(&block)
-  end
-
-  # evaluates all matching filters for given context_stack, 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(target, method)
-    local_called = false
-
-    @priority_filters.each do |priority, filters|
-
-      @context_stack.each { |options| filters.apply(target, 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

@@ -1,41 +0,0 @@
-=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
-  # @api private
-  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+
-  # @api private
-  def evaluate_local_filters(target, method)
-    local_filters.each { |block| target.send(method, &block) }
-  end
-
-end

data/lib/context-filters/priority_filters.rb

@@ -1,53 +0,0 @@
-=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
-
-  # @return [Array] list of priorities this object was initialized with
-  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/test/context-filters/global_context_test.rb

@@ -1,97 +0,0 @@
-=begin
-Copyright 2014 Michal Papis <mpapis@gmail.com>
-
-See the file LICENSE for copying permission.
-=end
-
-require "test_helper"
-require "context-filters/global_context"
-require "context-filters/filter_test_subject"
-
-describe ContextFilters::GlobalContext do
-
-  subject do
-    ContextFilters::GlobalContext.new
-  end
-
-  let(:filter_test_subject) do
-    FilterTestSubject.new(3)
-  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_stack.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(filter_test_subject, :change)
-    end
-
-    it "does apply filters" do
-      method = Proc.new{}
-      subject.context_stack << :a
-      subject.filter(nil, :b) { true }
-      subject.priority_filters.to_a[0][1].expects(:apply).once.with(filter_test_subject, :change, nil)
-      subject.priority_filters.to_a[0][1].expects(:apply).once.with(filter_test_subject, :change, :a)
-      subject.evaluate_filters(filter_test_subject, :change)
-    end
-
-    it "does apply targeted filters in top context" do
-      addition       = Proc.new { |value| value+1 }
-      multiplication = Proc.new { |value| value*3 }
-      subject.filter(nil, {:target => filter_test_subject}, &addition)
-      subject.filter(nil, {:target => nil}, &multiplication)
-      subject.evaluate_filters(filter_test_subject, :change)
-      filter_test_subject.value.must_equal(4)
-    end
-
-    it "does apply targeted filters in sub context" do
-      addition       = Proc.new { |value| value+1 }
-      multiplication = Proc.new { |value| value*3 }
-      subject.context_stack << { :a => 1 }
-      subject.filter(nil, {:a => 1, :target => filter_test_subject}, &addition)
-      subject.filter(nil, {:a => 1, :target => nil}, &multiplication)
-      subject.evaluate_filters(filter_test_subject, :change)
-      filter_test_subject.value.must_equal(4)
-    end
-
-  end #evaluate_command
-
-  describe "#group" do
-
-    it "nests" do
-      subject.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_stack.object_id.wont_equal(subject.context_stack.object_id)
-        test_a.context_stack.must_equal([nil, :a])
-
-        test_a.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_stack.object_id.wont_equal(test_a.context_stack.object_id)
-          test_b.context_stack.must_equal([nil, :a, :b])
-        end
-
-        test_a.context_stack.must_equal([nil, :a])
-      end
-      subject.context_stack.must_equal([nil])
-    end
-
-  end #group
-
-end