annotation 0.1.0

data/test/annotation_test.rb

@@ -0,0 +1,199 @@
+# -*- coding: utf-8 -*-
+
+###
+### $Release: 0.1.0 $
+### $Copyright: copyright(c) 2010 kuwata-lab.com all rights reserved $
+### $License: MIT-License $
+###
+
+$: << 'lib'    if File.file?('lib/annotation.rb')
+$: << '../lib' if File.file?('../lib/annotation.rb')
+$: << 'test'   if File.file?('test/annotation_test.rb')
+
+
+require 'oktest'
+require 'annotation'
+
+HAVE_INSTANCE_EXEC = RUBY_VERSION >= '1.8.7' unless defined?(HAVE_INSTANCE_EXEC)
+
+
+module DummyMod1
+  extend Annotation
+  def GET(method_name, path)
+    (@__actions ||= []) << [method_name, :GET, path]
+  end
+  annotation :GET
+  [:POST, :PUT, :DELETE].each do |req_meth|
+    define_method req_meth do |method_name, path|
+      (@__actions ||= []) << [method_name, req_meth, path]
+    end
+  end
+  annotation :POST, :PUT, :DELETE
+end
+
+class Dummy1
+  extend DummyMod1
+
+  GET('/')
+  def index
+    "index() called."
+  end
+  GET('/:id')
+  def show(id)
+    "show(#{id.inspect}) called."
+  end
+  PUT('/:id')
+  def update(id)
+    "update(#{id.inspect}) called."
+  end
+
+end
+
+
+module DummyMod2
+  extend Annotation
+  def login_required(method_name)
+    orig_method = "_orig_#{method_name}"
+    class_eval do
+      alias_method orig_method, method_name
+      eval "def #{method_name}(*args)
+              raise '302 Found' unless @_current_user
+              #{orig_method}(*args)
+            end"
+    end
+  end
+  annotation :login_required
+end
+
+class Dummy2
+  extend DummyMod2
+  login_required
+  def do_update(*args)
+    return "updated: args=#{args.inspect}"
+  end
+end
+
+
+
+class AnnotationTest
+  include Oktest::TestCase
+
+
+  def self.spec_of(target, &block)
+    define_method("test_#{target}", &block) if block
+  end
+
+
+  spec_of "#annotation"
+  def test_annotation
+
+    spec "define annotation method." do
+      ok_(Dummy1.respond_to?(:GET))    == true
+      ok_(Dummy1.respond_to?(:POST))   == true
+      ok_(Dummy1.respond_to?(:PUT))    == true
+      ok_(Dummy1.respond_to?(:DELETE)) == true
+    end
+
+    spec "annotation method should be protected." do
+      msg = "protected method `GET' called for Dummy1:Class"
+      ok_(proc { Dummy1.GET('/') }).raise?(NoMethodError, msg)
+    end
+
+    spec "aliased method should be private." do
+      ok_(Dummy1.methods.grep(/^GET$/).length) == 1
+      ok_(Dummy1.private_methods.grep(/^__anno_GET/).length) == 1
+    end
+
+    spec "callback is called when instance method is defined." do
+      #falldown
+      expected = [ [:index,  :GET, '/'],
+                   [:show,   :GET, '/:id'],
+                   [:update, :PUT, '/:id'],
+                 ]
+      ok_(Dummy1.instance_variable_get('@__actions')) == expected
+    end
+
+    spec "if annotation method is not called then do nothing on method_add." do
+      #falldown
+      Dummy1.instance_variable_get('@__actions').clear
+      Dummy1.class_eval do
+        GET('/new')
+        def new
+          "new() called."
+        end
+        def create
+          "create() called."
+        end
+      end
+      ok_(Dummy1.instance_variable_get('@__actions')) == [ [:new, :GET, '/new'] ]
+    end
+
+    spec "callback is called only when method is defined." do
+      called = false
+      DummyMod1.module_eval do
+        define_method :ann1 do |method_name|
+          called = true
+        end
+        annotation :ann1
+      end
+      ok_(called) == false
+      Dummy1.class_eval do
+        ann1
+        def meth1; end
+      end
+      ok_(called) == true
+    end
+
+    spec "self in annotation callback is class object." do
+      $__self = false
+      DummyMod1.class_eval do
+        def ann2(method_name)
+          $__self = self
+        end
+        annotation :ann2
+      end
+      Dummy1.class_eval do
+        ann2
+        def meth2; end
+      end
+      #ok_(Dummy1.__send__(:class_variable_get, '@@__self__')) == Dummy1
+      ok_($__self) == Dummy1
+    end
+
+  end
+
+
+  spec_of "#method_added"
+  def test_method_added
+
+    spec "if annotation is specified then call callbacks." do
+      annotated = []
+      DummyMod2.module_eval do
+        @@_annotated_ = annotated
+        extend Annotation
+        def anno3(method_name)
+          @@_annotated_ << method_name
+        end
+        annotation :anno3
+      end
+      ok_(annotated) == []
+      Dummy2.class_eval do
+        def foo; end
+        anno3
+        def bar; end
+        anno3
+        def baz; end
+      end
+      ok_(annotated) == [:bar, :baz]
+    end
+
+    spec "it is possible to define new method in annotation callback." do
+      obj = Dummy2.new
+      ok_(obj.respond_to?(:_orig_do_update)) == true
+      ok_(proc { obj.do_update(123) }).raise?(RuntimeError, '302 Found')
+    end
+
+  end
+
+
+end

data/test/examples_test.rb

@@ -0,0 +1,243 @@
+# -*- coding: utf-8 -*-
+
+###
+### $Release: 0.1.0 $
+### $Copyright: copyright(c) 2010 kuwata-lab.com all rights reserved $
+### $License: MIT-License $
+###
+
+$: << 'lib'    if File.file?('lib/annotation.rb')
+$: << '../lib' if File.file?('../lib/annotation.rb')
+$: << 'test'   if File.file?('test/annotation_test.rb')
+
+
+require 'oktest'
+require 'annotation'
+
+
+class ExamplesTest
+  include Oktest::TestCase
+
+
+  if "ex1".to_s
+
+    module ControllerAnnotation
+      extend Annotation
+
+      def GET(imethod, path)
+        (@__routes ||= []) << [path, :GET, imethod]
+      end
+
+      def POST(imethod, path)
+        (@__routes ||= []) << [path, :POST, imethod]
+      end
+
+      def login_required(imethod)
+        alias_method "__orig_#{imethod}", imethod
+        s = "def #{imethod}(*args)
+               raise '302 Found' unless @current_user
+               __orig_#{imethod}(*args)
+             end"
+        self.class_eval s    # not 'eval(s)'
+      end
+
+      annotation :GET, :POST, :login_required         # !!!!!!
+
+    end
+
+
+    class Controller
+      extend ControllerAnnotation
+    end
+
+
+    class MyController < Controller
+
+      GET('/')
+      def index
+        "index() called."
+      end
+
+      GET('/:id')
+      def show(id)
+        "show(#{id}) called."
+      end
+
+      POST('/:id')
+      login_required
+      def update(id)
+        "update(#{id}) called."
+      end
+
+      #p @__routes   #=> [["/", :GET, :index],
+      #              #    ["/:id", :GET, :show],
+      #              #    ["/:id", :POST, :update]]
+    end
+
+
+    #p MyController.new.update(123)   #=> 302 Found (RuntimeError)
+
+
+    def test_FUNC_ex1_class_instance_variable
+      actual = MyController.instance_variable_get('@__routes')
+      expected = [["/", :GET, :index], ["/:id", :GET, :show], ["/:id", :POST, :update]]
+      ok_(actual) == expected
+    end
+
+    def test_FUNC_ex1_method_override
+      ok_(proc { MyController.new.update(123) }).raise?(RuntimeError, '302 Found')
+    end
+
+
+  end
+
+
+  if "ex2".to_s
+
+    module Memoize
+      extend Annotation
+
+      def memoize(func_name)
+        aliased = "_orig_#{func_name}"   # or "_#{func_name}_#{rand().to_s[2..9]}"
+        alias_method aliased, func_name
+        s = "def #{func_name}(*args)
+               @_memos ||= {}
+               hash = (@_memos[:#{func_name}] ||= {})
+               hash[args] = __send__(:#{aliased}, *args) unless hash.key?(args)
+               return hash[args]
+             end"
+        class_eval s
+      end
+      annotation :memoize         # !!!!!!
+
+    end
+
+    class Fib
+      extend Memoize
+
+      def fib1(n)
+        n <= 2 ? 1 : fib1(n-1) + fib1(n-2)
+      end
+
+      memoize                     # !!!!
+      def fib2(n)
+        n <= 2 ? 1 : fib2(n-1) + fib2(n-2)
+      end
+
+    end
+
+    #require 'benchmark'
+    #fib = Fib.new
+    #Benchmark.bm(20) do |x|
+    #  x.report('fib1(30)') { ret = fib.fib1(30) }
+    #  x.report('fib2(30)') { ret = fib.fib2(30) }
+    #end
+
+    ### Result:
+    # $ ruby memoize.rb
+    #                           user     system      total        real
+    # fib1(30)              1.060000   0.000000   1.060000 (  1.063110)
+    # fib2(30)              0.000000   0.000000   0.000000 (  0.000327)
+
+
+    def test_FUNC_ex2_memoized_fib
+      fib = Fib.new
+      ok_(fib.fib1(30)) == 832040
+      ok_(fib.fib2(30)) == 832040
+    end
+
+  end
+
+
+  if "ex3. obsolete.rb".to_s
+
+    module Obsolete
+      extend Annotation
+
+      def obsolete(method)
+        aliased = "_orig_#{method}"  # or "_#{method}_#{rand().to_s[2..9]}"
+        alias_method aliased, method
+        s = "def #{method}(*args)
+               warn %Q`*** warning: #{method} is obsolete.`
+               __send__(:#{aliased}, *args)
+             end"
+        class_eval s
+      end
+      annotation :obsolete          # !!!!!!
+
+    end
+
+    class Hello
+      extend Obsolete
+
+      obsolete                      # !!!!!!
+      def hello(name)
+        puts "Hello #{name}!"
+      end
+
+    end
+
+
+    def test_FUNC_ex3_obsolete_message
+      stdout, stderr = Oktest::Helper::capture_io do
+        Hello.new.hello('World')
+      end
+      ok_(stdout) == "Hello World!\n"
+      ok_(stderr) == "*** warning: hello is obsolete.\n"
+    end
+
+  end
+
+
+  if "ex4. my_test.rb".to_s
+
+    module DummyFiles
+      extend Annotation
+
+      def dummy_files(method_name, files={})
+        aliased = "__#{method_name}_#{rand().to_s[2..10]}"
+        alias_method aliased, method_name
+        method_undefined method_name
+        define_method method_name do
+          begin
+            files.each do |filename, content|
+              next unless content
+              File.open(filename, 'w') {|f| f.write(content) }
+            end
+            __send__(aliased)
+          ensure
+            files.each do |filename, _|
+              File.unlink(filename) if File.exist?(filename)
+            end
+          end
+        end
+      end
+      annotation :dummy_files         # !!!!!!
+
+    end
+
+
+    #class MyTestCase < Test::Unit::TestCase
+    #  extend DummyFiles
+    #
+    #  dummy_files 'A.txt'=>'AAA', 'B.txt'=>'BBB'   # !!!!!!
+    #  def test_something
+    #    assert_equal 'AAA', File.read('A.txt')
+    #    assert_equal 'BBB', File.read('B.txt')
+    #  end
+    #
+    #end
+
+    extend DummyFiles
+    dummy_files 'A.txt'=>'AAA', 'B.txt'=>'BBB'
+    def test_FUNC_ex4_dummy_files
+      ok_(File.read('A.txt')) == 'AAA'
+      ok_(File.read('B.txt')) == 'BBB'
+    end
+
+
+  end
+
+
+
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: annotation
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- makoto kuwata
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-10-10 00:00:00 +09:00
+default_executable: 
+dependencies: []
+
+description: "  Annotation.rb is a very small but pretty good library which introduces\n  Java's annotation or Python's functhon decorator into Ruby.\n"
+email: kwa(at)kuwata-lab.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/annotation.rb
+- test/annotation_test.rb
+- test/examples_test.rb
+- README.txt
+- CHANGES.txt
+- MIT-LICENSE
+- setup.rb
+- annotation.gemspec
+has_rdoc: true
+homepage: http://www.kuwata-lab.com/annotation/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  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 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: annotation
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: annotation library similar to Java or Python
+test_files: 
+- test/annotation_test.rb