cambium 0.3.0 → 1.0.0

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

@@ -1,162 +0,0 @@
-require 'rake'
-require 'rails/generators'
-require File.expand_path('../../helpers/_autoloader.rb', __FILE__)
-
-module Cambium
-  module Install
-    class AppGenerator < Rails::Generators::Base
-      desc "Setup app files for new rails project"
-
-      source_root File.expand_path('../../templates', __FILE__)
-
-      # Add a default public controller, so we have a working home page when
-      # we're done.
-      # 
-      def add_home_controller
-        generate "controller home index"
-        gsub_file("config/routes.rb", /\ \ get\ \'home\/index\'\n\n/, '')
-      end
-
-      # Add our default routes, ommitting admin routes (which are added via the
-      # admin generator)
-      # 
-      def add_default_routes
-        insert_into_file(
-          "config/routes.rb",
-          file_contents("config/app_routes.rb"),
-          :after => "Rails.application.routes.draw do"
-        )
-      end
-
-      # Add our default public views
-      # 
-      def add_public_views
-        directory "app/views/application"
-        directory "app/views/home", :force => true
-      end
-
-      # 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}]"
-        @site_title = site_title unless site_title.blank?
-        
-        app = "app/views/layouts/application.html.erb"
-        remove_file app
-        template app, app
-      end
-
-      # 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
-
-      # 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
-
-      # 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
-        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
-
-      # 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
-
-      # 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
-
-        # 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)}:"
-          u = User.new(
-            :email => email,
-            :password => password, 
-            :password_confirmation => password,
-          )
-          u.is_admin = true if u.respond_to?(:is_admin)
-          if u.save
-            say "User created successfully!"
-          else
-            create_user
-          end
-        end
-
-    end
-  end
-end

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

@@ -1,182 +0,0 @@
-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"
-
-      source_root File.expand_path('../../templates', __FILE__)
-
-      # 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 => {},
-          :app => {}
-        }
-      end
-
-      # Read existing project files to set default config values
-      # 
-      def auto_config
-        # read Gemfile
-        File.open("#{Rails.root}/Gemfile") do |f|
-          f.each_line do |line|
-            # find database adapter
-            if line.include?("'mysql2'")
-              @config[:db][:adapter] = "mysql2"
-            elsif line.include?("'pg'")
-              @config[:db][:adapter] = "pg"
-            elsif line.include?("'sqlite3'")
-              @config[:db][:adapter] = "sqlite3"
-            end
-            # find rails version
-            if line.match(/gem\ \'rails\'/)
-              @config[:app][:version] = line.gsub(/gem\ \'rails\'\,/, '').gsub(/\'/, '').strip
-            end
-          end
-        end
-        # Find the application class name
-        @config[:app][:name] = Rails.application.class.parent_name
-      end
-
-      # 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
-
-      # 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
-
-      # 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
-
-      # 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?
-        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
-
-      # Add settings to application config file (config/application.rb)
-      # 
-      def add_application_config
-        environment { file_contents("config/application.rb") }
-      end
-
-      # Assets initializer for Rails 4.1+
-      # 
-      def add_assets_initializer
-        template "config/initializers/assets.rb", 
-          "config/initializers/assets.rb"
-      end
-
-      # 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"
-        rake "db:create"
-        rake "db:migrate"
-      end
-
-      # Add custom gitignore file
-      # 
-      def add_gitignore
-        remove_file ".gitignore"
-        template "gitignore", ".gitignore"
-      end
-
-      # 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
-
-      # Outgoing message
-      # 
-      def tell_user_we_are_done
-        say "\n#{set_color('Config completed!', :green, :bold)}"
-      end
-
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-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
-    class UtilitiesGenerator < Rails::Generators::Base
-      desc "Setup utilities for new rails project"
-
-      # ------------------------------------------ Class Methods
-
-      source_root File.expand_path('../../templates', __FILE__)
-
-      # ------------------------------------------ Model Concerns
-
-      def add_model_concerns
-        [
-          'idx',
-          'name',
-          'publishable',
-          'slug',
-          'title',
-        ].each do |concern|
-          copy_file "app/models/concerns/#{concern}.rb", 
-            "app/models/concerns/#{concern}.rb"
-        end
-      end
-
-      # ------------------------------------------ Settings Files
-
-      def add_settings_files
-        template "config/initializers/_settings.rb", 
-          "config/initializers/_settings.rb"
-        ['settings','settings_private','settings_private.sample'].each do |s|
-          template "config/#{s}.yml", "config/#{s}.yml"
-        end
-      end
-
-      # ------------------------------------------ Seeds
-
-      def add_seed_generator
-        remove_file "db/seeds.rb"
-        template "db/seeds.rb", "db/seeds.rb"
-      end
-
-      # ------------------------------------------ Rake Tasks
-
-      def add_rake_tasks
-        ['db','rename'].each do |task|
-          template "lib/tasks/#{task}.rake", "lib/tasks/#{task}.rake"
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-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

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

@@ -1,131 +0,0 @@
-require 'rake'
-require 'rails/generators'
-require File.expand_path('../../helpers/_autoloader.rb', __FILE__)
-
-module Cambium
-  module Model
-    class PageGenerator < Rails::Generators::Base
-      desc "Add pages to your project"
-
-      source_root File.expand_path('../../templates', __FILE__)
-
-      # Since we're using images, we need to make sure the image generator has
-      # already been run. And, like all other models, we want to make sure we
-      # already have an admin available to us.
-      # 
-      def set_dependencies
-        check_dependencies(['cambium:install:admin','cambium:model:image'])
-      end
-
-      # We need a couple concerns, so we add them here unless they are already
-      # part of the project.
-      # 
-      def add_concerns
-        add_model_concerns(['publishable', 'slug'])
-      end
-
-      # Add our model file.
-      # 
-      def add_model_files
-        template("app/models/page.rb", "app/models/page.rb")
-      end
-
-      # Since we have to customize the up/down methods in the migration, we
-      # don't generate the model, we just copy an interpreted template.
-      # 
-      def add_migration_files
-        template(
-          "db/migrate/create_pages.rb.erb",
-          "db/migrate/#{timestamp}_create_pages.rb"
-        )
-        migrate_and_annotate
-      end
-
-      # We are setting a global template directory for reference throughout the
-      # project.
-      # 
-      def add_application_config
-        application 'config.template_directory = "#{Rails.root}/app/views/page_templates"'
-      end
-
-      # We add our page templates directory and our default template.
-      # 
-      def add_page_templates
-        directory('app/views/page_templates','app/views/page_templates')
-      end
-
-      # We have two controllers here -- one for the app and one for the admin.
-      # We'll add them both instead of generating them since they are
-      # customized.
-      # 
-      def add_controller_files
-        template("app/controllers/pages_controller.rb", 
-          "app/controllers/pages_controller.rb")
-        template("app/controllers/admin/pages_controller.rb", 
-          "app/controllers/admin/pages_controller.rb")
-      end
-
-      # We add the customized views that override the default admin views, while
-      # the app views are driven by the page template
-      # 
-      def add_admin_views
-        directory("app/views/admin/pages", "app/views/admin/pages")
-      end
-
-      # We need to add routes to routes file for the app and the admin. We
-      # expect to see an admin, so we don't have a check, but we do need the
-      # public route. Since the contents of the routes file are variable, we
-      # have a check and notify the user if we can't find what we need.
-      # 
-      def add_routes
-        # App
-        insert_into_file(
-          "config/routes.rb",
-          "get '/:slug', :to => 'pages#show', :as => 'page'\n\n  ",
-          :before => /root\ (.*)\n/
-        )
-        if File.read(Rails.root.join('config','routes.rb')).include?('/:slug')
-          uncomment_lines(
-            Rails.root.join('config','routes.rb'),
-            /get\ \'\/\:slug/
-          )
-        else
-          add_routes_manually
-        end
-        # Admin
-        insert_into_file(
-          "config/routes.rb",
-          "    resources :pages, :except => [:show]\n",
-          :after => /namespace\ \:admin(.*)\n/
-        )
-      end
-
-      # In the admin helper, we can add a link and an icon to the sidebar. The
-      # easiest way to do this is to add it to the top. The user can move if
-      # they'd like.
-      # 
-      def add_admin_icon
-        insert_into_file(
-          "app/helpers/admin_helper.rb",
-          file_contents('_partials/pages/admin_icon.rb'),
-          :after => /items\ \=\ \[\n/
-        )
-      end
-
-      private
-
-        # If we couldn't find a root route in the config file, then we tell the
-        # user to add the routes manually.
-        # 
-        def add_routes_manually
-          say set_color(
-            "\nAdd the following to the end of your config/routes.rb file:\n",
-            :yellow,
-            :bold
-          )
-          say "    get '/:slug', :to => 'pages#show', :as => 'page'\n"
-        end
-
-    end
-  end
-end

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

@@ -1,71 +0,0 @@
-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 Model
-    class PostGenerator < Rails::Generators::Base
-      desc "Add blog posts to your project"
-
-      # ------------------------------------------ Class Methods
-
-      source_root File.expand_path('../../templates', __FILE__)
-
-      # ------------------------------------------ Model Concern
-
-      def add_model_concerns
-        copy_file "app/models/concerns/publishable.rb", "app/models/concerns/publishable.rb"
-        copy_file "app/models/concerns/slug.rb", "app/models/concerns/slug.rb"
-        copy_file "app/models/concerns/tags.rb", "app/models/concerns/tags.rb"
-      end
-
-      # ------------------------------------------ Add Model Templates
-
-      def add_model_files
-        model_path = "app/models/post.rb"
-        template(model_path, model_path)
-      end
-
-      # ------------------------------------------ Add Migration Templates
-
-      def add_migration_files
-        template(
-          'db/migrate/create_posts.rb',
-          "db/migrate/#{timestamp}_create_posts.rb"
-        )
-      end
-
-      # ------------------------------------------ Add Controller Templates
-
-      def add_controller_files
-        controller_path = "app/controllers/posts_controller.rb"
-        template(controller_path, controller_path)
-      end
-
-      # ------------------------------------------ Add View Templates
-
-      def add_view_files
-        view_path = "app/views/posts"
-        directory(view_path, view_path)
-      end
-
-      # ------------------------------------------ Migrate & Annotate
-
-      def migrate_and_annotate
-        rake "db:migrate"
-        run_cmd "#{be} annotate"
-      end
-
-      # ------------------------------------------ User output
-      # This is kind of a cop out in leu of appending to the *end* of routes.rb
-      def notes_to_user
-        puts "\n== Don't forget to add routes for blog posts ================="
-        puts "get '/news', :to => 'posts#index', :as => 'posts'"
-        puts "get '/news/:slug', :to => 'posts#show', :as => 'post'"
-        puts "\n"
-      end
-
-    end
-  end
-end