swiftly 4.0.0

data/lib/swiftly/packages.rb

@@ -0,0 +1,137 @@
+require "swiftly/config"
+require "swiftly/app_module"
+require "yaml"
+
+module Swiftly
+  class Packages < Thor
+
+    include Thor::Actions
+    include Helpers
+
+    no_commands do
+
+      def self.file
+
+        @settings = Swiftly::Config.load :global
+
+        File.join(
+          @settings[:sites_path],
+          'Swiftlyfile',
+        ) unless !File.exists?(
+          File.join(
+            @settings[:sites_path],
+            'Swiftlyfile'
+          )
+        )
+
+      end
+
+      def self.check?
+
+        if File.exists? self.file
+
+          true
+
+        else
+
+          false
+
+        end
+      end
+
+      def self.available
+
+        YAML.load_file self.file
+
+      end
+
+      def self.template
+
+        {
+          name:     'mask',
+          location: 'https://github.com/micalexander/mask/archive/master.zip'
+        }
+
+      end
+
+      def self.load package = {}
+
+        approved_package = nil
+
+        if self.available &&
+          !self.available[:packages].nil? &&
+          !self.available[:packages][package[:framework]].nil? &&
+          !self.available[:packages][package[:framework]][package[:type]].nil?
+
+          self.available[:packages][package[:framework]][package[:type]].each do |p|
+
+            if ( p[:name] == package[:name] && p[:status] != :disabled ) ||
+               ( p[:status] == :default )
+
+              approved_package = p
+
+            else
+
+              approved_package = self.template
+
+            end
+          end
+
+        elsif !self.available
+
+
+          approved_package = self.template
+
+        end
+
+        if !approved_package.nil? &&
+           (
+            approved_package[:location] =~ /^#{URI::regexp}\.zip$/ ||
+            File.exist?( File.join( approved_package[:location], approved_package[:name] ) )
+           )
+
+          return approved_package
+
+        end
+
+        false
+
+      end
+
+      def self.load_plugins framework
+
+        plugins = []
+
+        if self.available &&
+          !self.available[:packages].nil? &&
+          !self.available[:packages][framework].nil? &&
+          !self.available[:packages][framework][:plugins].nil?
+
+          self.available[:packages][framework][:plugins].each do |p|
+
+            verified = self.load({
+              framework: framework,
+              type:      :plugins,
+              name:      p[:name]
+            })
+
+            if verified
+
+              plugins << verified
+
+            end
+          end
+
+          if plugins.count > 0
+
+            return plugins
+
+          end
+
+          false
+
+        end
+      end
+    end
+  end
+end

data/lib/swiftly/project.rb

@@ -0,0 +1,127 @@
+require 'Thor'
+require 'yaml'
+require 'swiftly/app_module'
+
+module Swiftly
+  class Project < Thor
+
+    include Thor::Actions
+    include Helpers
+
+    no_commands do
+
+      def self.settings( project_name )
+
+        project_name   = self.get_project project_name
+        global_config  = Swiftly::Config.load :global
+        swiftly_config = Swiftly::Config.load :swiftly
+        project_config = Swiftly::Config.load :project,   project_name
+        wp_config      = Swiftly::Config.load :wp_config, project_name
+
+        global_config  = {
+          version:    VERSION,
+          sites_path: global_config[:sites_path],
+        }
+
+        switly_config  = {
+          staging: {
+            domain:  defined?(project_config[:staging][:domain])  ? project_config[:staging][:domain]  : global_config[:staging][:domain],
+            db_host: defined?(project_config[:staging][:db_host]) ? project_config[:staging][:db_host] : global_config[:staging][:db_host],
+            db_user: defined?(project_config[:staging][:db_user]) ? project_config[:staging][:db_user] : global_config[:staging][:db_user],
+            db_pass: defined?(project_config[:staging][:db_pass]) ? project_config[:staging][:db_pass] : global_config[:staging][:db_pass],
+          },
+          production: {
+            domain:  defined?(project_config[:production][:domain])  ? project_config[:production][:domain]  : global_config[:production][:domain],
+            db_host: defined?(project_config[:production][:db_host]) ? project_config[:production][:db_host] : global_config[:production][:db_host],
+            db_user: defined?(project_config[:production][:db_user]) ? project_config[:production][:db_user] : global_config[:production][:db_user],
+            db_pass: defined?(project_config[:production][:db_pass]) ? project_config[:production][:db_pass] : global_config[:production][:db_pass],
+          }
+        }.merge! local: global_config[:local]
+
+        settings = {
+          project: {
+            name: project_name,
+            path: File.join( global_config[:sites_path], project_name ),
+            dump: File.join( global_config[:sites_path], project_name, '_backups', 'dumps' )
+          },
+          local: {
+            domain:  defined?(wp_config[:local][:domain])  ? wp_config[:local][:domain]  : project_config[:local][:domain],
+            db_name: defined?(wp_config[:local][:db_name]) ? wp_config[:local][:db_name] : project_config[:local][:db_name],
+            db_host: defined?(wp_config[:local][:db_host]) ? wp_config[:local][:db_host] : switly_config[:local][:db_host],
+            db_user: defined?(wp_config[:local][:db_user]) ? wp_config[:local][:db_user] : switly_config[:local][:db_user],
+            db_pass: defined?(wp_config[:local][:db_pass]) ? wp_config[:local][:db_pass] : switly_config[:local][:db_pass],
+          },
+          staging: {
+            db_name:  defined?(wp_config[:staging][:db_name])    ? wp_config[:staging][:db_name] : project_config[:staging][:db_name],
+            db_host:  defined?(wp_config[:staging][:db_host])    ? wp_config[:staging][:db_host] : switly_config[:staging][:db_host],
+            db_user:  defined?(wp_config[:staging][:db_user])    ? wp_config[:staging][:db_user] : switly_config[:staging][:db_user],
+            db_pass:  defined?(wp_config[:staging][:db_pass])    ? wp_config[:staging][:db_pass] : switly_config[:staging][:db_pass],
+            domain:   defined?(switly_config[:staging][:domain]) ? switly_config[:staging][:domain]  : wp_config[:staging][:domain],
+            repo:     project_config[:staging][:repo],
+            branch:   project_config[:staging][:branch],
+            ssh_path: project_config[:staging][:ssh_path],
+            ssh_user: project_config[:staging][:ssh_user],
+          },
+          production: {
+            db_name:  defined?(wp_config[:production][:db_name])    ? wp_config[:production][:db_name] : project_config[:production][:db_name],
+            db_host:  defined?(wp_config[:production][:db_host])    ? wp_config[:production][:db_host] : switly_config[:production][:db_host],
+            db_user:  defined?(wp_config[:production][:db_user])    ? wp_config[:production][:db_user] : switly_config[:production][:db_user],
+            db_pass:  defined?(wp_config[:production][:db_pass])    ? wp_config[:production][:db_pass] : switly_config[:production][:db_pass],
+            domain:   defined?(switly_config[:production][:domain]) ? switly_config[:production][:domain]  : wp_config[:production][:domain],
+            repo:     project_config[:production][:repo],
+            branch:   project_config[:production][:branch],
+            ssh_path: project_config[:production][:ssh_path],
+            ssh_user: project_config[:production][:ssh_user],
+          }
+        }
+
+        if defined?( settings[:staging][:ssh_user] ) &&
+           defined?( settings[:staging][:domain] ) &&
+           settings[:staging][:ssh_user] != nil  &&
+           settings[:staging][:domain] != nil
+
+          settings[:staging][:userhost] = settings[:staging][:ssh_user] + '@' + settings[:staging][:domain].gsub(/http:\/\//, "")
+
+        end
+
+        if defined?( settings[:production][:ssh_user] ) &&
+           defined?( settings[:production][:domain] ) &&
+           settings[:production][:ssh_user] != nil  &&
+           settings[:production][:domain] != nil
+
+          settings[:production][:userhost] = settings[:production][:ssh_user] + '@' + settings[:production][:domain].gsub(/http:\/\//, "")
+
+        end
+
+        settings
+
+      end
+
+      def self.get_project( project_name )
+
+        pathname     = Pathname.new project_name
+        settings     = Swiftly::Config.load( :global )
+        project_path = File.join( settings[:sites_path], pathname.expand_path.basename )
+
+        thor = Thor.new
+
+        thor.say #spacer
+
+        thor.say_status( "#{APP_NAME}:", "#{project_path} is not a project.\n", :yellow ) &&
+        abort unless File.directory?( project_path )
+
+        pathname.expand_path.basename
+
+      end
+
+      def self.exists?( project_name )
+
+        settings     = Swiftly::Config.load( :global )
+        project_path = File.join( settings[:sites_path], project_name )
+
+        File.directory?( project_path )
+
+      end
+    end
+  end
+end

data/lib/swiftly/pull.rb

@@ -0,0 +1,25 @@
+require 'swiftly/app_module'
+require 'swiftly/Database'
+
+module Swiftly
+  class Pull < Thor
+    include Thor::Actions
+    include Helpers
+
+    desc "staging PROJECT_NAME", "Pull down staging environment"
+
+    def staging( project_name )
+
+      Swiftly::Database.new( project_name ).sync( :staging, :local )
+
+    end
+
+    desc "production PROJECT_NAME", "Pull down production environment"
+
+    def production( project_name )
+
+      Swiftly::Database.new( project_name ).sync( :production, :local )
+
+    end
+  end
+end

data/lib/swiftly/push.rb

@@ -0,0 +1,60 @@
+require 'swiftly/app_module'
+require 'swiftly/Database'
+
+module Swiftly
+  class Push < Thor
+
+    include Thor::Actions
+    include Helpers
+
+    desc "staging PROJECT_NAME", "Push staging environment"
+
+    def staging( project_name )
+
+      settings  = Swiftly::Project.settings( project_name )
+      database  = Swiftly::Database.new project_name
+
+      verifiy_mina_credentials  :staging, settings, 'push to the'
+
+      dump_file = database.dump :staging
+
+      database.sync :local, :staging
+
+      mina 'deploy', :staging, project_name
+
+      scp = <<-EOF.unindent
+        scp \
+        #{dump_file} \
+        #{settings[:staging][:userhost]}:#{settings[:staging][:ssh_path]}/current
+      EOF
+
+      swiftly_shell scp
+
+    end
+
+    desc "production PROJECT_NAME", "Push production environment"
+
+    def production( project_name )
+
+      settings  = Swiftly::Project.settings( project_name )
+      database  = Swiftly::Database.new project_name
+
+      verifiy_mina_credentials  :production, settings, 'push to the'
+
+      dump_file = database.dump :production
+
+      database.sync :local, :production
+
+      mina 'deploy', :production, project_name
+
+      scp = <<-EOF.unindent
+        scp \
+        #{dump_file} \
+        #{settings[:production][:userhost]}:#{settings[:production][:ssh_path]}/current
+      EOF
+
+      swiftly_shell scp
+
+    end
+  end
+end

data/lib/swiftly/rollback.rb

@@ -0,0 +1,78 @@
+require 'swiftly/app_module'
+require 'swiftly/Database'
+
+module Swiftly
+  class Rollback < Thor
+    include Thor::Actions
+    include Helpers
+
+    desc "staging PROJECT_NAME", "Rollback staging environment"
+
+    def staging( project_name )
+
+      database = Swiftly::Database.new( project_name )
+      settings = Swiftly::Project.settings( project_name )
+
+      verifiy_mina_credentials :staging, settings, 'rollback to the'
+
+      ssh = <<-EOF.unindent
+        ssh \
+        -q \
+        #{settings[:staging][:userhost]} \
+        ls \
+        #{settings[:staging][:ssh_path]}/current \
+        | grep staging.sql
+      EOF
+
+      previous_sql = return_cmd( ssh ).gsub(/[^a-zA-Z0-9\-\.]/,"")
+
+      scp = <<-EOF.unindent
+        scp \
+        #{settings[:staging][:userhost]}:#{settings[:staging][:ssh_path]}/current/#{previous_sql } \
+        #{settings[:project][:dump]}/temp
+      EOF
+
+      swiftly_shell scp
+
+      database.import( :staging, "#{settings[:project][:dump]}/temp/#{previous_sql}" )
+
+      mina 'rollback', :staging, project_name
+
+    end
+
+    desc "production PROJECT_NAME", "Rollback production environment"
+
+    def production( project_name )
+
+      database = Swiftly::Database.new( project_name )
+      settings = Swiftly::Project.settings( project_name )
+
+      verifiy_mina_credentials :production, settings, 'rollback to the'
+
+      ssh = <<-EOF.unindent
+        ssh \
+        -q \
+        #{settings[:production][:userhost]} \
+        ls \
+        #{settings[:production][:ssh_path]}/current \
+        | grep production.sql
+      EOF
+
+      previous_sql = return_cmd( ssh ).gsub(/[^a-zA-Z0-9\-\.]/,"")
+
+      scp = <<-EOF.unindent
+        scp \
+        #{settings[:production][:userhost]}:#{settings[:production][:ssh_path]}/current/#{previous_sql } \
+        #{settings[:project][:dump]}/temp
+      EOF
+
+      swiftly_shell scp
+
+      database.import( :production, "#{settings[:project][:dump]}/temp/#{previous_sql}" )
+
+      mina 'rollback', :production, project_name
+
+
+    end
+  end
+end

data/lib/swiftly/setup.rb

@@ -0,0 +1,34 @@
+require 'swiftly/app_module'
+require 'swiftly/Database'
+
+module Swiftly
+  class Setup < Thor
+
+    include Thor::Actions
+    include Helpers
+
+    desc "staging PROJECT_NAME", "setup staging server"
+
+    def staging( project_name )
+
+      settings = Swiftly::Project.settings( project_name )
+
+      verifiy_mina_credentials :staging, settings, 'setup the'
+
+      mina 'setup', :staging, project_name
+
+    end
+
+    desc "production PROJECT_NAME", "setup production server"
+
+    def production( project_name )
+
+      settings = Swiftly::Project.settings( project_name )
+
+      verifiy_mina_credentials :production, settings, 'setup the'
+
+      mina 'setup', :production, project_name
+
+    end
+  end
+end

data/lib/swiftly/ssh.rb

@@ -0,0 +1,36 @@
+require 'swiftly/app_module'
+require 'swiftly/Database'
+
+module Swiftly
+  class SSH < Thor
+
+    include Thor::Actions
+    include Helpers
+
+    desc "staging PROJECT_NAME", "SSH into staging server and cd into site root"
+
+    def staging( project_name )
+
+      settings = Swiftly::Project.settings( project_name )
+
+      verifiy_mina_credentials :staging, settings, 'ssh into the'
+
+      mina 'ssh', :staging, project_name
+
+    end
+
+    desc "production PROJECT_NAME", "SSH into production server and cd into site root"
+
+    def production( project_name )
+
+      settings = Swiftly::Project.settings( project_name )
+
+      verifiy_mina_credentials :production, settings, 'ssh into the'
+
+      mina 'ssh', :production, project_name
+
+    end
+
+  end
+end
+

data/lib/swiftly/templates/config_global.erb

@@ -0,0 +1,3 @@
+---
+:version: <%= @version %>
+:sites_path: <%= @sites_path %>

data/lib/swiftly/templates/config_project.erb

@@ -0,0 +1,11 @@
+---
+:staging:
+  :repo:
+  :branch:
+  :ssh_path:
+  :ssh_user:
+:production:
+  :repo:
+  :branch:
+  :ssh_path:
+  :ssh_user:

data/lib/swiftly/templates/gitignore.erb

@@ -0,0 +1,7 @@
+_backups
+_resources
+.DS_Store
+.sass-cache/
+_resources/
+.htaccess
+bower_components/

data/lib/swiftly/templates/post_type.erb

@@ -0,0 +1,98 @@
+<?php
+function create_<%= @project[:name][0..9] %>_<%= post_type_name.singularize %>_post_type() {
+  // Setup Custom Post Type
+  register_post_type(
+    '<%= @project[:name][0..9] %>-<%= post_type_name.pluralize %>',
+    array(
+      'labels'  => array(
+              'name'                   => _x( '<%= post_type_name.pluralize.capitalize %>', 'taxonomy general name' ),
+              'singular_name'          => _x( '<%= post_type_name.singularize.capitalize %>', 'taxonomy singular name' ),
+              'menu_name'              => __( '<%= post_type_name.pluralize.capitalize %>' ),
+              'all_items'              => __( 'All <%= post_type_name.pluralize.capitalize %>' ),
+              'add_new'                => __( 'Add New <%= post_type_name.singularize.capitalize %>' ),
+              'add_new_item'           => __( 'Add New <%= post_type_name.singularize.capitalize %>' ),
+              'edit_item'              => __( 'Edit <%= post_type_name.singularize.capitalize %>' ),
+              'new_item'               => __( 'New <%= post_type_name.singularize.capitalize %>' ),
+              'view_item'              => __( 'View <%= post_type_name.singularize.capitalize %>' ),
+              'search_items'           => __( 'Search <%= post_type_name.pluralize.capitalize %>' ),
+              'not_found'              => __( 'No <%= post_type_name.pluralize %> found.' ),
+              'not_found_in_trash'     => __( 'No <%= post_type_name.pluralize %> found in trash.' ),
+              'parent_item'            => null,
+      ),
+      'description'            => '',
+      'has_archive'            => true,
+      'public'                 => true,
+      //'show_ui'              => true,
+      //'show_in_menu'         => true,
+      //'capability_type'      => 'post',
+      'hierarchical'           => false,
+      // 'exclude_from_search' => false,
+      'supports'  => array(
+                'title',
+                'editor',
+                'author',
+                'excerpt',
+                'trackbacks',
+                'comments',
+                'revisions',
+                'page-attributes',
+                'thumbnail'
+      ),
+      'rewrite' => array(
+                'slug'  => '<%= post_type_name.pluralize %>'
+      )
+    )
+  );
+}
+add_action( 'init', 'create_<%= @project[:name][0..9] %>_<%= post_type_name.singularize %>_post_type' );
+
+function <%= post_type_name %>_type_init() {
+  // Setup Custom Taxonomy
+  register_taxonomy(
+    '<%= post_type_name.singularize %>-type',
+    array( '<%= @project[:name][0..9] %>-<%= post_type_name.pluralize %>' ),
+    array(
+      'labels'  => array(
+                'name'                       => _x( '<%= post_type_name.pluralize.capitalize %>', 'taxonomy general name' ),
+                'singular_name'              => _x( '<%= post_type_name.singularize.capitalize %>', 'taxonomy singular name' ),
+                'menu_name'                  => __( '<%= post_type_name.singularize.capitalize %> Types' ),
+                'all_items'                  => __( 'All <%= post_type_name.singularize.capitalize %> Types' ),
+                'edit_item'                  => __( 'Edit <%= post_type_name.singularize.capitalize %> Type' ),
+                'view_item'                  => __( 'View <%= post_type_name.singularize.capitalize %> Type' ),
+                'update_item'                => __( 'Update <%= post_type_name.singularize.capitalize %> Type' ),
+                'add_new_item'               => __( 'Add New <%= post_type_name.singularize.capitalize %> Type' ),
+                'parent_item'                => null,
+                'parent_item_colon'          => null,
+                'search_items'               => __( 'Search <%= post_type_name.pluralize.capitalize %> Types' ),
+                'popular_items'              => __( 'Popular <%= post_type_name.pluralize.capitalize %> Types' ),
+                'separate_items_with_commas' => __( 'Separate <%= post_type_name.pluralize.capitalize %> Types with commas' ),
+                'add_or_remove_items'        => __( 'Add or remove <%= post_type_name.singularize %> Types' ),
+                'choose_from_most_used'      => __( 'Choose from the most used <%= post_type_name.singularize %> Types' ),
+                'not_found'                  => __( 'No <%= post_type_name.pluralize.capitalize %> Types found.' ),
+      ),
+      'hierarchical'               => true,
+      'show_ui'                    => true,
+      'query_var'                  => true,
+      'rewrite' => array(
+                'slug'            => '<%= post_type_name.singularize %>-type',
+                // 'hierarchical' => true
+      )
+    )
+  );
+}
+add_action( 'init', '<%= post_type_name.singularize %>_type_init' );
+
+// remove_post_type_support('<%= @project[:name][0..9] %>-<%= post_type_name.pluralize %>', '');
+
+function <%= post_type_name.pluralize %>_add_rewrite_rules($aRules) {
+  $aNewRules = array('<%= post_type_name.singularize %>-type/([^/]*)/?$' => 'index.php?<%= post_type_name.singularize %>-type=$matches[1]');
+  $aNewRules2  = array('<%= post_type_name.pluralize %>/<%= @filter_regexp %>' => 'index.php?post_type=<%= @project[:name] %>-<%= post_type_name.pluralize %><%= @filter %>');
+  $aNewRules1 = array('<%= post_type_name.singularize %>-type/([^/]*)/<%= @filter_regexp %>' => 'index.php?<%= post_type_name.singularize %>-type<%= @taxonomy_filter %>');
+  $aRules     = $aNewRules + $aNewRules1 + $aNewRules2 + $aRules;
+  return $aRules;
+}
+
+// hook add_rewrite_rules function into rewrite_rules_array
+add_filter('rewrite_rules_array', '<%= post_type_name.pluralize %>_add_rewrite_rules');
+
+?>

data/lib/swiftly/templates/swiftlyfile.erb

@@ -0,0 +1,21 @@
+---
+:local:
+  :db_host: "<%= @db_host %>"
+  :db_user: "<%= @db_user %>"
+  :db_pass: "<%= @db_pass %>"
+:staging:
+  :domain:
+  :db_host:
+:production:
+  :domain:
+  :db_host:
+:packages:
+  :wordpress:
+    :template:
+    - :name: mask
+      :location: https://github.com/micalexander/mask/archive/master.zip
+      :status: :disabled
+    :plugins:
+    - :name: advanced-custom-fields-pro
+      :location: "/Users/username/plugins"
+      :status: :disabled

data/lib/swiftly/version.rb

@@ -0,0 +1,4 @@
+module Swiftly
+  APP_NAME = 'swiftly'
+  VERSION  = '4.0.0'
+end