redmine_plugin_support 0.0.3 → 0.0.4

data/CHANGES.rdoc

@@ -0,0 +1,22 @@
+== NEXT
+
+* Added: support for code statistics tasks
+
+== 0.0.3
+
+* Feature: MIT License
+* Feature: use jeweler to package instead of newgem
+
+== 0.0.2
+
+* Feature: support for Test::Unit
+* Bug: both zip and tar files can be generated together
+
+== 0.0.1
+
+* First public release
+* Feature: support for rdoc tasks
+* Feature: support for RSpec tasks
+* Feature: support for Cucumber tasks
+* Feature: support for packaging (zip and tar) tasks
+* Feature: ENV['REDMINE_ROOT'] support for running tasks outside of vendor/plugins

data/README.rdoc

@@ -1,16 +1,40 @@
-= redmine_plugin_support
+= Redmine Plugin Support
 
-Description goes here.
+This library is a collection of rake tasks and other scripts that will make Redmine plugin development easier.  To use it, just configure it in your plugin's Rakefile:
+
+    require 'redmine_plugin_support'
+    
+    RedminePluginSupport::Base.setup do |plugin|
+      plugin.project_name = 'my_plugin_name'
+      plugin.default_task = [:spec]
+      plugin.tasks = [:doc, :release, :clean, :spec]
+    end
+
+== Configuration options
+
+* project_name - name of your Redmine plugin.  Make sure it matches your name in the init.rb
+* tasks - list of Rake tasks to use.   Valid options are:
+  * :doc - rdoc tasks
+  * :spec
+  * :cucumber
+  * :release - packaging tasks
+  * :clean
+  * :test - Test::Unit tasks
+* plugin_root - the location of your plugin.  Default: '.' which will work fine if you're requiring this gem from a Rakefile.
+* redmine_root - the location of your Redmine root.  Default: the system's REDMINE_ROOT environment or three directories down from your plugin
+* default_task
+
+== Bugs and Feature requests
+
+Bug reports and feature requests are welcome at https://projects.littlestreamsoftware.com/projects/plugin-support-gem.
 
 == Note on Patches/Pull Requests
- 
+
 * Fork the project.
 * Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
-  future version unintentionally.
+* Add tests for it. This is important so I don't break it in a future version unintentionally.
 * Commit, do not mess with rakefile, version, or history.
-  (if you want to have your own version, that is fine but
-   bump version in a commit by itself I can ignore when I pull)
+  * (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
 * Send me a pull request. Bonus points for topic branches.
 
 == Copyright

data/Rakefile

@@ -12,6 +12,14 @@ begin
     gem.authors = ["Eric Davis"]
     gem.add_development_dependency "thoughtbot-shoulda"
     gem.rubyforge_project = "redmine_plugin_support" # TODO
+    gem.files =  FileList[
+                          "[A-Z]*",
+                          "init.rb",
+                          "rails/init.rb",
+                          "{bin,generators,lib,test,app,assets,config,lang}/**/*",
+                          'lib/jeweler/templates/.gitignore'
+                         ]
+
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end
   Jeweler::GemcutterTasks.new

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.0.4

data/lib/redmine_plugin_support/database_task.rb

@@ -0,0 +1,187 @@
+module RedminePluginSupport
+  class DatabaseTask < GeneralTask
+    def define
+      # Adding Rails's database rake tasks, we need the db:test:reset one in
+      # order to clear the test database.
+      namespace :db do
+        desc "Raises an error if there are pending migrations"
+        task :abort_if_pending_migrations => :environment do
+          if defined? ActiveRecord
+            pending_migrations = ActiveRecord::Migrator.new(:up, 'db/migrate').pending_migrations
+
+            if pending_migrations.any?
+              puts "You have #{pending_migrations.size} pending migrations:"
+              pending_migrations.each do |pending_migration|
+                puts '  %4d %s' % [pending_migration.version, pending_migration.name]
+              end
+              abort %{Run "rake db:migrate" to update your database then try again.}
+            end
+          end
+        end
+
+        namespace :schema do
+          desc "Create a db/schema.rb file that can be portably used against any DB supported by AR"
+          task :dump => :environment do
+            require 'active_record/schema_dumper'
+            File.open(ENV['SCHEMA'] || "#{RAILS_ROOT}/db/schema.rb", "w") do |file|
+              ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, file)
+            end
+            Rake::Task["db:schema:dump"].reenable
+          end
+
+          desc "Load a schema.rb file into the database"
+          task :load => :environment do
+            file = ENV['SCHEMA'] || "#{RAILS_ROOT}/db/schema.rb"
+            if File.exists?(file)
+              load(file)
+            else
+              abort %{#{file} doesn't exist yet. Run "rake db:migrate" to create it then try again. If you do not intend to use a database, you should instead alter #{RAILS_ROOT}/config/environment.rb to prevent active_record from loading: config.frameworks -= [ :active_record ]}
+            end
+          end
+        end
+
+        namespace :structure do
+          desc "Dump the database structure to a SQL file"
+          task :dump => :environment do
+            abcs = ActiveRecord::Base.configurations
+            case abcs[RAILS_ENV]["adapter"]
+            when "mysql", "oci", "oracle"
+              ActiveRecord::Base.establish_connection(abcs[RAILS_ENV])
+              File.open("#{RAILS_ROOT}/db/#{RAILS_ENV}_structure.sql", "w+") { |f| f << ActiveRecord::Base.connection.structure_dump }
+            when "postgresql"
+              ENV['PGHOST']     = abcs[RAILS_ENV]["host"] if abcs[RAILS_ENV]["host"]
+              ENV['PGPORT']     = abcs[RAILS_ENV]["port"].to_s if abcs[RAILS_ENV]["port"]
+              ENV['PGPASSWORD'] = abcs[RAILS_ENV]["password"].to_s if abcs[RAILS_ENV]["password"]
+              search_path = abcs[RAILS_ENV]["schema_search_path"]
+              search_path = "--schema=#{search_path}" if search_path
+              `pg_dump -i -U "#{abcs[RAILS_ENV]["username"]}" -s -x -O -f db/#{RAILS_ENV}_structure.sql #{search_path} #{abcs[RAILS_ENV]["database"]}`
+              raise "Error dumping database" if $?.exitstatus == 1
+            when "sqlite", "sqlite3"
+              dbfile = abcs[RAILS_ENV]["database"] || abcs[RAILS_ENV]["dbfile"]
+              `#{abcs[RAILS_ENV]["adapter"]} #{dbfile} .schema > db/#{RAILS_ENV}_structure.sql`
+            when "sqlserver"
+              `scptxfr /s #{abcs[RAILS_ENV]["host"]} /d #{abcs[RAILS_ENV]["database"]} /I /f db\\#{RAILS_ENV}_structure.sql /q /A /r`
+              `scptxfr /s #{abcs[RAILS_ENV]["host"]} /d #{abcs[RAILS_ENV]["database"]} /I /F db\ /q /A /r`
+            when "firebird"
+              set_firebird_env(abcs[RAILS_ENV])
+              db_string = firebird_db_string(abcs[RAILS_ENV])
+              sh "isql -a #{db_string} > #{RAILS_ROOT}/db/#{RAILS_ENV}_structure.sql"
+            else
+              raise "Task not supported by '#{abcs["test"]["adapter"]}'"
+            end
+
+            if ActiveRecord::Base.connection.supports_migrations?
+              File.open("#{RAILS_ROOT}/db/#{RAILS_ENV}_structure.sql", "a") { |f| f << ActiveRecord::Base.connection.dump_schema_information }
+            end
+          end
+        end
+
+        namespace :test do
+          desc "Recreate the test database from the current schema.rb"
+          task :load => 'db:test:purge' do
+            ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
+            ActiveRecord::Schema.verbose = false
+            Rake::Task["db:schema:load"].invoke
+          end
+
+          desc "Recreate the test database from the current environment's database schema"
+          task :clone => %w(db:schema:dump db:test:load)
+
+          desc "Recreate the test databases from the development structure"
+          task :clone_structure => [ "db:structure:dump", "db:test:purge" ] do
+            abcs = ActiveRecord::Base.configurations
+            case abcs["test"]["adapter"]
+            when "mysql"
+              ActiveRecord::Base.establish_connection(:test)
+              ActiveRecord::Base.connection.execute('SET foreign_key_checks = 0')
+              IO.readlines("#{RAILS_ROOT}/db/#{RAILS_ENV}_structure.sql").join.split("\n\n").each do |table|
+                ActiveRecord::Base.connection.execute(table)
+              end
+            when "postgresql"
+              ENV['PGHOST']     = abcs["test"]["host"] if abcs["test"]["host"]
+              ENV['PGPORT']     = abcs["test"]["port"].to_s if abcs["test"]["port"]
+              ENV['PGPASSWORD'] = abcs["test"]["password"].to_s if abcs["test"]["password"]
+              `psql -U "#{abcs["test"]["username"]}" -f #{RAILS_ROOT}/db/#{RAILS_ENV}_structure.sql #{abcs["test"]["database"]}`
+            when "sqlite", "sqlite3"
+              dbfile = abcs["test"]["database"] || abcs["test"]["dbfile"]
+              `#{abcs["test"]["adapter"]} #{dbfile} < #{RAILS_ROOT}/db/#{RAILS_ENV}_structure.sql`
+            when "sqlserver"
+              `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{RAILS_ENV}_structure.sql`
+            when "oci", "oracle"
+              ActiveRecord::Base.establish_connection(:test)
+              IO.readlines("#{RAILS_ROOT}/db/#{RAILS_ENV}_structure.sql").join.split(";\n\n").each do |ddl|
+                ActiveRecord::Base.connection.execute(ddl)
+              end
+            when "firebird"
+              set_firebird_env(abcs["test"])
+              db_string = firebird_db_string(abcs["test"])
+              sh "isql -i #{RAILS_ROOT}/db/#{RAILS_ENV}_structure.sql #{db_string}"
+            else
+              raise "Task not supported by '#{abcs["test"]["adapter"]}'"
+            end
+          end
+
+          desc "Empty the test database"
+          task :purge => :environment do
+            abcs = ActiveRecord::Base.configurations
+            case abcs["test"]["adapter"]
+            when "mysql"
+              ActiveRecord::Base.establish_connection(:test)
+              ActiveRecord::Base.connection.recreate_database(abcs["test"]["database"], abcs["test"])
+            when "postgresql"
+              ActiveRecord::Base.clear_active_connections!
+              drop_database(abcs['test'])
+              create_database(abcs['test'])
+            when "sqlite","sqlite3"
+              dbfile = abcs["test"]["database"] || abcs["test"]["dbfile"]
+              File.delete(dbfile) if File.exist?(dbfile)
+            when "sqlserver"
+              dropfkscript = "#{abcs["test"]["host"]}.#{abcs["test"]["database"]}.DP1".gsub(/\\/,'-')
+              `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{dropfkscript}`
+              `osql -E -S #{abcs["test"]["host"]} -d #{abcs["test"]["database"]} -i db\\#{RAILS_ENV}_structure.sql`
+            when "oci", "oracle"
+              ActiveRecord::Base.establish_connection(:test)
+              ActiveRecord::Base.connection.structure_drop.split(";\n\n").each do |ddl|
+                ActiveRecord::Base.connection.execute(ddl)
+              end
+            when "firebird"
+              ActiveRecord::Base.establish_connection(:test)
+              ActiveRecord::Base.connection.recreate_database!
+            else
+              raise "Task not supported by '#{abcs["test"]["adapter"]}'"
+            end
+          end
+
+          desc 'Check for pending migrations and load the test schema'
+          task :prepare => 'db:abort_if_pending_migrations' do
+            if defined?(ActiveRecord) && !ActiveRecord::Base.configurations.blank?
+              Rake::Task[{ :sql  => "db:test:clone_structure", :ruby => "db:test:load" }[ActiveRecord::Base.schema_format]].invoke
+            end
+          end
+        end
+      end
+
+      def drop_database(config)
+        case config['adapter']
+        when 'mysql'
+          ActiveRecord::Base.establish_connection(config)
+          ActiveRecord::Base.connection.drop_database config['database']
+        when /^sqlite/
+          FileUtils.rm(File.join(RAILS_ROOT, config['database']))
+        when 'postgresql'
+          ActiveRecord::Base.establish_connection(config.merge('database' => 'postgres', 'schema_search_path' => 'public'))
+          ActiveRecord::Base.connection.drop_database config['database']
+        end
+      end
+
+      def set_firebird_env(config)
+        ENV["ISC_USER"]     = config["username"].to_s if config["username"]
+        ENV["ISC_PASSWORD"] = config["password"].to_s if config["password"]
+      end
+
+      def firebird_db_string(config)
+        FireRuby::Database.db_string_for(config.symbolize_keys)
+      end
+    end
+  end
+end

data/lib/redmine_plugin_support/metrics_task.rb

@@ -0,0 +1,14 @@
+module RedminePluginSupport
+  class MetricsTask < GeneralTask
+    def define
+      require 'metric_fu'
+
+      namespace :metrics do
+        desc "Check the code against the rails_best_practices"
+        task :rails_best_practices do
+          system("rails_best_practices #{RedmineHelper.plugin_root}")
+        end
+      end
+    end
+  end
+end

data/lib/redmine_plugin_support/stats_task.rb

@@ -0,0 +1,55 @@
+module RedminePluginSupport
+  class StatsTask < GeneralTask
+
+    STATS_DIRECTORIES = [
+                         %w(Controllers        app/controllers),
+                         %w(Helpers            app/helpers), 
+                         %w(Models             app/models),
+                         %w(Libraries          lib/),
+                         %w(APIs               app/apis),
+                         %w(Integration\ tests test/integration),
+                         %w(Functional\ tests  test/functional),
+                         %w(Unit\ tests        test/unit)
+                        ]
+
+    def stats_directories
+      STATS_DIRECTORIES.collect { |name, dir| [ name, "#{RedmineHelper.plugin_root}/#{dir}" ] }.select { |name, dir| File.directory?(dir) }
+    end
+    
+    def define
+      # TODO: Need to get rspec stats to work
+      
+      namespace :spec do
+        task :statsetup do
+          require 'code_statistics'
+          STATS_DIRECTORIES << %w(Model\ specs spec/models) if File.exist?("#{RedmineHelper.plugin_root}/spec/models")
+          STATS_DIRECTORIES << %w(View\ specs spec/views) if File.exist?("#{RedmineHelper.plugin_root}/spec/views")
+          STATS_DIRECTORIES << %w(Controller\ specs spec/controllers) if File.exist?("#{RedmineHelper.plugin_root}/spec/controllers")
+          STATS_DIRECTORIES << %w(Helper\ specs spec/helpers) if File.exist?("#{RedmineHelper.plugin_root}/spec/helpers")
+          STATS_DIRECTORIES << %w(Library\ specs spec/lib) if File.exist?("#{RedmineHelper.plugin_root}/spec/lib")
+          STATS_DIRECTORIES << %w(Routing\ specs spec/routing) if File.exist?("#{RedmineHelper.plugin_root}/spec/routing")
+          STATS_DIRECTORIES << %w(Integration\ specs spec/integration) if File.exist?("#{RedmineHelper.plugin_root}/spec/integration")
+          ::CodeStatistics::TEST_TYPES << "Model specs" if File.exist?("#{RedmineHelper.plugin_root}/spec/models")
+          ::CodeStatistics::TEST_TYPES << "View specs" if File.exist?("#{RedmineHelper.plugin_root}/spec/views")
+          ::CodeStatistics::TEST_TYPES << "Controller specs" if File.exist?("#{RedmineHelper.plugin_root}/spec/controllers")
+          ::CodeStatistics::TEST_TYPES << "Helper specs" if File.exist?("#{RedmineHelper.plugin_root}/spec/helpers")
+          ::CodeStatistics::TEST_TYPES << "Library specs" if File.exist?("#{RedmineHelper.plugin_root}/spec/lib")
+          ::CodeStatistics::TEST_TYPES << "Routing specs" if File.exist?("#{RedmineHelper.plugin_root}/spec/routing")
+          ::CodeStatistics::TEST_TYPES << "Integration specs" if File.exist?("#{RedmineHelper.plugin_root}/spec/integration")
+        end
+      end
+
+
+
+      desc "Report code statistics (KLOCs, etc) from the application"
+      task :stats do
+        require 'code_statistics'
+        CodeStatistics.new(*stats_directories).to_s
+      end
+      
+      self
+    end
+    
+  end
+end
+

data/lib/redmine_plugin_support/test_unit_task.rb

@@ -19,28 +19,28 @@ module RedminePluginSupport
       end
 
       namespace :test do
-        Rake::TestTask.new(:units => :environment) do |t|
+        Rake::TestTask.new(:units => [:environment, '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 => :environment) do |t|
+        Rake::TestTask.new(:functionals => [:environment, '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 => :environment) do |t|
+        Rake::TestTask.new(:integration => [:environment, '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(:benchmark => :environment) do |t|
+        Rake::TestTask.new(:benchmark => [:environment, 'db:test:prepare']) do |t|
           t.libs << 'test'
           t.pattern = 'test/performance/**/*_test.rb'
           t.verbose = true
@@ -48,7 +48,7 @@ module RedminePluginSupport
         end
         Rake::Task['test:benchmark'].comment = 'Benchmark the performance tests'
 
-        Rake::TestTask.new(:profile => :environment) do |t|
+        Rake::TestTask.new(:profile => [:environment, 'db:test:prepare']) do |t|
           t.libs << 'test'
           t.pattern = 'test/performance/**/*_test.rb'
           t.verbose = true

data/lib/redmine_plugin_support.rb

@@ -7,14 +7,17 @@ require 'rake/tasklib'
 require 'redmine_plugin_support/redmine_helper'
 require 'redmine_plugin_support/general_task'
 require 'redmine_plugin_support/environment_task'
+require 'redmine_plugin_support/database_task'
 require 'redmine_plugin_support/cucumber_task'
+require 'redmine_plugin_support/metrics_task'
 require 'redmine_plugin_support/rdoc_task'
 require 'redmine_plugin_support/release_task'
 require 'redmine_plugin_support/rspec_task'
+require 'redmine_plugin_support/stats_task'
 require 'redmine_plugin_support/test_unit_task'
 
 module RedminePluginSupport
-  VERSION = '0.0.2'
+  VERSION = '0.0.4'
 
   @@options = { }
 
@@ -34,7 +37,7 @@ module RedminePluginSupport
     def self.setup(options = { }, &block)
       plugin = self.instance
       plugin.project_name = 'undefined'
-      plugin.tasks = [:doc, :spec, :cucumber, :release, :clean, :test]
+      plugin.tasks = [:db, :doc, :spec, :cucumber, :release, :clean, :test, :stats]
       plugin.plugin_root = '.'
       plugin.redmine_root = ENV["REDMINE_ROOT"] || File.expand_path(File.dirname(__FILE__) + '/../../../')
       plugin.default_task = :doc
@@ -45,6 +48,8 @@ module RedminePluginSupport
 
       plugin.tasks.each do |task|
         case task
+        when :db
+          RedminePluginSupport::DatabaseTask.new(:db)
         when :doc
           RedminePluginSupport::RDocTask.new(:doc)
         when :spec
@@ -55,6 +60,10 @@ module RedminePluginSupport
           RedminePluginSupport::CucumberTask.new(:features)
         when :release
           RedminePluginSupport::ReleaseTask.new(:release)
+        when :stats
+          RedminePluginSupport::StatsTask.new(:stats)
+        when :metrics
+          RedminePluginSupport::MetricsTask.new(:metrics)
         when :clean
           require 'rake/clean'
           CLEAN.include('**/semantic.cache', "**/#{plugin.project_name}.zip", "**/#{plugin.project_name}.tar.gz")

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 0
-  - 3
-  version: 0.0.3
+  - 4
+  version: 0.0.4
 platform: ruby
 authors: 
 - Eric Davis
@@ -39,7 +39,7 @@ extra_rdoc_files:
 - LICENSE
 - README.rdoc
 files: 
-- .gitignore
+- CHANGES.rdoc
 - History.txt
 - LICENSE
 - Manifest.txt
@@ -49,18 +49,16 @@ files:
 - VERSION
 - lib/redmine_plugin_support.rb
 - lib/redmine_plugin_support/cucumber_task.rb
+- lib/redmine_plugin_support/database_task.rb
 - lib/redmine_plugin_support/environment_task.rb
 - lib/redmine_plugin_support/general_task.rb
+- lib/redmine_plugin_support/metrics_task.rb
 - lib/redmine_plugin_support/rdoc_task.rb
 - lib/redmine_plugin_support/redmine_helper.rb
 - lib/redmine_plugin_support/release_task.rb
 - lib/redmine_plugin_support/rspec_task.rb
+- lib/redmine_plugin_support/stats_task.rb
 - lib/redmine_plugin_support/test_unit_task.rb
-- redmine_plugin_support.gemspec
-- script/console
-- script/destroy
-- script/generate
-- tasks/rspec.rake
 - test/redmine_plugin_support_test.rb
 - test/test_helper.rb
 has_rdoc: true

data/.gitignore

@@ -1,5 +0,0 @@
-*.sw?
-.DS_Store
-coverage
-rdoc
-pkg

data/redmine_plugin_support.gemspec

@@ -1,69 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{redmine_plugin_support}
-  s.version = "0.0.3"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Eric Davis"]
-  s.date = %q{2010-05-10}
-  s.description = %q{This libarary is a collection of rake tasks and other scripts that will make Redmine plugin development easier.}
-  s.email = %q{edavis@littlestreamsoftware.com}
-  s.extra_rdoc_files = [
-    "LICENSE",
-     "README.rdoc"
-  ]
-  s.files = [
-    ".gitignore",
-     "History.txt",
-     "LICENSE",
-     "Manifest.txt",
-     "PostInstall.txt",
-     "README.rdoc",
-     "Rakefile",
-     "VERSION",
-     "lib/redmine_plugin_support.rb",
-     "lib/redmine_plugin_support/cucumber_task.rb",
-     "lib/redmine_plugin_support/environment_task.rb",
-     "lib/redmine_plugin_support/general_task.rb",
-     "lib/redmine_plugin_support/rdoc_task.rb",
-     "lib/redmine_plugin_support/redmine_helper.rb",
-     "lib/redmine_plugin_support/release_task.rb",
-     "lib/redmine_plugin_support/rspec_task.rb",
-     "lib/redmine_plugin_support/test_unit_task.rb",
-     "redmine_plugin_support.gemspec",
-     "script/console",
-     "script/destroy",
-     "script/generate",
-     "tasks/rspec.rake",
-     "test/redmine_plugin_support_test.rb",
-     "test/test_helper.rb"
-  ]
-  s.homepage = %q{http://github.com/edavis10/redmine_plugin_support}
-  s.rdoc_options = ["--charset=UTF-8"]
-  s.require_paths = ["lib"]
-  s.rubyforge_project = %q{redmine_plugin_support}
-  s.rubygems_version = %q{1.3.6}
-  s.summary = %q{Libraries to automate the creation and management of Redmine plugins}
-  s.test_files = [
-    "test/test_helper.rb",
-     "test/redmine_plugin_support_test.rb"
-  ]
-
-  if s.respond_to? :specification_version then
-    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
-    else
-      s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
-  end
-end
-

data/script/console

@@ -1,10 +0,0 @@
-#!/usr/bin/env ruby
-# File: script/console
-irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
-
-libs =  " -r irb/completion"
-# Perhaps use a console_lib to store any extra methods I may want available in the cosole
-# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
-libs <<  " -r #{File.dirname(__FILE__) + '/../lib/redmine_plugin_support.rb'}"
-puts "Loading redmine_plugin_support gem"
-exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
-
-begin
-  require 'rubigen'
-rescue LoadError
-  require 'rubygems'
-  require 'rubigen'
-end
-require 'rubigen/scripts/destroy'
-
-ARGV.shift if ['--help', '-h'].include?(ARGV[0])
-RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
-RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -1,14 +0,0 @@
-#!/usr/bin/env ruby
-APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
-
-begin
-  require 'rubigen'
-rescue LoadError
-  require 'rubygems'
-  require 'rubigen'
-end
-require 'rubigen/scripts/generate'
-
-ARGV.shift if ['--help', '-h'].include?(ARGV[0])
-RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
-RubiGen::Scripts::Generate.new.run(ARGV)

data/tasks/rspec.rake

@@ -1,21 +0,0 @@
-begin
-  require 'spec'
-rescue LoadError
-  require 'rubygems'
-  require 'spec'
-end
-begin
-  require 'spec/rake/spectask'
-rescue LoadError
-  puts <<-EOS
-To use rspec for testing you must install rspec gem:
-    gem install rspec
-EOS
-  exit(0)
-end
-
-desc "Run the specs under spec/models"
-Spec::Rake::SpecTask.new do |t|
-  t.spec_opts = ['--options', "spec/spec.opts"]
-  t.spec_files = FileList['spec/**/*_spec.rb']
-end