burke 0.2.2 → 0.3.5

data/lib/burke.rb

@@ -1,469 +1,245 @@
 require 'rubygems'
 require 'rake'
-require 'hashie'
+require 'burke/holder'
 
-class Smash < Hashie::Mash
-  def initialize *args
-    super
-    @read_filters = {}
-    @write_filters = {}
-  end
-  
-  def method_missing name, *args
-    key = convert_key(name)
-    if key? key or @read_filters.key? key
-      value = self[key]
-      yield value if block_given?
-      value
-    else
-      super
-    end
-  end
-  
-  def [](key)
-    filter = @read_filters[convert_key(key)]
-    value = super(key)
-    filter.nil? ? value : filter[value]
-  end
+module Burke
+  VERSION = File.read(File.join(File.dirname(File.dirname(__FILE__)), 'VERSION'))
   
-  def []=(key, value)
-    filter = @write_filters[convert_key(key)]
-    value = filter[value] if filter
-    super(key, value)
-  end
+  class Settings < Holder ; end
   
-  def read_filter key, &block
-    key = convert_key(key)
-    @read_filters[key] = block
+  class TaskDefinition
+    ALL = {}
+    
+    attr_reader :name, :block, :prerequisites
+    
+    def initialize *args, &block
+      a1, a2 = *args
+      name = nil
+      prereqs = nil
+      if a1.is_a? Hash
+        name, prereqs = *a1.entries[0]
+      else
+        name, prereqs = a1, a2
+      end
+      @name = String(name)
+      @prerequisites = [*prereqs].compact.map {|e| String(e)}
+      @block = block
+      ALL[@name] = self
+    end
+    
+    def execute(s)
+      unless @executed
+        execute_prerequisites(s)
+        @block.call(s)
+        @executed = true
+      end
+    end
+    
+    def execute_prerequisites(s)
+      @prerequisites.each do |prereq|
+        ALL[prereq].execute(s)
+      end
+    end
   end
   
-  def write_filter key, &block
-    @write_filters[convert_key(key)] = block
+  def self.define_task *args, &block
+    TaskDefinition.new *args, &block
   end
 end
 
+require 'burke/tasks/rspec'
+require 'burke/tasks/test'
+require 'burke/tasks/clean'
+require 'burke/tasks/docs'
+require 'burke/tasks/rdoc'
+require 'burke/tasks/yard'
+require 'burke/tasks/gems'
+require 'burke/tasks/release'
+
 module Burke
-  VERSION = File.read(File.join(File.dirname(File.dirname(__FILE__)), 'VERSION'))
-  ALL_TASKS = [:clean, :yard, :rdoc, :rspec, :rspec_rcov, :gems, :install, :test]
   @tasks = []
+  @enabled_tasks = TaskDefinition::ALL.keys
   
-  class << self
-    def enable_all opts={}
-      @tasks = ALL_TASKS.dup
-      disable opts[:except] if opts[:except]
-    end
+  class DependencySettings < Holder
+    def self.field_exists? name ; true ; end
+  end
+  
+  class Settings < Holder
+    fields *(Gem::Specification.attribute_names - [:dependencies, :development_dependencies])
+    fields *%w[author gems]
     
-    def enable *args
-      @tasks.concat([*args].map {|t| t.to_sym})
-      @tasks.uniq!
-    end
+    field(:has_rdoc) { Burke.task_enabled? :rdoc }
     
-    def disable *args
-      dis = [*args].map {|t| t.to_sym}
-      @tasks.reject! {|t| dis.include? t}
+    field :rdoc_options do
+      opts = []
+      opts << "--title" << docs.title
+      opts << "--main" << docs.readme_file if docs.readme_file
+      opts.freeze
     end
     
-    def setup
-      @settings = create_settings
-      
-      yield @settings
-      
-      if @tasks.include? :gems and GemTaskManager::TASKS.empty?
-        @settings.gems.platform 'ruby'
-      end
-      
-      generate_tasks
-      
-      return @settings
+    field :extra_rdoc_files do
+      docs.extra_files
     end
     
-    def generate_tasks
+    field :dependencies do
+      dependencies = (self.dependencies = DependencySettings.new)
       begin
-        require 'rake/clean'
-        CLEAN.include(*@settings.clean) if @settings.clean
-        CLOBBER.include(*@settings.clobber) if @settings.clobber
-      rescue LoadError
-      end if @tasks.include? :clean
-      
-      unless @settings.docs.files
-        d = @settings.docs
-        fl = FileList.new
-        fl.include "lib/**/*.rb"
-        fl.include d.readme if d.readme
-        fl.include d.license if d.license
-        d.files = fl.to_a
-      end
-      
-      begin
-        require 'yard'
-        opts = []
-        d = @settings.docs
-        opts << "--title" << "#{@settings.name} #{@settings.version}"
-        opts << "--readme" << d.readme if d.readme
-        opts << "--markup" << d.markup if d.markup
-        extra_files = [d.license].compact
-        opts << "--files" << extra_files.join(',') unless extra_files.empty?
-        YARD::Rake::YardocTask.new 'yard' do |t|
-          t.options = opts
+        require 'bundler'
+        bundler = Bundler.load
+        deps = bundler.dependencies_for(:runtime)
+        if deps.empty?
+          deps = bundler.dependencies_for(:default)
         end
-      rescue LoadError
-      end if @tasks.include? :yard
-      
-      begin
-        require 'rake/rdoctask'
-        d = @settings.docs
-        Rake::RDocTask.new 'rdoc' do |r|
-          r.rdoc_files.include d.files
-          r.title = "#{@settings.name} #{@settings.version}"
-          r.main = d.readme if d.readme
+        deps.each do |d|
+          dependencies[d.name] = d.requirement.to_s
         end
-      rescue LoadError
-      end if @tasks.include? :rdoc
-      
-      if @settings.has_rdoc
-        d = @settings.docs
-        (@settings.extra_rdoc_files ||= []).concat d.files
-        opts = []
-        opts << "--title" << "#{@settings.name} #{@settings.version}"
-        opts << "--main" << d.readme if d.readme
-        @settings.rdoc_options ||= opts
+      rescue
       end
-      
-      begin
-        require 'spec/rake/spectask'
-        r = @settings.rspec
-        opts = []
-        if r.options_file
-          opts << "--options" << r.options_file
-        else
-          opts << "--colour" if r.color
-          opts << "--format" << r.format if r.format
-        end
-        Spec::Rake::SpecTask.new 'spec' do |t|
-          t.spec_files = r.spec_files
-          t.spec_opts = opts
-          t.ruby_opts = r.ruby_opts if r.ruby_opts
-        end
-        
-        begin
-          require 'rcov'
-          require 'spec/rake/verify_rcov'
-          
-          desc "Run specs with RCov"
-          Spec::Rake::SpecTask.new('spec:rcov') do |t|
-            t.spec_files = r.spec_files
-            t.spec_opts = opts
-            t.rcov = true
-            t.rcov_opts = ['--exclude', 'spec']
-          end
-          
-          desc "Run specs with RCov and verify code coverage"
-          RCov::VerifyTask.new('spec:rcov:verify' => 'spec:rcov') do |t|
-            t.threshold = r.rcov.threshold
-            t.index_html = 'coverage/index.html'
-          end if r.rcov.threshold
-        rescue LoadError
-        end if @tasks.include? :rspec_rcov
-      rescue LoadError
-      end if @tasks.include? :rspec and !@settings.rspec.spec_files.empty?
-      
-      begin
-        require 'rake/testtask'
-        Rake::TestTask.new do |t|
-          t.test_files = @settings.test.test_files
-        end
-      rescue LoadError
-      end if @tasks.include? :test and !@settings.test.test_files.empty?
-      
-      begin
-        settings.gems.individuals.each do |conf|
-          GemTaskManager.add_task conf
-        end
-        
-        if name
-          desc "Build gem for this platform"
-          task(:gem => GemTaskManager.task_for_this_platform.task_name)
-        end
-      rescue LoadError
-      end if @tasks.include? :gems
-      
-      begin
-        require 'rubygems/installer'
-        GemTaskManager.install_task unless GemTaskManager::TASKS.empty?
-      rescue LoadError
-      end if @tasks.include? :install
+      dependencies
     end
     
-    def base_gemspec
-      if @base_gemspec.nil?
-        @base_gemspec = Gem::Specification.new
-        
-        attrs = Gem::Specification.attribute_names
-        attrs -= [:dependencies, :development_dependencies]
-        attrs += [:author]
-        
-        attrs.each do |attr|
-          value = @settings.send(attr)
-          @base_gemspec.send("#{attr}=", value) if value
-        end
-        
-        @settings.dependencies.each do |gem, requirements|
-          @base_gemspec.add_dependency gem.to_s, *requirements
-        end
-        
-        @settings.development_dependencies.each do |gem, requirements|
-          @base_gemspec.add_development_dependency gem.to_s, *requirements
+    field :development_dependencies do
+      dev_deps = (self.development_dependencies = DependencySettings.new)
+      begin
+        require 'bundler'
+        Bundler.load.dependencies_for(:development).each do |d|
+          dev_deps[d.name] = d.requirement.to_s
         end
+      rescue
       end
-      
-      @base_gemspec
+      dev_deps
     end
     
-    def settings
-      @settings
-    end
+    field(:rakefile_file) { find_file('rakefile').freeze }
+    field(:version_file) { find_file('version{.*,}').freeze }
     
-    def create_settings
-      # TODO: put default values in getter filters
-      s = Smash.new
-      s.docs!
-      s.rspec!.rcov!
-      s.test!
-      s.gems = GemSettings.new
-      s.clean = []
-      s.clobber = []
-      
-      s.read_filter :dependencies do |v|
-        if v.nil?
-          s.dependencies = Smash.new
-          v = s.dependencies
-          begin
-            require 'bundler'
-            bundler = Bundler.load
-            deps = bundler.dependencies_for(:runtime)
-            if deps.empty?
-              deps = bundler.dependencies_for(:default)
-            end
-            deps.each do |d|
-              v[d.name] = d.requirement.to_s
-            end
-          rescue
-          end
-        end
-        v
-      end
-      
-      s.read_filter :development_dependencies do |v|
-        if v.nil?
-          s.development_dependencies = Smash.new
-          v = s.development_dependencies
-          begin
-            require 'bundler'
-            Bundler.load.dependencies_for(:development).each do |d|
-              v[d.name] = d.requirement.to_s
-            end
-          rescue
-          end
-        end
-        v
-      end
-      
-      s.read_filter :files do |v|
-        if v.nil?
-          v = Dir['{lib,spec,bin}/**/*']
-          v << s.docs.readme_file
-          v << s.docs.license_file
-          v << s.version_file
-          v << s.rakefile_file
-          v.compact.freeze
-        else
-          v
-        end
-      end
-      
-      s.read_filter :rakefile_file do |v|
-        v or find_file('rakefile').freeze
-      end
-      
-      s.read_filter :version_file do |v|
-        v or find_file('version{.*,}').freeze
-      end
-      
-      s.read_filter :version do |v|
-        if v.nil? and s.version_file
-          File.read(s.version_file).strip.freeze
-        else
-          v
-        end
-      end
-      
-      s.docs.read_filter :readme_file do |v|
-        v or find_file('readme{.*,}').freeze
-      end
-      s.docs.read_filter(:readme) { s.docs.readme_file }
-      s.docs.write_filter(:readme) { |v| s.docs.readme_file = v }
-      
-      s.docs.read_filter :license_file do |v|
-        v or find_file('{licen{c,s}e,copying}{.*,}').freeze
-      end
-      s.docs.read_filter(:license) { s.docs.license_file }
-      s.docs.write_filter(:license) { |v| s.docs.license_file = v }
-      
-      s.docs.read_filter :markup do |v|
-        readme = s.docs.readme
-        if v.nil? and readme
-          case File.extname(readme).downcase
-          when '.rdoc'
-            'rdoc'
-          when '.md', '.markdown'
-            'markdown'
-          when '.textile'
-            'textile'
-          end.freeze
-        else
-          v
-        end
-      end
-      
-      s.test.read_filter :test_files do |v|
-        v or Dir['test/**/{*_{test,tc},{test,tc}_*}.rb'].freeze
-      end
-      
-      s.rspec.read_filter :options_file do |v|
-        v or find_file('{{spec/,}{spec.opts,.specopts}}').freeze
-      end
-      
-      s.rspec.read_filter :color do |v|
-        v.nil? ? true : v
-      end
-      
-      s.rspec.read_filter :spec_files do |v|
-        v or Dir['spec/**/*_spec.rb'].freeze
-      end
-      
-      s.rspec.write_filter(:ruby_opts) { |v| [*v] }
-      
-      return s
-    end
+    field(:version) { File.read(version_file).strip.freeze if version_file }
     
-    private
-    def readable_file? file
-      File.readable? file and File.file? file
+    field :files do
+      fs = Dir['{lib,spec,bin}/**/*']
+      fs << docs.readme_file
+      fs << docs.license_file
+      fs << version_file
+      fs << rakefile_file
+      fs.compact.freeze
     end
     
+    private
     def find_file pattern
       files = Dir.glob(pattern, File::FNM_CASEFOLD)
-      files.find { |f| readable_file? f }
+      files.find { |f| File.readable? f and File.file? f }
     end
   end
   
-  class GemTaskManager
-    TASKS = {}
-    
-    def self.add_task conf
-      spec = conf.gemspec
-      name = "gem:#{spec.platform}"
-      pkg_dir = Burke.settings.gems.package_dir
-      
-      if TASKS.empty?
-        desc "Build gems for all targets"
-      end
-      task :gems => name
-      
-      unless ::Rake.application.last_comment
-        desc "Build gem for target '#{spec.platform}'"
-      end
-      
-      task(name) do
-        conf.before.call spec unless conf.before.nil?
-        builder = Gem::Builder.new(spec)
-        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.call spec unless conf.after.nil?
-      end
-      
-      TASKS[spec.platform.to_s] = conf
-    end
-    
-    def self.has_task? platform
-      TASKS.has_key? platform
+  class << self
+    def enable_all opts={}
+      @enabled_tasks = TaskDefinition::ALL.keys
+      disable *opts[:except] if opts[:except]
     end
     
-    def self.task_for_this_platform
-      platform = Gem::Platform.new(RUBY_PLATFORM).to_s
-      name = nil
-      
-      if GemTaskManager.has_task? platform
-        name = platform
-      elsif GemTaskManager.has_task? 'ruby'
-        name = "ruby"
-      end
-      
-      TASKS[name]
+    def disable_all opts={}
+      @enabled_tasks = []
+      enable *opts[:except] if opts[:except]
     end
     
-    def self.install_task
-      t = task_for_this_platform
-      
-      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
+    def enable *args
+      @enabled_tasks.concat([*args].map {|t| String(t)})
+      @enabled_tasks.uniq!
     end
-  end
-  
-  class GemSettings
-    attr_accessor :package_dir, :individuals
     
-    def initialize
-      @package_dir = 'pkg'
+    def disable *args
+      dis = [*args].map {|t| String(t)}
+      @enabled_tasks.reject! {|t| dis.include? t}
     end
     
-    def platform plaf
-      conf = IndividualGemSettings.new plaf
-      @individuals ||= []
-      @individuals << conf
-      yield conf if block_given?
-      conf
+    def settings
+      @settings ||= Settings.new
     end
     
-    class IndividualGemSettings
-      attr_reader :platform
+    def setup &block
+      settings.instance_exec settings, &block
       
-      def initialize plaf
-        @platform = Gem::Platform.new plaf
+      if task_enabled? :gems and GemTaskManager::TASKS.empty?
+        settings.gems.add_platform 'ruby'
       end
       
-      def gemspec
-        spec = Burke.base_gemspec.dup
-        spec.platform = @platform
-        spec
-      end
-      
-      def gem_file
-        "#{gemspec.full_name}.gem"
-      end
+      enabled = []
+      disabled = []
       
-      def task_name
-        "gem:#{platform}"
+      # Generate tasks
+      TaskDefinition::ALL.each do |name, td|
+        if task_enabled? name
+          begin
+            td.prerequisites.each do |prereq|
+              raise "prerequisite '#{prereq}' is disabled" unless task_enabled? prereq
+            end
+            td.execute(settings)
+            enabled << [name, nil]
+          rescue Exception => ex
+            disabled << [name, ex.message]
+          end
+        else
+          disabled << [name, "disabled by project developer(s)"]
+        end
       end
       
-      def package_dir
-        Burke.settings.gems.package_dir
+      desc 'List Burke task groups'
+      task 'burke:tasks' do
+        unless enabled.empty?
+          puts ' ---------'
+          puts '  Enabled '
+          puts ' ---------'
+          width = enabled.map {|a| a[0].length}.sort.last
+          enabled.sort_by {|a| a[0]}.each do |name, reason|
+            line = "+ #{name.ljust(width)}"
+            line << " (#{reason})" if reason
+            puts line
+          end
+          puts
+        end
+        unless disabled.empty?
+          puts ' ----------'
+          puts '  Disabled '
+          puts ' ----------'
+          width = disabled.map {|a| a[0].length}.sort.last
+          disabled.sort_by {|a| a[0]}.each do |name, reason|
+            line = "- #{name.ljust(width)}"
+            line << " (#{reason})" if reason
+            puts line
+          end
+        end
       end
       
-      def before &block
-        @before = block if block_given?
-        @before
+      return settings
+    end
+    
+    def task_enabled? name
+      @enabled_tasks.include? String(name)
+    end
+    
+    def base_gemspec
+      if @base_gemspec.nil?
+        @base_gemspec = Gem::Specification.new
+        
+        attrs = Gem::Specification.attribute_names
+        attrs -= [:dependencies, :development_dependencies]
+        attrs += [:author]
+        
+        attrs.each do |attr|
+          value = settings.send(attr)
+          @base_gemspec.send("#{attr}=", value) if value
+        end
+        
+        settings.dependencies.each do |gem, requirements|
+          @base_gemspec.add_dependency gem.to_s, *requirements
+        end
+        
+        settings.development_dependencies.each do |gem, requirements|
+          @base_gemspec.add_development_dependency gem.to_s, *requirements
+        end
       end
       
-      def after &block
-        @after = block if block_given?
-        @after
-      end
+      @base_gemspec
     end
   end
 end

data/spec/{conventional_project_spec.rb → burke_spec.rb}

@@ -1,23 +1,26 @@
+($LOAD_PATH << File.dirname(File.expand_path(__FILE__))).uniq!
+require 'spec_helper'
+
 DIR = File.dirname(File.expand_path(__FILE__))
-require File.join(DIR, 'spec_helper')
 
 describe Burke do
   describe 'settings' do
-    context 'for example of a conventional project' do
+    context 'for example of a simple project' do
       before do
         @old_pwd = Dir.pwd
-        Dir.chdir File.join(DIR, 'conventional_project')
+        Dir.chdir File.join(DIR, 'simple_project')
         mock_burke_setup
-        eval(File.read('Rakefile'))
-        @settings = Burke.test_settings
+        load 'Rakefile'
+        @settings = Burke.settings
       end
       
       subject { @settings }
       
-      its(:name) { should eql 'conventional_project' }
+      its(:name) { should eql 'simple_project' }
       
       its(:version_file) { should eql 'VERSION' }
       its(:rakefile_file) { should eql 'Rakefile' }
+      its(:version) { should eql '1.2.3' }
       
       describe 'docs' do
         subject { @settings.docs }