iba 0.0.2 → 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 14fbefc240682b4cf95c79cf93598e2e8b12dd70
+  data.tar.gz: c3501eda480f88b302353c718a3a452d470c94d2
+SHA512:
+  metadata.gz: c13f36b28278479f94947f0c62c3fb600d16c5c3db034825fb580b6d4d76f61e00a7c6110661720a22cd525e3054894d599fd355241c3ac2be03c67adfa56927
+  data.tar.gz: 0a5e9b56dcbde33f6033d32ec7117ce03ff3dc37c158b5cfd2da323d5880508b2dae6ddf585d88b38c6639d286198a3180bfd87166795d58053ddf2f898b0815

data/Rakefile

@@ -1,3 +1,18 @@
-load 'tasks/setup.rb'
+require 'rake/clean'
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+namespace :test do
+
+  Rake::TestTask.new(:run) do |t|
+    t.libs = ['lib']
+    t.test_files = FileList['test/**/*_test.rb']
+    t.ruby_opts += ['-w']
+  end
+
+end
+
+desc 'Alias to test:run'
+task :test => 'test:run'
 
 task :default => 'test:run'

data/lib/iba.rb

@@ -1,186 +1,205 @@
 module Iba
+  class Combinator
+    def initialize &blk
+      @block = blk
+    end
 
-class Combinator
-  def initialize &blk
-    @block = blk
-  end
-
-  def call
-    @block.call
-  end
+    def call
+      @block.call
+    end
 
-  def to_s
-    expression._to_s
-  end
+    def to_s
+      expression._to_s
+    end
 
-  def expression
-    @expression ||= EmptyExpression.new._parse(&@block)
-  end
+    def expression
+      @expression ||= EmptyExpression.new._parse(&@block)
+    end
 
-  def analyse
-    str = "#{self.to_s} is #{self.call.inspect}"
-    if expression.class == MethodCallExpression and expression._method == :==
-      b = @block.binding
-      lft = expression._reciever
-      rgt = expression._args.first
-      exprs = [lft, rgt].map {|e| display_subexpression e}.compact
-      str << "\n"
-      str << exprs.join(", ")
-    end
-    str
-  end
+    def analyse
+      str = "#{self} is #{call.inspect}"
+      if expression.class == MethodCallExpression && expression._method == :==
+        lft = expression._reciever
+        rgt = expression._args.first
+        exprs = [lft, rgt].map { |e| display_subexpression e }.compact
+        str << "\n"
+        str << exprs.join(', ')
+      end
+      str
+    end
 
-  private
+    private
 
-  def display_subexpression expr
-    if expr.class == LiteralExpression
-      nil
-    else
-      str = expr._to_s
-      "#{str} is #{eval(str, @block.binding).inspect}"
+    def display_subexpression expr
+      if expr.class == LiteralExpression
+        nil
+      else
+        str = expr._to_s
+        "#{str} is #{eval(str, @block.binding).inspect}"
+      end
     end
   end
 
-end
+  class EmptyExpression
+    def method_missing method, *args
+      MethodCallExpression.new self, method, args
+    end
 
-class EmptyExpression
-  def method_missing method, *args
-    return MethodCallExpression.new self, method, args
-  end
+    def _parse &blk
+      b = blk.binding
+
+      vars = eval 'local_variables', b
+      ivars = eval 'instance_variables', b
 
-  def _parse &blk
-    b = blk.binding
+      _override_instance_variables ivars
 
-    vars = eval "local_variables", b
-    ivars = eval "instance_variables", b
+      _override_local_variables vars, b
 
-    _override_instance_variables ivars
+      result = instance_eval(&blk)
+      unless result.class == MethodCallExpression
+        result = LiteralExpression.new(result)
+      end
 
-    _override_local_variables vars, b
+      _restore_local_variables vars, b
 
-    result = self.instance_eval(&blk)
-    unless result.class == MethodCallExpression
-      result = LiteralExpression.new(result)
+      result
     end
 
-    _restore_local_variables vars, b
-
-    result
-  end
+    def _override_instance_variables vars
+      vars.each do |v|
+        next if v =~ /^@_/
+        eval "#{v} = Iba::MethodCallExpression.new(Iba::EmptyExpression.new, :#{v}, [])"
+      end
+    end
 
-  def _override_instance_variables vars
-    vars.each do |v|
-      next if v =~ /^@_/
-      eval "#{v} = Iba::MethodCallExpression.new(Iba::EmptyExpression.new, :#{v}, [])"
+    def _override_local_variables vars, b
+      vars.each do |v|
+        next if v =~ /^_/
+        eval "_#{v} = #{v}", b
+        eval "#{v} = Iba::MethodCallExpression.new(Iba::EmptyExpression.new, :#{v}, [])", b
+      end
     end
-  end
 
-  def _override_local_variables vars, b
-    vars.each do |v|
-      next if v =~ /^_/
-      eval "_#{v} = #{v}", b
-      eval "#{v} = Iba::MethodCallExpression.new(Iba::EmptyExpression.new, :#{v}, [])", b
+    def _restore_local_variables vars, b
+      vars.each do |v|
+        next if v =~ /^_/
+        eval "#{v} = _#{v}", b
+      end
     end
-  end
 
-  def _restore_local_variables vars, b
-    vars.each do |v|
-      next if v =~ /^_/
-      eval "#{v} = _#{v}", b
+    def _to_s
+      ''
     end
   end
 
-  def _to_s
-    ""
-  end
-end
-
-class LiteralExpression
-  def initialize val
-    @value = val
-  end
+  class LiteralExpression
+    def initialize val
+      @value = val
+    end
 
-  def _to_s
-    @value.inspect
+    def _to_s
+      @value.inspect
+    end
   end
-end
 
-class MethodCallExpression
-  attr_reader :_method, :_reciever, :_args
+  class MethodCallExpression
+    attr_reader :_method, :_reciever, :_args
 
-  def initialize reciever, methodname, args
-    @_reciever = reciever
-    @_method = methodname
-    @_args = args.map {|a| _wrap(a)}
-  end
+    def initialize reciever, methodname, args
+      @_reciever = reciever
+      @_method = methodname
+      @_args = args.map { |a| _wrap(a) }
+    end
 
-  def _to_s
-    rcv = @_reciever._to_s
-    args = @_args.map {|a| a.respond_to?(:_to_s) ? a._to_s : a.to_s }
-
-    if @_method == :[]
-      "#{rcv}[#{args[0]}]"
-    elsif method_is_operator?
-      case @_args.length
-      when 0
-	"#{@_method.to_s.sub(/@$/, '')}#{rcv}"
-      when 1
-	"(#{rcv} #{@_method} #{args.first})"
+    def _to_s
+      rcv = @_reciever._to_s
+      args = @_args.map { |a| a.respond_to?(:_to_s) ? a._to_s : a.to_s }
+
+      if @_method == :[]
+        "#{rcv}[#{args[0]}]"
+      elsif method_is_operator?
+        case @_args.length
+        when 0
+          "#{@_method.to_s.sub(/@$/, '')}#{rcv}"
+        when 1
+          "(#{rcv} #{@_method} #{args.first})"
+        else
+          raise NotImplementedError
+        end
       else
-	raise NotImplementedError
+        str = rcv == '' ? '' : "#{rcv}."
+        str << @_method.to_s
+        str << "(#{args.join(', ')})" unless @_args.empty?
+        str
       end
-    else
-      str = rcv == "" ? "" : "#{rcv}."
-      str << @_method.to_s
-      unless @_args.empty?
-	str << "(#{args.join(', ')})"
-      end
-      str
     end
-  end
 
-  def method_missing method, *args
-    super if method.to_s =~ /^_/
-    return MethodCallExpression.new self, method, args
-  end
+    def method_missing method, *args
+      super if method.to_s =~ /^_/
+      MethodCallExpression.new self, method, args
+    end
 
-  def method_is_operator?
-    @_method.to_s !~ /^[a-z]/
-  end
+    def method_is_operator?
+      @_method.to_s !~ /^[a-z]/
+    end
 
-  def to_s
-    method_missing :to_s
-  end
+    def to_s
+      method_missing :to_s
+    end
 
-  def == other
-    method_missing :==, other
-  end
+    def == other
+      method_missing :==, other
+    end
 
-  private
+    private
 
-  def _wrap arg
-    if arg.class == MethodCallExpression
-      arg
-    else
-      LiteralExpression.new arg
+    def _wrap arg
+      if arg.class == MethodCallExpression
+        arg
+      else
+        LiteralExpression.new arg
+      end
     end
   end
-end
 
-module BlockAssertion
-  def assert *args
-    if block_given?
-      if yield
-	assert_block("true") { true }
-      else
-        msg = args.empty? ? "" : args.first
-	ana = Combinator.new(&Proc.new).analyse
-	assert_block(build_message(msg, "#{ana}.")) { false }
+  module BlockAssertion
+    if RUBY_VERSION < '1.9'
+
+      def assert *args
+        if block_given?
+          if yield
+            assert_block('true') { true }
+          else
+            msg = args.empty? ? '' : args.first
+            ana = Combinator.new(&Proc.new).analyse
+            assert_block(build_message msg, "#{ana}.") { false }
+          end
+        else
+          super
+        end
       end
+
     else
-      super
+
+      def assert *args
+        if block_given?
+          if yield
+            assert_block('true') { true }
+          else
+            msg = args.empty? ? '' : args.first
+            ana = Combinator.new(&Proc.new).analyse
+            assert_block(message(msg) { ana }) { false }
+          end
+        else
+          test, msg = *args
+          case msg
+          when nil, String
+            msg = message(msg) { '<false> is not true' }
+          end
+          super test, msg
+        end
+      end
+
     end
   end
 end
-
-end

data/test/.rubocop.yml

@@ -0,0 +1,10 @@
+inherit_from: ../.rubocop.yml
+
+# We need to rescue Exception to test exceptions thrown by assert
+# TODO: Remove once support for Ruby 1.8 is dropped.
+Lint/RescueException:
+  Enabled: false
+
+# Allow compact syntax when adding to Test::Unit::TestCase
+Style/ClassAndModuleChildren:
+  Enabled: false

data/test/analyse_test.rb

@@ -3,41 +3,41 @@ require File.expand_path('test_helper.rb', File.dirname(__FILE__))
 # Test how the combinator analyses the parsed block contents.
 class AnalyseTest < Test::Unit::TestCase
   def test_empty_block
-    assert_equal "nil is nil", combinator { }.analyse
+    assert_equal 'nil is nil', combinator {}.analyse
   end
 
   def test_variable
     foo = 23
-    assert_equal "foo is 23", combinator { foo }.analyse
+    assert_equal 'foo is 23', combinator { foo }.analyse
   end
 
   def test_operator_equals
     foo = 42
     bar = 23
-    assert_equal "(foo == bar) is false\nfoo is 42, bar is 23",
-      combinator { foo == bar }.analyse 
+    result = combinator { foo == bar }.analyse
+    assert_equal "(foo == bar) is false\nfoo is 42, bar is 23", result
   end
 
   def test_operator_equals_literal
     foo = 42
-    assert_equal "(foo == 23) is false\nfoo is 42",
-      combinator { foo == 23 }.analyse 
+    result = combinator { foo == 23 }.analyse
+    assert_equal "(foo == 23) is false\nfoo is 42", result
   end
 
   def test_operator_equals_array_literal
-    foo = [1, "bar"]
-    assert_equal "(foo == [2, \"baz\"]) is false\nfoo is [1, \"bar\"]",
-      combinator { foo == [2, "baz"] }.analyse 
+    foo = [1, 'bar']
+    result = combinator { foo == [2, 'baz'] }.analyse
+    assert_equal "(foo == [2, \"baz\"]) is false\nfoo is [1, \"bar\"]", result
   end
 
   def test_string_variable
-    foo = "blub"
+    foo = 'blub'
     assert_equal "foo is \"blub\"", combinator { foo }.analyse
   end
 
   def test_array_variable
     foo = [1, 2]
-    assert_equal "foo is [1, 2]", combinator { foo }.analyse
+    assert_equal 'foo is [1, 2]', combinator { foo }.analyse
   end
 
   def test_object_variable
@@ -47,12 +47,11 @@ class AnalyseTest < Test::Unit::TestCase
   end
 
   def test_literal
-    assert_equal "23 is 23", combinator { 23 }.analyse
+    assert_equal '23 is 23', combinator { 23 }.analyse
   end
 
   def test_instance_variable
     @foo = 23
-    assert_equal "@foo is 23", combinator { @foo }.analyse
+    assert_equal '@foo is 23', combinator { @foo }.analyse
   end
 end
-

data/test/assert_test.rb

@@ -7,15 +7,13 @@ class AssertTest < Test::Unit::TestCase
   end
 
   def failing_block_assertion_test message, &block
-    begin
-      assert(&block)
-    rescue Exception => e
-      assert_equal message, e.message
-    end
+    assert(&block)
+  rescue Exception => e
+    assert_equal message, e.message
   end
 
   def test_simple_failing_assert
-    failing_block_assertion_test("false is false.") { false }
+    failing_block_assertion_test('false is false.') { false }
   end
 
   def test_operator_equals_assert
@@ -33,26 +31,21 @@ class AssertTest < Test::Unit::TestCase
   def test_assert_with_custom_message
     foo = false
     begin
-      assert("We want foo") { foo }
+      assert('We want foo') { foo }
     rescue Exception => e
       assert_equal "We want foo.\nfoo is false.", e.message
     end
   end
 
-  def test_original_assert
-    begin
-      assert false
-    rescue Exception => e
-      assert_equal "<false> is not true.", e.message
-    end
+  def test_blockless_assert
+    assert false
+  rescue Exception => e
+    assert_equal '<false> is not true.', e.message
   end
 
-  def test_original_assert_with_custom_message
-    begin
-      assert false, "We want the truth"
-    rescue Exception => e
-      assert_equal "We want the truth.\n<false> is not true.", e.message
-    end
+  def test_blockless_assert_with_custom_message
+    assert false, 'We want the truth'
+  rescue Exception => e
+    assert_equal "We want the truth.\n<false> is not true.", e.message
   end
 end
-

data/test/call_test.rb

@@ -3,7 +3,7 @@ require File.expand_path('test_helper.rb', File.dirname(__FILE__))
 # Test how the combinator calls the passed block.
 class CallTest < Test::Unit::TestCase
   def test_empty_combinator
-    assert_equal nil, combinator { }.call
+    assert_equal nil, combinator {}.call
   end
 
   def test_variable

data/test/display_test.rb

@@ -3,55 +3,55 @@ require File.expand_path('test_helper.rb', File.dirname(__FILE__))
 # Test how the combinator displays the parsed block contents.
 class DisplayTest < Test::Unit::TestCase
   def test_empty_combinator
-    assert_equal "nil", combinator { }.to_s
+    assert_equal 'nil', combinator {}.to_s
   end
 
   def test_literal_number
-    assert_equal "23", combinator { 23 }.to_s
+    assert_equal '23', combinator { 23 }.to_s
   end
 
   def test_literal_string
-    assert_equal "\"aa\"", combinator { "aa" }.to_s
+    assert_equal "\"aa\"", combinator { 'aa' }.to_s
   end
 
   def test_method_calls
-    assert_equal "foo", combinator { foo }.to_s
-    assert_equal "foo.foo", combinator { foo.foo }.to_s
-    assert_equal "foo.foo(1)", combinator { foo.foo 1 }.to_s
-    assert_equal "foo(1)", combinator { foo 1 }.to_s
-    assert_equal "foo(bar)", combinator { foo bar }.to_s
-    assert_equal "foo(1).bar", combinator { foo(1).bar }.to_s
-    assert_equal "foo.foo.foo", combinator { foo.foo.foo }.to_s
-    assert_equal "foo(bar.baz)", combinator { foo bar.baz }.to_s
+    assert_equal 'foo', combinator { foo }.to_s
+    assert_equal 'foo.foo', combinator { foo.foo }.to_s
+    assert_equal 'foo.foo(1)', combinator { foo.foo 1 }.to_s
+    assert_equal 'foo(1)', combinator { foo 1 }.to_s
+    assert_equal 'foo(bar)', combinator { foo bar }.to_s
+    assert_equal 'foo(1).bar', combinator { foo(1).bar }.to_s
+    assert_equal 'foo.foo.foo', combinator { foo.foo.foo }.to_s
+    assert_equal 'foo(bar.baz)', combinator { foo bar.baz }.to_s
   end
 
   def test_operators
-    assert_equal "(foo + 1)", combinator { foo + 1 }.to_s
-    assert_equal "(foo - 1)", combinator { foo - 1 }.to_s
+    assert_equal '(foo + 1)', combinator { foo + 1 }.to_s
+    assert_equal '(foo - 1)', combinator { foo - 1 }.to_s
   end
 
   def test_operator_equals
-    assert_equal "(foo == 1)", combinator { foo == 1 }.to_s
+    assert_equal '(foo == 1)', combinator { foo == 1 }.to_s
   end
 
   def test_array_index
-    assert_equal "foo[1]", combinator { foo[1] }.to_s
+    assert_equal 'foo[1]', combinator { foo[1] }.to_s
   end
 
   def test_to_s_method
-    assert_equal "foo.to_s", combinator { foo.to_s }.to_s
+    assert_equal 'foo.to_s', combinator { foo.to_s }.to_s
   end
 
   def test_operator_unary_minus
-    assert_equal "-foo", combinator { -foo }.to_s
+    assert_equal '-foo', combinator { -foo }.to_s
   end
 
   def test_operator_if_wont_work
-    assert_equal "bar", combinator { foo ? bar : baz }.to_s
+    assert_equal 'bar', combinator { foo ? bar : baz }.to_s
   end
 
   def test_defined_instance_variables
     @foo = 1
-    assert_equal "@foo", combinator { @foo }.to_s
+    assert_equal '@foo', combinator { @foo }.to_s
   end
 end

data/test/test_helper.rb

@@ -2,11 +2,10 @@ require 'test/unit'
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 require 'iba'
 
-class Test::Unit::TestCase 
+class Test::Unit::TestCase
   include Iba::BlockAssertion
 
   def combinator &blk
-    return Iba::Combinator.new(&blk)
+    Iba::Combinator.new(&blk)
   end
-
 end

metadata

@@ -1,89 +1,82 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: iba
-version: !ruby/object:Gem::Version 
-  hash: 27
-  prerelease: false
-  segments: 
-  - 0
-  - 0
-  - 2
-  version: 0.0.2
+version: !ruby/object:Gem::Version
+  version: 0.0.3
 platform: ruby
-authors: 
+authors:
 - Matijs van Zuijlen
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-02-25 00:00:00 +01:00
-default_executable: 
-dependencies: []
-
+date: 2015-05-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
 description: Asserts blocks, prints introspective failure messages.
-email: 
+email:
 - matijs@matijs.net
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.rdoc
 - LICENSE
 - COPYING.LESSER
 - COPYING
-files: 
-- lib/iba.rb
-- test/analyse_test.rb
-- test/test_helper.rb
-- test/call_test.rb
-- test/assert_test.rb
-- test/display_test.rb
-- tasks/test.rake
-- tasks/setup.rb
-- tasks/notes.rake
+files:
+- COPYING
 - COPYING.LESSER
 - LICENSE
 - README.rdoc
 - Rakefile
-- COPYING
-has_rdoc: true
+- lib/iba.rb
+- test/.rubocop.yml
+- test/analyse_test.rb
+- test/assert_test.rb
+- test/call_test.rb
+- test/display_test.rb
+- test/test_helper.rb
 homepage: http://www.github.com/mvz/iba
 licenses: []
-
+metadata: {}
 post_install_message: 
-rdoc_options: 
-- --main
+rdoc_options:
+- "--main"
 - README.rdoc
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 2.4.5
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Introspective Block Assertions
-test_files: 
+test_files:
+- test/.rubocop.yml
 - test/analyse_test.rb
 - test/assert_test.rb
 - test/call_test.rb
 - test/display_test.rb
 - test/test_helper.rb
+has_rdoc: 

data/tasks/notes.rake

@@ -1,122 +0,0 @@
-# The following code is based on Bones 2.5.1
-#
-
-module Bones
-
-# A helper class used to find and display any annotations in a collection of
-# project files.
-#
-class AnnotationExtractor
-
-  class Annotation < Struct.new(:line, :tag, :text)
-    # Returns a string representation of the annotation. If the
-    # <tt>:tag</tt> parameter is given as +true+, then the annotation tag
-    # will be included in the string.
-    #
-    def to_s( opts = {} )
-      s = "[%3d] " % line
-      s << "[#{tag}] " if opts[:tag]
-      s << text
-    end
-  end
-
-  # Enumerate all the annoations for the given _project_ and _tag_. This
-  # will search for all athe annotations and display them on standard
-  # output.
-  #
-  def self.enumerate tag, id = nil, opts = {}
-    extractor = new(tag, id)
-    extractor.display(extractor.find, opts)
-  end
-
-  attr_reader :tag, :id
-
-  # Creates a new annotation extractor configured to use the _project_ open
-  # strcut and to search for the given _tag_ (which can be more than one tag
-  # via a regular expression 'or' operation -- i.e. THIS|THAT|OTHER)
-  #
-  def initialize tag, id
-    @tag = tag
-    @id = @id_rgxp = nil
-
-    unless id.nil? or id.empty?
-      @id = id
-      @id_rgxp = Regexp.new(Regexp.escape(id), Regexp::IGNORECASE)
-    end
-  end
-
-  # Iterate over all the files in the project and extract annotations from
-  # the those files. Returns the results as a hash for display.
-  #
-  def find
-    results = {}
-    rgxp = %r/(#{tag}):?\s*(.*?)(?:\s*(?:-?%>|\*+\/))?$/o
-
-    files = Dir.glob("lib/**/*.rb")
-    files += Dir.glob("test/**/*.rb")
-    files += Dir.glob("bin/*")
-    files.each do |fn|
-      results.update(extract_annotations_from(fn, rgxp))
-    end
-
-    results
-  end
-
-  # Extract any annotations from the given _file_ using the regular
-  # expression _pattern_ provided.
-  #
-  def extract_annotations_from( file, pattern )
-    lineno = 0
-    result = File.readlines(file).inject([]) do |list, line|
-      lineno += 1
-      next list unless m = pattern.match(line)
-      next list << Annotation.new(lineno, m[1], m[2]) unless id
-
-      text = m[2]
-      if text =~ @id_rgxp
-        list << Annotation.new(lineno, m[1], text)
-      end
-      list
-    end
-    result.empty? ? {} : { file => result }
-  end
-
-  # Print the results of the annotation extraction to the screen. If the
-  # <tt>:tags</tt> option is set to +true+, then the annotation tag will be
-  # displayed.
-  #
-  def display( results, opts = {} )
-    results.keys.sort.each do |file|
-      puts "#{file}:"
-      results[file].each do |note|
-        puts "  * #{note.to_s(opts)}"
-      end
-      puts
-    end
-  end
-
-end  # class AnnotationExtractor
-end  # module Bones
-
-note_tags = ["TODO", "FIXME", "OPTIMIZE"]
-
-desc "Enumerate all annotations"
-task :notes do |t|
-  id = if t.application.top_level_tasks.length > 1
-    t.application.top_level_tasks.slice!(1..-1).join(' ')
-  end
-  Bones::AnnotationExtractor.enumerate(
-      note_tags.join('|'), id, :tag => true)
-end
-
-namespace :notes do
-  note_tags.each do |tag|
-    desc "Enumerate all #{tag} annotations"
-    task tag.downcase.to_sym do |t|
-      id = if t.application.top_level_tasks.length > 1
-        t.application.top_level_tasks.slice!(1..-1).join(' ')
-      end
-      Bones::AnnotationExtractor.enumerate(tag, id)
-    end
-  end
-end

data/tasks/setup.rb

@@ -1,6 +0,0 @@
-require 'rake/clean'
-
-# Load the other rake files in the tasks folder
-tasks_dir = File.expand_path(File.dirname(__FILE__))
-rakefiles = Dir.glob(File.join(tasks_dir, '*.rake')).sort
-import(*rakefiles)

data/tasks/test.rake

@@ -1,14 +0,0 @@
-require 'rake/testtask'
-
-namespace :test do
-
-  Rake::TestTask.new(:run) do |t|
-    t.libs = ['lib']
-    t.test_files = FileList['test/**/*_test.rb']
-    t.ruby_opts += ["-w"]
-  end
-
-end
-
-desc 'Alias to test:run'
-task :test => 'test:run'