reactive-dev 0.2.0

data/lib/reactive-dev/rubigen_plugin_sources.rb

@@ -0,0 +1,49 @@
+# Yeah, this is a monkey patch...
+module RubiGen # :nodoc:all
+=begin
+  class PathReallyFilteredSource < PathFilteredSource
+    def filter_str(filters)
+      @filters = filters.first.is_a?(Array) ? filters.first : filters
+      return "" if @filters.blank?
+      filter_str = @filters.map {|filter| "#{filter}_"}.join(",")
+      # filter_str += ","  <--- This is exactly what i don't want, because it traps the 'generators' dir at the root of the rubigen gem.
+      "{#{filter_str}}"
+    end
+  end
+=end
+  class Base
+    # Use reactive gem plugins generators (test_unit, etc).
+    # 1.  Current application. Use Reactive.dir_for(:generators).
+    # 2.  User home directory.  Search ~/.rubigen/generators.
+    # 3.  GemPlugins. Search for loaded gems containing /{scope}_generators folder.
+    def self.use_plugin_sources!(*filters)
+      reset_sources
+      new_sources = []
+      new_sources << Reactive.dirs_for(:generators).collect{|dir| PathSource.new(:app, dir) } if Reactive.respond_to? :dirs_for
+      new_sources << PathFilteredSource.new(:user, "#{Dir.user_home}/.rubigen/", *filters)
+      new_sources << Reactive.configuration.gems.map(&:loaded_spec).compact.collect{|spec| RubiGen::PathFilteredSource.new(:GemPlugins, spec.full_gem_path, *filters) }
+      write_inheritable_attribute(:sources, new_sources.flatten)
+    end
+  
+    def klass
+      self.class
+    end
+  
+  end
+end
+
+module Reactive
+  module RubiGenAffiliateMethod # :nodoc:
+  
+    def affiliates(name, args, options)
+      klass.sources.collect {|source| source.collect}.flatten.each do |spec|
+        logger.affiliate(spec.name) do
+          self.class.new(spec.klass.new(args.dup, options)).invoke!
+        end
+      end
+    end
+
+  end
+end
+
+RubiGen::Commands::Base.send(:include, Reactive::RubiGenAffiliateMethod)

data/lib/reactive-dev/source_annotation_extractor.rb

@@ -0,0 +1,62 @@
+class SourceAnnotationExtractor # :nodoc: all
+  class Annotation < Struct.new(:line, :tag, :text)
+    def to_s(options={})
+      s = "[%3d] " % line
+      s << "[#{tag}] " if options[:tag]
+      s << text
+    end
+  end
+
+  def self.enumerate(tag, options={})
+    extractor = new(tag)
+    extractor.display(extractor.find, options)
+  end
+
+  attr_reader :tag
+
+  def initialize(tag)
+    @tag = tag
+  end
+
+  def find(dirs=%w(app lib test))
+    dirs.inject({}) { |h, dir| h.update(find_in(dir)) }
+  end
+
+  def find_in(dir)
+    results = {}
+
+    Dir.glob("#{dir}/*") do |item|
+      next if File.basename(item)[0] == ?.
+
+      if File.directory?(item)
+        results.update(find_in(item))
+      elsif item =~ /\.(builder|(r(?:b|xml|js)))$/
+        results.update(extract_annotations_from(item, /#\s*(#{tag}):?\s*(.*)$/))
+      elsif item =~ /\.(rhtml|erb)$/
+        results.update(extract_annotations_from(item, /<%\s*#\s*(#{tag}):?\s*(.*?)\s*%>/))
+      end
+    end
+
+    results
+  end
+
+  def extract_annotations_from(file, pattern)
+    lineno = 0
+    result = File.readlines(file).inject([]) do |list, line|
+      lineno += 1
+      next list unless line =~ pattern
+      list << Annotation.new(lineno, $1, $2)
+    end
+    result.empty? ? {} : { file => result }
+  end
+
+  def display(results, options={})
+    results.keys.sort.each do |file|
+      puts "#{file}:"
+      results[file].each do |note|
+        puts "  * #{note.to_s(options)}"
+      end
+      puts
+    end
+  end
+end

data/lib/reactive-dev/tasks/annotations.rake

@@ -0,0 +1,23 @@
+require 'source_annotation_extractor'
+
+desc "Enumerate all annotations"
+task :notes do
+  SourceAnnotationExtractor.enumerate "OPTIMIZE|FIXME|TODO", :tag => true
+end
+
+namespace :notes do
+  desc "Enumerate all OPTIMIZE annotations"
+  task :optimize do
+    SourceAnnotationExtractor.enumerate "OPTIMIZE"
+  end
+
+  desc "Enumerate all FIXME annotations"
+  task :fixme do
+    SourceAnnotationExtractor.enumerate "FIXME"
+  end
+
+  desc "Enumerate all TODO annotations"
+  task :todo do
+    SourceAnnotationExtractor.enumerate "TODO"
+  end
+end

data/lib/reactive-dev/tasks/app.rake

@@ -0,0 +1,51 @@
+namespace :app do
+  desc "Create the application gem package"
+  task :package => :environment do
+    require 'rubygems'
+    require 'rake/gempackagetask'
+
+    spec = Gem::Specification.new do |s|
+      s.files = []
+      Reactive.configuration.app_gem_spec(s)
+      s.name = APP_NAME
+      s.platform = Gem::Platform::RUBY
+      Dir.chdir(APP_PATH) do
+        s.files += Dir.glob("{app,assets,config,db,gems,lib,log}/**/*").delete_if {|item| item.include?("CVS") || item.include?("rdoc") || item.include?(".svn")}
+        s.files += Dir.entries('.').select {|name| File.file? name}
+      end
+      #s.add_dependency "reactive-core", "= #{Reactive::VERSION::STRING}"
+      #s.add_dependency "reactive-dev", "= #{Reactive::VERSION::STRING}"
+    end
+  
+    filename = Gem::Builder.new(spec).build
+    FileUtils.move filename, File.join(APP_PATH, "pkg")
+  end
+
+  namespace :package do
+    WINDOZE = /djgpp|(cyg|ms|bcc)win|mingw/ =~ RUBY_PLATFORM unless defined? WINDOZE
+    if WINDOZE
+      desc "Create a NSIS installer for the application\nPass APP_HUMAN_NAME='Fancy App Name' for the installer display name"
+      task :nsis => :package do
+        Dir.chdir(File.join(APP_PATH, 'pkg/nsis')) do
+          args = []
+          if File.file?(File.join(APP_PATH, 'License.txt'))
+            args << "/DLICENSE"
+          else
+            puts "Installer will have no License page. Put a License.txt in your app root to have one."
+          end
+          args << "/DRUBYSETUP" if ENV['RUBYSETUP']
+          args << "/DPRODUCT_NAME=#{APP_NAME}"
+          args << "/DPRODUCT_VERSION=#{Reactive.configuration.app_gem_spec.version}"
+          args << "/DPRODUCT_HUMAN_NAME=#{ENV['APP_HUMAN_NAME'] || APP_NAME}"
+          puts `#{nsis_command} #{args * ' '} ReactiveApp.nsi`
+        end
+      end
+    end
+  
+  end
+
+end
+
+def nsis_command
+  "C:\\Program Files\\NSIS\\makensis.exe"
+end

data/lib/reactive-dev/tasks/plugin.rb

@@ -0,0 +1,147 @@
+require 'rubyforge'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+
+begin
+  gem 'rdoc'
+rescue Gem::LoadError
+end
+
+WINDOZE = /djgpp|(cyg|ms|bcc)win|mingw/ =~ RUBY_PLATFORM unless defined? WINDOZE
+DIFF = (WINDOZE ? 'diff.exe' : (system("gdiff", __FILE__, __FILE__) ? 'gdiff' : 'diff')) unless defined? DIFF
+
+#
+# Setup variables used across task definitions below
+#   spec:            contains the gem specification
+#   rubyforge_name:  project name for rubyforge
+#   need_tar:        create and release tgz archive
+#   need_zip:        create and release tar archive
+#   RDOC_OPTIONS:    Default options for RDoc generation
+
+RDOC_OPTIONS = %w{-x Manifest -x Rakefile -x .*\.rake} unless defined? RDOC_OPTIONS
+RDOC_OPTIONS << '-d' if `which dot` =~ /\/dot/ unless ENV['NODOT'] unless WINDOZE
+RDOC_OPTIONS.push('-m', 'README') if File.file? 'README'
+
+need_tar = @need_tar.nil? ? true : @need_tar
+need_zip = @need_zip.nil? ? false : @need_zip
+
+required_fields = [:name, :author, :email, :summary]
+auto_populate_fields = required_fields + [:version, :homepage, :description, :changes]
+
+spec = @spec || Gem::Specification.new
+
+spec.has_rdoc = true
+spec.extra_rdoc_files |= ["README", "LICENSE", "TODO", "History"].select {|file| File.file? file}
+spec.rdoc_options += RDOC_OPTIONS
+spec.files |= File.read("Manifest").delete("\r").split(/\n/) if File.file? "Manifest"
+spec.executables |= spec.files.grep(/^bin/) {|file| File.basename(file)}
+
+readme = File.read("README").split(/^(=+ .*)$/)[1..-1] rescue []
+unless readme.empty?
+  sections = readme.map {|sct| sct =~ /^=/ ? sct.strip.downcase.chomp(':').split.last : sct.strip}
+
+  header = sections.slice!(0,2)
+  pairs = header[1].split(/^(\w+)::/)
+  spec.name ||= header[0]
+  spec.rubyforge_project ||= spec.name.downcase
+  spec.summary ||= pairs.shift
+
+  Hash[*pairs].each do |key,value|
+    spec.send("#{key.downcase}=", value.chomp.strip)
+  end if pairs.size.modulo(2) == 0
+  
+  sections = Hash[*sections]
+  spec.description ||= sections.values_at('description').join("\n\n")
+  
+  if sections['requirements']
+    sections['requirements'].scan(/^\*(.+)$/).flatten.each {|req| spec.add_dependency(*req.strip.split(/\s+/, 2)) unless req.empty? }
+  end
+end
+
+spec.extend(Module.new { attr_accessor :changes })
+spec.changes = File.read("History").split(/^(===.*)/)[1..2].join.strip if File.exists? "History"
+
+unless spec.version ||= ENV['VERSION']
+  warn "To package this gem, the specification needs a version number. It can't be\nfound in the README, so please pass it on the command line with VERSION=x.y.z"
+end
+
+unless (fields = required_fields.select {|field| !spec.send(field)}).empty?
+  warn "The following required fields for the gem specification are left unset:"
+  warn "  " + fields.join(', ')
+  warn "To correct this, either specify them in the @spec variable defined"
+  warn "at the top of the Rakefile, or write a correctly layed out README."
+end
+
+rubyforge_name = ENV["RUBYFORGE_NAME"] || spec.rubyforge_project
+
+###
+#
+
+#desc 'packages the plugin as a gem'
+Rake::GemPackageTask.new(spec) do |package|
+  package.need_tar = need_tar
+  package.need_zip = need_zip
+end
+
+###
+#
+
+desc 'Verify the manifest.'
+task :check_manifest do
+  f = "Manifest.tmp"
+  require 'find'
+  files = []
+  exclusions = /tmp$|CVS|pkg|\.svn|\.git/
+  Find.find '.' do |path|
+    next unless File.file? path
+    next if path =~ exclusions
+    files << path[2..-1]
+  end
+  files = files.sort.join "\n"
+  File.open f, 'w' do |fp| fp.puts files end
+  system "#{DIFF} -du Manifest #{f}"
+  rm f
+end
+
+###
+#
+
+desc 'Release the plugin and upload it to rubyforge.'
+task :release => [:gem] do |t|
+  version = ENV["VERSION"] or abort "Must supply VERSION=x.y.z"
+  abort "Rubyforge project name needed, add it to your gem specification\nin the Rakefile or pass RUBYFORGE_NAME=name on the command line." unless rubyforge_name
+
+  rf = RubyForge.new.configure
+  puts "Logging in"
+  rf.login
+
+  name = spec.name
+  pkg = "pkg/#{name}-#{version}"
+  
+  c = rf.userconfig
+  c["release_notes"] = spec.description if spec.description
+  c["release_changes"] = spec.changes if spec.changes
+  c["preformatted"] = true
+
+  files = [(need_tar ? "#{pkg}.tgz" : nil),
+           (need_zip ? "#{pkg}.zip" : nil),
+           "#{pkg}.gem"].compact
+
+  puts "Releasing #{name} #{version}"
+  rf.add_release rubyforge_name, name, version, *files
+end
+
+###
+#
+
+Rake::RDocTask.new(:docs) do |rd|
+  rd.rdoc_dir = 'doc'
+  rd.options += RDOC_OPTIONS
+  rd.rdoc_files.push(*spec.files.select {|file| file =~ /^[^\/]+$|^lib\//})
+
+  name = spec.name
+  title = "#{name}-#{spec.version} Documentation"
+  title = "#{rubyforge_name}'s " + title if rubyforge_name != name
+
+  rd.options << "-t #{title}"
+end

data/lib/reactive-dev/tasks/statistics.rake

@@ -0,0 +1,7 @@
+desc "Report code statistics (KLOCs, etc) from the application"
+task :stats do
+  require 'code_statistics'
+  # gather all dirs, then merge the names which targets the same dir, finally sort the pairs by the dir's path
+  dirs = Reactive.configuration.paths.inject(Hash.new([])) {|hash, (name, dir)| hash[dir] << name}.sort.collect {|dir,names| [names.join(', '), dir]}
+  CodeStatistics.new(dirs).to_s
+end

data/lib/reactive-dev/tasks/testing.rake

@@ -0,0 +1,118 @@
+TEST_CHANGES_SINCE = Time.now - 600
+
+# Look up tests for recently modified sources.
+def recent_tests(source_pattern, test_path, touched_since = 10.minutes.ago)
+  FileList[source_pattern].map do |path|
+    if File.mtime(path) > touched_since
+      tests = []
+      source_dir = File.dirname(path).split("/")
+      source_file = File.basename(path, '.rb')
+      
+      # Support subdirs in app/models and app/controllers
+      modified_test_path = source_dir.length > 2 ? "#{test_path}/" << source_dir[1..source_dir.length].join('/') : test_path
+
+      # For modified files in app/ run the tests for it. ex. /test/functional/account_controller.rb
+      test = "#{modified_test_path}/#{source_file}_test.rb"
+      tests.push test if File.exists?(test)
+
+      # For modified files in app, run tests in subdirs too. ex. /test/functional/account/*_test.rb
+      test = "#{modified_test_path}/#{File.basename(path, '.rb').sub("_controller","")}"
+      FileList["#{test}/*_test.rb"].each { |f| tests.push f } if File.exists?(test)
+		
+      return tests
+
+    end
+  end.flatten.compact
+end
+
+
+# Recreated here from ActiveSupport because :uncommitted needs it before Reactive is available
+module Kernel
+  def silence_stderr
+    old_stderr = STDERR.dup
+    STDERR.reopen(RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'NUL:' : '/dev/null')
+    STDERR.sync = true
+    yield
+  ensure
+    STDERR.reopen(old_stderr)
+  end
+end
+
+desc 'Test all units and functionals'
+task :test do
+  errors = %w(test:units test:functionals test:integration).collect do |task|
+    begin
+      Rake::Task[task].invoke
+      nil
+    rescue => e
+      task
+    end
+  end.compact
+  abort "Errors running #{errors.to_sentence}!" if errors.any?
+end
+
+namespace :test do
+  Rake::TestTask.new(:recent => "db:test:prepare") do |t|
+    since = TEST_CHANGES_SINCE
+    touched = FileList['test/**/*_test.rb'].select { |path| File.mtime(path) > since } +
+      recent_tests('app/models/**/*.rb', 'test/unit', since) +
+      recent_tests('app/controllers/**/*.rb', 'test/functional', since)
+
+    t.libs << 'test'
+    t.verbose = true
+    t.test_files = touched.uniq
+  end
+  Rake::Task['test:recent'].comment = "Test recent changes"
+  
+  Rake::TestTask.new(:uncommitted => "db:test:prepare") do |t|
+    def t.file_list
+      changed_since_checkin = silence_stderr { `svn status` }.map { |path| path.chomp[7 .. -1] }
+
+      models      = changed_since_checkin.select { |path| path =~ /app[\\\/]models[\\\/].*\.rb/ }
+      controllers = changed_since_checkin.select { |path| path =~ /app[\\\/]controllers[\\\/].*\.rb/ }  
+
+      unit_tests       = models.map { |model| "test/unit/#{File.basename(model, '.rb')}_test.rb" }
+      functional_tests = controllers.map { |controller| "test/functional/#{File.basename(controller, '.rb')}_test.rb" }
+
+      unit_tests.uniq + functional_tests.uniq
+    end
+    
+    t.libs << 'test'
+    t.verbose = true
+  end
+  Rake::Task['test:uncommitted'].comment = "Test changes since last checkin (only Subversion)"
+
+  Rake::TestTask.new(:units => "db:test:prepare") do |t|
+    t.libs << "test"
+    t.pattern = 'test/unit/**/*_test.rb'
+    t.verbose = true
+  end
+  Rake::Task['test:units'].comment = "Run the unit tests in test/unit"
+
+  Rake::TestTask.new(:functionals => "db:test:prepare") do |t|
+    t.libs << "test"
+    t.pattern = 'test/functional/**/*_test.rb'
+    t.verbose = true
+  end
+  Rake::Task['test:functionals'].comment = "Run the functional tests in test/functional"
+
+  Rake::TestTask.new(:integration => "db:test:prepare") do |t|
+    t.libs << "test"
+    t.pattern = 'test/integration/**/*_test.rb'
+    t.verbose = true
+  end
+  Rake::Task['test:integration'].comment = "Run the integration tests in test/integration"
+
+  Rake::TestTask.new(:plugins => :environment) do |t|
+    t.libs << "test"
+
+    if ENV['PLUGIN']
+      t.pattern = "vendor/plugins/#{ENV['PLUGIN']}/test/**/*_test.rb"
+    else
+      t.pattern = 'vendor/plugins/*/**/test/**/*_test.rb'
+    end
+
+    t.verbose = true
+  end
+  Rake::Task['test:plugins'].comment = "Run the plugin tests in vendor/plugins/*/**/test (or specify with PLUGIN=name)"
+end