innate 2009.04.12 → 2009.05

data/tasks/ycov.rake

@@ -0,0 +1,84 @@
+begin
+  require 'yard'
+
+  task 'Show Documentation coverage'
+  task :ycov => ['.yardoc'] do
+    YARD::Registry.load_yardoc
+    code_objects = YARD::Registry.paths.map{|path| YARD::Registry.at(path) }
+    code_objects.delete_if{|obj| obj.type == :root }
+    without_doc, with_doc = code_objects.partition{|obj| obj.docstring.empty? }
+
+    documented = with_doc.size
+    undocumented = without_doc.size
+    total = documented + undocumented
+    percentage = (documented / 0.01) / total
+
+    puts "Documentation coverage is %d/%d (%3.1f%%)" % [documented, total, percentage]
+  end
+
+  task 'ycov-full' => ['.yardoc'] do
+    require 'builder'
+
+    YARD::Registry.load_yardoc
+    code_objects = YARD::Registry.paths.map{|path| YARD::Registry.at(path) }
+    code_objects.delete_if{|obj| obj.type == :root }
+    without_doc, with_doc = code_objects.partition{|obj| obj.docstring.empty? }
+
+    list_objects = lambda{|body, list|
+      body.table(:width => '100%') do |table|
+        list.group_by{|obj| obj.type }.
+          sort_by{|k,v| k.to_s }.each do |type, objects|
+
+          table.tr do |tr|
+            tr.th(type.to_s, :colspan => 2)
+          end
+
+          objects.sort_by{|obj| obj.path }.each do |obj|
+            table.tr do |tr|
+              tr.td obj.path
+              tr.td "#{obj.file} +#{obj.line}"
+            end
+          end
+        end
+      end
+    }
+
+    File.open('ycov.html', 'w+') do |ycov|
+      builder = Builder::XmlMarkup.new(:target => ycov, :indent=>2)
+      builder.html do |html|
+        html.head do |head|
+          head.title 'YARD Coverage report'
+        end
+
+        html.body do |body|
+          body.h1 'YARD Coverage report'
+
+          body.h2 "#{without_doc.size} Undocumented objects"
+          list_objects[body, without_doc]
+
+          body.h2 "#{with_doc.size} Documented objects"
+          list_objects[body, with_doc]
+        end
+      end
+    end
+  end
+
+  file '.yardoc' => FileList['lib/**/*.rb'] do
+    files = ['lib/**/*.rb']
+    options = ['--no-output', '--private']
+    YARD::CLI::Yardoc.run(*(options + files))
+  end
+
+  desc 'Generate YARD documentation'
+  task :yardoc => ['.yardoc'] do
+    files = ['lib/**/*.rb']
+    options = [
+      '--output-dir', 'ydoc',
+      '--readme', PROJECT_README,
+      '--db', '.yardoc',
+      '--private']
+    YARD::CLI::Yardoc.run(*(options + files))
+  end
+rescue LoadError
+  # you'll survive
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: innate
 version: !ruby/object:Gem::Version 
-  version: 2009.04.12
+  version: "2009.05"
 platform: ruby
 authors: 
 - Michael 'manveru' Fellinger
@@ -9,10 +9,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-12 00:00:00 +09:00
+date: 2009-05-07 00:00:00 +09:00
 default_executable: 
-dependencies: []
-
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+    version: 
 description: Simple, straight-forward base for web-frameworks.
 email: m.fellinger@gmail.com
 executables: []
@@ -22,6 +31,7 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- AUTHORS
 - CHANGELOG
 - COPYING
 - MANIFEST
@@ -54,8 +64,6 @@ files:
 - lib/innate/cache/marshal.rb
 - lib/innate/cache/memory.rb
 - lib/innate/cache/yaml.rb
-- lib/innate/core_compatibility/basic_object.rb
-- lib/innate/core_compatibility/string.rb
 - lib/innate/current.rb
 - lib/innate/dynamap.rb
 - lib/innate/helper.rb
@@ -83,8 +91,6 @@ files:
 - lib/innate/spec.rb
 - lib/innate/state.rb
 - lib/innate/state/accessor.rb
-- lib/innate/state/fiber.rb
-- lib/innate/state/thread.rb
 - lib/innate/traited.rb
 - lib/innate/trinity.rb
 - lib/innate/version.rb
@@ -137,9 +143,8 @@ files:
 - spec/innate/request.rb
 - spec/innate/route.rb
 - spec/innate/session.rb
-- spec/innate/state/fiber.rb
-- spec/innate/state/thread.rb
 - spec/innate/traited.rb
+- tasks/authors.rake
 - tasks/bacon.rake
 - tasks/changelog.rake
 - tasks/gem.rake
@@ -151,8 +156,11 @@ files:
 - tasks/release.rake
 - tasks/reversion.rake
 - tasks/setup.rake
+- tasks/ycov.rake
 has_rdoc: true
 homepage: http://github.com/manveru/innate
+licenses: []
+
 post_install_message: 
 rdoc_options: []
 
@@ -172,10 +180,10 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: 
-rubygems_version: 1.3.1
+rubyforge_project: innate
+rubygems_version: 1.3.2
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: Powerful web-framework wrapper for Rack.
 test_files: []
 

data/lib/innate/core_compatibility/basic_object.rb

@@ -1,10 +0,0 @@
-# We define BasicObject for compatibility with 1.9 if it isn't there yet.
-class BasicObject
-  # Remove all but these methods
-  # NOTE: __id__ is not there in 1.9, but would give a warning in 1.8
-  KEEP = %w[== equal? ! != instance_eval instance_exec __send__ __id__]
-
-  (instance_methods - KEEP).each do |im|
-    undef_method(im)
-  end
-end unless defined?(BasicObject)

data/lib/innate/core_compatibility/string.rb

@@ -1,3 +0,0 @@
-class String # Dirty hack, but Rack needs it?
-  alias each each_line unless 'String'.respond_to?(:each)
-end

data/lib/innate/state/fiber.rb

@@ -1,74 +0,0 @@
-require 'fiber'
-
-module Innate
-  # Innate subclasses Fiber to enable lightweight request/respose-cycle local
-  # variables.
-  #
-  # We do that by adding a state Hash to the Fiber instance on initalization
-  # which can be accessed by #[], #[]= and #key?. Other Hash methods are not
-  # necessary right now but may be added.
-  #
-  # We subclass to keep your Ruby clean and polished.
-  class Fiber < ::Fiber
-    attr_accessor :state
-
-    def initialize(*args)
-      super
-      @state = {}
-    end
-
-    def [](key)
-      state[key]
-    end
-
-    def []=(key, value)
-      state[key] = value
-    end
-
-    def key?(key)
-      state.key?(key)
-    end
-
-    def keys
-      state.keys
-    end
-  end
-
-  module State
-    # Our accessor to the currently active Fiber, an instance of
-    # Innate::State::Fiber will be assigned to Innate::STATE if fibers are
-    # available.
-    class Fiber
-      def [](key)
-        ::Fiber.current[key]
-      end
-
-      def []=(key, value)
-        ::Fiber.current[key] = value
-      end
-
-      # We don't use Fiber in a concurrent manner and they don't run
-      # concurrently by themselves, so we directly #resume the Fiber to get the
-      # return value of +block+.
-
-      def wrap(&block)
-        Innate::Fiber.new(&block).resume
-      end
-
-      # In an environment where only Fiber is used there is no concurrency, so
-      # we don't have to lock with a Mutex.
-
-      def sync
-        yield
-      end
-
-      def defer
-        a = Innate::Fiber.current
-        ::Thread.new do
-          b = Innate::Fiber.new{ a.keys.each{|k| b[k] = a[k] }; yield }
-          b.resume
-        end
-      end
-    end
-  end
-end

data/lib/innate/state/thread.rb

@@ -1,47 +0,0 @@
-require 'thread'
-
-module Innate
-  module State
-    # In case fibers are not available we fall back to this wrapper.
-    #
-    # It will raise errors happening inside the wrapping Thread even if
-    # Thread::abort_on_exception is false.
-    #
-    # For things that require a mutex in a threaded environment, use
-    # STATE#sync, if Fiber is available no mutex will be used.
-
-    class Thread
-      SEMAPHORE = Mutex.new
-
-      def [](key)
-        ::Thread.current[key]
-      end
-
-      def []=(key, value)
-        ::Thread.current[key] = value
-      end
-
-      # Execute given block in a new Thread and rescue any exceptions before
-      # they reach Thread::new, so in case Thread::raise_on_exception is false
-      # we can still reraise the error outside of the Thread.
-      #
-      # This is not meant to be concurrent, we only use Thread as a wrapping
-      # context so we can store objects in Thread::current and access them from
-      # anywhere within this thread.
-      def wrap
-        value = ::Thread.new{ begin; yield; rescue Exception => ex; ex; end }.value
-        raise(value) if Exception === value
-        return value
-      end
-
-      def sync(&block)
-        SEMAPHORE.synchronize(&block)
-      end
-
-      def defer
-        a = ::Thread.current
-        ::Thread.new{ b = ::Thread.current; a.keys.each{|k| b[k] = a[k] }; yield }
-      end
-    end
-  end
-end

data/spec/innate/state/fiber.rb

@@ -1,58 +0,0 @@
-require 'spec/helper'
-
-describe 'Innate::State::Fiber' do
-  begin
-    require 'fiber'
-  rescue LoadError
-    it('needs fiber'){ should.flunk('needed fiber') }
-    exit
-  end
-
-  F = Innate::State::Fiber
-
-  it 'sets value in current thread with #[]=' do
-    Innate::Fiber.new{
-      t = F.new
-      t[:a] = :b
-      Fiber.current[:a].should == :b
-    }.resume
-  end
-
-  it 'gets value in current thread with #[]' do
-    Innate::Fiber.new{
-      t = F.new
-      Fiber.current[:b] = :c
-      t[:b].should == :c
-    }.resume
-  end
-
-  it 'executes block in #wrap' do
-    Innate::Fiber.new{
-      t = F.new
-      t.wrap{ :foo }.should == :foo
-    }.resume
-  end
-
-  it 'reraises exceptions occured in #wrap thread' do
-    Innate::Fiber.new{
-      t = F.new
-      Thread.abort_on_exception = false
-      lambda{ t.wrap{ raise 'foo' } }.should.raise
-    }.resume
-  end
-
-  it 'defers execution of passed block in #defer' do
-    Innate::Fiber.new{
-      t = F.new
-      t.defer{ :foo }.value.should == :foo
-    }.resume
-  end
-
-  it 'copies thread variables to thread spawned in #defer' do
-    Innate::Fiber.new{
-      t = F.new
-      t[:a] = :b
-      t.defer{ Fiber.current[:a] }.value.should == :b
-    }.resume
-  end
-end

data/spec/innate/state/thread.rb

@@ -1,40 +0,0 @@
-require 'spec/helper'
-require 'innate/state/thread'
-
-describe Innate::State::Thread do
-  T = Innate::State::Thread
-
-  it 'sets value in current thread with #[]=' do
-    t = T.new
-    t[:a] = :b
-    Thread.current[:a].should == :b
-  end
-
-  it 'gets value in current thread with #[]' do
-    t = T.new
-    Thread.current[:b] = :c
-    t[:b].should == :c
-  end
-
-  it 'executes block in #wrap' do
-    t = T.new
-    t.wrap{ :foo }.should == :foo
-  end
-
-  it 'reraises exceptions occured in #wrap thread' do
-    t = T.new
-    Thread.abort_on_exception = false
-    lambda{ t.wrap{ raise 'foo' } }.should.raise
-  end
-
-  it 'defers execution of passed block in #defer' do
-    t = T.new
-    t.defer{ :foo }.value.should == :foo
-  end
-
-  it 'copies thread variables to thread spawned in #defer' do
-    t = T.new
-    t[:a] = :b
-    t.defer{ Thread.current[:a] }.value.should == :b
-  end
-end