iba 0.0.2 → 0.0.6

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'

data/test/analyse_test.rb

@@ -1,58 +0,0 @@
-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
-  end
-
-  def test_variable
-    foo = 23
-    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 
-  end
-
-  def test_operator_equals_literal
-    foo = 42
-    assert_equal "(foo == 23) is false\nfoo is 42",
-      combinator { foo == 23 }.analyse 
-  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 
-  end
-
-  def test_string_variable
-    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
-  end
-
-  def test_object_variable
-    foo = Object.new
-    insp = foo.inspect
-    assert_equal "foo is #{insp}", combinator { foo }.analyse
-  end
-
-  def test_literal
-    assert_equal "23 is 23", combinator { 23 }.analyse
-  end
-
-  def test_instance_variable
-    @foo = 23
-    assert_equal "@foo is 23", combinator { @foo }.analyse
-  end
-end
-

data/test/assert_test.rb

@@ -1,58 +0,0 @@
-require File.expand_path('test_helper.rb', File.dirname(__FILE__))
-
-# Test behavior of overridden assert method.
-class AssertTest < Test::Unit::TestCase
-  def test_simple_assert
-    assert { true }
-  end
-
-  def failing_block_assertion_test message, &block
-    begin
-      assert(&block)
-    rescue Exception => e
-      assert_equal message, e.message
-    end
-  end
-
-  def test_simple_failing_assert
-    failing_block_assertion_test("false is false.") { false }
-  end
-
-  def test_operator_equals_assert
-    foo = 24
-    failing_block_assertion_test("(foo == 23) is false\nfoo is 24.") { foo == 23  }
-  end
-
-  def test_instance_variable_assert
-    @foo = 24
-    failing_block_assertion_test("(@foo == 23) is false\n@foo is 24.") { @foo == 23  }
-  end
-
-  # Special cases
-
-  def test_assert_with_custom_message
-    foo = false
-    begin
-      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
-  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
-  end
-end
-

data/test/call_test.rb

@@ -1,18 +0,0 @@
-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
-  end
-
-  def test_variable
-    foo = 23
-    assert_equal 23, combinator { foo }.call
-  end
-
-  def test_operator_call
-    foo = 23
-    assert_equal true, combinator { foo == 23 }.call
-  end
-end

data/test/display_test.rb

@@ -1,57 +0,0 @@
-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
-  end
-
-  def test_literal_number
-    assert_equal "23", combinator { 23 }.to_s
-  end
-
-  def test_literal_string
-    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
-  end
-
-  def test_operators
-    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
-  end
-
-  def test_array_index
-    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
-  end
-
-  def test_operator_unary_minus
-    assert_equal "-foo", combinator { -foo }.to_s
-  end
-
-  def test_operator_if_wont_work
-    assert_equal "bar", combinator { foo ? bar : baz }.to_s
-  end
-
-  def test_defined_instance_variables
-    @foo = 1
-    assert_equal "@foo", combinator { @foo }.to_s
-  end
-end

data/test/test_helper.rb

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