burke 0.2.2 → 0.3.5

data/README.rdoc

@@ -25,26 +25,27 @@ Here is a sample Rakefile using Burke.
   Burke.enable_all
   
   # Give Burke some data about the project
-  Burke.setup do |s|
-    s.name = 'foo'
-    s.version = '1.2.3'
-    s.summary = 'an example Ruby library with extra foo'
+  Burke.setup do
+    name        'foo'
+    version     '1.2.3'
+    summary     'An example Ruby library with extra foo'
     
-    s.docs do |d|
-      d.markup = 'rdoc'
-    end
+    docs.markup 'rdoc'
+    
+    clean       %w[.yardoc]
+    clobber     %w[pkg doc html coverage]
     
-    s.gems do |g|
-      g.platform 'ruby'
+    gems do
+      add_platform  'ruby'
       
-      g.platform 'x86-linux' do |p|
-        p.before do |s|
+      add_platform  'x86-linux' do
+        before_build do |spec|
           cp 'native/libfoo-x86-linux.so', 'lib/libfoo.so'
-          s.add_dependency 'ffi'
-          s.files += ['lib/libfoo.so']
+          spec.add_dependency 'ffi'
+          spec.files += ['lib/libfoo.so']
         end
         
-        p.after do
+        after_build do
           rm 'lib/libfoo.so'
         end
       end

data/Rakefile

@@ -1,18 +1,16 @@
 $LOAD_PATH << File.join(File.dirname(File.expand_path(__FILE__)), 'lib')
 require 'burke'
 
-Burke.enable_all
-
-Burke.setup do |s|
-  s.name = 'burke'
-  s.summary = 'Helper for creating nice and clean Rake files'
-  s.author = 'Aiden Nibali'
-  s.email = 'dismal.denizen@gmail.com'
-  s.homepage = "http://github.com/dismaldenizen/burke"
+Burke.setup do
+  name      'burke'
+  summary   'Helper for creating nice, clean Rake files'
+  author    'Aiden Nibali'
+  email     'dismal.denizen@gmail.com'
+  homepage  'http://github.com/dismaldenizen/burke'
   
-  s.has_rdoc = true
+  clean     %w[.yardoc]
+  clobber   %w[pkg doc html coverage]
   
-  s.clean = %w[.yardoc]
-  s.clobber = %w[pkg doc html]
+  rspec.rcov.failure_threshold = 70
 end
 

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.3.5

data/lib/burke/holder.rb

@@ -0,0 +1,188 @@
+require 'thread'
+
+class Proc
+  def bind(object)
+    block, time = self, Time.now
+    (class << object; self end).class_eval do
+      method_name = "__bind_#{time.to_i}_#{time.usec}"
+      define_method(method_name, &block)
+      method = instance_method(method_name)
+      remove_method(method_name)
+      method
+    end.bind(object)
+  end
+end
+
+class Object
+  unless defined? instance_exec # 1.9
+    def instance_exec(*arguments, &block)
+      block.bind(self)[*arguments]
+    end
+  end
+end
+
+module Burke
+  class Holder < Hash
+    class CircularReadError < RuntimeError ; end
+    
+    def holder_instance_exec? ; true ; end
+    
+    class << self
+      attr_accessor :defaults
+      
+      def inherited clazz
+        clazz.instance_eval do
+          @fields = []
+          @defaults = {}
+        end
+      end
+      
+      def field name, &block
+        name = String(name)
+        @fields << name
+        @fields.uniq!
+        @defaults[name] = block if block_given?
+      end
+      
+      def fields *names
+        names.each { |name| field name }
+      end
+      
+      def field_exists? name
+        @fields.include? name
+      end
+      
+      def [](hash)
+        new.merge hash
+      end
+    end
+    
+    def initialize *args, &block
+      if block_given?
+        self.instance_exec self, &block
+      else
+        super
+      end
+      
+      @currently_getting = []
+      @currently_getting_mutex = Mutex.new
+    end
+    
+    def to_hash
+      out = {}
+      keys.concat(self.class.defaults.keys).uniq.each do |k|
+        out[k] = Holder === self[k] ? self[k].to_hash : self[k]
+      end
+      out
+    end
+    
+    def [](key)
+      key = normalize_key key
+      assert_field_exists! key
+      id = "#{key}-#{Thread.current.object_id}"
+      @currently_getting_mutex.synchronize do
+        if @currently_getting.include? id
+          raise CircularReadError.new "circular read for field '#{key}'" 
+        end
+        @currently_getting << id
+      end
+      val = if key? key
+        super
+      elsif self.class.defaults.key? key
+        self.instance_eval(&self.class.defaults[key])
+      else
+        nil
+      end
+      @currently_getting_mutex.synchronize do
+        @currently_getting.delete id
+      end
+      val
+    end
+    
+    def []=(key, value)
+      key = normalize_key key
+      assert_field_exists! key
+      super
+    end
+    
+    def merge! other
+      other.each do |k, v|
+        self[k] ||= v
+      end
+      
+      nil
+    end
+    
+    def merge other
+      holder = self.class.new
+      
+      self.each do |k, v|
+        holder[k] = v
+      end
+      
+      other.each do |k, v|
+        holder[k] ||= v
+      end
+      
+      holder
+    end
+    
+    def delete key
+      super normalize_key(key)
+    end
+    
+    def method_missing name, *args, &block
+      base, ending = *String(name).match(/(\w*)([!?=]?)/).to_a[1..-1]
+      key = normalize_key(base)
+      case ending
+      when '?'
+        if field_exists? key
+          !!self[key]
+        else
+          super
+        end
+      when '='
+        if field_exists? key
+          self[key] = *args
+        else
+          super
+        end
+      when ''
+        if field_exists? key
+          if args.empty?
+            v = self[key]
+            if block_given?
+              if v.respond_to? 'holder_instance_exec?' and v.holder_instance_exec?
+                v.instance_exec v, &block
+              else
+                yield v
+              end
+            end
+            v
+          else
+            self[key] = *args
+          end
+        else
+          super
+        end
+      else
+        super
+      end
+    end
+    
+    def normalize_key key
+      String(key)
+    end
+    
+    def field_exists? name
+      self.class.field_exists? name
+    end
+    
+    def assert_field_exists! name
+      unless field_exists? name
+        raise NoMethodError, "field '#{name}' is not defined for this Holder."
+      end
+    end
+  end
+end
+

data/lib/burke/tasks/clean.rb

@@ -0,0 +1,15 @@
+module Burke
+  Settings.field(:clean) { self.clean = [] }
+  Settings.field(:clobber) { self.clobber = [] }
+  
+  define_task 'clean' do |s|
+    require 'rake/clean'
+    CLEAN.include(*s.clean) if s.clean
+  end
+  
+  define_task 'clobber' do |s|
+    require 'rake/clean'
+    CLOBBER.include(*s.clobber) if s.clobber
+  end
+end
+

data/lib/burke/tasks/docs.rb

@@ -0,0 +1,46 @@
+module Burke
+  Settings.field(:docs) { self.docs = DocSettings.new }
+  
+  class DocSettings < Holder
+    field 'title' do
+      "#{Burke.settings.name} #{Burke.settings.version}"
+    end
+    
+    field 'files' do
+      fl = FileList.new
+      fl.include "lib/**/*.rb"
+      fl.include(([readme_file] + extra_files).compact)
+      fl.to_a.freeze
+    end
+    
+    field 'extra_files' do
+      [license_file].compact.freeze
+    end
+    
+    field 'readme_file' do
+      find_file('readme{.*,}').freeze
+    end
+    
+    field 'license_file' do
+      find_file('{licen{c,s}e,copying}{.*,}').freeze
+    end
+    
+    field 'markup' do
+      case File.extname(readme_file).downcase
+      when '.rdoc'
+        'rdoc'
+      when '.md', '.markdown'
+        'markdown'
+      when '.textile'
+        'textile'
+      end.freeze
+    end
+    
+    private
+    def find_file pattern
+      files = Dir.glob(pattern, File::FNM_CASEFOLD)
+      files.find { |f| File.readable? f and File.file? f }
+    end
+  end
+end
+

data/lib/burke/tasks/gems.rb

@@ -0,0 +1,117 @@
+module Burke
+  Settings.field(:gems) { self.gems = GlobalGemSettings.new }
+  
+  define_task 'gems' do |s|
+    s.gems.individuals.each do |conf|
+      GemTaskManager.add_task conf
+    end
+    
+    t = GemTaskManager.task_for_this_platform
+    unless t.nil?
+      desc "Build gem for this platform"
+      task(:gem => t.task_name)
+    end
+  end
+  
+  define_task 'install' => 'gems' do |s|
+    require 'rubygems/installer'
+    
+    t = GemTaskManager.task_for_this_platform
+    raise "no gem task for this platform" if t.nil?
+      
+    desc "Install gem for this platform"
+    task 'install' => [t.task_name] do
+      Gem::Installer.new(File.join(t.package_dir, t.gem_file)).install
+    end
+  end
+  
+  class GlobalGemSettings < Holder
+    field(:package_dir) { 'pkg' }
+    
+    attr_reader :individuals
+    
+    def add_platform plaf, &block
+      conf = IndividualGemSettings.new plaf
+      @individuals ||= []
+      @individuals << conf
+      conf.instance_exec conf, &block if block_given?
+      conf
+    end
+  end
+  
+  class IndividualGemSettings < Holder
+    attr_reader :platform
+    
+    field(:gemspec) do
+      spec = Burke.base_gemspec.dup
+      spec.platform = @platform
+      spec
+    end
+    field(:gem_file) { "#{gemspec.full_name}.gem" }
+    field(:package_dir) { Burke.settings.gems.package_dir }
+    
+    def initialize plaf
+      super
+      @platform = Gem::Platform.new plaf
+    end
+    
+    def task_name
+      "gem:#{platform}"
+    end
+    
+    def before_build &block
+      @before = block if block_given?
+      @before
+    end
+    
+    def after_build &block
+      @after = block if block_given?
+      @after
+    end
+  end
+  
+  class GemTaskManager
+    TASKS = {}
+    
+    def self.add_task conf
+      gemspec = conf.gemspec
+      name = conf.task_name
+      pkg_dir = conf.package_dir
+      
+      unless Rake::Task.tasks.find {|t| t.name == 'gems'}
+        desc "Build gems for all targets"
+      end
+      task(:gems => name)
+      
+      unless Rake::Task.tasks.find {|t| t.name == name}
+        desc "Build gem for target '#{gemspec.platform}'"
+      end
+      task(name) do |t|
+        conf.before_build.call gemspec unless conf.before_build.nil?
+        builder = Gem::Builder.new(gemspec)
+        builder.build
+        verbose true do
+          mkdir pkg_dir unless File.exists? pkg_dir
+          mv conf.gem_file, File.join(pkg_dir, conf.gem_file)
+        end
+        conf.after_build.call gemspec unless conf.after_build.nil?
+      end
+      
+      TASKS[gemspec.platform.to_s] = conf
+    end
+    
+    def self.task_for_this_platform
+      platform = Gem::Platform.new(RUBY_PLATFORM).to_s
+      name = nil
+      
+      if TASKS.key? platform
+        name = platform
+      elsif TASKS.key? 'ruby'
+        name = "ruby"
+      end
+      
+      TASKS[name]
+    end
+  end
+end
+

data/lib/burke/tasks/rdoc.rb

@@ -0,0 +1,12 @@
+module Burke
+  define_task 'rdoc' do |s|
+    require 'rake/rdoctask'
+    d = s.docs
+    Rake::RDocTask.new 'rdoc' do |r|
+      r.rdoc_files.include d.files
+      r.title = d.title
+      r.main = d.readme_file if d.readme_file
+    end
+  end
+end
+

data/lib/burke/tasks/release.rb

@@ -0,0 +1,81 @@
+module Burke
+  define_task 'release' do |s|
+    begin
+      require 'git'
+    rescue LoadError
+      raise "'git' gem is not available"
+    end
+    if s.key? 'version'
+      raise "version is managed in an unknown way"
+    end
+    desc 'Release a new version of this project'
+    task 'release' do |t|
+      g = Git.open '.'
+      st = g.status
+      unless st.added.empty? and st.changed.empty? and st.deleted.empty?
+        puts "Please commit changes with Git before releasing."
+      else
+        release_type = 0
+        until (1..4).include? release_type
+          puts "Please select type of release:"
+          puts "1. Major"
+          puts "2. Minor"
+          puts "3. Patch"
+          puts "4. Enter version manually"
+          print "> "
+          release_type = $stdin.gets.to_i
+          puts
+        end
+        
+        old_version = Gem::Version.new(s.version)
+        new_version = nil
+        
+        if release_type == 4
+          until new_version
+            print "Current version is #{old_version}. "
+            puts "Please enter a new version number:"
+            print "> "
+            new_version = $stdin.gets
+            if new_version.strip.empty?
+              new_version = nil
+            else
+              new_version = Gem::Version.new(new_version)
+            end
+            puts
+          end
+        else
+          segments = old_version.segments
+          segments[release_type - 1] += 1
+          new_version = Gem::Version.new(segments.join('.'))
+        end
+        
+        print "The VERSION file will be changed from containing '#{old_version}' "
+        print "to '#{new_version}'. The changes will be commited to the Git "
+        print "repository and tagged with 'v#{new_version}'."
+        puts
+        
+        continue = nil
+        until ['y', 'n', 'yes', 'no'].include? continue
+          puts "Continue? [Y]es, [N]o"
+          print "> "
+          continue = $stdin.gets.strip.downcase
+          puts
+        end
+        
+        if %w[yes y].include? continue
+          open 'VERSION', 'w' do |f|
+            f.puts new_version.to_s
+          end
+          
+          g.commit_all "version bumped to #{new_version}"
+          g.lib.send(:command, 'tag', ['-a', "v#{new_version}", '-m', "version #{new_version}"])
+          
+          puts "Version updated."
+        else
+          puts "Version not updated."
+        end
+      end
+    end
+  end
+end
+

data/lib/burke/tasks/rspec.rb

@@ -0,0 +1,76 @@
+module Burke
+  Settings.field(:rspec) { self.rspec = RSpecSettings.new }
+  
+  define_task 'spec' do |s|
+    begin
+      require 'rspec/core/rake_task'
+    rescue LoadError
+      raise "'rspec' gem is not available"
+    end
+    
+    RSpec::Core::RakeTask.new 'spec' do |t|
+      build_spec_task t, s.rspec
+    end
+  end
+  
+  define_task 'spec:rcov' do |s|
+    begin
+      require 'rspec/core/rake_task'
+    rescue LoadError
+      raise "'rspec' gem is not available"
+    end
+    
+    desc "Run RSpec code examples and generate full RCov report"
+    RSpec::Core::RakeTask.new('spec:rcov') do |t|
+      t.rcov = true
+      t.rcov_opts = [
+        '-Ilib',
+        '--exclude', "'spec/,#{s.rakefile_file}'",
+      ]
+    end
+  end
+  
+  define_task 'spec:rcov:verify' do |s|
+    begin
+      require 'rspec/core/rake_task'
+    rescue LoadError
+      raise "'rspec' gem is not available"
+    end
+    
+    desc "Run RSpec code examples and verify RCov percentage"
+    RSpec::Core::RakeTask.new('spec:rcov:verify') do |t|
+      t.rcov = true
+      t.rcov_opts = [
+        '--failure-threshold', s.rspec.rcov.failure_threshold,
+        '-Ilib',
+        '--exclude', "'spec/,#{s.rakefile_file}'",
+        '--no-html'
+      ]
+    end
+  end
+  
+  def self.build_spec_task task, rspec_settings
+    t = task
+    r = rspec_settings
+    t.ruby_opts = r.ruby_opts if r.ruby_opts
+  end
+  
+  class RCovSettings < Holder
+    field 'failure_threshold'
+  end
+  
+  class RSpecSettings < Holder
+    field('color') { true }
+    field('format') { 'progress' }
+    
+    field 'ruby_opts'
+    field('rcov') { self.rcov = RCovSettings.new }
+    
+    private
+    def find_file pattern
+      files = Dir.glob(pattern, File::FNM_CASEFOLD)
+      files.find { |f| File.readable? f and File.file? f }
+    end
+  end
+end
+

data/lib/burke/tasks/test.rb

@@ -0,0 +1,20 @@
+module Burke
+  Settings.field(:test) { self.test = TestSettings.new }
+  
+  define_task 'test' do |s|
+    if @settings.test.files.empty?
+      raise "project doesn't seem have any test files"
+    end
+    require 'rake/testtask'
+    Rake::TestTask.new do |t|
+      t.test_files = s.test.files
+    end
+  end
+  
+  class TestSettings < Holder
+    field 'files' do
+      Dir['test/**/{*_{test,tc},{test,tc}_*}.rb'].freeze
+    end
+  end
+end
+

data/lib/burke/tasks/yard.rb

@@ -0,0 +1,20 @@
+module Burke
+  define_task 'yard' do |s|
+    begin
+      require 'yard'
+    rescue LoadError
+      raise "'yard' gem is not available"
+    end
+    
+    opts = []
+    d = s.docs
+    opts << "--title" << d.title
+    opts << "--readme" << d.readme_file if d.readme_file
+    opts << "--markup" << d.markup if d.markup
+    opts << "--files" << d.extra_files.join(',') unless d.extra_files.empty?
+    YARD::Rake::YardocTask.new 'yard' do |t|
+      t.options = opts
+    end
+  end
+end
+