cambium 0.2.2 → 0.3.0

data/lib/generators/cambium/install/app_generator.rb

@@ -1,5 +1,6 @@
 require 'rake'
 require 'rails/generators'
+require File.expand_path('../../helpers/_autoloader.rb', __FILE__)
 
 module Cambium
   module Install
@@ -8,27 +9,34 @@ module Cambium
 
       source_root File.expand_path('../../templates', __FILE__)
 
-      # ------------------------------------------ Default Public Controller
-
+      # Add a default public controller, so we have a working home page when
+      # we're done.
+      # 
       def add_home_controller
-        run_cmd "#{g} controller home index"
+        generate "controller home index"
+        gsub_file("config/routes.rb", /\ \ get\ \'home\/index\'\n\n/, '')
       end
 
-      # ------------------------------------------ Routes
-
+      # Add our default routes, ommitting admin routes (which are added via the
+      # admin generator)
+      # 
       def add_default_routes
-        remove_file "config/routes.rb"
-        template "config/routes.rb.erb", "config/routes.rb"
+        insert_into_file(
+          "config/routes.rb",
+          file_contents("config/app_routes.rb"),
+          :after => "Rails.application.routes.draw do"
+        )
       end
 
-      # ------------------------------------------ Public Views
-
+      # Add our default public views
+      # 
       def add_public_views
-        directory "app/views/application", "app/views/application"
+        directory "app/views/application"
+        directory "app/views/home", :force => true
       end
 
-      # ------------------------------------------ Layouts
-
+      # Our layouts are templated so we can start with some custom information.
+      # 
       def add_layouts
         @site_title = Rails.application.class.parent_name.humanize.titleize
         site_title = ask "\n#{set_color('App Title:', :green, :bold)} [default: #{@site_title}]"
@@ -39,117 +47,100 @@ module Cambium
         template app, app
       end
 
-      # ------------------------------------------ Public Setup
-
+      # Backbone.js is our default javascript framework. We don't yet have an
+      # option to ignore, so here we automatically install it.
+      # 
       def install_backbone
         directory "app/assets/javascripts/backbone",
           "app/assets/javascripts"
       end
 
+      # Next, we need to replace our application.js file to add backbone and its
+      # dependencies, along with our default scripts.
+      # 
       def default_application_js
         app_js = "app/assets/javascripts/application.js"
         remove_file app_js
         template app_js, app_js
       end
 
-      def rename_backbone_root
-        app_name = Rails.application.class.parent_name.underscore.downcase
-        remove_file "app/assets/javascripts/backbone/#{app_name}.js.coffee"
-        template "app/assets/javascripts/backbone/app.js.coffee", 
-          "app/assets/javascripts/backbone/app.js.coffee"
-      end
-
-      # ------------------------------------------ Public Files
-
-      def add_public_router
-        remove_file "app/assets/javascripts/backbone/routers/.gitkeep"
-        template "app/assets/javascripts/backbone/routers/router.js.coffee", 
-          "app/assets/javascripts/backbone/routers/router.js.coffee"
-      end
-
-      def add_default_view
-        remove_file "app/assets/javascripts/backbone/views/.gitkeep"
-        template "app/assets/javascripts/backbone/views/default_helpers.js.coffee", 
-          "app/assets/javascripts/backbone/views/default_helpers.js.coffee"
-      end
-
-      # ------------------------------------------ Add Modernizr
-
-      def add_modernizr
+      # Don't forget about modernizr! This is where all the other vendor scripts
+      # should be added, although today we only use Modernizr.
+      # 
+      # Modernizr is called from the application layout since it is
+      # automatically added.
+      # 
+      def add_other_vendor_javascripts
         modernizr = "vendor/assets/javascripts/modernizr.js"
         copy_file modernizr, modernizr
       end
 
-      # ------------------------------------------ Public Styles
+      # Now we need to add our styles. We begin here by adding our vendor styles
+      # that are not already available via a gem.
+      # 
+      def add_vendor_styles
+        normalize = "vendor/assets/stylesheets/normalize.scss"
+        template normalize, normalize
+      end
 
+      # Once we have the files and gems we need, we can add our public manifest
+      # file. We ask the user if they are ok with us deleting theirs.
+      # 
+      # Note: Injecting seems easier here, and it would be, but we can't predict
+      # the name of this file, which is why we don't do it. It could be done
+      # with a longer method.
+      # 
       def add_public_manifest
-        ['css','scss','scss.css'].each { |ext| remove_file "app/assets/stylesheets/application.#{ext}" }
+        q = "\nWe're going to add our default application.scss file and remove yours. Is that ok?"
+        if yes? q
+          ['css','scss','scss.css'].each { |ext| remove_file "app/assets/stylesheets/application.#{ext}" }
+        end
         template "app/assets/stylesheets/application.scss", 
           "app/assets/stylesheets/application.scss"
       end
 
-      # ------------------------------------------ Add Modernizr
-
-      def add_normalize
-        normalize = "vendor/assets/stylesheets/normalize.scss"
-        template normalize, normalize
+      # If we have the user model generated, then we will try to create a
+      # default user.
+      # 
+      def add_default_user
+        if class_exists?('User')
+          create_user
+        else
+          msg = "\nUser model does not exist yet. If you want to use Cambium "
+          msg += "to add a user model, then you can run:\n"
+          say set_color(msg, :yellow, :bold)
+          say "   $ bundle exec rake cambium:model:user\n\n" 
+          msg = "and Cambium will handle the installation of Devise.\n"
+          say set_color(msg, :yellow, :bold)
+        end
       end
 
-      # ------------------------------------------ Create Default User
-
-      def add_default_user
-        create_user
+      # Add some gems to the gemfile, but don't install (we've been running into
+      # dependency issues)
+      # 
+      def add_application_gems
+        gems = [
+          'unicorn-rails',
+          'jquery-rails',
+          'uglifier',
+          'sass-rails',
+          'bourbon',
+          'coffee-rails',
+          'backbone-on-rails'
+        ]
+        add_gems_to_gemfile(gems)
+        added_gems = []
+        gems.each { |g| added_gems << g unless gem_exists?(g) }
+        gemfile_update_notification(added_gems)
       end
 
       # ------------------------------------------ Private Methods
 
       private
 
-        def run_cmd(cmd, options = {})
-          print_table(
-            [
-              [set_color("run", :green, :bold), cmd]
-            ],
-            :indent => 9
-          )
-          if options[:quiet] == true
-            `#{cmd}`
-          else
-            system(cmd)
-          end
-        end
-
-        def template_file(name)
-          File.expand_path("../../templates/#{name}", __FILE__)
-        end
-
-        def file_contents(template)
-          File.read(template_file(template))
-        end
-
-        def be
-          "bundle exec"
-        end
-
-        def g
-          "#{be} rails g"
-        end
-
-        def rake
-          "#{be} rake"
-        end
-
-        def confirm_ask(question)
-          answer = ask("\n#{question}")
-          match = ask("CONFIRM #{question}")
-          if answer == match
-            answer
-          else
-            say set_color("Did not match.", :red)
-            confirm_ask(question)
-          end
-        end
-
+        # create_user is down here because it can then keep looping until a
+        # valid record is created.
+        # 
         def create_user
           email = confirm_ask "#{set_color('Default User Email', :green, :bold)}:"
           password = confirm_ask "#{set_color('Default User Password', :green, :bold)}:"
@@ -157,8 +148,8 @@ module Cambium
             :email => email,
             :password => password, 
             :password_confirmation => password,
-            :is_admin => true
           )
+          u.is_admin = true if u.respond_to?(:is_admin)
           if u.save
             say "User created successfully!"
           else

data/lib/generators/cambium/install/config_generator.rb

@@ -1,21 +1,23 @@
 require 'rake'
 require 'rails/generators'
+require File.expand_path('../../helpers/_autoloader.rb', __FILE__)
 
 module Cambium
   module Install
     class ConfigGenerator < Rails::Generators::Base
       desc "Setup config files for new rails project"
 
-      # ------------------------------------------ Class Methods
-
       source_root File.expand_path('../../templates', __FILE__)
 
-      # ------------------------------------------ Config
-
+      # Initialize git repository. If repo was already initialized, repo is
+      # reinitialized, but that shouldn't hurt anything.
+      # 
       def git_init
         run_cmd "git init"
       end
 
+      # Set vars to use throughout this generator
+      # 
       def cambium_setup
         @config = {
           :db => {},
@@ -23,11 +25,13 @@ module Cambium
         }
       end
 
+      # Read existing project files to set default config values
+      # 
       def auto_config
-        # Read Gemfile
+        # read Gemfile
         File.open("#{Rails.root}/Gemfile") do |f|
           f.each_line do |line|
-            # Database
+            # find database adapter
             if line.include?("'mysql2'")
               @config[:db][:adapter] = "mysql2"
             elsif line.include?("'pg'")
@@ -35,157 +39,143 @@ module Cambium
             elsif line.include?("'sqlite3'")
               @config[:db][:adapter] = "sqlite3"
             end
-            # Rails Version
+            # find rails version
             if line.match(/gem\ \'rails\'/)
               @config[:app][:version] = line.gsub(/gem\ \'rails\'\,/, '').gsub(/\'/, '').strip
             end
           end
         end
-        # Application Class Name
+        # Find the application class name
         @config[:app][:name] = Rails.application.class.parent_name
       end
 
-      def user_config
-        # Database
-        if @config[:db][:adapter].present? && yes?("\nCambium, in all its wisdom, thinks your database adapter as #{set_color(@config[:db][:adapter], :green, :bold)}. Is this correct? [yes, no]")
-          say("Oh, goodie! Moving on...")
-        else
-          new_adapter = ask("What would you prefer?", :limited_to => ['mysql2','pg','sqlite3'])
-          unless new_adapter == @config[:db][:adapter]
-            say set_color("\nPlease add:", :red, :bold)
-            say "\n    gem '#{new_adapter}'"
-            say set_color("\nto your Gemfile. Then run `bundle install` and `bundle exec cambium setup`.", :red, :bold)
-            exit
+      # These next few methods let the user adjust the default config if they
+      # wish. Otherwise, we use default values from the previous method.
+      # 
+      # --------
+      # 
+      # Set correct database adapter.
+      # 
+      # Note: If the user wants to change the adapter, we *could* change the
+      # adapter on the fly and install the new one here. Instead, we tell the
+      # user what to do and exit. This make absolutely sure we've gotten rid of
+      # the original adapter in the Gemfile and added the new one.
+      # 
+      def set_database_adapter
+        if @config[:db][:adapter].present?
+          if yes?("\nCambium, in all its wisdom, thinks your database adapter as #{set_color(@config[:db][:adapter], :green, :bold)}. Is this correct? [yes, no]")
+            say("Oh, goodie! Moving on...")
+          else
+            new_adapter = ask("What would you prefer?", :limited_to => ['mysql2','pg','sqlite3'])
+            unless new_adapter == @config[:db][:adapter]
+              say set_color("\nPlease add:", :red, :bold)
+              say "\n    gem '#{new_adapter}'"
+              say set_color("\nto your Gemfile. Then run `bundle install` and `bundle exec cambium setup`.", :red, :bold)
+              exit
+            end
           end
         end
+      end
 
-        # Database Name
+      # Set the database base name (where we append "_#{stage}" to each stage)
+      # 
+      def set_database_name
         @config[:db][:name] = @config[:app][:name].underscore.downcase
         db_name = ask "\n#{set_color('Database Base Name:', :green, :bold)} [default: #{@config[:db][:name]}]"
         @config[:db][:name] = db_name unless db_name.blank?
+      end
 
-        # Database Credentials
+      # Set database credentials
+      # 
+      def set_database_creds
         @config[:db][:user] = confirm_ask("#{set_color('Database User', :green, :bold)}: [leave blank for no user]")
         if @config[:db][:user].present?
           @config[:db][:password] = confirm_ask("#{set_color('Database Password', :green, :bold)}: [leave blank for no password]")
         else
           @config[:db][:password] = ''
         end
+      end
 
-        # Root URL (for mailers)
+      # Set root URL (for mailers)
+      # 
+      def set_root_url
+        # development
         @config[:app][:dev_url] = ask("\n#{set_color('Development URL', :green, :bold)}: [leave blank for localhost:3000]")
         @config[:app][:dev_url] = 'localhost:3000' if @config[:app][:dev_url].blank?
+        environment(
+          "config.action_mailer.default_url_options = { :host => '#{@config[:app][:dev_url]}' }", 
+          :env => "development"
+        )
+        # production
         @config[:app][:prod_url] = ask("#{set_color('Production URL', :green, :bold)}: [leave blank for localhost:3000]")
         @config[:app][:prod_url] = 'localhost:3000' if @config[:app][:prod_url].blank?
-      end
-
-      # ------------------------------------------ Gems & Gemfile
-
-      def install_gemfile
-        remove_file "Gemfile"
-        template "Gemfile.erb", "Gemfile"
-        run_cmd "bundle clean"
-      end
-
-      # ------------------------------------------ Application Settings & Config
-
-      def add_application_config
-        insert_into_file(
-          "config/application.rb",
-          file_contents("config/application.rb"),
-          :after => "class Application < Rails::Application"
+        environment(
+          "config.action_mailer.default_url_options = { :host => '#{@config[:app][:prod_url]}' }", 
+          :env => "production"
+        )
+        environment(
+          "config.assets.precompile += %w( admin/admin.css admin/admin.js admin/wysihtml5.css modernizr.js )",
+          :env => "production"
         )
       end
 
-      # ------------------------------------------ Environment Settings
-
-      def add_env_settings
-        insert_into_file "config/environments/development.rb", 
-          :after => "Rails.application.configure do" do
-            "\n\n  config.action_mailer.default_url_options = { :host => '#{@config[:app][:dev_url]}' }\n"
-        end
-        insert_into_file "config/environments/production.rb", 
-          :after => "Rails.application.configure do" do
-            output = ''
-            output += "\n\n  config.action_mailer.default_url_options = { :host => '#{@config[:app][:prod_url]}' }"
-            output += "\n\n  config.assets.precompile += %w( admin/admin.css admin/admin.js admin/wysihtml5.css modernizr.js )\n"
-            output
-        end
+      # Add settings to application config file (config/application.rb)
+      # 
+      def add_application_config
+        environment { file_contents("config/application.rb") }
       end
 
-      # ------------------------------------------ Assets Initializer
-
+      # Assets initializer for Rails 4.1+
+      # 
       def add_assets_initializer
         template "config/initializers/assets.rb", 
           "config/initializers/assets.rb"
       end
 
-      # ------------------------------------------ Database Setup
-
+      # Create database based on custom config
+      # 
       def setup_database
         copy_file "#{Rails.root}/config/database.yml", "config/database.sample.yml"
         remove_file "config/database.yml"
         template "config/database.#{@config[:db][:adapter]}.yml.erb", "config/database.yml"
-        run_cmd "#{rake} db:drop", :quiet => true
-        run_cmd "#{rake} db:create"
-        run_cmd "#{rake} db:migrate"
+        rake "db:create"
+        rake "db:migrate"
       end
 
-      # ------------------------------------------ .gitignore
-
+      # Add custom gitignore file
+      # 
       def add_gitignore
         remove_file ".gitignore"
         template "gitignore", ".gitignore"
       end
 
-      # ------------------------------------------ Private Methods
-
-      private
-
-        def run_cmd(cmd, options = {})
-          print_table(
-            [
-              [set_color("run", :green, :bold), cmd]
-            ],
-            :indent => 9
-          )
-          if options[:quiet] == true
-            `#{cmd}`
-          else
-            system(cmd)
-          end
-        end
-
-        def template_file(name)
-          File.expand_path("../../templates/#{name}", __FILE__)
-        end
-
-        def file_contents(template)
-          File.read(template_file(template))
-        end
-
-        def be
-          "bundle exec"
-        end
-
-        def g
-          "#{be} rails g"
-        end
-
-        def rake
-          "#{be} rake"
+      # We used to start the user out by installing all the gems we will need
+      # throughout the project. Now, we're going to ask the user if they want to
+      # replace their Gemfile with our custom file. If they say "no," then we
+      # will install the gems we need at a later step.
+      # 
+      def add_recommended_gems
+        msg = "\nWe have a set of gems we recommend by default. You can \n"
+        msg += "start with this Gemfile if you'd like. Of course, we'll \n"
+        msg += "install gems for you when we need them."
+        say msg
+        if yes? "\nWould you like to replace your existing Gemfile with our default?"
+          remove_file "Gemfile"
+          template "Gemfile.erb", "Gemfile"
+          say "\nYour Gemfile has been updated, but now you need to run:"
+          say "\n    $ bundle install"
+          say "\nto install all your gems. Feel free to any gems you don't want, "
+          say "\nsince we will add gems to your project as we need them."
+        else
+          say "You got it!"
         end
+      end
 
-        def confirm_ask(question)
-          answer = ask("\n#{question}")
-          match = ask("CONFIRM #{question}")
-          if answer == match
-            answer
-          else
-            say set_color("Did not match.", :red)
-            confirm_ask(question)
-          end
-        end
+      # Outgoing message
+      # 
+      def tell_user_we_are_done
+        say "\n#{set_color('Config completed!', :green, :bold)}"
+      end
 
     end
   end

data/lib/generators/cambium/install/utilities_generator.rb

@@ -1,5 +1,7 @@
 require 'rake'
 require 'rails/generators'
+require "#{Gem::Specification.find_by_name("cambium").gem_dir}/lib/generators/cambium/helpers/generators_helper.rb"
+include Cambium::GeneratorsHelper
 
 module Cambium
   module Install
@@ -18,7 +20,6 @@ module Cambium
           'name',
           'publishable',
           'slug',
-          'tags',
           'title',
         ].each do |concern|
           copy_file "app/models/concerns/#{concern}.rb", 
@@ -51,55 +52,6 @@ module Cambium
         end
       end
 
-      # ------------------------------------------ Private Methods
-
-      private
-
-        def run_cmd(cmd, options = {})
-          print_table(
-            [
-              [set_color("run", :green, :bold), cmd]
-            ],
-            :indent => 9
-          )
-          if options[:quiet] == true
-            `#{cmd}`
-          else
-            system(cmd)
-          end
-        end
-
-        def template_file(name)
-          File.expand_path("../../templates/#{name}", __FILE__)
-        end
-
-        def file_contents(template)
-          File.read(template_file(template))
-        end
-
-        def be
-          "bundle exec"
-        end
-
-        def g
-          "#{be} rails g"
-        end
-
-        def rake
-          "#{be} rake"
-        end
-
-        def confirm_ask(question)
-          answer = ask("\n#{question}")
-          match = ask("Confirm: #{question}")
-          if answer == match
-            answer
-          else
-            say set_color("Did not match.", :red)
-            confirm_ask(question)
-          end
-        end
-
     end
   end
 end

data/lib/generators/cambium/model/image_generator.rb

@@ -0,0 +1,67 @@
+require 'rake'
+require 'rails/generators'
+require File.expand_path('../../helpers/_autoloader.rb', __FILE__)
+
+module Cambium
+  module Model
+    class ImageGenerator < Rails::Generators::Base
+      desc "Create a simple image model"
+
+      source_root File.expand_path('../../templates', __FILE__)
+
+      # Let's make sure we have the admin setup already.
+      # 
+      def set_dependencies
+        check_dependencies(['cambium:install:admin'])
+      end
+
+      # Install gems we need for images
+      # 
+      def install_gem_dependencies
+        install_gem 'carrierwave'
+        install_gem 'rmagick', :require => 'RMagick'
+      end
+
+      # Since the Image model is so simple, we can generate it from the command
+      # line instead of copying templates.
+      # 
+      def generate_model
+        generate "model Image filename"
+      end
+
+      # Add our pre-built model file
+      # 
+      def add_model_files
+        copy_file("app/models/image.rb", "app/models/image.rb", :force => true)
+      end
+
+      # Add our image uploader, which uses CarrierWave
+      # 
+      def add_uploaders
+        generate "uploader Image"
+        uploader_path = "app/uploaders/image_uploader.rb"
+        copy_file uploader_path, uploader_path, :force => true
+      end
+
+      # Add our image cropper model concern. Currently, we don't have the
+      # cropping tool functional within the admin.
+      # 
+      def add_model_concerns
+        add_model_concern 'image_cropper'
+      end
+
+      # Before we finish up, we need to add our admin files.
+      # 
+      def add_admin_files
+        template("app/controllers/admin/images_controller.rb", 
+          "app/controllers/admin/images_controller.rb")
+        directory("app/views/admin/images", "app/views/admin/images")
+      end
+
+      def finish_up
+        migrate_and_annotate
+      end
+
+    end
+  end
+end