dreamcat4-moonshadow 0.0.1

data/LICENSE

@@ -0,0 +1,165 @@
+       GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions. 
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version. 
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.

data/app_generators/moonshine/moonshine_generator.rb

@@ -0,0 +1,154 @@
+require 'tempfile'
+class MoonshineGenerator < RubiGen::Base
+  attr_reader :file_name, :klass_name, :is_rails_app, :moonshine_version
+
+  def initialize(runtime_args, runtime_options = {})
+    super
+    @destination_root = args.shift
+    @file_name = "application_manifest"
+    @klass_name = @file_name.classify
+    @is_rails_app = detect_rails
+    gem 'moonshine'
+    @moonshine_version = Gem.loaded_specs["moonshine"].version.to_s
+  end
+
+  # Override with your own usage banner.
+  def banner
+    "Usage: #{$0} <path> [options]"
+  end
+
+  def manifest
+    recorded_session = record do |m|
+      directories(m)
+      m.template  'readme.templates', 'app/manifests/templates/README'
+      m.template  'Capfile', 'Capfile'
+      m.template  "#{application_type}/moonshine.yml", "config/moonshine.yml"
+      m.template  "#{application_type}/moonshine.rake", 'lib/tasks/moonshine.rake'
+      m.template  'rails/gems.yml', 'config/gems.yml', :assigns => { :gems => gems } if is_rails_app
+      generate_or_upgrade_manifest(m)
+      generate_or_upgrade_deploy(m)
+    end
+    intro
+    recorded_session
+  end
+
+protected
+
+  def intro
+    intro = <<-INTRO
+
+After the Moonshine generator finishes don't forget to:
+
+- Edit config/moonshine.yml
+Use this file to manage configuration related to deploying and running the app: 
+domain name, git repos, package dependencies for gems, and more.
+
+- Edit app/manifests/#{file_name}.rb
+Use this to manage the configuration of everything else on the server:
+define the server 'stack', cron jobs, mail aliases, configuration files 
+
+    INTRO
+    puts intro if File.basename($0) == 'generate'
+  end
+
+  def detect_rails
+    begin
+      require File.expand_path(File.join(destination_root, 'config/environment.rb'))
+    rescue LoadError
+      false
+    else
+      true
+    end
+  end
+
+  def application_type
+    is_rails_app ? 'rails' : 'standalone'
+  end
+
+  def gems
+    gem_array = returning Array.new do |hash|
+      Rails.configuration.gems.map do |gem|
+        hash = { :name => gem.name }
+        hash.merge!(:source => gem.source) if gem.source
+        hash.merge!(:version => gem.requirement.to_s) if gem.requirement
+        hash
+      end if Rails.respond_to?( 'configuration' )
+    end
+    if (RAILS_GEM_VERSION rescue false)
+      gem_array << {:name => 'rails', :version => RAILS_GEM_VERSION }
+    else
+      gem_array << {:name => 'rails'}
+    end
+    gem_array
+  end
+
+  def directories(m)
+    m.directory 'app'
+    m.directory 'app/manifests'
+    m.directory 'app/manifests/templates'
+    m.directory 'config'
+    m.directory 'lib'
+    m.directory 'lib/tasks'
+  end
+
+  #generate or upgrade app/manifests/#{file_name}.rb
+  def generate_or_upgrade_manifest(m)
+    if File.exists?(destination_path("app/manifests/#{file_name}.rb"))
+      if File.read(destination_path("app/manifests/#{file_name}.rb")) =~ /vendor\/plugins\/moonshine/
+        gsub_file "app/manifests/#{file_name}.rb", /^.*vendor\/plugins\/moonshine.*$/mi do |match|
+          "#{moonshine_gem_string}\nrequire 'moonshine'\n"
+        end
+      else
+        gsub_file "app/manifests/#{file_name}.rb", /^gem 'moonshine'.*$/mi do |match|
+          moonshine_gem_string
+        end
+      end
+    else
+      m.template  "#{application_type}/manifest.rb", "app/manifests/#{file_name}.rb", :assigns => { :moonshine_gem_string => moonshine_gem_string }
+    end
+  end
+
+  #generate or upgrade config/deploy.rb
+  def generate_or_upgrade_deploy(m)
+    if File.exists?(destination_path('config/deploy.rb'))
+      if File.read(destination_path('config/deploy.rb')) =~ /moonshine\/capistrano/
+        gsub_file 'config/deploy.rb', /^gem 'moonshine'.*$/mi do |match|
+          moonshine_gem_string
+        end
+      else
+        File.prepend(destination_path('config/deploy.rb'), "#{moonshine_gem_string}\nrequire 'moonshine/capistrano'\n")
+      end
+    else
+      m.template  "#{application_type}/deploy.rb", 'config/deploy.rb', :assigns => { :moonshine_gem_string => moonshine_gem_string }
+    end
+  end
+
+  def moonshine_gem_string
+    "gem 'moonshine', '= #{moonshine_version}'"
+  end
+
+  def gsub_file(relative_destination, regexp, *args, &block)
+    path = destination_path(relative_destination)
+    content = File.read(path).gsub(regexp, *args, &block)
+    File.open(path, 'wb') { |file| file.write(content) }
+  end
+
+end
+
+class File
+  def self.prepend(path, string)
+    Tempfile.open File.basename(path) do |tempfile|
+      # prepend data to tempfile
+      tempfile << string
+
+      File.open(path, 'r+') do |file|
+        # append original data to tempfile
+        tempfile << file.read
+        # reset file positions
+        file.pos = tempfile.pos = 0
+        # copy all data back to original file
+        file << tempfile.read
+      end
+    end
+  end
+end

data/app_generators/moonshine/templates/Capfile

@@ -0,0 +1,3 @@
+load 'deploy' if respond_to?(:namespace) # cap2 differentiator
+Dir['vendor/plugins/*/recipes/*.rb'].each { |plugin| load(plugin) }
+load 'config/deploy'

data/app_generators/moonshine/templates/rails/deploy.rb

@@ -0,0 +1,3 @@
+<%= moonshine_gem_string %>
+require 'moonshine/capistrano'
+server "moonshine-managed-server.com", :app, :web, :db, :primary => true

data/app_generators/moonshine/templates/rails/gems.yml

@@ -0,0 +1 @@
+<%= gems.to_yaml %>

data/app_generators/moonshine/templates/rails/manifest.rb

@@ -0,0 +1,55 @@
+<%= moonshine_gem_string %>
+require 'moonshine'
+class <%= klass_name %> < Moonshine::Manifest::Rails
+  # The majority of your configuration should be in <tt>config/moonshine.yml</tt>
+  # If necessary, you may provide extra configuration directly in this class 
+  # using the configure method. The hash passed to the configure method is deep 
+  # merged with what is in <tt>config/moonshine.yml</tt>. This could be used, 
+  # for example, to store passwords and/or private keys outside of your SCM, or 
+  # to query a web service for configuration data.
+  #
+  # In the example below, the value configuration[:custom][:random] can be used in 
+  # your moonshine settings or templates.
+  #
+  # require 'net/http'
+  # require 'json'
+  # random = JSON::load(Net::HTTP.get(URI.parse('http://twitter.com/statuses/public_timeline.json'))).last['id']
+  # configure({
+  #   :custom => { :random => random  }
+  # })
+
+  # The default_stack recipe install Rails, Apache, Passenger, the database from 
+  # database.yml, Postfix, Cron, logrotate and NTP. See lib/moonshine/manifest/rails.rb
+  # for details. To customize, remove this recipe and specify the components you want.
+  recipe :default_stack
+
+  # Add your application's custom requirements here
+  def application_packages
+    # If you've already told Moonshine about a package required by a gem with
+    # :apt_gems in <tt>moonshine.yml</tt> you do not need to include it here.
+    # package 'some_native_package', :ensure => :installed
+    
+    # some_rake_task = "/usr/bin/rake -f #{configuration[:deploy_to]}/current/Rakefile custom:task RAILS_ENV=#{ENV['RAILS_ENV']}"
+    # cron 'custom:task', :command => some_rake_task, :user => configuration[:user], :minute => 0, :hour => 0
+    
+    # %w( root rails ).each do |user|
+    #   mailalias user, :recipient => 'you@domain.com'
+    # end
+    
+    # farm_config = <<-CONFIG
+    #   MOOCOWS = 3
+    #   HORSIES = 10
+    # CONFIG
+    # file '/etc/farm.conf', :ensure => :present, :content => farm_config
+    
+    # Logs for Rails, MySQL, and Apache are rotated by default
+    # logrotate '/var/log/some_service.log', :options => %w(weekly missingok compress), :postrotate => '/etc/init.d/some_service restart'
+    
+    # Only run the following on the 'testing' stage using capistrano-ext's multistage functionality.
+    # on_stage 'testing' do
+    #   file '/etc/motd', :ensure => :file, :content => "Welcome to the TEST server!"
+    # end
+  end
+  # The following line includes the 'application_packages' recipe defined above
+  recipe :application_packages
+end

data/app_generators/moonshine/templates/rails/moonshine.rake

@@ -0,0 +1,83 @@
+namespace :moonshine do
+
+  namespace :db do
+    desc "Bootstrap the database with fixtures from db/boostrap."
+    task :bootstrap => :environment do
+      require 'active_record/fixtures'
+      ActiveRecord::Base.establish_connection(Rails.env)
+      fixtures_dir = File.join(Rails.root, 'db/bootstrap/')
+      Dir.glob(File.join(fixtures_dir, '*.{yml,csv}')).each do |fixture_file|
+        Fixtures.create_fixtures(File.dirname(fixture_file), File.basename(fixture_file, '.*'))
+      end
+    end
+
+    desc "Create fixtures in db/bootstrap. Specify tables with FIXTURES=x,y otherwise all will be created."
+    task :dump => :environment do
+      sql = "SELECT * FROM %s"
+      skip_tables = [ "schema_info", "sessions", "schema_migrations" ]
+      ActiveRecord::Base.establish_connection
+      tables = ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/) : ActiveRecord::Base.connection.tables - skip_tables
+
+      tables.each do |table_name|
+        i = "0000"
+        File.open("#{RAILS_ROOT}/db/bootstrap/#{table_name}.yml", 'w') do |file|
+          data = ActiveRecord::Base.connection.select_all(sql % table_name)
+          file.write data.inject({}) { |hsh, record|
+            hsh["#{table_name}_#{i.succ!}"] = record
+            hsh
+          }.to_yaml
+        end
+      end
+    end
+  end
+
+  namespace :app do
+    desc "Overwrite this task in your app if you have any bootstrap tasks that need to be run"
+    task :bootstrap do
+      #
+    end
+  end
+
+  desc <<-DOC
+  Attempt to bootstrap this application. In order, we run:
+
+    rake db:schema:load (if db/schema.rb exists)
+    rake db:migrate (if db/migrate exists)
+    rake moonshine:db:bootstrap (if db/bootstrap/ exists)
+    rake moonshine:app:bootstrap
+
+  All of this assumes one things. That your application can run 'rake
+  environment' with an empty database. Please ensure your application can do
+  so!
+  DOC
+  task :bootstrap do
+    Rake::Task["db:schema:load"].invoke if File.exist?("db/schema.rb")
+    Rake::Task["environment"].invoke
+    Rake::Task["db:migrate"].invoke if File.exist?("db/migrate")
+    Rake::Task["moonshine:db:bootstrap"].invoke if File.exist?("db/bootstrap")
+    Rake::Task["moonshine:app:bootstrap"].invoke
+  end
+
+  desc "Update config/moonshine.yml with a list of the required gems"
+  task :gems => 'gems:base' do
+    gem_array = Rails.configuration.gems.reject(&:frozen?).map do |gem|
+      hash = { :name => gem.name }
+      hash.merge!(:source => gem.source) if gem.source
+      hash.merge!(:version => gem.requirement.to_s) if gem.requirement
+      hash
+    end
+    if (RAILS_GEM_VERSION rescue false)
+      gem_array << {:name => 'rails', :version => RAILS_GEM_VERSION }
+    else
+      gem_array << {:name => 'rails'}
+    end
+    config_path = File.join(Dir.pwd, 'config', 'gems.yml')
+    File.open( config_path, 'w' ) do |out|
+      YAML.dump(gem_array, out )
+    end
+    puts "config/gems.yml has been updated with your application's gem"
+    puts "dependencies. Please commit these changes to your SCM or upload"
+    puts "them to your server with the cap local_config:upload command."
+  end
+
+end