manveru-innate 2009.04.18 → 2009.05

data/spec/innate/node/node.rb

@@ -49,6 +49,7 @@ class SpecNodeWithLayoutView < SpecNodeProvide
   layout 'another_layout'
 
   map_views 'node/another_layout'
+  map_layouts 'another_layout'
 end
 
 class SpecNodeWithLayoutMethod < SpecNodeProvide

data/spec/innate/options.rb

@@ -46,7 +46,7 @@ describe Options do
 
   should 'get sub-sub option' do
     @options.get(:deep, :down, :me).
-      should == {:value => :too, :doc => 'deep down', :trigger=> nil}
+      should == {:value => :too, :doc => 'deep down'}
   end
 
   should 'respond with nil on getting missing option' do
@@ -98,6 +98,10 @@ describe Options do
     lambda{ @options[:foo] = :bar }.should.raise(ArgumentError)
   end
 
+  should "raise when trying to assign to an option that doesn't exist" do
+    lambda{ @options.merge!(:foo => :bar) }.should.raise(IndexError)
+  end
+
   should 'pretty_print' do
     require 'pp'
     p = PP.new

data/tasks/authors.rake

@@ -0,0 +1,30 @@
+# Once git has a fix for the glibc in handling .mailmap and another fix for
+# allowing empty mail address to be mapped in .mailmap we won't have to handle
+# them manually.
+
+desc 'Update AUTHORS'
+task :authors do
+  authors = Hash.new(0)
+
+  `git shortlog -nse`.scan(/(\d+)\s(.+)\s<(.*)>$/) do |count, name, email|
+    case name
+    when "ahoward"
+      name, email = "Ara T. Howard", "ara.t.howard@gmail.com"
+    when "Martin Hilbig blueonyx@dev-area.net"
+      name, email = "Martin Hilbig", "blueonyx@dev-area.net"
+    when "Michael Fellinger m.fellinger@gmail.com"
+      name, email = "Michael Fellinger", "m.fellinger@gmail.com"
+    end
+
+    authors[[name, email]] += count.to_i
+  end
+
+  File.open('AUTHORS', 'w+') do |io|
+    io.puts "Following persons have contributed to #{GEMSPEC.name}."
+    io.puts '(Sorted by number of submitted patches, then alphabetically)'
+    io.puts ''
+    authors.sort_by{|(n,e),c| [-c, n.downcase] }.each do |(name, email), count|
+      io.puts("%6d %s <%s>" % [count, name, email])
+    end
+  end
+end

data/tasks/release.rake

@@ -2,13 +2,13 @@ namespace :release do
   task :all => [:release_github, :release_rubyforge]
 
   desc 'Display instructions to release on github'
-  task :github => [:reversion, :gemspec] do
+  task :github => [:reversion, :authors, :gemspec] do
     name, version = GEMSPEC.name, GEMSPEC.version
 
     puts <<INSTRUCTIONS
 First add the relevant files:
 
-git add MANIFEST CHANGELOG #{name}.gemspec lib/#{name}/version.rb
+git add AUTHORS MANIFEST CHANGELOG #{name}.gemspec lib/#{name}/version.rb
 
 Then commit them, tag the commit, and push:
 
@@ -22,7 +22,7 @@ INSTRUCTIONS
 
   # TODO: Not tested
   desc 'Display instructions to release on rubyforge'
-  task :rubyforge => [:reversion, :gemspec, :package] do
+  task :rubyforge => [:reversion, :authors, :gemspec, :package] do
     name, version = GEMSPEC.name, GEMSPEC.version
 
     puts <<INSTRUCTIONS

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: manveru-innate
 version: !ruby/object:Gem::Version 
-  version: 2009.04.18
+  version: "2009.05"
 platform: ruby
 authors: 
 - Michael 'manveru' Fellinger
@@ -9,10 +9,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-18 00:00:00 -07:00
+date: 2009-05-07 00:00:00 -07: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: []
@@ -81,8 +90,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
@@ -135,9 +142,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
@@ -149,6 +155,7 @@ files:
 - tasks/release.rake
 - tasks/reversion.rake
 - tasks/setup.rake
+- tasks/ycov.rake
 has_rdoc: true
 homepage: http://github.com/manveru/innate
 post_install_message: 
@@ -170,7 +177,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: 
+rubyforge_project: innate
 rubygems_version: 1.2.0
 signing_key: 
 specification_version: 3

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