refinerycms 0.9.8.9 → 0.9.9

data/base/lib/base.rb

@@ -0,0 +1,32 @@
+require 'refinery'
+
+module Refinery
+
+  module Base
+    class << self
+    end
+
+    class Engine < Rails::Engine
+
+      config.autoload_paths += %W( #{config.root}/lib )
+
+      config.before_configuration do
+      end
+
+      config.to_prepare do
+      end
+
+      config.after_initialize do
+        ::Refinery::Plugin.register do |plugin|
+          plugin.name = "refinerycms_base"
+          plugin.class_name ="RefineryBaseEngine"
+          plugin.version = Refinery.version.to_s
+          plugin.hide_from_menu = true
+          plugin.always_allow_access = true
+          plugin.menu_match = /(refinery|admin)\/(refinery_base)$/
+        end
+      end
+    end
+  end
+
+end

data/base/lib/generators/refinerycms_base_generator.rb

@@ -0,0 +1,8 @@
+require 'refinery/generators'
+
+class RefinerycmsBase < ::Refinery::Generators::EngineInstaller
+
+  source_root File.expand_path('../../../', __FILE__)
+  engine_name "base"
+
+end

data/base/lib/refinery.rb

@@ -0,0 +1,32 @@
+require 'rbconfig'
+
+module Refinery
+
+  WINDOWS = !!(RbConfig::CONFIG["host_os"] =~ %r!(msdos|mswin|djgpp|mingw)!) unless defined? WINDOWS
+
+  autoload :Version, File.expand_path('../refinery/version', __FILE__)
+
+  class << self
+    attr_accessor :root, :s3_backend, :base_cache_key, :rescue_not_found
+
+    def root
+      @root ||= Pathname.new(File.expand_path('../../../', __FILE__))
+    end
+
+    def s3_backend
+      @s3_backend ||= false
+    end
+
+    def base_cache_key
+      @base_cache_key ||= :refinery
+    end
+
+    def rescue_not_found
+      !!@rescue_not_found
+    end
+
+    def version
+      ::Refinery::Version.to_s
+    end
+  end
+end

data/base/lib/refinery/version.rb

@@ -0,0 +1,16 @@
+module Refinery
+  class Version
+    @major = 0
+    @minor = 9
+    @tiny  = 9
+    @build = nil
+
+    class << self
+      attr_reader :major, :minor, :tiny, :build
+
+      def to_s
+        [@major, @minor, @tiny, @build].compact.join('.')
+      end
+    end
+  end
+end

data/base/license.md

@@ -0,0 +1,21 @@
+# MIT License
+ 
+Copyright (c) 2005-2010 [Resolve Digital](http://www.resolvedigital.com)
+ 
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+ 
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+ 
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/base/refinerycms-base.gemspec

@@ -0,0 +1,18 @@
+require File.expand_path(File.join(*%w[.. .. lib refinery.rb]), __FILE__)
+version = Refinery.version
+
+Gem::Specification.new do |s|
+  s.platform    = Gem::Platform::RUBY
+  s.name        = 'refinerycms-base'
+  s.version     = version
+  s.summary     = 'Base engine for Refinery CMS'
+  s.description = 'Ruby on Rails Base engine for Refinery CMS'
+  s.required_ruby_version = '>= 1.8.7'
+
+  s.email       = %q{info@refinerycms.com}
+  s.homepage    = %q{http://refinerycms.com}
+  s.authors     = ['Resolve Digital', 'David Jones', 'Philip Arndt']
+
+  s.files       = Dir['**/*'] - Dir['*.gemspec']
+  s.require_path = 'lib'
+end

data/bin/refinerycms

@@ -16,7 +16,18 @@ require 'fileutils'
 require 'optparse'
 
 # Load refinerycms
-require Pathname.new(File.expand_path(File.dirname(__FILE__) << "/..")).join('vendor', 'refinerycms', 'refinery.rb')
+require Pathname.new(File.expand_path(File.dirname(__FILE__) << "/..")).join('lib', 'refinery')
+
+class String
+  def blank?
+    self.nil? or self.length == 0
+  end
+end
+class NilClass
+  def blank?
+    true
+  end
+end
 
 module Refinery
   class AppGenerator
@@ -30,8 +41,12 @@ module Refinery
           :username => 'root',
           :password => ''
         },
+        :from_version => '0.9.8',
         :force => false,
         :heroku => false,
+        :duostack => false,
+        :update => false,
+        :confirm => false,
         :gems => []
       }
 
@@ -64,10 +79,26 @@ module Refinery
           @options[:force] = true
         end
 
+        opts.on("--from-version VERSION", String, "Set the version that we are updating from, incase there are special files that need to change", "  (default '0.9.8')") do |version|
+          @options[:from_version] = version
+        end
+
         opts.on("--heroku [APP_NAME]", "Set up and deploy to Heroku") do |app_name|
           @options[:heroku] = app_name || ''
         end
 
+        opts.on("--duostack APP_NAME", String, "Set up and deploy to Duostack") do |app_name|
+          @options[:duostack] = app_name
+        end
+
+        opts.on("--update", "--update", "Migrate the database instead of rebuilding it") do
+           @options[:update] = true
+        end
+
+        opts.on("-c", "--confirm", "Confirm any prompts that require input") do
+          @options[:confirm] = true
+        end
+
         opts.separator ""
         opts.separator "Common options:"
 
@@ -87,17 +118,33 @@ module Refinery
       # Grab input and ensure that the path doesn't exist already and other checks.
       validate!
 
-      # Generate a Refinery CMS application
-      generate!
+      unless @options[:update]
+        # Generate a Refinery CMS application
+        generate!
+
+        # Bundle the application which activates Refinery CMS
+        bundle!
 
-      # Add in the Refinery specifics to the application
-      refine!
+        # Ensure the database exists so that queries like .table_exists? don't fail.
+        run_command("rake -f \"#{@app_path.join('Rakefile')}\" db:create")
+      else
+        # Update the current application.
+        update!
+
+        # Bundle the application which activates Refinery CMS
+        bundle!
+      end
+
+      # Run the newly activated Refinery CMS generator.
+      run_command("rails generate refinerycms#{' --update' if @options[:update]}", {:cd => true})
+
+      # Run the update task if we're updating
+      run_command("rake refinery:update", {:cd => true}) if @options[:update]
 
       # Output helpful messages to user
       output!
     end
 
-
     def validate!
       # Check for valid input
       begin
@@ -121,119 +168,171 @@ module Refinery
       @app_path = Pathname.new(File.expand_path(@input.first))
       @app_name = @app_path.to_s.split(File::SEPARATOR).last
 
-      if @app_path.directory? and @options[:force] == false
+      if @app_path.directory? and @options[:force] == false and @options[:update] == false
         puts "The directory '#{@app_path}' that you specified already exists."
         puts "Use --force to overwrite an existing directory."
+        puts "Use --update to replace any Refinery CMS files in an existing installation."
         exit
+      elsif @app_path.join('.git').directory? && @options[:update] && !@options[:confirm]
+        git_status = run_command('git status --porcelain', :puts => false)
+        if git_status.to_s.strip.length > 0
+          puts "\nYou have uncommitted changes or untracked files. Please remove or commit them, or:"
+          puts "Use --confirm to have Refinery proceed anyway. "
+          puts "Untracked files will be removed, and uncommitted changes may be lost.\n\n"
+          exit
+        end
       end
     end
 
-    def generate!
-      # Generate a rails application
+    def update!
       rails_command = "rails new \"#{@app_path}\""
+      rails_command << (@options[:from_version] !~ %r{^0.9.8} ? ' --skip' : ' --force')
       rails_command << " --database #{@options[:database][:adapter]}"
-      rails_command << " --force" if @options[:force]
-      rails_command << " --skip-test-unit --skip-prototype"
-      run_command(rails_command, {:cd => false})
-      abort "Generating Rails application failed. Exiting..." unless $?.success?
-    end
-
-    def refine!
-      # Overwrite rails defaults with refinery defaults
-      %w(app db).each do |folder|
-        FileUtils::cp_r Refinery.root.join(folder), @app_path, :verbose => false
+      skips = %w(active-record gemfile git javascript prototype test-unit)
+      skips.each do |skip|
+        rails_command << " --skip-#{skip}"
       end
 
-      # Copy in important files to the Rails app.
-      %w(.gitignore readme.md license.md config/routes.rb config/settings.rb config/environments/production.rb
-          config/initializers/acts_as_indexed_config.rb config/initializers/field_with_error_fix.rb
-          config/initializers/fix_rack.rb).each do |file|
-        FileUtils::cp_r Refinery.root.join(file), @app_path.join(file), :verbose => false if Refinery.root.join(file).exist?
-      end
+      # Generate a new rails application in this directory
+      generate!(rails_command)
 
-      # Copy stylesheets so they're ready to use.
-      %w(application.css formatting.css home.css).map{|stylesheet|
-        Refinery.root.join('vendor', 'refinerycms', 'core', 'public', 'stylesheets', stylesheet)
-      }.each do |stylesheet|
-        FileUtils::cp stylesheet.to_s,
-                      @app_path.join('public', 'stylesheets').to_s,
-                      :verbose => false if stylesheet.file?
-      end
+      # Clean the directory of all new files from rails that we don't want
+      run_command('git clean -f -d') if @app_path.join('.git').directory?
+    end
 
-      # Remove default application layout, README, and public/index.html
-      %w(README app/views/layouts/application.html.erb public/index.html).each do |remove|
-	      FileUtils::rm @app_path.join(remove) if @app_path.join(remove).exist?
+    def generate!(rails_command = nil)
+      if rails_command.blank?
+        # Generate a rails application
+        rails_command = "rails new \"#{@app_path}\""
+        rails_command << " --database #{@options[:database][:adapter]}"
+        rails_command << " --force" if @options[:force]
+        rails_command << " --skip-test-unit --skip-prototype"
       end
+      run_command(rails_command, {:cd => false})
+      abort "Generating Rails application failed. Exiting..." unless $?.success?
+    end
 
+    def bundle!
       # Add refinery gems to the Gemfile
-      gemfile_contents = File.read(Refinery.root.join('Gemfile'))
+      gemfile_contents = Refinery.root.join('Gemfile').read
       refinery_gems = gemfile_contents.match(/# REFINERY CMS =+.*# END REFINERY CMS =+/m)[0]
-      File.open(@app_path.join('Gemfile'), "a") do |f|
-        f.write "\n" + refinery_gems + "\n\n# USER DEFINED\n" + @options[:gems].join("\n") + "\n# END USER DEFINED"
+      refinery_user_defined_gems = gemfile_contents.match(/# USER DEFINED(.*)# END USER DEFINED/m)
+      refinery_user_defined_gems = refinery_user_defined_gems[1] unless refinery_user_defined_gems.nil?
+      app_gemfile = @app_path.join('Gemfile')
+      FileUtils::cp app_gemfile, "#{app_gemfile}.backup"
+      unless @options[:update]
+        app_gemfile.open('a') do |f|
+          f.write "\n#{refinery_gems}\n"
+          @options[:gems] = ([refinery_user_defined_gems] | [@options[:gems]]).flatten.compact
+
+          f.write "\n# USER DEFINED\n#{@options[:gems].join("\n")}\n# END USER DEFINED" if @options[:gems].any?
+        end
+      else
+        # Now find all user defined gems before we go changing anything.
+        user_defined_gems = app_gemfile.read.match(/# USER DEFINED(.*)# END USER DEFINED/m)
+        user_defined_gems = user_defined_gems[1].to_s.strip unless user_defined_gems.nil?
+
+        # If the user is updating to this version from a version that defined user defined gems
+        # in the "# REFINERY CMS " section then we need to salvage them.
+        incorrectly_core_gems = app_gemfile.read.match(/# REFINERY CMS =+.*(# Specify additional Refinery.*)# END REFINERY CMS =+/m)
+        unless incorrectly_core_gems.nil?
+          incorrectly_core_gems = incorrectly_core_gems[1].to_s.strip
+          # stop before any new groups appear.
+          incorrectly_core_gems_take_two = incorrectly_core_gems.match(/(# Specify additional Refinery.*)group ?:?/m)
+          incorrectly_core_gems = incorrectly_core_gems_take_two[1].to_s.strip unless incorrectly_core_gems_take_two.nil?
+        end
+
+        unless incorrectly_core_gems.blank?
+          # wipe the gems from the gemfile in their current position
+          # they will be reintroduced in the next step.
+          find_and_replace(app_gemfile, incorrectly_core_gems, '')
+        end
+
+        # If the user hasn't defined any gems then use the refinery ones.
+        refinery_user_defined_gems = user_defined_gems.to_s.strip.blank? ? [refinery_user_defined_gems] : []
+        refinery_user_defined_gems |= [user_defined_gems, incorrectly_core_gems].reject{|g| g.to_s.strip.blank?}.compact.flatten
+
+        # Unless all sets of gems are blank we want to overwrite the section.
+        unless refinery_user_defined_gems.length == 0
+          # Manage double ups so that earlier rules are kept (can't use uniq because it strips blank lines)
+          # sorted by order of precedence (so we have to reverse the array)
+          refinery_user_defined_gems = refinery_user_defined_gems.join('').split("\n").reverse
+          refinery_user_defined_gems.reject! do |g|
+            # Ignoring blank lines because we want to keep them,
+            g != '' && (
+              (refinery_user_defined_gems.count{|line| line == g} > 1) || # Delete where there's another line like this.
+              (g =~ %r{^(# +)?( +)?gem} && (refinery_user_defined_gems.count{|line| line.split(',').first == g.split(',').first} > 1))
+            )
+          end
+
+          # Use any gems specified, too, ensuring we restore the sort order of refinery_user_defined_gems.
+          @options[:gems] = refinery_user_defined_gems.reverse + @options[:gems]
+          gems_to_insert = "# USER DEFINED\n#{@options[:gems].join("\n")}\n\n# END USER DEFINED"
+          unless user_defined_gems.nil?
+            find_and_replace(app_gemfile, /# USER DEFINED.*# END USER DEFINED/m, gems_to_insert)
+          else
+            app_gemfile.open('a') {|f| f.write "\n\n#{gems_to_insert}" }
+          end
+        end
+
+        # replace existing core dependencies with the current set of dependencies.
+        find_and_replace(app_gemfile, /# REFINERY CMS =+.*# END REFINERY CMS =+/m, refinery_gems)
       end
 
       # Override database username and password
-      find_and_replace('config/database.yml', %r{username:.*}, "username: #{@options[:database][:username]}")
-      find_and_replace('config/database.yml', %r{password:.*}, "password: #{@options[:database][:password]}")
+      unless @options[:update]
+        # Override username and password
+        find_and_replace('config/database.yml', %r{username:.*}, "username: #{@options[:database][:username]}")
+        find_and_replace('config/database.yml', %r{password:.*}, "password: #{@options[:database][:password]}")
+      end
 
       # Specify the correct version of the Refinery CMS gem (may be git source).
-      src = Refinery.version !~ /\.pre$/ ? "'~> #{Refinery.version}'" : ":git => 'git://github.com/resolve/refinerycms.git'"
-      find_and_replace('Gemfile', "gem 'refinerycms',              :path => '.'",
-                        "gem 'refinerycms',              #{src}")
+      src = Refinery.version !~ /\.pre$/ ? "'= #{Refinery.version}'" : ":git => 'git://github.com/resolve/refinerycms'"
+      find_and_replace('Gemfile', %r{gem 'refinerycms',.*}, "gem 'refinerycms',              #{src}")
 
       # Add in AWS-S3 for Heroku
       find_and_replace('Gemfile', "# gem 'aws-s3', :require => 'aws/s3'",
                         "gem 'aws-s3', :require => 'aws/s3'") if @options[:heroku]
 
-      # Replace app constant with Refinery
-      # TODO: Find a way around this
-      camelized_app_name = @app_name.gsub(/\W/, '_').squeeze('_').gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-      camelized_app_name << "::Application" # We only want to replace occurances like App::Application.
-      %w(Rakefile config.ru config/application.rb config/environment.rb
-          config/environments/development.rb config/environments/production.rb config/environments/test.rb
-          config/initializers/secret_token.rb config/initializers/session_store.rb).each do |hackable|
-        find_and_replace(hackable, camelized_app_name, 'Refinery::Application')
-        find_and_replace(hackable, "module #{camelized_app_name.split('::').first}", 'module Refinery')
-      end
-
-      # Remove development specific stuff from the .gitinore file
-      find_and_replace('.gitignore',
-                       /# REFINERY CMS DEVELOPMENT =+.*# END REFINERY CMS DEVELOPMENT =+/m, '')
-    end
-
-    def output!
       puts "\n---------"
       puts "Refinery successfully installed in '#{@app_path}'!\n\n"
 
       # Automate
       # TODO: Check exit codes to see whether or not these worked
       puts "Installing gem requirements using bundler..\n"
+
+      # Ensure RefineryCMS is up to date if we're updating
+      run_command("bundle update refinerycms refinerycms-generators") if @options[:update]
+
+      # Install!
       run_command("bundle install")
+    end
 
-      # sqlite3 requires we use 'db:migrate' etc instead of 'db:setup'
-      puts "\n\nSetting up your development database..\n"
-      tasks = @options[:database][:adapter] == 'sqlite3' ? %w(db:migrate db:seed) : %w(db:setup)
-      tasks.each do |task|
-        run_command("rake -f \"#{@app_path.join('Rakefile')}\" #{task}")
-      end
+    def output!
+      puts "\n\n#{@options[:update] ? "Migrating" : "Setting up"} your development database..\n"
+      run_command("rake -f \"#{@app_path.join('Rakefile')}\" db:migrate")
 
       # Deploy to Heroku
-      if @options[:heroku]
+      hosting = nil
+      hosting = "Heroku" if @options[:heroku]
+      hosting = "Duostack" if @options[:duostack]
+      unless hosting.nil?
         puts "\n\nInitializing and committing to git..\n"
         run_command("git init && git add . && git commit -am 'Initial Commit'")
 
-        puts "\n\nCreating Heroku app..\n"
-        run_command("heroku create #{@options[:heroku]}")
+        puts "\n\nCreating #{hosting} app..\n"
+        run_command("#{hosting.downcase} create #{@options[:heroku] || @options[:duostack]}")
 
-        puts "\n\nPushing to Heroku (this takes time, be patient)..\n"
-        run_command("git push heroku master")
+        puts "\n\nPushing to #{hosting} (this takes time, be patient)..\n"
+        run_command("git push #{hosting.downcase} master")
 
-        puts "\n\nSetting up the Heroku database..\n"
-        run_command("heroku rake db:migrate")
-        run_command("heroku rake db:seed")
+        puts "\n\nSetting up the #{hosting} database..\n"
+        run_command("#{hosting.downcase} rake db:setup")
 
-        puts "\n\nRestarting servers...\n"
-        run_command("heroku restart")
+        if @options[:heroku]
+          puts "\n\nRestarting servers...\n"
+          run_command("#{hosting.downcase} restart")
+        end
       end
       # End automation
 
@@ -254,7 +353,7 @@ module Refinery
       puts "---------\n\n"
     end
 
-    private :validate!, :generate!, :refine!, :output!
+    private :validate!, :generate!, :bundle!, :output!
 
     def run_command(command, options = {})
       options = {:cd => true, :puts => true}.merge(options)
@@ -268,16 +367,20 @@ module Refinery
 
       to_run = to_run.join(' ')
 
+      output = []
       if options[:puts]
         puts "Running: #{to_run}"
         IO.popen(to_run) do |t|
           while (line = t.gets)
+            output << line
             puts line
           end
         end
       else
-        `#{to_run}`
+        output << `#{to_run}`
       end
+
+      output.join("\n")
     end
 
     def find_and_replace(file, find, replace)
@@ -291,4 +394,4 @@ module Refinery
   end
 end
 
-Refinery::AppGenerator.new(ARGV).run!
+Refinery::AppGenerator.new(ARGV).run! if $0 =~ %r{refinerycms$}